1 /*

     2  * Copyright (c) 2015, 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 com.sun.management.internal;

    26 

    27 import com.sun.management.DiagnosticCommandMBean;

    28 import com.sun.management.HotSpotDiagnosticMXBean;

    29 import com.sun.management.ThreadMXBean;

    30 import java.lang.management.ManagementFactory;

    31 import java.lang.management.MemoryManagerMXBean;

    32 import java.lang.management.OperatingSystemMXBean;

    33 import java.security.AccessController;

    34 import java.security.PrivilegedAction;

    35 import java.util.ArrayList;

    36 import java.util.Collections;

    37 import java.util.HashMap;

    38 import java.util.List;

    39 import java.util.Map;

    40 import java.util.Set;

    41 import java.util.stream.Collectors;

    42 import java.util.stream.Stream;

    43 import javax.management.DynamicMBean;

    44 import sun.management.ManagementFactoryHelper;

    45 import sun.management.spi.PlatformMBeanProvider;

    46 

    47 public final class PlatformMBeanProviderImpl extends PlatformMBeanProvider {

    48     final static String DIAGNOSTIC_COMMAND_MBEAN_NAME =

    49         "com.sun.management:type=DiagnosticCommand";

    50 

    51     private final List<PlatformComponent<?>> mxbeanList;

    52     private static HotSpotDiagnostic hsDiagMBean = null;

    53     private static OperatingSystemMXBean osMBean = null;

    54 

    55     static {

    56        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {

    57            System.loadLibrary("management_ext");

    58            return null;

    59        });

    60     }

    61 

    62     public PlatformMBeanProviderImpl() {

    63         mxbeanList = Collections.unmodifiableList(init());

    64     }

    65 

    66     @Override

    67     public List<PlatformComponent<?>> getPlatformComponentList() {

    68         return mxbeanList;

    69     }

    70 

    71     private List<PlatformComponent<?>> init() {

    72         ArrayList<PlatformComponent<?>> initMBeanList = new ArrayList<>();

    73         /**

    74          * Garbage Collector in the Java virtual machine.

    75          */

    76         initMBeanList.add(new PlatformComponent<MemoryManagerMXBean>() {

    77             private final Set<String> garbageCollectorMXBeanInterfaceNames

    78                     = Collections.unmodifiableSet(

    79                             Stream.of("java.lang.management.MemoryManagerMXBean",

    80                                     "java.lang.management.GarbageCollectorMXBean",

    81                                     "com.sun.management.GarbageCollectorMXBean")

    82                             .collect(Collectors.toSet()));

    83 

    84             @Override

    85             public Set<Class<? extends MemoryManagerMXBean>> mbeanInterfaces() {

    86                 return Stream.of(MemoryManagerMXBean.class,

    87                         java.lang.management.GarbageCollectorMXBean.class,

    88                         com.sun.management.GarbageCollectorMXBean.class)

    89                         .collect(Collectors.toSet());

    90             }

    91 

    92             @Override

    93             public Set<String> mbeanInterfaceNames() {

    94                 return garbageCollectorMXBeanInterfaceNames;

    95             }

    96 

    97             @Override

    98             public String getObjectNamePattern() {

    99                 return ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE + ",name=*";

   100             }

   101 

   102             @Override

   103             public boolean isSingleton() {

   104                 return false; // zero or more instances

   105             }

   106 

   107             @Override

   108             public Map<String, MemoryManagerMXBean> nameToMBeanMap() {

   109                 List<java.lang.management.GarbageCollectorMXBean> list

   110                         = ManagementFactoryHelper.getGarbageCollectorMXBeans();

   111                 Map<String, MemoryManagerMXBean> map;

   112                 if (list.isEmpty()) {

   113                     map = Collections.emptyMap();

   114                 } else {

   115                     map = new HashMap<>(list.size());

   116                     for (MemoryManagerMXBean gcm : list) {

   117                         map.put(gcm.getObjectName().getCanonicalName(),

   118                                 gcm);

   119                     }

   120                 }

   121 

   122                 return map;

   123             }

   124         });

   125 

   126         /**

   127          * Threading system of the Java virtual machine.

   128          */

   129         initMBeanList.add(new PlatformComponent<java.lang.management.ThreadMXBean>() {

   130             private final Set<String> threadMXBeanInterfaceNames

   131                     = Collections.unmodifiableSet(

   132                             Stream.of("java.lang.management.ThreadMXBean",

   133                                     "com.sun.management.ThreadMXBean")

   134                             .collect(Collectors.toSet()));

   135             private ThreadMXBean threadMBean = null;

   136 

   137             @Override

   138             public Set<Class<? extends java.lang.management.ThreadMXBean>> mbeanInterfaces() {

   139                 return Stream.of(java.lang.management.ThreadMXBean.class,

   140                         com.sun.management.ThreadMXBean.class)

   141                         .collect(Collectors.toSet());

   142             }

   143 

   144             @Override

   145             public Set<String> mbeanInterfaceNames() {

   146                 return threadMXBeanInterfaceNames;

   147             }

   148 

   149             @Override

   150             public String getObjectNamePattern() {

   151                 return ManagementFactory.THREAD_MXBEAN_NAME;

   152             }

   153 

   154             @Override

   155             public synchronized Map<String, java.lang.management.ThreadMXBean> nameToMBeanMap() {

   156                 if (threadMBean == null) {

   157                     threadMBean = new HotSpotThreadImpl(ManagementFactoryHelper.getVMManagement());

   158                 }

   159                 return Collections.singletonMap(

   160                         ManagementFactory.THREAD_MXBEAN_NAME,

   161                         threadMBean);

   162             }

   163         });

   164 

   165         /**

   166          * OperatingSystemMXBean

   167          */

   168         initMBeanList.add(new PlatformComponent<OperatingSystemMXBean>() {

   169             private final Set<String> operatingSystemMXBeanInterfaceNames

   170                     = Collections.unmodifiableSet(

   171                             Stream.of("java.lang.management.OperatingSystemMXBean",

   172                                     "com.sun.management.OperatingSystemMXBean",

   173                                     "com.sun.management.UnixOperatingSystemMXBean")

   174                             .collect(Collectors.toSet()));

   175 

   176             @Override

   177             public Set<Class<? extends OperatingSystemMXBean>> mbeanInterfaces() {

   178                 return Stream.of(java.lang.management.OperatingSystemMXBean.class,

   179                         com.sun.management.OperatingSystemMXBean.class,

   180                         com.sun.management.UnixOperatingSystemMXBean.class)

   181                         .collect(Collectors.toSet());

   182             }

   183 

   184             @Override

   185             public Set<String> mbeanInterfaceNames() {

   186                 return operatingSystemMXBeanInterfaceNames;

   187             }

   188 

   189             @Override

   190             public String getObjectNamePattern() {

   191                 return ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME;

   192             }

   193 

   194             @Override

   195             public Map<String, java.lang.management.OperatingSystemMXBean> nameToMBeanMap() {

   196                 return Collections.<String, java.lang.management.OperatingSystemMXBean>singletonMap(

   197                         ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME,

   198                         getOperatingSystemMXBean());

   199             }

   200         });

   201 

   202         /**

   203          * Diagnostic support for the HotSpot Virtual Machine.

   204          */

   205         initMBeanList.add(new PlatformComponent<com.sun.management.HotSpotDiagnosticMXBean>() {

   206             private final Set<String> hotSpotDiagnosticMXBeanInterfaceNames =

   207                     Collections.unmodifiableSet(Collections.<String>singleton(

   208                             "com.sun.management.HotSpotDiagnosticMXBean"));

   209 

   210             @Override

   211             public Set<Class<? extends com.sun.management.HotSpotDiagnosticMXBean>> mbeanInterfaces() {

   212                 return Collections.singleton(com.sun.management.HotSpotDiagnosticMXBean.class);

   213             }

   214 

   215             @Override

   216             public Set<String> mbeanInterfaceNames() {

   217                 return hotSpotDiagnosticMXBeanInterfaceNames;

   218             }

   219 

   220             @Override

   221             public String getObjectNamePattern() {

   222                 return "com.sun.management:type=HotSpotDiagnostic";

   223             }

   224 

   225             @Override

   226             public Map<String, com.sun.management.HotSpotDiagnosticMXBean> nameToMBeanMap() {

   227                 return Collections.<String, com.sun.management.HotSpotDiagnosticMXBean>singletonMap(

   228                         "com.sun.management:type=HotSpotDiagnostic",

   229                         getDiagnosticMXBean());

   230             }

   231         });

   232 

   233         /**

   234          * Diagnostic command MBean

   235          */

   236         DiagnosticCommandMBean diagMBean = DiagnosticCommandImpl.getDiagnosticCommandMBean();

   237         if (diagMBean != null) {

   238             initMBeanList.add(new PlatformComponent<DynamicMBean>() {

   239                 final Set<String> dynamicMBeanInterfaceNames

   240                         = Collections.unmodifiableSet(Collections.<String>singleton(

   241                                 "javax.management.DynamicMBean"));

   242 

   243                 @Override

   244                 public Set<String> mbeanInterfaceNames() {

   245                     return dynamicMBeanInterfaceNames;

   246                 }

   247 

   248                 @Override

   249                 public Set<Class<? extends DynamicMBean>> mbeanInterfaces() {

   250                     // DynamicMBean cannot be used to find an MBean by ManagementFactory

   251                     return Collections.emptySet();

   252                 }

   253 

   254                 @Override

   255                 public String getObjectNamePattern() {

   256                     return DIAGNOSTIC_COMMAND_MBEAN_NAME;

   257                 }

   258 

   259                 @Override

   260                 public Map<String, DynamicMBean> nameToMBeanMap() {

   261                     return Collections.<String, DynamicMBean>singletonMap(

   262                             DIAGNOSTIC_COMMAND_MBEAN_NAME,

   263                             diagMBean);

   264                 }

   265             });

   266         }

   267 

   268         initMBeanList.trimToSize();

   269         return initMBeanList;

   270     }

   271 

   272     private static synchronized HotSpotDiagnosticMXBean getDiagnosticMXBean() {

   273         if (hsDiagMBean == null) {

   274             hsDiagMBean = new HotSpotDiagnostic();

   275         }

   276         return hsDiagMBean;

   277     }

   278 

   279     private static synchronized OperatingSystemMXBean getOperatingSystemMXBean() {

   280         if (osMBean == null) {

   281             osMBean = new OperatingSystemImpl(ManagementFactoryHelper.getVMManagement());

   282         }

   283         return osMBean;

   284     }

   285 }