1 /*

     2  * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package sun.management.snmp.jvminstr;

    26 

    27 // java imports

    28 //

    29 import java.io.Serializable;

    30 

    31 import java.lang.management.ThreadMXBean;

    32 import java.lang.management.ManagementFactory;

    33 

    34 // jmx imports

    35 //

    36 import javax.management.MBeanServer;

    37 import com.sun.jmx.snmp.SnmpString;

    38 import com.sun.jmx.snmp.SnmpStatusException;

    39 

    40 // jdmk imports

    41 //

    42 import com.sun.jmx.snmp.agent.SnmpMib;

    43 import com.sun.jmx.snmp.SnmpDefinitions;

    44 

    45 import sun.management.snmp.jvmmib.JvmThreadingMBean;

    46 import sun.management.snmp.jvmmib.EnumJvmThreadCpuTimeMonitoring;

    47 import sun.management.snmp.jvmmib.EnumJvmThreadContentionMonitoring;

    48 import sun.management.snmp.util.MibLogger;

    49 

    50 /**

    51  * The class is used for implementing the "JvmThreading" group.

    52  */

    53 public class JvmThreadingImpl implements JvmThreadingMBean {

    54 

    55     /**

    56      * Variable for storing the value of "JvmThreadCpuTimeMonitoring".

    57      *

    58      * "The state of the Thread CPU Time Monitoring feature.

    59      * This feature can be:

    60      *

    61      * unsupported: The JVM does not support Thread CPU Time Monitoring.

    62      * enabled    : The JVM supports Thread CPU Time Monitoring, and it

    63      * is enabled.

    64      * disabled   : The JVM supports Thread CPU Time Monitoring, and it

    65      * is disabled.

    66      *

    67      * Only enabled(3) and disabled(4) may be supplied as values to a

    68      * SET request. unsupported(1) can only be set internally by the

    69      * agent.

    70      *

    71      * See java.lang.management.ThreadMXBean.isThreadCpuTimeSupported(),

    72      * java.lang.management.ThreadMXBean.isThreadCpuTimeEnabled(),

    73      * java.lang.management.ThreadMXBean.setThreadCpuTimeEnabled()

    74      * "

    75      *

    76      */

    77     final static EnumJvmThreadCpuTimeMonitoring

    78         JvmThreadCpuTimeMonitoringUnsupported =

    79         new EnumJvmThreadCpuTimeMonitoring("unsupported");

    80     final static EnumJvmThreadCpuTimeMonitoring

    81         JvmThreadCpuTimeMonitoringEnabled =

    82         new EnumJvmThreadCpuTimeMonitoring("enabled");

    83     final static EnumJvmThreadCpuTimeMonitoring

    84         JvmThreadCpuTimeMonitoringDisabled =

    85         new EnumJvmThreadCpuTimeMonitoring("disabled");

    86 

    87 

    88     /**

    89      * Variable for storing the value of "JvmThreadContentionMonitoring".

    90      *

    91      * "The state of the Thread Contention Monitoring feature.

    92      * This feature can be:

    93      *

    94      * unsupported: The JVM does not support Thread Contention Monitoring.

    95      * enabled    : The JVM supports Thread Contention Monitoring, and it

    96      * is enabled.

    97      * disabled   : The JVM supports Thread Contention Monitoring, and it

    98      * is disabled.

    99      *

   100      * Only enabled(3) and disabled(4) may be supplied as values to a

   101      * SET request. unsupported(1) can only be set internally by the

   102      * agent.

   103      *

   104      * See java.lang.management.ThreadMXBean.isThreadContentionMonitoringSupported(),

   105      * java.lang.management.ThreadMXBean.isThreadContentionMonitoringEnabled(),

   106      * java.lang.management.ThreadMXBean.setThreadContentionMonitoringEnabled()

   107      * "

   108      *

   109      */

   110     static final EnumJvmThreadContentionMonitoring

   111         JvmThreadContentionMonitoringUnsupported =

   112         new EnumJvmThreadContentionMonitoring("unsupported");

   113     static final EnumJvmThreadContentionMonitoring

   114         JvmThreadContentionMonitoringEnabled =

   115         new EnumJvmThreadContentionMonitoring("enabled");

   116     static final EnumJvmThreadContentionMonitoring

   117         JvmThreadContentionMonitoringDisabled =

   118         new EnumJvmThreadContentionMonitoring("disabled");

   119 

   120     /**

   121      * Constructor for the "JvmThreading" group.

   122      * If the group contains a table, the entries created through an SNMP SET

   123      * will not be registered in Java DMK.

   124      */

   125     public JvmThreadingImpl(SnmpMib myMib) {

   126         log.debug("JvmThreadingImpl","Constructor");

   127     }

   128 

   129 

   130     /**

   131      * Constructor for the "JvmThreading" group.

   132      * If the group contains a table, the entries created through an SNMP SET

   133      * will be AUTOMATICALLY REGISTERED in Java DMK.

   134      */

   135     public JvmThreadingImpl(SnmpMib myMib, MBeanServer server) {

   136         log.debug("JvmThreadingImpl","Constructor with server");

   137     }

   138 

   139     /**

   140      * ThreadMXBean accessor. It is acquired from the

   141      * java.lang.management.ManagementFactory

   142      * @return The local ThreadMXBean.

   143      */

   144     static ThreadMXBean getThreadMXBean() {

   145         return ManagementFactory.getThreadMXBean();

   146     }

   147 

   148     /**

   149      * Getter for the "JvmThreadCpuTimeMonitoring" variable.

   150      */

   151     public EnumJvmThreadCpuTimeMonitoring getJvmThreadCpuTimeMonitoring()

   152         throws SnmpStatusException {

   153 

   154         ThreadMXBean mbean = getThreadMXBean();

   155 

   156         if(!mbean.isThreadCpuTimeSupported()) {

   157             log.debug("getJvmThreadCpuTimeMonitoring",

   158                       "Unsupported ThreadCpuTimeMonitoring");

   159             return JvmThreadCpuTimeMonitoringUnsupported;

   160         }

   161 

   162         try {

   163             if(mbean.isThreadCpuTimeEnabled()) {

   164                 log.debug("getJvmThreadCpuTimeMonitoring",

   165                       "Enabled ThreadCpuTimeMonitoring");

   166                 return JvmThreadCpuTimeMonitoringEnabled;

   167             } else {

   168                 log.debug("getJvmThreadCpuTimeMonitoring",

   169                           "Disabled ThreadCpuTimeMonitoring");

   170                 return JvmThreadCpuTimeMonitoringDisabled;

   171             }

   172         }catch(UnsupportedOperationException e) {

   173             log.debug("getJvmThreadCpuTimeMonitoring",

   174                       "Newly unsupported ThreadCpuTimeMonitoring");

   175 

   176             return JvmThreadCpuTimeMonitoringUnsupported;

   177         }

   178     }

   179 

   180     /**

   181      * Setter for the "JvmThreadCpuTimeMonitoring" variable.

   182      */

   183     public void setJvmThreadCpuTimeMonitoring(EnumJvmThreadCpuTimeMonitoring x)

   184         throws SnmpStatusException {

   185 

   186         ThreadMXBean mbean = getThreadMXBean();

   187 

   188         // We can trust the received value, it has been checked in

   189         // checkJvmThreadCpuTimeMonitoring

   190         if(JvmThreadCpuTimeMonitoringEnabled.intValue() == x.intValue())

   191             mbean.setThreadCpuTimeEnabled(true);

   192         else

   193             mbean.setThreadCpuTimeEnabled(false);

   194     }

   195 

   196     /**

   197      * Checker for the "JvmThreadCpuTimeMonitoring" variable.

   198      */

   199     public void checkJvmThreadCpuTimeMonitoring(EnumJvmThreadCpuTimeMonitoring

   200                                                 x)

   201         throws SnmpStatusException {

   202 

   203         //Can't be set externaly to unsupported state.

   204         if(JvmThreadCpuTimeMonitoringUnsupported.intValue() == x.intValue()) {

   205              log.debug("checkJvmThreadCpuTimeMonitoring",

   206                       "Try to set to illegal unsupported value");

   207             throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);

   208         }

   209 

   210         if ((JvmThreadCpuTimeMonitoringEnabled.intValue() == x.intValue()) ||

   211             (JvmThreadCpuTimeMonitoringDisabled.intValue() == x.intValue())) {

   212 

   213             // The value is a valid value. But is the feature supported?

   214             ThreadMXBean mbean = getThreadMXBean();

   215             if(mbean.isThreadCpuTimeSupported()) return;

   216 

   217             // Not supported.

   218             log.debug("checkJvmThreadCpuTimeMonitoring",

   219                       "Unsupported operation, can't set state");

   220             throw new

   221                 SnmpStatusException(SnmpDefinitions.snmpRspInconsistentValue);

   222         }

   223 

   224         // Unknown value.

   225         log.debug("checkJvmThreadCpuTimeMonitoring",

   226                   "unknown enum value ");

   227         throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);

   228     }

   229 

   230     /**

   231      * Getter for the "JvmThreadContentionMonitoring" variable.

   232      */

   233     public EnumJvmThreadContentionMonitoring getJvmThreadContentionMonitoring()

   234         throws SnmpStatusException {

   235 

   236         ThreadMXBean mbean = getThreadMXBean();

   237 

   238         if(!mbean.isThreadContentionMonitoringSupported()) {

   239             log.debug("getJvmThreadContentionMonitoring",

   240                       "Unsupported ThreadContentionMonitoring");

   241             return JvmThreadContentionMonitoringUnsupported;

   242         }

   243 

   244         if(mbean.isThreadContentionMonitoringEnabled()) {

   245             log.debug("getJvmThreadContentionMonitoring",

   246                       "Enabled ThreadContentionMonitoring");

   247             return JvmThreadContentionMonitoringEnabled;

   248         } else {

   249             log.debug("getJvmThreadContentionMonitoring",

   250                       "Disabled ThreadContentionMonitoring");

   251             return JvmThreadContentionMonitoringDisabled;

   252         }

   253     }

   254 

   255     /**

   256      * Setter for the "JvmThreadContentionMonitoring" variable.

   257      */

   258     public void setJvmThreadContentionMonitoring(

   259                             EnumJvmThreadContentionMonitoring x)

   260         throws SnmpStatusException {

   261         ThreadMXBean mbean = getThreadMXBean();

   262 

   263         // We can trust the received value, it has been checked in

   264         // checkJvmThreadContentionMonitoring

   265         if(JvmThreadContentionMonitoringEnabled.intValue() == x.intValue())

   266             mbean.setThreadContentionMonitoringEnabled(true);

   267         else

   268             mbean.setThreadContentionMonitoringEnabled(false);

   269     }

   270 

   271     /**

   272      * Checker for the "JvmThreadContentionMonitoring" variable.

   273      */

   274     public void checkJvmThreadContentionMonitoring(

   275                               EnumJvmThreadContentionMonitoring x)

   276         throws SnmpStatusException {

   277         //Can't be set externaly to unsupported state.

   278         if(JvmThreadContentionMonitoringUnsupported.intValue()==x.intValue()) {

   279             log.debug("checkJvmThreadContentionMonitoring",

   280                       "Try to set to illegal unsupported value");

   281             throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);

   282         }

   283 

   284         if ((JvmThreadContentionMonitoringEnabled.intValue()==x.intValue()) ||

   285             (JvmThreadContentionMonitoringDisabled.intValue()==x.intValue())) {

   286 

   287             // The value is valid, but is the feature supported ?

   288             ThreadMXBean mbean = getThreadMXBean();

   289             if(mbean.isThreadContentionMonitoringSupported()) return;

   290 

   291             log.debug("checkJvmThreadContentionMonitoring",

   292                       "Unsupported operation, can't set state");

   293             throw new

   294                 SnmpStatusException(SnmpDefinitions.snmpRspInconsistentValue);

   295         }

   296 

   297         log.debug("checkJvmThreadContentionMonitoring",

   298                   "Try to set to unknown value");

   299         throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);

   300     }

   301 

   302     /**

   303      * Getter for the "JvmThreadTotalStartedCount" variable.

   304      */

   305     public Long getJvmThreadTotalStartedCount() throws SnmpStatusException {

   306         return getThreadMXBean().getTotalStartedThreadCount();

   307     }

   308 

   309     /**

   310      * Getter for the "JvmThreadPeakCount" variable.

   311      */

   312     public Long getJvmThreadPeakCount() throws SnmpStatusException {

   313         return (long)getThreadMXBean().getPeakThreadCount();

   314     }

   315 

   316     /**

   317      * Getter for the "JvmThreadDaemonCount" variable.

   318      */

   319     public Long getJvmThreadDaemonCount() throws SnmpStatusException {

   320         return (long)getThreadMXBean().getDaemonThreadCount();

   321     }

   322 

   323     /**

   324      * Getter for the "JvmThreadCount" variable.

   325      */

   326     public Long getJvmThreadCount() throws SnmpStatusException {

   327         return (long)getThreadMXBean().getThreadCount();

   328     }

   329 

   330    /**

   331      * Getter for the "JvmThreadPeakCountReset" variable.

   332      */

   333     public synchronized Long getJvmThreadPeakCountReset()

   334         throws SnmpStatusException {

   335         return jvmThreadPeakCountReset;

   336     }

   337 

   338     /**

   339      * Setter for the "JvmThreadPeakCountReset" variable.

   340      */

   341     public synchronized void setJvmThreadPeakCountReset(Long x)

   342         throws SnmpStatusException {

   343         final long l = x.longValue();

   344         if (l > jvmThreadPeakCountReset) {

   345             final long stamp = System.currentTimeMillis();

   346             getThreadMXBean().resetPeakThreadCount();

   347             jvmThreadPeakCountReset = stamp;

   348             log.debug("setJvmThreadPeakCountReset",

   349                       "jvmThreadPeakCountReset="+stamp);

   350         }

   351     }

   352 

   353     /**

   354      * Checker for the "JvmThreadPeakCountReset" variable.

   355      */

   356     public void checkJvmThreadPeakCountReset(Long x)

   357         throws SnmpStatusException {

   358     }

   359 

   360     /* Last time thread peak count was reset */

   361     private long jvmThreadPeakCountReset=0;

   362 

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

   364 }