/*

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

}