/* * 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);}