/*

 * 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 = 0L;

    /**

     * Getter for the "JvmMemoryNonHeapMaxSize" variable.

     */

    public Long getJvmMemoryNonHeapMaxSize()

        throws SnmpStatusException {

        final long val = getNonHeapMemoryUsage().getMax();

        if (val > -1) return  val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryNonHeapCommitted" variable.

     */

    public Long getJvmMemoryNonHeapCommitted() throws SnmpStatusException {

        final long val = getNonHeapMemoryUsage().getCommitted();

        if (val > -1) return val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryNonHeapUsed" variable.

     */

    public Long getJvmMemoryNonHeapUsed() throws SnmpStatusException {

        final long val = getNonHeapMemoryUsage().getUsed();

        if (val > -1) return val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryNonHeapInitSize" variable.

     */

    public Long getJvmMemoryNonHeapInitSize() throws SnmpStatusException {

        final long val = getNonHeapMemoryUsage().getInit();

        if (val > -1) return val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryHeapMaxSize" variable.

     */

    public Long getJvmMemoryHeapMaxSize() throws SnmpStatusException {

        final long val = getHeapMemoryUsage().getMax();

        if (val > -1) return 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 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 val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryHeapInitSize" variable.

     */

    public Long getJvmMemoryHeapInitSize() throws SnmpStatusException {

        final long val = getHeapMemoryUsage().getInit();

        if (val > -1) return val;

        else return Long0;

    }

    /**

     * Getter for the "JvmMemoryPendingFinalCount" variable.

     */

    public Long getJvmMemoryPendingFinalCount()

        throws SnmpStatusException {

        final long val = ManagementFactory.getMemoryMXBean().

            getObjectPendingFinalizationCount();

        if (val > -1) return Long.valueOf((int) val);

        // Should never happen... but stay safe all the same.

        //

        else return 0L;

    }

    static final MibLogger log = new MibLogger(JvmMemoryImpl.class);

}