1 /*
2  * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
4  *
5  *
6  *
7  *
8  *
9  *
10  *
11  *
12  *
13  *
14  *
15  *
16  *
17  *
18  *
19  *
20  *
21  *
22  *
23  *
24  */
25
26 package java.lang.management;
27
28 import java.util.ArrayList;
29 import java.util.Collections;
30 import java.util.List;
31 import java.util.HashSet;
32 import java.util.HashMap;
33 import java.util.Map;
34 import java.util.Set;
35 import javax.management.MBeanServerConnection;
36 import javax.management.ObjectName;
37
38 import com.sun.management.HotSpotDiagnosticMXBean;
39 import com.sun.management.UnixOperatingSystemMXBean;
40
41 import sun.management.ManagementFactoryHelper;
42 import sun.management.Util;
43
44 /**
45  * This enum class defines the list of platform components
46  * that provides monitoring and management support.
47  * Each enum represents one MXBean interface. A MXBean
48  * instance could implement one or more MXBean interfaces.
49  *
50  * For example, com.sun.management.GarbageCollectorMXBean
51  * extends java.lang.management.GarbageCollectorMXBean
52  * and there is one set of garbage collection MXBean instances,
53  * each of which implements both c.s.m. and j.l.m. interfaces.
54  * There are two separate enums GARBAGE_COLLECTOR
55  * and SUN_GARBAGE_COLLECTOR so that ManagementFactory.getPlatformMXBeans(Class)
56  * will return the list of MXBeans of the specified type.
57  *
58  * To add a new MXBean interface for the Java platform,
59  * add a new enum constant and implement the MXBeanFetcher.
60  */
61 enum PlatformComponent {
62
63     /**
64      * Class loading system of the Java virtual machine.
65      */
66     CLASS_LOADING(
67         "java.lang.management.ClassLoadingMXBean",
68         "java.lang", "ClassLoading", defaultKeyProperties(),
69         true, // singleton
70         new MXBeanFetcher<ClassLoadingMXBean>() {
71             public List<ClassLoadingMXBean> getMXBeans() {
72                 return Collections.singletonList(ManagementFactoryHelper.getClassLoadingMXBean());
73             }
74         }),
75
76     /**
77      * Compilation system of the Java virtual machine.
78      */
79     COMPILATION(
80         "java.lang.management.CompilationMXBean",
81         "java.lang", "Compilation", defaultKeyProperties(),
82         true, // singleton
83         new MXBeanFetcher<CompilationMXBean>() {
84             public List<CompilationMXBean> getMXBeans() {
85                 CompilationMXBean m = ManagementFactoryHelper.getCompilationMXBean();
86                 if (m == null) {
87                    return Collections.emptyList();
88                 } else {
89                    return Collections.singletonList(m);
90                 }
91             }
92         }),
93
94     /**
95      * Memory system of the Java virtual machine.
96      */
97     MEMORY(
98         "java.lang.management.MemoryMXBean",
99         "java.lang", "Memory", defaultKeyProperties(),
100         true, // singleton
101         new MXBeanFetcher<MemoryMXBean>() {
102             public List<MemoryMXBean> getMXBeans() {
103                 return Collections.singletonList(ManagementFactoryHelper.getMemoryMXBean());
104             }
105         }),
106
107     /**
108      * Garbage Collector in the Java virtual machine.
109      */
110     GARBAGE_COLLECTOR(
111         "java.lang.management.GarbageCollectorMXBean",
112         "java.lang", "GarbageCollector", keyProperties("name"),
113         false, // zero or more instances
114         new MXBeanFetcher<GarbageCollectorMXBean>() {
115             public List<GarbageCollectorMXBean> getMXBeans() {
116                 return ManagementFactoryHelper.
117                            getGarbageCollectorMXBeans();
118             }
119         }),
120
121     /**
122      * Memory manager in the Java virtual machine.
123      */
124     MEMORY_MANAGER(
125         "java.lang.management.MemoryManagerMXBean",
126         "java.lang", "MemoryManager", keyProperties("name"),
127         false, // zero or more instances
128         new MXBeanFetcher<MemoryManagerMXBean>() {
129             public List<MemoryManagerMXBean> getMXBeans() {
130                 return ManagementFactoryHelper.getMemoryManagerMXBeans();
131             }
132         },
133         GARBAGE_COLLECTOR),
134
135     /**
136      * Memory pool in the Java virtual machine.
137      */
138     MEMORY_POOL(
139         "java.lang.management.MemoryPoolMXBean",
140         "java.lang", "MemoryPool", keyProperties("name"),
141         false, // zero or more instances
142         new MXBeanFetcher<MemoryPoolMXBean>() {
143             public List<MemoryPoolMXBean> getMXBeans() {
144                 return ManagementFactoryHelper.getMemoryPoolMXBeans();
145             }
146         }),
147
148     /**
149      * Operating system on which the Java virtual machine is running
150      */
151     OPERATING_SYSTEM(
152         "java.lang.management.OperatingSystemMXBean",
153         "java.lang", "OperatingSystem", defaultKeyProperties(),
154         true, // singleton
155         new MXBeanFetcher<OperatingSystemMXBean>() {
156             public List<OperatingSystemMXBean> getMXBeans() {
157                 return Collections.singletonList(ManagementFactoryHelper.getOperatingSystemMXBean());
158             }
159         }),
160
161     /**
162      * Runtime system of the Java virtual machine.
163      */
164     RUNTIME(
165         "java.lang.management.RuntimeMXBean",
166         "java.lang", "Runtime", defaultKeyProperties(),
167         true, // singleton
168         new MXBeanFetcher<RuntimeMXBean>() {
169             public List<RuntimeMXBean> getMXBeans() {
170                 return Collections.singletonList(ManagementFactoryHelper.getRuntimeMXBean());
171             }
172         }),
173
174     /**
175      * Threading system of the Java virtual machine.
176      */
177     THREADING(
178         "java.lang.management.ThreadMXBean",
179         "java.lang", "Threading", defaultKeyProperties(),
180         true, // singleton
181         new MXBeanFetcher<ThreadMXBean>() {
182             public List<ThreadMXBean> getMXBeans() {
183                 return Collections.singletonList(ManagementFactoryHelper.getThreadMXBean());
184             }
185         }),
186
187
188     /**
189      * Logging facility.
190      */
191     LOGGING(
192         "java.lang.management.PlatformLoggingMXBean",
193         "java.util.logging", "Logging", defaultKeyProperties(),
194         true, // singleton
195         new MXBeanFetcher<PlatformLoggingMXBean>() {
196             public List<PlatformLoggingMXBean> getMXBeans() {
197                 PlatformLoggingMXBean m = ManagementFactoryHelper.getPlatformLoggingMXBean();
198                 if (m == null) {
199                    return Collections.emptyList();
200                 } else {
201                    return Collections.singletonList(m);
202                 }
203             }
204         }),
205
206     /**
207      * Buffer pools.
208      */
209     BUFFER_POOL(
210         "java.lang.management.BufferPoolMXBean",
211         "java.nio", "BufferPool", keyProperties("name"),
212         false, // zero or more instances
213         new MXBeanFetcher<BufferPoolMXBean>() {
214             public List<BufferPoolMXBean> getMXBeans() {
215                 return ManagementFactoryHelper.getBufferPoolMXBeans();
216             }
217         }),
218
219
220     // Sun Platform Extension
221
222     /**
223      * Sun extension garbage collector that performs collections in cycles.
224      */
225     SUN_GARBAGE_COLLECTOR(
226         "com.sun.management.GarbageCollectorMXBean",
227         "java.lang", "GarbageCollector", keyProperties("name"),
228         false, // zero or more instances
229         new MXBeanFetcher<com.sun.management.GarbageCollectorMXBean>() {
230             public List<com.sun.management.GarbageCollectorMXBean> getMXBeans() {
231                 return getGcMXBeanList(com.sun.management.GarbageCollectorMXBean.class);
232             }
233         }),
234
235     /**
236      * Sun extension operating system on which the Java virtual machine
237      * is running.
238      */
239     SUN_OPERATING_SYSTEM(
240         "com.sun.management.OperatingSystemMXBean",
241         "java.lang", "OperatingSystem", defaultKeyProperties(),
242         true, // singleton
243         new MXBeanFetcher<com.sun.management.OperatingSystemMXBean>() {
244             public List<com.sun.management.OperatingSystemMXBean> getMXBeans() {
245                 return getOSMXBeanList(com.sun.management.OperatingSystemMXBean.class);
246             }
247         }),
248
249     /**
250      * Unix operating system.
251      */
252     SUN_UNIX_OPERATING_SYSTEM(
253         "com.sun.management.UnixOperatingSystemMXBean",
254         "java.lang", "OperatingSystem", defaultKeyProperties(),
255         true, // singleton
256         new MXBeanFetcher<UnixOperatingSystemMXBean>() {
257             public List<UnixOperatingSystemMXBean> getMXBeans() {
258                 return getOSMXBeanList(com.sun.management.UnixOperatingSystemMXBean.class);
259             }
260         }),
261
262     /**
263      * Diagnostic support for the HotSpot Virtual Machine.
264      */
265     HOTSPOT_DIAGNOSTIC(
266         "com.sun.management.HotSpotDiagnosticMXBean",
267         "com.sun.management", "HotSpotDiagnostic", defaultKeyProperties(),
268         true, // singleton
269         new MXBeanFetcher<HotSpotDiagnosticMXBean>() {
270             public List<HotSpotDiagnosticMXBean> getMXBeans() {
271                 return Collections.singletonList(ManagementFactoryHelper.getDiagnosticMXBean());
272             }
273         });
274
275
276     /**
277      * A task that returns the MXBeans for a component.
278      */
279     interface MXBeanFetcher<T extends PlatformManagedObject> {
280         public List<T> getMXBeans();
281     }
282
283     /*
284      * Returns a list of the GC MXBeans of the given type.
285      */
286     private static <T extends GarbageCollectorMXBean>
287             List<T> getGcMXBeanList(Class<T> gcMXBeanIntf) {
288         List<GarbageCollectorMXBean> list =
289             ManagementFactoryHelper.getGarbageCollectorMXBeans();
290         List<T> result = new ArrayList<>(list.size());
291         for (GarbageCollectorMXBean m : list) {
292             if (gcMXBeanIntf.isInstance(m)) {
293                 result.add(gcMXBeanIntf.cast(m));
294             }
295         }
296         return result;
297     }
298
299     /*
300      * Returns the OS mxbean instance of the given type.
301      */
302     private static <T extends OperatingSystemMXBean>
303             List<T> getOSMXBeanList(Class<T> osMXBeanIntf) {
304         OperatingSystemMXBean m =
305             ManagementFactoryHelper.getOperatingSystemMXBean();
306         if (osMXBeanIntf.isInstance(m)) {
307             return Collections.singletonList(osMXBeanIntf.cast(m));
308         } else {
309             return Collections.emptyList();
310         }
311     }
312
313     private final String mxbeanInterfaceName;
314     private final String domain;
315     private final String type;
316     private final Set<String> keyProperties;
317     private final MXBeanFetcher<?> fetcher;
318     private final PlatformComponent[] subComponents;
319     private final boolean singleton;
320
321     private PlatformComponent(String intfName,
322                               String domain, String type,
323                               Set<String> keyProperties,
324                               boolean singleton,
325                               MXBeanFetcher<?> fetcher,
326                               PlatformComponent... subComponents) {
327         this.mxbeanInterfaceName = intfName;
328         this.domain = domain;
329         this.type = type;
330         this.keyProperties = keyProperties;
331         this.singleton = singleton;
332         this.fetcher = fetcher;
333         this.subComponents = subComponents;
334     }
335
336     private static Set<String> defaultKeyProps;
337     private static Set<String> defaultKeyProperties() {
338         if (defaultKeyProps == null) {
339             defaultKeyProps = Collections.singleton("type");
340         }
341         return defaultKeyProps;
342     }
343
344     private static Set<String> keyProperties(String... keyNames) {
345         Set<String> set = new HashSet<>();
346         set.add("type");
347         for (String s : keyNames) {
348             set.add(s);
349         }
350         return set;
351     }
352
353     boolean isSingleton() {
354         return singleton;
355     }
356
357     String getMXBeanInterfaceName() {
358         return mxbeanInterfaceName;
359     }
360
361     @SuppressWarnings("unchecked")
362     Class<? extends PlatformManagedObject> getMXBeanInterface() {
363         try {
364             // Lazy loading the MXBean interface only when it is needed
365             return (Class<? extends PlatformManagedObject>)
366                        Class.forName(mxbeanInterfaceName, false,
367                                      PlatformManagedObject.class.getClassLoader());
368         } catch (ClassNotFoundException x) {
369             throw new AssertionError(x);
370         }
371     }
372
373     @SuppressWarnings("unchecked")
374     <T extends PlatformManagedObject>
375         List<T> getMXBeans(Class<T> mxbeanInterface)
376     {
377         return (List<T>) fetcher.getMXBeans();
378     }
379
380     <T extends PlatformManagedObject> T getSingletonMXBean(Class<T> mxbeanInterface)
381     {
382         if (!singleton)
383             throw new IllegalArgumentException(mxbeanInterfaceName +
384                 " can have zero or more than one instances");
385
386         List<T> list = getMXBeans(mxbeanInterface);
387         assert list.size() == 1;
388         return list.isEmpty() ? null : list.get(0);
389     }
390
391     <T extends PlatformManagedObject>
392             T getSingletonMXBean(MBeanServerConnection mbs, Class<T> mxbeanInterface)
393         throws java.io.IOException
394     {
395         if (!singleton)
396             throw new IllegalArgumentException(mxbeanInterfaceName +
397                 " can have zero or more than one instances");
398
399         // ObjectName of a singleton MXBean contains only domain and type
400         assert keyProperties.size() == 1;
401         String on = domain + ":type=" + type;
402         return ManagementFactory.newPlatformMXBeanProxy(mbs,
403                                                         on,
404                                                         mxbeanInterface);
405     }
406
407     <T extends PlatformManagedObject>
408             List<T> getMXBeans(MBeanServerConnection mbs, Class<T> mxbeanInterface)
409         throws java.io.IOException
410     {
411         List<T> result = new ArrayList<>();
412         for (ObjectName on : getObjectNames(mbs)) {
413             result.add(ManagementFactory.
414                 newPlatformMXBeanProxy(mbs,
415                                        on.getCanonicalName(),
416                                        mxbeanInterface)
417             );
418         }
419         return result;
420     }
421
422     private Set<ObjectName> getObjectNames(MBeanServerConnection mbs)
423         throws java.io.IOException
424     {
425         String domainAndType = domain + ":type=" + type;
426         if (keyProperties.size() > 1) {
427             // if there are more than 1 key properties (i.e. other than "type")
428             domainAndType += ",*";
429         }
430         ObjectName on = Util.newObjectName(domainAndType);
431         Set<ObjectName> set =  mbs.queryNames(on, null);
432         for (PlatformComponent pc : subComponents) {
433             set.addAll(pc.getObjectNames(mbs));
434         }
435         return set;
436     }
437
438     // a map from MXBean interface name to PlatformComponent
439     private static Map<String, PlatformComponent> enumMap;
440     private static synchronized void ensureInitialized() {
441         if (enumMap == null) {
442             enumMap = new HashMap<>();
443             for (PlatformComponent pc: PlatformComponent.values()) {
444                 // Use String as the key rather than Class<?> to avoid
445                 // causing unnecessary class loading of management interface
446                 enumMap.put(pc.getMXBeanInterfaceName(), pc);
447             }
448         }
449     }
450
451     static boolean isPlatformMXBean(String cn) {
452         ensureInitialized();
453         return enumMap.containsKey(cn);
454     }
455
456     static <T extends PlatformManagedObject>
457         PlatformComponent getPlatformComponent(Class<T> mxbeanInterface)
458     {
459         ensureInitialized();
460         String cn = mxbeanInterface.getName();
461         PlatformComponent pc = enumMap.get(cn);
462         if (pc != null && pc.getMXBeanInterface() == mxbeanInterface)
463             return pc;
464         return null;
465     }
466
467     private static final long serialVersionUID = 6992337162326171013L;
468 }
469
Powered by JavaMelody