/*

 * Copyright (c) 2008, 2010, 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 java.lang.management;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.HashSet;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import javax.management.MBeanServerConnection;

import javax.management.ObjectName;

import com.sun.management.HotSpotDiagnosticMXBean;

import com.sun.management.UnixOperatingSystemMXBean;

import sun.management.ManagementFactoryHelper;

import sun.management.Util;

/**

 * This enum class defines the list of platform components

 * that provides monitoring and management support.

 * Each enum represents one MXBean interface. A MXBean

 * instance could implement one or more MXBean interfaces.

 *

 * For example, com.sun.management.GarbageCollectorMXBean

 * extends java.lang.management.GarbageCollectorMXBean

 * and there is one set of garbage collection MXBean instances,

 * each of which implements both c.s.m. and j.l.m. interfaces.

 * There are two separate enums GARBAGE_COLLECTOR

 * and SUN_GARBAGE_COLLECTOR so that ManagementFactory.getPlatformMXBeans(Class)

 * will return the list of MXBeans of the specified type.

 *

 * To add a new MXBean interface for the Java platform,

 * add a new enum constant and implement the MXBeanFetcher.

 */

enum PlatformComponent {

    /**

     * Class loading system of the Java virtual machine.

     */

    CLASS_LOADING(

        "java.lang.management.ClassLoadingMXBean",

        "java.lang", "ClassLoading", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<ClassLoadingMXBean>() {

            public List<ClassLoadingMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getClassLoadingMXBean());

            }

        }),

    /**

     * Compilation system of the Java virtual machine.

     */

    COMPILATION(

        "java.lang.management.CompilationMXBean",

        "java.lang", "Compilation", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<CompilationMXBean>() {

            public List<CompilationMXBean> getMXBeans() {

                CompilationMXBean m = ManagementFactoryHelper.getCompilationMXBean();

                if (m == null) {

                   return Collections.emptyList();

                } else {

                   return Collections.singletonList(m);

                }

            }

        }),

    /**

     * Memory system of the Java virtual machine.

     */

    MEMORY(

        "java.lang.management.MemoryMXBean",

        "java.lang", "Memory", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<MemoryMXBean>() {

            public List<MemoryMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getMemoryMXBean());

            }

        }),

    /**

     * Garbage Collector in the Java virtual machine.

     */

    GARBAGE_COLLECTOR(

        "java.lang.management.GarbageCollectorMXBean",

        "java.lang", "GarbageCollector", keyProperties("name"),

        false, // zero or more instances

        new MXBeanFetcher<GarbageCollectorMXBean>() {

            public List<GarbageCollectorMXBean> getMXBeans() {

                return ManagementFactoryHelper.

                           getGarbageCollectorMXBeans();

            }

        }),

    /**

     * Memory manager in the Java virtual machine.

     */

    MEMORY_MANAGER(

        "java.lang.management.MemoryManagerMXBean",

        "java.lang", "MemoryManager", keyProperties("name"),

        false, // zero or more instances

        new MXBeanFetcher<MemoryManagerMXBean>() {

            public List<MemoryManagerMXBean> getMXBeans() {

                return ManagementFactoryHelper.getMemoryManagerMXBeans();

            }

        },

        GARBAGE_COLLECTOR),

    /**

     * Memory pool in the Java virtual machine.

     */

    MEMORY_POOL(

        "java.lang.management.MemoryPoolMXBean",

        "java.lang", "MemoryPool", keyProperties("name"),

        false, // zero or more instances

        new MXBeanFetcher<MemoryPoolMXBean>() {

            public List<MemoryPoolMXBean> getMXBeans() {

                return ManagementFactoryHelper.getMemoryPoolMXBeans();

            }

        }),

    /**

     * Operating system on which the Java virtual machine is running

     */

    OPERATING_SYSTEM(

        "java.lang.management.OperatingSystemMXBean",

        "java.lang", "OperatingSystem", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<OperatingSystemMXBean>() {

            public List<OperatingSystemMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getOperatingSystemMXBean());

            }

        }),

    /**

     * Runtime system of the Java virtual machine.

     */

    RUNTIME(

        "java.lang.management.RuntimeMXBean",

        "java.lang", "Runtime", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<RuntimeMXBean>() {

            public List<RuntimeMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getRuntimeMXBean());

            }

        }),

    /**

     * Threading system of the Java virtual machine.

     */

    THREADING(

        "java.lang.management.ThreadMXBean",

        "java.lang", "Threading", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<ThreadMXBean>() {

            public List<ThreadMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getThreadMXBean());

            }

        }),

    /**

     * Logging facility.

     */

    LOGGING(

        "java.lang.management.PlatformLoggingMXBean",

        "java.util.logging", "Logging", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<PlatformLoggingMXBean>() {

            public List<PlatformLoggingMXBean> getMXBeans() {

                PlatformLoggingMXBean m = ManagementFactoryHelper.getPlatformLoggingMXBean();

                if (m == null) {

                   return Collections.emptyList();

                } else {

                   return Collections.singletonList(m);

                }

            }

        }),

    /**

     * Buffer pools.

     */

    BUFFER_POOL(

        "java.lang.management.BufferPoolMXBean",

        "java.nio", "BufferPool", keyProperties("name"),

        false, // zero or more instances

        new MXBeanFetcher<BufferPoolMXBean>() {

            public List<BufferPoolMXBean> getMXBeans() {

                return ManagementFactoryHelper.getBufferPoolMXBeans();

            }

        }),

    // Sun Platform Extension

    /**

     * Sun extension garbage collector that performs collections in cycles.

     */

    SUN_GARBAGE_COLLECTOR(

        "com.sun.management.GarbageCollectorMXBean",

        "java.lang", "GarbageCollector", keyProperties("name"),

        false, // zero or more instances

        new MXBeanFetcher<com.sun.management.GarbageCollectorMXBean>() {

            public List<com.sun.management.GarbageCollectorMXBean> getMXBeans() {

                return getGcMXBeanList(com.sun.management.GarbageCollectorMXBean.class);

            }

        }),

    /**

     * Sun extension operating system on which the Java virtual machine

     * is running.

     */

    SUN_OPERATING_SYSTEM(

        "com.sun.management.OperatingSystemMXBean",

        "java.lang", "OperatingSystem", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<com.sun.management.OperatingSystemMXBean>() {

            public List<com.sun.management.OperatingSystemMXBean> getMXBeans() {

                return getOSMXBeanList(com.sun.management.OperatingSystemMXBean.class);

            }

        }),

    /**

     * Unix operating system.

     */

    SUN_UNIX_OPERATING_SYSTEM(

        "com.sun.management.UnixOperatingSystemMXBean",

        "java.lang", "OperatingSystem", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<UnixOperatingSystemMXBean>() {

            public List<UnixOperatingSystemMXBean> getMXBeans() {

                return getOSMXBeanList(com.sun.management.UnixOperatingSystemMXBean.class);

            }

        }),

    /**

     * Diagnostic support for the HotSpot Virtual Machine.

     */

    HOTSPOT_DIAGNOSTIC(

        "com.sun.management.HotSpotDiagnosticMXBean",

        "com.sun.management", "HotSpotDiagnostic", defaultKeyProperties(),

        true, // singleton

        new MXBeanFetcher<HotSpotDiagnosticMXBean>() {

            public List<HotSpotDiagnosticMXBean> getMXBeans() {

                return Collections.singletonList(ManagementFactoryHelper.getDiagnosticMXBean());

            }

        });

    /**

     * A task that returns the MXBeans for a component.

     */

    interface MXBeanFetcher<T extends PlatformManagedObject> {

        public List<T> getMXBeans();

    }

    /*

     * Returns a list of the GC MXBeans of the given type.

     */

    private static <T extends GarbageCollectorMXBean>

            List<T> getGcMXBeanList(Class<T> gcMXBeanIntf) {

        List<GarbageCollectorMXBean> list =

            ManagementFactoryHelper.getGarbageCollectorMXBeans();

        List<T> result = new ArrayList<>(list.size());

        for (GarbageCollectorMXBean m : list) {

            if (gcMXBeanIntf.isInstance(m)) {

                result.add(gcMXBeanIntf.cast(m));

            }

        }

        return result;

    }

    /*

     * Returns the OS mxbean instance of the given type.

     */

    private static <T extends OperatingSystemMXBean>

            List<T> getOSMXBeanList(Class<T> osMXBeanIntf) {

        OperatingSystemMXBean m =

            ManagementFactoryHelper.getOperatingSystemMXBean();

        if (osMXBeanIntf.isInstance(m)) {

            return Collections.singletonList(osMXBeanIntf.cast(m));

        } else {

            return Collections.emptyList();

        }

    }

    private final String mxbeanInterfaceName;

    private final String domain;

    private final String type;

    private final Set<String> keyProperties;

    private final MXBeanFetcher fetcher;

    private final PlatformComponent[] subComponents;

    private final boolean singleton;

    private PlatformComponent(String intfName,

                              String domain, String type,

                              Set<String> keyProperties,

                              boolean singleton,

                              MXBeanFetcher fetcher,

                              PlatformComponent... subComponents) {

        this.mxbeanInterfaceName = intfName;

        this.domain = domain;

        this.type = type;

        this.keyProperties = keyProperties;

        this.singleton = singleton;

        this.fetcher = fetcher;

        this.subComponents = subComponents;

    }

    private static Set<String> defaultKeyProps;

    private static Set<String> defaultKeyProperties() {

        if (defaultKeyProps == null) {

            defaultKeyProps = Collections.singleton("type");

        }

        return defaultKeyProps;

    }

    private static Set<String> keyProperties(String... keyNames) {

        Set<String> set = new HashSet<>();

        set.add("type");

        for (String s : keyNames) {

            set.add(s);

        }

        return set;

    }

    boolean isSingleton() {

        return singleton;

    }

    String getMXBeanInterfaceName() {

        return mxbeanInterfaceName;

    }

    @SuppressWarnings("unchecked")

    Class<? extends PlatformManagedObject> getMXBeanInterface() {

        try {

            // Lazy loading the MXBean interface only when it is needed

            return (Class<? extends PlatformManagedObject>)

                       Class.forName(mxbeanInterfaceName, false, null);

        } catch (ClassNotFoundException x) {

            throw new AssertionError(x);

        }

    }

    @SuppressWarnings("unchecked")

    <T extends PlatformManagedObject>

        List<T> getMXBeans(Class<T> mxbeanInterface)

    {

        return fetcher.getMXBeans();

    }

    <T extends PlatformManagedObject> T getSingletonMXBean(Class<T> mxbeanInterface)

    {

        if (!singleton)

            throw new IllegalArgumentException(mxbeanInterfaceName +

                " can have zero or more than one instances");

        List<T> list = fetcher.getMXBeans();

        assert list.size() == 1;

        return list.isEmpty() ? null : list.get(0);

    }

    <T extends PlatformManagedObject>

            T getSingletonMXBean(MBeanServerConnection mbs, Class<T> mxbeanInterface)

        throws java.io.IOException

    {

        if (!singleton)

            throw new IllegalArgumentException(mxbeanInterfaceName +

                " can have zero or more than one instances");

        // ObjectName of a singleton MXBean contains only domain and type

        assert keyProperties.size() == 1;

        String on = domain + ":type=" + type;

        return ManagementFactory.newPlatformMXBeanProxy(mbs,

                                                        on,

                                                        mxbeanInterface);

    }

    <T extends PlatformManagedObject>

            List<T> getMXBeans(MBeanServerConnection mbs, Class<T> mxbeanInterface)

        throws java.io.IOException

    {

        List<T> result = new ArrayList<>();

        for (ObjectName on : getObjectNames(mbs)) {

            result.add(ManagementFactory.

                newPlatformMXBeanProxy(mbs,

                                       on.getCanonicalName(),

                                       mxbeanInterface)

            );

        }

        return result;

    }

    private Set<ObjectName> getObjectNames(MBeanServerConnection mbs)

        throws java.io.IOException

    {

        String domainAndType = domain + ":type=" + type;

        if (keyProperties.size() > 1) {

            // if there are more than 1 key properties (i.e. other than "type")

            domainAndType += ",*";

        }

        ObjectName on = Util.newObjectName(domainAndType);

        Set<ObjectName> set =  mbs.queryNames(on, null);

        for (PlatformComponent pc : subComponents) {

            set.addAll(pc.getObjectNames(mbs));

        }

        return set;

    }

    // a map from MXBean interface name to PlatformComponent

    private static Map<String, PlatformComponent> enumMap;

    private static synchronized void ensureInitialized() {

        if (enumMap == null) {

            enumMap = new HashMap<>();

            for (PlatformComponent pc: PlatformComponent.values()) {

                // Use String as the key rather than Class<?> to avoid

                // causing unnecessary class loading of management interface

                enumMap.put(pc.getMXBeanInterfaceName(), pc);

            }

        }

    }

    static boolean isPlatformMXBean(String cn) {

        ensureInitialized();

        return enumMap.containsKey(cn);

    }

    static <T extends PlatformManagedObject>

        PlatformComponent getPlatformComponent(Class<T> mxbeanInterface)

    {

        ensureInitialized();

        String cn = mxbeanInterface.getName();

        PlatformComponent pc = enumMap.get(cn);

        if (pc != null && pc.getMXBeanInterface() == mxbeanInterface)

            return pc;

        return null;

    }

    private static final long serialVersionUID = 6992337162326171013L;

}