|
1
22
23
24 package org.snmp4j.agent.agentx.master;
25
26
29 import org.snmp4j.smi.*;
30 import org.snmp4j.mp.SnmpConstants;
31 import org.snmp4j.agent.*;
32 import org.snmp4j.agent.mo.*;
33 import org.snmp4j.agent.mo.snmp.*;
34 import org.snmp4j.agent.mo.snmp.smi.*;
35 import org.snmp4j.agent.request.*;
36 import org.snmp4j.log.LogFactory;
37 import org.snmp4j.log.LogAdapter;
38
39 import org.snmp4j.agent.agentx.AgentXProtocol;
41 import org.snmp4j.agent.agentx.AgentXPeer;
42 import org.snmp4j.agent.util.IndexGenerator;
43 import org.snmp4j.agent.agentx.master.AgentXMib.AgentxConnectionEntryRow;
44 import org.snmp4j.agent.agentx.master.AgentXMib.AgentxRegistrationEntryRow;
45 import org.snmp4j.agent.mo.snmp.tc.TruthValueTC;
46
48 public class AgentXMib
49 implements MOGroup, AgentXMasterListener, MOTableModelListener
52 {
55
56 private static final LogAdapter LOGGER =
57 LogFactory.getLogger(AgentXMib.class);
58
59
62 private static MOFactory moFactory = DefaultMOFactory.getInstance();
64
65 static final OID oidAgentxDefaultTimeout =
67 new OID(new int[] { 1,3,6,1,2,1,74,1,1,1,0 });
68 static final OID oidAgentxMasterAgentXVer =
69 new OID(new int[] { 1,3,6,1,2,1,74,1,1,2,0 });
70 static final OID oidAgentxConnTableLastChange =
71 new OID(new int[] { 1,3,6,1,2,1,74,1,2,1,0 });
72 static final OID oidAgentxSessionTableLastChange =
73 new OID(new int[] { 1,3,6,1,2,1,74,1,3,1,0 });
74 static final OID oidAgentxRegistrationTableLastChange =
75 new OID(new int[] { 1,3,6,1,2,1,74,1,4,1,0 });
76
77 private static final String  TC_MODULE_SNMPV2_TC = "SNMPv2-TC";
79 private static final String TC_TIMESTAMP = "TimeStamp";
80
81 private MOScalar agentxDefaultTimeout;
83 private MOScalar agentxMasterAgentXVer;
84 private MOScalar agentxConnTableLastChange;
85 private MOScalar agentxSessionTableLastChange;
86 private MOScalar agentxRegistrationTableLastChange;
87
88 static final OID oidAgentxConnectionEntry =
90 new OID(new int[] { 1,3,6,1,2,1,74,1,2,2,1 });
91
92 static final int colAgentxConnOpenTime = 2;
94 static final int colAgentxConnTransportDomain = 3;
95 static final int colAgentxConnTransportAddress = 4;
96
97 static final int idxAgentxConnOpenTime = 0;
99 static final int idxAgentxConnTransportDomain = 1;
100 static final int idxAgentxConnTransportAddress = 2;
101
102 private static final MOTableSubIndex[] agentxConnectionEntryIndexes =
103 new MOTableSubIndex[] {
104 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
105
106 private static final MOTableIndex agentxConnectionEntryIndex =
107 moFactory.createIndex(agentxConnectionEntryIndexes,
108 false,
109 new MOTableIndexValidator() {
110 public boolean isValidIndex(OID index) {
111 boolean isValidIndex = true;
112 return isValidIndex;
115 }
116 });
117
118
119 private MOTable agentxConnectionEntry;
120 private MOMutableTableModel agentxConnectionEntryModel;
121 static final OID oidAgentxSessionEntry =
122 new OID(new int[] { 1,3,6,1,2,1,74,1,3,2,1 });
123
124 static final int colAgentxSessionObjectID = 2;
126 static final int colAgentxSessionDescr = 3;
127 static final int colAgentxSessionAdminStatus = 4;
128 static final int colAgentxSessionOpenTime = 5;
129 static final int colAgentxSessionAgentXVer = 6;
130 static final int colAgentxSessionTimeout = 7;
131
132 static final int idxAgentxSessionObjectID = 0;
134 static final int idxAgentxSessionDescr = 1;
135 static final int idxAgentxSessionAdminStatus = 2;
136 static final int idxAgentxSessionOpenTime = 3;
137 static final int idxAgentxSessionAgentXVer = 4;
138 static final int idxAgentxSessionTimeout = 5;
139
140 private static final MOTableSubIndex[] agentxSessionEntryIndexes =
141 new MOTableSubIndex[] {
142 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1),
143 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
144
145 private static final MOTableIndex agentxSessionEntryIndex =
146 moFactory.createIndex(agentxSessionEntryIndexes,
147 false,
148 new MOTableIndexValidator() {
149 public boolean isValidIndex(OID index) {
150 boolean isValidIndex = true;
151 return isValidIndex;
154 }
155 });
156
157
158 private MOTable agentxSessionEntry;
159 private MOMutableTableModel agentxSessionEntryModel;
160 static final OID oidAgentxRegistrationEntry =
161 new OID(new int[] { 1,3,6,1,2,1,74,1,4,2,1 });
162
163 static final int colAgentxRegContext = 2;
165 static final int colAgentxRegStart = 3;
166 static final int colAgentxRegRangeSubId = 4;
167 static final int colAgentxRegUpperBound = 5;
168 static final int colAgentxRegPriority = 6;
169 static final int colAgentxRegTimeout = 7;
170 static final int colAgentxRegInstance = 8;
171
172 static final int idxAgentxRegContext = 0;
174 static final int idxAgentxRegStart = 1;
175 static final int idxAgentxRegRangeSubId = 2;
176 static final int idxAgentxRegUpperBound = 3;
177 static final int idxAgentxRegPriority = 4;
178 static final int idxAgentxRegTimeout = 5;
179 static final int idxAgentxRegInstance = 6;
180
181 private static final MOTableSubIndex[] agentxRegistrationEntryIndexes =
182 new MOTableSubIndex[] {
183 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1),
184 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1),
185 moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
186
187 private static final MOTableIndex agentxRegistrationEntryIndex =
188 moFactory.createIndex(agentxRegistrationEntryIndexes,
189 false,
190 new MOTableIndexValidator() {
191 public boolean isValidIndex(OID index) {
192 boolean isValidIndex = true;
193 return isValidIndex;
196 }
197 });
198
199
200 private MOTable agentxRegistrationEntry;
201 private MOMutableTableModel agentxRegistrationEntryModel;
202
203
204
206 private AgentXCommandProcessor agentXProcessor;
207
208 private IndexGenerator connIndexGenerator =
209 new IndexGenerator(new UnsignedInteger32(1));
210 private IndexGenerator regEntryIndexGenerator =
211 new IndexGenerator(new UnsignedInteger32(1));
212 private TDomainAddressFactory addrFactory = new TDomainAddressFactoryImpl();
213
214
216 protected AgentXMib() {
217 agentxDefaultTimeout =
218 moFactory.createScalar(oidAgentxDefaultTimeout,
219 MOAccessImpl.ACCESS_READ_ONLY, new Integer32());
220 agentxDefaultTimeout.setVolatile(true);
221 agentxMasterAgentXVer =
222 moFactory.createScalar(oidAgentxMasterAgentXVer,
223 MOAccessImpl.ACCESS_READ_ONLY, new Integer32());
224 agentxMasterAgentXVer.setVolatile(true);
225 agentxConnTableLastChange =
226 moFactory.createScalar(oidAgentxConnTableLastChange,
227 MOAccessImpl.ACCESS_READ_ONLY, new TimeTicks(),
228 TC_MODULE_SNMPV2_TC, TC_TIMESTAMP);
229 agentxConnTableLastChange.setVolatile(true);
230 agentxSessionTableLastChange =
231 moFactory.createScalar(oidAgentxSessionTableLastChange,
232 MOAccessImpl.ACCESS_READ_ONLY, new TimeTicks(),
233 TC_MODULE_SNMPV2_TC, TC_TIMESTAMP);
234 agentxSessionTableLastChange.setVolatile(true);
235 agentxRegistrationTableLastChange =
236 moFactory.createScalar(oidAgentxRegistrationTableLastChange,
237 MOAccessImpl.ACCESS_READ_ONLY, new TimeTicks(),
238 TC_MODULE_SNMPV2_TC, TC_TIMESTAMP);
239 agentxRegistrationTableLastChange.setVolatile(true);
240 createAgentxConnectionEntry();
241 createAgentxSessionEntry();
242 createAgentxRegistrationEntry();
243 }
246
247 public AgentXMib(AgentXCommandProcessor agentXProcessor) {
249 this();
250 this.agentXProcessor = agentXProcessor;
251 VariantVariableCallback agentxDefaultTimeoutCallback =
252 new ReadonlyVariableCallback() {
253 public void updateVariable(VariantVariable variable) {
254 variable.setValue(AgentXMib.this.agentXProcessor.getDefaultTimeout());
255 }
256 };
257 agentxDefaultTimeout.setValue(new VariantVariable(new Integer32(),
258 agentxDefaultTimeoutCallback));
259 agentxMasterAgentXVer.setValue(
260 new Integer32(agentXProcessor.getAgentXVersion()));
261 ((DefaultMOMutableTableModel)
262 agentxConnectionEntryModel).addMOTableModelListener(this);
263 ((DefaultMOMutableTableModel)
264 agentxSessionEntryModel).addMOTableModelListener(this);
265 ((DefaultMOMutableTableModel)
266 agentxRegistrationEntryModel).addMOTableModelListener(this);
267 }
268
270
271 public MOTable getAgentxConnectionEntry() {
272 return agentxConnectionEntry;
273 }
274
275
276 private void createAgentxConnectionEntry() {
277 MOColumn[] agentxConnectionEntryColumns = new MOColumn[3];
278 agentxConnectionEntryColumns[idxAgentxConnOpenTime] =
279 moFactory.createColumn(colAgentxConnOpenTime,
280 SMIConstants.SYNTAX_TIMETICKS,
281 MOAccessImpl.ACCESS_READ_ONLY);
282 agentxConnectionEntryColumns[idxAgentxConnTransportDomain] =
283 moFactory.createColumn(colAgentxConnTransportDomain,
284 SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
285 MOAccessImpl.ACCESS_READ_ONLY);
286 agentxConnectionEntryColumns[idxAgentxConnTransportAddress] =
287 moFactory.createColumn(colAgentxConnTransportAddress,
288 SMIConstants.SYNTAX_OCTET_STRING,
289 MOAccessImpl.ACCESS_READ_ONLY);
290
291 agentxConnectionEntryModel = new DefaultMOMutableTableModel();
292 agentxConnectionEntryModel.setRowFactory(new AgentxConnectionEntryRowFactory());
293 agentxConnectionEntry =
294 moFactory.createTable(oidAgentxConnectionEntry,
295 agentxConnectionEntryIndex,
296 agentxConnectionEntryColumns,
297 agentxConnectionEntryModel);
298 if (agentxConnectionEntry instanceof DefaultMOTable) {
299 ((DefaultMOTable)agentxConnectionEntry).setVolatile(true);
300 }
301 }
302
303 public MOTable getAgentxSessionEntry() {
304 return agentxSessionEntry;
305 }
306
307
308 private void createAgentxSessionEntry() {
309 MOColumn[] agentxSessionEntryColumns = new MOColumn[6];
310 agentxSessionEntryColumns[idxAgentxSessionObjectID] =
311 moFactory.createColumn(colAgentxSessionObjectID,
312 SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
313 MOAccessImpl.ACCESS_READ_ONLY);
314 agentxSessionEntryColumns[idxAgentxSessionDescr] =
315 moFactory.createColumn(colAgentxSessionDescr,
316 SMIConstants.SYNTAX_OCTET_STRING,
317 MOAccessImpl.ACCESS_READ_ONLY);
318 agentxSessionEntryColumns[idxAgentxSessionAdminStatus] =
319 new Enumerated(colAgentxSessionAdminStatus,
320 MOAccessImpl.ACCESS_READ_WRITE,
321 null,
322 true);
323 ValueConstraint agentxSessionAdminStatusVC = new EnumerationConstraint(
324 new int[] { AgentxSessionAdminStatusEnum.up,
325 AgentxSessionAdminStatusEnum.down });
326 ((MOMutableColumn)agentxSessionEntryColumns[idxAgentxSessionAdminStatus]).
327 addMOValueValidationListener(new ValueConstraintValidator(agentxSessionAdminStatusVC));
328 ((MOMutableColumn)agentxSessionEntryColumns[idxAgentxSessionAdminStatus]).
329 addMOValueValidationListener(new AgentxSessionAdminStatusValidator());
330 agentxSessionEntryColumns[idxAgentxSessionOpenTime] =
331 moFactory.createColumn(colAgentxSessionOpenTime,
332 SMIConstants.SYNTAX_TIMETICKS,
333 MOAccessImpl.ACCESS_READ_ONLY);
334 agentxSessionEntryColumns[idxAgentxSessionAgentXVer] =
335 moFactory.createColumn(colAgentxSessionAgentXVer,
336 SMIConstants.SYNTAX_INTEGER,
337 MOAccessImpl.ACCESS_READ_ONLY);
338 agentxSessionEntryColumns[idxAgentxSessionTimeout] =
339 moFactory.createColumn(colAgentxSessionTimeout,
340 SMIConstants.SYNTAX_INTEGER,
341 MOAccessImpl.ACCESS_READ_ONLY);
342
343 agentxSessionEntryModel = new DefaultMOMutableTableModel();
344 agentxSessionEntryModel.setRowFactory(new AgentxSessionEntryRowFactory());
345 agentxSessionEntry =
346 moFactory.createTable(oidAgentxSessionEntry,
347 agentxSessionEntryIndex,
348 agentxSessionEntryColumns,
349 agentxSessionEntryModel);
350 if (agentxSessionEntry instanceof DefaultMOTable) {
351 ((DefaultMOTable)agentxSessionEntry).setVolatile(true);
352 }
353 }
354
355 public MOTable getAgentxRegistrationEntry() {
356 return agentxRegistrationEntry;
357 }
358
359
360 private void createAgentxRegistrationEntry() {
361 MOColumn[] agentxRegistrationEntryColumns = new MOColumn[7];
362 agentxRegistrationEntryColumns[idxAgentxRegContext] =
363 moFactory.createColumn(colAgentxRegContext,
364 SMIConstants.SYNTAX_OCTET_STRING,
365 MOAccessImpl.ACCESS_READ_ONLY);
366 agentxRegistrationEntryColumns[idxAgentxRegStart] =
367 moFactory.createColumn(colAgentxRegStart,
368 SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
369 MOAccessImpl.ACCESS_READ_ONLY);
370 agentxRegistrationEntryColumns[idxAgentxRegRangeSubId] =
371 moFactory.createColumn(colAgentxRegRangeSubId,
372 SMIConstants.SYNTAX_GAUGE32,
373 MOAccessImpl.ACCESS_READ_ONLY);
374 agentxRegistrationEntryColumns[idxAgentxRegUpperBound] =
375 moFactory.createColumn(colAgentxRegUpperBound,
376 SMIConstants.SYNTAX_GAUGE32,
377 MOAccessImpl.ACCESS_READ_ONLY);
378 agentxRegistrationEntryColumns[idxAgentxRegPriority] =
379 moFactory.createColumn(colAgentxRegPriority,
380 SMIConstants.SYNTAX_GAUGE32,
381 MOAccessImpl.ACCESS_READ_ONLY);
382 agentxRegistrationEntryColumns[idxAgentxRegTimeout] =
383 moFactory.createColumn(colAgentxRegTimeout,
384 SMIConstants.SYNTAX_INTEGER,
385 MOAccessImpl.ACCESS_READ_ONLY);
386 agentxRegistrationEntryColumns[idxAgentxRegInstance] =
387 moFactory.createColumn(colAgentxRegInstance,
388 SMIConstants.SYNTAX_INTEGER,
389 MOAccessImpl.ACCESS_READ_ONLY);
390
391 agentxRegistrationEntryModel = new DefaultMOMutableTableModel();
392 agentxRegistrationEntryModel.setRowFactory(new AgentxRegistrationEntryRowFactory());
393 agentxRegistrationEntry =
394 moFactory.createTable(oidAgentxRegistrationEntry,
395 agentxRegistrationEntryIndex,
396 agentxRegistrationEntryColumns,
397 agentxRegistrationEntryModel);
398 if (agentxRegistrationEntry instanceof DefaultMOTable) {
399 ((DefaultMOTable)agentxRegistrationEntry).setVolatile(true);
400 }
401 }
402
403
404
405 public void registerMOs(MOServer server, OctetString context)
406 throws DuplicateRegistrationException
407 {
408 server.register(this.agentxDefaultTimeout, context);
410 server.register(this.agentxMasterAgentXVer, context);
411 server.register(this.agentxConnTableLastChange, context);
412 server.register(this.agentxSessionTableLastChange, context);
413 server.register(this.agentxRegistrationTableLastChange, context);
414 server.register(this.agentxConnectionEntry, context);
415 server.register(this.agentxSessionEntry, context);
416 server.register(this.agentxRegistrationEntry, context);
417 ((TimeStampScalar)
419 agentxConnTableLastChange).setSysUpTime(SNMPv2MIB.getSysUpTime(context));
420 ((TimeStampScalar)
421 agentxSessionTableLastChange).setSysUpTime(SNMPv2MIB.getSysUpTime(context));
422 ((TimeStampScalar)
423 agentxRegistrationTableLastChange).setSysUpTime(SNMPv2MIB.getSysUpTime(context));
424 }
426
427 public void unregisterMOs(MOServer server, OctetString context) {
428 server.unregister(this.agentxDefaultTimeout, context);
430 server.unregister(this.agentxMasterAgentXVer, context);
431 server.unregister(this.agentxConnTableLastChange, context);
432 server.unregister(this.agentxSessionTableLastChange, context);
433 server.unregister(this.agentxRegistrationTableLastChange, context);
434 server.unregister(this.agentxConnectionEntry, context);
435 server.unregister(this.agentxSessionEntry, context);
436 server.unregister(this.agentxRegistrationEntry, context);
437 }
440
441
443
445
447
451 static class AgentxSessionAdminStatusValidator implements MOValueValidationListener {
452
453 public void validate(MOValueValidationEvent validationEvent) {
454 Variable newValue = validationEvent.getNewValue();
455 }
458 }
459
460
462 public static final class AgentxSessionAdminStatusEnum {
463 public static final int up = 1;
464 public static final int down = 2;
465 }
466
467 class AgentxConnectionEntryRowFactory
469 extends DefaultMOMutableRow2PCFactory
470 {
471 public synchronized MOTableRow createRow(OID index, Variable[] values)
472 throws UnsupportedOperationException
473 {
474 AgentxConnectionEntryRow row = new AgentxConnectionEntryRow(index, values);
475 return row;
478 }
479
480 public synchronized void freeRow(MOTableRow row) {
481 }
484 }
485
486 class AgentxConnectionEntryRow extends DefaultMOMutableRow2PC {
487 public AgentxConnectionEntryRow(OID index, Variable[] values) {
488 super(index, values);
489 }
490
491 public TimeTicks getAgentxConnOpenTime() {
492 return (TimeTicks) getValue(idxAgentxConnOpenTime);
493 }
494
495 public void setAgentxConnOpenTime(TimeTicks newValue) {
496 setValue(idxAgentxConnOpenTime, newValue);
497 }
498
499 public OID getAgentxConnTransportDomain() {
500 return (OID) getValue(idxAgentxConnTransportDomain);
501 }
502
503 public void setAgentxConnTransportDomain(OID newValue) {
504 setValue(idxAgentxConnTransportDomain, newValue);
505 }
506
507 public OctetString getAgentxConnTransportAddress() {
508 return (OctetString) getValue(idxAgentxConnTransportAddress);
509 }
510
511 public void setAgentxConnTransportAddress(OctetString newValue) {
512 setValue(idxAgentxConnTransportAddress, newValue);
513 }
514
515
516 }
519
520 class AgentxSessionEntryRowFactory
521 extends DefaultMOMutableRow2PCFactory
522 {
523 public synchronized MOTableRow createRow(OID index, Variable[] values)
524 throws UnsupportedOperationException
525 {
526 AgentxSessionEntryRow row = new AgentxSessionEntryRow(index, values);
527 return row;
530 }
531
532 public synchronized void freeRow(MOTableRow row) {
533 }
536 }
537
538 class AgentxSessionEntryRow extends DefaultMOMutableRow2PC {
539 public AgentxSessionEntryRow(OID index, Variable[] values) {
540 super(index, values);
541 }
542
543 public OID getAgentxSessionObjectID() {
544 return (OID) getValue(idxAgentxSessionObjectID);
545 }
546
547 public void setAgentxSessionObjectID(OID newValue) {
548 setValue(idxAgentxSessionObjectID, newValue);
549 }
550
551 public OctetString getAgentxSessionDescr() {
552 return (OctetString) getValue(idxAgentxSessionDescr);
553 }
554
555 public void setAgentxSessionDescr(OctetString newValue) {
556 setValue(idxAgentxSessionDescr, newValue);
557 }
558
559 public Integer32 getAgentxSessionAdminStatus() {
560 return (Integer32) getValue(idxAgentxSessionAdminStatus);
561 }
562
563 public void setAgentxSessionAdminStatus(Integer32 newValue) {
564 setValue(idxAgentxSessionAdminStatus, newValue);
565 }
566
567 public TimeTicks getAgentxSessionOpenTime() {
568 return (TimeTicks) getValue(idxAgentxSessionOpenTime);
569 }
570
571 public void setAgentxSessionOpenTime(TimeTicks newValue) {
572 setValue(idxAgentxSessionOpenTime, newValue);
573 }
574
575 public Integer32 getAgentxSessionAgentXVer() {
576 return (Integer32) getValue(idxAgentxSessionAgentXVer);
577 }
578
579 public void setAgentxSessionAgentXVer(Integer32 newValue) {
580 setValue(idxAgentxSessionAgentXVer, newValue);
581 }
582
583 public Integer32 getAgentxSessionTimeout() {
584 return (Integer32) getValue(idxAgentxSessionTimeout);
585 }
586
587 public void setAgentxSessionTimeout(Integer32 newValue) {
588 setValue(idxAgentxSessionTimeout, newValue);
589 }
590
591
592 }
595
596 class AgentxRegistrationEntryRowFactory
597 extends DefaultMOMutableRow2PCFactory
598 {
599 public synchronized MOTableRow createRow(OID index, Variable[] values)
600 throws UnsupportedOperationException
601 {
602 AgentxRegistrationEntryRow row = new AgentxRegistrationEntryRow(index, values);
603 return row;
606 }
607
608 public synchronized void freeRow(MOTableRow row) {
609 }
612 }
613
614 class AgentxRegistrationEntryRow extends DefaultMOMutableRow2PC {
615 public AgentxRegistrationEntryRow(OID index, Variable[] values) {
616 super(index, values);
617 }
618
619 public OctetString getAgentxRegContext() {
620 return (OctetString) getValue(idxAgentxRegContext);
621 }
622
623 public void setAgentxRegContext(OctetString newValue) {
624 setValue(idxAgentxRegContext, newValue);
625 }
626
627 public OID getAgentxRegStart() {
628 return (OID) getValue(idxAgentxRegStart);
629 }
630
631 public void setAgentxRegStart(OID newValue) {
632 setValue(idxAgentxRegStart, newValue);
633 }
634
635 public UnsignedInteger32 getAgentxRegRangeSubId() {
636 return (UnsignedInteger32) getValue(idxAgentxRegRangeSubId);
637 }
638
639 public void setAgentxRegRangeSubId(UnsignedInteger32 newValue) {
640 setValue(idxAgentxRegRangeSubId, newValue);
641 }
642
643 public UnsignedInteger32 getAgentxRegUpperBound() {
644 return (UnsignedInteger32) getValue(idxAgentxRegUpperBound);
645 }
646
647 public void setAgentxRegUpperBound(UnsignedInteger32 newValue) {
648 setValue(idxAgentxRegUpperBound, newValue);
649 }
650
651 public UnsignedInteger32 getAgentxRegPriority() {
652 return (UnsignedInteger32) getValue(idxAgentxRegPriority);
653 }
654
655 public void setAgentxRegPriority(UnsignedInteger32 newValue) {
656 setValue(idxAgentxRegPriority, newValue);
657 }
658
659 public Integer32 getAgentxRegTimeout() {
660 return (Integer32) getValue(idxAgentxRegTimeout);
661 }
662
663 public void setAgentxRegTimeout(Integer32 newValue) {
664 setValue(idxAgentxRegTimeout, newValue);
665 }
666
667 public Integer32 getAgentxRegInstance() {
668 return (Integer32) getValue(idxAgentxRegInstance);
669 }
670
671 public void setAgentxRegInstance(Integer32 newValue) {
672 setValue(idxAgentxRegInstance, newValue);
673 }
674
675
676 }
679
680
681
682 public void masterChanged(AgentXMasterEvent event) {
684 switch (event.getType()) {
685 case AgentXMasterEvent.PEER_ADDED: {
686 AgentXPeer changedPeer = (AgentXPeer) event.getChangedObject();
687 Address addr = changedPeer.getAddress();
688 AgentxConnectionEntryRow row = (AgentxConnectionEntryRow)
689 agentxConnectionEntry.createRow(connIndexGenerator.getNextSubIndex());
690 agentxConnectionEntry.addRow(row);
691 row.setAgentxConnOpenTime(((TimeStampScalar)agentxConnTableLastChange).
692 getSysUpTime().get());
693 row.setAgentxConnTransportAddress(addrFactory.getAddress(addr));
694 row.setAgentxConnTransportDomain(addrFactory.getTransportDomain(addr));
695 changedPeer.setId(row.getIndex());
696 break;
697 }
698 case AgentXMasterEvent.PEER_REMOVED: {
699 AgentXPeer changedPeer = (AgentXPeer) event.getChangedObject();
700 if (changedPeer != null) {
701 OID index = (OID) changedPeer.getId();
702 OID next = index.nextPeer();
703 agentxConnectionEntry.removeRow(index);
704 ((DefaultMOMutableTableModel) agentxSessionEntryModel).
705 removeRows(index, next);
706 ((DefaultMOMutableTableModel) agentxRegistrationEntryModel).
707 removeRows(index, next);
708 }
709 break;
710 }
711 case AgentXMasterEvent.SESSION_ADDED: {
712 AgentXMasterSession session =
713 (AgentXMasterSession)event.getChangedObject();
714 OID index = new OID((OID)session.getPeer().getId());
715 index.append(session.getSessionID());
716 AgentxSessionEntryRow row = (AgentxSessionEntryRow)
717 agentxSessionEntry.createRow(index);
718 row.setAgentxSessionAdminStatus(
719 new Integer32(AgentxSessionAdminStatusEnum.up));
720 row.setAgentxSessionAgentXVer(new Integer32(session.getAgentXVersion()));
721 row.setAgentxSessionDescr(session.getDescr());
722 row.setAgentxSessionObjectID(session.getOid());
723 row.setAgentxSessionOpenTime(((TimeStampScalar)agentxSessionTableLastChange).
724 getSysUpTime().get());
725 row.setAgentxSessionTimeout(new Integer32(session.getTimeout() & 0xFF));
726 agentxSessionEntry.addRow(row);
727 break;
728 }
729 case AgentXMasterEvent.SESSION_REMOVED: {
730 AgentXMasterSession session =
731 (AgentXMasterSession)event.getChangedObject();
732 OID index = new OID((OID)session.getPeer().getId());
733 index.append(session.getSessionID());
734 agentxSessionEntry.removeRow(index);
735 break;
736 }
737 case AgentXMasterEvent.REGISTRATION_ADDED: {
738 AgentXRegEntry entry = (AgentXRegEntry)event.getChangedObject();
739 AgentXMasterSession session = entry.getSession();
740 AgentXPeer peer = session.getPeer();
741 if (peer.getId() == null) {
742 LOGGER.error("Peer ID is null for peer "+peer+
743 ", cannot add registration "+
744 entry+" to AgentXMIB");
745 }
746 else {
747 OID index = new OID((OID)peer.getId());
748 index.append(session.getSessionID());
749 index.append(regEntryIndexGenerator.getNextSubIndex());
750 entry.setId(index);
751 AgentxRegistrationEntryRow row = (AgentxRegistrationEntryRow)
752 agentxRegistrationEntry.createRow(index);
753 row.setAgentxRegContext(entry.getContext());
754 Integer32 singleOID =
755 TruthValueTC.getValue(entry.getRegion().isSingleOID());
756 row.setAgentxRegInstance(singleOID);
757 row.setAgentxRegPriority(new UnsignedInteger32(entry.getPriority()));
758 row.setAgentxRegRangeSubId(
759 new UnsignedInteger32(entry.getRegion().getRangeSubID()));
760 row.setAgentxRegStart(entry.getRegion().getLowerBound());
761 row.setAgentxRegTimeout(new Integer32(entry.getTimeout()));
762 row.setAgentxRegUpperBound(
763 new UnsignedInteger32(entry.getRegion().getUpperBoundSubID()));
764 agentxRegistrationEntry.addRow(row);
765 }
766 break;
767 }
768 case AgentXMasterEvent.REGISTRATION_REMOVED: {
769 AgentXRegEntry entry = (AgentXRegEntry)event.getChangedObject();
770 OID index = entry.getId();
771 if (index == null) {
772 LOGGER.warn("Registration has been removed that was not previously "+
773 "added to the AgentXMib: "+entry);
774 }
775 else {
776 agentxRegistrationEntry.removeRow(index);
777 }
778 break;
779 }
780 default: {
781 if (LOGGER.isDebugEnabled()) {
782 LOGGER.debug("Unrecognized master change event: " + event);
783 }
784 }
785 }
786 }
787
788 public void tableModelChanged(MOTableModelEvent changeEvent) {
789 Object source = changeEvent.getSource();
790 if (source.equals(agentxConnectionEntryModel)) {
791 ((UpdatableManagedObject)agentxConnTableLastChange).update();
792 }
793 else if (source.equals(agentxSessionEntryModel)) {
794 ((UpdatableManagedObject)agentxSessionTableLastChange).update();
795 }
796 else if (source.equals(agentxRegistrationEntryModel)) {
797 ((UpdatableManagedObject)agentxRegistrationTableLastChange).update();
798 }
799 }
800
801
803
806 }
809
810
811 |
Popular Tags |
Java API By Example, From Geeks To Geeks.