DiscoveryServiceImpl.java

package org.objectweb.jonas.discovery;

import javax.management.JMException;
import javax.management.MBeanServer;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;
import javax.naming.NamingException;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class DiscoveryServiceImpl extends AbsServiceImpl implements DiscoveryService , DiscoveryServiceImplMBean {

    private final String DISCOVERY_SOURCE_PORT_DEFAULT = "9888";
    private String listeningIp = null;
    private int listeningPort;
    private int sourcePort;
    private boolean isDiscoveryMaster = false;
    private MBeanServer mbeanServer = null;

    private JmxService jmxService = null;
    private static Logger logger = null;

    public String getMulticastAddress() {
        return listeningIp;
    }

    public String getMulticastPort() {
        return String.valueOf(listeningPort);
    }

    public Boolean getIsDiscoveryMaster() {
        return new Boolean(isDiscoveryMaster);
    }
    public void startDiscoveryMaster() throws JMException {
        if (!isDiscoveryMaster) {
            createEnroller();
            createDiscClient();
            isDiscoveryMaster = true;
        }
    }

    /* (non-Javadoc)
     * @see org.objectweb.jonas.service.AbsServiceImpl#doInit(javax.naming.Context)
     */
    protected void doInit(Context ctx) throws ServiceException {
        //Init the logger
        logger = Log.getLogger(Log.JONAS_DISCOVERY_PREFIX);

        // Get service configuration
        try {
            listeningIp = (String) ctx.lookup("jonas.service.discovery.multicast.address");
            String sListeningPort = (String) ctx.lookup("jonas.service.discovery.multicast.port");
            listeningPort = (Integer.valueOf(sListeningPort)).intValue();
        } catch (NamingException ne) {
            String err = "Cannot read initializations arguments in service context";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, ne);
        }
        // Get info allowing to see if this is a discovery master
        try {
            String sMaster = (String) ctx.lookup("jonas.service.discovery.master");
            if (sMaster != null && sMaster.equals("true")) {
                isDiscoveryMaster = true;
            }
        } catch (NamingException ne) {
            // isDiscoveryMaster rests false
        }
        // If configuration does not says this ia a master, allow
        // however to start it as a master if the server name is
        // identical to the domain name (in the default case this
        // is "jonas", "jonas")
        if (!isDiscoveryMaster) {
            if (getDomainName().equals(getJonasServerName())) {
                isDiscoveryMaster = true;
            }
        }

        String sSourcePort = null;
        try {
            sSourcePort = (String) ctx.lookup("jonas.service.discovery.source.port");
        } catch (NamingException ne) {
            sSourcePort = DISCOVERY_SOURCE_PORT_DEFAULT;
        }
        sourcePort = (Integer.valueOf(sSourcePort)).intValue();

        // Get JOnAS references allowing to start execution
        ServiceManager sm  = null;
        try {
            sm = ServiceManager.getInstance();
        } catch (Exception e) {
            String err = "Cannot get ServiceManager instance";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }
        jmxService = ((JmxService) sm.getJmxService());
        try {
            mbeanServer = jmxService.getJmxServer();
        } catch (ServiceException e) {
            // the JMX service may not be started
            mbeanServer = null;
            String err = "Cannot get MBeanServer reference";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }
    }

    protected void doStart() throws ServiceException {
        // Create discovery manager
        DiscoveryManager dm = new DiscoveryManager(listeningPort, listeningIp);
        dm.setDomainName(jmxService.getDomainName());
        dm.setJonasName(jmxService.getJonasServerName());
        JMXServiceURL[] connectorServerURLs = jmxService.getConnectorServerURLs();
        String[] urls = new String[connectorServerURLs.length];
        for (int i = 0; i < urls.length; i++) {
            urls[i] = connectorServerURLs[i].toString();
        }
        dm.setUrls(urls);
        try {
            // Register  DiscoveryManager MBean
            if (mbeanServer != null) {
                mbeanServer.registerMBean(dm, JonasObjectName.discoveryManager());
            }
        } catch (JMException e) {
            throw new ServiceException("Problem when starting the Discovery Service: ", e);
        }
        // Start discovery manager
        dm.start();

        if (isDiscoveryMaster) {
            // Create enroller
            try {
                createEnroller();
            } catch (JMException e) {
                throw new ServiceException("Problem when starting the Discovery Service: ", e);
            }

            // Create discovery client
            try {
                createDiscClient();
            } catch (JMException e) {
                throw new ServiceException("Problem when starting the Discovery Service: ", e);
            }
        }
        
        // Create and register the service MBean
        try {
                if (mbeanServer != null) {
                        mbeanServer.registerMBean(this, JonasObjectName.discoveryService());
                }
        } catch (JMException e) {
            throw new ServiceException("Problem when starting the Discovery Service: ", e);
        }
    }

    private void createEnroller() throws JMException {
        Enroller enroller = new Enroller(listeningPort, listeningIp);
        if (mbeanServer != null) {
            mbeanServer.registerMBean(enroller, JonasObjectName.discoveryEnroller());
        }
    }

    private void createDiscClient() throws JMException {
        DiscoveryClient dc = new DiscoveryClient(listeningPort, listeningIp, sourcePort);
        // Register MBean
        if (mbeanServer != null) {
            mbeanServer.registerMBean(dc, JonasObjectName.discoveryClient());
        }
    }

    /* (non-Javadoc)
     * @see org.objectweb.jonas.service.AbsServiceImpl#doStop()
     */
    protected void doStop() throws ServiceException {
        // TO DO
        // ....

        // Unegister the service MBean
        try {
                if (mbeanServer != null) {
                        mbeanServer.unregisterMBean(JonasObjectName.discoveryService());
                }
        } catch (JMException e) {
            throw new ServiceException("Problem when stoping the Discovery Service: ", e);
        }
    }
}

---