844 lines
35 KiB
Java
844 lines
35 KiB
Java
/*
|
|
* Copyright (c) 2003, 2018, 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.
|
|
*/
|
|
|
|
package nsk.monitoring.share;
|
|
|
|
import java.util.*;
|
|
import java.io.*;
|
|
import java.lang.reflect.*;
|
|
import java.lang.management.*;
|
|
import javax.management.*;
|
|
import javax.management.loading.*;
|
|
import nsk.share.*;
|
|
|
|
/**
|
|
* The <code>CustomMBeanServer</code> implemenets the
|
|
* {@link javax.management.MBeanServer MBeanServer} interface to provide
|
|
* minimal funcionality for JSR-174 testing.
|
|
* <p>Insignificant methods that are not used just throw {@link TestBug TestBug}
|
|
* with "not implemented" message. If this exception is caught during test
|
|
* execution, the corresponding method must be implemented.
|
|
*/
|
|
|
|
public class CustomMBeanServer implements MBeanServer {
|
|
|
|
// Name of the system property, which specifies class name of MBean server
|
|
final static String SERVER_BUILDER_PROPERTY
|
|
= "javax.management.builder.initial";
|
|
|
|
// Class name of MBeanServer builder that creates CustomMBeanServer
|
|
final static String CUSTOM_SERVER_BUILDER
|
|
= CustomMBeanServerBuilder.class.getCanonicalName();
|
|
|
|
// Default MBeanServer builder
|
|
final static String DEFAULT_SERVER_BUILDER = "";
|
|
|
|
// Internal trace level
|
|
private final static int TRACE_ALL = 10;
|
|
|
|
// Prefix to print while logging
|
|
private final static String LOG_PREFIX = "CustomMBeanServer> ";
|
|
|
|
private final static String BROADCASTER_ITNF_NAME =
|
|
"javax.management.NotificationBroadcaster";
|
|
|
|
private final static String DYNAMICMBEAN_ITNF_NAME =
|
|
"javax.management.DynamicMBean";
|
|
|
|
// Private variables
|
|
private String defaultDomain;
|
|
private CustomMBeanRegistration register = new CustomMBeanRegistration();
|
|
private Log.Logger log;
|
|
private Hashtable<ObjectName, ObjectKeeper> registeredMBeans = new Hashtable<ObjectName, ObjectKeeper>();
|
|
// StandardMBean view of registered MBeans
|
|
private Map<ObjectName, DynamicMBean> registeredMBeansStd = new HashMap<ObjectName, DynamicMBean>();
|
|
|
|
// Inner class to connect ObjectInstance and Object
|
|
class ObjectKeeper {
|
|
ObjectInstance instance;
|
|
Object object;
|
|
|
|
ObjectKeeper(ObjectInstance instance, Object object) {
|
|
this.instance = instance;
|
|
this.object = object;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new <code>CustomMBeanServer</code> object.
|
|
*
|
|
* @param defaultDomain default domain of the new MBeanServer
|
|
*/
|
|
public CustomMBeanServer(String defaultDomain) {
|
|
this.defaultDomain = defaultDomain;
|
|
}
|
|
|
|
/**
|
|
* Instantiates and registers an MBean in the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#createMBean(String, ObjectName)
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name)
|
|
throws ReflectionException,
|
|
InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
MBeanException,
|
|
NotCompliantMBeanException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates and registers an MBean in the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#createMBean(String, ObjectName,
|
|
* Object[], String[])
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
Object[] params, String[] signature)
|
|
throws ReflectionException,
|
|
InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
MBeanException,
|
|
NotCompliantMBeanException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates and registers an MBean in the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#createMBean(String, ObjectName,
|
|
* ObjectName)
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName)
|
|
throws ReflectionException,
|
|
InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
MBeanException,
|
|
NotCompliantMBeanException,
|
|
InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates and registers an MBean in the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#createMBean(String, ObjectName,
|
|
* ObjectName, Object[], String[])
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName, Object[] params,
|
|
String[] signature)
|
|
throws ReflectionException,
|
|
InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
MBeanException,
|
|
NotCompliantMBeanException,
|
|
InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Registers a pre-existing object as an MBean with the MBean server
|
|
*
|
|
* @see javax.management.MBeanServer#registerMBean(Object, ObjectName)
|
|
*/
|
|
public ObjectInstance registerMBean(Object object, ObjectName name)
|
|
throws InstanceAlreadyExistsException,
|
|
MBeanRegistrationException,
|
|
NotCompliantMBeanException {
|
|
ObjectName newName = null;
|
|
|
|
try {
|
|
newName = register.preRegister(this, name);
|
|
} catch (Exception e) {
|
|
register.postRegister(new Boolean(false));
|
|
throw new MBeanRegistrationException(e);
|
|
}
|
|
|
|
// The log object may not be initialized by that time, so try
|
|
// to check it
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[registerMBean] " + newName);
|
|
|
|
if (isRegistered(newName)) {
|
|
register.postRegister(new Boolean(false));
|
|
throw new InstanceAlreadyExistsException("already registered");
|
|
}
|
|
|
|
ObjectInstance instance = null;
|
|
try {
|
|
instance = new ObjectInstance(newName, object.getClass().getName());
|
|
} catch (IllegalArgumentException e) {
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
registeredMBeans.put(newName, new ObjectKeeper(instance, object));
|
|
register.postRegister(new Boolean(true));
|
|
return instance;
|
|
}
|
|
|
|
/**
|
|
* Unregisters an MBean from the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#unregisterMBean(ObjectName)
|
|
*/
|
|
public void unregisterMBean(ObjectName name)
|
|
throws InstanceNotFoundException,
|
|
MBeanRegistrationException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Gets the <code>ObjectInstance</code> for a given MBean registered with
|
|
* the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#getObjectInstance(ObjectName)
|
|
*/
|
|
public ObjectInstance getObjectInstance(ObjectName name)
|
|
throws InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Gets MBeans controlled by the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#queryMBeans(ObjectName, QueryExp)
|
|
*/
|
|
public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query) {
|
|
if ( (name != null) || (query != null) )
|
|
throw new TestBug("not implemented");
|
|
|
|
HashSet<ObjectInstance> result = new HashSet<ObjectInstance>();
|
|
Enumeration enumeration = registeredMBeans.elements();
|
|
while (enumeration.hasMoreElements()) {
|
|
ObjectKeeper keeper = (ObjectKeeper) enumeration.nextElement();
|
|
result.add(keeper.instance);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the names of MBeans controlled by the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#queryNames(ObjectName, QueryExp)
|
|
*/
|
|
public Set<ObjectName> queryNames(ObjectName name, QueryExp query) {
|
|
if (query != null)
|
|
throw new TestBug("not implemented");
|
|
|
|
HashSet<ObjectName> result = new HashSet<ObjectName>();
|
|
Enumeration enumeration = registeredMBeans.elements();
|
|
while (enumeration.hasMoreElements()) {
|
|
ObjectKeeper keeper = (ObjectKeeper) enumeration.nextElement();
|
|
ObjectName obj = keeper.instance.getObjectName();
|
|
if ((name == null) || (name.apply(obj))) {
|
|
result.add(obj);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Checks whether an MBean, identified by its object name, is
|
|
* already registered with the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#isRegistered(ObjectName)
|
|
*/
|
|
public boolean isRegistered(ObjectName name) {
|
|
return registeredMBeans.containsKey(name);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of MBeans registered in the MBean server.
|
|
*
|
|
* @see javax.management.MBeanServer#getMBeanCount()
|
|
*/
|
|
public Integer getMBeanCount() {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Gets the value of a specific attribute of a named MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#getAttribute(ObjectName, String)
|
|
*/
|
|
public Object getAttribute(ObjectName name, String attribute)
|
|
throws MBeanException,
|
|
AttributeNotFoundException,
|
|
InstanceNotFoundException,
|
|
ReflectionException {
|
|
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[getAttribute] " + name + "> " + attribute);
|
|
|
|
DynamicMBean mbean = getObject(name);
|
|
Object result = mbean.getAttribute(attribute);
|
|
if (result instanceof List) {
|
|
List list = (List) result;
|
|
Object[] arr = new Object[list.size()];
|
|
int i = 0;
|
|
for (Object o : list)
|
|
arr[i++] = o;
|
|
return arr;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Gets the values of several attributes of a named MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#getAttributes(ObjectName, String[])
|
|
*/
|
|
public AttributeList getAttributes(ObjectName name, String[] attributes)
|
|
throws InstanceNotFoundException,
|
|
ReflectionException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Sets the value of a specific attribute of a named MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#setAttribute(ObjectName, Attribute)
|
|
*/
|
|
public void setAttribute(ObjectName name, Attribute attribute)
|
|
throws InstanceNotFoundException,
|
|
AttributeNotFoundException,
|
|
InvalidAttributeValueException,
|
|
MBeanException,
|
|
ReflectionException {
|
|
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[setAttribute] " + name + "> " + attribute);
|
|
|
|
DynamicMBean mbean = getObject(name);
|
|
mbean.setAttribute(attribute);
|
|
}
|
|
|
|
/**
|
|
* Sets the values of several attributes of a named MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#setAttributes(ObjectName,
|
|
* AttributeList)
|
|
*/
|
|
public AttributeList setAttributes(ObjectName name,
|
|
AttributeList attributes)
|
|
throws InstanceNotFoundException,
|
|
ReflectionException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Invokes an operation on an MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#invoke(ObjectName, String,
|
|
* Object[], String[])
|
|
*/
|
|
public Object invoke(ObjectName name, String operationName,
|
|
Object[] params, String[] signature)
|
|
throws InstanceNotFoundException,
|
|
MBeanException,
|
|
ReflectionException {
|
|
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[invoke] " + name + "> "
|
|
+ operationName);
|
|
return invokeObjectMethod(name, operationName, params, signature);
|
|
}
|
|
|
|
/**
|
|
* Returns the default domain used for naming the MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#getDefaultDomain()
|
|
*/
|
|
public String getDefaultDomain() {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Returns the list of domains in which any MBean is currently
|
|
* registered.
|
|
*
|
|
* @see javax.management.MBeanServer#getDomains()
|
|
*/
|
|
public String[] getDomains() {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Adds a listener to a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#addNotificationListener(ObjectName,
|
|
* NotificationListener, NotificationFilter, Object)
|
|
*/
|
|
public void addNotificationListener(ObjectName name,
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback) throws InstanceNotFoundException {
|
|
getNotificationBroadcaster(name).addNotificationListener(listener, filter, handback);
|
|
}
|
|
|
|
/**
|
|
* Adds a listener to a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#addNotificationListener(ObjectName,
|
|
* ObjectName, NotificationFilter, Object)
|
|
*/
|
|
public void addNotificationListener(ObjectName name, ObjectName listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#removeNotificationListener(ObjectName,
|
|
* ObjectName)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name, ObjectName listener)
|
|
throws InstanceNotFoundException, ListenerNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#removeNotificationListener(ObjectName,
|
|
* ObjectName, NotificationFilter, Object)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
ObjectName listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException,
|
|
ListenerNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#removeNotificationListener(ObjectName,
|
|
* NotificationListener)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener)
|
|
throws InstanceNotFoundException,
|
|
ListenerNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Removes a listener from a registered MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#removeNotificationListener(ObjectName,
|
|
* NotificationListener, NotificationFilter, Object)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException,
|
|
ListenerNotFoundException {
|
|
}
|
|
|
|
/**
|
|
* This method discovers the attributes and operations that an
|
|
* MBean exposes for management.
|
|
*
|
|
* @see javax.management.MBeanServer#getMBeanInfo(ObjectName)
|
|
*/
|
|
public MBeanInfo getMBeanInfo(ObjectName name)
|
|
throws InstanceNotFoundException,
|
|
IntrospectionException,
|
|
ReflectionException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Returns true if the MBean specified is an instance of the
|
|
* specified class, false otherwise.
|
|
*
|
|
* @see javax.management.MBeanServer#isInstanceOf(ObjectName, String)
|
|
*/
|
|
public boolean isInstanceOf(ObjectName name, String className)
|
|
throws InstanceNotFoundException {
|
|
// DynamicMBean mbean = getObject(name);
|
|
// MBeanInfo info = mbean.getMBeanInfo();
|
|
// return info.getClassName().compareTo(className) == 0;
|
|
|
|
DynamicMBean mbean = getObject(name);
|
|
MBeanInfo info = mbean.getMBeanInfo();
|
|
String infoClassName = info.getClassName();
|
|
|
|
if (log != null) {
|
|
log.trace(TRACE_ALL, "[isInstanceOf] name=" + name);
|
|
log.trace(TRACE_ALL, "[isInstanceOf] className=" + className);
|
|
}
|
|
|
|
if (infoClassName.equals(className)) {
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[isInstanceOf] infoClassName is equal className. return true");
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
ClassLoader cl = mbean.getClass().getClassLoader();
|
|
Class<?> classNameClass = loadClass(className,cl);
|
|
if (classNameClass == null) {
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[isInstanceOf] classNameClass is null. return false");
|
|
return false;
|
|
}
|
|
|
|
if (classNameClass.isInstance(mbean)) {
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[isInstanceOf] mbean is instance of classNameClass. return true");
|
|
return true;
|
|
}
|
|
|
|
Class<?> instanceClass = loadClass(infoClassName,cl);
|
|
if (instanceClass == null) {
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[isInstanceOf] instanceClass is null. return false");
|
|
return false;
|
|
}
|
|
|
|
boolean isAssignable = classNameClass.isAssignableFrom(instanceClass);
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[isInstanceOf] classNameClass is assignable="+isAssignable);
|
|
return isAssignable;
|
|
} catch (ReflectionException e) {
|
|
if (log != null) {
|
|
log.trace(TRACE_ALL, "[isInstanceOf] "+e.getMessage());
|
|
e.printStackTrace(log.getOutStream());
|
|
}
|
|
return false;
|
|
} catch (Exception e) {
|
|
/* Could be SecurityException or ClassNotFoundException */
|
|
if (log != null) {
|
|
log.trace(TRACE_ALL, "[isInstanceOf] "+e.getMessage());
|
|
e.printStackTrace(log.getOutStream());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Load a class with the specified loader, or with this object
|
|
* class loader if the specified loader is null.
|
|
**/
|
|
static Class loadClass(String className, ClassLoader loader)
|
|
throws ReflectionException {
|
|
|
|
Class theClass = null;
|
|
if (className == null) {
|
|
throw new RuntimeOperationsException(new
|
|
IllegalArgumentException("The class name cannot be null"),
|
|
"Exception occured during object instantiation");
|
|
}
|
|
try {
|
|
if (loader == null)
|
|
loader = CustomMBeanServer.class.getClassLoader();
|
|
if (loader != null) {
|
|
theClass = Class.forName(className, false, loader);
|
|
} else {
|
|
theClass = Class.forName(className);
|
|
}
|
|
} catch (ClassNotFoundException e) {
|
|
throw new ReflectionException(e,
|
|
"The MBean class could not be loaded by the context classloader");
|
|
}
|
|
return theClass;
|
|
}
|
|
|
|
|
|
/**
|
|
* Instantiates an object using the list of all class loaders
|
|
* registered in the MBean server's.
|
|
*
|
|
* @see javax.management.MBeanServer#instantiate(String)
|
|
*/
|
|
public Object instantiate(String className)
|
|
throws ReflectionException,
|
|
MBeanException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates an object using the list of all class loaders
|
|
* registered in the MBean server's.
|
|
*
|
|
* @see javax.management.MBeanServer#instantiate(String, ObjectName)
|
|
*/
|
|
public Object instantiate(String className, ObjectName loaderName)
|
|
throws ReflectionException,
|
|
MBeanException,
|
|
InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates an object using the list of all class loaders
|
|
* registered in the MBean server's.
|
|
*
|
|
* @see javax.management.MBeanServer#instantiate(String, Object[],
|
|
* String[])
|
|
*/
|
|
public Object instantiate(String className, Object[] params,
|
|
String[] signature)
|
|
throws ReflectionException,
|
|
MBeanException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Instantiates an object using the list of all class loaders
|
|
* registered in the MBean server's.
|
|
*
|
|
* @see javax.management.MBeanServer#instantiate(String, ObjectName,
|
|
* Object[], String[])
|
|
*/
|
|
public Object instantiate(String className, ObjectName loaderName,
|
|
Object[] params, String[] signature)
|
|
throws ReflectionException,
|
|
MBeanException,
|
|
InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* De-serializes a byte array in the context of the class loader
|
|
* of an MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#deserialize(ObjectName, byte[])
|
|
*/
|
|
public ObjectInputStream deserialize(ObjectName name, byte[] data)
|
|
throws InstanceNotFoundException,
|
|
OperationsException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* De-serializes a byte array in the context of the class loader
|
|
* of an MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#deserialize(String, byte[])
|
|
*/
|
|
public ObjectInputStream deserialize(String className, byte[] data)
|
|
throws OperationsException,
|
|
ReflectionException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* De-serializes a byte array in the context of the class loader
|
|
* of an MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#deserialize(String, ObjectName, byte[])
|
|
*/
|
|
public ObjectInputStream deserialize(String className,
|
|
ObjectName loaderName,
|
|
byte[] data)
|
|
throws InstanceNotFoundException,
|
|
OperationsException,
|
|
ReflectionException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Return the {@link java.lang.ClassLoader} that was used for
|
|
* loading the class of the named MBean.
|
|
*
|
|
* @see javax.management.MBeanServer#getClassLoaderFor(ObjectName)
|
|
*/
|
|
public ClassLoader getClassLoaderFor(ObjectName mbeanName)
|
|
throws InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Return the named {@link java.lang.ClassLoader}.
|
|
*
|
|
* @see javax.management.MBeanServer#getClassLoader(ObjectName)
|
|
*/
|
|
public ClassLoader getClassLoader(ObjectName loaderName)
|
|
throws InstanceNotFoundException {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Return the named {@link java.lang.ClassLoader}.
|
|
*
|
|
* @see javax.management.MBeanServer#getClassLoader(ObjectName)
|
|
*/
|
|
public ClassLoaderRepository getClassLoaderRepository() {
|
|
throw new TestBug("not implemented");
|
|
}
|
|
|
|
/**
|
|
* Initializes {@link Log <code>Log</code>} object.
|
|
*
|
|
* @param log a new <code>Log</code> object.
|
|
*/
|
|
public void setLog(Log log) {
|
|
this.log = new Log.Logger(log, LOG_PREFIX + "> ");
|
|
}
|
|
|
|
// **********************************************************************
|
|
//
|
|
// Private methods
|
|
//
|
|
// **********************************************************************
|
|
|
|
/**
|
|
* Gets the object reference for a given MBean registered with the MBean
|
|
* server.
|
|
*
|
|
* @param name The object name of the MBean.
|
|
*
|
|
* @return The MBean object, specified by <code>name</code>.
|
|
*
|
|
* @throws InstanceNotFoundException The MBean specified is not registered
|
|
* in the MBean server.
|
|
*/
|
|
private DynamicMBean getObject(ObjectName name) throws InstanceNotFoundException {
|
|
DynamicMBean mbean = registeredMBeansStd.get(name);
|
|
if (mbean == null) {
|
|
ObjectKeeper objKeeper = registeredMBeans.get(name);
|
|
if (objKeeper == null)
|
|
throw new InstanceNotFoundException();
|
|
Object object = objKeeper.object;
|
|
if (object instanceof DynamicMBean)
|
|
mbean = (DynamicMBean) object;
|
|
else
|
|
mbean = new StandardMBean(object, getMBeanInterface(object), true);
|
|
registeredMBeansStd.put(name, mbean);
|
|
}
|
|
return mbean;
|
|
/*
|
|
ObjectKeeper objKeeper = (ObjectKeeper) registeredMBeans.get(name);
|
|
|
|
if (objKeeper == null)
|
|
throw new InstanceNotFoundException();
|
|
|
|
Class superOfMBeans = null;
|
|
try {
|
|
superOfMBeans = Class.forName(DYNAMICMBEAN_ITNF_NAME);
|
|
} catch (ClassNotFoundException e) {
|
|
throw new InstanceNotFoundException();
|
|
}
|
|
|
|
if (superOfMBeans.isAssignableFrom(objKeeper.object.getClass())) {
|
|
return (DynamicMBean )objKeeper.object;
|
|
}
|
|
|
|
return null;
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Obtain NotificationBroadcaster for given MBean registered with the MBean
|
|
* server.
|
|
*
|
|
* @param name The object name of the MBean.
|
|
*
|
|
* @return The MBean object, specified by <code>name</code>.
|
|
*
|
|
* @throws InstanceNotFoundException if MBean specified is not registered
|
|
* in the MBean server.
|
|
*/
|
|
private NotificationBroadcaster getNotificationBroadcaster(ObjectName name) throws InstanceNotFoundException {
|
|
ObjectKeeper objKeeper = (ObjectKeeper) registeredMBeans.get(name);
|
|
if (objKeeper == null)
|
|
throw new InstanceNotFoundException();
|
|
Object mbean = objKeeper.object;
|
|
if (mbean instanceof NotificationBroadcaster)
|
|
return (NotificationBroadcaster) mbean;
|
|
throw new InstanceNotFoundException();
|
|
}
|
|
|
|
/**
|
|
* Invoke the method
|
|
*/
|
|
private Object invokeObjectMethod(ObjectName name, String methodName,
|
|
Object[] params, String[] signature) throws InstanceNotFoundException,
|
|
MBeanException,
|
|
ReflectionException {
|
|
|
|
if (log != null)
|
|
log.trace(TRACE_ALL, "[invokeObjectMethod] " + name + "> "
|
|
+ methodName);
|
|
|
|
DynamicMBean mbean = getObject(name);
|
|
return mbean.invoke(methodName, params, signature);
|
|
}
|
|
|
|
private Class getInterface(Class cl, String prefix) {
|
|
Class[] interfaces = cl.getInterfaces();
|
|
if (interfaces == null || interfaces.length == 0)
|
|
return null;
|
|
for (Class c : interfaces) {
|
|
if (c.getName().startsWith(prefix))
|
|
return c;
|
|
c = getInterface(c, prefix);
|
|
if (c != null)
|
|
return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Discover MBean interface of the bean.
|
|
*
|
|
* Note: this is very specialized for java.lang.management
|
|
* and java.util.logging tests.
|
|
* It is generally not correct for any MBean.
|
|
*
|
|
* @param object the bean
|
|
* @return interface class
|
|
*/
|
|
private Class getMBeanInterface(Object object) throws InstanceNotFoundException {
|
|
String className = object.getClass().getName();
|
|
Class<?> iface = null;
|
|
if (className.startsWith("java.lang.management"))
|
|
iface = getInterface(object.getClass(), "java.lang.management");
|
|
else if (className.startsWith("java.util.logging"))
|
|
iface = getInterface(object.getClass(), "java.util.logging");
|
|
else if (className.startsWith("sun.management"))
|
|
iface = getInterface(object.getClass(), "java.lang.management");
|
|
if (iface != null)
|
|
return iface;
|
|
Class<?>[] interfaces = object.getClass().getInterfaces();
|
|
System.out.println(object);
|
|
System.out.println(object.getClass());
|
|
System.out.println(interfaces.length);
|
|
for (Class<?> c : interfaces) {
|
|
System.out.println(c.getName());
|
|
}
|
|
throw new TestBug("No suitable implemented interface found for: " + object + " class: " + object.getClass());
|
|
}
|
|
}
|