Back to index...

	/*
	* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package sun.management.snmp.jvminstr;


	// java imports
	//
	import java.io.Serializable;
	import java.util.List;
	import java.util.Map;
	import java.util.TreeMap;

	// jmx imports
	//
	import com.sun.jmx.snmp.SnmpOid;
	import com.sun.jmx.snmp.SnmpStatusException;

	// jdmk imports
	//
	import com.sun.jmx.snmp.agent.SnmpMib;
	import com.sun.jmx.snmp.agent.SnmpStandardObjectServer;

	import java.lang.management.MemoryManagerMXBean;
	import java.lang.management.GarbageCollectorMXBean;
	import java.lang.management.ManagementFactory;

	import sun.management.snmp.jvmmib.JvmMemGCTableMeta;
	import sun.management.snmp.util.SnmpCachedData;
	import sun.management.snmp.util.SnmpTableCache;
	import sun.management.snmp.util.SnmpTableHandler;
	import sun.management.snmp.util.MibLogger;
	import sun.management.snmp.util.JvmContextFactory;

	/**
	* The class is used for implementing the "JvmMemGCTable" table.
	*/
	public class JvmMemGCTableMetaImpl extends JvmMemGCTableMeta {

	static final long serialVersionUID = 8250461197108867607L;

	/**
	* This class acts as a filter over the SnmpTableHandler
	* used for the JvmMemoryManagerTable. It filters out
	* (skip) all MemoryManagerMXBean that are not instances of
	* GarbageCollectorMXBean so that only Garbage Collectors are
	* seen. This is a better solution than relying on
	* ManagementFactory.getGarbageCollectorMXBeans() because it makes it
	* possible to guarantee the consistency betwen the MemoryManager table
	* and the GCTable since both will be sharing the same cache.
	**/
	protected static class GCTableFilter {

	/**
	* Returns the index that immediately follows the given
	* <var>index</var>. The returned index is strictly greater
	* than the given <var>index</var>, and is contained in the table.
	* <br>If the given <var>index</var> is null, returns the first
	* index in the table.
	* <br>If there are no index after the given <var>index</var>,
	* returns null.
	* This method is an optimization for the case where the
	* SnmpTableHandler is in fact an instance of SnmpCachedData.
	**/
	public SnmpOid getNext(SnmpCachedData datas, SnmpOid index) {

	final boolean dbg = log.isDebugOn();

	// We're going to loop until we find an instance of
	// GarbageCollectorMXBean. First we attempt to find
	// the next element whose OID follows the given index.
	// If `index' is null, the insertion point is -1
	// (the next is 0 = -insertion - 1)
	//
	final int insertion = (index==null)?-1:datas.find(index);
	if (dbg) log.debug("GCTableFilter","oid="+index+
	" at insertion="+insertion);

	int next;
	if (insertion > -1) next = insertion+1;
	else next = -insertion -1;

	// Now `next' points to the element that imediately
	// follows the given `index'. We're going to loop
	// through the table, starting at `next' (included),
	// and return the first element which is an instance
	// of GarbageCollectorMXBean.
	//
	for (;next<datas.indexes.length;next++) {
	if (dbg) log.debug("GCTableFilter","next="+next);
	final Object value = datas.datas[next];
	if (dbg) log.debug("GCTableFilter","value["+next+"]=" +
	((MemoryManagerMXBean)value).getName());
	if (value instanceof GarbageCollectorMXBean) {
	// That's the next: return it.
	if (dbg) log.debug("GCTableFilter",
	((MemoryManagerMXBean)value).getName() +
	" is a GarbageCollectorMXBean.");
	return datas.indexes[next];
	}
	if (dbg) log.debug("GCTableFilter",
	((MemoryManagerMXBean)value).getName() +
	" is not a GarbageCollectorMXBean: " +
	value.getClass().getName());
	// skip to next index...
	}
	return null;
	}

	/**
	* Returns the index that immediately follows the given
	* <var>index</var>. The returned index is strictly greater
	* than the given <var>index</var>, and is contained in the table.
	* <br>If the given <var>index</var> is null, returns the first
	* index in the table.
	* <br>If there are no index after the given <var>index</var>,
	* returns null.
	**/
	public SnmpOid getNext(SnmpTableHandler handler, SnmpOid index) {

	// try to call the optimized method
	if (handler instanceof SnmpCachedData)
	return getNext((SnmpCachedData)handler, index);

	// too bad - revert to non-optimized generic algorithm
	SnmpOid next = index;
	do {
	next = handler.getNext(next);
	final Object value = handler.getData(next);
	if (value instanceof GarbageCollectorMXBean)
	// That's the next! return it
	return next;
	// skip to next index...
	} while (next != null);
	return null;
	}

	/**
	* Returns the data associated with the given index.
	* If the given index is not found, null is returned.
	* Note that returning null does not necessarily means that
	* the index was not found.
	**/
	public Object getData(SnmpTableHandler handler, SnmpOid index) {
	final Object value = handler.getData(index);
	if (value instanceof GarbageCollectorMXBean) return value;
	// Behaves as if there was nothing at this index...
	//
	return null;
	}

	/**
	* Returns true if the given <var>index</var> is present.
	**/
	public boolean contains(SnmpTableHandler handler, SnmpOid index) {
	if (handler.getData(index) instanceof GarbageCollectorMXBean)
	return true;
	// Behaves as if there was nothing at this index...
	//
	return false;
	}
	}


	private transient JvmMemManagerTableMetaImpl managers = null;
	private static GCTableFilter filter = new GCTableFilter();


	/**
	* Constructor for the table. Initialize metadata for "JvmMemGCTableMeta".
	*/
	public JvmMemGCTableMetaImpl(SnmpMib myMib,
	SnmpStandardObjectServer objserv) {
	super(myMib,objserv);
	}

	// Returns a pointer to the JvmMemManager meta node - we're going
	// to reuse its SnmpTableHandler by filtering out all that is
	// not a GarbageCollectorMXBean.
	private final JvmMemManagerTableMetaImpl getManagers(SnmpMib mib) {
	if (managers == null) {
	managers = (JvmMemManagerTableMetaImpl)
	mib.getRegisteredTableMeta("JvmMemManagerTable");
	}
	return managers;
	}

	/**
	* Returns the JvmMemManagerTable SnmpTableHandler
	**/
	protected SnmpTableHandler getHandler(Object userData) {
	JvmMemManagerTableMetaImpl managerTable= getManagers(theMib);
	return managerTable.getHandler(userData);
	}

	// See com.sun.jmx.snmp.agent.SnmpMibTable
	protected SnmpOid getNextOid(Object userData)
	throws SnmpStatusException {
	// null means get the first OID.
	return getNextOid(null,userData);
	}

	// See com.sun.jmx.snmp.agent.SnmpMibTable
	protected SnmpOid getNextOid(SnmpOid oid, Object userData)
	throws SnmpStatusException {
	final boolean dbg = log.isDebugOn();
	try {
	if (dbg) log.debug("getNextOid", "previous=" + oid);

	// Get the data handler.
	//
	SnmpTableHandler handler = getHandler(userData);
	if (handler == null) {
	// This should never happen.
	// If we get here it's a bug.
	//
	if (dbg) log.debug("getNextOid", "handler is null!");
	throw new
	SnmpStatusException(SnmpStatusException.noSuchInstance);
	}


	// Get the next oid, using the GC filter.
	//
	final SnmpOid next = filter.getNext(handler,oid);
	if (dbg) log.debug("getNextOid", "next=" + next);

	// if next is null: we reached the end of the table.
	//
	if (next == null)
	throw new
	SnmpStatusException(SnmpStatusException.noSuchInstance);

	return next;
	} catch (RuntimeException x) {
	// debug. This should never happen.
	//
	if (dbg) log.debug("getNextOid",x);
	throw x;
	}
	}


	// See com.sun.jmx.snmp.agent.SnmpMibTable
	protected boolean contains(SnmpOid oid, Object userData) {
	// Get the handler.
	//
	SnmpTableHandler handler = getHandler(userData);

	// handler should never be null.
	//
	if (handler == null)
	return false;
	return filter.contains(handler,oid);
	}

	// See com.sun.jmx.snmp.agent.SnmpMibTable
	public Object getEntry(SnmpOid oid)
	throws SnmpStatusException {

	if (oid == null)
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);

	// Get the request contextual cache (userData).
	//
	final Map<Object, Object> m = JvmContextFactory.getUserData();

	// First look in the request contextual cache: maybe we've already
	// created this entry...
	//

	// We know in the case of this table that the index is an integer,
	// it is thus the first OID arc of the index OID.
	//
	final long index = oid.getOidArc(0);

	// We're going to use this name to store/retrieve the entry in
	// the request contextual cache.
	//
	// Revisit: Probably better programming to put all these strings
	// in some interface.
	//
	final String entryTag = ((m==null)?null:("JvmMemGCTable.entry." +
	index));

	// If the entry is in the cache, simply return it.
	//
	if (m != null) {
	final Object entry = m.get(entryTag);
	if (entry != null) return entry;
	}

	// Entry was not in request cache. Make a new one.
	//
	// Get the data hanler.
	//
	SnmpTableHandler handler = getHandler(m);

	// handler should never be null.
	//
	if (handler == null)
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);

	// Use the filter to retrieve only GarabageCollectorMBean data.
	//
	final Object data = filter.getData(handler,oid);

	// data may be null if the OID we were given is not valid.
	// (e.g. it identifies a MemoryManager which is not a
	// GarbageCollector)
	//
	if (data == null)
	throw new SnmpStatusException(SnmpStatusException.noSuchInstance);

	// Make a new entryy (transient object that will be kept only
	// for the duration of the request.
	//
	final Object entry =
	new JvmMemGCEntryImpl((GarbageCollectorMXBean)data,(int)index);

	// Put the entry in the request cache in case we need it later
	// in the processing of the request. Note that we could have
	// optimized this by making JvmMemGCEntryImpl extend
	// JvmMemManagerEntryImpl, and then make sure that
	// JvmMemManagerTableMetaImpl creates an instance of JvmMemGCEntryImpl
	// instead of JvmMemManagerEntryImpl when the associated data is
	// an instance of GarbageCollectorMXBean. This would have made it
	// possible to share the transient entry object.
	// As it is, we may have two transient objects that points to
	// the same underlying MemoryManagerMXBean (which is definitely
	// not a problem - but is only a small dysatisfaction)
	//
	if (m != null && entry != null) {
	m.put(entryTag,entry);
	}

	return entry;
	}

	static final MibLogger log = new MibLogger(JvmMemGCTableMetaImpl.class);
	}

Back to index...