J2EEDomain.java

package org.objectweb.jonas.management.j2eemanagement;

import java.io.IOException;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.management.InstanceNotFoundException;
import javax.management.JMException;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanRegistration;
import javax.management.MBeanServer;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerNotification;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
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.discovery.DiscEvent;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class J2EEDomain extends J2EEManagedObject implements MBeanRegistration, NotificationListener {

    private String name = null;
    private ArrayList myServers = null;

    private static Logger logger = null;

    private MBeanServer mbeanServer = null;

    private Map managedServersToUrls = null;
    private Map managedServersToConnectors = null;
    private Map managedServersToConnections = null;

    public J2EEDomain(String objectName, boolean stateManageable, boolean statisticsProvider, boolean eventProvider) throws JMException {
        super(objectName, stateManageable, statisticsProvider, eventProvider);
        ObjectName myObjectName = ObjectName.getInstance(objectName);
        name = myObjectName.getKeyProperty("name");
        myServers = new ArrayList();
        managedServersToConnectors = new HashMap();
        managedServersToConnections = new HashMap();
        managedServersToUrls = new HashMap();
        logger = Log.getLogger("org.objectweb.jonas.management.j2eemanagement");
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "J2EEDomain managed object created. OBJECT_NAME = " + objectName);
        }
    }

    public String[] getServers() {
        //return (String[]) myServers.toArray();
        String[] sb = new String[myServers.size()];
        int i = 0;
        for (Iterator it = myServers.iterator(); it.hasNext();) {
            sb[i++] = (String) it.next();
        }
        return sb;
    }

    public void addServer(String serverName) {
        if (myServers.contains(serverName)) {
            if (logger.isLoggable(BasicLevel.DEBUG)) {
                logger.log(BasicLevel.DEBUG, "The object name: " + serverName + " is already in the servers list");
            }
        } else {
            myServers.add(serverName);
        }
    }

    public String removeServer(String serverName) {
        int index = myServers.indexOf(serverName);
        if (index == -1) {
            // name not found
            return null;
        } else {
            return (String) myServers.remove(index);
        }
    }

    public MBeanServerConnection getConnection(String serverName) {
        MBeanServerConnection connection = null;
        connection = (MBeanServerConnection) managedServersToConnections.get(serverName);
        testConnection(connection, serverName);
        return connection;
    }
    public void addServer(String domainName, String serverName, String connectorServerURL) {
        logger = Log.getLogger("org.objectweb.jonas.management.j2eemanagement");
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "domain name: " + domainName + ", server name: " + serverName + ", url: " + connectorServerURL);
        }
        if (domainName.equals(name)) {
            // Server thet belongs to the current management domain
            if (managedServersToUrls.containsKey(serverName)) {
                // This server is already known
                ArrayList urls = (ArrayList) managedServersToUrls.get(serverName);
                if (!urls.contains(connectorServerURL)) {
                    // Add this new connectorServerURL in the connectors list
                    urls.add(connectorServerURL);
                    // try to create a connection for this connectorServerURL
                    createConnection(serverName, connectorServerURL);
                }
            } else {
                // Add new server
                ArrayList urls = new ArrayList();
                urls.add(connectorServerURL);
                managedServersToUrls.put(serverName, urls);
                // try to create a connection
                boolean created = createConnection(serverName, connectorServerURL);
                if (created) {
                    // Update the servers list
                    ObjectName on = J2eeObjectName.J2EEServer(domainName, serverName);
                    addServer(on.toString());
                }
            }
        } else {
            if (logger.isLoggable(BasicLevel.WARN)) {
                logger.log(BasicLevel.WARN, "The server named " + serverName + " was not started in the management domain "
                        + name + ", but in management domain " + domainName);
            }
        }
    }

    public void removeServer(String domainName, String serverName) {
        if (domainName.equals(name)) {
            // Server thet belongs to the current management domain
            managedServersToConnections.remove(serverName);
            JMXConnector connector = (JMXConnector) managedServersToConnectors.remove(serverName);
            if (connector != null) {
            try {
                connector.close();
            } catch (IOException e1) {
            }
            }
            managedServersToUrls.remove(serverName);
            removeServer(J2eeObjectName.J2EEServer(domainName, serverName).toString());
        } else {
            if (logger.isLoggable(BasicLevel.WARN)) {
                logger.log(BasicLevel.WARN, "The server named " + serverName + " was not started in the management domain "
                        + name + ", but in management domain " + domainName);
            }
        }
    }
    private boolean createConnection(String serverName, String connectorServerURL) {
        boolean created = false;
        MBeanServerConnection connection;
        // create a connector client for the connector server at the given url
        JMXConnector connector = null;
        try {
            JMXServiceURL url = new JMXServiceURL(connectorServerURL);
            connector = JMXConnectorFactory.newJMXConnector(url, null);
            connector.connect(null);
            connection = connector.getMBeanServerConnection();
        } catch (MalformedURLException e) {
            // there is no provider for the protocol in url
            connection = null;
        } catch (IOException e) {
            // connector client or connection cannot be made because of a communication problem.
            connection = null;
        } catch (java.lang.SecurityException e) {
            // connection cannot be made for security reasons
            connection = null;
        }
        if (connection != null) {
            // OK, connection was established to the connector server.
            testConnection(connection, serverName);
            if (!managedServersToConnections.containsKey(serverName)) {
                // add new connection and connector to managed data structure
                managedServersToConnections.put(serverName, connection);
                managedServersToConnectors.put(serverName, connector);
                created = true;
                logger.log(BasicLevel.INFO, "First MBeanServerConnection created for connecting to server " + serverName + " using URL: " + connectorServerURL);
            } else {
                // A connection already exists.
                // We have the following possibilities:
                // - ignore this connection (close it), so continue to use the old one
                // - replace the old one by the new one (close the old)
                // - keep several connections
                //
                // Currently we keep only one connection, the new one (second approach)
                JMXConnector oldConnector = (JMXConnector) managedServersToConnectors.get(serverName);
                try {
                    oldConnector.close();
                } catch (IOException e1) {
                }
                managedServersToConnectors.put(serverName, connector);
                managedServersToConnections.put(serverName, connection);
                created = true;
                logger.log(BasicLevel.INFO, "New MBeanServerConnection created for connecting to server " + serverName + " using URL: " + connectorServerURL + "(replaces the old connection)");
            }
        } else {
            if (connector != null) {
                try {
                    connector.close();
                } catch (IOException e1) {
                }
            }
        }
        return created;
    }

    private boolean testConnection(MBeanServerConnection connection, String serverName) {
        boolean ok = false;
        try {
            Integer nb = connection.getMBeanCount();
            ok = true;
        } catch(IOException ioe) {
            ioe.printStackTrace();
        }
        return ok;
    }

    public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {
        if (name == null) {
            return J2eeObjectName.J2EEDomain(this.name);
        }
        String myName = getObjectName().toString();
        String argName = name.toString();
        if (myName.equals(argName)) {
            // OK
            mbeanServer = server;
            return name;
        } else {
            if (logger.isLoggable(BasicLevel.WARN)) {
                logger.log(BasicLevel.WARN, "Trying to register J2EEDomain MBean with the following name: "
                        + argName + " when the expected name is: " + myName);
            }
            return ObjectName.getInstance(this.name);
        }
    }

    public void postRegister(Boolean registrationDone) {
        if (registrationDone.booleanValue()) {
            try {
                // MBeanServerDelegate is the MBean which sends registration/unregistration notifications
                ObjectName delegate = ObjectName.getInstance("JMImplementation:type=MBeanServerDelegate");
                mbeanServer.addNotificationListener(delegate, this, null, null);
            } catch (JMException me) {
                if (logger.isLoggable(BasicLevel.DEBUG)) {
                    logger.log(BasicLevel.DEBUG, "J2EEDomain MBean could not be added as notification listener for MBeanServerNotifications " +
                            "related to the REGISTRATION or UNREGISTRETION of JOnAS management MBeans");
                }
            }
        }
    }

    public void preDeregister() throws Exception {
        // TODO Auto-generated method stub

    }

    public void postDeregister() {
        // TODO Auto-generated method stub

    }

    public void handleNotification(Notification notification, Object handback) {
        if (notification instanceof MBeanServerNotification) {
            String type = notification.getType();
            // ObjectName of the MBean that caused the notification
            ObjectName registeredOn = ((MBeanServerNotification) notification).getMBeanName();
            String name = registeredOn.getKeyProperty("name");
            // The names below are defined in JonasObjectName class
            if ((name != null) && (name.equals("discoveryEnroller") || name.equals("discoveryClient"))) {
                if (type.equals(MBeanServerNotification.REGISTRATION_NOTIFICATION)) {
                    try {
                        // register myself as listener of notifications emitted by the Enroller or DiscoveryClient MBean
                        mbeanServer.addNotificationListener(registeredOn, this, null, null);
                        if (logger.isLoggable(BasicLevel.DEBUG)) {
                            logger.log(BasicLevel.DEBUG, "J2EEDomain (this) registered as listener to notifs emitted by " + registeredOn);
                        }
                    } catch (InstanceNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if (type.equals(MBeanServerNotification.UNREGISTRATION_NOTIFICATION)) {
                    try {
                        // unregister myself as listener of notifications emitted by the Enroller or DiscoveryClient MBean
                        mbeanServer.removeNotificationListener(registeredOn, this);
                        if (logger.isLoggable(BasicLevel.DEBUG)) {
                            logger.log(BasicLevel.DEBUG, "J2EEDomain (this) removed listener for notifs emitted by " + registeredOn);
                        }
                    } catch (InstanceNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (ListenerNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        } else {
            // Tread discovery notification
            String type = notification.getType();
            String message = notification.getMessage();
            DiscEvent userData = (DiscEvent) notification.getUserData();
            String source = ((ObjectName) notification.getSource()).toString();
            String state = userData.getState();
            if (logger.isLoggable(BasicLevel.DEBUG)) {
                logger.log(BasicLevel.DEBUG, "Treat notification:");
                logger.log(BasicLevel.DEBUG, "- source: " + source);
                logger.log(BasicLevel.DEBUG, "- type: " + type);
                logger.log(BasicLevel.DEBUG, "- data: ");
                logger.log(BasicLevel.DEBUG, "--- state: " + state);
                logger.log(BasicLevel.DEBUG, "--- serverName : " + userData.getServerName());
                logger.log(BasicLevel.DEBUG, "--- domainName : " + userData.getDomainName());
                if (userData.getConnectorURL() != null) {
                    String[] urls = userData.getConnectorURL();
                    for (int i = 0; i < urls.length; i++) {
                        logger.log(BasicLevel.DEBUG, "--- urls : " + urls[i]);
                    }
                }
                logger.log(BasicLevel.DEBUG, "");
            }
            if (state.equals(DiscEvent.RUNNING)) {
                String[] urls = userData.getConnectorURL();
                for (int i = 0; i < urls.length; i++) {
                    addServer(userData.getDomainName(), userData.getServerName(), urls[i]);
                }
            } else if (state.equals(DiscEvent.STOPPING)) {
                removeServer(userData.getDomainName(), userData.getServerName());
            }
        }
    }
}

---