/*
* Copyright 2005 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.felix.jmxintrospector;
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.List;
/*import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.NotFoundException;
*/
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerInvocationHandler;
import javax.management.MalformedObjectNameException;
import javax.management.NotificationEmitter;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Predicate;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.InterfaceMaker;
import org.objectweb.asm.Type;
/**
*
* The MBeanProxyFactory is the central element of the jmxintrospector library. The main method is the {@link MBeanProxyFactory#newProxyInstance(String)}
* method, that accepts an objectname in String form and returns a proxy for that mbean.
* Internally, it uses the cglib library, although it be made to work with other bytecode libraries. More specifically,prior versions used the Javassist library
*/
public class MBeanProxyFactory {
private MBeanServerConnection mbeanServer;
public MBeanProxyFactory(){
}
public MBeanProxyFactory(MBeanServerConnection mbeanServer) {
super();
this.mbeanServer = mbeanServer;
}
/**
* Internal method for generating the Class object for the dynamically-generated interface for the mbean.
* The name given to the class is based on the actual classname of the mbean, although some extensions are added
* to it by the cglib library to avoid namespace clashes.
* @param oname
* @return
* @throws IOException
* @throws InstanceNotFoundException
* @throws ClassNotFoundException
* @throws ReflectionException
* @throws IntrospectionException
* @throws
* @throws MalformedObjectNameException
* @throws Exception
*/
private Class getInterface(String oname) throws MalformedObjectNameException, InstanceNotFoundException, IOException, IntrospectionException, ReflectionException {
ObjectName objectName=ObjectName.getInstance(oname);
String ifaceName=mbeanServer.getObjectInstance(objectName).getClassName();
//uses the ifaceName as the prefix for the class name
InterfaceMaker maker=new MBeanInterfaceMaker(ifaceName);
for (Signature s : getSignatures(objectName)) {
//add each method
maker.add(s, null);
}
return maker.create();
}
private Type getType(String type) throws ClassNotFoundException{
return JmxAsmHelper.getAsmType(type);
}
/**
* Internal method for generating the signatures of the mbeans.
* @param objectName
* @return
* @throws IOException
* @throws ReflectionException
* @throws IntrospectionException
* @throws InstanceNotFoundException
*/
private List<Signature> getSignatures(ObjectName objectName)throws InstanceNotFoundException, IntrospectionException, ReflectionException, IOException{
List<Signature> methods=new ArrayList<Signature>();
MBeanInfo minfo;
MBeanAttributeInfo[] attributes=null;
minfo = mbeanServer.getMBeanInfo(objectName);
attributes=minfo.getAttributes();
for (MBeanAttributeInfo info : attributes) {
String name=info.getName().substring(0, 1).toUpperCase()+info.getName().substring(1);
if(info.isReadable()){
//For each readable attribute, we generate a getter method (following the isXX for booleans
//when it is being used on the remote side)
if(info.isIs()){
methods.add(new Signature("is"+name, Type.BOOLEAN_TYPE, new Type[0]));
}
else{
try{
methods.add(new Signature("get"+name, getType(info.getType()), new Type[0]));
}catch(ClassNotFoundException cnfe){
System.out.println("JMXINTROSPECTOR WARNING: "+info.getType()+" could not be found. Attribute will not be added to proxy.");
continue;
}
}
}
//Same with each writable att, but with setters.
if(info.isWritable()){
try{
Type [] params=new Type[]{getType(info.getType())};
Signature s=new Signature("set"+name, Type.VOID_TYPE, params);
methods.add(s);
}catch(ClassNotFoundException cnfe){
System.out.println("JMXINTROSPECTOR WARNING: "+info.getType()+" could not be found. Attribute will not be added to proxy.");
continue;
}
}
}
//same for each operation
for (MBeanOperationInfo info : minfo.getOperations()) {
try{
Type[] params=new Type[info.getSignature().length];
for (int i = 0; i < params.length; i++) {
params[i]=getType(info.getSignature()[i].getType());
}
Signature s=new Signature(info.getName(), getType(info.getReturnType()), params);
methods.add(s);
}catch(ClassNotFoundException cnfe){
System.out.println("JMXINTROSPECTOR WARNING: "+info.toString()+" could not be created. Operation will not be added to proxy.");
continue;
}
}
return methods;
}
/**
* Returns a proxy object for the MBean specified by the object name oname in the
* mbean server associated with this factory. This proxy object implements the generated interface plus
* the MBean interface. It will also be a notification broadcaster if the underlying mbean broadcasts notifications.
* @param oname
* @return
* @throws IOException
* @throws ReflectionException
* @throws IntrospectionException
* @throws InstanceNotFoundException
* @throws
* @throws MalformedObjectNameException
* @throws Exception
*/
public Object newProxyInstance(String oname) throws MalformedObjectNameException, InstanceNotFoundException, IntrospectionException, ReflectionException, IOException{
ObjectName objectName=ObjectName.getInstance(oname);
Class iface=getInterface(oname);
MBeanInfo info=mbeanServer.getMBeanInfo(objectName);
boolean isBroadcaster=false;
MBeanNotificationInfo[] notifs=info.getNotifications();
if (notifs!=null && notifs.length!=0) isBroadcaster=true;
//We first create the proxy for the remote mbean. If broadcasting supported, then it adds the broadcasting interface
Object proxy=MBeanServerInvocationHandler.newProxyInstance(mbeanServer, objectName, iface, isBroadcaster);
//We get the underlying invocation handler, needed for the wrapper handler. The wrapper adds the mbean interface functionality
//and integrates JMX invocation handler.
InvocationHandler h=Proxy.getInvocationHandler(proxy);
InvocationHandler wrapper=new JMXInvocationHandler(oname,mbeanServer, mbeanServer.getMBeanInfo(objectName), h);
Class[] ifaces;
if (isBroadcaster) {
ifaces=new Class[]{iface, NotificationEmitter.class, MBean.class};
}else ifaces=new Class[]{iface, MBean.class};
//finally, we create the proxy with the appropriate classloader, the interfaces and the invocation handler
Object mbeanProxy=Proxy.newProxyInstance(proxy.getClass().getClassLoader(), ifaces, wrapper);
return mbeanProxy;
}
private class JMXInvocationHandler implements InvocationHandler, MBean{
private String objectName;
private MBeanServerConnection mBeanServer;
private InvocationHandler mbeanHandler;
private MBeanInfo mbeanInfo;
public JMXInvocationHandler(String objectName, MBeanServerConnection mbeanServer, MBeanInfo mBeanInfo, InvocationHandler mbeanHandler) {
super();
this.objectName = objectName;
this.mBeanServer = mbeanServer;
this.mbeanHandler = mbeanHandler;
this.mbeanInfo =mBeanInfo;
}
//FIXME: hashCode() and equals do not work if not exposed in management interface. I have not thought of a workaround for that yet.
//note that this is needed for hashmaps and comparisons.
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//decide wether to invoke the JMXInvocationHandler we have implemented
//or use the one that was created by the MBeanServerInvocationHandler
if(method.getDeclaringClass().equals(MBean.class)){
return this.getClass().getMethod(method.getName(), null).invoke(this, args);
}
else return mbeanHandler.invoke(proxy, method, args);
}
public MBeanServerConnection getMBeanServer() {
return mBeanServer;
}
public String getObjectName() {
return objectName;
}
public MBeanInfo getMBeanInfo() {
return mbeanInfo;
}
}
public MBeanServerConnection getMbeanServer() {
return mbeanServer;
}
public void setMbeanServer(MBeanServerConnection mbs) {
this.mbeanServer = mbs;
}
/**
* This class is used to be able to modify the super class,
* because setNamePrefix and setAttemptLoad are protected methods
*
*/
private class MBeanInterfaceMaker extends InterfaceMaker{
public MBeanInterfaceMaker(String namePrefix) {
super();
super.setNamePrefix(namePrefix);
super.setAttemptLoad(true);
}
}
}