mirror of git://gcc.gnu.org/git/gcc.git
818 lines
29 KiB
Java
818 lines
29 KiB
Java
/* ManagementFactory.java - Factory for obtaining system beans.
|
|
Copyright (C) 2006 Free Software Foundation
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package java.lang.management;
|
|
|
|
import gnu.classpath.SystemProperties;
|
|
|
|
import gnu.java.lang.management.ClassLoadingMXBeanImpl;
|
|
import gnu.java.lang.management.CompilationMXBeanImpl;
|
|
import gnu.java.lang.management.GarbageCollectorMXBeanImpl;
|
|
import gnu.java.lang.management.OperatingSystemMXBeanImpl;
|
|
import gnu.java.lang.management.MemoryMXBeanImpl;
|
|
import gnu.java.lang.management.MemoryManagerMXBeanImpl;
|
|
import gnu.java.lang.management.MemoryPoolMXBeanImpl;
|
|
import gnu.java.lang.management.RuntimeMXBeanImpl;
|
|
import gnu.java.lang.management.ThreadMXBeanImpl;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.lang.reflect.InvocationHandler;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Proxy;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import java.util.logging.LogManager;
|
|
|
|
import javax.management.Attribute;
|
|
import javax.management.InstanceAlreadyExistsException;
|
|
import javax.management.MBeanRegistrationException;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerConnection;
|
|
import javax.management.MBeanServerFactory;
|
|
import javax.management.MalformedObjectNameException;
|
|
import javax.management.NotCompliantMBeanException;
|
|
import javax.management.NotificationEmitter;
|
|
import javax.management.NotificationFilter;
|
|
import javax.management.NotificationListener;
|
|
import javax.management.ObjectName;
|
|
|
|
import javax.management.openmbean.CompositeData;
|
|
import javax.management.openmbean.TabularData;
|
|
|
|
/**
|
|
* <p>
|
|
* Provides access to the system's management beans via a series
|
|
* of static methods.
|
|
* </p>
|
|
* <p>
|
|
* An instance of a system management bean can be obtained by
|
|
* using one of the following methods:
|
|
* </p>
|
|
* <ol>
|
|
* <li>Calling the appropriate static method of this factory.
|
|
* </li>
|
|
* <li>Using the platform {@link javax.management.MBeanServer}
|
|
* to access the beans locally, or an
|
|
* {@link javax.management.MBeanServerConnection} for remote
|
|
* access. The attributes and operations use the limited
|
|
* range of data types specified below.</li>
|
|
* </ol>
|
|
* <h2>Open Data Types</h2>
|
|
* <p>
|
|
* The data types used by the management beans are restricted
|
|
* to <emph>open</emph> data types to aid interoperability. This
|
|
* allows the beans to be accessed remotely, including from non-Java
|
|
* clients. Below is a table which lists the types used by the beans
|
|
* on the left, and the types they are converted to when returned via
|
|
* a bean server on the right. Type information is provided for each
|
|
* bean by obtaining its instance of {@link javax.management.MBeanInfo}.
|
|
* </p>
|
|
* <table>
|
|
* <th><td>Data Type Used</td><td>Data Type Returned</td></th>
|
|
* <tr>
|
|
* <td>Primitive types (<code>int</code>, <code>char</code>, etc.)</td>
|
|
* <td>Same</td>
|
|
* </tr><tr>
|
|
* <td>Wrapper classes ({@link{java.lang.Integer},
|
|
* @link{java.lang.Character}, etc.)</td>
|
|
* <td>Same</td>
|
|
* </tr><tr>
|
|
* <td>An {@link java.lang.Enum}</td>
|
|
* <td>The <code>name</code> of the enumeration constant</td>
|
|
* </tr><tr>
|
|
* <td>An array of type <code>E</code></td>
|
|
* <td>An array of the same dimensions with this mapping applied
|
|
* to <code>E</code>.</td>
|
|
* </tr><tr>
|
|
* <td>A class with `getter' methods and a
|
|
* <code>from({@link javax.management.openmbean.CompositeData})</code>
|
|
* method.</td>
|
|
* <td>The equivalent {@link javax.management.openmbean.CompositeData}
|
|
* instance, specified by the <code>from</code> method.</td>
|
|
* </tr><tr>
|
|
* <td>A map with keys of type <code>K</code> and values of
|
|
* type <code>V</code>.</td>
|
|
* <td>A {@link javax.management.openmbean.TabularData} instance,
|
|
* with the row type containing two items, <code>"key"</code> and
|
|
* <code>"value"</code> with the types <code>K</code> and <code>V</code>
|
|
* respectively (with translation applied).</td>
|
|
* </tr><tr>
|
|
* <td>A list of type <code>E</code>.</td>
|
|
* <td>An array with this mapping applied to <code>E</code>.</td>
|
|
* </tr></table>
|
|
*
|
|
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
|
|
* @since 1.5
|
|
*/
|
|
public class ManagementFactory
|
|
{
|
|
|
|
/**
|
|
* The object name for the class loading bean.
|
|
*/
|
|
public static final String CLASS_LOADING_MXBEAN_NAME =
|
|
"java.lang:type=ClassLoading";
|
|
|
|
/**
|
|
* The object name for the compilation bean.
|
|
*/
|
|
public static final String COMPILATION_MXBEAN_NAME =
|
|
"java.lang:type=Compilation";
|
|
|
|
/**
|
|
* The domain for the garbage collecting beans.
|
|
*/
|
|
public static final String GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE =
|
|
"java.lang:type=GarbageCollector";
|
|
|
|
/**
|
|
* The domain for the memory manager beans.
|
|
*/
|
|
public static final String MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE =
|
|
"java.lang:type=MemoryManager";
|
|
|
|
/**
|
|
* The object name for the memory bean.
|
|
*/
|
|
public static final String MEMORY_MXBEAN_NAME =
|
|
"java.lang:type=Memory";
|
|
|
|
/**
|
|
* The domain for the memory pool beans.
|
|
*/
|
|
public static final String MEMORY_POOL_MXBEAN_DOMAIN_TYPE =
|
|
"java.lang:type=MemoryPool";
|
|
|
|
/**
|
|
* The object name for the operating system bean.
|
|
*/
|
|
public static final String OPERATING_SYSTEM_MXBEAN_NAME =
|
|
"java.lang:type=OperatingSystem";
|
|
|
|
/**
|
|
* The object name for the runtime bean.
|
|
*/
|
|
public static final String RUNTIME_MXBEAN_NAME =
|
|
"java.lang:type=Runtime";
|
|
|
|
/**
|
|
* The object name for the threading bean.
|
|
*/
|
|
public static final String THREAD_MXBEAN_NAME =
|
|
"java.lang:type=Threading";
|
|
|
|
/**
|
|
* The operating system management bean.
|
|
*/
|
|
private static OperatingSystemMXBean osBean;
|
|
|
|
/**
|
|
* The runtime management bean.
|
|
*/
|
|
private static RuntimeMXBean runtimeBean;
|
|
|
|
/**
|
|
* The class loading management bean.
|
|
*/
|
|
private static ClassLoadingMXBean classLoadingBean;
|
|
|
|
/**
|
|
* The thread bean.
|
|
*/
|
|
private static ThreadMXBean threadBean;
|
|
|
|
/**
|
|
* The memory bean.
|
|
*/
|
|
private static MemoryMXBean memoryBean;
|
|
|
|
/**
|
|
* The compilation bean (may remain null).
|
|
*/
|
|
private static CompilationMXBean compilationBean;
|
|
|
|
/**
|
|
* The platform server.
|
|
*/
|
|
private static MBeanServer platformServer;
|
|
|
|
/**
|
|
* Private constructor to prevent instance creation.
|
|
*/
|
|
private ManagementFactory() {}
|
|
|
|
/**
|
|
* Returns the operating system management bean for the
|
|
* operating system on which the virtual machine is running.
|
|
*
|
|
* @return an instance of {@link OperatingSystemMXBean} for
|
|
* the underlying operating system.
|
|
*/
|
|
public static OperatingSystemMXBean getOperatingSystemMXBean()
|
|
{
|
|
if (osBean == null)
|
|
try
|
|
{
|
|
osBean = new OperatingSystemMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"operating system bean is not a " +
|
|
"compliant management bean.");
|
|
}
|
|
return osBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the runtime management bean for the
|
|
* running virtual machine.
|
|
*
|
|
* @return an instance of {@link RuntimeMXBean} for
|
|
* this virtual machine.
|
|
*/
|
|
public static RuntimeMXBean getRuntimeMXBean()
|
|
{
|
|
if (runtimeBean == null)
|
|
try
|
|
{
|
|
runtimeBean = new RuntimeMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"runtime bean is not a compliant " +
|
|
"management bean.");
|
|
}
|
|
return runtimeBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the class loading management bean for the
|
|
* running virtual machine.
|
|
*
|
|
* @return an instance of {@link ClassLoadingMXBean} for
|
|
* this virtual machine.
|
|
*/
|
|
public static ClassLoadingMXBean getClassLoadingMXBean()
|
|
{
|
|
if (classLoadingBean == null)
|
|
try
|
|
{
|
|
classLoadingBean = new ClassLoadingMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"class loading bean is not a " +
|
|
"compliant management bean.");
|
|
}
|
|
return classLoadingBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the thread management bean for the running
|
|
* virtual machine.
|
|
*
|
|
* @return an instance of {@link ThreadMXBean} for
|
|
* this virtual machine.
|
|
*/
|
|
public static ThreadMXBean getThreadMXBean()
|
|
{
|
|
if (threadBean == null)
|
|
try
|
|
{
|
|
threadBean = new ThreadMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"thread bean is not a compliant " +
|
|
"management bean.");
|
|
}
|
|
return threadBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the memory management bean for the running
|
|
* virtual machine.
|
|
*
|
|
* @return an instance of {@link MemoryMXBean} for
|
|
* this virtual machine.
|
|
*/
|
|
public static MemoryMXBean getMemoryMXBean()
|
|
{
|
|
if (memoryBean == null)
|
|
try
|
|
{
|
|
memoryBean = new MemoryMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"memory bean is not a compliant " +
|
|
"management bean.");
|
|
}
|
|
return memoryBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the compilation bean for the running
|
|
* virtual machine, if supported. Otherwise,
|
|
* it returns <code>null</code>.
|
|
*
|
|
* @return an instance of {@link CompilationMXBean} for
|
|
* this virtual machine, or <code>null</code>
|
|
* if the virtual machine doesn't include
|
|
* a Just-In-Time (JIT) compiler.
|
|
*/
|
|
public static CompilationMXBean getCompilationMXBean()
|
|
{
|
|
if (compilationBean == null &&
|
|
SystemProperties.getProperty("gnu.java.compiler.name") != null)
|
|
try
|
|
{
|
|
compilationBean = new CompilationMXBeanImpl();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"compilation bean is not a compliant " +
|
|
"management bean.");
|
|
}
|
|
return compilationBean;
|
|
}
|
|
|
|
/**
|
|
* Returns the memory pool beans for the running
|
|
* virtual machine. These may change during the course
|
|
* of execution.
|
|
*
|
|
* @return a list of memory pool beans, one for each pool.
|
|
*/
|
|
public static List<MemoryPoolMXBean> getMemoryPoolMXBeans()
|
|
{
|
|
List<MemoryPoolMXBean> poolBeans =
|
|
new ArrayList<MemoryPoolMXBean>();
|
|
String[] names = VMManagementFactory.getMemoryPoolNames();
|
|
for (int a = 0; a < names.length; ++a)
|
|
try
|
|
{
|
|
poolBeans.add(new MemoryPoolMXBeanImpl(names[a]));
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"memory pool bean, " + a + ", is " +
|
|
"not a compliant management bean.");
|
|
}
|
|
return poolBeans;
|
|
}
|
|
|
|
/**
|
|
* Returns the memory manager beans for the running
|
|
* virtual machine. These may change during the course
|
|
* of execution.
|
|
*
|
|
* @return a list of memory manager beans, one for each manager.
|
|
*/
|
|
public static List<MemoryManagerMXBean> getMemoryManagerMXBeans()
|
|
{
|
|
List<MemoryManagerMXBean> managerBeans =
|
|
new ArrayList<MemoryManagerMXBean>();
|
|
String[] names = VMManagementFactory.getMemoryManagerNames();
|
|
for (int a = 0; a < names.length; ++a)
|
|
try
|
|
{
|
|
managerBeans.add(new MemoryManagerMXBeanImpl(names[a]));
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"memory manager bean, " + a + ", is " +
|
|
"not a compliant management bean.");
|
|
}
|
|
managerBeans.addAll(getGarbageCollectorMXBeans());
|
|
return managerBeans;
|
|
}
|
|
|
|
/**
|
|
* Returns the garbage collector beans for the running
|
|
* virtual machine. These may change during the course
|
|
* of execution.
|
|
*
|
|
* @return a list of garbage collector beans, one for each pool.
|
|
*/
|
|
public static List<GarbageCollectorMXBean> getGarbageCollectorMXBeans()
|
|
{
|
|
List<GarbageCollectorMXBean> gcBeans =
|
|
new ArrayList<GarbageCollectorMXBean>();
|
|
String[] names = VMManagementFactory.getGarbageCollectorNames();
|
|
for (int a = 0; a < names.length; ++a)
|
|
try
|
|
{
|
|
gcBeans.add(new GarbageCollectorMXBeanImpl(names[a]));
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw new InternalError("The GNU implementation of the " +
|
|
"garbage collector bean, " + a +
|
|
", is not a compliant management " +
|
|
"bean.");
|
|
}
|
|
return gcBeans;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns the platform {@link javax.management.MBeanServer}. On the
|
|
* first call to this method, a server instance is retrieved from
|
|
* the {@link javax.management.MBeanServerFactory} and each of the
|
|
* beans are registered with it. Subsequent calls return the existing
|
|
* instance. If the property <code>javax.management.builder.initial</code>
|
|
* is set, its value will be used as the name of the class which is used
|
|
* to provide the server instance.
|
|
* </p>
|
|
* <p>
|
|
* It is recommended that the platform server is used for other beans as
|
|
* well, in order to simplify their discovery and publication. Name conflicts
|
|
* should be avoided.
|
|
* </p>
|
|
*
|
|
* @return the platform {@link javax.management.MBeanServer}
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanServerPermission(String)}("createMBeanServer")
|
|
* @see javax.management.MBeanServerFactory
|
|
* @see javax.management.MBeanServerFactory#createMBeanServer()
|
|
*/
|
|
public static MBeanServer getPlatformMBeanServer()
|
|
{
|
|
if (platformServer == null)
|
|
{
|
|
platformServer = MBeanServerFactory.createMBeanServer();
|
|
try
|
|
{
|
|
platformServer.registerMBean(getOperatingSystemMXBean(),
|
|
new ObjectName(OPERATING_SYSTEM_MXBEAN_NAME));
|
|
platformServer.registerMBean(getRuntimeMXBean(),
|
|
new ObjectName(RUNTIME_MXBEAN_NAME));
|
|
platformServer.registerMBean(getClassLoadingMXBean(),
|
|
new ObjectName(CLASS_LOADING_MXBEAN_NAME));
|
|
platformServer.registerMBean(getThreadMXBean(),
|
|
new ObjectName(THREAD_MXBEAN_NAME));
|
|
platformServer.registerMBean(getMemoryMXBean(),
|
|
new ObjectName(MEMORY_MXBEAN_NAME));
|
|
CompilationMXBean compBean = getCompilationMXBean();
|
|
if (compBean != null)
|
|
platformServer.registerMBean(compBean,
|
|
new ObjectName(COMPILATION_MXBEAN_NAME));
|
|
Iterator beans = getMemoryPoolMXBeans().iterator();
|
|
while (beans.hasNext())
|
|
{
|
|
MemoryPoolMXBean bean = (MemoryPoolMXBean) beans.next();
|
|
platformServer.registerMBean(bean,
|
|
new ObjectName(MEMORY_POOL_MXBEAN_DOMAIN_TYPE +
|
|
",name=" +
|
|
bean.getName()));
|
|
}
|
|
beans = getMemoryManagerMXBeans().iterator();
|
|
while (beans.hasNext())
|
|
{
|
|
MemoryManagerMXBean bean = (MemoryManagerMXBean) beans.next();
|
|
platformServer.registerMBean(bean,
|
|
new ObjectName(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE +
|
|
",name=" +
|
|
bean.getName()));
|
|
}
|
|
beans = getGarbageCollectorMXBeans().iterator();
|
|
while (beans.hasNext())
|
|
{
|
|
GarbageCollectorMXBean bean = (GarbageCollectorMXBean) beans.next();
|
|
platformServer.registerMBean(bean,
|
|
new ObjectName(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE +
|
|
",name=" +
|
|
bean.getName()));
|
|
}
|
|
platformServer.registerMBean(LogManager.getLoggingMXBean(),
|
|
new ObjectName(LogManager.LOGGING_MXBEAN_NAME));
|
|
}
|
|
catch (InstanceAlreadyExistsException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("One of the management beans is " +
|
|
"already registered.").initCause(e));
|
|
}
|
|
catch (MBeanRegistrationException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("One of the management beans' preRegister " +
|
|
"methods threw an exception.").initCause(e));
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("One of the management beans is " +
|
|
"not compliant.").initCause(e));
|
|
}
|
|
catch (MalformedObjectNameException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("The object name of a management bean is " +
|
|
"not compliant.").initCause(e));
|
|
}
|
|
}
|
|
return platformServer;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns a proxy for the specified platform bean. A proxy object is created
|
|
* using <code>Proxy.newProxyInstance(mxbeanInterface.getClassLoader(),
|
|
* new Class[] { mxbeanInterface }, handler)</code>. The
|
|
* {@link javax.management.NotificationEmitter} class is also added to the
|
|
* array if the bean provides notifications. <code>handler</code> refers
|
|
* to the invocation handler which forwards calls to the connection, and
|
|
* also provides translation between the Java data types used in the
|
|
* bean interfaces and the open data types, as specified in the description
|
|
* of this class. It is this translation that makes the
|
|
* usual {@link javax.management.MBeanServerInvocationHandler} inappropriate
|
|
* for providing such a proxy.
|
|
* </p>
|
|
* <p>
|
|
* <strong>Note</strong>: use of the proxy may result in
|
|
* {@link java.io.IOException}s from the underlying {@link MBeanServerConnection}
|
|
* and a {@link java.io.InvalidObjectException} if enum constants
|
|
* used on the client and the server don't match.
|
|
* </p>
|
|
*
|
|
* @param connection the server connection to use to access the bean.
|
|
* @param mxbeanName the {@link javax.management.ObjectName} of the
|
|
* bean to provide a proxy for.
|
|
* @param mxbeanInterface the interface for the bean being proxied.
|
|
* @return a proxy for the specified bean.
|
|
* @throws IllegalArgumentException if <code>mxbeanName</code> is not a valid
|
|
* {@link javax.management.ObjectName},
|
|
* the interface and name do not match the
|
|
* same bean, the name does not refer to a
|
|
* platform bean or the bean is not registered
|
|
* with the server accessed by <code>connection</code>.
|
|
* @throws IOException if the connection throws one.
|
|
*/
|
|
public static <T> T newPlatformMXBeanProxy(MBeanServerConnection connection,
|
|
String mxbeanName,
|
|
Class<T> mxbeanInterface)
|
|
throws IOException
|
|
{
|
|
if (!(mxbeanName.equals(CLASS_LOADING_MXBEAN_NAME) ||
|
|
mxbeanName.equals(COMPILATION_MXBEAN_NAME) ||
|
|
mxbeanName.startsWith(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE) ||
|
|
mxbeanName.startsWith(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE) ||
|
|
mxbeanName.equals(MEMORY_MXBEAN_NAME) ||
|
|
mxbeanName.startsWith(MEMORY_POOL_MXBEAN_DOMAIN_TYPE) ||
|
|
mxbeanName.equals(OPERATING_SYSTEM_MXBEAN_NAME) ||
|
|
mxbeanName.equals(RUNTIME_MXBEAN_NAME) ||
|
|
mxbeanName.equals(THREAD_MXBEAN_NAME)))
|
|
{
|
|
throw new IllegalArgumentException("The named bean, " + mxbeanName +
|
|
", is not a platform name.");
|
|
}
|
|
if ((mxbeanName.equals(CLASS_LOADING_MXBEAN_NAME) &&
|
|
mxbeanInterface != ClassLoadingMXBean.class) ||
|
|
(mxbeanName.equals(COMPILATION_MXBEAN_NAME) &&
|
|
mxbeanInterface != CompilationMXBean.class) ||
|
|
(mxbeanName.startsWith(GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE) &&
|
|
mxbeanInterface != GarbageCollectorMXBean.class) ||
|
|
(mxbeanName.startsWith(MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE) &&
|
|
mxbeanInterface != MemoryManagerMXBean.class) ||
|
|
(mxbeanName.equals(MEMORY_MXBEAN_NAME) &&
|
|
mxbeanInterface != MemoryMXBean.class) ||
|
|
(mxbeanName.startsWith(MEMORY_POOL_MXBEAN_DOMAIN_TYPE) &&
|
|
mxbeanInterface != MemoryPoolMXBean.class) ||
|
|
(mxbeanName.equals(OPERATING_SYSTEM_MXBEAN_NAME) &&
|
|
mxbeanInterface != OperatingSystemMXBean.class) ||
|
|
(mxbeanName.equals(RUNTIME_MXBEAN_NAME) &&
|
|
mxbeanInterface != RuntimeMXBean.class) ||
|
|
(mxbeanName.equals(THREAD_MXBEAN_NAME) &&
|
|
mxbeanInterface != ThreadMXBean.class))
|
|
throw new IllegalArgumentException("The interface, " + mxbeanInterface +
|
|
", does not match the bean, " + mxbeanName);
|
|
ObjectName bean;
|
|
try
|
|
{
|
|
bean = new ObjectName(mxbeanName);
|
|
}
|
|
catch (MalformedObjectNameException e)
|
|
{
|
|
throw new IllegalArgumentException("The named bean is invalid.");
|
|
}
|
|
if (!(connection.isRegistered(bean)))
|
|
throw new IllegalArgumentException("The bean is not registered on this connection.");
|
|
Class[] interfaces;
|
|
if (mxbeanName.equals(MEMORY_MXBEAN_NAME))
|
|
interfaces = new Class[] { mxbeanInterface, NotificationEmitter.class };
|
|
else
|
|
interfaces = new Class[] { mxbeanInterface };
|
|
return (T) Proxy.newProxyInstance(mxbeanInterface.getClassLoader(),
|
|
interfaces,
|
|
new ManagementInvocationHandler(connection, bean));
|
|
}
|
|
|
|
/**
|
|
* This invocation handler provides method calls for a platform bean
|
|
* by forwarding them to a {@link MBeanServerConnection}. Translation from
|
|
* Java data types to open data types is performed as specified above.
|
|
*
|
|
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
|
|
* @since 1.5
|
|
*/
|
|
private static class ManagementInvocationHandler
|
|
implements InvocationHandler
|
|
{
|
|
|
|
/**
|
|
* The encapsulated connection.
|
|
*/
|
|
private MBeanServerConnection conn;
|
|
|
|
/**
|
|
* The bean being proxied.
|
|
*/
|
|
private ObjectName bean;
|
|
|
|
/**
|
|
* Constructs a new {@link InvocationHandler} which proxies
|
|
* for the specified bean using the supplied connection.
|
|
*
|
|
* @param conn the connection on which to forward method calls.
|
|
* @param bean the bean to proxy.
|
|
*/
|
|
public ManagementInvocationHandler(MBeanServerConnection conn,
|
|
ObjectName bean)
|
|
throws IOException
|
|
{
|
|
this.conn = conn;
|
|
this.bean = bean;
|
|
}
|
|
|
|
/**
|
|
* Called by the proxy class whenever a method is called. The method
|
|
* is emulated by retrieving an attribute from, setting an attribute on
|
|
* or invoking a method on the server connection as required. Translation
|
|
* between the Java data types supplied as arguments to the open types used
|
|
* by the bean is provided, as well as translation of the return value back
|
|
* in to the appropriate Java type.
|
|
*
|
|
* @param proxy the proxy on which the method was called.
|
|
* @param method the method which was called.
|
|
* @param args the arguments supplied to the method.
|
|
* @return the return value from the method.
|
|
* @throws Throwable if an exception is thrown in performing the
|
|
* method emulation.
|
|
*/
|
|
public Object invoke(Object proxy, Method method, Object[] args)
|
|
throws Throwable
|
|
{
|
|
String name = method.getName();
|
|
if (name.equals("toString"))
|
|
return "Proxy for " + bean + " using " + conn;
|
|
if (name.equals("addNotificationListener"))
|
|
{
|
|
conn.addNotificationListener(bean,
|
|
(NotificationListener) args[0],
|
|
(NotificationFilter) args[1],
|
|
args[2]);
|
|
return null;
|
|
}
|
|
if (name.equals("getNotificationInfo"))
|
|
return conn.getMBeanInfo(bean).getNotifications();
|
|
if (name.equals("removeNotificationListener"))
|
|
{
|
|
if (args.length == 1)
|
|
conn.removeNotificationListener(bean,
|
|
(NotificationListener)
|
|
args[0]);
|
|
else
|
|
conn.removeNotificationListener(bean,
|
|
(NotificationListener)
|
|
args[0],
|
|
(NotificationFilter)
|
|
args[1], args[2]);
|
|
return null;
|
|
}
|
|
String attrib = null;
|
|
if (name.startsWith("get"))
|
|
attrib = name.substring(3);
|
|
else if (name.startsWith("is"))
|
|
attrib = name.substring(2);
|
|
if (attrib != null)
|
|
return translate(conn.getAttribute(bean, attrib), method);
|
|
else if (name.startsWith("set"))
|
|
{
|
|
conn.setAttribute(bean, new Attribute(name.substring(3),
|
|
args[0]));
|
|
return null;
|
|
}
|
|
else
|
|
return translate(conn.invoke(bean, name, args, null), method);
|
|
}
|
|
|
|
/**
|
|
* Translates the returned open data type to the value
|
|
* required by the interface.
|
|
*
|
|
* @param otype the open type returned by the method call.
|
|
* @param method the method that was called.
|
|
* @return the equivalent return type required by the interface.
|
|
* @throws Throwable if an exception is thrown in performing the
|
|
* conversion.
|
|
*/
|
|
private final Object translate(Object otype, Method method)
|
|
throws Throwable
|
|
{
|
|
Class<?> returnType = method.getReturnType();
|
|
if (returnType.isEnum())
|
|
{
|
|
String ename = (String) otype;
|
|
Enum[] constants = (Enum[]) returnType.getEnumConstants();
|
|
for (Enum c : constants)
|
|
if (c.name().equals(ename))
|
|
return c;
|
|
}
|
|
if (List.class.isAssignableFrom(returnType))
|
|
{
|
|
Object[] elems = (Object[]) otype;
|
|
List l = new ArrayList(elems.length);
|
|
for (Object elem : elems)
|
|
l.add(elem);
|
|
return l;
|
|
}
|
|
if (Map.class.isAssignableFrom(returnType))
|
|
{
|
|
TabularData data = (TabularData) otype;
|
|
Map m = new HashMap(data.size());
|
|
for (Object val : data.values())
|
|
{
|
|
CompositeData vals = (CompositeData) val;
|
|
m.put(vals.get("key"), vals.get("value"));
|
|
}
|
|
return m;
|
|
}
|
|
try
|
|
{
|
|
Method m = returnType.getMethod("from",
|
|
new Class[]
|
|
{ CompositeData.class });
|
|
return m.invoke(null, (CompositeData) otype);
|
|
}
|
|
catch (NoSuchMethodException e)
|
|
{
|
|
/* Ignored; we expect this if this
|
|
isn't a from(CompositeData) class */
|
|
}
|
|
return otype;
|
|
}
|
|
|
|
}
|
|
}
|