ManagementReprImplJSR160.java

package org.objectweb.jonas.jmx;

import java.util.HashSet;
import java.util.Properties;
import java.util.Set;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.RuntimeErrorException;
import javax.management.RuntimeMBeanException;
import javax.management.RuntimeOperationsException;
import javax.naming.Context;

import org.objectweb.jonas.common.Log;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class ManagementReprImplJSR160 implements ManagementRepr {

    private static Logger logger = null;
    private MBeanServerConnection mbeanServerConnection = null;

    protected ManagementReprImplJSR160() {
        logger = Log.getLogger("org.objectweb.jonas.jmx");
        logger.log(BasicLevel.DEBUG, "Management Representativ based on JSR160 created for jonasAdmin");
    }

    public boolean isRegistered(ObjectName on) {
        try {
            return mbeanServerConnection.isRegistered(on);
        } catch (Exception e) {
            return false;
        }
    }

    public Object getAttribute(ObjectName on, String attribute)
    throws ManagementException {

        try {
            return mbeanServerConnection.getAttribute(on, attribute);
        } catch (Exception e) {
            throw new ManagementException("Error while getting attribute " + attribute + ": "
                    + e.getClass().getName(), e);
        }
    }

    public AttributeList getAttributes(ObjectName on, String[] attributes)
    throws ManagementException {

        try {
            return mbeanServerConnection.getAttributes(on, attributes);
        } catch (Exception e) {
            throw new ManagementException("Error while getting attributes: "
                    + e.getClass().getName(), e);
        }
    }

    public void setAttribute(ObjectName on, String attribute, Object value)
    throws ManagementException {
        if(logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG
                    , "Set Attribute called, on " + on.toString() + " to change attribute " + attribute
                    + " value to " + (String) value.toString());
        }

        try {
            mbeanServerConnection.setAttribute(on, new Attribute(attribute, value));
        } catch (Exception e) {
            throw new ManagementException("Error while setting attribute " + attribute + ": "
                    + e.getClass().getName(), e);
        }
    }

    public AttributeList setAttributes(ObjectName on, AttributeList attributes)
    throws ManagementException {

        try {
            return mbeanServerConnection.setAttributes(on, attributes);
        } catch (Exception e) {
            throw new ManagementException("Error while setting attributes: "
                    + e.getClass().getName(), e);
        }
    }

    public Object invoke(ObjectName on, String operation, Object[] param, String[] signature)
    throws ManagementException {

        try {
            return mbeanServerConnection.invoke(on, operation, param, signature);
        } catch (Exception e) {
            String message = "";
            String targetExcName = null;
            Throwable exc = null;
            if (e instanceof MBeanException ||
                    e instanceof ReflectionException ||
                    e instanceof RuntimeMBeanException ||
                    e instanceof RuntimeOperationsException ||
                    e instanceof RuntimeErrorException) {

                Exception targetExc = null;
                if (e instanceof MBeanException)                {
                    targetExc = ((MBeanException) e).getTargetException();
                }
                else if (e instanceof ReflectionException) {
                    targetExc = ((ReflectionException) e).getTargetException();
                }
                else if (e instanceof RuntimeMBeanException) {
                    targetExc = ((RuntimeMBeanException) e).getTargetException();
                }
                else if (e instanceof RuntimeOperationsException) {
                    targetExc = ((RuntimeOperationsException) e).getTargetException();
                }
                else if (e instanceof RuntimeErrorException) {
                    Error atargetExc = ((RuntimeErrorException) e).getTargetError();
                    targetExc = new Exception(atargetExc.getMessage());
                }
                targetExcName = targetExc.toString();
                exc = targetExc;
            }
            else {
                exc = e;
            }
            if(logger.isLoggable(BasicLevel.DEBUG)) {
                logger.log(BasicLevel.DEBUG
                        , "Exception ----[ " + e.toString() + " while invoking operation " + operation +
                        " on MBean " + on.toString() + " ]-------");
                if (targetExcName != null) {
                    logger.log(BasicLevel.DEBUG, "-------[ Embedded error : ]-------");
                    logger.log(BasicLevel.DEBUG, "-------[ " + targetExcName + " ]-------");
                }
            }

            throw new ManagementException(message, exc);
        }
    }

    public java.util.Set queryNames(ObjectName on)
    throws ManagementException {
        try {
            return (java.util.Set) mbeanServerConnection.queryNames(on, null);
        } catch (Exception e) {
            throw new ManagementException("Error while getting MBeans names: " + e.getClass().getName()
                    , e);
        }
    }

    public MBeanInfo getMBeanInfo(ObjectName name)
    throws ManagementException {
        try {
            return (MBeanInfo) mbeanServerConnection.getMBeanInfo(name);
        } catch (Exception e) {
            throw new ManagementException("Error while getting MBean info: " + e.getClass().getName()
                    , e);
        }
    }

    public Context getContext() throws javax.naming.NamingException {
        return null;
    }

    public String getCurrentRMIConnectorName() {
        return "jonas";
    }

    public void setCurrentRMIConnectorName(String name) throws Exception {
        ;
    }

    public void resetCurrentRMIConnectorName() {
        ;
    }

    public Set getRMIConnectorsNames() throws javax.naming.NamingException {
        HashSet res = new HashSet();
        res.add("jonas");
        return res;
    }

    public String getJonasNamingServiceURL() {
        return "url";
    }

    public void setJonasNamingServiceURL(String url) throws javax.naming.NamingException {
        ;
    }

    public void setNamingEnvCtx(Properties env) throws javax.naming.NamingException {
        ;
    }
    public MBeanServerConnection getMBeanServerConnection() {
        return mbeanServerConnection;
    }
    public void setMBeanServerConnection(
            MBeanServerConnection mbeanServerConnection) {
        this.mbeanServerConnection = mbeanServerConnection;
    }
}

---