639 lines
24 KiB
Java
639 lines
24 KiB
Java
/*
|
|
* Copyright (c) 2005, 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8058865
|
|
* @summary Test all MXBeans available by default on the platform
|
|
* @author Olivier Lagneau
|
|
* @modules java.management.rmi
|
|
* @library /lib/testlibrary
|
|
* @run main/othervm/timeout=300 -DDEBUG_STANDARD MXBeanInteropTest1
|
|
*/
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import java.lang.management.ClassLoadingMXBean;
|
|
import java.lang.management.CompilationMXBean;
|
|
import java.lang.management.GarbageCollectorMXBean;
|
|
import java.lang.management.ManagementFactory;
|
|
import java.lang.management.MemoryMXBean;
|
|
import java.lang.management.MemoryManagerMXBean;
|
|
import java.lang.management.MemoryPoolMXBean;
|
|
import java.lang.management.OperatingSystemMXBean;
|
|
import java.lang.management.RuntimeMXBean;
|
|
import java.lang.management.ThreadMXBean;
|
|
|
|
import javax.management.JMX;
|
|
import javax.management.MBeanAttributeInfo;
|
|
import javax.management.MBeanConstructorInfo;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerFactory;
|
|
import javax.management.MBeanInfo;
|
|
import javax.management.MBeanNotificationInfo;
|
|
import javax.management.MBeanOperationInfo;
|
|
import javax.management.MBeanServerConnection;
|
|
import javax.management.ObjectName;
|
|
import javax.management.remote.JMXConnector;
|
|
import javax.management.remote.JMXConnectorFactory;
|
|
import javax.management.remote.JMXConnectorServer;
|
|
import javax.management.remote.JMXConnectorServerFactory;
|
|
import javax.management.remote.JMXServiceURL;
|
|
|
|
public class MXBeanInteropTest1 {
|
|
|
|
/*
|
|
* First Debug properties and arguments are collect in expected
|
|
* map (argName, value) format, then calls original test's run method.
|
|
*/
|
|
public static void main(String args[]) throws Exception {
|
|
|
|
System.out.println("=================================================");
|
|
|
|
// Parses parameters
|
|
Utils.parseDebugProperties();
|
|
Map<String, Object> map = Utils.parseParameters(args) ;
|
|
|
|
// Run test
|
|
MXBeanInteropTest1 test = new MXBeanInteropTest1();
|
|
test.run(map);
|
|
|
|
}
|
|
|
|
public void run(Map<String, Object> args) {
|
|
|
|
System.out.println("MXBeanInteropTest1::run: Start") ;
|
|
int errorCount = 0 ;
|
|
|
|
try {
|
|
// JMX MbeanServer used inside single VM as if remote.
|
|
// MBeanServer mbs = MBeanServerFactory.newMBeanServer();
|
|
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
|
|
|
|
JMXServiceURL url = new JMXServiceURL("rmi", null, 0);
|
|
JMXConnectorServer cs =
|
|
JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);
|
|
cs.start();
|
|
|
|
JMXServiceURL addr = cs.getAddress();
|
|
JMXConnector cc = JMXConnectorFactory.connect(addr);
|
|
MBeanServerConnection mbsc = cc.getMBeanServerConnection();
|
|
|
|
// Print out registered java.lang.management MXBeans found
|
|
// in the remote jvm.
|
|
printMBeans(mbsc) ;
|
|
|
|
// For each possible kind of JDK 5 defined MXBean, we retrieve its
|
|
// MBeanInfo and print it and we call all getters and print
|
|
// their output.
|
|
errorCount += doClassLoadingMXBeanTest(mbsc) ;
|
|
errorCount += doMemoryMXBeanTest(mbsc) ;
|
|
errorCount += doThreadMXBeanTest(mbsc) ;
|
|
errorCount += doRuntimeMXBeanTest(mbsc) ;
|
|
errorCount += doOperatingSystemMXBeanTest(mbsc) ;
|
|
errorCount += doCompilationMXBeanTest(mbsc) ;
|
|
errorCount += doGarbageCollectorMXBeanTest(mbsc) ;
|
|
errorCount += doMemoryManagerMXBeanTest(mbsc) ;
|
|
errorCount += doMemoryPoolMXBeanTest(mbsc) ;
|
|
|
|
// Terminate the JMX Client
|
|
cc.close();
|
|
|
|
} catch(Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
throw new RuntimeException(e);
|
|
}
|
|
|
|
if ( errorCount == 0 ) {
|
|
System.out.println("MXBeanInteropTest1::run: Done without any error") ;
|
|
} else {
|
|
System.out.println("MXBeanInteropTest1::run: Done with "
|
|
+ errorCount
|
|
+ " error(s)") ;
|
|
throw new RuntimeException("errorCount = " + errorCount);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints all MBeans of domain java.lang.
|
|
* They are MBeans related to the JSR 174 that defines
|
|
* package java.lang.management.
|
|
*/
|
|
private static void printMBeans(MBeanServerConnection mbsc) throws Exception {
|
|
ObjectName filterName = new ObjectName("java.lang:*");
|
|
Set<ObjectName> set = mbsc.queryNames(filterName, null);
|
|
|
|
if ( set.size() == 0 ) {
|
|
throw new RuntimeException("(ERROR) No MBean found with filter "
|
|
+ filterName);
|
|
}
|
|
|
|
System.out.println("---- MBeans found in domain java.lang :");
|
|
|
|
for (Iterator<ObjectName> iter = set.iterator(); iter.hasNext(); ) {
|
|
System.out.println(iter.next().toString());
|
|
}
|
|
|
|
System.out.println("\n") ;
|
|
}
|
|
|
|
|
|
private final int doClassLoadingMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- ClassLoadingMXBean") ;
|
|
|
|
try {
|
|
ObjectName classLoadingName =
|
|
new ObjectName(ManagementFactory.CLASS_LOADING_MXBEAN_NAME) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(classLoadingName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t"
|
|
+ mbInfo);
|
|
ClassLoadingMXBean classLoading = null;
|
|
|
|
classLoading = JMX.newMXBeanProxy(mbsc,
|
|
classLoadingName,
|
|
ClassLoadingMXBean.class) ;
|
|
System.out.println("getLoadedClassCount\t\t"
|
|
+ classLoading.getLoadedClassCount());
|
|
System.out.println("getTotalLoadedClassCount\t\t"
|
|
+ classLoading.getTotalLoadedClassCount());
|
|
System.out.println("getUnloadedClassCount\t\t"
|
|
+ classLoading.getUnloadedClassCount());
|
|
System.out.println("isVerbose\t\t"
|
|
+ classLoading.isVerbose());
|
|
|
|
System.out.println("---- OK\n") ;
|
|
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doMemoryMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- MemoryMXBean") ;
|
|
|
|
try {
|
|
ObjectName memoryName =
|
|
new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t"
|
|
+ mbInfo);
|
|
MemoryMXBean memory = null ;
|
|
|
|
memory =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
memoryName,
|
|
MemoryMXBean.class,
|
|
true) ;
|
|
System.out.println("getMemoryHeapUsage\t\t"
|
|
+ memory.getHeapMemoryUsage());
|
|
System.out.println("getNonHeapMemoryHeapUsage\t\t"
|
|
+ memory.getNonHeapMemoryUsage());
|
|
System.out.println("getObjectPendingFinalizationCount\t\t"
|
|
+ memory.getObjectPendingFinalizationCount());
|
|
System.out.println("isVerbose\t\t"
|
|
+ memory.isVerbose());
|
|
|
|
System.out.println("---- OK\n") ;
|
|
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doThreadMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- ThreadMXBean") ;
|
|
|
|
try {
|
|
ObjectName threadName =
|
|
new ObjectName(ManagementFactory.THREAD_MXBEAN_NAME) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(threadName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
ThreadMXBean thread = null ;
|
|
|
|
thread =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
threadName,
|
|
ThreadMXBean.class) ;
|
|
System.out.println("findMonitorDeadlockedThreads\t\t"
|
|
+ thread.findMonitorDeadlockedThreads());
|
|
long[] threadIDs = thread.getAllThreadIds() ;
|
|
System.out.println("getAllThreadIds\t\t"
|
|
+ threadIDs);
|
|
|
|
for ( long threadID : threadIDs ) {
|
|
System.out.println("getThreadInfo long\t\t"
|
|
+ thread.getThreadInfo(threadID));
|
|
System.out.println("getThreadInfo long, int\t\t"
|
|
+ thread.getThreadInfo(threadID, 2));
|
|
}
|
|
|
|
System.out.println("getThreadInfo long[]\t\t"
|
|
+ thread.getThreadInfo(threadIDs));
|
|
System.out.println("getThreadInfo long[], int\t\t"
|
|
+ thread.getThreadInfo(threadIDs, 2));
|
|
System.out.println("getDaemonThreadCount\t\t"
|
|
+ thread.getDaemonThreadCount());
|
|
System.out.println("getPeakThreadCount\t\t"
|
|
+ thread.getPeakThreadCount());
|
|
System.out.println("getThreadCount\t\t"
|
|
+ thread.getThreadCount());
|
|
System.out.println("getTotalStartedThreadCount\t\t"
|
|
+ thread.getTotalStartedThreadCount());
|
|
boolean supported = thread.isThreadContentionMonitoringSupported() ;
|
|
System.out.println("isThreadContentionMonitoringSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("isThreadContentionMonitoringEnabled\t\t"
|
|
+ thread.isThreadContentionMonitoringEnabled());
|
|
}
|
|
|
|
supported = thread.isThreadCpuTimeSupported() ;
|
|
System.out.println("isThreadCpuTimeSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("isThreadCpuTimeEnabled\t\t"
|
|
+ thread.isThreadCpuTimeEnabled());
|
|
|
|
for (long id : threadIDs) {
|
|
System.out.println("getThreadCpuTime(" + id + ")\t\t"
|
|
+ thread.getThreadCpuTime(id));
|
|
System.out.println("getThreadUserTime(" + id + ")\t\t"
|
|
+ thread.getThreadUserTime(id));
|
|
}
|
|
}
|
|
|
|
supported = thread.isCurrentThreadCpuTimeSupported() ;
|
|
System.out.println("isCurrentThreadCpuTimeSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("getCurrentThreadCpuTime\t\t"
|
|
+ thread.getCurrentThreadCpuTime());
|
|
System.out.println("getCurrentThreadUserTime\t\t"
|
|
+ thread.getCurrentThreadUserTime());
|
|
}
|
|
|
|
thread.resetPeakThreadCount() ;
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doRuntimeMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- RuntimeMXBean") ;
|
|
|
|
try {
|
|
ObjectName runtimeName =
|
|
new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(runtimeName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
RuntimeMXBean runtime = null;
|
|
|
|
runtime =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
runtimeName,
|
|
RuntimeMXBean.class) ;
|
|
System.out.println("getClassPath\t\t"
|
|
+ runtime.getClassPath());
|
|
System.out.println("getInputArguments\t\t"
|
|
+ runtime.getInputArguments());
|
|
System.out.println("getLibraryPath\t\t"
|
|
+ runtime.getLibraryPath());
|
|
System.out.println("getManagementSpecVersion\t\t"
|
|
+ runtime.getManagementSpecVersion());
|
|
System.out.println("getName\t\t"
|
|
+ runtime.getName());
|
|
System.out.println("getSpecName\t\t"
|
|
+ runtime.getSpecName());
|
|
System.out.println("getSpecVendor\t\t"
|
|
+ runtime.getSpecVendor());
|
|
System.out.println("getSpecVersion\t\t"
|
|
+ runtime.getSpecVersion());
|
|
System.out.println("getStartTime\t\t"
|
|
+ runtime.getStartTime());
|
|
System.out.println("getSystemProperties\t\t"
|
|
+ runtime.getSystemProperties());
|
|
System.out.println("getUptime\t\t"
|
|
+ runtime.getUptime());
|
|
System.out.println("getVmName\t\t"
|
|
+ runtime.getVmName());
|
|
System.out.println("getVmVendor\t\t"
|
|
+ runtime.getVmVendor());
|
|
System.out.println("getVmVersion\t\t"
|
|
+ runtime.getVmVersion());
|
|
boolean supported = runtime.isBootClassPathSupported() ;
|
|
System.out.println("isBootClassPathSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("getBootClassPath\t\t"
|
|
+ runtime.getBootClassPath());
|
|
}
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doOperatingSystemMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- OperatingSystemMXBean") ;
|
|
|
|
try {
|
|
ObjectName operationName =
|
|
new ObjectName(ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(operationName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
OperatingSystemMXBean operation = null ;
|
|
|
|
operation =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
operationName,
|
|
OperatingSystemMXBean.class) ;
|
|
System.out.println("getArch\t\t"
|
|
+ operation.getArch());
|
|
System.out.println("getAvailableProcessors\t\t"
|
|
+ operation.getAvailableProcessors());
|
|
System.out.println("getName\t\t"
|
|
+ operation.getName());
|
|
System.out.println("getVersion\t\t"
|
|
+ operation.getVersion());
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doCompilationMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- CompilationMXBean") ;
|
|
|
|
try {
|
|
ObjectName compilationName =
|
|
new ObjectName(ManagementFactory.COMPILATION_MXBEAN_NAME);
|
|
|
|
if ( mbsc.isRegistered(compilationName) ) {
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(compilationName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
CompilationMXBean compilation = null ;
|
|
|
|
compilation =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
compilationName,
|
|
CompilationMXBean.class) ;
|
|
System.out.println("getName\t\t"
|
|
+ compilation.getName());
|
|
boolean supported =
|
|
compilation.isCompilationTimeMonitoringSupported() ;
|
|
System.out.println("isCompilationTimeMonitoringSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("getTotalCompilationTime\t\t"
|
|
+ compilation.getTotalCompilationTime());
|
|
}
|
|
}
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doGarbageCollectorMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- GarbageCollectorMXBean") ;
|
|
|
|
try {
|
|
ObjectName filterName =
|
|
new ObjectName(ManagementFactory.GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE
|
|
+ ",*");
|
|
Set<ObjectName> onSet = mbsc.queryNames(filterName, null);
|
|
|
|
for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {
|
|
ObjectName garbageName = iter.next() ;
|
|
System.out.println("-------- " + garbageName) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(garbageName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
GarbageCollectorMXBean garbage = null ;
|
|
|
|
garbage =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
garbageName,
|
|
GarbageCollectorMXBean.class) ;
|
|
System.out.println("getCollectionCount\t\t"
|
|
+ garbage.getCollectionCount());
|
|
System.out.println("getCollectionTime\t\t"
|
|
+ garbage.getCollectionTime());
|
|
}
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doMemoryManagerMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- MemoryManagerMXBean") ;
|
|
|
|
try {
|
|
ObjectName filterName =
|
|
new ObjectName(ManagementFactory.MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE
|
|
+ ",*");
|
|
Set<ObjectName> onSet = mbsc.queryNames(filterName, null);
|
|
|
|
for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {
|
|
ObjectName memoryManagerName = iter.next() ;
|
|
System.out.println("-------- " + memoryManagerName) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryManagerName);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
MemoryManagerMXBean memoryManager = null;
|
|
|
|
memoryManager =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
memoryManagerName,
|
|
MemoryManagerMXBean.class) ;
|
|
System.out.println("getMemoryPoolNames\t\t"
|
|
+ Arrays.deepToString(memoryManager.getMemoryPoolNames()));
|
|
System.out.println("getName\t\t"
|
|
+ memoryManager.getName());
|
|
System.out.println("isValid\t\t"
|
|
+ memoryManager.isValid());
|
|
}
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private final int doMemoryPoolMXBeanTest(MBeanServerConnection mbsc) {
|
|
int errorCount = 0 ;
|
|
System.out.println("---- MemoryPoolMXBean") ;
|
|
|
|
try {
|
|
ObjectName filterName =
|
|
new ObjectName(ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE
|
|
+ ",*");
|
|
Set<ObjectName> onSet = mbsc.queryNames(filterName, null);
|
|
|
|
for (Iterator<ObjectName> iter = onSet.iterator(); iter.hasNext(); ) {
|
|
ObjectName memoryPoolName = iter.next() ;
|
|
System.out.println("-------- " + memoryPoolName) ;
|
|
MBeanInfo mbInfo = mbsc.getMBeanInfo(memoryPoolName);
|
|
errorCount += checkNonEmpty(mbInfo);
|
|
System.out.println("getMBeanInfo\t\t" + mbInfo);
|
|
MemoryPoolMXBean memoryPool = null;
|
|
|
|
memoryPool =
|
|
JMX.newMXBeanProxy(mbsc,
|
|
memoryPoolName,
|
|
MemoryPoolMXBean.class,
|
|
true) ;
|
|
System.out.println("getCollectionUsage\t\t"
|
|
+ memoryPool.getCollectionUsage());
|
|
System.out.println("getMemoryManagerNames\t\t"
|
|
+ Arrays.deepToString(memoryPool.getMemoryManagerNames()));
|
|
System.out.println("getName\t\t"
|
|
+ memoryPool.getName());
|
|
System.out.println("getPeakUsage\t\t"
|
|
+ memoryPool.getPeakUsage());
|
|
System.out.println("getType\t\t"
|
|
+ memoryPool.getType());
|
|
System.out.println("getUsage\t\t"
|
|
+ memoryPool.getUsage());
|
|
System.out.println("isValid\t\t"
|
|
+ memoryPool.isValid());
|
|
boolean supported = memoryPool.isUsageThresholdSupported() ;
|
|
System.out.println("isUsageThresholdSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("getUsageThreshold\t\t"
|
|
+ memoryPool.getUsageThreshold());
|
|
System.out.println("isUsageThresholdExceeded\t\t"
|
|
+ memoryPool.isUsageThresholdExceeded());
|
|
System.out.println("getUsageThresholdCount\t\t"
|
|
+ memoryPool.getUsageThresholdCount());
|
|
}
|
|
|
|
supported = memoryPool.isCollectionUsageThresholdSupported() ;
|
|
System.out.println("isCollectionUsageThresholdSupported\t\t"
|
|
+ supported);
|
|
|
|
if ( supported ) {
|
|
System.out.println("getCollectionUsageThreshold\t\t"
|
|
+ memoryPool.getCollectionUsageThreshold());
|
|
System.out.println("getCollectionUsageThresholdCount\t\t"
|
|
+ memoryPool.getCollectionUsageThresholdCount());
|
|
System.out.println("isCollectionUsageThresholdExceeded\t\t"
|
|
+ memoryPool.isCollectionUsageThresholdExceeded());
|
|
}
|
|
|
|
memoryPool.resetPeakUsage();
|
|
}
|
|
|
|
System.out.println("---- OK\n") ;
|
|
} catch (Exception e) {
|
|
Utils.printThrowable(e, true) ;
|
|
errorCount++ ;
|
|
System.out.println("---- ERROR\n") ;
|
|
}
|
|
|
|
return errorCount ;
|
|
}
|
|
|
|
|
|
private int checkNonEmpty(MBeanInfo mbi) {
|
|
if ( mbi.toString().length() == 0 ) {
|
|
System.out.println("(ERROR) MBeanInfo is empty !");
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
}
|