0001: /*_############################################################################
0002: _##
0003: _## SNMP4J-AgentJMX - JvmManagementMib.java
0004: _##
0005: _## Copyright (C) 2006-2007 Frank Fock (SNMP4J.org)
0006: _##
0007: _## This program is free software; you can redistribute it and/or modify
0008: _## it under the terms of the GNU General Public License version 2 as
0009: _## published by the Free Software Foundation.
0010: _##
0011: _## This program is distributed in the hope that it will be useful,
0012: _## but WITHOUT ANY WARRANTY; without even the implied warranty of
0013: _## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
0014: _## GNU General Public License for more details.
0015: _##
0016: _## You should have received a copy of the GNU General Public License
0017: _## along with this program; if not, write to the Free Software
0018: _## Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
0019: _## MA 02110-1301 USA
0020: _##
0021: _##########################################################################*/
0022:
0023: package org.snmp4j.agent.mo.jmx.mibs;
0024:
0025: //--AgentGen BEGIN=_BEGIN
0026: //--AgentGen END
0027:
0028: import org.snmp4j.smi.*;
0029: import org.snmp4j.mp.SnmpConstants;
0030: import org.snmp4j.agent.*;
0031: import org.snmp4j.agent.mo.*;
0032: import org.snmp4j.agent.mo.snmp.*;
0033: import org.snmp4j.agent.mo.snmp.smi.*;
0034: import org.snmp4j.agent.request.*;
0035: import org.snmp4j.log.LogFactory;
0036: import org.snmp4j.log.LogAdapter;
0037:
0038: import org.snmp4j.agent.mo.jmx.*;
0039:
0040: //--AgentGen BEGIN=_IMPORT
0041: //--AgentGen END
0042:
0043: public class JvmManagementMib
0044: //--AgentGen BEGIN=_EXTENDS
0045: //--AgentGen END
0046: implements MOGroup
0047: //--AgentGen BEGIN=_IMPLEMENTS
0048: //--AgentGen END
0049: {
0050:
0051: private static final LogAdapter LOGGER = LogFactory
0052: .getLogger(JvmManagementMib.class);
0053:
0054: //--AgentGen BEGIN=_STATIC
0055: //--AgentGen END
0056:
0057: // Factory
0058: private MOFactory moFactory = DefaultMOFactory.getInstance();
0059:
0060: // Constants
0061: public static final OID oidJvmClassesLoadedCount = new OID(
0062: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 1,
0063: 1, 0 });
0064: public static final OID oidJvmClassesTotalLoadedCount = new OID(
0065: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 1,
0066: 2, 0 });
0067: public static final OID oidJvmClassesUnloadedCount = new OID(
0068: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 1,
0069: 3, 0 });
0070: public static final OID oidJvmClassesVerboseLevel = new OID(
0071: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 1,
0072: 4, 0 });
0073: public static final OID oidJvmMemoryPendingFinalCount = new OID(
0074: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0075: 1, 0 });
0076: public static final OID oidJvmMemoryGCVerboseLevel = new OID(
0077: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0078: 2, 0 });
0079: public static final OID oidJvmMemoryGCCall = new OID(new int[] { 1,
0080: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2, 3, 0 });
0081: public static final OID oidJvmMemoryHeapInitSize = new OID(
0082: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0083: 10, 0 });
0084: public static final OID oidJvmMemoryHeapUsed = new OID(new int[] {
0085: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2, 11, 0 });
0086: public static final OID oidJvmMemoryHeapCommitted = new OID(
0087: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0088: 12, 0 });
0089: public static final OID oidJvmMemoryHeapMaxSize = new OID(
0090: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0091: 13, 0 });
0092: public static final OID oidJvmMemoryNonHeapInitSize = new OID(
0093: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0094: 20, 0 });
0095: public static final OID oidJvmMemoryNonHeapUsed = new OID(
0096: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0097: 21, 0 });
0098: public static final OID oidJvmMemoryNonHeapCommitted = new OID(
0099: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0100: 22, 0 });
0101: public static final OID oidJvmMemoryNonHeapMaxSize = new OID(
0102: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0103: 23, 0 });
0104: public static final OID oidJvmThreadCount = new OID(new int[] { 1,
0105: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3, 1, 0 });
0106: public static final OID oidJvmThreadDaemonCount = new OID(
0107: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0108: 2, 0 });
0109: public static final OID oidJvmThreadPeakCount = new OID(new int[] {
0110: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3, 3, 0 });
0111: public static final OID oidJvmThreadTotalStartedCount = new OID(
0112: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0113: 4, 0 });
0114: public static final OID oidJvmThreadContentionMonitoring = new OID(
0115: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0116: 5, 0 });
0117: public static final OID oidJvmThreadCpuTimeMonitoring = new OID(
0118: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0119: 6, 0 });
0120: public static final OID oidJvmThreadPeakCountReset = new OID(
0121: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0122: 7, 0 });
0123: public static final OID oidJvmRTName = new OID(new int[] { 1, 3, 6,
0124: 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 1, 0 });
0125: public static final OID oidJvmRTVMName = new OID(new int[] { 1, 3,
0126: 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 2, 0 });
0127: public static final OID oidJvmRTVMVendor = new OID(new int[] { 1,
0128: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 3, 0 });
0129: public static final OID oidJvmRTVMVersion = new OID(new int[] { 1,
0130: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 4, 0 });
0131: public static final OID oidJvmRTSpecName = new OID(new int[] { 1,
0132: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 5, 0 });
0133: public static final OID oidJvmRTSpecVendor = new OID(new int[] { 1,
0134: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 6, 0 });
0135: public static final OID oidJvmRTSpecVersion = new OID(new int[] {
0136: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 7, 0 });
0137: public static final OID oidJvmRTManagementSpecVersion = new OID(
0138: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4,
0139: 8, 0 });
0140: public static final OID oidJvmRTBootClassPathSupport = new OID(
0141: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4,
0142: 9, 0 });
0143: public static final OID oidJvmRTInputArgsCount = new OID(new int[] {
0144: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 10, 0 });
0145: public static final OID oidJvmRTUptimeMs = new OID(new int[] { 1,
0146: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 11, 0 });
0147: public static final OID oidJvmRTStartTimeMs = new OID(new int[] {
0148: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 12, 0 });
0149: public static final OID oidJvmJITCompilerName = new OID(new int[] {
0150: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 5, 1, 0 });
0151: public static final OID oidJvmJITCompilerTimeMs = new OID(
0152: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 5,
0153: 2, 0 });
0154: public static final OID oidJvmJITCompilerTimeMonitoring = new OID(
0155: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 5,
0156: 3, 0 });
0157: public static final OID oidJvmOSName = new OID(new int[] { 1, 3, 6,
0158: 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 6, 1, 0 });
0159: public static final OID oidJvmOSArch = new OID(new int[] { 1, 3, 6,
0160: 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 6, 2, 0 });
0161: public static final OID oidJvmOSVersion = new OID(new int[] { 1, 3,
0162: 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 6, 3, 0 });
0163: public static final OID oidJvmOSProcessorCount = new OID(new int[] {
0164: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 6, 4, 0 });
0165: public static final OID oidJvmLowMemoryPoolUsageNotif = new OID(
0166: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 2, 2,
0167: 1, 0, 1 });
0168: public static final OID oidTrapVarJvmMemPoolName = new OID(
0169: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0170: 110, 1, 2 });
0171: public static final OID oidTrapVarJvmMemPoolUsed = new OID(
0172: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0173: 110, 1, 11 });
0174: public static final OID oidTrapVarJvmMemPoolThreshdCount = new OID(
0175: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0176: 110, 1, 111 });
0177:
0178: public static final OID oidJvmLowMemoryPoolCollectNotif = new OID(
0179: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 2, 2,
0180: 1, 0, 2 });
0181: public static final OID oidTrapVarJvmMemPoolCollectUsed = new OID(
0182: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0183: 110, 1, 31 });
0184: public static final OID oidTrapVarJvmMemPoolCollectThreshdCount = new OID(
0185: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0186: 110, 1, 132 });
0187:
0188: // Enumerations
0189: public static final class JvmClassesVerboseLevelEnum {
0190: public static final int silent = 1;
0191: public static final int verbose = 2;
0192: }
0193:
0194: public static final class JvmMemoryGCVerboseLevelEnum {
0195: public static final int silent = 1;
0196: public static final int verbose = 2;
0197: }
0198:
0199: public static final class JvmMemoryGCCallEnum {
0200: public static final int unsupported = 1;
0201: public static final int supported = 2;
0202: public static final int start = 3;
0203: public static final int started = 4;
0204: public static final int failed = 5;
0205: }
0206:
0207: public static final class JvmThreadContentionMonitoringEnum {
0208: public static final int unsupported = 1;
0209: public static final int enabled = 3;
0210: public static final int disabled = 4;
0211: }
0212:
0213: public static final class JvmThreadCpuTimeMonitoringEnum {
0214: public static final int unsupported = 1;
0215: public static final int enabled = 3;
0216: public static final int disabled = 4;
0217: }
0218:
0219: public static final class JvmRTBootClassPathSupportEnum {
0220: public static final int unsupported = 1;
0221: public static final int supported = 2;
0222: }
0223:
0224: public static final class JvmJITCompilerTimeMonitoringEnum {
0225: public static final int unsupported = 1;
0226: public static final int supported = 2;
0227: }
0228:
0229: // TextualConventions
0230: private static final String TC_MODULE_SNMPV2_TC = "SNMPv2-TC";
0231: private static final String TC_MODULE_JVM_MANAGEMENT_MIB = "JVM-MANAGEMENT-MIB";
0232: private static final String TC_DISPLAYSTRING = "DisplayString";
0233: private static final String TC_JVMJAVAOBJECTNAMETC = "JvmJavaObjectNameTC";
0234: private static final String TC_JVMIMPLSUPPORTSTATETC = "JvmImplSupportStateTC";
0235: private static final String TC_JVMUNSIGNED64TC = "JvmUnsigned64TC";
0236: private static final String TC_JVMPOSITIVE32TC = "JvmPositive32TC";
0237: private static final String TC_JVMIMPLOPTFEATURESTATETC = "JvmImplOptFeatureStateTC";
0238: private static final String TC_JVMVERBOSELEVELTC = "JvmVerboseLevelTC";
0239: private static final String TC_JVMTIMEMILLIS64TC = "JvmTimeMillis64TC";
0240:
0241: // Scalars
0242: private MOScalar jvmClassesLoadedCount;
0243: private MOScalar jvmClassesTotalLoadedCount;
0244: private MOScalar jvmClassesUnloadedCount;
0245: private MOScalar jvmClassesVerboseLevel;
0246: private MOScalar jvmMemoryPendingFinalCount;
0247: private MOScalar jvmMemoryGCVerboseLevel;
0248: private MOScalar jvmMemoryGCCall;
0249: private MOScalar jvmMemoryHeapInitSize;
0250: private MOScalar jvmMemoryHeapUsed;
0251: private MOScalar jvmMemoryHeapCommitted;
0252: private MOScalar jvmMemoryHeapMaxSize;
0253: private MOScalar jvmMemoryNonHeapInitSize;
0254: private MOScalar jvmMemoryNonHeapUsed;
0255: private MOScalar jvmMemoryNonHeapCommitted;
0256: private MOScalar jvmMemoryNonHeapMaxSize;
0257: private MOScalar jvmThreadCount;
0258: private MOScalar jvmThreadDaemonCount;
0259: private MOScalar jvmThreadPeakCount;
0260: private MOScalar jvmThreadTotalStartedCount;
0261: private MOScalar jvmThreadContentionMonitoring;
0262: private MOScalar jvmThreadCpuTimeMonitoring;
0263: private MOScalar jvmThreadPeakCountReset;
0264: private MOScalar jvmRTName;
0265: private MOScalar jvmRTVMName;
0266: private MOScalar jvmRTVMVendor;
0267: private MOScalar jvmRTVMVersion;
0268: private MOScalar jvmRTSpecName;
0269: private MOScalar jvmRTSpecVendor;
0270: private MOScalar jvmRTSpecVersion;
0271: private MOScalar jvmRTManagementSpecVersion;
0272: private MOScalar jvmRTBootClassPathSupport;
0273: private MOScalar jvmRTInputArgsCount;
0274: private MOScalar jvmRTUptimeMs;
0275: private MOScalar jvmRTStartTimeMs;
0276: private MOScalar jvmJITCompilerName;
0277: private MOScalar jvmJITCompilerTimeMs;
0278: private MOScalar jvmJITCompilerTimeMonitoring;
0279: private MOScalar jvmOSName;
0280: private MOScalar jvmOSArch;
0281: private MOScalar jvmOSVersion;
0282: private MOScalar jvmOSProcessorCount;
0283:
0284: // Tables
0285: public static final OID oidJvmMemManagerEntry = new OID(new int[] {
0286: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2, 100, 1 });
0287:
0288: // Column sub-identifer defintions for jvmMemManagerEntry:
0289: public static final int colJvmMemManagerName = 2;
0290: public static final int colJvmMemManagerState = 3;
0291:
0292: // Column index defintions for jvmMemManagerEntry:
0293: public static final int idxJvmMemManagerName = 0;
0294: public static final int idxJvmMemManagerState = 1;
0295:
0296: private MOTableSubIndex[] jvmMemManagerEntryIndexes;
0297: private MOTableIndex jvmMemManagerEntryIndex;
0298:
0299: private MOTable jvmMemManagerEntry;
0300: private MOTableModel jvmMemManagerEntryModel;
0301: public static final OID oidJvmMemGCEntry = new OID(new int[] { 1,
0302: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2, 101, 1 });
0303:
0304: // Column sub-identifer defintions for jvmMemGCEntry:
0305: public static final int colJvmMemGCCount = 2;
0306: public static final int colJvmMemGCTimeMs = 3;
0307:
0308: // Column index defintions for jvmMemGCEntry:
0309: public static final int idxJvmMemGCCount = 0;
0310: public static final int idxJvmMemGCTimeMs = 1;
0311:
0312: private MOTableSubIndex[] jvmMemGCEntryIndexes;
0313: private MOTableIndex jvmMemGCEntryIndex;
0314:
0315: private MOTable jvmMemGCEntry;
0316: private MOTableModel jvmMemGCEntryModel;
0317: public static final OID oidJvmMemPoolEntry = new OID(new int[] { 1,
0318: 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2, 110, 1 });
0319:
0320: // Column sub-identifer defintions for jvmMemPoolEntry:
0321: public static final int colJvmMemPoolName = 2;
0322: public static final int colJvmMemPoolType = 3;
0323: public static final int colJvmMemPoolState = 4;
0324: public static final int colJvmMemPoolPeakReset = 5;
0325: public static final int colJvmMemPoolInitSize = 10;
0326: public static final int colJvmMemPoolUsed = 11;
0327: public static final int colJvmMemPoolCommitted = 12;
0328: public static final int colJvmMemPoolMaxSize = 13;
0329: public static final int colJvmMemPoolPeakUsed = 21;
0330: public static final int colJvmMemPoolPeakCommitted = 22;
0331: public static final int colJvmMemPoolPeakMaxSize = 23;
0332: public static final int colJvmMemPoolCollectUsed = 31;
0333: public static final int colJvmMemPoolCollectCommitted = 32;
0334: public static final int colJvmMemPoolCollectMaxSize = 33;
0335: public static final int colJvmMemPoolThreshold = 110;
0336: public static final int colJvmMemPoolThreshdCount = 111;
0337: public static final int colJvmMemPoolThreshdSupport = 112;
0338: public static final int colJvmMemPoolCollectThreshold = 131;
0339: public static final int colJvmMemPoolCollectThreshdCount = 132;
0340: public static final int colJvmMemPoolCollectThreshdSupport = 133;
0341:
0342: // Column index defintions for jvmMemPoolEntry:
0343: public static final int idxJvmMemPoolName = 0;
0344: public static final int idxJvmMemPoolType = 1;
0345: public static final int idxJvmMemPoolState = 2;
0346: public static final int idxJvmMemPoolPeakReset = 3;
0347: public static final int idxJvmMemPoolInitSize = 4;
0348: public static final int idxJvmMemPoolUsed = 5;
0349: public static final int idxJvmMemPoolCommitted = 6;
0350: public static final int idxJvmMemPoolMaxSize = 7;
0351: public static final int idxJvmMemPoolPeakUsed = 8;
0352: public static final int idxJvmMemPoolPeakCommitted = 9;
0353: public static final int idxJvmMemPoolPeakMaxSize = 10;
0354: public static final int idxJvmMemPoolCollectUsed = 11;
0355: public static final int idxJvmMemPoolCollectCommitted = 12;
0356: public static final int idxJvmMemPoolCollectMaxSize = 13;
0357: public static final int idxJvmMemPoolThreshold = 14;
0358: public static final int idxJvmMemPoolThreshdCount = 15;
0359: public static final int idxJvmMemPoolThreshdSupport = 16;
0360: public static final int idxJvmMemPoolCollectThreshold = 17;
0361: public static final int idxJvmMemPoolCollectThreshdCount = 18;
0362: public static final int idxJvmMemPoolCollectThreshdSupport = 19;
0363:
0364: private MOTableSubIndex[] jvmMemPoolEntryIndexes;
0365: private MOTableIndex jvmMemPoolEntryIndex;
0366:
0367: private MOTable jvmMemPoolEntry;
0368: private MOTableModel jvmMemPoolEntryModel;
0369: public static final OID oidJvmMemMgrPoolRelEntry = new OID(
0370: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 2,
0371: 120, 1 });
0372:
0373: // Column sub-identifer defintions for jvmMemMgrPoolRelEntry:
0374: public static final int colJvmMemMgrRelManagerName = 2;
0375: public static final int colJvmMemMgrRelPoolName = 3;
0376:
0377: // Column index defintions for jvmMemMgrPoolRelEntry:
0378: public static final int idxJvmMemMgrRelManagerName = 0;
0379: public static final int idxJvmMemMgrRelPoolName = 1;
0380:
0381: private MOTableSubIndex[] jvmMemMgrPoolRelEntryIndexes;
0382: private MOTableIndex jvmMemMgrPoolRelEntryIndex;
0383:
0384: private MOTable jvmMemMgrPoolRelEntry;
0385: private MOTableModel jvmMemMgrPoolRelEntryModel;
0386: public static final OID oidJvmThreadInstanceEntry = new OID(
0387: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 3,
0388: 10, 1 });
0389:
0390: // Column sub-identifer defintions for jvmThreadInstanceEntry:
0391: public static final int colJvmThreadInstId = 2;
0392: public static final int colJvmThreadInstState = 3;
0393: public static final int colJvmThreadInstBlockCount = 4;
0394: public static final int colJvmThreadInstBlockTimeMs = 5;
0395: public static final int colJvmThreadInstWaitCount = 6;
0396: public static final int colJvmThreadInstWaitTimeMs = 7;
0397: public static final int colJvmThreadInstCpuTimeNs = 8;
0398: public static final int colJvmThreadInstName = 9;
0399: public static final int colJvmThreadInstLockName = 10;
0400: public static final int colJvmThreadInstLockOwnerPtr = 11;
0401:
0402: // Column index defintions for jvmThreadInstanceEntry:
0403: public static final int idxJvmThreadInstId = 0;
0404: public static final int idxJvmThreadInstState = 1;
0405: public static final int idxJvmThreadInstBlockCount = 2;
0406: public static final int idxJvmThreadInstBlockTimeMs = 3;
0407: public static final int idxJvmThreadInstWaitCount = 4;
0408: public static final int idxJvmThreadInstWaitTimeMs = 5;
0409: public static final int idxJvmThreadInstCpuTimeNs = 6;
0410: public static final int idxJvmThreadInstName = 7;
0411: public static final int idxJvmThreadInstLockName = 8;
0412: public static final int idxJvmThreadInstLockOwnerPtr = 9;
0413:
0414: private MOTableSubIndex[] jvmThreadInstanceEntryIndexes;
0415: private MOTableIndex jvmThreadInstanceEntryIndex;
0416:
0417: private MOTable jvmThreadInstanceEntry;
0418: private MOTableModel jvmThreadInstanceEntryModel;
0419: public static final OID oidJvmRTInputArgsEntry = new OID(new int[] {
0420: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 20, 1 });
0421:
0422: // Column sub-identifer defintions for jvmRTInputArgsEntry:
0423: public static final int colJvmRTInputArgsItem = 2;
0424:
0425: // Column index defintions for jvmRTInputArgsEntry:
0426: public static final int idxJvmRTInputArgsItem = 0;
0427:
0428: private MOTableSubIndex[] jvmRTInputArgsEntryIndexes;
0429: private MOTableIndex jvmRTInputArgsEntryIndex;
0430:
0431: private MOTable jvmRTInputArgsEntry;
0432: private MOTableModel jvmRTInputArgsEntryModel;
0433: public static final OID oidJvmRTBootClassPathEntry = new OID(
0434: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4,
0435: 21, 1 });
0436:
0437: // Column sub-identifer defintions for jvmRTBootClassPathEntry:
0438: public static final int colJvmRTBootClassPathItem = 2;
0439:
0440: // Column index defintions for jvmRTBootClassPathEntry:
0441: public static final int idxJvmRTBootClassPathItem = 0;
0442:
0443: private MOTableSubIndex[] jvmRTBootClassPathEntryIndexes;
0444: private MOTableIndex jvmRTBootClassPathEntryIndex;
0445:
0446: private MOTable jvmRTBootClassPathEntry;
0447: private MOTableModel jvmRTBootClassPathEntryModel;
0448: public static final OID oidJvmRTClassPathEntry = new OID(new int[] {
0449: 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4, 22, 1 });
0450:
0451: // Column sub-identifer defintions for jvmRTClassPathEntry:
0452: public static final int colJvmRTClassPathItem = 2;
0453:
0454: // Column index defintions for jvmRTClassPathEntry:
0455: public static final int idxJvmRTClassPathItem = 0;
0456:
0457: private MOTableSubIndex[] jvmRTClassPathEntryIndexes;
0458: private MOTableIndex jvmRTClassPathEntryIndex;
0459:
0460: private MOTable jvmRTClassPathEntry;
0461: private MOTableModel jvmRTClassPathEntryModel;
0462: public static final OID oidJvmRTLibraryPathEntry = new OID(
0463: new int[] { 1, 3, 6, 1, 4, 1, 42, 2, 145, 3, 163, 1, 1, 4,
0464: 23, 1 });
0465:
0466: // Column sub-identifer defintions for jvmRTLibraryPathEntry:
0467: public static final int colJvmRTLibraryPathItem = 2;
0468:
0469: // Column index defintions for jvmRTLibraryPathEntry:
0470: public static final int idxJvmRTLibraryPathItem = 0;
0471:
0472: private MOTableSubIndex[] jvmRTLibraryPathEntryIndexes;
0473: private MOTableIndex jvmRTLibraryPathEntryIndex;
0474:
0475: private MOTable jvmRTLibraryPathEntry;
0476: private MOTableModel jvmRTLibraryPathEntryModel;
0477:
0478: //--AgentGen BEGIN=_MEMBERS
0479: //--AgentGen END
0480:
0481: /**
0482: * Constructs a JvmManagementMib instance without actually creating its
0483: * <code>ManagedObject</code> instances. This has to be done in a
0484: * sub-class constructor or after construction by calling
0485: * {@link #createMO(MOFactory moFactory)}.
0486: */
0487: protected JvmManagementMib() {
0488: //--AgentGen BEGIN=_DEFAULTCONSTRUCTOR
0489: //--AgentGen END
0490: }
0491:
0492: /**
0493: * Constructs a JvmManagementMib instance and actually creates its
0494: * <code>ManagedObject</code> instances using the supplied
0495: * <code>MOFactory</code> (by calling
0496: * {@link #createMO(MOFactory moFactory)}).
0497: * @param moFactory
0498: * the <code>MOFactory</code> to be used to create the
0499: * managed objects for this module.
0500: */
0501: public JvmManagementMib(MOFactory moFactory) {
0502: createMO(moFactory);
0503: //--AgentGen BEGIN=_FACTORYCONSTRUCTOR
0504: //--AgentGen END
0505: }
0506:
0507: //--AgentGen BEGIN=_CONSTRUCTORS
0508: //--AgentGen END
0509:
0510: /**
0511: * Create the ManagedObjects defined for this MIB module
0512: * using the specified {@link MOFactory}.
0513: * @param moFactory
0514: * the <code>MOFactory</code> instance to use for object
0515: * creation.
0516: */
0517: protected void createMO(MOFactory moFactory) {
0518: jvmClassesLoadedCount = moFactory
0519: .createScalar(
0520: oidJvmClassesLoadedCount,
0521: moFactory
0522: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0523: new Gauge32());
0524: jvmClassesTotalLoadedCount = moFactory
0525: .createScalar(
0526: oidJvmClassesTotalLoadedCount,
0527: moFactory
0528: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0529: new Counter64());
0530: jvmClassesUnloadedCount = moFactory
0531: .createScalar(
0532: oidJvmClassesUnloadedCount,
0533: moFactory
0534: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0535: new Counter64());
0536: jvmClassesVerboseLevel = moFactory
0537: .createScalar(
0538: oidJvmClassesVerboseLevel,
0539: moFactory
0540: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0541: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0542: TC_JVMVERBOSELEVELTC);
0543: ValueConstraint jvmClassesVerboseLevelVC = new EnumerationConstraint(
0544: new int[] { JvmClassesVerboseLevelEnum.silent,
0545: JvmClassesVerboseLevelEnum.verbose });
0546: jvmClassesVerboseLevel
0547: .addMOValueValidationListener(new ValueConstraintValidator(
0548: jvmClassesVerboseLevelVC));
0549: jvmMemoryPendingFinalCount = moFactory
0550: .createScalar(
0551: oidJvmMemoryPendingFinalCount,
0552: moFactory
0553: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0554: new Gauge32());
0555: jvmMemoryGCVerboseLevel = moFactory
0556: .createScalar(
0557: oidJvmMemoryGCVerboseLevel,
0558: moFactory
0559: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0560: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0561: TC_JVMVERBOSELEVELTC);
0562: ValueConstraint jvmMemoryGCVerboseLevelVC = new EnumerationConstraint(
0563: new int[] { JvmMemoryGCVerboseLevelEnum.silent,
0564: JvmMemoryGCVerboseLevelEnum.verbose });
0565: jvmMemoryGCVerboseLevel
0566: .addMOValueValidationListener(new ValueConstraintValidator(
0567: jvmMemoryGCVerboseLevelVC));
0568: jvmMemoryGCCall = moFactory
0569: .createScalar(
0570: oidJvmMemoryGCCall,
0571: moFactory
0572: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0573: new Integer32());
0574: ValueConstraint jvmMemoryGCCallVC = new EnumerationConstraint(
0575: new int[] { JvmMemoryGCCallEnum.unsupported,
0576: JvmMemoryGCCallEnum.supported,
0577: JvmMemoryGCCallEnum.start,
0578: JvmMemoryGCCallEnum.started,
0579: JvmMemoryGCCallEnum.failed });
0580: jvmMemoryGCCall
0581: .addMOValueValidationListener(new ValueConstraintValidator(
0582: jvmMemoryGCCallVC));
0583: jvmMemoryHeapInitSize = moFactory
0584: .createScalar(
0585: oidJvmMemoryHeapInitSize,
0586: moFactory
0587: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0588: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0589: TC_JVMUNSIGNED64TC);
0590: jvmMemoryHeapUsed = moFactory
0591: .createScalar(
0592: oidJvmMemoryHeapUsed,
0593: moFactory
0594: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0595: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0596: TC_JVMUNSIGNED64TC);
0597: jvmMemoryHeapCommitted = moFactory
0598: .createScalar(
0599: oidJvmMemoryHeapCommitted,
0600: moFactory
0601: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0602: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0603: TC_JVMUNSIGNED64TC);
0604: jvmMemoryHeapMaxSize = moFactory
0605: .createScalar(
0606: oidJvmMemoryHeapMaxSize,
0607: moFactory
0608: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0609: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0610: TC_JVMUNSIGNED64TC);
0611: jvmMemoryNonHeapInitSize = moFactory
0612: .createScalar(
0613: oidJvmMemoryNonHeapInitSize,
0614: moFactory
0615: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0616: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0617: TC_JVMUNSIGNED64TC);
0618: jvmMemoryNonHeapUsed = moFactory
0619: .createScalar(
0620: oidJvmMemoryNonHeapUsed,
0621: moFactory
0622: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0623: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0624: TC_JVMUNSIGNED64TC);
0625: jvmMemoryNonHeapCommitted = moFactory
0626: .createScalar(
0627: oidJvmMemoryNonHeapCommitted,
0628: moFactory
0629: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0630: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0631: TC_JVMUNSIGNED64TC);
0632: jvmMemoryNonHeapMaxSize = moFactory
0633: .createScalar(
0634: oidJvmMemoryNonHeapMaxSize,
0635: moFactory
0636: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0637: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0638: TC_JVMUNSIGNED64TC);
0639: jvmThreadCount = moFactory
0640: .createScalar(
0641: oidJvmThreadCount,
0642: moFactory
0643: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0644: new Gauge32());
0645: jvmThreadDaemonCount = moFactory
0646: .createScalar(
0647: oidJvmThreadDaemonCount,
0648: moFactory
0649: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0650: new Gauge32());
0651: jvmThreadPeakCount = moFactory
0652: .createScalar(
0653: oidJvmThreadPeakCount,
0654: moFactory
0655: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0656: new Counter32());
0657: jvmThreadTotalStartedCount = moFactory
0658: .createScalar(
0659: oidJvmThreadTotalStartedCount,
0660: moFactory
0661: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0662: new Counter64());
0663: jvmThreadContentionMonitoring = moFactory
0664: .createScalar(
0665: oidJvmThreadContentionMonitoring,
0666: moFactory
0667: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0668: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0669: TC_JVMIMPLOPTFEATURESTATETC);
0670: ValueConstraint jvmThreadContentionMonitoringVC = new EnumerationConstraint(
0671: new int[] {
0672: JvmThreadContentionMonitoringEnum.unsupported,
0673: JvmThreadContentionMonitoringEnum.enabled,
0674: JvmThreadContentionMonitoringEnum.disabled });
0675: jvmThreadContentionMonitoring
0676: .addMOValueValidationListener(new ValueConstraintValidator(
0677: jvmThreadContentionMonitoringVC));
0678: jvmThreadCpuTimeMonitoring = moFactory
0679: .createScalar(
0680: oidJvmThreadCpuTimeMonitoring,
0681: moFactory
0682: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0683: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0684: TC_JVMIMPLOPTFEATURESTATETC);
0685: ValueConstraint jvmThreadCpuTimeMonitoringVC = new EnumerationConstraint(
0686: new int[] { JvmThreadCpuTimeMonitoringEnum.unsupported,
0687: JvmThreadCpuTimeMonitoringEnum.enabled,
0688: JvmThreadCpuTimeMonitoringEnum.disabled });
0689: jvmThreadCpuTimeMonitoring
0690: .addMOValueValidationListener(new ValueConstraintValidator(
0691: jvmThreadCpuTimeMonitoringVC));
0692: jvmThreadPeakCountReset = moFactory
0693: .createScalar(
0694: oidJvmThreadPeakCountReset,
0695: moFactory
0696: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0697: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0698: TC_JVMTIMEMILLIS64TC);
0699: jvmRTName = moFactory.createScalar(oidJvmRTName, moFactory
0700: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0701: new OctetString(), TC_MODULE_SNMPV2_TC,
0702: TC_DISPLAYSTRING);
0703: jvmRTVMName = moFactory.createScalar(oidJvmRTVMName, moFactory
0704: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0705: new OctetString(), TC_MODULE_JVM_MANAGEMENT_MIB,
0706: TC_JVMJAVAOBJECTNAMETC);
0707: jvmRTVMVendor = moFactory
0708: .createScalar(
0709: oidJvmRTVMVendor,
0710: moFactory
0711: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0712: new OctetString(), TC_MODULE_SNMPV2_TC,
0713: TC_DISPLAYSTRING);
0714: jvmRTVMVersion = moFactory
0715: .createScalar(
0716: oidJvmRTVMVersion,
0717: moFactory
0718: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0719: new OctetString(), TC_MODULE_SNMPV2_TC,
0720: TC_DISPLAYSTRING);
0721: jvmRTSpecName = moFactory
0722: .createScalar(
0723: oidJvmRTSpecName,
0724: moFactory
0725: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0726: new OctetString(), TC_MODULE_SNMPV2_TC,
0727: TC_DISPLAYSTRING);
0728: jvmRTSpecVendor = moFactory
0729: .createScalar(
0730: oidJvmRTSpecVendor,
0731: moFactory
0732: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0733: new OctetString(), TC_MODULE_SNMPV2_TC,
0734: TC_DISPLAYSTRING);
0735: jvmRTSpecVersion = moFactory
0736: .createScalar(
0737: oidJvmRTSpecVersion,
0738: moFactory
0739: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0740: new OctetString(), TC_MODULE_SNMPV2_TC,
0741: TC_DISPLAYSTRING);
0742: jvmRTManagementSpecVersion = moFactory
0743: .createScalar(
0744: oidJvmRTManagementSpecVersion,
0745: moFactory
0746: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0747: new OctetString(), TC_MODULE_SNMPV2_TC,
0748: TC_DISPLAYSTRING);
0749: jvmRTBootClassPathSupport = moFactory
0750: .createScalar(
0751: oidJvmRTBootClassPathSupport,
0752: moFactory
0753: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0754: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0755: TC_JVMIMPLSUPPORTSTATETC);
0756: jvmRTInputArgsCount = moFactory
0757: .createScalar(
0758: oidJvmRTInputArgsCount,
0759: moFactory
0760: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0761: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0762: TC_JVMPOSITIVE32TC);
0763: jvmRTUptimeMs = moFactory
0764: .createScalar(
0765: oidJvmRTUptimeMs,
0766: moFactory
0767: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0768: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0769: TC_JVMTIMEMILLIS64TC);
0770: jvmRTStartTimeMs = moFactory
0771: .createScalar(
0772: oidJvmRTStartTimeMs,
0773: moFactory
0774: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0775: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0776: TC_JVMTIMEMILLIS64TC);
0777: jvmJITCompilerName = moFactory
0778: .createScalar(
0779: oidJvmJITCompilerName,
0780: moFactory
0781: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0782: new OctetString(),
0783: TC_MODULE_JVM_MANAGEMENT_MIB,
0784: TC_JVMJAVAOBJECTNAMETC);
0785: jvmJITCompilerTimeMs = moFactory
0786: .createScalar(
0787: oidJvmJITCompilerTimeMs,
0788: moFactory
0789: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0790: new Counter64(), TC_MODULE_JVM_MANAGEMENT_MIB,
0791: TC_JVMTIMEMILLIS64TC);
0792: jvmJITCompilerTimeMonitoring = moFactory
0793: .createScalar(
0794: oidJvmJITCompilerTimeMonitoring,
0795: moFactory
0796: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0797: new Integer32(), TC_MODULE_JVM_MANAGEMENT_MIB,
0798: TC_JVMIMPLSUPPORTSTATETC);
0799: jvmOSName = moFactory.createScalar(oidJvmOSName, moFactory
0800: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0801: new OctetString(), TC_MODULE_JVM_MANAGEMENT_MIB,
0802: TC_JVMJAVAOBJECTNAMETC);
0803: jvmOSArch = moFactory.createScalar(oidJvmOSArch, moFactory
0804: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0805: new OctetString(), TC_MODULE_SNMPV2_TC,
0806: TC_DISPLAYSTRING);
0807: jvmOSVersion = moFactory
0808: .createScalar(
0809: oidJvmOSVersion,
0810: moFactory
0811: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0812: new OctetString(), TC_MODULE_SNMPV2_TC,
0813: TC_DISPLAYSTRING);
0814: jvmOSProcessorCount = moFactory
0815: .createScalar(
0816: oidJvmOSProcessorCount,
0817: moFactory
0818: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY),
0819: new Integer32());
0820: createJvmMemManagerEntry(moFactory);
0821: createJvmMemGCEntry(moFactory);
0822: createJvmMemPoolEntry(moFactory);
0823: createJvmMemMgrPoolRelEntry(moFactory);
0824: createJvmThreadInstanceEntry(moFactory);
0825: createJvmRTInputArgsEntry(moFactory);
0826: createJvmRTBootClassPathEntry(moFactory);
0827: createJvmRTClassPathEntry(moFactory);
0828: createJvmRTLibraryPathEntry(moFactory);
0829: }
0830:
0831: public MOTable getJvmMemManagerEntry() {
0832: return jvmMemManagerEntry;
0833: }
0834:
0835: private void createJvmMemManagerEntry(MOFactory moFactory) {
0836: // Index definition
0837: jvmMemManagerEntryIndexes = new MOTableSubIndex[] { moFactory
0838: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
0839:
0840: jvmMemManagerEntryIndex = moFactory.createIndex(
0841: jvmMemManagerEntryIndexes, false,
0842: new MOTableIndexValidator() {
0843: public boolean isValidIndex(OID index) {
0844: boolean isValidIndex = true;
0845: //--AgentGen BEGIN=jvmMemManagerEntry::isValidIndex
0846: //--AgentGen END
0847: return isValidIndex;
0848: }
0849: });
0850:
0851: // Columns
0852: MOColumn[] jvmMemManagerEntryColumns = new MOColumn[2];
0853: jvmMemManagerEntryColumns[idxJvmMemManagerName] = moFactory
0854: .createColumn(
0855: colJvmMemManagerName,
0856: SMIConstants.SYNTAX_OCTET_STRING,
0857: moFactory
0858: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0859: jvmMemManagerEntryColumns[idxJvmMemManagerState] = moFactory
0860: .createColumn(
0861: colJvmMemManagerState,
0862: SMIConstants.SYNTAX_INTEGER,
0863: moFactory
0864: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0865: // Table model
0866: jvmMemManagerEntryModel = moFactory.createTableModel(
0867: oidJvmMemManagerEntry, jvmMemManagerEntryIndex,
0868: jvmMemManagerEntryColumns);
0869: jvmMemManagerEntry = moFactory.createTable(
0870: oidJvmMemManagerEntry, jvmMemManagerEntryIndex,
0871: jvmMemManagerEntryColumns, jvmMemManagerEntryModel);
0872: }
0873:
0874: public MOTable getJvmMemGCEntry() {
0875: return jvmMemGCEntry;
0876: }
0877:
0878: private void createJvmMemGCEntry(MOFactory moFactory) {
0879: // Index definition
0880: jvmMemGCEntryIndexes = new MOTableSubIndex[] { moFactory
0881: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
0882:
0883: jvmMemGCEntryIndex = moFactory.createIndex(
0884: jvmMemGCEntryIndexes, false,
0885: new MOTableIndexValidator() {
0886: public boolean isValidIndex(OID index) {
0887: boolean isValidIndex = true;
0888: //--AgentGen BEGIN=jvmMemGCEntry::isValidIndex
0889: //--AgentGen END
0890: return isValidIndex;
0891: }
0892: });
0893:
0894: // Columns
0895: MOColumn[] jvmMemGCEntryColumns = new MOColumn[2];
0896: jvmMemGCEntryColumns[idxJvmMemGCCount] = moFactory
0897: .createColumn(
0898: colJvmMemGCCount,
0899: SMIConstants.SYNTAX_COUNTER64,
0900: moFactory
0901: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0902: jvmMemGCEntryColumns[idxJvmMemGCTimeMs] = moFactory
0903: .createColumn(
0904: colJvmMemGCTimeMs,
0905: SMIConstants.SYNTAX_COUNTER64,
0906: moFactory
0907: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0908: // Table model
0909: jvmMemGCEntryModel = moFactory.createTableModel(
0910: oidJvmMemGCEntry, jvmMemGCEntryIndex,
0911: jvmMemGCEntryColumns);
0912: jvmMemGCEntry = moFactory.createTable(oidJvmMemGCEntry,
0913: jvmMemGCEntryIndex, jvmMemGCEntryColumns,
0914: jvmMemGCEntryModel);
0915: }
0916:
0917: public MOTable getJvmMemPoolEntry() {
0918: return jvmMemPoolEntry;
0919: }
0920:
0921: private void createJvmMemPoolEntry(MOFactory moFactory) {
0922: // Index definition
0923: jvmMemPoolEntryIndexes = new MOTableSubIndex[] { moFactory
0924: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
0925:
0926: jvmMemPoolEntryIndex = moFactory.createIndex(
0927: jvmMemPoolEntryIndexes, false,
0928: new MOTableIndexValidator() {
0929: public boolean isValidIndex(OID index) {
0930: boolean isValidIndex = true;
0931: //--AgentGen BEGIN=jvmMemPoolEntry::isValidIndex
0932: //--AgentGen END
0933: return isValidIndex;
0934: }
0935: });
0936:
0937: // Columns
0938: MOColumn[] jvmMemPoolEntryColumns = new MOColumn[20];
0939: jvmMemPoolEntryColumns[idxJvmMemPoolName] = moFactory
0940: .createColumn(
0941: colJvmMemPoolName,
0942: SMIConstants.SYNTAX_OCTET_STRING,
0943: moFactory
0944: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0945: jvmMemPoolEntryColumns[idxJvmMemPoolType] = moFactory
0946: .createColumn(
0947: colJvmMemPoolType,
0948: SMIConstants.SYNTAX_INTEGER,
0949: moFactory
0950: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0951: jvmMemPoolEntryColumns[idxJvmMemPoolState] = moFactory
0952: .createColumn(
0953: colJvmMemPoolState,
0954: SMIConstants.SYNTAX_INTEGER,
0955: moFactory
0956: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0957: jvmMemPoolEntryColumns[idxJvmMemPoolPeakReset] = new MOMutableColumn(
0958: colJvmMemPoolPeakReset,
0959: SMIConstants.SYNTAX_COUNTER64,
0960: moFactory
0961: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
0962: null);
0963: jvmMemPoolEntryColumns[idxJvmMemPoolInitSize] = moFactory
0964: .createColumn(
0965: colJvmMemPoolInitSize,
0966: SMIConstants.SYNTAX_COUNTER64,
0967: moFactory
0968: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0969: jvmMemPoolEntryColumns[idxJvmMemPoolUsed] = moFactory
0970: .createColumn(
0971: colJvmMemPoolUsed,
0972: SMIConstants.SYNTAX_COUNTER64,
0973: moFactory
0974: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0975: jvmMemPoolEntryColumns[idxJvmMemPoolCommitted] = moFactory
0976: .createColumn(
0977: colJvmMemPoolCommitted,
0978: SMIConstants.SYNTAX_COUNTER64,
0979: moFactory
0980: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0981: jvmMemPoolEntryColumns[idxJvmMemPoolMaxSize] = moFactory
0982: .createColumn(
0983: colJvmMemPoolMaxSize,
0984: SMIConstants.SYNTAX_COUNTER64,
0985: moFactory
0986: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0987: jvmMemPoolEntryColumns[idxJvmMemPoolPeakUsed] = moFactory
0988: .createColumn(
0989: colJvmMemPoolPeakUsed,
0990: SMIConstants.SYNTAX_COUNTER64,
0991: moFactory
0992: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0993: jvmMemPoolEntryColumns[idxJvmMemPoolPeakCommitted] = moFactory
0994: .createColumn(
0995: colJvmMemPoolPeakCommitted,
0996: SMIConstants.SYNTAX_COUNTER64,
0997: moFactory
0998: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
0999: jvmMemPoolEntryColumns[idxJvmMemPoolPeakMaxSize] = moFactory
1000: .createColumn(
1001: colJvmMemPoolPeakMaxSize,
1002: SMIConstants.SYNTAX_COUNTER64,
1003: moFactory
1004: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1005: jvmMemPoolEntryColumns[idxJvmMemPoolCollectUsed] = moFactory
1006: .createColumn(
1007: colJvmMemPoolCollectUsed,
1008: SMIConstants.SYNTAX_COUNTER64,
1009: moFactory
1010: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1011: jvmMemPoolEntryColumns[idxJvmMemPoolCollectCommitted] = moFactory
1012: .createColumn(
1013: colJvmMemPoolCollectCommitted,
1014: SMIConstants.SYNTAX_COUNTER64,
1015: moFactory
1016: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1017: jvmMemPoolEntryColumns[idxJvmMemPoolCollectMaxSize] = moFactory
1018: .createColumn(
1019: colJvmMemPoolCollectMaxSize,
1020: SMIConstants.SYNTAX_COUNTER64,
1021: moFactory
1022: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1023: jvmMemPoolEntryColumns[idxJvmMemPoolThreshold] = new MOMutableColumn(
1024: colJvmMemPoolThreshold,
1025: SMIConstants.SYNTAX_COUNTER64,
1026: moFactory
1027: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
1028: null);
1029: jvmMemPoolEntryColumns[idxJvmMemPoolThreshdCount] = moFactory
1030: .createColumn(
1031: colJvmMemPoolThreshdCount,
1032: SMIConstants.SYNTAX_COUNTER64,
1033: moFactory
1034: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1035: jvmMemPoolEntryColumns[idxJvmMemPoolThreshdSupport] = moFactory
1036: .createColumn(
1037: colJvmMemPoolThreshdSupport,
1038: SMIConstants.SYNTAX_INTEGER,
1039: moFactory
1040: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1041: jvmMemPoolEntryColumns[idxJvmMemPoolCollectThreshold] = new MOMutableColumn(
1042: colJvmMemPoolCollectThreshold,
1043: SMIConstants.SYNTAX_COUNTER64,
1044: moFactory
1045: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_WRITE),
1046: null);
1047: jvmMemPoolEntryColumns[idxJvmMemPoolCollectThreshdCount] = moFactory
1048: .createColumn(
1049: colJvmMemPoolCollectThreshdCount,
1050: SMIConstants.SYNTAX_COUNTER64,
1051: moFactory
1052: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1053: jvmMemPoolEntryColumns[idxJvmMemPoolCollectThreshdSupport] = moFactory
1054: .createColumn(
1055: colJvmMemPoolCollectThreshdSupport,
1056: SMIConstants.SYNTAX_INTEGER,
1057: moFactory
1058: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1059: // Table model
1060: jvmMemPoolEntryModel = moFactory.createTableModel(
1061: oidJvmMemPoolEntry, jvmMemPoolEntryIndex,
1062: jvmMemPoolEntryColumns);
1063: jvmMemPoolEntry = moFactory.createTable(oidJvmMemPoolEntry,
1064: jvmMemPoolEntryIndex, jvmMemPoolEntryColumns,
1065: jvmMemPoolEntryModel);
1066: }
1067:
1068: public MOTable getJvmMemMgrPoolRelEntry() {
1069: return jvmMemMgrPoolRelEntry;
1070: }
1071:
1072: private void createJvmMemMgrPoolRelEntry(MOFactory moFactory) {
1073: // Index definition
1074: jvmMemMgrPoolRelEntryIndexes = new MOTableSubIndex[] {
1075: moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER,
1076: 1, 1),
1077: moFactory.createSubIndex(SMIConstants.SYNTAX_INTEGER,
1078: 1, 1) };
1079:
1080: jvmMemMgrPoolRelEntryIndex = moFactory.createIndex(
1081: jvmMemMgrPoolRelEntryIndexes, false,
1082: new MOTableIndexValidator() {
1083: public boolean isValidIndex(OID index) {
1084: boolean isValidIndex = true;
1085: //--AgentGen BEGIN=jvmMemMgrPoolRelEntry::isValidIndex
1086: //--AgentGen END
1087: return isValidIndex;
1088: }
1089: });
1090:
1091: // Columns
1092: MOColumn[] jvmMemMgrPoolRelEntryColumns = new MOColumn[2];
1093: jvmMemMgrPoolRelEntryColumns[idxJvmMemMgrRelManagerName] = moFactory
1094: .createColumn(
1095: colJvmMemMgrRelManagerName,
1096: SMIConstants.SYNTAX_OCTET_STRING,
1097: moFactory
1098: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1099: jvmMemMgrPoolRelEntryColumns[idxJvmMemMgrRelPoolName] = moFactory
1100: .createColumn(
1101: colJvmMemMgrRelPoolName,
1102: SMIConstants.SYNTAX_OCTET_STRING,
1103: moFactory
1104: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1105: // Table model
1106: jvmMemMgrPoolRelEntryModel = moFactory.createTableModel(
1107: oidJvmMemMgrPoolRelEntry, jvmMemMgrPoolRelEntryIndex,
1108: jvmMemMgrPoolRelEntryColumns);
1109: jvmMemMgrPoolRelEntry = moFactory.createTable(
1110: oidJvmMemMgrPoolRelEntry, jvmMemMgrPoolRelEntryIndex,
1111: jvmMemMgrPoolRelEntryColumns,
1112: jvmMemMgrPoolRelEntryModel);
1113: }
1114:
1115: public MOTable getJvmThreadInstanceEntry() {
1116: return jvmThreadInstanceEntry;
1117: }
1118:
1119: private void createJvmThreadInstanceEntry(MOFactory moFactory) {
1120: // Index definition
1121: jvmThreadInstanceEntryIndexes = new MOTableSubIndex[] { moFactory
1122: .createSubIndex(SMIConstants.SYNTAX_OCTET_STRING, 8, 8) };
1123:
1124: jvmThreadInstanceEntryIndex = moFactory.createIndex(
1125: jvmThreadInstanceEntryIndexes, false,
1126: new MOTableIndexValidator() {
1127: public boolean isValidIndex(OID index) {
1128: boolean isValidIndex = true;
1129: //--AgentGen BEGIN=jvmThreadInstanceEntry::isValidIndex
1130: //--AgentGen END
1131: return isValidIndex;
1132: }
1133: });
1134:
1135: // Columns
1136: MOColumn[] jvmThreadInstanceEntryColumns = new MOColumn[10];
1137: jvmThreadInstanceEntryColumns[idxJvmThreadInstId] = moFactory
1138: .createColumn(
1139: colJvmThreadInstId,
1140: SMIConstants.SYNTAX_COUNTER64,
1141: moFactory
1142: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1143: jvmThreadInstanceEntryColumns[idxJvmThreadInstState] = moFactory
1144: .createColumn(
1145: colJvmThreadInstState,
1146: SMIConstants.SYNTAX_BITS,
1147: moFactory
1148: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1149: jvmThreadInstanceEntryColumns[idxJvmThreadInstBlockCount] = moFactory
1150: .createColumn(
1151: colJvmThreadInstBlockCount,
1152: SMIConstants.SYNTAX_COUNTER64,
1153: moFactory
1154: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1155: jvmThreadInstanceEntryColumns[idxJvmThreadInstBlockTimeMs] = moFactory
1156: .createColumn(
1157: colJvmThreadInstBlockTimeMs,
1158: SMIConstants.SYNTAX_COUNTER64,
1159: moFactory
1160: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1161: jvmThreadInstanceEntryColumns[idxJvmThreadInstWaitCount] = moFactory
1162: .createColumn(
1163: colJvmThreadInstWaitCount,
1164: SMIConstants.SYNTAX_COUNTER64,
1165: moFactory
1166: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1167: jvmThreadInstanceEntryColumns[idxJvmThreadInstWaitTimeMs] = moFactory
1168: .createColumn(
1169: colJvmThreadInstWaitTimeMs,
1170: SMIConstants.SYNTAX_COUNTER64,
1171: moFactory
1172: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1173: jvmThreadInstanceEntryColumns[idxJvmThreadInstCpuTimeNs] = moFactory
1174: .createColumn(
1175: colJvmThreadInstCpuTimeNs,
1176: SMIConstants.SYNTAX_COUNTER64,
1177: moFactory
1178: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1179: jvmThreadInstanceEntryColumns[idxJvmThreadInstName] = moFactory
1180: .createColumn(
1181: colJvmThreadInstName,
1182: SMIConstants.SYNTAX_OCTET_STRING,
1183: moFactory
1184: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1185: jvmThreadInstanceEntryColumns[idxJvmThreadInstLockName] = moFactory
1186: .createColumn(
1187: colJvmThreadInstLockName,
1188: SMIConstants.SYNTAX_OCTET_STRING,
1189: moFactory
1190: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1191: jvmThreadInstanceEntryColumns[idxJvmThreadInstLockOwnerPtr] = moFactory
1192: .createColumn(
1193: colJvmThreadInstLockOwnerPtr,
1194: SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
1195: moFactory
1196: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1197: // Table model
1198: jvmThreadInstanceEntryModel = moFactory.createTableModel(
1199: oidJvmThreadInstanceEntry, jvmThreadInstanceEntryIndex,
1200: jvmThreadInstanceEntryColumns);
1201: jvmThreadInstanceEntry = moFactory.createTable(
1202: oidJvmThreadInstanceEntry, jvmThreadInstanceEntryIndex,
1203: jvmThreadInstanceEntryColumns,
1204: jvmThreadInstanceEntryModel);
1205: }
1206:
1207: public MOTable getJvmRTInputArgsEntry() {
1208: return jvmRTInputArgsEntry;
1209: }
1210:
1211: private void createJvmRTInputArgsEntry(MOFactory moFactory) {
1212: // Index definition
1213: jvmRTInputArgsEntryIndexes = new MOTableSubIndex[] { moFactory
1214: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
1215:
1216: jvmRTInputArgsEntryIndex = moFactory.createIndex(
1217: jvmRTInputArgsEntryIndexes, false,
1218: new MOTableIndexValidator() {
1219: public boolean isValidIndex(OID index) {
1220: boolean isValidIndex = true;
1221: //--AgentGen BEGIN=jvmRTInputArgsEntry::isValidIndex
1222: //--AgentGen END
1223: return isValidIndex;
1224: }
1225: });
1226:
1227: // Columns
1228: MOColumn[] jvmRTInputArgsEntryColumns = new MOColumn[1];
1229: jvmRTInputArgsEntryColumns[idxJvmRTInputArgsItem] = moFactory
1230: .createColumn(
1231: colJvmRTInputArgsItem,
1232: SMIConstants.SYNTAX_OCTET_STRING,
1233: moFactory
1234: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1235: // Table model
1236: jvmRTInputArgsEntryModel = moFactory.createTableModel(
1237: oidJvmRTInputArgsEntry, jvmRTInputArgsEntryIndex,
1238: jvmRTInputArgsEntryColumns);
1239: jvmRTInputArgsEntry = moFactory.createTable(
1240: oidJvmRTInputArgsEntry, jvmRTInputArgsEntryIndex,
1241: jvmRTInputArgsEntryColumns, jvmRTInputArgsEntryModel);
1242: }
1243:
1244: public MOTable getJvmRTBootClassPathEntry() {
1245: return jvmRTBootClassPathEntry;
1246: }
1247:
1248: private void createJvmRTBootClassPathEntry(MOFactory moFactory) {
1249: // Index definition
1250: jvmRTBootClassPathEntryIndexes = new MOTableSubIndex[] { moFactory
1251: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
1252:
1253: jvmRTBootClassPathEntryIndex = moFactory.createIndex(
1254: jvmRTBootClassPathEntryIndexes, false,
1255: new MOTableIndexValidator() {
1256: public boolean isValidIndex(OID index) {
1257: boolean isValidIndex = true;
1258: //--AgentGen BEGIN=jvmRTBootClassPathEntry::isValidIndex
1259: //--AgentGen END
1260: return isValidIndex;
1261: }
1262: });
1263:
1264: // Columns
1265: MOColumn[] jvmRTBootClassPathEntryColumns = new MOColumn[1];
1266: jvmRTBootClassPathEntryColumns[idxJvmRTBootClassPathItem] = moFactory
1267: .createColumn(
1268: colJvmRTBootClassPathItem,
1269: SMIConstants.SYNTAX_OCTET_STRING,
1270: moFactory
1271: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1272: // Table model
1273: jvmRTBootClassPathEntryModel = moFactory.createTableModel(
1274: oidJvmRTBootClassPathEntry,
1275: jvmRTBootClassPathEntryIndex,
1276: jvmRTBootClassPathEntryColumns);
1277: jvmRTBootClassPathEntry = moFactory.createTable(
1278: oidJvmRTBootClassPathEntry,
1279: jvmRTBootClassPathEntryIndex,
1280: jvmRTBootClassPathEntryColumns,
1281: jvmRTBootClassPathEntryModel);
1282: }
1283:
1284: public MOTable getJvmRTClassPathEntry() {
1285: return jvmRTClassPathEntry;
1286: }
1287:
1288: private void createJvmRTClassPathEntry(MOFactory moFactory) {
1289: // Index definition
1290: jvmRTClassPathEntryIndexes = new MOTableSubIndex[] { moFactory
1291: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
1292:
1293: jvmRTClassPathEntryIndex = moFactory.createIndex(
1294: jvmRTClassPathEntryIndexes, false,
1295: new MOTableIndexValidator() {
1296: public boolean isValidIndex(OID index) {
1297: boolean isValidIndex = true;
1298: //--AgentGen BEGIN=jvmRTClassPathEntry::isValidIndex
1299: //--AgentGen END
1300: return isValidIndex;
1301: }
1302: });
1303:
1304: // Columns
1305: MOColumn[] jvmRTClassPathEntryColumns = new MOColumn[1];
1306: jvmRTClassPathEntryColumns[idxJvmRTClassPathItem] = moFactory
1307: .createColumn(
1308: colJvmRTClassPathItem,
1309: SMIConstants.SYNTAX_OCTET_STRING,
1310: moFactory
1311: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1312: // Table model
1313: jvmRTClassPathEntryModel = moFactory.createTableModel(
1314: oidJvmRTClassPathEntry, jvmRTClassPathEntryIndex,
1315: jvmRTClassPathEntryColumns);
1316: jvmRTClassPathEntry = moFactory.createTable(
1317: oidJvmRTClassPathEntry, jvmRTClassPathEntryIndex,
1318: jvmRTClassPathEntryColumns, jvmRTClassPathEntryModel);
1319: }
1320:
1321: public MOTable getJvmRTLibraryPathEntry() {
1322: return jvmRTLibraryPathEntry;
1323: }
1324:
1325: private void createJvmRTLibraryPathEntry(MOFactory moFactory) {
1326: // Index definition
1327: jvmRTLibraryPathEntryIndexes = new MOTableSubIndex[] { moFactory
1328: .createSubIndex(SMIConstants.SYNTAX_INTEGER, 1, 1) };
1329:
1330: jvmRTLibraryPathEntryIndex = moFactory.createIndex(
1331: jvmRTLibraryPathEntryIndexes, false,
1332: new MOTableIndexValidator() {
1333: public boolean isValidIndex(OID index) {
1334: boolean isValidIndex = true;
1335: //--AgentGen BEGIN=jvmRTLibraryPathEntry::isValidIndex
1336: //--AgentGen END
1337: return isValidIndex;
1338: }
1339: });
1340:
1341: // Columns
1342: MOColumn[] jvmRTLibraryPathEntryColumns = new MOColumn[1];
1343: jvmRTLibraryPathEntryColumns[idxJvmRTLibraryPathItem] = moFactory
1344: .createColumn(
1345: colJvmRTLibraryPathItem,
1346: SMIConstants.SYNTAX_OCTET_STRING,
1347: moFactory
1348: .createAccess(MOAccessImpl.ACCESSIBLE_FOR_READ_ONLY));
1349: // Table model
1350: jvmRTLibraryPathEntryModel = moFactory.createTableModel(
1351: oidJvmRTLibraryPathEntry, jvmRTLibraryPathEntryIndex,
1352: jvmRTLibraryPathEntryColumns);
1353: jvmRTLibraryPathEntry = moFactory.createTable(
1354: oidJvmRTLibraryPathEntry, jvmRTLibraryPathEntryIndex,
1355: jvmRTLibraryPathEntryColumns,
1356: jvmRTLibraryPathEntryModel);
1357: }
1358:
1359: public void registerMOs(MOServer server, OctetString context)
1360: throws DuplicateRegistrationException {
1361: // Scalar Objects
1362: server.register(this .jvmClassesLoadedCount, context);
1363: server.register(this .jvmClassesTotalLoadedCount, context);
1364: server.register(this .jvmClassesUnloadedCount, context);
1365: server.register(this .jvmClassesVerboseLevel, context);
1366: server.register(this .jvmMemoryPendingFinalCount, context);
1367: server.register(this .jvmMemoryGCVerboseLevel, context);
1368: server.register(this .jvmMemoryGCCall, context);
1369: server.register(this .jvmMemoryHeapInitSize, context);
1370: server.register(this .jvmMemoryHeapUsed, context);
1371: server.register(this .jvmMemoryHeapCommitted, context);
1372: server.register(this .jvmMemoryHeapMaxSize, context);
1373: server.register(this .jvmMemoryNonHeapInitSize, context);
1374: server.register(this .jvmMemoryNonHeapUsed, context);
1375: server.register(this .jvmMemoryNonHeapCommitted, context);
1376: server.register(this .jvmMemoryNonHeapMaxSize, context);
1377: server.register(this .jvmThreadCount, context);
1378: server.register(this .jvmThreadDaemonCount, context);
1379: server.register(this .jvmThreadPeakCount, context);
1380: server.register(this .jvmThreadTotalStartedCount, context);
1381: server.register(this .jvmThreadContentionMonitoring, context);
1382: server.register(this .jvmThreadCpuTimeMonitoring, context);
1383: server.register(this .jvmThreadPeakCountReset, context);
1384: server.register(this .jvmRTName, context);
1385: server.register(this .jvmRTVMName, context);
1386: server.register(this .jvmRTVMVendor, context);
1387: server.register(this .jvmRTVMVersion, context);
1388: server.register(this .jvmRTSpecName, context);
1389: server.register(this .jvmRTSpecVendor, context);
1390: server.register(this .jvmRTSpecVersion, context);
1391: server.register(this .jvmRTManagementSpecVersion, context);
1392: server.register(this .jvmRTBootClassPathSupport, context);
1393: server.register(this .jvmRTInputArgsCount, context);
1394: server.register(this .jvmRTUptimeMs, context);
1395: server.register(this .jvmRTStartTimeMs, context);
1396: server.register(this .jvmJITCompilerName, context);
1397: server.register(this .jvmJITCompilerTimeMs, context);
1398: server.register(this .jvmJITCompilerTimeMonitoring, context);
1399: server.register(this .jvmOSName, context);
1400: server.register(this .jvmOSArch, context);
1401: server.register(this .jvmOSVersion, context);
1402: server.register(this .jvmOSProcessorCount, context);
1403: server.register(this .jvmMemManagerEntry, context);
1404: server.register(this .jvmMemGCEntry, context);
1405: server.register(this .jvmMemPoolEntry, context);
1406: server.register(this .jvmMemMgrPoolRelEntry, context);
1407: server.register(this .jvmThreadInstanceEntry, context);
1408: server.register(this .jvmRTInputArgsEntry, context);
1409: server.register(this .jvmRTBootClassPathEntry, context);
1410: server.register(this .jvmRTClassPathEntry, context);
1411: server.register(this .jvmRTLibraryPathEntry, context);
1412: //--AgentGen BEGIN=_registerMOs
1413: //--AgentGen END
1414: }
1415:
1416: public void unregisterMOs(MOServer server, OctetString context) {
1417: // Scalar Objects
1418: server.unregister(this .jvmClassesLoadedCount, context);
1419: server.unregister(this .jvmClassesTotalLoadedCount, context);
1420: server.unregister(this .jvmClassesUnloadedCount, context);
1421: server.unregister(this .jvmClassesVerboseLevel, context);
1422: server.unregister(this .jvmMemoryPendingFinalCount, context);
1423: server.unregister(this .jvmMemoryGCVerboseLevel, context);
1424: server.unregister(this .jvmMemoryGCCall, context);
1425: server.unregister(this .jvmMemoryHeapInitSize, context);
1426: server.unregister(this .jvmMemoryHeapUsed, context);
1427: server.unregister(this .jvmMemoryHeapCommitted, context);
1428: server.unregister(this .jvmMemoryHeapMaxSize, context);
1429: server.unregister(this .jvmMemoryNonHeapInitSize, context);
1430: server.unregister(this .jvmMemoryNonHeapUsed, context);
1431: server.unregister(this .jvmMemoryNonHeapCommitted, context);
1432: server.unregister(this .jvmMemoryNonHeapMaxSize, context);
1433: server.unregister(this .jvmThreadCount, context);
1434: server.unregister(this .jvmThreadDaemonCount, context);
1435: server.unregister(this .jvmThreadPeakCount, context);
1436: server.unregister(this .jvmThreadTotalStartedCount, context);
1437: server.unregister(this .jvmThreadContentionMonitoring, context);
1438: server.unregister(this .jvmThreadCpuTimeMonitoring, context);
1439: server.unregister(this .jvmThreadPeakCountReset, context);
1440: server.unregister(this .jvmRTName, context);
1441: server.unregister(this .jvmRTVMName, context);
1442: server.unregister(this .jvmRTVMVendor, context);
1443: server.unregister(this .jvmRTVMVersion, context);
1444: server.unregister(this .jvmRTSpecName, context);
1445: server.unregister(this .jvmRTSpecVendor, context);
1446: server.unregister(this .jvmRTSpecVersion, context);
1447: server.unregister(this .jvmRTManagementSpecVersion, context);
1448: server.unregister(this .jvmRTBootClassPathSupport, context);
1449: server.unregister(this .jvmRTInputArgsCount, context);
1450: server.unregister(this .jvmRTUptimeMs, context);
1451: server.unregister(this .jvmRTStartTimeMs, context);
1452: server.unregister(this .jvmJITCompilerName, context);
1453: server.unregister(this .jvmJITCompilerTimeMs, context);
1454: server.unregister(this .jvmJITCompilerTimeMonitoring, context);
1455: server.unregister(this .jvmOSName, context);
1456: server.unregister(this .jvmOSArch, context);
1457: server.unregister(this .jvmOSVersion, context);
1458: server.unregister(this .jvmOSProcessorCount, context);
1459: server.unregister(this .jvmMemManagerEntry, context);
1460: server.unregister(this .jvmMemGCEntry, context);
1461: server.unregister(this .jvmMemPoolEntry, context);
1462: server.unregister(this .jvmMemMgrPoolRelEntry, context);
1463: server.unregister(this .jvmThreadInstanceEntry, context);
1464: server.unregister(this .jvmRTInputArgsEntry, context);
1465: server.unregister(this .jvmRTBootClassPathEntry, context);
1466: server.unregister(this .jvmRTClassPathEntry, context);
1467: server.unregister(this .jvmRTLibraryPathEntry, context);
1468: //--AgentGen BEGIN=_unregisterMOs
1469: //--AgentGen END
1470: }
1471:
1472: // Notifications
1473: public void jvmLowMemoryPoolUsageNotif(
1474: NotificationOriginator notificationOriginator,
1475: OctetString context, VariableBinding[] vbs) {
1476: if (vbs.length < 3) {
1477: throw new IllegalArgumentException(
1478: "Too few notification objects: " + vbs.length
1479: + "<3");
1480: }
1481: if (!(vbs[0].getOid().startsWith(oidTrapVarJvmMemPoolName))) {
1482: throw new IllegalArgumentException(
1483: "Variable 0 has wrong OID: " + vbs[0].getOid()
1484: + " does not start with "
1485: + oidTrapVarJvmMemPoolName);
1486: }
1487: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1488: .getIndexPart(vbs[0].getOid()))) {
1489: throw new IllegalArgumentException(
1490: "Illegal index for variable 0 specified: "
1491: + jvmMemPoolEntry.getIndexPart(vbs[0]
1492: .getOid()));
1493: }
1494: if (!(vbs[1].getOid().startsWith(oidTrapVarJvmMemPoolUsed))) {
1495: throw new IllegalArgumentException(
1496: "Variable 1 has wrong OID: " + vbs[1].getOid()
1497: + " does not start with "
1498: + oidTrapVarJvmMemPoolUsed);
1499: }
1500: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1501: .getIndexPart(vbs[1].getOid()))) {
1502: throw new IllegalArgumentException(
1503: "Illegal index for variable 1 specified: "
1504: + jvmMemPoolEntry.getIndexPart(vbs[1]
1505: .getOid()));
1506: }
1507: if (!(vbs[2].getOid()
1508: .startsWith(oidTrapVarJvmMemPoolThreshdCount))) {
1509: throw new IllegalArgumentException(
1510: "Variable 2 has wrong OID: " + vbs[2].getOid()
1511: + " does not start with "
1512: + oidTrapVarJvmMemPoolThreshdCount);
1513: }
1514: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1515: .getIndexPart(vbs[2].getOid()))) {
1516: throw new IllegalArgumentException(
1517: "Illegal index for variable 2 specified: "
1518: + jvmMemPoolEntry.getIndexPart(vbs[2]
1519: .getOid()));
1520: }
1521: notificationOriginator.notify(context,
1522: oidJvmLowMemoryPoolUsageNotif, vbs);
1523: }
1524:
1525: public void jvmLowMemoryPoolCollectNotif(
1526: NotificationOriginator notificationOriginator,
1527: OctetString context, VariableBinding[] vbs) {
1528: if (vbs.length < 3) {
1529: throw new IllegalArgumentException(
1530: "Too few notification objects: " + vbs.length
1531: + "<3");
1532: }
1533: if (!(vbs[0].getOid().startsWith(oidTrapVarJvmMemPoolName))) {
1534: throw new IllegalArgumentException(
1535: "Variable 0 has wrong OID: " + vbs[0].getOid()
1536: + " does not start with "
1537: + oidTrapVarJvmMemPoolName);
1538: }
1539: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1540: .getIndexPart(vbs[0].getOid()))) {
1541: throw new IllegalArgumentException(
1542: "Illegal index for variable 0 specified: "
1543: + jvmMemPoolEntry.getIndexPart(vbs[0]
1544: .getOid()));
1545: }
1546: if (!(vbs[1].getOid()
1547: .startsWith(oidTrapVarJvmMemPoolCollectUsed))) {
1548: throw new IllegalArgumentException(
1549: "Variable 1 has wrong OID: " + vbs[1].getOid()
1550: + " does not start with "
1551: + oidTrapVarJvmMemPoolCollectUsed);
1552: }
1553: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1554: .getIndexPart(vbs[1].getOid()))) {
1555: throw new IllegalArgumentException(
1556: "Illegal index for variable 1 specified: "
1557: + jvmMemPoolEntry.getIndexPart(vbs[1]
1558: .getOid()));
1559: }
1560: if (!(vbs[2].getOid()
1561: .startsWith(oidTrapVarJvmMemPoolCollectThreshdCount))) {
1562: throw new IllegalArgumentException(
1563: "Variable 2 has wrong OID: " + vbs[2].getOid()
1564: + " does not start with "
1565: + oidTrapVarJvmMemPoolCollectThreshdCount);
1566: }
1567: if (!jvmMemPoolEntryIndex.isValidIndex(jvmMemPoolEntry
1568: .getIndexPart(vbs[2].getOid()))) {
1569: throw new IllegalArgumentException(
1570: "Illegal index for variable 2 specified: "
1571: + jvmMemPoolEntry.getIndexPart(vbs[2]
1572: .getOid()));
1573: }
1574: notificationOriginator.notify(context,
1575: oidJvmLowMemoryPoolCollectNotif, vbs);
1576: }
1577:
1578: // Scalars
1579:
1580: // Value Validators
1581:
1582: // Rows and Factories
1583:
1584: //--AgentGen BEGIN=_METHODS
1585: //--AgentGen END
1586:
1587: //--AgentGen BEGIN=_CLASSES
1588: //--AgentGen END
1589:
1590: //--AgentGen BEGIN=_END
1591: //--AgentGen END
1592: }
|