ManagementBean.java

package org.objectweb.jonas.mejb;

import java.io.IOException;
import java.rmi.RemoteException;
import java.util.Set;

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.IntrospectionException;
import javax.management.InvalidAttributeValueException;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.QueryExp;
import javax.management.ReflectionException;
import javax.management.j2ee.ListenerRegistration;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.management.j2eemanagement.ManagementListener;
import org.objectweb.jonas.management.j2eemanagement.ManagementListenerMBean;
import org.objectweb.jonas.service.ServiceManager;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class ManagementBean implements SessionBean {

    private static Logger logger = Log.getLogger(Log.JONAS_MEJB);
    private SessionContext sessionContext = null;

    private MBeanServer jmxServer = null;

    private MBeanServerConnection currentServerConnection = null;

    private boolean connected = false;
    private String serverName = null;
    private String domainName = null;
    private String proxyName = "MEJB_listener";

    public void ejbCreate() {
        // Get the MBeanServer reference to allow local access
        JmxService jmxService = null;
        try {
            jmxService = (JmxService) ServiceManager.getInstance().getJmxService();
        } catch (Exception e) {
            // should never occurs
        }
//        JMXServiceURL[] jmxServiceUrls = jmxService.getConnectorServerURLs();
//        int nbAvailableConnections = jmxServiceUrls.length;
//        for (int i = 0; i < nbAvailableConnections; i++) {
//            JMXServiceURL url = jmxServiceUrls[i];
//            logger.log(BasicLevel.DEBUG, "Try to connect to MBeanServer using url:" + url);
//            try {
//                JMXConnector connector = JMXConnectorFactory.newJMXConnector(url, null);
//                connector.connect();
//                currentServerConnection = connector.getMBeanServerConnection();
//                connected = true;
//                logger.log(BasicLevel.DEBUG, "Connected via url:" + url);
//                break;
//            } catch (IOException ioe) {
//                // This may not happen normally as we are not trying to connect to a remote server
//                logger.log(BasicLevel.DEBUG, "Cannot connect to MBeanServer using url:" + url);
//            }
//        }
        if (!connected) {
            jmxServer = jmxService.getJmxServer();
        }
        serverName = jmxService.getJonasServerName();
        domainName = jmxService.getDomainName();

    }

    /*====================== javax.ejb.SessionBean implementation =================*/

    public void ejbActivate() {
        // Nothing to do when the MEJB is activated
    }
    public void ejbPassivate() {
        // Nothing to do when the MEJB is passivated
    }
    public void ejbRemove() {
        // Nothing to do when the MEJB is removed
    }
    public void setSessionContext(SessionContext sessionContext) {
        this.sessionContext = sessionContext;
    }

    /*========================= ManagementBean implementation ============================*/
    /*=============== The management methods are invoked on the local MBeanServer ========*/

    public Object getAttribute(ObjectName name, String attribute) throws
        MBeanException,
        AttributeNotFoundException,
        InstanceNotFoundException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            return jmxServer.getAttribute(name, attribute);
        } else {
            try {
                return currentServerConnection.getAttribute(name, attribute);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("Object getAttribute(ObjectName, String) failed", ioe);
            }
        }
    }

    public AttributeList getAttributes(ObjectName name, String[] attributes) throws
        InstanceNotFoundException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            return jmxServer.getAttributes(name, attributes);
        } else {
            try {
                return currentServerConnection.getAttributes(name, attributes);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("AttributeList getAttributes(ObjectName, String[]) failed", ioe);
            }
        }
    }

    public String getDefaultDomain() throws RemoteException {

        if (!connected) {
            return jmxServer.getDefaultDomain();
        } else {
            try {
                return currentServerConnection.getDefaultDomain();
            } catch (java.io.IOException ioe) {
                throw new RemoteException("String getDefaultDomain() failed", ioe);
            }
        }
    }

    public Integer getMBeanCount() throws RemoteException {

        if (!connected) {
            return jmxServer.getMBeanCount();
        } else {
            try {
                return currentServerConnection.getMBeanCount();
            } catch (java.io.IOException ioe) {
                throw new RemoteException("Integer getMBeanCount() failed", ioe);
            }
        }
    }

    public MBeanInfo getMBeanInfo(ObjectName name) throws
        IntrospectionException,
        InstanceNotFoundException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            return jmxServer.getMBeanInfo(name);
        } else {
            try {
                return currentServerConnection.getMBeanInfo(name);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("MBeanInfo getMBeanInfo(ObjectName) failed", ioe);
            }
        }
    }

    public Object invoke(ObjectName name, String operationName, Object[] params, String[] signature) throws
        MBeanException,
        InstanceNotFoundException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            return jmxServer.invoke(name, operationName, params, signature);
        } else {
            try {
                return currentServerConnection.invoke(name, operationName, params, signature);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("Object invoke(ObjectName, String, Object[], String[]) failed", ioe);
            }
        }
    }

    public boolean isRegistered(ObjectName name) throws RemoteException {

        if (!connected) {
            return jmxServer.isRegistered(name);
        } else {
            try {
                return currentServerConnection.isRegistered(name);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("boolean isRegistered(ObjectName) failed", ioe);
            }
        }
    }

    public Set queryNames(ObjectName name, QueryExp query) throws RemoteException {
        if (!connected) {
            return jmxServer.queryNames(name, query);
        } else {
            try {
                return currentServerConnection.queryNames(name, query);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("Set queryNames(ObjectName, QueryExp)  failed", ioe);
            }
        }
    }

    public void setAttribute(ObjectName name, Attribute attribute) throws
        MBeanException,
        AttributeNotFoundException,
        InstanceNotFoundException,
        InvalidAttributeValueException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            jmxServer.setAttribute(name, attribute);
        } else {
            try {
                currentServerConnection.setAttribute(name, attribute);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("void setAttribute(ObjectName, Attribute) failed", ioe);
            }
        }
    }

    public AttributeList setAttributes(ObjectName name, AttributeList attributes) throws
        InstanceNotFoundException,
        ReflectionException,
        RemoteException {

        if (!connected) {
            return jmxServer.setAttributes(name, attributes);
        } else {
            try {
                return currentServerConnection.setAttributes(name, attributes);
            } catch (java.io.IOException ioe) {
                throw new RemoteException("AttributeList setAttributes(ObjectName, AttributeList) failed", ioe);
            }
        }
    }

    public ListenerRegistration getListenerRegistry() throws RemoteException {
        if (!connected) {
            // Create and register the ManagemenentListener MBean if this is not already done
            ObjectName listenerOn = J2eeObjectName.ManagementListener(domainName, serverName);
            boolean isRegisteredListener;
            isRegisteredListener = jmxServer.isRegistered(listenerOn);
            if (!isRegisteredListener) {
                ManagementListenerMBean listenerMBean = new ManagementListener(proxyName);
                try {
                    jmxServer.registerMBean(listenerMBean, listenerOn);
                } catch (InstanceAlreadyExistsException ae) {
                    // Not possible as tested before
                } catch (Exception e) {
                    // Could not register MBean -> the management bean can't handle notifications
                    throw new RemoteException("Can not return ListenerRegistration implementation", e);
                }
            }
            // Create ListenerRegistration object
            return new ListenerRegistrationImpl(listenerOn, proxyName);
        } else {
            // JMX Remote way of adding remote listeners not yet implemented
            return null;
        }
    }
}

---