Java > Open Source Codes > org > snmp4j > agent > mo > snmp4j > Snmp4jLogMib


1 /*_############################################################################
2   _##
3   _## SNMP4J-Agent - Snmp4jLogMib.java
4   _##
5   _## Copyright (C) 2005-2007 Frank Fock (SNMP4J.org)
6   _##
7   _## Licensed under the Apache License, Version 2.0 (the "License");
8   _## you may not use this file except in compliance with the License.
9   _## You may obtain a copy of the License at
10   _##
11   _## http://www.apache.org/licenses/LICENSE-2.0
12   _##
13   _## Unless required by applicable law or agreed to in writing, software
14   _## distributed under the License is distributed on an "AS IS" BASIS,
15   _## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   _## See the License for the specific language governing permissions and
17   _## limitations under the License.
18   _##
19   _##########################################################################*/
20
21
22 package org.snmp4j.agent.mo.snmp4j;
23
24 //--AgentGen BEGIN=_BEGIN
25 //--AgentGen END
26
27 import org.snmp4j.smi.*;
28 import org.snmp4j.mp.SnmpConstants;
29 import org.snmp4j.agent.*;
30 import org.snmp4j.agent.mo.*;
31 import org.snmp4j.agent.mo.snmp.*;
32 import org.snmp4j.agent.request.*;
33 import org.snmp4j.log.LogFactory;
34 import org.snmp4j.log.LogAdapter;
35 import org.snmp4j.log.LogLevel;
36
37 //--AgentGen BEGIN=_IMPORT
38 import java.util.Iterator ;
39 import java.util.HashMap ;
40 import java.util.Map ;
41 import java.util.WeakHashMap ;
42 import org.snmp4j.agent.io.MOInput;
43 import java.io.IOException ;
44
45 //--AgentGen END
46
47 public class Snmp4jLogMib
48 //--AgentGen BEGIN=_EXTENDS
49 //--AgentGen END
50 implements MOGroup
51 //--AgentGen BEGIN=_IMPLEMENTS
52 ,MOServerLookupListener
53     ,MOTableRowListener
54     ,RowStatusListener
55 //--AgentGen END
56 {
57
58   private static final LogAdapter LOGGER =
59       LogFactory.getLogger(Snmp4jLogMib.class);
60
61 //--AgentGen BEGIN=_STATIC
62 private static final MOTableRowFilter NOT_ACTIVE_ROW_FILTER =
63       new MOTableRowFilter() {
64     public boolean passesFilter(MOTableRow row) {
65       if (row instanceof Snmp4jLogLoggerRow) {
66         Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow)row;
67         if (r.getSnmp4jLogLoggerRowStatus().getValue() == RowStatus.active) {
68           return true;
69         }
70       }
71       return false;
72     }
73
74   };
75 //--AgentGen END
76
77   // Factory
78 private static MOFactory moFactory = DefaultMOFactory.getInstance();
79
80   // Constants
81 private static final OID oidSnmp4jLogSysDescr =
82     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,1,1,0 });
83   private static final OID oidSnmp4jLogFactory =
84     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,1,2,0 });
85   private static final OID oidSnmp4jLogRootLevel =
86     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,1,0 });
87
88   // Scalars
89 private MOScalar snmp4jLogSysDescr;
90   private MOScalar snmp4jLogFactory;
91   private MOScalar snmp4jLogRootLevel;
92
93   // Tables
94 private static final OID oidSnmp4jLogLoggerEntry =
95     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,2,1 });
96
97   // Column sub-identifer defintions for snmp4jLogLoggerEntry:
98 private static final int colSnmp4jLogLoggerIndex = 2;
99   private static final int colSnmp4jLogLoggerLevel = 3;
100   private static final int colSnmp4jLogLoggerEffectiveLevel = 4;
101   private static final int colSnmp4jLogLoggerStorageType = 5;
102   private static final int colSnmp4jLogLoggerRowStatus = 6;
103
104   // Column index defintions for snmp4jLogLoggerEntry:
105 private static final int idxSnmp4jLogLoggerIndex = 0;
106   private static final int idxSnmp4jLogLoggerLevel = 1;
107   private static final int idxSnmp4jLogLoggerEffectiveLevel = 2;
108   private static final int idxSnmp4jLogLoggerStorageType = 3;
109   private static final int idxSnmp4jLogLoggerRowStatus = 4;
110   private static MOTableSubIndex[] snmp4jLogLoggerEntryIndexes =
111     new MOTableSubIndex[] {
112         moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 127)
113   };
114
115   private static MOTableIndex snmp4jLogLoggerEntryIndex =
116       moFactory.createIndex(snmp4jLogLoggerEntryIndexes,
117                             true,
118                             new MOTableIndexValidator() {
119     public boolean isValidIndex(OID index) {
120       boolean isValidIndex = true;
121      //--AgentGen BEGIN=snmp4jLogLoggerEntry::isValidIndex
122 //--AgentGen END
123 return isValidIndex;
124     }
125   });
126
127
128   private MOTable snmp4jLogLoggerEntry;
129   private MOMutableTableModel snmp4jLogLoggerEntryModel;
130   private static final OID oidSnmp4jLogLoggerToHandlerEntry =
131     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,3,1 });
132
133   // Column sub-identifer defintions for snmp4jLogLoggerToHandlerEntry:
134 private static final int colSnmp4jLogLoggerToHandlerThreshold = 1;
135   private static final int colSnmp4jLogLoggerToHandlerStorageType = 2;
136   private static final int colSnmp4jLogLoggerToHandlerRowStatus = 3;
137
138   // Column index defintions for snmp4jLogLoggerToHandlerEntry:
139 private static final int idxSnmp4jLogLoggerToHandlerThreshold = 0;
140   private static final int idxSnmp4jLogLoggerToHandlerStorageType = 1;
141   private static final int idxSnmp4jLogLoggerToHandlerRowStatus = 2;
142   private static MOTableSubIndex[] snmp4jLogLoggerToHandlerEntryIndexes =
143     new MOTableSubIndex[] {
144         moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1),
145         moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
146   };
147
148   private static MOTableIndex snmp4jLogLoggerToHandlerEntryIndex =
149       moFactory.createIndex(snmp4jLogLoggerToHandlerEntryIndexes,
150                             false);
151
152
153   private MOTable snmp4jLogLoggerToHandlerEntry;
154   private MOMutableTableModel snmp4jLogLoggerToHandlerEntryModel;
155   private static final OID oidSnmp4jLogHandlerEntry =
156     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,2,1 });
157
158   // Column sub-identifer defintions for snmp4jLogHandlerEntry:
159 private static final int colSnmp4jLogHandlerType = 2;
160   private static final int colSnmp4jLogHandlerStorageType = 3;
161   private static final int colSnmp4jLogHandlerRowStatus = 4;
162
163   // Column index defintions for snmp4jLogHandlerEntry:
164 private static final int idxSnmp4jLogHandlerType = 0;
165   private static final int idxSnmp4jLogHandlerStorageType = 1;
166   private static final int idxSnmp4jLogHandlerRowStatus = 2;
167   private static MOTableSubIndex[] snmp4jLogHandlerEntryIndexes =
168     new MOTableSubIndex[] {
169         moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
170   };
171
172   private static MOTableIndex snmp4jLogHandlerEntryIndex =
173       moFactory.createIndex(snmp4jLogHandlerEntryIndexes,
174                             false);
175
176
177   private MOTable snmp4jLogHandlerEntry;
178   private MOMutableTableModel snmp4jLogHandlerEntryModel;
179   private static final OID oidSnmp4jLogFileHandlerEntry =
180     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,3,1,1 });
181
182   // Column sub-identifer defintions for snmp4jLogFileHandlerEntry:
183 private static final int colSnmp4jLogFileHandlerPath = 1;
184   private static final int colSnmp4jLogFileHandlerAppend = 2;
185   private static final int colSnmp4jLogFileHandlerBufferedIO = 3;
186   private static final int colSnmp4jLogFileHandlerBufferSize = 4;
187
188   // Column index defintions for snmp4jLogFileHandlerEntry:
189 private static final int idxSnmp4jLogFileHandlerPath = 0;
190   private static final int idxSnmp4jLogFileHandlerAppend = 1;
191   private static final int idxSnmp4jLogFileHandlerBufferedIO = 2;
192   private static final int idxSnmp4jLogFileHandlerBufferSize = 3;
193   private static MOTableSubIndex[] snmp4jLogFileHandlerEntryIndexes =
194     new MOTableSubIndex[] {
195         moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 255)
196   };
197
198   private static MOTableIndex snmp4jLogFileHandlerEntryIndex =
199       moFactory.createIndex(snmp4jLogFileHandlerEntryIndexes,
200                             false);
201
202
203   private MOTable snmp4jLogFileHandlerEntry;
204   private MOMutableTableModel snmp4jLogFileHandlerEntryModel;
205   private static final OID oidSnmp4jLogConsoleHandlerEntry =
206     new OID(new int[] { 1,3,6,1,4,1,4976,10,1,1,1,1,2,5,3,2,1 });
207
208   // Column sub-identifer defintions for snmp4jLogConsoleHandlerEntry:
209 private static final int colSnmp4jLogConsoleHandlerTarget = 1;
210
211   // Column index defintions for snmp4jLogConsoleHandlerEntry:
212 private static final int idxSnmp4jLogConsoleHandlerTarget = 0;
213   private static MOTableSubIndex[] snmp4jLogConsoleHandlerEntryIndexes =
214     new MOTableSubIndex[] {
215         moFactory.createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 0, 127)
216   };
217
218   private static MOTableIndex snmp4jLogConsoleHandlerEntryIndex =
219       moFactory.createIndex(snmp4jLogConsoleHandlerEntryIndexes,
220                             false);
221
222
223   private MOTable snmp4jLogConsoleHandlerEntry;
224   private MOMutableTableModel snmp4jLogConsoleHandlerEntryModel;
225
226
227   //--AgentGen BEGIN=_MEMBERS
228 private Map loggers = new HashMap ();
229   private Map loggerNames2Index = new WeakHashMap ();
230   private int nextLoggerIndex = 1;
231   private Object lastLoggerUpdateSource;
232   //--AgentGen END
233
234   public Snmp4jLogMib() {
235     snmp4jLogSysDescr =
236       moFactory.createScalar(oidSnmp4jLogSysDescr,
237                              MOAccessImpl.ACCESS_READ_ONLY, new OctetString());
238     snmp4jLogFactory =
239       moFactory.createScalar(oidSnmp4jLogFactory,
240                              MOAccessImpl.ACCESS_READ_ONLY, new OctetString());
241     snmp4jLogRootLevel =
242       new Snmp4jLogRootLevel(oidSnmp4jLogRootLevel, MOAccessImpl.ACCESS_READ_WRITE);
243     snmp4jLogRootLevel.addMOValueValidationListener(new Snmp4jLogLevelValidator());
244     createSnmp4jLogLoggerEntry();
245     createSnmp4jLogLoggerToHandlerEntry();
246     createSnmp4jLogHandlerEntry();
247     createSnmp4jLogFileHandlerEntry();
248     createSnmp4jLogConsoleHandlerEntry();
249 //--AgentGen BEGIN=_DEFAULTCONSTRUCTOR
250 //--AgentGen END
251 }
252
253
254   public MOTable getSnmp4jLogLoggerEntry() {
255     return snmp4jLogLoggerEntry;
256   }
257
258
259   private void createSnmp4jLogLoggerEntry() {
260     MOColumn[] snmp4jLogLoggerEntryColumns = new MOColumn[5];
261     snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerIndex] =
262       new MOColumn(colSnmp4jLogLoggerIndex,
263                    SMIConstants.SYNTAX_INTEGER32,
264                    MOAccessImpl.ACCESS_READ_ONLY);
265     snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerLevel] =
266       new MOMutableColumn(colSnmp4jLogLoggerLevel,
267                           SMIConstants.SYNTAX_INTEGER,
268                           MOAccessImpl.ACCESS_READ_CREATE,
269                           new Integer32(1),
270                           true);
271     ((MOMutableColumn)snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerLevel]).
272       addMOValueValidationListener(new Snmp4jLogLevelValidator());
273     snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerEffectiveLevel] =
274       new MOColumn(colSnmp4jLogLoggerEffectiveLevel,
275                    SMIConstants.SYNTAX_INTEGER,
276                    MOAccessImpl.ACCESS_READ_ONLY);
277     snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerStorageType] =
278       new StorageType(colSnmp4jLogLoggerStorageType,
279                       MOAccessImpl.ACCESS_READ_CREATE,
280                       new Integer32(2),
281                       true);
282     snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerRowStatus] =
283       new RowStatus(colSnmp4jLogLoggerRowStatus);
284
285     snmp4jLogLoggerEntryModel = new DefaultMOMutableTableModel();
286     snmp4jLogLoggerEntryModel.setRowFactory(new Snmp4jLogLoggerEntryRowFactory());
287     snmp4jLogLoggerEntry =
288       moFactory.createTable(oidSnmp4jLogLoggerEntry,
289                          snmp4jLogLoggerEntryIndex,
290                             snmp4jLogLoggerEntryColumns,
291                             snmp4jLogLoggerEntryModel);
292     ((RowStatus)snmp4jLogLoggerEntryColumns[idxSnmp4jLogLoggerRowStatus]).
293         addRowStatusListener(this);
294     snmp4jLogLoggerEntry.addMOTableRowListener(this);
295     // Not needed any more (since 1.1):
296 // updateLoggerTable();
297 }
298
299   public MOTable getSnmp4jLogLoggerToHandlerEntry() {
300     return snmp4jLogLoggerToHandlerEntry;
301   }
302
303
304   private void createSnmp4jLogLoggerToHandlerEntry() {
305     MOColumn[] snmp4jLogLoggerToHandlerEntryColumns = new MOColumn[3];
306     snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerThreshold] =
307       new MOMutableColumn(colSnmp4jLogLoggerToHandlerThreshold,
308                           SMIConstants.SYNTAX_INTEGER,
309                           MOAccessImpl.ACCESS_READ_CREATE,
310                           new Integer32(2),
311                           true);
312     ((MOMutableColumn)snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerThreshold]).
313       addMOValueValidationListener(new Snmp4jLogLevelValidator());
314     snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerStorageType] =
315       new StorageType(colSnmp4jLogLoggerToHandlerStorageType,
316                       MOAccessImpl.ACCESS_READ_CREATE,
317                       new Integer32(2),
318                       true);
319     snmp4jLogLoggerToHandlerEntryColumns[idxSnmp4jLogLoggerToHandlerRowStatus] =
320       new RowStatus(colSnmp4jLogLoggerToHandlerRowStatus);
321
322     snmp4jLogLoggerToHandlerEntryModel = new DefaultMOMutableTableModel();
323     snmp4jLogLoggerToHandlerEntryModel.setRowFactory(new Snmp4jLogLoggerToHandlerEntryRowFactory());
324     snmp4jLogLoggerToHandlerEntry =
325       moFactory.createTable(oidSnmp4jLogLoggerToHandlerEntry,
326                          snmp4jLogLoggerToHandlerEntryIndex,
327                             snmp4jLogLoggerToHandlerEntryColumns,
328                             snmp4jLogLoggerToHandlerEntryModel);
329   }
330
331   public MOTable getSnmp4jLogHandlerEntry() {
332     return snmp4jLogHandlerEntry;
333   }
334
335   private void createSnmp4jLogHandlerEntry() {
336     MOColumn[] snmp4jLogHandlerEntryColumns = new MOColumn[3];
337     snmp4jLogHandlerEntryColumns[idxSnmp4jLogHandlerType] =
338       new MOMutableColumn(colSnmp4jLogHandlerType,
339                           SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
340                           MOAccessImpl.ACCESS_READ_CREATE,
341                           new OID("1.3.6.1.4.1.4976.10.1.1.1.1.2.5.1.2.1"),
342                           true);
343     ((MOMutableColumn)snmp4jLogHandlerEntryColumns[idxSnmp4jLogHandlerType]).
344       addMOValueValidationListener(new Snmp4jLogHandlerTypeValidator());
345     snmp4jLogHandlerEntryColumns[idxSnmp4jLogHandlerStorageType] =
346       new StorageType(colSnmp4jLogHandlerStorageType,
347                       MOAccessImpl.ACCESS_READ_CREATE,
348                       null,
349                       true);
350     snmp4jLogHandlerEntryColumns[idxSnmp4jLogHandlerRowStatus] =
351       new RowStatus(colSnmp4jLogHandlerRowStatus);
352
353     snmp4jLogHandlerEntryModel = new DefaultMOMutableTableModel();
354     snmp4jLogHandlerEntryModel.setRowFactory(new Snmp4jLogHandlerEntryRowFactory());
355     snmp4jLogHandlerEntry =
356       moFactory.createTable(oidSnmp4jLogHandlerEntry,
357                          snmp4jLogHandlerEntryIndex,
358                             snmp4jLogHandlerEntryColumns,
359                             snmp4jLogHandlerEntryModel);
360   }
361
362   public MOTable getSnmp4jLogFileHandlerEntry() {
363     return snmp4jLogFileHandlerEntry;
364   }
365
366   private void createSnmp4jLogFileHandlerEntry() {
367     MOColumn[] snmp4jLogFileHandlerEntryColumns = new MOColumn[4];
368     snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerPath] =
369       new MOMutableColumn(colSnmp4jLogFileHandlerPath,
370                           SMIConstants.SYNTAX_OCTET_STRING,
371                           MOAccessImpl.ACCESS_READ_CREATE,
372                           new OctetString(new byte[] { (byte)115,(byte)110,(byte)109,(byte)112,(byte)52,(byte)106,(byte)46,(byte)108,(byte)111,(byte)103 }),
373                           true);
374     ((MOMutableColumn)snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerPath]).
375       addMOValueValidationListener(new Snmp4jLogFileHandlerPathValidator());
376     snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerAppend] =
377       new MOMutableColumn(colSnmp4jLogFileHandlerAppend,
378                           SMIConstants.SYNTAX_INTEGER,
379                           MOAccessImpl.ACCESS_READ_CREATE,
380                           new Integer32(1),
381                           true);
382     ((MOMutableColumn)snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerAppend]).
383       addMOValueValidationListener(new Snmp4jLogFileHandlerAppendValidator());
384     snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerBufferedIO] =
385       new MOMutableColumn(colSnmp4jLogFileHandlerBufferedIO,
386                           SMIConstants.SYNTAX_INTEGER,
387                           MOAccessImpl.ACCESS_READ_CREATE,
388                           new Integer32(1),
389                           true);
390     ((MOMutableColumn)snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerBufferedIO]).
391       addMOValueValidationListener(new Snmp4jLogFileHandlerBufferedIOValidator());
392     snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerBufferSize] =
393       new MOMutableColumn(colSnmp4jLogFileHandlerBufferSize,
394                           SMIConstants.SYNTAX_GAUGE32,
395                           MOAccessImpl.ACCESS_READ_CREATE,
396                           new UnsignedInteger32(16535),
397                           true);
398     ((MOMutableColumn)snmp4jLogFileHandlerEntryColumns[idxSnmp4jLogFileHandlerBufferSize]).
399       addMOValueValidationListener(new Snmp4jLogFileHandlerBufferSizeValidator());
400
401     snmp4jLogFileHandlerEntryModel = new DefaultMOMutableTableModel();
402     snmp4jLogFileHandlerEntryModel.setRowFactory(new Snmp4jLogFileHandlerEntryRowFactory());
403     snmp4jLogFileHandlerEntry =
404       moFactory.createTable(oidSnmp4jLogFileHandlerEntry,
405                          snmp4jLogFileHandlerEntryIndex,
406                             snmp4jLogFileHandlerEntryColumns,
407                             snmp4jLogFileHandlerEntryModel);
408   }
409
410   public MOTable getSnmp4jLogConsoleHandlerEntry() {
411     return snmp4jLogConsoleHandlerEntry;
412   }
413
414   private void createSnmp4jLogConsoleHandlerEntry() {
415     MOColumn[] snmp4jLogConsoleHandlerEntryColumns = new MOColumn[1];
416     snmp4jLogConsoleHandlerEntryColumns[idxSnmp4jLogConsoleHandlerTarget] =
417       new Enumerated(colSnmp4jLogConsoleHandlerTarget,
418                      MOAccessImpl.ACCESS_READ_CREATE,
419                      new Integer32(1),
420                      true,
421                      new int[] { Snmp4jLogConsoleHandlerTargetEnum.systemOut,
422                                  Snmp4jLogConsoleHandlerTargetEnum.systemErr });
423     ((MOMutableColumn)snmp4jLogConsoleHandlerEntryColumns[idxSnmp4jLogConsoleHandlerTarget]).
424       addMOValueValidationListener(new Snmp4jLogConsoleHandlerTargetValidator());
425
426     snmp4jLogConsoleHandlerEntryModel = new DefaultMOMutableTableModel();
427     snmp4jLogConsoleHandlerEntryModel.setRowFactory(new Snmp4jLogConsoleHandlerEntryRowFactory());
428     snmp4jLogConsoleHandlerEntry =
429       moFactory.createTable(oidSnmp4jLogConsoleHandlerEntry,
430                          snmp4jLogConsoleHandlerEntryIndex,
431                             snmp4jLogConsoleHandlerEntryColumns,
432                             snmp4jLogConsoleHandlerEntryModel);
433   }
434
435
436   public void registerMOs(MOServer server, OctetString context)
437     throws DuplicateRegistrationException
438   {
439     // Scalar Objects
440 server.register(this.snmp4jLogSysDescr, context);
441     server.register(this.snmp4jLogFactory, context);
442     server.register(this.snmp4jLogRootLevel, context);
443     server.register(this.snmp4jLogLoggerEntry, context);
444     /**@todo implement other tables
445     server.register(this.snmp4jLogLoggerToHandlerEntry, context);
446     server.register(this.snmp4jLogHandlerEntry, context);
447     server.register(this.snmp4jLogFileHandlerEntry, context);
448     server.register(this.snmp4jLogConsoleHandlerEntry, context);
449     */
450     //--AgentGen BEGIN=_registerMOs
451 server.addLookupListener(this, this.snmp4jLogSysDescr);
452     server.addLookupListener(this, this.snmp4jLogLoggerEntry);
453     //--AgentGen END
454 }
455
456   public void unregisterMOs(MOServer server, OctetString context) {
457     // Scalar Objects
458 server.unregister(this.snmp4jLogSysDescr, context);
459     server.unregister(this.snmp4jLogFactory, context);
460     server.unregister(this.snmp4jLogRootLevel, context);
461     server.unregister(this.snmp4jLogLoggerEntry, context);
462     server.unregister(this.snmp4jLogLoggerToHandlerEntry, context);
463     server.unregister(this.snmp4jLogHandlerEntry, context);
464     server.unregister(this.snmp4jLogFileHandlerEntry, context);
465     server.unregister(this.snmp4jLogConsoleHandlerEntry, context);
466     //--AgentGen BEGIN=_unregisterMOs
467 server.removeLookupListener(this, this.snmp4jLogSysDescr);
468     server.removeLookupListener(this, this.snmp4jLogLoggerEntry);
469     //--AgentGen END
470 }
471
472   // Notifications
473
474   // Scalars
475 class Snmp4jLogRootLevel extends MOScalar {
476     Snmp4jLogRootLevel(OID oid, MOAccess access) {
477       super(oid, access, new Integer32());
478     }
479
480     public void commit(SubRequest request) {
481      //--AgentGen BEGIN=snmp4jLogRootLevel::commit
482 Variable vb = request.getVariableBinding().getVariable();
483      int v = ((Integer32)vb).getValue();
484      LogAdapter logAdapter = LogFactory.getLogFactory().getRootLogger();
485      logAdapter.setLogLevel(new LogLevel(v));
486      //--AgentGen END
487 super.commit(request);
488     }
489
490     public void load(MOInput input) throws IOException {
491       super.load(input);
492       int v = ((Integer32)getValue()).getValue();
493       LogAdapter logAdapter = LogFactory.getLogFactory().getRootLogger();
494       if (v != LogLevel.LEVEL_NONE) {
495         logAdapter.setLogLevel(new LogLevel(v));
496       }
497     }
498
499   }
500
501
502   // Value Validators
503 /**
504    * The <code>Snmp4jLogRootLevelValidator</code> implements the value
505    * validation for <code>Snmp4jLogRootLevel</code>.
506    */
507   static class Snmp4jLogLevelValidator implements MOValueValidationListener {
508
509     public void validate(MOValueValidationEvent validationEvent) {
510       Variable newValue = validationEvent.getNewValue();
511      //--AgentGen BEGIN=snmp4jLogRootLevel::validate
512 int v = ((Integer32)newValue ).getValue();
513      if ((v < 1) || (v > 8)) {
514        validationEvent.setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_VALUE);
515      }
516      //--AgentGen END
517 }
518   }
519
520   /**
521    * The <code>Snmp4jLogHandlerTypeValidator</code> implements the value
522    * validation for <code>Snmp4jLogHandlerType</code>.
523    */
524   static class Snmp4jLogHandlerTypeValidator implements MOValueValidationListener {
525
526     public void validate(MOValueValidationEvent validationEvent) {
527       Variable newValue = validationEvent.getNewValue();
528      //--AgentGen BEGIN=snmp4jLogHandlerType::validate
529 //--AgentGen END
530 }
531   }
532   /**
533    * The <code>Snmp4jLogFileHandlerPathValidator</code> implements the value
534    * validation for <code>Snmp4jLogFileHandlerPath</code>.
535    */
536   static class Snmp4jLogFileHandlerPathValidator implements MOValueValidationListener {
537
538     public void validate(MOValueValidationEvent validationEvent) {
539       Variable newValue = validationEvent.getNewValue();
540       OctetString os = (OctetString)newValue;
541       if (!(((os.length() >= 1) && (os.length() <= 512)))) {
542         validationEvent.setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_LENGTH);
543         return;
544       }
545      //--AgentGen BEGIN=snmp4jLogFileHandlerPath::validate
546 //--AgentGen END
547 }
548   }
549   /**
550    * The <code>Snmp4jLogFileHandlerAppendValidator</code> implements the value
551    * validation for <code>Snmp4jLogFileHandlerAppend</code>.
552    */
553   static class Snmp4jLogFileHandlerAppendValidator implements MOValueValidationListener {
554
555     public void validate(MOValueValidationEvent validationEvent) {
556       Variable newValue = validationEvent.getNewValue();
557      //--AgentGen BEGIN=snmp4jLogFileHandlerAppend::validate
558 //--AgentGen END
559 }
560   }
561   /**
562    * The <code>Snmp4jLogFileHandlerBufferedIOValidator</code> implements the value
563    * validation for <code>Snmp4jLogFileHandlerBufferedIO</code>.
564    */
565   static class Snmp4jLogFileHandlerBufferedIOValidator implements MOValueValidationListener {
566
567     public void validate(MOValueValidationEvent validationEvent) {
568       Variable newValue = validationEvent.getNewValue();
569      //--AgentGen BEGIN=snmp4jLogFileHandlerBufferedIO::validate
570 //--AgentGen END
571 }
572   }
573   /**
574    * The <code>Snmp4jLogFileHandlerBufferSizeValidator</code> implements the value
575    * validation for <code>Snmp4jLogFileHandlerBufferSize</code>.
576    */
577   static class Snmp4jLogFileHandlerBufferSizeValidator implements MOValueValidationListener {
578
579     public void validate(MOValueValidationEvent validationEvent) {
580       Variable newValue = validationEvent.getNewValue();
581      //--AgentGen BEGIN=snmp4jLogFileHandlerBufferSize::validate
582 //--AgentGen END
583 }
584   }
585   /**
586    * The <code>Snmp4jLogConsoleHandlerTargetValidator</code> implements the value
587    * validation for <code>Snmp4jLogConsoleHandlerTarget</code>.
588    */
589   static class Snmp4jLogConsoleHandlerTargetValidator implements MOValueValidationListener {
590
591     public void validate(MOValueValidationEvent validationEvent) {
592       Variable newValue = validationEvent.getNewValue();
593      //--AgentGen BEGIN=snmp4jLogConsoleHandlerTarget::validate
594 //--AgentGen END
595 }
596   }
597
598   public static final class Snmp4jLogLoggerToHandlerThresholdEnum {
599     /* -- no level has been specified */
600     public static final int notSpecified = 0;
601     public static final int off = 1;
602     public static final int all = 2;
603     public static final int trace = 3;
604     public static final int debug = 4;
605     public static final int info = 5;
606     public static final int warn = 6;
607     public static final int error = 7;
608     public static final int fatal = 8;
609   }
610   public static final class Snmp4jLogFileHandlerAppendEnum {
611     public static final int _true = 1;
612     public static final int _false = 2;
613   }
614   public static final class Snmp4jLogFileHandlerBufferedIOEnum {
615     public static final int _true = 1;
616     public static final int _false = 2;
617   }
618   public static final class Snmp4jLogConsoleHandlerTargetEnum {
619     public static final int systemOut = 1;
620     public static final int systemErr = 2;
621   }
622
623   // Rows and Factories
624 class Snmp4jLogLoggerEntryRowFactory
625         extends DefaultMOMutableRow2PCFactory
626   {
627     public Snmp4jLogLoggerEntryRowFactory() {}
628
629     public MOTableRow createRow(OID index, Variable[] values)
630         throws UnsupportedOperationException
631     {
632 // Snmp4jLogLoggerEntryRow row = new Snmp4jLogLoggerEntryRow(index, values);
633 //--AgentGen BEGIN=snmp4jLogLoggerEntry::createRow
634 int i = nextLoggerIndex++;
635       Snmp4jLogLoggerEntryRow row =
636           new Snmp4jLogLoggerRow(index, values, i, null);
637       row.setSnmp4jLogLoggerIndex(new Integer32(i));
638       loggerNames2Index.put(new OctetString(index.toByteArray()).toString(),
639                             new Integer (i));
640       //--AgentGen END
641 return row;
642     }
643
644     public void freeRow(MOTableRow row) {
645      //--AgentGen BEGIN=snmp4jLogLoggerEntry::freeRow
646 //--AgentGen END
647 }
648   }
649
650   class Snmp4jLogLoggerEntryRow extends DefaultMOMutableRow2PC {
651     public Snmp4jLogLoggerEntryRow(OID index, Variable[] values) {
652       super(index, values);
653     }
654
655     public Integer32 getSnmp4jLogLoggerIndex() {
656       return (Integer32) getValue(idxSnmp4jLogLoggerIndex);
657     }
658
659     public void setSnmp4jLogLoggerIndex(Integer32 newValue) {
660       setValue(idxSnmp4jLogLoggerIndex, newValue);
661     }
662
663     public Integer32 getSnmp4jLogLoggerLevel() {
664       return (Integer32) getValue(idxSnmp4jLogLoggerLevel);
665     }
666
667     public void setSnmp4jLogLoggerLevel(Integer32 newValue) {
668       setValue(idxSnmp4jLogLoggerLevel, newValue);
669     }
670
671     public Integer32 getSnmp4jLogLoggerEffectiveLevel() {
672       return (Integer32) getValue(idxSnmp4jLogLoggerEffectiveLevel);
673     }
674
675     public void setSnmp4jLogLoggerEffectiveLevel(Integer32 newValue) {
676       setValue(idxSnmp4jLogLoggerEffectiveLevel, newValue);
677     }
678
679     public Integer32 getSnmp4jLogLoggerStorageType() {
680       return (Integer32) getValue(idxSnmp4jLogLoggerStorageType);
681     }
682
683     public void setSnmp4jLogLoggerStorageType(Integer32 newValue) {
684       setValue(idxSnmp4jLogLoggerStorageType, newValue);
685     }
686
687     public Integer32 getSnmp4jLogLoggerRowStatus() {
688       return (Integer32) getValue(idxSnmp4jLogLoggerRowStatus);
689     }
690
691     public void setSnmp4jLogLoggerRowStatus(Integer32 newValue) {
692       setValue(idxSnmp4jLogLoggerRowStatus, newValue);
693     }
694
695
696      //--AgentGen BEGIN=snmp4jLogLoggerEntry::RowFactory
697 //--AgentGen END
698 }
699
700   class Snmp4jLogLoggerToHandlerEntryRowFactory
701         extends DefaultMOMutableRow2PCFactory
702   {
703     public MOTableRow createRow(OID index, Variable[] values)
704         throws UnsupportedOperationException
705     {
706       Snmp4jLogLoggerToHandlerEntryRow row = new Snmp4jLogLoggerToHandlerEntryRow(index, values);
707      //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::createRow
708 //--AgentGen END
709 return row;
710     }
711
712     public void freeRow(MOTableRow row) {
713      //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::freeRow
714 //--AgentGen END
715 }
716   }
717
718   class Snmp4jLogLoggerToHandlerEntryRow extends DefaultMOMutableRow2PC {
719     public Snmp4jLogLoggerToHandlerEntryRow(OID index, Variable[] values) {
720       super(index, values);
721     }
722
723     public Integer32 getSnmp4jLogLoggerToHandlerThreshold() {
724       return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerThreshold);
725     }
726
727     public void setSnmp4jLogLoggerToHandlerThreshold(Integer32 newValue) {
728       setValue(idxSnmp4jLogLoggerToHandlerThreshold, newValue);
729     }
730
731     public Integer32 getSnmp4jLogLoggerToHandlerStorageType() {
732       return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerStorageType);
733     }
734
735     public void setSnmp4jLogLoggerToHandlerStorageType(Integer32 newValue) {
736       setValue(idxSnmp4jLogLoggerToHandlerStorageType, newValue);
737     }
738
739     public Integer32 getSnmp4jLogLoggerToHandlerRowStatus() {
740       return (Integer32) getValue(idxSnmp4jLogLoggerToHandlerRowStatus);
741     }
742
743     public void setSnmp4jLogLoggerToHandlerRowStatus(Integer32 newValue) {
744       setValue(idxSnmp4jLogLoggerToHandlerRowStatus, newValue);
745     }
746
747
748      //--AgentGen BEGIN=snmp4jLogLoggerToHandlerEntry::RowFactory
749 //--AgentGen END
750 }
751
752   class Snmp4jLogHandlerEntryRowFactory
753         extends DefaultMOMutableRow2PCFactory
754   {
755     public MOTableRow createRow(OID index, Variable[] values)
756         throws UnsupportedOperationException
757     {
758       Snmp4jLogHandlerEntryRow row = new Snmp4jLogHandlerEntryRow(index, values);
759      //--AgentGen BEGIN=snmp4jLogHandlerEntry::createRow
760 //--AgentGen END
761 return row;
762     }
763
764     public void freeRow(MOTableRow row) {
765      //--AgentGen BEGIN=snmp4jLogHandlerEntry::freeRow
766 //--AgentGen END
767 }
768   }
769
770   class Snmp4jLogHandlerEntryRow extends DefaultMOMutableRow2PC {
771     public Snmp4jLogHandlerEntryRow(OID index, Variable[] values) {
772       super(index, values);
773     }
774
775     public OID getSnmp4jLogHandlerType() {
776       return (OID) getValue(idxSnmp4jLogHandlerType);
777     }
778
779     public void setSnmp4jLogHandlerType(OID newValue) {
780       setValue(idxSnmp4jLogHandlerType, newValue);
781     }
782
783     public Integer32 getSnmp4jLogHandlerStorageType() {
784       return (Integer32) getValue(idxSnmp4jLogHandlerStorageType);
785     }
786
787     public void setSnmp4jLogHandlerStorageType(Integer32 newValue) {
788       setValue(idxSnmp4jLogHandlerStorageType, newValue);
789     }
790
791     public Integer32 getSnmp4jLogHandlerRowStatus() {
792       return (Integer32) getValue(idxSnmp4jLogHandlerRowStatus);
793     }
794
795     public void setSnmp4jLogHandlerRowStatus(Integer32 newValue) {
796       setValue(idxSnmp4jLogHandlerRowStatus, newValue);
797     }
798
799
800      //--AgentGen BEGIN=snmp4jLogHandlerEntry::RowFactory
801 //--AgentGen END
802 }
803
804   class Snmp4jLogFileHandlerEntryRowFactory
805         extends DefaultMOMutableRow2PCFactory
806   {
807     public MOTableRow createRow(OID index, Variable[] values)
808         throws UnsupportedOperationException
809     {
810       Snmp4jLogFileHandlerEntryRow row = new Snmp4jLogFileHandlerEntryRow(index, values);
811      //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::createRow
812 //--AgentGen END
813 return row;
814     }
815
816     public void freeRow(MOTableRow row) {
817      //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::freeRow
818 //--AgentGen END
819 }
820   }
821
822   class Snmp4jLogFileHandlerEntryRow extends DefaultMOMutableRow2PC {
823     public Snmp4jLogFileHandlerEntryRow(OID index, Variable[] values) {
824       super(index, values);
825     }
826
827     public OctetString getSnmp4jLogFileHandlerPath() {
828       return (OctetString) getValue(idxSnmp4jLogFileHandlerPath);
829     }
830
831     public void setSnmp4jLogFileHandlerPath(OctetString newValue) {
832       setValue(idxSnmp4jLogFileHandlerPath, newValue);
833     }
834
835     public Integer32 getSnmp4jLogFileHandlerAppend() {
836       return (Integer32) getValue(idxSnmp4jLogFileHandlerAppend);
837     }
838
839     public void setSnmp4jLogFileHandlerAppend(Integer32 newValue) {
840       setValue(idxSnmp4jLogFileHandlerAppend, newValue);
841     }
842
843     public Integer32 getSnmp4jLogFileHandlerBufferedIO() {
844       return (Integer32) getValue(idxSnmp4jLogFileHandlerBufferedIO);
845     }
846
847     public void setSnmp4jLogFileHandlerBufferedIO(Integer32 newValue) {
848       setValue(idxSnmp4jLogFileHandlerBufferedIO, newValue);
849     }
850
851     public UnsignedInteger32 getSnmp4jLogFileHandlerBufferSize() {
852       return (UnsignedInteger32) getValue(idxSnmp4jLogFileHandlerBufferSize);
853     }
854
855     public void setSnmp4jLogFileHandlerBufferSize(UnsignedInteger32 newValue) {
856       setValue(idxSnmp4jLogFileHandlerBufferSize, newValue);
857     }
858
859
860      //--AgentGen BEGIN=snmp4jLogFileHandlerEntry::RowFactory
861 //--AgentGen END
862 }
863
864   class Snmp4jLogConsoleHandlerEntryRowFactory
865         extends DefaultMOMutableRow2PCFactory
866   {
867     public Snmp4jLogConsoleHandlerEntryRowFactory() {}
868
869     public MOTableRow createRow(OID index, Variable[] values)
870         throws UnsupportedOperationException
871     {
872       Snmp4jLogConsoleHandlerEntryRow row =
873           new Snmp4jLogConsoleHandlerEntryRow(index, values);
874      //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::createRow
875
876      //--AgentGen END
877 return row;
878     }
879
880     public void freeRow(MOTableRow row) {
881      //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::freeRow
882 //--AgentGen END
883 }
884   }
885
886   class Snmp4jLogConsoleHandlerEntryRow extends DefaultMOMutableRow2PC {
887     public Snmp4jLogConsoleHandlerEntryRow(OID index, Variable[] values) {
888       super(index, values);
889     }
890
891     public Integer32 getSnmp4jLogConsoleHandlerTarget() {
892       return (Integer32) getValue(idxSnmp4jLogConsoleHandlerTarget);
893     }
894
895     public void setSnmp4jLogConsoleHandlerTarget(Integer32 newValue) {
896       setValue(idxSnmp4jLogConsoleHandlerTarget, newValue);
897     }
898
899
900      //--AgentGen BEGIN=snmp4jLogConsoleHandlerEntry::RowFactory
901 //--AgentGen END
902 }
903
904
905 //--AgentGen BEGIN=_METHODS
906
907   private OctetString getLogSysDescr() {
908     LogFactory logFactory = LogFactory.getLogFactory();
909     if (logFactory == null) {
910       return new OctetString();
911     }
912     return new OctetString(logFactory.toString());
913   }
914
915   private OctetString getLogFactory() {
916     LogFactory logFactory = LogFactory.getLogFactory();
917     if (logFactory == null) {
918       return new OctetString();
919     }
920     return new OctetString(logFactory.getClass().getName());
921   }
922
923   public void lookupEvent(MOServerLookupEvent event) {
924     if (event.getLookupResult() == this.snmp4jLogSysDescr) {
925       this.snmp4jLogSysDescr.setValue(getLogSysDescr());
926     }
927     if (event.getLookupResult() == this.snmp4jLogFactory) {
928       this.snmp4jLogFactory.setValue(getLogFactory());
929     }
930 /* This table is updated by the queryEvent method below
931     else if (event.getLookupResult() == this.snmp4jLogLoggerEntry) {
932       updateLoggerTable();
933     }
934 */
935   }
936
937   public void queryEvent(MOServerLookupEvent event) {
938     if ((event.getLookupResult() == this.snmp4jLogLoggerEntry) &&
939         (!DefaultMOQuery.isSameSource(event.getQuery(),
940                                       lastLoggerUpdateSource))) {
941       lastLoggerUpdateSource = event.getSource();
942       updateLoggerTable();
943     }
944   }
945
946   private static OID getLoggerIndex(LogAdapter logger) {
947     return new OctetString(logger.getName()).toSubIndex(true);
948   }
949
950   private Snmp4jLogLoggerRow createLoggerRow(int n, LogAdapter logger,
951                                              int storageType) {
952     OID index = getLoggerIndex(logger);
953     Variable[] row = new Variable[5];
954     int i=0;
955     row[i++] = new Integer32(n);
956     row[i++] = new Integer32(logger.getLogLevel().getLevel());
957     row[i++] = new Integer32(logger.getEffectiveLogLevel().getLevel());
958     row[i++] = new Integer32(storageType);
959     row[i++] = new Integer32(RowStatus.active);
960     return new Snmp4jLogLoggerRow(index, row, n, logger);
961   }
962
963   private int getStorageType(LogAdapter logger) {
964     Snmp4jLogLoggerRow row = (Snmp4jLogLoggerRow)
965         snmp4jLogLoggerEntryModel.getRow(getLoggerIndex(logger));
966     if (row != null) {
967       return row.getSnmp4jLogLoggerStorageType().getValue();
968     }
969     return StorageType.volatile_;
970   }
971
972   public void updateLoggerTable() {
973     snmp4jLogLoggerEntryModel.clear(NOT_ACTIVE_ROW_FILTER);
974     if (LogFactory.getLogFactory() == null) {
975       return;
976     }
977     Iterator loggers = LogFactory.getLogFactory().loggers();
978     this.loggers = new HashMap ();
979     LogAdapter rootLogger = LogFactory.getLogFactory().getRootLogger();
980     snmp4jLogLoggerEntryModel.addRow(createLoggerRow(1, rootLogger,
981         getStorageType(rootLogger)));
982     while (loggers.hasNext()) {
983       LogAdapter l = (LogAdapter) loggers.next();
984       int i = 1;
985       Integer index = (Integer ) loggerNames2Index.get(l.getName());
986       if (index == null) {
987         i = nextLoggerIndex++;
988         loggerNames2Index.put(l.getName(), new Integer (i));
989       }
990       else {
991         i = index.intValue();
992       }
993       this.loggers.put(new Integer (i+1), l);
994       snmp4jLogLoggerEntryModel.addRow(createLoggerRow(i+1, l,
995           getStorageType(l)));
996     }
997   }
998
999   public void rowStatusChanged(RowStatusEvent event) {
1000    if (event.getTable().equals(snmp4jLogLoggerEntry)) {
1001      if ((event.getNewStatus() == RowStatus.active) ||
1002          (event.getNewStatus() == RowStatus.createAndGo)) {
1003        Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow) event.getRow();
1004        OctetString loggerName =
1005            new OctetString(r.getIndex().toByteArray());
1006        LogAdapter logAdapter = LogFactory.getLogger(loggerName.toString());
1007        r.setLogAdapter(logAdapter);
1008        logAdapter.setLogLevel(
1009            new LogLevel(r.getSnmp4jLogLoggerLevel().getValue()));
1010      }
1011    }
1012  }
1013
1014  public void rowChanged(MOTableRowEvent event) {
1015    if (event.getTable().equals(snmp4jLogLoggerEntry)) {
1016      switch (event.getType()) {
1017        case MOTableRowEvent.UPDATED: {
1018          Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow) event.getRow();
1019          if (r.getLogAdapter() != null) {
1020            r.getLogAdapter().setLogLevel(
1021                new LogLevel(r.getSnmp4jLogLoggerLevel().getValue()));
1022          }
1023          break;
1024        }
1025        case MOTableRowEvent.ADD: {
1026          Snmp4jLogLoggerRow r = (Snmp4jLogLoggerRow) event.getRow();
1027          OctetString loggerName =
1028              new OctetString(r.getIndex().toByteArray());
1029          LogAdapter logAdapter = LogFactory.getLogger(loggerName.toString());
1030          r.setLogAdapter(logAdapter);
1031          int level = r.getSnmp4jLogLoggerLevel().getValue();
1032          logAdapter.setLogLevel(new LogLevel(level));
1033          break;
1034        }
1035      }
1036    }
1037  }
1038
1039  //--AgentGen END
1040
1041  //--AgentGen BEGIN=_CLASSES
1042
1043  public class Snmp4jLogLoggerRow extends Snmp4jLogLoggerEntryRow {
1044
1045    private LogAdapter logger;
1046    private int n;
1047
1048    protected Snmp4jLogLoggerRow(OID index, Variable[] values,
1049                                 int n, LogAdapter logger) {
1050      super(index, values);
1051      this.n = n;
1052      this.logger = logger;
1053    }
1054
1055    public void setLogAdapter(LogAdapter logAdapter) {
1056      this.logger = logAdapter;
1057    }
1058
1059    public LogAdapter getLogAdapter() {
1060      return logger;
1061    }
1062
1063  }
1064
1065  //--AgentGen END
1066
1067//--AgentGen BEGIN=_END
1068//--AgentGen END
1069}
1070
1071
1072

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags