ManagementReprImpl.java

package org.objectweb.jonas.jmx;

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.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 ManagementReprImpl implements ManagementRepr
{

    static private Logger logger = null;

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

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

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

        try {
            return ConnectorFactory.getRMIConnector().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 ConnectorFactory.getRMIConnector().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 {

            //Logger logger = Log.getLogger("org.objectweb.jonas.jmx");
            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 {
                ConnectorFactory.getRMIConnector().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 ConnectorFactory.getRMIConnector().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 ConnectorFactory.getRMIConnector().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) ConnectorFactory.getRMIConnector().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) ConnectorFactory.getRMIConnector().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 ConnectorFactory.getContext();
            }

        public String getCurrentRMIConnectorName()
            {
                return ConnectorFactory.getCurrentRMIConnectorName();
            }

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

        public void resetCurrentRMIConnectorName()
            {
                ConnectorFactory.resetCurrentRMIConnectorName();
            }

        public Set getRMIConnectorsNames()
            throws javax.naming.NamingException
            {
                return ConnectorFactory.getRMIConnectorsNames();
            }

        public String getJonasNamingServiceURL()
            {
                return ConnectorFactory.getJonasNamingServiceURL();
            }

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

        public void setNamingEnvCtx(Properties env) throws javax.naming.NamingException {
            ConnectorFactory.setNamingEnvCtx(env);
        }
}

---