feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/management/snmp/jvminstr/JvmMemoryImpl.java

@@ -0,0 +1,391 @@
+/*
+ * 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;
+
+// jmx imports
+//
+import javax.management.MBeanServer;
+import com.sun.jmx.snmp.SnmpStatusException;
+import com.sun.jmx.snmp.SnmpDefinitions;
+
+// jdmk imports
+//
+import com.sun.jmx.snmp.agent.SnmpMib;
+
+import java.util.Map;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.lang.management.MemoryType;
+import java.lang.management.MemoryMXBean;
+import javax.management.openmbean.CompositeData;
+
+import sun.management.snmp.jvmmib.JvmMemoryMBean;
+import sun.management.snmp.jvmmib.EnumJvmMemoryGCCall;
+import sun.management.snmp.jvmmib.EnumJvmMemoryGCVerboseLevel;
+import sun.management.snmp.util.MibLogger;
+import sun.management.snmp.util.JvmContextFactory;
+
+/**
+ * The class is used for implementing the "JvmMemory" group.
+ */
+public class JvmMemoryImpl implements JvmMemoryMBean {
+
+    /**
+     * Variable for storing the value of "JvmMemoryGCCall".
+     *
+     * "This object makes it possible to remotelly trigger the
+     * Garbage Collector in the JVM.
+     *
+     * This object's syntax is an enumeration which defines:
+     *
+     * * Two state values, that can be returned from a GET request:
+     *
+     * unsupported(1): means that remote invocation of gc() is not
+     * supported by the SNMP agent.
+     * supported(2)  : means that remote invocation of gc() is supported
+     * by the SNMP agent.
+     *
+     * * One action value, that can be provided in a SET request to
+     * trigger the garbage collector:
+     *
+     * start(3)      : means that a manager wishes to trigger
+     * garbage collection.
+     *
+     * * Two result value, that will be returned as a result of a
+     * SET request when remote invocation of gc is supported
+     * by the SNMP agent:
+     *
+     * started(4)       : means that garbage collection was
+     * successfully triggered. It does not mean
+     * however that the action was successfullly
+     * completed: gc might still be running when
+     * this value is returned.
+     * failed(5)     : means that garbage collection couldn't be
+     * triggered.
+     *
+     * * If remote invocation is not supported by the SNMP agent, then
+     * unsupported(1) will always be returned as a result of either
+     * a GET request, or a SET request with start(3) as input value.
+     *
+     * * If a SET request with anything but start(3) is received, then
+     * the agent will return a wrongValue error.
+     *
+     * See java.management.MemoryMXBean.gc()
+     * "
+     *
+     */
+    final static EnumJvmMemoryGCCall JvmMemoryGCCallSupported
+        = new EnumJvmMemoryGCCall("supported");
+    final static EnumJvmMemoryGCCall JvmMemoryGCCallStart
+        = new EnumJvmMemoryGCCall("start");
+    final static EnumJvmMemoryGCCall JvmMemoryGCCallFailed
+        = new EnumJvmMemoryGCCall("failed");
+    final static EnumJvmMemoryGCCall JvmMemoryGCCallStarted
+        = new EnumJvmMemoryGCCall("started");
+
+    /**
+     * Variable for storing the value of "JvmMemoryGCVerboseLevel".
+     *
+     * "State of the -verbose:gc state.
+     *
+     * verbose: if the -verbose:gc flag is on,
+     * silent:  otherwise.
+     *
+     * See java.management.MemoryMXBean.isVerbose(),
+     * java.management.MemoryMXBean.setVerbose()
+     * "
+     *
+     */
+    final static EnumJvmMemoryGCVerboseLevel JvmMemoryGCVerboseLevelVerbose =
+        new EnumJvmMemoryGCVerboseLevel("verbose");
+    final static EnumJvmMemoryGCVerboseLevel JvmMemoryGCVerboseLevelSilent =
+        new EnumJvmMemoryGCVerboseLevel("silent");
+
+    /**
+     * Constructor for the "JvmMemory" group.
+     * If the group contains a table, the entries created through an
+     * SNMP SET will not be registered in Java DMK.
+     */
+    public JvmMemoryImpl(SnmpMib myMib) {
+    }
+
+
+    /**
+     * Constructor for the "JvmMemory" group.
+     * If the group contains a table, the entries created through an
+     * SNMP SET will be AUTOMATICALLY REGISTERED in Java DMK.
+     */
+    public JvmMemoryImpl(SnmpMib myMib, MBeanServer server) {
+        // no entry will be registered since the table is virtual.
+    }
+
+    final static String heapMemoryTag = "jvmMemory.getHeapMemoryUsage";
+    final static String nonHeapMemoryTag = "jvmMemory.getNonHeapMemoryUsage";
+
+    private MemoryUsage getMemoryUsage(MemoryType type) {
+        if (type == MemoryType.HEAP) {
+            return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+        } else {
+            return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
+        }
+    }
+
+    MemoryUsage getNonHeapMemoryUsage() {
+        try {
+            final Map<Object, Object> m = JvmContextFactory.getUserData();
+
+            if (m != null) {
+                final MemoryUsage cached = (MemoryUsage)
+                    m.get(nonHeapMemoryTag);
+                if (cached != null) {
+                    log.debug("getNonHeapMemoryUsage",
+                          "jvmMemory.getNonHeapMemoryUsage found in cache.");
+                    return cached;
+                }
+
+                final MemoryUsage u = getMemoryUsage(MemoryType.NON_HEAP);
+
+                //  getNonHeapMemoryUsage() never returns null.
+                //
+                // if (u == null) u=MemoryUsage.INVALID;
+
+                m.put(nonHeapMemoryTag,u);
+                return u;
+            }
+            // Should never come here.
+            // Log error!
+            log.trace("getNonHeapMemoryUsage",
+                      "ERROR: should never come here!");
+            return getMemoryUsage(MemoryType.NON_HEAP);
+        } catch (RuntimeException x) {
+            log.trace("getNonHeapMemoryUsage",
+                  "Failed to get NonHeapMemoryUsage: " + x);
+            log.debug("getNonHeapMemoryUsage",x);
+            throw x;
+        }
+
+    }
+
+    MemoryUsage getHeapMemoryUsage() {
+        try {
+            final Map<Object, Object> m = JvmContextFactory.getUserData();
+
+            if (m != null) {
+                final MemoryUsage cached = (MemoryUsage)m.get(heapMemoryTag);
+                if (cached != null) {
+                    log.debug("getHeapMemoryUsage",
+                          "jvmMemory.getHeapMemoryUsage found in cache.");
+                    return cached;
+                }
+
+                final MemoryUsage u = getMemoryUsage(MemoryType.HEAP);
+
+                // getHeapMemoryUsage() never returns null.
+                //
+                // if (u == null) u=MemoryUsage.INVALID;
+
+                m.put(heapMemoryTag,u);
+                return u;
+            }
+
+            // Should never come here.
+            // Log error!
+            log.trace("getHeapMemoryUsage", "ERROR: should never come here!");
+            return getMemoryUsage(MemoryType.HEAP);
+        } catch (RuntimeException x) {
+            log.trace("getHeapMemoryUsage",
+                  "Failed to get HeapMemoryUsage: " + x);
+            log.debug("getHeapMemoryUsage",x);
+            throw x;
+        }
+    }
+
+    static final Long Long0 = new Long(0);
+
+    /**
+     * Getter for the "JvmMemoryNonHeapMaxSize" variable.
+     */
+    public Long getJvmMemoryNonHeapMaxSize()
+        throws SnmpStatusException {
+        final long val = getNonHeapMemoryUsage().getMax();
+        if (val > -1) return  new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryNonHeapCommitted" variable.
+     */
+    public Long getJvmMemoryNonHeapCommitted() throws SnmpStatusException {
+        final long val = getNonHeapMemoryUsage().getCommitted();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryNonHeapUsed" variable.
+     */
+    public Long getJvmMemoryNonHeapUsed() throws SnmpStatusException {
+        final long val = getNonHeapMemoryUsage().getUsed();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryNonHeapInitSize" variable.
+     */
+    public Long getJvmMemoryNonHeapInitSize() throws SnmpStatusException {
+        final long val = getNonHeapMemoryUsage().getInit();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryHeapMaxSize" variable.
+     */
+    public Long getJvmMemoryHeapMaxSize() throws SnmpStatusException {
+        final long val = getHeapMemoryUsage().getMax();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryGCCall" variable.
+     */
+    public EnumJvmMemoryGCCall getJvmMemoryGCCall()
+        throws SnmpStatusException {
+        final Map<Object,Object> m = JvmContextFactory.getUserData();
+
+        if (m != null) {
+            final EnumJvmMemoryGCCall cached
+                = (EnumJvmMemoryGCCall) m.get("jvmMemory.getJvmMemoryGCCall");
+            if (cached != null) return cached;
+        }
+        return JvmMemoryGCCallSupported;
+    }
+
+    /**
+     * Setter for the "JvmMemoryGCCall" variable.
+     */
+    public void setJvmMemoryGCCall(EnumJvmMemoryGCCall x)
+        throws SnmpStatusException {
+        if (x.intValue() == JvmMemoryGCCallStart.intValue()) {
+            final Map<Object, Object> m = JvmContextFactory.getUserData();
+
+            try {
+                ManagementFactory.getMemoryMXBean().gc();
+                if (m != null) m.put("jvmMemory.getJvmMemoryGCCall",
+                                     JvmMemoryGCCallStarted);
+            } catch (Exception ex) {
+                if (m != null) m.put("jvmMemory.getJvmMemoryGCCall",
+                                     JvmMemoryGCCallFailed);
+            }
+            return;
+        }
+        throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
+    }
+
+    /**
+     * Checker for the "JvmMemoryGCCall" variable.
+     */
+    public void checkJvmMemoryGCCall(EnumJvmMemoryGCCall x)
+        throws SnmpStatusException {
+        if (x.intValue() != JvmMemoryGCCallStart.intValue())
+        throw new SnmpStatusException(SnmpDefinitions.snmpRspWrongValue);
+    }
+
+    /**
+     * Getter for the "JvmMemoryHeapCommitted" variable.
+     */
+    public Long getJvmMemoryHeapCommitted() throws SnmpStatusException {
+        final long val = getHeapMemoryUsage().getCommitted();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryGCVerboseLevel" variable.
+     */
+    public EnumJvmMemoryGCVerboseLevel getJvmMemoryGCVerboseLevel()
+        throws SnmpStatusException {
+        if (ManagementFactory.getMemoryMXBean().isVerbose())
+            return JvmMemoryGCVerboseLevelVerbose;
+        else
+            return JvmMemoryGCVerboseLevelSilent;
+    }
+
+    /**
+     * Setter for the "JvmMemoryGCVerboseLevel" variable.
+     */
+    public void setJvmMemoryGCVerboseLevel(EnumJvmMemoryGCVerboseLevel x)
+        throws SnmpStatusException {
+        if (JvmMemoryGCVerboseLevelVerbose.intValue() == x.intValue())
+            ManagementFactory.getMemoryMXBean().setVerbose(true);
+        else
+            ManagementFactory.getMemoryMXBean().setVerbose(false);
+    }
+
+    /**
+     * Checker for the "JvmMemoryGCVerboseLevel" variable.
+     */
+    public void checkJvmMemoryGCVerboseLevel(EnumJvmMemoryGCVerboseLevel x)
+        throws SnmpStatusException {
+        // Nothing to check...
+    }
+
+    /**
+     * Getter for the "JvmMemoryHeapUsed" variable.
+     */
+    public Long getJvmMemoryHeapUsed() throws SnmpStatusException {
+        final long val = getHeapMemoryUsage().getUsed();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryHeapInitSize" variable.
+     */
+    public Long getJvmMemoryHeapInitSize() throws SnmpStatusException {
+        final long val = getHeapMemoryUsage().getInit();
+        if (val > -1) return new Long(val);
+        else return Long0;
+    }
+
+    /**
+     * Getter for the "JvmMemoryPendingFinalCount" variable.
+     */
+    public Long getJvmMemoryPendingFinalCount()
+        throws SnmpStatusException {
+        final long val = ManagementFactory.getMemoryMXBean().
+            getObjectPendingFinalizationCount();
+
+        if (val > -1) return new Long((int)val);
+
+        // Should never happen... but stay safe all the same.
+        //
+        else return new Long(0);
+    }
+
+    static final MibLogger log = new MibLogger(JvmMemoryImpl.class);
+}