/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.mosgi.jmx.agent.mx4j.server.interceptor;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InvalidAttributeValueException;
import javax.management.JMRuntimeException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanRegistration;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.NotificationBroadcaster;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectInstance;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.RuntimeErrorException;
import javax.management.RuntimeMBeanException;
import javax.management.NotificationEmitter;
import org.apache.felix.mosgi.jmx.agent.mx4j.ImplementationException;
import org.apache.felix.mosgi.jmx.agent.mx4j.log.Logger;
import org.apache.felix.mosgi.jmx.agent.mx4j.server.MBeanMetaData;
import org.apache.felix.mosgi.jmx.agent.mx4j.util.Utils;
/**
* The last MBeanServer --$gt; MBean interceptor in the chain.
* It calls the MBean instance; if the MBean is a dynamic MBean, the call is direct, otherwise the call is delegated
* to an {@link mx4j.server.MBeanInvoker MBeanInvoker}.
*
* @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a>
* @version $Revision: 1.1.1.1 $
*/
public class InvokerMBeanServerInterceptor extends DefaultMBeanServerInterceptor implements InvokerMBeanServerInterceptorMBean
{
private MBeanServer outerServer;
/**
* Instantiates a new interceptor instance.
* @param outerServer the {@link MBeanServer} instance that is passed to
* {@link MBeanRegistration#preRegister(MBeanServer, ObjectName)}.
*/
public InvokerMBeanServerInterceptor(MBeanServer outerServer)
{
this.outerServer = outerServer;
}
/**
* Returns the type of this interceptor
*/
public String getType()
{
return "invoker";
}
/**
* This interceptor is always enabled
*/
public boolean isEnabled()
{
return true;
}
public void addNotificationListener(MBeanMetaData metadata, NotificationListener listener, NotificationFilter filter, Object handback)
{
((NotificationBroadcaster)metadata.mbean).addNotificationListener(listener, filter, handback);
}
public void removeNotificationListener(MBeanMetaData metadata, NotificationListener listener) throws ListenerNotFoundException
{
((NotificationBroadcaster)metadata.mbean).removeNotificationListener(listener);
}
public void removeNotificationListener(MBeanMetaData metadata, NotificationListener listener, NotificationFilter filter, Object handback)
throws ListenerNotFoundException
{
((NotificationEmitter)metadata.mbean).removeNotificationListener(listener, filter, handback);
}
public void instantiate(MBeanMetaData metadata, String className, String[] params, Object[] args) throws ReflectionException, MBeanException
{
try
{
ClassLoader loader = metadata.classloader;
Class cls = null;
if (loader != null)
cls = loader.loadClass(className);
else
cls = Class.forName(className, false, null);
Class[] signature = Utils.loadClasses(loader, params);
Constructor ctor = cls.getConstructor(signature);
metadata.mbean = ctor.newInstance(args);
}
catch (ClassNotFoundException x)
{
throw new ReflectionException(x);
}
catch (NoSuchMethodException x)
{
throw new ReflectionException(x);
}
catch (InstantiationException x)
{
throw new ReflectionException(x);
}
catch (IllegalAccessException x)
{
throw new ReflectionException(x);
}
catch (IllegalArgumentException x)
{
throw new ReflectionException(x);
}
catch (InvocationTargetException x)
{
Throwable t = x.getTargetException();
if (t instanceof Error)
{
throw new RuntimeErrorException((Error)t);
}
else if (t instanceof RuntimeException)
{
throw new RuntimeMBeanException((RuntimeException)t);
}
else
{
throw new MBeanException((Exception)t);
}
}
}
public void registration(MBeanMetaData metadata, int operation) throws MBeanRegistrationException
{
if (!(metadata.mbean instanceof MBeanRegistration)) return;
MBeanRegistration registrable = (MBeanRegistration)metadata.mbean;
try
{
switch (operation)
{
case PRE_REGISTER:
ObjectName objName = registrable.preRegister(outerServer, metadata.name);
metadata.name = objName;
break;
case POST_REGISTER_TRUE:
registrable.postRegister(Boolean.TRUE);
break;
case POST_REGISTER_FALSE:
registrable.postRegister(Boolean.FALSE);
break;
case PRE_DEREGISTER:
registrable.preDeregister();
break;
case POST_DEREGISTER:
registrable.postDeregister();
break;
default:
throw new ImplementationException();
}
}
catch (RuntimeException x) {
throw new RuntimeMBeanException(x);
}
catch (Exception x)
{
if (x instanceof MBeanRegistrationException)
{
throw (MBeanRegistrationException)x;
}
throw new MBeanRegistrationException(x);
}
}
public MBeanInfo getMBeanInfo(MBeanMetaData metadata)
{
if (metadata.dynamic)
{
// From JMX 1.1 the MBeanInfo may be dynamically changed at every time, let's refresh it
MBeanInfo info = null;
try {
info = ((DynamicMBean)metadata.mbean).getMBeanInfo();
} catch (RuntimeException x) {
throw new RuntimeMBeanException(x);
}
if (info == null) return null;
metadata.info = info;
// Refresh also ObjectInstance.getClassName(), if it's the case
String className = info.getClassName();
if (!metadata.instance.getClassName().equals(className))
{
metadata.instance = new ObjectInstance(metadata.name, className);
}
}
return (MBeanInfo)metadata.info.clone();
}
public Object invoke(MBeanMetaData metadata, String method, String[] params, Object[] args) throws MBeanException, ReflectionException
{
if (metadata.dynamic)
{
try
{
return ((DynamicMBean)metadata.mbean).invoke(method, args, params);
}
catch (JMRuntimeException x)
{
throw x;
}
catch (RuntimeException x)
{
throw new RuntimeMBeanException(x);
}
catch (Error x)
{
throw new RuntimeErrorException(x);
}
}
else
{
return metadata.invoker.invoke(metadata, method, params, args);
}
}
public Object getAttribute(MBeanMetaData metadata, String attribute) throws MBeanException, AttributeNotFoundException, ReflectionException
{
if (metadata.dynamic)
{
try
{
return ((DynamicMBean)metadata.mbean).getAttribute(attribute);
}
catch (JMRuntimeException x)
{
throw x;
}
catch (RuntimeException x)
{
throw new RuntimeMBeanException(x);
}
catch (Error x)
{
throw new RuntimeErrorException(x);
}
}
else
{
return metadata.invoker.getAttribute(metadata, attribute);
}
}
public void setAttribute(MBeanMetaData metadata, Attribute attribute) throws MBeanException, AttributeNotFoundException, InvalidAttributeValueException, ReflectionException
{
if (metadata.dynamic)
{
try
{
((DynamicMBean)metadata.mbean).setAttribute(attribute);
}
catch (JMRuntimeException x)
{
throw x;
}
catch (RuntimeException x)
{
throw new RuntimeMBeanException(x);
}
catch (Error x)
{
throw new RuntimeErrorException(x);
}
}
else
{
metadata.invoker.setAttribute(metadata, attribute);
}
}
public AttributeList getAttributes(MBeanMetaData metadata, String[] attributes)
{
if (metadata.dynamic)
{
try
{
return ((DynamicMBean)metadata.mbean).getAttributes(attributes);
}
catch (JMRuntimeException x)
{
throw x;
}
catch (RuntimeException x)
{
throw new RuntimeMBeanException(x);
}
catch (Error x)
{
throw new RuntimeErrorException(x);
}
}
else
{
AttributeList list = new AttributeList();
for (int i = 0; i < attributes.length; ++i)
{
String name = attributes[i];
try
{
Object value = getAttribute(metadata, name);
Attribute attr = new Attribute(name, value);
list.add(attr);
}
catch (Exception ignored)
{
Logger logger = getLogger();
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Exception caught from getAttributes(), ignoring attribute " + name);
}
}
return list;
}
}
public AttributeList setAttributes(MBeanMetaData metadata, AttributeList attributes)
{
if (metadata.dynamic)
{
try
{
return ((DynamicMBean)metadata.mbean).setAttributes(attributes);
}
catch (JMRuntimeException x)
{
throw x;
}
catch (RuntimeException x)
{
throw new RuntimeMBeanException(x);
}
catch (Error x)
{
throw new RuntimeErrorException(x);
}
}
else
{
AttributeList list = new AttributeList();
for (int i = 0; i < attributes.size(); ++i)
{
Attribute attr = (Attribute)attributes.get(i);
try
{
setAttribute(metadata, attr);
list.add(attr);
}
catch (Exception ignored)
{
Logger logger = getLogger();
if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Exception caught from setAttributes(), ignoring attribute " + attr, ignored);
}
}
return list;
}
}
}