src/java.management/share/classes/java/lang/management/DefaultPlatformMBeanProvider.java

/*
 * Copyright (c) 2015, 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.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.management.ObjectName;
import sun.management.ManagementFactoryHelper;
import sun.management.spi.PlatformMBeanProvider;

class DefaultPlatformMBeanProvider extends PlatformMBeanProvider {
    private final List<PlatformComponent<?>> mxbeanList;

    DefaultPlatformMBeanProvider() {
        mxbeanList = Collections.unmodifiableList(init());
    }

    @Override
    public List<PlatformComponent<?>> getPlatformComponentList() {
        return mxbeanList;
    }

    private List<PlatformComponent<?>> init() {
        ArrayList<PlatformComponent<?>> initMBeanList = new ArrayList<>();
        /**
         * Class loading system of the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<ClassLoadingMXBean>() {
            private final Set<String> classLoadingInterfaceNames =
                    Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.ClassLoadingMXBean"));

            @Override
            public Set<Class<? extends ClassLoadingMXBean>> mbeanInterfaces() {
                return Collections.singleton(ClassLoadingMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return classLoadingInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.CLASS_LOADING_MXBEAN_NAME;
            }

            @Override
            public Map<String, ClassLoadingMXBean> nameToMBeanMap() {
                return Collections.singletonMap(
                        ManagementFactory.CLASS_LOADING_MXBEAN_NAME,
                        ManagementFactoryHelper.getClassLoadingMXBean());
            }
        });

        /**
         * Compilation system of the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<CompilationMXBean>() {
            private final Set<String> compilationMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.CompilationMXBean"));

            @Override
            public Set<Class<? extends CompilationMXBean>> mbeanInterfaces() {
                return Collections.singleton(CompilationMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return compilationMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.COMPILATION_MXBEAN_NAME;
            }

            @Override
            public Map<String, CompilationMXBean> nameToMBeanMap() {
                CompilationMXBean m = ManagementFactoryHelper.getCompilationMXBean();
                if (m == null) {
                    return Collections.emptyMap();
                } else {
                    return Collections.singletonMap(
                            ManagementFactory.COMPILATION_MXBEAN_NAME,
                            ManagementFactoryHelper.getCompilationMXBean());
                }
            }
        });

        /**
         * Memory system of the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<MemoryMXBean>() {
            private final Set<String> memoryMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.MemoryMXBean"));

            @Override
            public Set<Class<? extends MemoryMXBean>> mbeanInterfaces() {
                return Collections.singleton(MemoryMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return memoryMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.MEMORY_MXBEAN_NAME;
            }

            @Override
            public Map<String, MemoryMXBean> nameToMBeanMap() {
                return Collections.singletonMap(
                        ManagementFactory.MEMORY_MXBEAN_NAME,
                        ManagementFactoryHelper.getMemoryMXBean());
            }
        });

        /**
         * Garbage Collector in the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<MemoryManagerMXBean>() {
            private final Set<String> garbageCollectorMXBeanInterfaceNames
                    = Collections.unmodifiableSet(
                            Stream.of("java.lang.management.MemoryManagerMXBean",
                                    "java.lang.management.GarbageCollectorMXBean")
                            .collect(Collectors.toSet()));
            @Override
            public Set<Class<? extends MemoryManagerMXBean>> mbeanInterfaces() {
                return Stream.of(MemoryManagerMXBean.class,
                        GarbageCollectorMXBean.class).collect(Collectors.toSet());
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return garbageCollectorMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE + ",name=*";
            }

            @Override
            public boolean isSingleton() {
                return false; // zero or more instances
            }

            @Override
            public Map<String, MemoryManagerMXBean> nameToMBeanMap() {
                List<GarbageCollectorMXBean> list
                        = ManagementFactoryHelper.getGarbageCollectorMXBeans();
                Map<String, MemoryManagerMXBean> map;
                if (list.isEmpty()) {
                    map = Collections.emptyMap();
                } else {
                    map = new HashMap<>(list.size());
                    for (MemoryManagerMXBean gcm : list) {
                        map.put(gcm.getObjectName().getCanonicalName(),
                                gcm);
                    }
                }
                return map;
            }

        });

        /**
         * Memory manager in the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<MemoryManagerMXBean>() {
            private final Set<String> memoryManagerMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.MemoryManagerMXBean"));

            @Override
            public Set<Class<? extends MemoryManagerMXBean>> mbeanInterfaces() {
                return Collections.singleton(MemoryManagerMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return memoryManagerMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE + ",name=*";
            }

            @Override
            public boolean isSingleton() {
                return false; // zero or more instances
            }

            @Override
            public Map<String, MemoryManagerMXBean> nameToMBeanMap() {
                List<MemoryManagerMXBean> list
                        = ManagementFactoryHelper.getMemoryManagerMXBeans();
                return list.stream()
                        .filter(this::isMemoryManager)
                        .collect(Collectors.toMap(
                                pmo -> pmo.getObjectName().getCanonicalName(), Function.identity()));
            }

            // ManagementFactoryHelper.getMemoryManagerMXBeans() returns all
            // memory managers - we need to filter out those that do not match
            // the pattern for which we are registered
            private boolean isMemoryManager(MemoryManagerMXBean mbean) {
                final ObjectName name = mbean.getObjectName();
                return ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE.startsWith(name.getDomain())
                        && ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE.contains(
                                "type="+name.getKeyProperty("type"));
            }
        });

        /**
         * Memory pool in the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<MemoryPoolMXBean>() {
            private final Set<String> memoryPoolMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.MemoryPoolMXBean"));

            @Override
            public Set<Class<? extends MemoryPoolMXBean>> mbeanInterfaces() {
                return Collections.singleton(MemoryPoolMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return memoryPoolMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE + ",name=*";
            }

            @Override
            public boolean isSingleton() {
                return false; // zero or more instances
            }

            @Override
            public Map<String, MemoryPoolMXBean> nameToMBeanMap() {
                List<MemoryPoolMXBean> list
                        = ManagementFactoryHelper.getMemoryPoolMXBeans();
                Map<String, MemoryPoolMXBean> map;
                if (list.isEmpty()) {
                    map = Collections.<String, MemoryPoolMXBean>emptyMap();
                } else {
                    map = new HashMap<>(list.size());
                    for (MemoryPoolMXBean mpm : list) {
                        map.put(mpm.getObjectName().getCanonicalName(),
                                mpm);
                    }
                }
                return map;
            }
        });

        /**
         * Runtime system of the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<RuntimeMXBean>() {
            private final Set<String> runtimeMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.RuntimeMXBean"));

            @Override
            public Set<Class<? extends RuntimeMXBean>> mbeanInterfaces() {
                return Collections.singleton(RuntimeMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return runtimeMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.RUNTIME_MXBEAN_NAME;
            }

            @Override
            public Map<String, RuntimeMXBean> nameToMBeanMap() {
                return Collections.singletonMap(
                        ManagementFactory.RUNTIME_MXBEAN_NAME,
                        ManagementFactoryHelper.getRuntimeMXBean());
            }
        });

        /**
         * Threading system of the Java virtual machine.
         */
        initMBeanList.add(new PlatformComponent<ThreadMXBean>() {
            private final Set<String> threadMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.ThreadMXBean"));

            @Override
            public Set<Class<? extends ThreadMXBean>> mbeanInterfaces() {
                return Collections.singleton(ThreadMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return threadMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.THREAD_MXBEAN_NAME;
            }

            @Override
            public Map<String, ThreadMXBean> nameToMBeanMap() {
                return Collections.singletonMap(
                        ManagementFactory.THREAD_MXBEAN_NAME,
                        ManagementFactoryHelper.getThreadMXBean());
            }
        });

        if (ManagementFactoryHelper.isPlatformLoggingMXBeanAvailable()) {
            /**
             * Logging facility.
             */
            initMBeanList.add(new PlatformComponent<PlatformLoggingMXBean>() {
                private final Set<String> platformLoggingMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.PlatformLoggingMXBean"));

                @Override
                public Set<Class<? extends PlatformLoggingMXBean>> mbeanInterfaces() {
                    return Collections.singleton(PlatformLoggingMXBean.class);
                }

                @Override
                public Set<String> mbeanInterfaceNames() {
                    return platformLoggingMXBeanInterfaceNames;
                }

                @Override
                public String getObjectNamePattern() {
                    return "java.util.logging:type=Logging";
                }

                @Override
                public Map<String, PlatformLoggingMXBean> nameToMBeanMap() {
                    return Collections.singletonMap(
                        "java.util.logging:type=Logging",
                        ManagementFactoryHelper.getPlatformLoggingMXBean());
                }
            });
        }

        /**
         * Buffer pools.
         */
        initMBeanList.add(new PlatformComponent<BufferPoolMXBean>() {
            private final Set<String> bufferPoolMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.BufferPoolMXBean"));

            @Override
            public Set<Class<? extends BufferPoolMXBean>> mbeanInterfaces() {
                return Collections.singleton(BufferPoolMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return bufferPoolMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return "java.nio:type=BufferPool,name=*";
            }

            @Override
            public boolean isSingleton() {
                return false; // zero or more instances
            }

            @Override
            public Map<String, BufferPoolMXBean> nameToMBeanMap() {
                List<BufferPoolMXBean> list
                        = ManagementFactoryHelper.getBufferPoolMXBeans();
                Map<String, BufferPoolMXBean> map;
                if (list.isEmpty()) {
                    map = Collections.<String, BufferPoolMXBean>emptyMap();
                } else {
                    map = new HashMap<>(list.size());
                    list.stream()
                        .forEach(mbean -> map.put(mbean.getObjectName().getCanonicalName(),mbean));
                }
                return map;
            }
        });

        /**
         * OperatingSystemMXBean
         */
        initMBeanList.add(new PlatformComponent<OperatingSystemMXBean>() {
            private final Set<String> operatingSystemMXBeanInterfaceNames
                    = Collections.unmodifiableSet(Collections.singleton(
                            "java.lang.management.OperatingSystemMXBean"));

            @Override
            public Set<Class<? extends OperatingSystemMXBean>> mbeanInterfaces() {
                return Collections.singleton(OperatingSystemMXBean.class);
            }

            @Override
            public Set<String> mbeanInterfaceNames() {
                return operatingSystemMXBeanInterfaceNames;
            }

            @Override
            public String getObjectNamePattern() {
                return ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME;
            }

            @Override
            public Map<String, OperatingSystemMXBean> nameToMBeanMap() {
                return Collections.singletonMap(
                        ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME,
                        ManagementFactoryHelper.getOperatingSystemMXBean());
            }

        });

        initMBeanList.trimToSize();
        return initMBeanList;
    }
}