Back to index...

	/*
	* Copyright (c) 2003, 2004, 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.lang.management.ThreadMXBean;
	import java.lang.management.ManagementFactory;

	// jmx imports
	//
	import javax.management.MBeanServer;
	import com.sun.jmx.snmp.SnmpString;
	import com.sun.jmx.snmp.SnmpStatusException;

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

	import sun.management.snmp.jvmmib.JvmThreadingMBean;
	import sun.management.snmp.jvmmib.EnumJvmThreadCpuTimeMonitoring;
	import sun.management.snmp.jvmmib.EnumJvmThreadContentionMonitoring;
	import sun.management.snmp.util.MibLogger;

	/**
	* The class is used for implementing the "JvmThreading" group.
	*/
	public class JvmThreadingImpl implements JvmThreadingMBean {

	/**
	* Variable for storing the value of "JvmThreadCpuTimeMonitoring".
	*
	* "The state of the Thread CPU Time Monitoring feature.
	* This feature can be:
	*
	* unsupported: The JVM does not support Thread CPU Time Monitoring.
	* enabled : The JVM supports Thread CPU Time Monitoring, and it
	* is enabled.
	* disabled : The JVM supports Thread CPU Time Monitoring, and it
	* is disabled.
	*
	* Only enabled(3) and disabled(4) may be supplied as values to a
	* SET request. unsupported(1) can only be set internally by the
	* agent.
	*
	* See java.lang.management.ThreadMXBean.isThreadCpuTimeSupported(),
	* java.lang.management.ThreadMXBean.isThreadCpuTimeEnabled(),
	* java.lang.management.ThreadMXBean.setThreadCpuTimeEnabled()
	* "
	*
	*/
	final static EnumJvmThreadCpuTimeMonitoring
	JvmThreadCpuTimeMonitoringUnsupported =
	new EnumJvmThreadCpuTimeMonitoring("unsupported");
	final static EnumJvmThreadCpuTimeMonitoring
	JvmThreadCpuTimeMonitoringEnabled =
	new EnumJvmThreadCpuTimeMonitoring("enabled");
	final static EnumJvmThreadCpuTimeMonitoring
	JvmThreadCpuTimeMonitoringDisabled =
	new EnumJvmThreadCpuTimeMonitoring("disabled");


	/**
	* Variable for storing the value of "JvmThreadContentionMonitoring".
	*
	* "The state of the Thread Contention Monitoring feature.
	* This feature can be:
	*
	* unsupported: The JVM does not support Thread Contention Monitoring.
	* enabled : The JVM supports Thread Contention Monitoring, and it
	* is enabled.
	* disabled : The JVM supports Thread Contention Monitoring, and it
	* is disabled.
	*
	* Only enabled(3) and disabled(4) may be supplied as values to a
	* SET request. unsupported(1) can only be set internally by the
	* agent.
	*
	* See java.lang.management.ThreadMXBean.isThreadContentionMonitoringSupported(),
	* java.lang.management.ThreadMXBean.isThreadContentionMonitoringEnabled(),
	* java.lang.management.ThreadMXBean.setThreadContentionMonitoringEnabled()
	* "
	*
	*/
	static final EnumJvmThreadContentionMonitoring
	JvmThreadContentionMonitoringUnsupported =
	new EnumJvmThreadContentionMonitoring("unsupported");
	static final EnumJvmThreadContentionMonitoring
	JvmThreadContentionMonitoringEnabled =
	new EnumJvmThreadContentionMonitoring("enabled");
	static final EnumJvmThreadContentionMonitoring
	JvmThreadContentionMonitoringDisabled =
	new EnumJvmThreadContentionMonitoring("disabled");

	/**
	* Constructor for the "JvmThreading" group.
	* If the group contains a table, the entries created through an SNMP SET
	* will not be registered in Java DMK.
	*/
	public JvmThreadingImpl(SnmpMib myMib) {
	log.debug("JvmThreadingImpl","Constructor");
	}


	/**
	* Constructor for the "JvmThreading" group.
	* If the group contains a table, the entries created through an SNMP SET
	* will be AUTOMATICALLY REGISTERED in Java DMK.
	*/
	public JvmThreadingImpl(SnmpMib myMib, MBeanServer server) {
	log.debug("JvmThreadingImpl","Constructor with server");
	}

	/**
	* ThreadMXBean accessor. It is acquired from the
	* java.lang.management.ManagementFactory
	* @return The local ThreadMXBean.
	*/
	static ThreadMXBean getThreadMXBean() {
	return ManagementFactory.getThreadMXBean();
	}

	/**
	* Getter for the "JvmThreadCpuTimeMonitoring" variable.
	*/
	public EnumJvmThreadCpuTimeMonitoring getJvmThreadCpuTimeMonitoring()
	throws SnmpStatusException {

	ThreadMXBean mbean = getThreadMXBean();

	if(!mbean.isThreadCpuTimeSupported()) {
	log.debug("getJvmThreadCpuTimeMonitoring",
	"Unsupported ThreadCpuTimeMonitoring");
	return JvmThreadCpuTimeMonitoringUnsupported;
	}

	try {
	if(mbean.isThreadCpuTimeEnabled()) {
	log.debug("getJvmThreadCpuTimeMonitoring",
	"Enabled ThreadCpuTimeMonitoring");
	return JvmThreadCpuTimeMonitoringEnabled;
	} else {
	log.debug("getJvmThreadCpuTimeMonitoring",
	"Disabled ThreadCpuTimeMonitoring");
	return JvmThreadCpuTimeMonitoringDisabled;
	}
	}catch(UnsupportedOperationException e) {
	log.debug("getJvmThreadCpuTimeMonitoring",
	"Newly unsupported ThreadCpuTimeMonitoring");

	return JvmThreadCpuTimeMonitoringUnsupported;
	}
	}

	/**
	* Setter for the "JvmThreadCpuTimeMonitoring" variable.
	*/
	public void setJvmThreadCpuTimeMonitoring(EnumJvmThreadCpuTimeMonitoring x)
	throws SnmpStatusException {

	ThreadMXBean mbean = getThreadMXBean();

	// We can trust the received value, it has been checked in
	// checkJvmThreadCpuTimeMonitoring
	if(JvmThreadCpuTimeMonitoringEnabled.intValue() == x.intValue())
	mbean.setThreadCpuTimeEnabled(true);
	else
	mbean.setThreadCpuTimeEnabled(false);
	}

	/**
	* Checker for the "JvmThreadCpuTimeMonitoring" variable.
	*/
	public void checkJvmThreadCpuTimeMonitoring(EnumJvmThreadCpuTimeMonitoring
	x)
	throws SnmpStatusException {

	//Can't be set externaly to unsupported state.
	if(JvmThreadCpuTimeMonitoringUnsupported.intValue() == x.intValue()) {
	log.debug("checkJvmThreadCpuTimeMonitoring",
	"Try to set to illegal unsupported value");
	throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
	}

	if ((JvmThreadCpuTimeMonitoringEnabled.intValue() == x.intValue()) \|\|
	(JvmThreadCpuTimeMonitoringDisabled.intValue() == x.intValue())) {

	// The value is a valid value. But is the feature supported?
	ThreadMXBean mbean = getThreadMXBean();
	if(mbean.isThreadCpuTimeSupported()) return;

	// Not supported.
	log.debug("checkJvmThreadCpuTimeMonitoring",
	"Unsupported operation, can't set state");
	throw new
	SnmpStatusException(SnmpDefinitions.snmpRspInconsistentValue);
	}

	// Unknown value.
	log.debug("checkJvmThreadCpuTimeMonitoring",
	"unknown enum value ");
	throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
	}

	/**
	* Getter for the "JvmThreadContentionMonitoring" variable.
	*/
	public EnumJvmThreadContentionMonitoring getJvmThreadContentionMonitoring()
	throws SnmpStatusException {

	ThreadMXBean mbean = getThreadMXBean();

	if(!mbean.isThreadContentionMonitoringSupported()) {
	log.debug("getJvmThreadContentionMonitoring",
	"Unsupported ThreadContentionMonitoring");
	return JvmThreadContentionMonitoringUnsupported;
	}

	if(mbean.isThreadContentionMonitoringEnabled()) {
	log.debug("getJvmThreadContentionMonitoring",
	"Enabled ThreadContentionMonitoring");
	return JvmThreadContentionMonitoringEnabled;
	} else {
	log.debug("getJvmThreadContentionMonitoring",
	"Disabled ThreadContentionMonitoring");
	return JvmThreadContentionMonitoringDisabled;
	}
	}

	/**
	* Setter for the "JvmThreadContentionMonitoring" variable.
	*/
	public void setJvmThreadContentionMonitoring(
	EnumJvmThreadContentionMonitoring x)
	throws SnmpStatusException {
	ThreadMXBean mbean = getThreadMXBean();

	// We can trust the received value, it has been checked in
	// checkJvmThreadContentionMonitoring
	if(JvmThreadContentionMonitoringEnabled.intValue() == x.intValue())
	mbean.setThreadContentionMonitoringEnabled(true);
	else
	mbean.setThreadContentionMonitoringEnabled(false);
	}

	/**
	* Checker for the "JvmThreadContentionMonitoring" variable.
	*/
	public void checkJvmThreadContentionMonitoring(
	EnumJvmThreadContentionMonitoring x)
	throws SnmpStatusException {
	//Can't be set externaly to unsupported state.
	if(JvmThreadContentionMonitoringUnsupported.intValue()==x.intValue()) {
	log.debug("checkJvmThreadContentionMonitoring",
	"Try to set to illegal unsupported value");
	throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
	}

	if ((JvmThreadContentionMonitoringEnabled.intValue()==x.intValue()) \|\|
	(JvmThreadContentionMonitoringDisabled.intValue()==x.intValue())) {

	// The value is valid, but is the feature supported ?
	ThreadMXBean mbean = getThreadMXBean();
	if(mbean.isThreadContentionMonitoringSupported()) return;

	log.debug("checkJvmThreadContentionMonitoring",
	"Unsupported operation, can't set state");
	throw new
	SnmpStatusException(SnmpDefinitions.snmpRspInconsistentValue);
	}

	log.debug("checkJvmThreadContentionMonitoring",
	"Try to set to unknown value");
	throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
	}

	/**
	* Getter for the "JvmThreadTotalStartedCount" variable.
	*/
	public Long getJvmThreadTotalStartedCount() throws SnmpStatusException {
	return new Long(getThreadMXBean().getTotalStartedThreadCount());
	}

	/**
	* Getter for the "JvmThreadPeakCount" variable.
	*/
	public Long getJvmThreadPeakCount() throws SnmpStatusException {
	return new Long(getThreadMXBean().getPeakThreadCount());
	}

	/**
	* Getter for the "JvmThreadDaemonCount" variable.
	*/
	public Long getJvmThreadDaemonCount() throws SnmpStatusException {
	return new Long(getThreadMXBean().getDaemonThreadCount());
	}

	/**
	* Getter for the "JvmThreadCount" variable.
	*/
	public Long getJvmThreadCount() throws SnmpStatusException {
	return new Long(getThreadMXBean().getThreadCount());
	}

	/**
	* Getter for the "JvmThreadPeakCountReset" variable.
	*/
	public synchronized Long getJvmThreadPeakCountReset()
	throws SnmpStatusException {
	return new Long(jvmThreadPeakCountReset);
	}

	/**
	* Setter for the "JvmThreadPeakCountReset" variable.
	*/
	public synchronized void setJvmThreadPeakCountReset(Long x)
	throws SnmpStatusException {
	final long l = x.longValue();
	if (l > jvmThreadPeakCountReset) {
	final long stamp = System.currentTimeMillis();
	getThreadMXBean().resetPeakThreadCount();
	jvmThreadPeakCountReset = stamp;
	log.debug("setJvmThreadPeakCountReset",
	"jvmThreadPeakCountReset="+stamp);
	}
	}

	/**
	* Checker for the "JvmThreadPeakCountReset" variable.
	*/
	public void checkJvmThreadPeakCountReset(Long x)
	throws SnmpStatusException {
	}

	/* Last time thread peak count was reset */
	private long jvmThreadPeakCountReset=0;

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

Back to index...