Java example source code file (README)
The README Java example source code#==============================================================================
# JVM Management MIB - Instrumentation Classes
#==============================================================================
In this directory:
------------------
README: this file
commands.env: a file containing some ksh variables & functions
that I have used to generate & compile all the
stuff. Probably only valid in my own environment.
logging.properties: logging.properties file that can be used to obtain
trace information.
*.java: utility and custom classes for the JVM Management MIB.
These classes show how to provide instrumentation for
a mibgen generated MIB, how to simulate virtual tables,
and how to make use of the SnmpUserDataFactory.
Only the jvmMemory group and its tables are instrumented.
Dependency
----------
jvmManagementMib.txt : the JVM Management MIB module in compilable form.
Tiger SNMP Runtime : SNMP Runtime classes for Tiger. We assume these
classes could be part of the JMX delivery
(classes in com.sun.jmx.snmp.*)
JDMK 5.1 : The jdmktk.jar contains the com.sun.jdmk.tools.MibGen class
used to compile the MIB. JDMK also has a mibgen.sh script
to start mibgen. By default mibgen generates code that can
integrate with JDMK SNMP runtime. In order to generate
code that integrate with Tiger SNMP runtime, you need to
start mibgen with a non-default resource file.
JDMK 5.1 workspace contains a mibgen resource file
specific for tiger: mibgen.property.tiger
Custom Instrumentation Code: the files in this directory.
How to proceed:
---------------
Get mibgen from JDMK 5.1. Start mibgen with mibgen resource file for
tiger (add -Dcom.sun.jdmk.tools.mibgen.config.file=<mibgen.properties.tiger>)
on the Java command line.
Use mibgen to generate code for the jvmManagementMib.txt file. Note that
the custom classes provided in this directory are all in the
sun.management.snmp.jvminstr package, and expect the generated classes to
be in another sun.management.snmp.jvmmib package (use mibgen option
-tp sun.management.snmp.jvmmib)
If this package name does not suit you, simply change it to something else,
both in the custom classes below (you might use 'sed' or do it manually)
and in the -tp option that you will pass to mibgen.
It is recommended to generate all classes in a different directory (if
you read command.env you will see that I have put the custom classes
in a "custom" directory, and the generated classes in a "parsed"
directory. This makes it easier to cleanup the mib. You can safely
do a rm -rf <parsed> and call mibgen again.
Then compile the generated classes - you will need JMX and Tiger SNMP
runtime classes in your classpath - if you compile with a tiger build that
already have them then you don't need to specify anything special.
Then make your classpath point to the compiled generated classes, and
compile the custom code in this directory.
Then you can use the SnmpDaemonTest class to start a JVM with the
intsrumented MIB, and you can use e.g. the easymanager contrib of
JDMK to view the MIB through SNMP.
#==============================================================================
# Classes Details
#==============================================================================
Utility Classes developped for the JVM Management MIB:
------------------------------------------------------
JvmContextFactory.java : The context factory allocates a Map that
serves as request contextual cache.
Values obtained from JSR 163 API can be
cached in this object.
A request contextual cache is allocated
each time a request is being processed,
and is released at the end of processing.
Object: 1) preserve atomicity
2) minimize API calls
3) ensure consistency of the
various pieces of data returned.
MibLogger.java : Send traces to java.util.logging
SnmpTableHandler.java : an interface used to access table data.
SnmpCachedData.java : This object can be use to cache a snapshot
of the data contained in a table.
SnmpTableCache.java : A weak cache for table data. The data is
computed on demand and cached in a
weakreference. Makes it possible to specify
a validity period for the cache data.
SnmpListTableCache.java : Extends SnmpTableCache - for tables whose
data is returned in a List object.
SnmpNamedListTableCache.java : Extends SnmpListTableCache - for tables whose
elements can be named by a unique string.
SnmpDaemonTest.java : A dummy standalone SNMP agent that registers
the JVM Managemnt MIB in Tiger's SNMP
adaptor. This is the "main". Note that
this not the class that will be used to
start the adaptor in the final Tiger - it is
just a dummy test main.
JVM Management MIB
------------------
JVM_MANAGEMENT_MIB_IMPL.java : subclasses the generated JVM_MANAGEMENT_MIB
class.
Object: overriding factory method in order
to instantiate custom code instead
of generated code.
JVM Memory Group
----------------
JvmMemoryImpl.java : Provides instrumentation for the jvmMemory
group. Replaces the generated JvmMemory class,
which is not used and can be thrown away.
Implements the generated JvmMemoryMBean
interface (which was also implemented by
the generated JvmMemory skeleton class)
Use the request contextual cache
in order to ensure consistency when
returning MemoryUsage datas. Note that all
tables in this group have been implemented
as virtual tables. As a consequence, the
generated TableJvmMemXXXXXTable.java classes
are not needed.
JvmMemoryMetaImpl.java : Custom MetaData class for the jvmMemory group.
Subclasses the generated JvmMemoryMeta class.
Object: overrides the factory methods in order
to instantiate custom meta data classes
for the jvmMemManagerTable,
jvmMemGCTable,
jvmMemPoolTable,
jvmMemMgrPoolRelTable.
JVM Memory Manager Table
------------------------
JvmMemManagerTableMetaImpl.java : Custom MetaData class for the
jvmMemManagerTable. This MetaData traps
all the SNMP Runtime calls made to the
table - in order to make the Memory Manager
table virtual: i.e. the table does not have
to be maintained permanently in memory.
Instead, the table is computed "on demand",
and the data is cached in a weak cache
(see SnmpNamedListTableCache) which remains
valid for a few ms. If the data is found
to be obsolete, or was garbage collected,
the table is recomputed.
JvmMemManagerEntryImpl.java : Custom Entry class for jvmMemManagerTable.
Entries are created on the fly when it
becomes necessary to get data from a
Memory Managers. They are temporary objects
that wrap the MemoryManager just for the
call duration - and are released just after.
JVM Memory GC Table
-------------------
JvmMemGCTableMetaImpl.java : Custom MetaData class for the
jvmMemGCTable. This MetaData traps
all the SNMP Runtime calls made to the
table - in order to make the GC
table virtual: the GC table reuses the
cached data computed for the
jvmMemManagerTable - simply acting as a
filter that only shows those elements that
are instance of GarbageCollectorMetrics.
In other words it implements a fitered view
of the jvmMemManagerTable.
JvmMemGCEntryImpl.java : Provide access to the data specific to
GarbageCollectorMetrics objects. Objects
of this classes are created on the fly,
when data needs to be returned from a
GarbageCollectorMetrics object, and are
released just after. They are not kept in
memory.
JVM Memory Pool Table
---------------------
JvmMemPoolTableMetaImpl.java : Custom MetaData class for the jvmMemPoolTable.
This is quite similar to what was done for
the jvmMemManagerTable in
JvmMemManagerTableMetaImpl. Most of the code
here was obtain by cut&paste-ing from
JvmMemManagerTableMetaImpl and replacing
"Manager" with "Pool".
JvmMemPoolEntryImpl.java : Provide access to the data specific to
MemoryPoolMetrics objects. Objects
of this classes are created on the fly,
when data needs to be returned from a
MemoryPoolMetrics object, and are
released just after. They are not kept in
memory. Use the request contextual cache
in order to ensure consistency when
returning MemoryUsage datas.
JVM Memory Manager / Memory Pool Relation Table
------------------------------------------------
JvmMemMgrPoolRelTableMetaImpl.java : Custom MetaData class for the
jvmMemMgrPoolRelTable. This meta data
uses the JvmMemManagerTableMetaImpl and
JvmMemPoolTableMetaImpl in order to
find out the content of the
jvmMemManagerTable and the mapping between
Memory Pool Name and Memory Pool Index.
For each element of the jvmMemManagerTable
it calls the JSR 163 APIs to find the
related Memory Pool, then finds out their
index, and then creates the corresponding
row in the jvmMemMgrPoolRelTable cached data.
Like all the other tables, this table is
virtual: the data is kept on a weak cache
and recomputed on demand, if its validity
as expired or if it has been gc'ed.
JvmMemMgrPoolRelEntryImpl.java : A simple couple MemoryManager/MemoryPool.
Models a row in the jvmMemMgrPoolRelTable.
Objects of this type are cached in the
jvmMemMgrPoolRelTable cached data.
#==============================================================================
#==============================================================================
Other Java examples (source code examples)Here is a short list of links related to this Java README source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
