7024172: Move BufferPoolMXBean and PlatformLoggingMXBean java.lang.management
Reviewed-by: alanb
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/lang/management/BufferPoolMXBean.java Tue Mar 29 15:50:55 2011 -0700
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2007, 2008, 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;
+
+/**
+ * The management interface for a buffer pool, for example a pool of
+ * {@link java.nio.ByteBuffer#allocateDirect direct} or {@link
+ * java.nio.MappedByteBuffer mapped} buffers.
+ *
+ * <p> A class implementing this interface is an
+ * {@link javax.management.MXBean}. A Java
+ * virtual machine has one or more implementations of this interface. The {@link
+ * java.lang.management.ManagementFactory#getPlatformMXBeans getPlatformMXBeans}
+ * method can be used to obtain the list of {@code BufferPoolMXBean} objects
+ * representing the management interfaces for pools of buffers as follows:
+ * <pre>
+ * List<BufferPoolMXBean> pools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
+ * </pre>
+ *
+ * <p> The management interfaces are also registered with the platform {@link
+ * javax.management.MBeanServer MBeanServer}. The {@link
+ * javax.management.ObjectName ObjectName} that uniquely identifies the
+ * management interface within the {@code MBeanServer} takes the form:
+ * <pre>
+ * java.nio:type=BufferPool,name=<i>pool name</i>
+ * </pre>
+ * where <em>pool name</em> is the {@link #getName name} of the buffer pool.
+ *
+ * @since 1.7
+ */
+public interface BufferPoolMXBean extends PlatformManagedObject {
+
+ /**
+ * Returns the name representing this buffer pool.
+ *
+ * @return The name of this buffer pool.
+ */
+ String getName();
+
+ /**
+ * Returns an estimate of the number of buffers in the pool.
+ *
+ * @return An estimate of the number of buffers in this pool
+ */
+ long getCount();
+
+ /**
+ * Returns an estimate of the total capacity of the buffers in this pool.
+ * A buffer's capacity is the number of elements it contains and the value
+ * returned by this method is an estimate of the total capacity of buffers
+ * in the pool in bytes.
+ *
+ * @return An estimate of the total capacity of the buffers in this pool
+ * in bytes
+ */
+ long getTotalCapacity();
+
+ /**
+ * Returns an estimate of the memory that the Java virtual machine is using
+ * for this buffer pool. The value returned by this method may differ
+ * from the estimate of the total {@link #getTotalCapacity capacity} of
+ * the buffers in this pool. This difference is explained by alignment,
+ * memory allocator, and other implementation specific reasons.
+ *
+ * @return An estimate of the memory that the Java virtual machine is using
+ * for this buffer pool in bytes, or {@code -1L} if an estimate of
+ * the memory usage is not available
+ */
+ long getMemoryUsed();
+}
--- a/jdk/src/share/classes/java/lang/management/ManagementFactory.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/lang/management/ManagementFactory.java Tue Mar 29 15:50:55 2011 -0700
@@ -40,8 +40,9 @@
import javax.management.StandardEmitterMBean;
import javax.management.StandardMBean;
import java.util.Collections;
-import java.util.ArrayList;
import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
import java.security.AccessController;
import java.security.Permission;
import java.security.PrivilegedAction;
@@ -51,37 +52,63 @@
import sun.management.ManagementFactoryHelper;
/**
- * The <tt>ManagementFactory</tt> class is a factory class for getting
+ * The {@code ManagementFactory} class is a factory class for getting
* managed beans for the Java platform.
* This class consists of static methods each of which returns
- * one or more <a href="#MXBean">platform MXBean(s)</a> representing
+ * one or more <i>platform MXBeans</i> representing
* the management interface of a component of the Java virtual
* machine.
+ * <p>
+ * <h4><a name="MXBean">Platform MXBeans</a></h4>
+ * <p>
+ * A platform MXBean is a <i>managed bean</i> that
+ * conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
+ * Instrumentation Specification and only uses a set of basic data types.
+ * A JMX management application and the {@linkplain
+ * #getPlatformMBeanServer platform MBeanServer}
+ * can interoperate without requiring classes for MXBean specific
+ * data types.
+ * The data types being transmitted between the JMX connector
+ * server and the connector client are
+ * {@linkplain javax.management.openmbean.OpenType open types}
+ * and this allows interoperation across versions.
+ * See <a href="../../../javax/management/MXBean.html#MXBean-spec">
+ * the specification of MXBeans</a> for details.
+ *
+ * <a name="MXBeanNames"></a>
+ * <p>Each platform MXBean is a {@link PlatformManagedObject}
+ * and it has a unique
+ * {@link javax.management.ObjectName ObjectName} for
+ * registration in the platform {@code MBeanServer} as returned by
+ * by the {@link PlatformManagedObject#getObjectName getObjectName}
+ * method.
*
* <p>
* An application can access a platform MXBean in the following ways:
+ * <h5>1. Direct access to an MXBean interface</h5>
+ * <blockquote>
* <ul>
- * <li><i>Direct access to an MXBean interface</i>
- * <ol type="a">
- * <li>Get the MXBean instance through the static factory method,
- * or the {@link #getPlatformMXBeans(Class)} method
- * and access the MXBean locally of the running
+ * <li>Get an MXBean instance by calling the
+ * {@link #getPlatformMXBean(Class) getPlatformMXBean} or
+ * {@link #getPlatformMXBeans(Class) getPlatformMXBeans} method
+ * and access the MXBean locally in the running
* virtual machine.
* </li>
* <li>Construct an MXBean proxy instance that forwards the
* method calls to a given {@link MBeanServer MBeanServer} by calling
- * the {@link #newPlatformMXBeanProxy newPlatformMXBeanProxy} method
- * or the {@link #getPlatformMXBeans(MBeanServerConnection, Class)}
- * method.
+ * the {@link #getPlatformMXBean(MBeanServerConnection, Class)} or
+ * {@link #getPlatformMXBeans(MBeanServerConnection, Class)} method.
+ * The {@link #newPlatformMXBeanProxy newPlatformMXBeanProxy} method
+ * can also be used to construct an MXBean proxy instance of
+ * a given {@code ObjectName}.
* A proxy is typically constructed to remotely access
* an MXBean of another running virtual machine.
* </li>
- * </ol></li>
- * <li><i>Indirect access to an MXBean interface via MBeanServer</i>
- * <ol type="a">
- * <li>Go through the {@link #getPlatformMBeanServer
- * platform MBeanServer} to access MXBeans locally or
- * a specific <tt>MBeanServerConnection</tt> to access
+ * </ul>
+ * <h5>2. Indirect access to an MXBean interface via MBeanServer</h5>
+ * <ul>
+ * <li>Go through the platform {@code MBeanServer} to access MXBeans
+ * locally or a specific <tt>MBeanServerConnection</tt> to access
* MXBeans remotely.
* The attributes and operations of an MXBean use only
* <em>JMX open types</em> which include basic data types,
@@ -89,133 +116,19 @@
* and {@link javax.management.openmbean.TabularData TabularData}
* defined in
* {@link javax.management.openmbean.OpenType OpenType}.
- * The mapping is specified below.
+ * The mapping is specified in
+ * the {@linkplain javax.management.MXBean MXBean} specification
+ * for details.
* </li>
- * </ol></li>
* </ul>
- *
- * <h4><a name="MXBean">Platform MXBeans</a></h4>
- * A platform MXBean is a <i>managed bean</i> that conforms to
- * the JMX Instrumentation Specification and only uses
- * a set of basic data types described below.
- * See <a href="../../../javax/management/MXBean.html#MXBean-spec">
- * the specification of MXBeans</a> for details.
- * All platform MXBean interfaces extend {@link PlatformManagedObject}s
- * and new methods may be added in these interfaces
- * in future Java SE releases.
- * <p>
- * A JMX management application and the platform <tt>MBeanServer</tt>
- * can interoperate without requiring classes for MXBean specific
- * data types.
- * The data types being transmitted between the JMX connector
- * server and the connector client are
- * {@linkplain javax.management.openmbean.OpenType open types}
- * and this allows interoperation across versions.
- * <p>
- * The platform MXBean interfaces use only the following data types:
- * <ul>
- * <li>Primitive types such as <tt>int</tt>, <tt>long</tt>,
- * <tt>boolean</tt>, etc</li>
- * <li>Wrapper classes for primitive types such as
- * {@link java.lang.Integer Integer}, {@link java.lang.Long Long},
- * {@link java.lang.Boolean Boolean}, etc and
- * {@link java.lang.String String}</li>
- * <li>{@link java.lang.Enum Enum} classes</li>
- * <li>Classes that define only getter methods and define a static
- * <tt>from</tt> method with a
- * {@link javax.management.openmbean.CompositeData CompositeData}
- * argument to convert from an input <tt>CompositeData</tt> to
- * an instance of that class
- * </li>
- * <li>{@link java.util.List List<E>}
- * where <tt>E</tt> is a primitive type, a wrapper class,
- * an enum class, or a class supporting conversion from a
- * <tt>CompositeData</tt> to its class
- * </li>
- * <li>{@link java.util.Map Map<K,V>}
- * where <tt>K</tt> and <tt>V</tt> are
- * a primitive type, a wrapper class,
- * an enum class, or a class supporting conversion from a
- * <tt>CompositeData</tt> to its class
- * </li>
- * </ul>
+ * </blockquote>
*
* <p>
- * When an attribute or operation of a platform MXBean
- * is accessed via an <tt>MBeanServer</tt>, the data types are mapped
- * as follows:
- * <ul>
- * <li>A primitive type or a wrapper class is mapped
- * to the same type.
- * </li>
- * <li>An {@link Enum} is mapped to
- * <tt>String</tt> whose value is the name of the enum constant.
- * <li>A class that defines only getter methods and a static
- * <tt>from</tt> method with a
- * {@link javax.management.openmbean.CompositeData CompositeData}
- * argument is mapped to
- * {@link javax.management.openmbean.CompositeData CompositeData}.
- * </li>
- * <li><tt>Map<K,V></tt> is mapped to
- * {@link javax.management.openmbean.TabularData TabularData}
- * whose row type is a
- * {@link javax.management.openmbean.CompositeType CompositeType} with
- * two items whose names are <i>"key"</i> and <i>"value"</i>
- * and the item types are
- * the corresponding mapped type of <tt>K</tt> and <tt>V</tt>
- * respectively and the <i>"key"</i> is the index.
- * </li>
- * <li><tt>List<E></tt> is mapped to an array with the mapped
- * type of <tt>E</tt> as the element type.
- * </li>
- * <li>An array of element type <tt>E</tt> is mapped to
- * an array of the same dimenions with the mapped type of <tt>E</tt>
- * as the element type.</li>
- * </ul>
- *
- * The {@link javax.management.MBeanInfo MBeanInfo}
- * for a platform MXBean
- * describes the data types of the attributes and operations
- * as primitive or open types mapped as specified above.
- *
+ * The {@link #getPlatformManagementInterfaces getPlatformManagementInterfaces}
+ * method returns all management interfaces supported in the Java virtual machine
+ * including the standard management interfaces listed in the tables
+ * below as well as the management interfaces extended by the JDK implementation.
* <p>
- * For example, the {@link MemoryMXBean}
- * interface has the following <i>getter</i> and <i>setter</i> methods:
- *
- * <blockquote><pre>
- * public MemoryUsage getHeapMemoryUsage();
- * public boolean isVerbose();
- * public void setVerbose(boolean value);
- * </pre></blockquote>
- *
- * These attributes in the <tt>MBeanInfo</tt>
- * of the <tt>MemoryMXBean</tt> have the following names and types:
- *
- * <blockquote>
- * <table border>
- * <tr>
- * <th>Attribute Name</th>
- * <th>Type</th>
- * </tr>
- * <tr>
- * <td><tt>HeapMemoryUsage</tt></td>
- * <td>{@link MemoryUsage#from
- * CompositeData representing MemoryUsage}</td>
- * </tr>
- * <tr>
- * <td><tt>Verbose</tt></td>
- * <td><tt>boolean</tt></td>
- * </tr>
- * </table>
- * </blockquote>
- *
- * <h4><a name="MXBeanNames">MXBean Names</a></h4>
- * Each platform MXBean for a Java virtual machine has a unique
- * {@link javax.management.ObjectName ObjectName} for
- * registration in the platform <tt>MBeanServer</tt> that can
- * be obtained by calling the {@link PlatformManagedObject#getObjectName}
- * method.
- *
* A Java virtual machine has a single instance of the following management
* interfaces:
*
@@ -228,27 +141,32 @@
* <tr>
* <td> {@link ClassLoadingMXBean} </td>
* <td> {@link #CLASS_LOADING_MXBEAN_NAME
- * <tt>java.lang:type=ClassLoading</tt>}</td>
+ * java.lang:type=ClassLoading}</td>
* </tr>
* <tr>
* <td> {@link MemoryMXBean} </td>
* <td> {@link #MEMORY_MXBEAN_NAME
- * <tt>java.lang:type=Memory</tt>}</td>
+ * java.lang:type=Memory}</td>
* </tr>
* <tr>
* <td> {@link ThreadMXBean} </td>
* <td> {@link #THREAD_MXBEAN_NAME
- * <tt>java.lang:type=Threading</tt>}</td>
+ * java.lang:type=Threading}</td>
* </tr>
* <tr>
* <td> {@link RuntimeMXBean} </td>
* <td> {@link #RUNTIME_MXBEAN_NAME
- * <tt>java.lang:type=Runtime</tt>}</td>
+ * java.lang:type=Runtime}</td>
* </tr>
* <tr>
* <td> {@link OperatingSystemMXBean} </td>
* <td> {@link #OPERATING_SYSTEM_MXBEAN_NAME
- * <tt>java.lang:type=OperatingSystem</tt>}</td>
+ * java.lang:type=OperatingSystem}</td>
+ * </tr>
+ * <tr>
+ * <td> {@link PlatformLoggingMXBean} </td>
+ * <td> {@link java.util.logging.LogManager#LOGGING_MXBEAN_NAME
+ * java.util.logging:type=Logging}</td>
* </tr>
* </table>
* </blockquote>
@@ -266,7 +184,7 @@
* <tr>
* <td> {@link CompilationMXBean} </td>
* <td> {@link #COMPILATION_MXBEAN_NAME
- * <tt>java.lang:type=Compilation</tt>}</td>
+ * java.lang:type=Compilation}</td>
* </tr>
* </table>
* </blockquote>
@@ -283,17 +201,21 @@
* <tr>
* <td> {@link GarbageCollectorMXBean} </td>
* <td> {@link #GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE
- * <tt>java.lang:type=GarbageCollector</tt>}<tt>,name=</tt><i>collector's name</i></td>
+ * java.lang:type=GarbageCollector}<tt>,name=</tt><i>collector's name</i></td>
* </tr>
* <tr>
* <td> {@link MemoryManagerMXBean} </td>
* <td> {@link #MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE
- * <tt>java.lang:type=MemoryManager</tt>}<tt>,name=</tt><i>manager's name</i></td>
+ * java.lang:type=MemoryManager}<tt>,name=</tt><i>manager's name</i></td>
* </tr>
* <tr>
* <td> {@link MemoryPoolMXBean} </td>
* <td> {@link #MEMORY_POOL_MXBEAN_DOMAIN_TYPE
- * <tt>java.lang:type=MemoryPool</tt>}<tt>,name=</tt><i>pool's name</i></td>
+ * java.lang:type=MemoryPool}<tt>,name=</tt><i>pool's name</i></td>
+ * </tr>
+ * <tr>
+ * <td> {@link BufferPoolMXBean} </td>
+ * <td> {@code java.nio:type=BufferPool,name=}<i>pool name</i></td>
* </tr>
* </table>
* </blockquote>
@@ -302,7 +224,6 @@
* JMX Specification</a>
* @see <a href="package-summary.html#examples">
* Ways to Access Management Metrics</a>
- * @see java.util.logging.LoggingMXBean
* @see javax.management.MXBean
*
* @author Mandy Chung
@@ -496,35 +417,35 @@
/**
* Returns the platform {@link javax.management.MBeanServer MBeanServer}.
* On the first call to this method, it first creates the platform
- * <tt>MBeanServer</tt> by calling the
+ * {@code MBeanServer} by calling the
* {@link javax.management.MBeanServerFactory#createMBeanServer
* MBeanServerFactory.createMBeanServer}
- * method and registers the platform MXBeans in this platform
- * <tt>MBeanServer</tt> using the <a href="#MXBeanNames">MXBean names</a>
- * defined in the class description.
+ * method and registers each platform MXBean in this platform
+ * {@code MBeanServer} with its
+ * {@link PlatformManagedObject#getObjectName ObjectName}.
* This method, in subsequent calls, will simply return the
- * initially created platform <tt>MBeanServer</tt>.
+ * initially created platform {@code MBeanServer}.
* <p>
* MXBeans that get created and destroyed dynamically, for example,
* memory {@link MemoryPoolMXBean pools} and
* {@link MemoryManagerMXBean managers},
* will automatically be registered and deregistered into the platform
- * <tt>MBeanServer</tt>.
+ * {@code MBeanServer}.
* <p>
- * If the system property <tt>javax.management.builder.initial</tt>
- * is set, the platform <tt>MBeanServer</tt> creation will be done
+ * If the system property {@code javax.management.builder.initial}
+ * is set, the platform {@code MBeanServer} creation will be done
* by the specified {@link javax.management.MBeanServerBuilder}.
* <p>
* It is recommended that this platform MBeanServer also be used
* to register other application managed beans
* besides the platform MXBeans.
* This will allow all MBeans to be published through the same
- * <tt>MBeanServer</tt> and hence allow for easier network publishing
+ * {@code MBeanServer} and hence allow for easier network publishing
* and discovery.
* Name conflicts with the platform MXBeans should be avoided.
*
- * @return the platform <tt>MBeanServer</tt>; the platform
- * MXBeans are registered into the platform <tt>MBeanServer</tt>
+ * @return the platform {@code MBeanServer}; the platform
+ * MXBeans are registered into the platform {@code MBeanServer}
* at the first time this method is called.
*
* @exception SecurityException if there is a security manager
@@ -671,7 +592,9 @@
try {
final ObjectName objName = new ObjectName(mxbeanName);
- if (!connection.isInstanceOf(objName, interfaceClass.getName())) {
+ // skip the isInstanceOf check for LoggingMXBean
+ String intfName = interfaceClass.getName();
+ if (!connection.isInstanceOf(objName, intfName)) {
throw new IllegalArgumentException(mxbeanName +
" is not an instance of " + interfaceClass);
}
@@ -683,55 +606,128 @@
// create an MXBean proxy
return JMX.newMXBeanProxy(connection, objName, mxbeanInterface,
emitter);
- } catch (InstanceNotFoundException e) {
- final IllegalArgumentException iae =
- new IllegalArgumentException(mxbeanName +
- " not found in the connection.");
- iae.initCause(e);
- throw iae;
- } catch (MalformedObjectNameException e) {
- final IllegalArgumentException iae =
- new IllegalArgumentException(mxbeanName +
- " is not a valid ObjectName format.");
- iae.initCause(e);
- throw iae;
+ } catch (InstanceNotFoundException|MalformedObjectNameException e) {
+ throw new IllegalArgumentException(e);
}
}
/**
- * Returns the list of platform MXBeans that implement
- * the given {@code mxbeanInterface} in the running Java
+ * Returns the platform MXBean implementing
+ * the given {@code mxbeanInterface} which is specified
+ * to have one single instance in the Java virtual machine.
+ * This method may return {@code null} if the management interface
+ * is not implemented in the Java virtual machine (for example,
+ * a Java virtual machine with no compilation system does not
+ * implement {@link CompilationMXBean});
+ * otherwise, this method is equivalent to calling:
+ * <pre>
+ * {@link #getPlatformMXBeans(Class)
+ * getPlatformMXBeans(mxbeanInterface)}.get(0);
+ * </pre>
+ *
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean with one single instance in the Java virtual machine
+ * if implemented.
+ *
+ * @return the platform MXBean that implements
+ * {@code mxbeanInterface}, or {@code null} if not exist.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface or
+ * not a singleton platform MXBean.
+ *
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject>
+ T getPlatformMXBean(Class<T> mxbeanInterface) {
+ PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
+ if (pc == null)
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " is not a platform management interface");
+ if (!pc.isSingleton())
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " can have zero or more than one instances");
+
+ return pc.getSingletonMXBean(mxbeanInterface);
+ }
+
+ /**
+ * Returns the list of platform MXBeans implementing
+ * the given {@code mxbeanInterface} in the Java
* virtual machine.
* The returned list may contain zero, one, or more instances.
* The number of instances in the returned list is defined
* in the specification of the given management interface.
+ * The order is undefined and there is no guarantee that
+ * the list returned is in the same order as previous invocations.
*
* @param mxbeanInterface a management interface for a platform
* MXBean
*
- * @return the list of platform MXBeans that implements
+ * @return the list of platform MXBeans that implement
* {@code mxbeanInterface}.
*
* @throws IllegalArgumentException if {@code mxbeanInterface}
- * is not a management interface for the platform.
+ * is not a platform management interface.
*
* @since 1.7
*/
public static <T extends PlatformManagedObject> List<T>
getPlatformMXBeans(Class<T> mxbeanInterface) {
- String className = mxbeanInterface.getName();
- for (PlatformComponent component: PlatformComponent.values()) {
- // comparing the class name first instead of the Class instance
- // to avoid causing unnecessary class loading of
- // the other MXBean interfaces
- if (className.equals(component.getMXBeanInterfaceName())) {
- if (component.getMXBeanInterface() == mxbeanInterface) {
- return component.getMXBeans(mxbeanInterface);
- }
- }
- }
- throw new IllegalArgumentException(mxbeanInterface.getName() +
- " is not implemented by any of the platform MXBeans.");
+ PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
+ if (pc == null)
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " is not a platform management interface");
+ return Collections.unmodifiableList(pc.getMXBeans(mxbeanInterface));
+ }
+
+ /**
+ * Returns the platform MXBean proxy for
+ * {@code mxbeanInterface} which is specified to have one single
+ * instance in a Java virtual machine and the proxy will
+ * forward the method calls through the given {@code MBeanServerConnection}.
+ * This method may return {@code null} if the management interface
+ * is not implemented in the Java virtual machine being monitored
+ * (for example, a Java virtual machine with no compilation system
+ * does not implement {@link CompilationMXBean});
+ * otherwise, this method is equivalent to calling:
+ * <pre>
+ * {@link #getPlatformMXBeans(MBeanServerConnection, Class)
+ * getPlatformMXBeans(connection, mxbeanInterface)}.get(0);
+ * </pre>
+ *
+ * @param connection the {@code MBeanServerConnection} to forward to.
+ * @param mxbeanInterface a management interface for a platform
+ * MXBean with one single instance in the Java virtual machine
+ * being monitored, if implemented.
+ *
+ * @return the platform MXBean proxy for
+ * forwarding the method calls of the {@code mxbeanInterface}
+ * through the given {@code MBeanServerConnection},
+ * or {@code null} if not exist.
+ *
+ * @throws IllegalArgumentException if {@code mxbeanInterface}
+ * is not a platform management interface or
+ * not a singleton platform MXBean.
+ * @throws java.io.IOException if a communication problem
+ * occurred when accessing the {@code MBeanServerConnection}.
+ *
+ * @see #newPlatformMXBeanProxy
+ * @since 1.7
+ */
+ public static <T extends PlatformManagedObject>
+ T getPlatformMXBean(MBeanServerConnection connection,
+ Class<T> mxbeanInterface)
+ throws java.io.IOException
+ {
+ PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
+ if (pc == null)
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " is not a platform management interface");
+ if (!pc.isSingleton())
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " can have zero or more than one instances");
+ return pc.getSingletonMXBean(connection, mxbeanInterface);
}
/**
@@ -741,6 +737,8 @@
* The returned list may contain zero, one, or more instances.
* The number of instances in the returned list is defined
* in the specification of the given management interface.
+ * The order is undefined and there is no guarantee that
+ * the list returned is in the same order as previous invocations.
*
* @param connection the {@code MBeanServerConnection} to forward to.
* @param mxbeanInterface a management interface for a platform
@@ -751,54 +749,49 @@
* through the given {@code MBeanServerConnection}.
*
* @throws IllegalArgumentException if {@code mxbeanInterface}
- * is not a management interface for the platform.
+ * is not a platform management interface.
*
* @throws java.io.IOException if a communication problem
* occurred when accessing the {@code MBeanServerConnection}.
*
+ * @see #newPlatformMXBeanProxy
* @since 1.7
*/
public static <T extends PlatformManagedObject>
- List<T> getPlatformMXBeans(MBeanServerConnection connection,
- Class<T> mxbeanInterface)
+ List<T> getPlatformMXBeans(MBeanServerConnection connection,
+ Class<T> mxbeanInterface)
throws java.io.IOException
{
- String className = mxbeanInterface.getName();
- for (PlatformComponent component: PlatformComponent.values()) {
- // comparing the class name first instead of the Class instance
- // to avoid causing unnecessary class loading of
- // the other MXBean interfaces
- if (className.equals(component.getMXBeanInterfaceName())) {
- if (component.getMXBeanInterface() == mxbeanInterface) {
- return component.getMXBeans(connection,
- mxbeanInterface);
- }
- }
+ PlatformComponent pc = PlatformComponent.getPlatformComponent(mxbeanInterface);
+ if (pc == null) {
+ throw new IllegalArgumentException(mxbeanInterface.getName() +
+ " is not a platform management interface");
}
- throw new IllegalArgumentException(mxbeanInterface.getName() +
- " is not implemented by any of the platform MXBeans.");
+ return Collections.unmodifiableList(pc.getMXBeans(connection, mxbeanInterface));
}
/**
- * Returns a list of {@code Class} objects, subinterface of
+ * Returns the set of {@code Class} objects, subinterface of
* {@link PlatformManagedObject}, representing
* all management interfaces for
* monitoring and managing the Java platform.
*
- * @return a list of {@code Class} objects, subinterface of
+ * @return the set of {@code Class} objects, subinterface of
* {@link PlatformManagedObject} representing
* the management interfaces for
* monitoring and managing the Java platform.
*
* @since 1.7
*/
- public static List<Class<? extends PlatformManagedObject>> getAllPlatformMXBeanInterfaces() {
- List<Class<? extends PlatformManagedObject>> result =
- new ArrayList<>();
+ public static Set<Class<? extends PlatformManagedObject>>
+ getPlatformManagementInterfaces()
+ {
+ Set<Class<? extends PlatformManagedObject>> result =
+ new TreeSet<>();
for (PlatformComponent component: PlatformComponent.values()) {
result.add(component.getMXBeanInterface());
}
- return result;
+ return Collections.unmodifiableSet(result);
}
private static final String NOTIF_EMITTER =
@@ -810,7 +803,9 @@
private static void addMXBean(final MBeanServer mbs, final PlatformManagedObject pmo) {
// Make DynamicMBean out of MXBean by wrapping it with a StandardMBean
final DynamicMBean dmbean;
- if (pmo instanceof NotificationEmitter) {
+ if (pmo instanceof DynamicMBean) {
+ dmbean = DynamicMBean.class.cast(pmo);
+ } else if (pmo instanceof NotificationEmitter) {
dmbean = new StandardEmitterMBean(pmo, null, true, (NotificationEmitter) pmo);
} else {
dmbean = new StandardMBean(pmo, null, true);
--- a/jdk/src/share/classes/java/lang/management/PlatformComponent.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/lang/management/PlatformComponent.java Tue Mar 29 15:50:55 2011 -0700
@@ -29,9 +29,9 @@
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 java.util.logging.PlatformLoggingMXBean;
-import java.nio.BufferPoolMXBean;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
@@ -66,6 +66,7 @@
CLASS_LOADING(
"java.lang.management.ClassLoadingMXBean",
"java.lang", "ClassLoading", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<ClassLoadingMXBean>() {
public List<ClassLoadingMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getClassLoadingMXBean());
@@ -78,6 +79,7 @@
COMPILATION(
"java.lang.management.CompilationMXBean",
"java.lang", "Compilation", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<CompilationMXBean>() {
public List<CompilationMXBean> getMXBeans() {
CompilationMXBean m = ManagementFactoryHelper.getCompilationMXBean();
@@ -95,6 +97,7 @@
MEMORY(
"java.lang.management.MemoryMXBean",
"java.lang", "Memory", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<MemoryMXBean>() {
public List<MemoryMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getMemoryMXBean());
@@ -107,6 +110,7 @@
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.
@@ -120,6 +124,7 @@
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();
@@ -133,6 +138,7 @@
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();
@@ -145,6 +151,7 @@
OPERATING_SYSTEM(
"java.lang.management.OperatingSystemMXBean",
"java.lang", "OperatingSystem", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<OperatingSystemMXBean>() {
public List<OperatingSystemMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getOperatingSystemMXBean());
@@ -157,6 +164,7 @@
RUNTIME(
"java.lang.management.RuntimeMXBean",
"java.lang", "Runtime", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<RuntimeMXBean>() {
public List<RuntimeMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getRuntimeMXBean());
@@ -169,6 +177,7 @@
THREADING(
"java.lang.management.ThreadMXBean",
"java.lang", "Threading", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<ThreadMXBean>() {
public List<ThreadMXBean> getMXBeans() {
return Collections.singletonList(ManagementFactoryHelper.getThreadMXBean());
@@ -180,11 +189,17 @@
* Logging facility.
*/
LOGGING(
- "java.util.logging.PlatformLoggingMXBean",
+ "java.lang.management.PlatformLoggingMXBean",
"java.util.logging", "Logging", defaultKeyProperties(),
+ true, // singleton
new MXBeanFetcher<PlatformLoggingMXBean>() {
public List<PlatformLoggingMXBean> getMXBeans() {
- return ManagementFactoryHelper.getLoggingMXBean();
+ PlatformLoggingMXBean m = ManagementFactoryHelper.getPlatformLoggingMXBean();
+ if (m == null) {
+ return Collections.emptyList();
+ } else {
+ return Collections.singletonList(m);
+ }
}
}),
@@ -192,8 +207,9 @@
* Buffer pools.
*/
BUFFER_POOL(
- "java.nio.BufferPoolMXBean",
+ "java.lang.management.BufferPoolMXBean",
"java.nio", "BufferPool", keyProperties("name"),
+ false, // zero or more instances
new MXBeanFetcher<BufferPoolMXBean>() {
public List<BufferPoolMXBean> getMXBeans() {
return ManagementFactoryHelper.getBufferPoolMXBeans();
@@ -209,6 +225,7 @@
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);
@@ -222,6 +239,7 @@
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);
@@ -234,6 +252,7 @@
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);
@@ -246,6 +265,7 @@
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());
@@ -296,27 +316,19 @@
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,
- MXBeanFetcher fetcher) {
- this.mxbeanInterfaceName = intfName;
- this.domain = domain;
- this.type = type;
- this.keyProperties = keyProperties;
- this.fetcher = fetcher;
- this.subComponents = new PlatformComponent[0];
- }
- 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;
}
@@ -338,6 +350,10 @@
return set;
}
+ boolean isSingleton() {
+ return singleton;
+ }
+
String getMXBeanInterfaceName() {
return mxbeanInterfaceName;
}
@@ -360,8 +376,35 @@
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>
- List<T> getMXBeans(MBeanServerConnection mbs, Class<T> mxbeanInterface)
+ 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<>();
@@ -391,5 +434,34 @@
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;
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/java/lang/management/PlatformLoggingMXBean.java Tue Mar 29 15:50:55 2011 -0700
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2009, 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;
+
+/**
+ * The management interface for the {@linkplain java.util.logging logging} facility.
+ *
+ * <p>There is a single global instance of the <tt>PlatformLoggingMXBean</tt>.
+ * The {@link java.lang.management.ManagementFactory#getPlatformMXBean(Class)
+ * ManagementFactory.getPlatformMXBean} method can be used to obtain
+ * the {@code PlatformLoggingMXBean} object as follows:
+ * <pre>
+ * PlatformLoggingMXBean logging = ManagementFactory.getPlatformMXBean(PlatformLoggingMXBean.class);
+ * </pre>
+ * The {@code PlatformLoggingMXBean} object is also registered with the
+ * platform {@linkplain java.lang.management.ManagementFactory#getPlatformMBeanServer
+ * MBeanServer}.
+ * The {@link javax.management.ObjectName ObjectName} for uniquely
+ * identifying the {@code PlatformLoggingMXBean} within an MBeanServer is:
+ * <pre>
+ * {@link java.util.logging.LogManager#LOGGING_MXBEAN_NAME java.util.logging:type=Logging}
+ * </pre>
+ *
+ * <p>The instance registered in the platform <tt>MBeanServer</tt> with
+ * this {@code ObjectName} implements all attributes defined by
+ * {@link java.util.logging.LoggingMXBean}.
+ *
+ * @since 1.7
+ */
+public interface PlatformLoggingMXBean extends PlatformManagedObject {
+
+ /**
+ * Returns the list of the currently registered
+ * {@linkplain java.util.logging.Logger logger} names. This method
+ * calls {@link java.util.logging.LogManager#getLoggerNames} and
+ * returns a list of the logger names.
+ *
+ * @return A list of {@code String} each of which is a
+ * currently registered {@code Logger} name.
+ */
+ java.util.List<String> getLoggerNames();
+
+ /**
+ * Gets the name of the log {@linkplain java.util.logging.Logger#getLevel
+ * level} associated with the specified logger.
+ * If the specified logger does not exist, {@code null}
+ * is returned.
+ * This method first finds the logger of the given name and
+ * then returns the name of the log level by calling:
+ * <blockquote>
+ * {@link java.util.logging.Logger#getLevel
+ * Logger.getLevel()}.{@link java.util.logging.Level#getName getName()};
+ * </blockquote>
+ *
+ * <p>
+ * If the {@code Level} of the specified logger is {@code null},
+ * which means that this logger's effective level is inherited
+ * from its parent, an empty string will be returned.
+ *
+ * @param loggerName The name of the {@code Logger} to be retrieved.
+ *
+ * @return The name of the log level of the specified logger; or
+ * an empty string if the log level of the specified logger
+ * is {@code null}. If the specified logger does not
+ * exist, {@code null} is returned.
+ *
+ * @see java.util.logging.Logger#getLevel
+ */
+ String getLoggerLevel(String loggerName);
+
+ /**
+ * Sets the specified logger to the specified new
+ * {@linkplain java.util.logging.Logger#setLevel level}.
+ * If the {@code levelName} is not {@code null}, the level
+ * of the specified logger is set to the parsed
+ * {@link java.util.logging.Level Level}
+ * matching the {@code levelName}.
+ * If the {@code levelName} is {@code null}, the level
+ * of the specified logger is set to {@code null} and
+ * the effective level of the logger is inherited from
+ * its nearest ancestor with a specific (non-null) level value.
+ *
+ * @param loggerName The name of the {@code Logger} to be set.
+ * Must be non-null.
+ * @param levelName The name of the level to set on the specified logger,
+ * or {@code null} if setting the level to inherit
+ * from its nearest ancestor.
+ *
+ * @throws IllegalArgumentException if the specified logger
+ * does not exist, or {@code levelName} is not a valid level name.
+ *
+ * @throws SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control").
+ *
+ * @see java.util.logging.Logger#setLevel
+ */
+ void setLoggerLevel(String loggerName, String levelName);
+
+ /**
+ * Returns the name of the
+ * {@linkplain java.util.logging.Logger#getParent parent}
+ * for the specified logger.
+ * If the specified logger does not exist, {@code null} is returned.
+ * If the specified logger is the root {@code Logger} in the namespace,
+ * the result will be an empty string.
+ *
+ * @param loggerName The name of a {@code Logger}.
+ *
+ * @return the name of the nearest existing parent logger;
+ * an empty string if the specified logger is the root logger.
+ * If the specified logger does not exist, {@code null}
+ * is returned.
+ */
+ String getParentLoggerName(String loggerName);
+}
--- a/jdk/src/share/classes/java/lang/management/PlatformManagedObject.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/lang/management/PlatformManagedObject.java Tue Mar 29 15:50:55 2011 -0700
@@ -46,7 +46,7 @@
* intended for the management interfaces for the platform to extend but
* not for applications.
*
- * @see <a href="ManagementFactory.html#MXBean">Platform MXBeans</a>
+ * @see ManagementFactory
* @since 1.7
*/
public interface PlatformManagedObject {
--- a/jdk/src/share/classes/java/lang/management/package.html Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/lang/management/package.html Tue Mar 29 15:50:55 2011 -0700
@@ -27,160 +27,124 @@
<html>
<body bgcolor="white">
-Provides the management interface for monitoring and management of the
-Java virtual machine as well as the operating system on which the
-Java virtual machine is running. It allows both local and remote
-monitoring and management of the running Java virtual machine.
-
-<h4>Platform MXBeans</h4>
-
-This package defines the management interface of the following
-components:
+Provides the management interfaces for monitoring and management of the
+Java virtual machine and other components in the Java runtime.
+It allows both local and remote
+monitoring and management of the running Java virtual machine.
+<p>
-<blockquote>
-<table cellspacing=1 summary="Description of the MBeans">
-<tr>
-<th><p align="left">Management Interface</p></th>
-<th><p align="left">Description</p></th>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.ClassLoadingMXBean}</tt> </td>
-<td> Class loading system of the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.CompilationMXBean}</tt> </td>
-<td> Compilation system of the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.MemoryMXBean}</tt> </td>
-<td> Memory system of the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.ThreadMXBean}</tt> </td>
-<td> Threads system of the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.RuntimeMXBean}</tt> </td>
-<td> Runtime system of the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.OperatingSystemMXBean}</tt> </td>
-<td> Operating system on which the Java virtual machine is running.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.GarbageCollectorMXBean}</tt> </td>
-<td> Garbage collector in the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.MemoryManagerMXBean}</tt> </td>
-<td> Memory manager in the Java virtual machine.</td>
-</tr>
-<tr>
-<td> <tt>{@link java.lang.management.MemoryPoolMXBean}</tt> </td>
-<td> Memory pool in the Java virtual machine.</td>
-</tr>
-</table>
-</blockquote>
-
+<h4><a name="MXBean">Platform MXBean</a></h4>
<p>
-A platform MXBean is a <i>managed bean</i> that defines the management
-interface for one component for the platform and is specified in the
-<a href="ManagementFactory.html#MXBean">
-ManagementFactory</a> class.
-
-<p>An application can monitor the instrumentation of the
-Java virtual machine and manage certain characteristics in
-the following ways:
-<ul>
-<li><i>Direct access to an MXBean interface</i>
- <ol type="a">
- <li>Get the MXBean instance through the static factory method
- and access the MXBean interface locally of the running
- virtual machine.</li>
- <li>Construct an MXBean proxy instance that
- forwards the method calls to a given
- {@link javax.management.MBeanServer MBeanServer}
- by calling
- {@link java.lang.management.ManagementFactory#newPlatformMXBeanProxy
- ManagementFactory.newPlatformMXBeanProxy}.
- A proxy is typically constructed to remotely access
- an MXBean of another running virtual machine.</li>
- </ol></li>
-<li><i>Indirect access via {@link javax.management.MBeanServer MBeanServer}
- interface</i>
- <ol type="a">
- <li>Go through the
- {@link java.lang.management.ManagementFactory#getPlatformMBeanServer
- platform MBeanServer} to access MXBeans locally or
- a specific <tt>MBeanServerConnection</tt> to access
- MXBeans remotely.
- The attributes and operations of an MXBean use only
- <em>JMX open types</em> which include basic data types,
- {@link javax.management.openmbean.CompositeData CompositeData},
- and {@link javax.management.openmbean.TabularData TabularData}
- defined in {@link javax.management.openmbean.OpenType OpenType}.
- </li>
- </ol></li>
-</ul>
-
-Below shows a few <a href="#examples">examples</a> of different
-ways to access MXBeans.
-
+A platform MXBean is a <i>managed bean</i> that
+conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
+Instrumentation Specification and only uses a set of basic data types.
+Each platform MXBean is a {@link java.lang.management.PlatformManagedObject}
+with a unique
+{@linkplain java.lang.management.PlatformManagedObject#getObjectName name}.
+<p>
<h4>ManagementFactory</h4>
-The {@link java.lang.management.ManagementFactory} class is the management
-factory class for the Java platform. This class provides a set of
+<p>The {@link java.lang.management.ManagementFactory} class is the management
+factory class for the Java platform. This class provides a set of
static factory methods to obtain the MXBeans for the Java platform
to allow an application to access the MXBeans directly.
<p>A <em>platform MBeanServer</em> can be accessed with the
{@link java.lang.management.ManagementFactory#getPlatformMBeanServer
getPlatformMBeanServer} method. On the first call to this method,
-it creates the platform MBeanServer and registers all platform MXBeans
-including platform MXBeans defined in other packages such as
-{@link java.util.logging.LoggingMXBean}.
-Each platform MXBean is registered with a unique name defined in the
-{@link java.lang.management.ManagementFactory ManagementFactory} class
-for constructing {@link javax.management.ObjectName ObjectName}.
-This is a single MBeanServer that can be shared by different managed
+it creates the platform MBeanServer and registers all platform MXBeans
+including {@linkplain java.lang.management.PlatformManagedObject
+platform MXBeans}.
+Each platform MXBean is registered with a unique name defined in
+the specification of the management interface.
+This is a single MBeanServer that can be shared by different managed
components running within the same Java virtual machine.
-
+
<h4>Interoperability</h4>
-A management application and a platform MBeanServer of a running
-virtual machine can interoperate
+<p>A management application and a platform MBeanServer of a running
+virtual machine can interoperate
without requiring classes used by the platform MXBean interfaces.
The data types being transmitted between the JMX connector
server and the connector client are JMX
-{@link javax.management.openmbean.OpenType open types} and
+{@linkplain javax.management.openmbean.OpenType open types} and
this allows interoperation across versions.
-
-<p>A data type used by the MXBean interfaces are mapped to
-an open type when being accessed via MBeanServer interface.
-The data type mapping is specified in the
-{@link java.lang.management.ManagementFactory ManagementFactory} class.
+A data type used by the MXBean interfaces are mapped to an
+open type when being accessed via MBeanServer interface.
+See the <a href="../../../javax/management/MXBean.html#MXBean-spec">
+MXBean</a> specification for details.
<h4><a name="examples">Ways to Access MXBeans</a></h4>
-There are three different ways to access the management interfaces.
-
+<p>An application can monitor the instrumentation of the
+Java virtual machine and the runtime in the following ways:
<p>
-<ol>
-<li>Call the methods in the MXBean directly within the same
- Java virtual machine.
-<blockquote><pre>
+<b>1. Direct access to an MXBean interface</b>
+<p>
+<ul>
+<li>Get an MXBean instance locally in the running Java virtual machine:<p>
+<pre>
RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();
// Get the standard attribute "VmVendor"
String vendor = mxbean.getVmVendor();
-
</pre>
-</blockquote>
+<p>Or by calling the
+ {@link java.lang.management.ManagementFactory#getPlatformMXBean(Class)
+ getPlatformMXBean} or
+ {@link java.lang.management.ManagementFactory#getPlatformMXBeans(Class)
+ getPlatformMXBeans} method:
+<pre>
+ RuntimeMXBean mxbean = ManagementFactory.getPlatformMXBean(RuntimeMXBean.class);
+
+ // Get the standard attribute "VmVendor"
+ String vendor = mxbean.getVmVendor();
+</pre>
+<p>
</li>
+<li>Construct an MXBean proxy instance that forwards the
+ method calls to a given MBeanServer:<p>
+<pre>
+ MBeanServerConnection mbs;
-<li>Go through a <tt>MBeanServerConnection</tt> connecting
- to the <tt>platform MBeanServer</tt> of a running virtual machine.</li>
-<blockquote><pre>
+ // Connect to a running JVM (or itself) and get MBeanServerConnection
+ // that has the JVM MBeans registered in it
+ ...
+
+ // Get a MBean proxy for RuntimeMXBean interface
+ RuntimeMXBean proxy =
+ {@link java.lang.management.ManagementFactory#getPlatformMXBean(MBeanServerConnection, Class)
+ ManagementFactory.getPlatformMXBean}(mbs,
+ RuntimeMXBean.class);
+ // Get standard attribute "VmVendor"
+ String vendor = proxy.getVmVendor();
+</pre>
+<p>A proxy is typically used to access an MXBean
+ in a remote Java virtual machine.
+ An alternative way to create an MXBean proxy is:
+<pre>
+ RuntimeMXBean proxy =
+ {@link java.lang.management.ManagementFactory#newPlatformMXBeanProxy
+ ManagementFactory.newPlatformMXBeanProxy}(mbs,
+ ManagementFactory.RUNTIME_MXBEAN_NAME,
+ RuntimeMXBean.class);
+</pre>
+</li>
+</ul>
+<p>
+<b>2. Indirect access to an MXBean interface via MBeanServer</b><p>
+<ul>
+<li>Go through the
+ {@link java.lang.management.ManagementFactory#getPlatformMBeanServer
+ platform MBeanServer} to access MXBeans locally or
+ a specific {@code MBeanServerConnection} to access
+ MXBeans remotely.
+ The attributes and operations of an MXBean use only
+ <em>JMX open types</em> which include basic data types,
+ {@link javax.management.openmbean.CompositeData CompositeData},
+ and {@link javax.management.openmbean.TabularData TabularData}
+ defined in {@link javax.management.openmbean.OpenType OpenType}.<p>
+<pre>
MBeanServerConnection mbs;
// Connect to a running JVM (or itself) and get MBeanServerConnection
@@ -190,7 +154,7 @@
try {
// Assuming the RuntimeMXBean has been registered in mbs
ObjectName oname = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
-
+
// Get standard attribute "VmVendor"
String vendor = (String) mbs.getAttribute(oname, "VmVendor");
} catch (....) {
@@ -198,36 +162,19 @@
// and MBeanServer.getAttribute method
...
}
-
-</pre></blockquote>
-
-<li>Use MXBean proxy.</li>
-<blockquote><pre>
- MBeanServerConnection mbs;
-
- // Connect to a running JVM (or itself) and get MBeanServerConnection
- // that has the JVM MBeans registered in it
- ...
-
- // Get a MBean proxy for RuntimeMXBean interface
- RuntimeMXBean proxy =
- ManagementFactory.newPlatformMXBeanProxy(mbs,
- ManagementFactory.RUNTIME_MXBEAN_NAME,
- RuntimeMXBean.class);
- // Get standard attribute "VmVendor"
- String vendor = proxy.getVmVendor();
-</pre></blockquote>
-</ol>
+</pre>
+</li>
+</ul>
<h4><a name="extension">Platform Extension</a></h4>
-A Java virtual machine implementation may add its platform extension to
+<p>A Java virtual machine implementation may add its platform extension to
the management interface by defining platform-dependent
interfaces that extend the standard management interfaces to include
-platform-specific metrics and management operations.
+platform-specific metrics and management operations.
The static factory methods in the <tt>ManagementFactory</tt> class will
-return the MBeans with the platform extension.
+return the MXBeans with the platform extension.
<p>
It is recommended to name the platform-specific attributes with
@@ -240,26 +187,30 @@
the applications accessing that vendor-specific attribute would have
to be modified to cope with versioning and compatibility issues.
-<p>Below is an example showing how to access a platform-specific
-attribute from Sun's implementation of the <tt>RuntimeMXBean</tt>.
+<p>Below is an example showing how to access an attribute
+from the platform extension:
<p>
-1) Direct access to the Sun-specific MXBean interface
-<blockquote><pre>
- com.sun.management.RuntimeMXBean mxbean =
- (com.sun.management.RuntimeMXBean) ManagementFactory.getRuntimeMXBean();
+1) Direct access to the Oracle-specific MXBean interface
+<blockquote>
+<pre>
+ List<com.sun.management.GarbageCollectorMXBean> mxbeans =
+ ManagementFactory.getPlatformMXBeans(com.sun.management.GarbageCollectorMXBean.class);
- // Get the standard attribute "VmVendor"
- String vendor = mxbean.getVmVendor();
+ for (com.sun.management.GarbageCollectorMXBean gc : mxbeans) {
+ // Get the standard attribute "CollectionCount"
+ String count = mxbean.getCollectionCount();
- // Get the platform-specific attribute "Bar"
- BarType bar = mxbean.getBar();
-
+ // Get the platform-specific attribute "LastGcInfo"
+ GcInfo gcinfo = gc.getLastGcInfo();
+ ...
+ }
</pre>
</blockquote>
<p>
-2) Access the Sun-specific MXBean interface via <tt>MBeanServer</tt>
+2) Access the Oracle-specific MXBean interface via <tt>MBeanServer</tt>
+ through proxy
<blockquote><pre>
MBeanServerConnection mbs;
@@ -268,24 +219,17 @@
// that has the JVM MXBeans registered in it
...
- try {
- // Assuming the RuntimeMXBean has been registered in mbs
- ObjectName oname = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
-
- // Get standard attribute "VmVendor"
- String vendor = (String) mbs.getAttribute(oname, "VmVendor");
+ List<com.sun.management.GarbageCollectorMXBean> mxbeans =
+ ManagementFactory.getPlatformMXBeans(mbs, com.sun.management.GarbageCollectorMXBean.class);
- // Check if this MXBean contains Sun's extension
- if (mbs.isInstanceOf(oname, "com.sun.management.RuntimeMXBean")) {
- // Get platform-specific attribute "Bar"
- BarType bar = (String) mbs.getAttribute(oname, "Bar");
- }
- } catch (....) {
- // Catch the exceptions thrown by ObjectName constructor
- // and MBeanServer methods
+ for (com.sun.management.GarbageCollectorMXBean gc : mxbeans) {
+ // Get the standard attribute "CollectionCount"
+ String count = mxbean.getCollectionCount();
+
+ // Get the platform-specific attribute "LastGcInfo"
+ GcInfo gcinfo = gc.getLastGcInfo();
...
}
-
</pre></blockquote>
<p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor
--- a/jdk/src/share/classes/java/nio/BufferPoolMXBean.java Tue Mar 29 11:37:48 2011 -0400
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2007, 2008, 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.nio;
-
-import java.lang.management.PlatformManagedObject;
-
-/**
- * The management interface for a buffer pool.
- *
- * <p> A class implementing this interface is an <a href=
- * "java.lang.management.ManagementFactory.html#MXBean">MXBean</a>. A Java
- * virtual machine has one or more implementations of this interface. The {@link
- * java.lang.management.ManagementFactory#getPlatformMXBeans getPlatformMXBeans}
- * method can be used to obtain the list of {@code BufferPoolMXBean} objects
- * representing the management interfaces for pools of buffers as follows:
- * <pre>
- * List<BufferPoolMXBean> pools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
- * </pre>
- *
- * <p> The management interfaces are also registered with the platform {@link
- * javax.management.MBeanServer MBeanServer}. The {@link
- * javax.management.ObjectName ObjectName} that uniquely identifies the
- * management interface within the {@code MBeanServer} takes the form:
- * <blockquote>
- * <tt>java.nio:type=BufferPool</tt><tt>,name=</tt><i>pool name</i>
- * </blockquote>
- * where <em>pool name</em> is the {@link #getName name} of the buffer pool.
- *
- * @since 1.7
- */
-
-public interface BufferPoolMXBean extends PlatformManagedObject {
-
- /**
- * Returns the name representing this buffer pool.
- *
- * @return The name of this buffer pool.
- */
- String getName();
-
- /**
- * Returns an estimate of the number of buffers in the pool.
- *
- * @return An estimate of the number of buffers in this pool
- */
- long getCount();
-
- /**
- * Returns an estimate of the total capacity of the buffers in this pool.
- * A buffer's capacity is the number of elements it contains and the value
- * returned by this method is an estimate of the total capacity of buffers
- * in the pool in bytes.
- *
- * @return An estimate of the total capacity of the buffers in this pool
- * in bytes
- */
- long getTotalCapacity();
-
- /**
- * Returns an estimate of the memory that the Java virtual machine is using
- * for this buffer pool. The value returned by this method may differ
- * from the estimate of the total {@link #getTotalCapacity capacity} of
- * the buffers in this pool. This difference is explained by alignment,
- * memory allocator, and other implementation specific reasons.
- *
- * @return An estimate of the memory that the Java virtual machine is using
- * for this buffer pool in bytes, or {@code -1L} if an estimate of
- * the memory usage is not available
- */
- long getMemoryUsed();
-}
--- a/jdk/src/share/classes/java/util/logging/LogManager.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/util/logging/LogManager.java Tue Mar 29 15:50:55 2011 -0700
@@ -1166,7 +1166,12 @@
private static LoggingMXBean loggingMXBean = null;
/**
* String representation of the
- * {@link javax.management.ObjectName} for {@link LoggingMXBean}.
+ * {@link javax.management.ObjectName} for the management interface
+ * for the logging facility.
+ *
+ * @see java.lang.management.PlatformLoggingMXBean
+ * @see java.util.logging.LoggingMXBean
+ *
* @since 1.5
*/
public final static String LOGGING_MXBEAN_NAME
@@ -1174,20 +1179,20 @@
/**
* Returns <tt>LoggingMXBean</tt> for managing loggers.
- * An alternative way to manage loggers is using
- * the {@link java.lang.management.ManagementFactory#getPlatformMXBeans(Class)
- * ManagementFactory.getPlatformMXBeans} method as follows:
+ * An alternative way to manage loggers is through the
+ * {@link java.lang.management.PlatformLoggingMXBean} interface
+ * that can be obtained by calling:
* <pre>
- * List<{@link PlatformLoggingMXBean}> result = ManagementFactory.getPlatformMXBeans(PlatformLoggingMXBean.class);
+ * PlatformLoggingMXBean logging = {@link java.lang.management.ManagementFactory#getPlatformMXBean(Class)
+ * ManagementFactory.getPlatformMXBean}(PlatformLoggingMXBean.class);
* </pre>
*
* @return a {@link LoggingMXBean} object.
*
- * @see PlatformLoggingMXBean
- * @see java.lang.management.ManagementFactory
+ * @see java.lang.management.PlatformLoggingMXBean
* @since 1.5
*/
- public static synchronized LoggingMXBean getLoggingMXBean() {
+ public static synchronized LoggingMXBean getLoggingMXBean() {
if (loggingMXBean == null) {
loggingMXBean = new Logging();
}
--- a/jdk/src/share/classes/java/util/logging/LoggingMXBean.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/java/util/logging/LoggingMXBean.java Tue Mar 29 15:50:55 2011 -0700
@@ -27,36 +27,41 @@
/**
- * The management interface for the logging facility.
+ * The management interface for the logging facility. It is recommended
+ * to use the {@link java.lang.management.PlatformLoggingMXBean} management
+ * interface that implements all attributes defined in this
+ * {@code LoggingMXBean}. The
+ * {@link java.lang.management.ManagementFactory#getPlatformMXBean(Class)
+ * ManagementFactory.getPlatformMXBean} method can be used to obtain
+ * the {@code PlatformLoggingMXBean} object representing the management
+ * interface for logging.
*
* <p>There is a single global instance of the <tt>LoggingMXBean</tt>.
- * This instance is an
- * <a href="../../lang/management/ManagementFactory.html#MXBean">MXBean</a>
- * can be obtained by calling
- * the {@link LogManager#getLoggingMXBean} method or from the
+ * This instance is an {@link javax.management.MXBean MXBean} that
+ * can be obtained by calling the {@link LogManager#getLoggingMXBean}
+ * method or from the
* {@linkplain java.lang.management.ManagementFactory#getPlatformMBeanServer
* platform <tt>MBeanServer</tt>}.
- *
- * The {@link javax.management.ObjectName ObjectName} for uniquely
- * identifying the <tt>LoggingMXBean</tt> within an MBeanServer is:
- * <blockquote>
- * {@link LogManager#LOGGING_MXBEAN_NAME
- * <tt>java.util.logging:type=Logging</tt>}
- * </blockquote>
- *
- * The instance registered in the platform <tt>MBeanServer</tt> with
- * this {@code ObjectName} is also a {@link PlatformLoggingMXBean}.
+ * <p>
+ * The {@link javax.management.ObjectName ObjectName} that uniquely identifies
+ * the management interface for logging within the {@code MBeanServer} is:
+ * <pre>
+ * {@link LogManager#LOGGING_MXBEAN_NAME java.util.logging:type=Logging}
+ * </pre>
+ * <p>
+ * The instance registered in the platform {@code MBeanServer}
+ * is also a {@link java.lang.management.PlatformLoggingMXBean}.
*
* @author Ron Mann
* @author Mandy Chung
* @since 1.5
*
- * @see PlatformLoggingMXBean
+ * @see java.lang.management.PlatformLoggingMXBean
*/
public interface LoggingMXBean {
/**
- * Returns the list of currently registered loggers. This method
+ * Returns the list of currently registered logger names. This method
* calls {@link LogManager#getLoggerNames} and returns a list
* of the logger names.
*
@@ -89,7 +94,7 @@
*
* @see Logger#getLevel
*/
- public String getLoggerLevel( String loggerName );
+ public String getLoggerLevel(String loggerName);
/**
* Sets the specified logger to the specified new level.
@@ -115,7 +120,7 @@
*
* @see Logger#setLevel
*/
- public void setLoggerLevel( String loggerName, String levelName );
+ public void setLoggerLevel(String loggerName, String levelName);
/**
* Returns the name of the parent for the specified logger.
--- a/jdk/src/share/classes/java/util/logging/PlatformLoggingMXBean.java Tue Mar 29 11:37:48 2011 -0400
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2009, 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.util.logging;
-
-import java.lang.management.PlatformManagedObject;
-
-/**
- * The {@linkplain PlatformManagedObject platform managed object} for the
- * logging facility. This interface simply unifies {@link LoggingMXBean}
- * {@link PlatformManagedObject};
- * and it does not specify any new operations.
- *
- * <p>The {@link java.lang.management.ManagementFactory#getPlatformMXBeans(Class)
- * ManagementFactory.getPlatformMXBeans} method can be used to obtain
- * the {@code PlatformLoggingMXBean} object as follows:
- * <pre>
- * ManagementFactory.getPlatformMXBeans(PlatformLoggingMXBean.class);
- * </pre>
- * or from the {@linkplain java.lang.management.ManagementFactory#getPlatformMBeanServer
- * platform <tt>MBeanServer</tt>}.
- *
- * The {@link javax.management.ObjectName ObjectName} for uniquely
- * identifying the <tt>LoggingMXBean</tt> within an MBeanServer is:
- * <blockquote>
- * <tt>java.util.logging:type=Logging</tt>
- * </blockquote>
- *
- * The {@link PlatformManagedObject#getObjectName} method
- * can be used to obtain its {@code ObjectName}.
- *
- * @see java.lang.management.PlatformManagedObject
- *
- * @author Mandy Chung
- * @since 1.7
- */
-public interface PlatformLoggingMXBean extends LoggingMXBean, PlatformManagedObject {
-}
--- a/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/src/share/classes/sun/management/ManagementFactoryHelper.java Tue Mar 29 15:50:55 2011 -0700
@@ -27,20 +27,18 @@
import java.lang.management.*;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
+import javax.management.MBeanServer;
import javax.management.MBeanRegistrationException;
import javax.management.NotCompliantMBeanException;
+import javax.management.ObjectName;
import javax.management.RuntimeOperationsException;
-import java.nio.BufferPoolMXBean;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import sun.security.action.LoadLibraryAction;
-import java.util.logging.PlatformLoggingMXBean;
import sun.util.logging.LoggingSupport;
import java.util.ArrayList;
@@ -139,61 +137,80 @@
return result;
}
- public static List<PlatformLoggingMXBean> getLoggingMXBean() {
+ public static PlatformLoggingMXBean getPlatformLoggingMXBean() {
if (LoggingSupport.isAvailable()) {
- return Collections.singletonList(createPlatformLoggingMXBean());
+ return PlatformLoggingImpl.instance;
} else {
- return Collections.emptyList();
+ return null;
}
}
- private final static String LOGGING_MXBEAN_NAME = "java.util.logging:type=Logging";
- private static PlatformLoggingMXBean createPlatformLoggingMXBean() {
- return new PlatformLoggingMXBean() {
- private volatile ObjectName objname; // created lazily
- @Override
- public ObjectName getObjectName() {
- ObjectName result = objname;
- if (result == null) {
- synchronized (this) {
- if (objname == null) {
- result = Util.newObjectName(LOGGING_MXBEAN_NAME);
- objname = result;
- }
+ // The logging MXBean object is an instance of
+ // PlatformLoggingMXBean and java.util.logging.LoggingMXBean
+ // but it can't directly implement two MXBean interfaces
+ // as a compliant MXBean implements exactly one MXBean interface,
+ // or if it implements one interface that is a subinterface of
+ // all the others; otherwise, it is a non-compliant MXBean
+ // and MBeanServer will throw NotCompliantMBeanException.
+ // See the Definition of an MXBean section in javax.management.MXBean spec.
+ //
+ // To create a compliant logging MXBean, define a LoggingMXBean interface
+ // that extend PlatformLoggingMXBean and j.u.l.LoggingMXBean
+ interface LoggingMXBean
+ extends PlatformLoggingMXBean, java.util.logging.LoggingMXBean {
+ }
+
+ static class PlatformLoggingImpl implements LoggingMXBean
+ {
+ final static PlatformLoggingMXBean instance = new PlatformLoggingImpl();
+ final static String LOGGING_MXBEAN_NAME = "java.util.logging:type=Logging";
+
+ private volatile ObjectName objname; // created lazily
+ @Override
+ public ObjectName getObjectName() {
+ ObjectName result = objname;
+ if (result == null) {
+ synchronized (this) {
+ if (objname == null) {
+ result = Util.newObjectName(LOGGING_MXBEAN_NAME);
+ objname = result;
}
}
- return result;
}
+ return result;
+ }
- @Override
- public java.util.List<String> getLoggerNames() {
- return LoggingSupport.getLoggerNames();
- }
+ @Override
+ public java.util.List<String> getLoggerNames() {
+ return LoggingSupport.getLoggerNames();
+ }
- @Override
- public String getLoggerLevel(String loggerName) {
- return LoggingSupport.getLoggerLevel(loggerName);
- }
+ @Override
+ public String getLoggerLevel(String loggerName) {
+ return LoggingSupport.getLoggerLevel(loggerName);
+ }
- @Override
- public void setLoggerLevel(String loggerName, String levelName) {
- LoggingSupport.setLoggerLevel(loggerName, levelName);
- }
+ @Override
+ public void setLoggerLevel(String loggerName, String levelName) {
+ LoggingSupport.setLoggerLevel(loggerName, levelName);
+ }
- @Override
- public String getParentLoggerName(String loggerName) {
- return LoggingSupport.getParentLoggerName(loggerName);
- }
- };
+ @Override
+ public String getParentLoggerName(String loggerName) {
+ return LoggingSupport.getParentLoggerName(loggerName);
+ }
}
- public static List<BufferPoolMXBean> getBufferPoolMXBeans() {
- List<BufferPoolMXBean> pools = new ArrayList<BufferPoolMXBean>(2);
- pools.add(createBufferPoolMXBean(sun.misc.SharedSecrets.getJavaNioAccess()
- .getDirectBufferPool()));
- pools.add(createBufferPoolMXBean(sun.nio.ch.FileChannelImpl
- .getMappedBufferPool()));
- return pools;
+ private static List<BufferPoolMXBean> bufferPools = null;
+ public static synchronized List<BufferPoolMXBean> getBufferPoolMXBeans() {
+ if (bufferPools == null) {
+ bufferPools = new ArrayList<>(2);
+ bufferPools.add(createBufferPoolMXBean(sun.misc.SharedSecrets.getJavaNioAccess()
+ .getDirectBufferPool()));
+ bufferPools.add(createBufferPoolMXBean(sun.nio.ch.FileChannelImpl
+ .getMappedBufferPool()));
+ }
+ return bufferPools;
}
private final static String BUFFER_POOL_MXBEAN_NAME = "java.nio:type=BufferPool";
--- a/jdk/test/Makefile Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/test/Makefile Tue Mar 29 15:50:55 2011 -0700
@@ -504,7 +504,7 @@
# Stable samevm testruns (minus items from PROBLEM_LIST)
JDK_ALL_TARGETS += jdk_nio2
jdk_nio2: $(call TestDirs, java/nio/Buffer java/nio/ByteOrder \
- java/nio/channels java/nio/BufferPoolMXBean java/nio/MappedByteBuffer)
+ java/nio/channels java/nio/MappedByteBuffer)
$(call SharedLibraryPermissions,java/nio/channels)
$(call RunSamevmBatch)
@@ -687,7 +687,7 @@
################################################################
-# perftest to collect statistics
+# perftest to collect statistics
# Expect JPRT to set JPRT_PACKTEST_HOME.
PERFTEST_HOME = $(TEST_ROOT)/perf
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/management/BufferPoolMXBean/Basic.java Tue Mar 29 15:50:55 2011 -0700
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2007, 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.
+ *
+ * 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 6606598 7024172
+ * @summary Unit test for java.lang.management.BufferPoolMXBean
+ * @run main/othervm Basic
+ */
+
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.file.Path;
+import java.nio.file.Files;
+import static java.nio.file.StandardOpenOption.*;
+import java.nio.channels.FileChannel;
+import java.lang.management.BufferPoolMXBean;
+import java.lang.management.ManagementFactory;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import java.lang.ref.WeakReference;
+import java.util.*;
+
+public class Basic {
+
+ // static fields to ensure buffers aren't GC'ed
+ static List<ByteBuffer> buffers;
+ static MappedByteBuffer mbb;
+
+ // check counters
+ static void check(List<BufferPoolMXBean> pools,
+ int minBufferCount,
+ long minTotalCapacity)
+ {
+ int bufferCount = 0;
+ long totalCap = 0;
+ long totalMem = 0;
+ for (BufferPoolMXBean pool: pools) {
+ bufferCount += pool.getCount();
+ totalCap += pool.getTotalCapacity();
+ totalMem += pool.getMemoryUsed();
+ }
+ if (bufferCount < minBufferCount)
+ throw new RuntimeException("Count less than expected");
+ if (totalMem < minTotalCapacity)
+ throw new RuntimeException("Memory usage less than expected");
+ if (totalCap < minTotalCapacity)
+ throw new RuntimeException("Total capacity less than expected");
+ }
+
+ public static void main(String[] args) throws Exception {
+ Random rand = new Random();
+
+ // allocate a few direct buffers
+ int bufferCount = 5 + rand.nextInt(20);
+ buffers = new ArrayList<ByteBuffer>(bufferCount);
+ long totalCapacity = 0L;
+ for (int i=0; i<bufferCount; i++) {
+ int cap = 1024 + rand.nextInt(4096);
+ buffers.add( ByteBuffer.allocateDirect(cap) );
+ totalCapacity += cap;
+ }
+
+ // create a mapped buffer
+ Path tmpfile = Files.createTempFile("blah", null);
+ tmpfile.toFile().deleteOnExit();
+ try (FileChannel fc = FileChannel.open(tmpfile, READ, WRITE)) {
+ mbb = fc.map(FileChannel.MapMode.READ_WRITE, 10, 100);
+ bufferCount++;
+ totalCapacity += mbb.capacity();
+ }
+
+ // use platform MXBeans directly
+ List<BufferPoolMXBean> pools =
+ ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
+ check(pools, bufferCount, totalCapacity);
+
+ // use MBeanServer
+ MBeanServer server = ManagementFactory.getPlatformMBeanServer();
+ Set<ObjectName> mbeans = server.queryNames(
+ new ObjectName("java.nio:type=BufferPool,*"), null);
+ pools = new ArrayList<BufferPoolMXBean>();
+ for (ObjectName name: mbeans) {
+ BufferPoolMXBean pool = ManagementFactory
+ .newPlatformMXBeanProxy(server, name.toString(), BufferPoolMXBean.class);
+ pools.add(pool);
+ }
+ check(pools, bufferCount, totalCapacity);
+
+ // attempt to unmap mapped buffer
+ WeakReference<MappedByteBuffer> ref = new WeakReference<>(mbb);
+ mbb = null;
+ do {
+ System.gc();
+ Thread.sleep(250);
+ } while (ref.get() != null);
+ }
+}
--- a/jdk/test/java/lang/management/ManagementFactory/GetPlatformMXBeans.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/test/java/lang/management/ManagementFactory/GetPlatformMXBeans.java Tue Mar 29 15:50:55 2011 -0700
@@ -23,23 +23,26 @@
/*
* @test
- * @bug 6610094
- * @summary Basic unit test of ManagementFactory.getPlatformMXBeans()
- * and also PlatformManagedObject.getObjectName()
+ * @bug 6610094 7024172
+ * @summary Basic unit test of ManagementFactory.getPlatformMXBean(s)
+ * methods and PlatformManagedObject.getObjectName()
* @author Mandy Chung
*
* @run main GetPlatformMXBeans
*/
import java.lang.management.*;
-import static java.lang.management.ManagementFactory.*;
+import java.io.IOException;
import java.util.*;
import javax.management.*;
+import static java.lang.management.ManagementFactory.*;
+
public class GetPlatformMXBeans {
private static MBeanServer platformMBeanServer =
getPlatformMBeanServer();
public static void main(String[] argv) throws Exception {
+ // singleton platform MXBean
checkPlatformMXBean(getClassLoadingMXBean(),
ClassLoadingMXBean.class,
CLASS_LOADING_MXBEAN_NAME);
@@ -58,17 +61,28 @@
checkPlatformMXBean(getThreadMXBean(),
ThreadMXBean.class,
THREAD_MXBEAN_NAME);
+
+ // the following MXBean can have more than one instances
checkGarbageCollectorMXBeans(getGarbageCollectorMXBeans());
checkMemoryManagerMXBeans(getMemoryManagerMXBeans());
checkMemoryPoolMXBeans(getMemoryPoolMXBeans());
+
+ // check invalid platform MXBean
+ checkInvalidPlatformMXBean();
}
private static <T extends PlatformManagedObject>
- void checkPlatformMXBean(T obj, Class<T> mxbeanInterface,
- String mxbeanName) throws Exception
+ void checkPlatformMXBean(T obj, Class<T> mxbeanInterface,
+ String mxbeanName)
+ throws Exception
{
- int numElements = (obj != null ? 1 : 0);
- // verify local list of platform MXBeans
+ // getPlatformMXBean may return null if the mxbean is not implemented
+ PlatformManagedObject mxbean = getPlatformMXBean(mxbeanInterface);
+ if (obj != mxbean) {
+ throw new RuntimeException("Singleton MXBean returned not matched");
+ }
+
+ int numElements = obj == null ? 0 : 1;
List<? extends PlatformManagedObject> mxbeans =
getPlatformMXBeans(mxbeanInterface);
if (mxbeans.size() != numElements) {
@@ -77,24 +91,46 @@
}
if (obj != null) {
- PlatformManagedObject pmo = mxbeans.get(0);
- if (obj != pmo) {
+ if (obj != mxbeans.get(0)) {
throw new RuntimeException("The list returned by getPlatformMXBeans"
+ " not matched");
}
ObjectName on = new ObjectName(mxbeanName);
- if (!on.equals(pmo.getObjectName())) {
+ if (!on.equals(mxbean.getObjectName())) {
throw new RuntimeException("Unmatched ObjectName " +
- pmo.getObjectName() + " Expected = " + on);
+ mxbean.getObjectName() + " Expected = " + on);
}
+ checkRemotePlatformMXBean(obj, platformMBeanServer,
+ mxbeanInterface, mxbeanName);
+ }
+ }
+
+ // verify platform MXBeans in the platform MBeanServer
+ private static <T extends PlatformManagedObject>
+ void checkRemotePlatformMXBean(T obj,
+ MBeanServerConnection mbs,
+ Class<T> mxbeanInterface,
+ String mxbeanName)
+ throws Exception
+ {
+ PlatformManagedObject mxbean = getPlatformMXBean(mbs, mxbeanInterface);
+ if ((obj == null && mxbean != null) || (obj != null && mxbean == null)) {
+ throw new RuntimeException("Singleton MXBean returned not matched");
}
- // verify platform MXBeans in the platform MBeanServer
- mxbeans = getPlatformMXBeans(platformMBeanServer, mxbeanInterface);
+ int numElements = obj == null ? 0 : 1;
+ List<? extends PlatformManagedObject> mxbeans =
+ getPlatformMXBeans(mbs, mxbeanInterface);
if (mxbeans.size() != numElements) {
throw new RuntimeException("Unmatched number of platform MXBeans "
+ mxbeans.size() + ". Expected = " + numElements);
}
+
+ ObjectName on = new ObjectName(mxbeanName);
+ if (!on.equals(mxbean.getObjectName())) {
+ throw new RuntimeException("Unmatched ObjectName " +
+ mxbean.getObjectName() + " Expected = " + on);
+ }
}
private static void checkMemoryManagerMXBeans(List<MemoryManagerMXBean> objs)
@@ -148,6 +184,14 @@
void checkPlatformMXBeans(List<T> objs, Class<T> mxbeanInterface)
throws Exception
{
+ try {
+ getPlatformMXBean(mxbeanInterface);
+ // mxbeanInterface is not a singleton
+ throw new RuntimeException(mxbeanInterface + ": not a singleton MXBean");
+ } catch (IllegalArgumentException e) {
+ // expect IAE
+ }
+
// verify local list of platform MXBeans
List<? extends PlatformManagedObject> mxbeans =
getPlatformMXBeans(mxbeanInterface);
@@ -177,4 +221,40 @@
+ mxbeans.size() + ". Expected = " + objs.size());
}
}
+
+ interface FakeMXBean extends PlatformManagedObject {};
+
+ private static void checkInvalidPlatformMXBean() throws IOException {
+ try {
+ getPlatformMXBean(FakeMXBean.class);
+ // mxbeanInterface is not a singleton
+ throw new RuntimeException("Expect IllegalArgumentException but not thrown");
+ } catch (IllegalArgumentException e) {
+ // expect IAE
+ }
+
+ try {
+ getPlatformMXBeans(FakeMXBean.class);
+ // mxbeanInterface is not a singleton
+ throw new RuntimeException("Expect IllegalArgumentException but not thrown");
+ } catch (IllegalArgumentException e) {
+ // expect IAE
+ }
+
+ try {
+ getPlatformMXBean(platformMBeanServer, FakeMXBean.class);
+ // mxbeanInterface is not a singleton
+ throw new RuntimeException("Expect IllegalArgumentException but not thrown");
+ } catch (IllegalArgumentException e) {
+ // expect IAE
+ }
+
+ try {
+ getPlatformMXBeans(platformMBeanServer, FakeMXBean.class);
+ // mxbeanInterface is not a singleton
+ throw new RuntimeException("Expect IllegalArgumentException but not thrown");
+ } catch (IllegalArgumentException e) {
+ // expect IAE
+ }
+ }
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/management/PlatformLoggingMXBean/LoggingMXBeanTest.java Tue Mar 29 15:50:55 2011 -0700
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2011, 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 7024172
+ * @summary Test if proxy for PlatformLoggingMXBean is equivalent
+ * to proxy for LoggingMXBean
+ *
+ * @build LoggingMXBeanTest
+ * @run main LoggingMXBeanTest
+ */
+
+import java.lang.management.*;
+import javax.management.MBeanServer;
+import java.util.logging.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class LoggingMXBeanTest
+{
+ static String LOGGER_NAME_1 = "com.sun.management.Logger";
+ static String LOGGER_NAME_2 = "com.sun.management.Logger.Logger2";
+ static String UNKNOWN_LOGGER_NAME = "com.sun.management.Unknown";
+
+ public static void main(String[] argv) throws Exception {
+ MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+ LoggingMXBean proxy =
+ ManagementFactory.newPlatformMXBeanProxy(mbs,
+ LogManager.LOGGING_MXBEAN_NAME,
+ LoggingMXBean.class);
+
+ // test LoggingMXBean proxy
+ LoggingMXBeanTest p = new LoggingMXBeanTest(proxy);
+
+ // check if the attributes implemented by PlatformLoggingMXBean
+ // and LoggingMXBean return the same value
+ PlatformLoggingMXBean mxbean =
+ ManagementFactory.getPlatformMXBean(mbs, PlatformLoggingMXBean.class);
+
+ checkAttributes(proxy, mxbean);
+ }
+
+ // same verification as in java/util/logging/LoggingMXBeanTest2
+ public LoggingMXBeanTest(LoggingMXBean mbean) throws Exception {
+
+ Logger logger1 = Logger.getLogger( LOGGER_NAME_1 );
+ logger1.setLevel(Level.FINE);
+ Logger logger2 = Logger.getLogger( LOGGER_NAME_2 );
+ logger2.setLevel(null);
+
+ /*
+ * Check for the existence of our new Loggers
+ */
+ System.out.println("Test Logger Name retrieval (getLoggerNames)");
+ boolean log1 = false, log2 = false;
+ List<String> loggers = mbean.getLoggerNames();
+ if (loggers == null || loggers.size() < 2) {
+ throw new RuntimeException(
+ "Could not Detect the presense of the new Loggers");
+ }
+
+ for (String logger : loggers) {
+ if (logger.equals(LOGGER_NAME_1)) {
+ log1 = true;
+ System.out.println(" : Found new Logger : " + logger);
+ }
+ if (logger.equals(LOGGER_NAME_2)) {
+ log2 = true;
+ System.out.println(" : Found new Logger : " + logger);
+ }
+ }
+ if ( log1 && log2 )
+ System.out.println(" : PASSED." );
+ else {
+ System.out.println(" : FAILED. Could not Detect the new Loggers." );
+ throw new RuntimeException(
+ "Could not Detect the presense of the new Loggers");
+ }
+
+ System.out.println("Test getLoggerLevel");
+ String l1 = mbean.getLoggerLevel(LOGGER_NAME_1);
+ System.out.println(" : Level for Logger " + LOGGER_NAME_1 + " : " + l1);
+ if (!l1.equals(Level.FINE.getName())) {
+ throw new RuntimeException(
+ "Expected level for " + LOGGER_NAME_1 + " = " +
+ Level.FINE.getName() + " but got " + l1);
+ }
+ String l2 = mbean.getLoggerLevel(LOGGER_NAME_2);
+ System.out.println(" : Level for Logger " + LOGGER_NAME_2 + " : " + l2);
+ if (!l2.equals("")) {
+ throw new RuntimeException(
+ "Expected level for " + LOGGER_NAME_2 + " = \"\"" +
+ " but got " + l2);
+ }
+ String l3 = mbean.getLoggerLevel(UNKNOWN_LOGGER_NAME);
+ System.out.println(" : Level for unknown logger : " + l3);
+ if (l3 != null) {
+ throw new RuntimeException(
+ "Expected level for " + UNKNOWN_LOGGER_NAME + " = null" +
+ " but got " + l3);
+ }
+
+ System.out.println("Test setLoggerLevel");
+ mbean.setLoggerLevel(LOGGER_NAME_1, "INFO");
+ System.out.println(" : Set Level for Logger " + LOGGER_NAME_1 + " to: INFO");
+ Level l = logger1.getLevel();
+ if (l != Level.INFO) {
+ throw new RuntimeException(
+ "Expected level for " + LOGGER_NAME_1 + " = " +
+ Level.INFO + " but got " + l);
+ }
+
+ mbean.setLoggerLevel(LOGGER_NAME_2, "SEVERE");
+ System.out.println(" : Set Level for Logger " + LOGGER_NAME_2 + " to: SERVER");
+ l = logger2.getLevel();
+ if (l != Level.SEVERE) {
+ throw new RuntimeException(
+ "Expected level for " + LOGGER_NAME_2 + " = " +
+ Level.SEVERE+ " but got " + l);
+ }
+
+ mbean.setLoggerLevel(LOGGER_NAME_1, null);
+ System.out.println(" : Set Level for Logger " + LOGGER_NAME_1 + " to: null");
+ l = logger1.getLevel();
+ if (l != null) {
+ throw new RuntimeException(
+ "Expected level for " + LOGGER_NAME_1 + " = null " +
+ " but got " + l);
+ }
+
+ boolean iaeCaught = false;
+ System.out.println(" : Set Level for unknown Logger to: FINE");
+ try {
+ mbean.setLoggerLevel(UNKNOWN_LOGGER_NAME, "FINE");
+ } catch (IllegalArgumentException e) {
+ // expected
+ iaeCaught = true;
+ System.out.println(" : IllegalArgumentException caught as expected");
+ }
+ if (!iaeCaught) {
+ throw new RuntimeException(
+ "Expected IllegalArgumentException for setting level for " +
+ UNKNOWN_LOGGER_NAME + " not thrown");
+ }
+ iaeCaught = false;
+ System.out.println(" : Set Level for Logger " + LOGGER_NAME_1 + " to: DUMMY");
+ try {
+ mbean.setLoggerLevel(LOGGER_NAME_1, "DUMMY");
+ } catch (IllegalArgumentException e) {
+ // expected
+ iaeCaught = true;
+ System.out.println(" : IllegalArgumentException caught as expected");
+ }
+ if (!iaeCaught) {
+ throw new RuntimeException(
+ "Expected IllegalArgumentException for invalid level.");
+ }
+
+
+ System.out.println("Test getParentLoggerName");
+ String p1 = mbean.getParentLoggerName(LOGGER_NAME_2);
+ System.out.println(" : Parent Logger for " + LOGGER_NAME_2 + " : " + p1);
+ if (!p1.equals(LOGGER_NAME_1)) {
+ throw new RuntimeException(
+ "Expected parent for " + LOGGER_NAME_2 + " = " +
+ LOGGER_NAME_1 + " but got " + p1);
+ }
+ String p2 = mbean.getParentLoggerName("");
+ System.out.println(" : Parent Logger for \"\" : " + p2);
+ if (!p2.equals("")) {
+ throw new RuntimeException(
+ "Expected parent for root logger \"\" = \"\"" +
+ " but got " + p2);
+ }
+ String p3 = mbean.getParentLoggerName(UNKNOWN_LOGGER_NAME);
+ System.out.println(" : Parent Logger for unknown logger : " + p3);
+ if (p3 != null) {
+ throw new RuntimeException(
+ "Expected level for " + UNKNOWN_LOGGER_NAME + " = null" +
+ " but got " + p3);
+ }
+ }
+
+ private static void checkAttributes(LoggingMXBean mxbean1,
+ PlatformLoggingMXBean mxbean2) {
+ // verify logger names
+ List<String> loggers1 = mxbean1.getLoggerNames();
+ List<String> loggers2 = mxbean2.getLoggerNames();
+ if (loggers1.size() != loggers2.size())
+ throw new RuntimeException("LoggerNames: unmatched number of entries");
+ List<String> loggers3 = new ArrayList<>(loggers1);
+ loggers3.removeAll(loggers2);
+ if (loggers3.size() != 0)
+ throw new RuntimeException("LoggerNames: unmatched loggers");
+
+ // verify logger's level and parent
+ for (String logger : loggers1) {
+ if (!mxbean1.getLoggerLevel(logger)
+ .equals(mxbean2.getLoggerLevel(logger)))
+ throw new RuntimeException(
+ "LoggerLevel: unmatched level for " + logger);
+ if (!mxbean1.getParentLoggerName(logger)
+ .equals(mxbean2.getParentLoggerName(logger)))
+ throw new RuntimeException(
+ "ParentLoggerName: unmatched parent logger's name for " + logger);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/management/PlatformLoggingMXBean/PlatformLoggingMXBeanTest.java Tue Mar 29 15:50:55 2011 -0700
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2003, 2004, 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 6876135 7024172
+ *
+ * @summary Test PlatformLoggingMXBean
+ * This test performs similar testing as
+ * java/util/logging/LoggingMXBeanTest.
+ *
+ * @build PlatformLoggingMXBeanTest
+ * @run main PlatformLoggingMXBeanTest
+ */
+
+import javax.management.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.PlatformLoggingMXBean;
+import java.util.logging.*;
+import java.util.List;
+
+public class PlatformLoggingMXBeanTest
+{
+
+ ObjectName objectName = null;
+ static String LOGGER_NAME_1 = "com.sun.management.Logger1";
+ static String LOGGER_NAME_2 = "com.sun.management.Logger2";
+
+ public PlatformLoggingMXBeanTest() throws Exception {
+ }
+
+ private void runTest(PlatformLoggingMXBean mBean) throws Exception {
+
+ /*
+ * Create the MBeanServeri, register the PlatformLoggingMXBean
+ */
+ System.out.println( "***************************************************" );
+ System.out.println( "********** PlatformLoggingMXBean Unit Test **********" );
+ System.out.println( "***************************************************" );
+ System.out.println( "" );
+ System.out.println( "*******************************" );
+ System.out.println( "*********** Phase 1 ***********" );
+ System.out.println( "*******************************" );
+ System.out.println( " Creating MBeanServer " );
+ System.out.print( " Register PlatformLoggingMXBean: " );
+ MBeanServer mbs = MBeanServerFactory.createMBeanServer();
+ String[] list = new String[0];
+
+ try {
+ objectName = new ObjectName(LogManager.LOGGING_MXBEAN_NAME);
+ mbs.registerMBean( mBean, objectName );
+ }
+ catch ( Exception e ) {
+ System.out.println( "FAILED" );
+ throw e;
+ }
+ System.out.println( "PASSED" );
+ System.out.println("");
+
+ /*
+ * Access our MBean to get the current list of Loggers
+ */
+ System.out.println( "*******************************" );
+ System.out.println( "*********** Phase 2 ***********" );
+ System.out.println( "*******************************" );
+ System.out.println( " Test Logger Name retrieval (getLoggerNames) " );
+ // check that Level object are returned properly
+ try {
+ list = (String[]) mbs.getAttribute( objectName, "LoggerNames" );
+ }
+ catch ( Exception e ) {
+ System.out.println(" : FAILED" );
+ throw e;
+ }
+
+ /*
+ * Dump the list of Loggers already present, if any
+ */
+ Object[] params = new Object[1];
+ String[] signature = new String[1];
+ Level l;
+
+ if ( list == null ) {
+ System.out.println(" : PASSED. No Standard Loggers Present" );
+ System.out.println("");
+ }
+ else {
+ System.out.println(" : PASSED. There are " + list.length + " Loggers Present" );
+ System.out.println("");
+ System.out.println( "*******************************" );
+ System.out.println( "*********** Phase 2B **********" );
+ System.out.println( "*******************************" );
+ System.out.println( " Examine Existing Loggers" );
+ for ( int i = 0; i < list.length; i++ ) {
+ try {
+ params[0] = list[i];
+ signature[0] = "java.lang.String";
+ String levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
+ System.out.println(" : Logger #" + i + " = " + list[i] );
+ System.out.println(" : Level = " + levelName );
+ }
+ catch ( Exception e ) {
+ System.out.println(" : FAILED" );
+ throw e;
+ }
+ }
+ System.out.println(" : PASSED" );
+ }
+
+ /*
+ * Create two new loggers to the list of Loggers already present
+ */
+ System.out.println("");
+ System.out.println( "*******************************" );
+ System.out.println( "*********** Phase 3 ***********" );
+ System.out.println( "*******************************" );
+ System.out.println( " Create and test new Loggers" );
+ Logger logger1 = Logger.getLogger( LOGGER_NAME_1 );
+ Logger logger2 = Logger.getLogger( LOGGER_NAME_2 );
+
+ // check that Level object are returned properly
+ try {
+ list = (String[]) mbs.getAttribute( objectName, "LoggerNames" );
+ }
+ catch ( Exception e ) {
+ System.out.println(" : FAILED" );
+ throw e;
+ }
+
+ /*
+ * Check for the existence of our new Loggers
+ */
+ boolean log1 = false, log2 = false;
+
+ if ( list == null || list.length < 2 ) {
+ System.out.println(" : FAILED. Could not Detect the presense of the new Loggers" );
+ throw new RuntimeException(
+ "Could not Detect the presense of the new Loggers");
+ }
+ else {
+ for ( int i = 0; i < list.length; i++ ) {
+ if ( list[i].equals( LOGGER_NAME_1 ) ) {
+ log1 = true;
+ System.out.println( " : Found new Logger : " + list[i] );
+ }
+ if ( list[i].equals( LOGGER_NAME_2 ) ) {
+ log2 = true;
+ System.out.println( " : Found new Logger : " + list[i] );
+ }
+ }
+ if ( log1 && log2 )
+ System.out.println( " : PASSED." );
+ else {
+ System.out.println( " : FAILED. Could not Detect the new Loggers." );
+ throw new RuntimeException(
+ "Could not Detect the presense of the new Loggers");
+ }
+ }
+
+ /*
+ * Set a new Logging levels and check that it succeeded
+ */
+ System.out.println("");
+ System.out.println( "*******************************" );
+ System.out.println( "*********** Phase 4 ***********" );
+ System.out.println( "*******************************" );
+ System.out.println( " Set and Check the Logger Level" );
+ log1 = false;
+ log2 = false;
+ try {
+ // Set the level of logger1 to ALL
+ params = new Object[2];
+ signature = new String[2];
+ params[0] = LOGGER_NAME_1;
+ params[1] = Level.ALL.getName();
+ signature[0] = "java.lang.String";
+ signature[1] = "java.lang.String";
+ mbs.invoke( objectName, "setLoggerLevel", params, signature );
+
+ // Set the level of logger2 to FINER
+ params[0] = LOGGER_NAME_2;
+ params[1] = Level.FINER.getName();
+ mbs.invoke( objectName, "setLoggerLevel", params, signature );
+
+ // Okay read back the Level from Logger1. Should be ALL
+ params = new Object[1];
+ signature = new String[1];
+ params[0] = LOGGER_NAME_1;
+ signature[0] = "java.lang.String";
+ String levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
+ l = Level.parse(levelName);
+ System.out.print(" Logger1: " );
+ if ( l.equals( l.ALL ) ) {
+ System.out.println("Level Set to ALL: PASSED" );
+ log1 = true;
+ }
+ else {
+ System.out.println("Level Set to ALL: FAILED" );
+ throw new RuntimeException(
+ "Level Set to ALL but returned " + l.toString());
+ }
+
+ // Okay read back the Level from Logger2. Should be FINER
+ params = new Object[1];
+ signature = new String[1];
+ params[0] = LOGGER_NAME_2;
+ signature[0] = "java.lang.String";
+ levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
+ l = Level.parse(levelName);
+ System.out.print(" Logger2: " );
+ if ( l.equals( l.FINER ) ) {
+ System.out.println("Level Set to FINER: PASSED" );
+ log2 = true;
+ }
+ else {
+ System.out.println("Level Set to FINER: FAILED" );
+ throw new RuntimeException(
+ "Level Set to FINER but returned " + l.toString());
+ }
+ }
+ catch ( Exception e ) {
+ throw e;
+ }
+
+ System.out.println( "" );
+ System.out.println( "***************************************************" );
+ System.out.println( "***************** All Tests Passed ****************" );
+ System.out.println( "***************************************************" );
+ }
+
+ public static void main(String[] argv) throws Exception {
+ PlatformLoggingMXBean mbean =
+ ManagementFactory.getPlatformMXBean(PlatformLoggingMXBean.class);
+ ObjectName objname = mbean.getObjectName();
+ if (!objname.equals(new ObjectName(LogManager.LOGGING_MXBEAN_NAME))) {
+ throw new RuntimeException("Invalid ObjectName " + objname);
+ }
+
+ // check if the PlatformLoggingMXBean is registered in the platform MBeanServer
+ MBeanServer platformMBS = ManagementFactory.getPlatformMBeanServer();
+ ObjectName objName = new ObjectName(LogManager.LOGGING_MXBEAN_NAME);
+
+ // We could call mbs.isRegistered(objName) here.
+ // Calling getMBeanInfo will throw exception if not found.
+ platformMBS.getMBeanInfo(objName);
+
+ if (!platformMBS.isInstanceOf(objName, "java.lang.management.PlatformLoggingMXBean") ||
+ !platformMBS.isInstanceOf(objName, "java.util.logging.LoggingMXBean")) {
+ throw new RuntimeException(objName + " is of unexpected type");
+ }
+
+ // test if PlatformLoggingMXBean works properly in a MBeanServer
+ PlatformLoggingMXBeanTest test = new PlatformLoggingMXBeanTest();
+ test.runTest(mbean);
+ }
+}
--- a/jdk/test/java/nio/BufferPoolMXBean/Basic.java Tue Mar 29 11:37:48 2011 -0400
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2007, 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.
- *
- * 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 6606598
- * @summary Unit test for java.nio.BufferPoolMXBean
- * @run main/othervm Basic
- */
-
-import java.nio.ByteBuffer;
-import java.nio.MappedByteBuffer;
-import java.nio.BufferPoolMXBean;
-import java.nio.channels.FileChannel;
-import java.io.File;
-import java.io.RandomAccessFile;
-import java.lang.management.ManagementFactory;
-import javax.management.MBeanServer;
-import javax.management.ObjectName;
-import java.util.*;
-
-public class Basic {
-
- // static fields to ensure buffers aren't GC'ed
- static List<ByteBuffer> buffers;
- static MappedByteBuffer mbb;
-
- // check counters
- static void check(List<BufferPoolMXBean> pools,
- int minBufferCount,
- long minTotalCapacity)
- {
- int bufferCount = 0;
- long totalCap = 0;
- long totalMem = 0;
- for (BufferPoolMXBean pool: pools) {
- bufferCount += pool.getCount();
- totalCap += pool.getTotalCapacity();
- totalMem += pool.getMemoryUsed();
- }
- if (bufferCount < minBufferCount)
- throw new RuntimeException("Count less than expected");
- if (totalMem < minTotalCapacity)
- throw new RuntimeException("Memory usage less than expected");
- if (totalCap < minTotalCapacity)
- throw new RuntimeException("Total capacity less than expected");
- }
-
- public static void main(String[] args) throws Exception {
- Random rand = new Random();
-
- // allocate a few direct buffers
- int bufferCount = 5 + rand.nextInt(20);
- buffers = new ArrayList<ByteBuffer>(bufferCount);
- long totalCapacity = 0L;
- for (int i=0; i<bufferCount; i++) {
- int cap = 1024 + rand.nextInt(4096);
- buffers.add( ByteBuffer.allocateDirect(cap) );
- totalCapacity += cap;
- }
-
- // map a file
- File f = File.createTempFile("blah", null);
- f.deleteOnExit();
- RandomAccessFile raf = new RandomAccessFile(f, "rw");
- FileChannel fc = raf.getChannel();
- mbb = fc.map(FileChannel.MapMode.READ_WRITE, 10, 100);
- bufferCount++;
- totalCapacity += mbb.capacity();
-
- // direct
- List<BufferPoolMXBean> pools =
- ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
- check(pools, bufferCount, totalCapacity);
-
- // using MBeanServer
- MBeanServer server = ManagementFactory.getPlatformMBeanServer();
- Set<ObjectName> mbeans = server.queryNames(
- new ObjectName("java.nio:type=BufferPool,*"), null);
- pools = new ArrayList<BufferPoolMXBean>();
- for (ObjectName name: mbeans) {
- BufferPoolMXBean pool = ManagementFactory
- .newPlatformMXBeanProxy(server, name.toString(), BufferPoolMXBean.class);
- pools.add(pool);
- }
- check(pools, bufferCount, totalCapacity);
- }
-}
--- a/jdk/test/java/nio/channels/AsynchronousSocketChannel/Leaky.java Tue Mar 29 11:37:48 2011 -0400
+++ b/jdk/test/java/nio/channels/AsynchronousSocketChannel/Leaky.java Tue Mar 29 15:50:55 2011 -0700
@@ -28,12 +28,12 @@
*/
import java.nio.ByteBuffer;
-import java.nio.BufferPoolMXBean;
import java.nio.channels.*;
import java.net.*;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
+import java.lang.management.BufferPoolMXBean;
import java.lang.management.ManagementFactory;
/**
--- a/jdk/test/java/util/logging/PlatformLoggingMXBean/PlatformLoggingMXBeanTest.java Tue Mar 29 11:37:48 2011 -0400
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,279 +0,0 @@
-/*
- * Copyright (c) 2003, 2004, 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 6876135
- *
- * @summary Test PlatformLoggingMXBean
- * This test performs similar testing as LoggingMXBeanTest.
- *
- * @build PlatformLoggingMXBeanTest
- * @run main PlatformLoggingMXBeanTest
- */
-
-import javax.management.*;
-import java.lang.management.ManagementFactory;
-import java.util.logging.*;
-import java.util.List;
-
-public class PlatformLoggingMXBeanTest
-{
-
- ObjectName objectName = null;
- static String LOGGER_NAME_1 = "com.sun.management.Logger1";
- static String LOGGER_NAME_2 = "com.sun.management.Logger2";
-
- public PlatformLoggingMXBeanTest() throws Exception {
- }
-
- private void runTest(PlatformLoggingMXBean mBean) throws Exception {
-
- /*
- * Create the MBeanServeri, register the PlatformLoggingMXBean
- */
- System.out.println( "***************************************************" );
- System.out.println( "********** PlatformLoggingMXBean Unit Test **********" );
- System.out.println( "***************************************************" );
- System.out.println( "" );
- System.out.println( "*******************************" );
- System.out.println( "*********** Phase 1 ***********" );
- System.out.println( "*******************************" );
- System.out.println( " Creating MBeanServer " );
- System.out.print( " Register PlatformLoggingMXBean: " );
- MBeanServer mbs = MBeanServerFactory.createMBeanServer();
- String[] list = new String[0];
-
- try {
- objectName = new ObjectName(LogManager.LOGGING_MXBEAN_NAME);
- mbs.registerMBean( mBean, objectName );
- }
- catch ( Exception e ) {
- System.out.println( "FAILED" );
- throw e;
- }
- System.out.println( "PASSED" );
- System.out.println("");
-
- /*
- * Access our MBean to get the current list of Loggers
- */
- System.out.println( "*******************************" );
- System.out.println( "*********** Phase 2 ***********" );
- System.out.println( "*******************************" );
- System.out.println( " Test Logger Name retrieval (getLoggerNames) " );
- // check that Level object are returned properly
- try {
- list = (String[]) mbs.getAttribute( objectName, "LoggerNames" );
- }
- catch ( Exception e ) {
- System.out.println(" : FAILED" );
- throw e;
- }
-
- /*
- * Dump the list of Loggers already present, if any
- */
- Object[] params = new Object[1];
- String[] signature = new String[1];
- Level l;
-
- if ( list == null ) {
- System.out.println(" : PASSED. No Standard Loggers Present" );
- System.out.println("");
- }
- else {
- System.out.println(" : PASSED. There are " + list.length + " Loggers Present" );
- System.out.println("");
- System.out.println( "*******************************" );
- System.out.println( "*********** Phase 2B **********" );
- System.out.println( "*******************************" );
- System.out.println( " Examine Existing Loggers" );
- for ( int i = 0; i < list.length; i++ ) {
- try {
- params[0] = list[i];
- signature[0] = "java.lang.String";
- String levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
- System.out.println(" : Logger #" + i + " = " + list[i] );
- System.out.println(" : Level = " + levelName );
- }
- catch ( Exception e ) {
- System.out.println(" : FAILED" );
- throw e;
- }
- }
- System.out.println(" : PASSED" );
- }
-
- /*
- * Create two new loggers to the list of Loggers already present
- */
- System.out.println("");
- System.out.println( "*******************************" );
- System.out.println( "*********** Phase 3 ***********" );
- System.out.println( "*******************************" );
- System.out.println( " Create and test new Loggers" );
- Logger logger1 = Logger.getLogger( LOGGER_NAME_1 );
- Logger logger2 = Logger.getLogger( LOGGER_NAME_2 );
-
- // check that Level object are returned properly
- try {
- list = (String[]) mbs.getAttribute( objectName, "LoggerNames" );
- }
- catch ( Exception e ) {
- System.out.println(" : FAILED" );
- throw e;
- }
-
- /*
- * Check for the existence of our new Loggers
- */
- boolean log1 = false, log2 = false;
-
- if ( list == null || list.length < 2 ) {
- System.out.println(" : FAILED. Could not Detect the presense of the new Loggers" );
- throw new RuntimeException(
- "Could not Detect the presense of the new Loggers");
- }
- else {
- for ( int i = 0; i < list.length; i++ ) {
- if ( list[i].equals( LOGGER_NAME_1 ) ) {
- log1 = true;
- System.out.println( " : Found new Logger : " + list[i] );
- }
- if ( list[i].equals( LOGGER_NAME_2 ) ) {
- log2 = true;
- System.out.println( " : Found new Logger : " + list[i] );
- }
- }
- if ( log1 && log2 )
- System.out.println( " : PASSED." );
- else {
- System.out.println( " : FAILED. Could not Detect the new Loggers." );
- throw new RuntimeException(
- "Could not Detect the presense of the new Loggers");
- }
- }
-
- /*
- * Set a new Logging levels and check that it succeeded
- */
- System.out.println("");
- System.out.println( "*******************************" );
- System.out.println( "*********** Phase 4 ***********" );
- System.out.println( "*******************************" );
- System.out.println( " Set and Check the Logger Level" );
- log1 = false;
- log2 = false;
- try {
- // Set the level of logger1 to ALL
- params = new Object[2];
- signature = new String[2];
- params[0] = LOGGER_NAME_1;
- params[1] = Level.ALL.getName();
- signature[0] = "java.lang.String";
- signature[1] = "java.lang.String";
- mbs.invoke( objectName, "setLoggerLevel", params, signature );
-
- // Set the level of logger2 to FINER
- params[0] = LOGGER_NAME_2;
- params[1] = Level.FINER.getName();
- mbs.invoke( objectName, "setLoggerLevel", params, signature );
-
- // Okay read back the Level from Logger1. Should be ALL
- params = new Object[1];
- signature = new String[1];
- params[0] = LOGGER_NAME_1;
- signature[0] = "java.lang.String";
- String levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
- l = Level.parse(levelName);
- System.out.print(" Logger1: " );
- if ( l.equals( l.ALL ) ) {
- System.out.println("Level Set to ALL: PASSED" );
- log1 = true;
- }
- else {
- System.out.println("Level Set to ALL: FAILED" );
- throw new RuntimeException(
- "Level Set to ALL but returned " + l.toString());
- }
-
- // Okay read back the Level from Logger2. Should be FINER
- params = new Object[1];
- signature = new String[1];
- params[0] = LOGGER_NAME_2;
- signature[0] = "java.lang.String";
- levelName = (String) mbs.invoke( objectName, "getLoggerLevel", params, signature );
- l = Level.parse(levelName);
- System.out.print(" Logger2: " );
- if ( l.equals( l.FINER ) ) {
- System.out.println("Level Set to FINER: PASSED" );
- log2 = true;
- }
- else {
- System.out.println("Level Set to FINER: FAILED" );
- throw new RuntimeException(
- "Level Set to FINER but returned " + l.toString());
- }
- }
- catch ( Exception e ) {
- throw e;
- }
-
- System.out.println( "" );
- System.out.println( "***************************************************" );
- System.out.println( "***************** All Tests Passed ****************" );
- System.out.println( "***************************************************" );
- }
-
- public static void main(String[] argv) throws Exception {
- List<PlatformLoggingMXBean> result =
- ManagementFactory.getPlatformMXBeans(PlatformLoggingMXBean.class);
- if (result.size() != 1) {
- throw new RuntimeException("Unexpected number of PlatformLoggingMXBean instances: " +
- result.size());
- }
-
- PlatformLoggingMXBean mbean = result.get(0);
- ObjectName objname = mbean.getObjectName();
- if (!objname.equals(new ObjectName(LogManager.LOGGING_MXBEAN_NAME))) {
- throw new RuntimeException("Invalid ObjectName " + objname);
- }
-
- // check if the PlatformLoggingMXBean is registered in the platform MBeanServer
- MBeanServer platformMBS = ManagementFactory.getPlatformMBeanServer();
- ObjectName objName = new ObjectName(LogManager.LOGGING_MXBEAN_NAME);
- // We could call mbs.isRegistered(objName) here.
- // Calling getMBeanInfo will throw exception if not found.
- platformMBS.getMBeanInfo(objName);
-
- if (!platformMBS.isInstanceOf(objName, "java.util.logging.PlatformLoggingMXBean") ||
- !platformMBS.isInstanceOf(objName, "java.util.logging.LoggingMXBean")) {
- throw new RuntimeException(objName + " is of unexpected type");
- }
-
- // test if PlatformLoggingMXBean works properly in a MBeanServer
- PlatformLoggingMXBeanTest test = new PlatformLoggingMXBeanTest();
- test.runTest(mbean);
- }
-}