ServiceManager.java

package org.objectweb.jonas.service;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import javax.naming.Context;
import javax.naming.NamingException;

import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.naming.CompNamingContext;

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

public class ServiceManager {

    static final String SERVICES_PROP_NAME = JProp.JONASPREFIX + ".services";

    static final String PREFIX_SERVICE_PROP_NAME = JProp.JONASPREFIX + ".service";

    private static Logger logger = null;

    private static ServiceManager unique = null;

    private JProp props = null;

    private static List services = null;

    private Map servicesByName = null;

    private Map contextsByService = null;

    private ServiceManager() throws Exception {
        logger = Log.getLogger(Log.JONAS_SERVER_PREFIX);
        // read properties from the different jonas.properties files
        props = JProp.getInstance();
        // read all services from properties
        readServices();
    }

    public static ServiceManager getInstance() throws Exception {
        if (unique == null) {
            unique = new ServiceManager();
        }
        return unique;
    }

    public Service getService(String name) throws ServiceException {
        if (servicesByName == null) {
            throw new ServiceException("No service has been initialized yet");
        }
        Service s = (Service) servicesByName.get(name);
        if (s == null) {
            throw new ServiceException("Unknown service '" + name + "'");
        }
        return s;
    }

    public Service getEjbService() throws ServiceException {
        return getService("ejb");
    }

    public Service getEarService() throws ServiceException {
        return getService("ear");
    }

    public Service getRarService() throws ServiceException {
        return getService("resource");
    }

    public Service getWebContainerService() throws ServiceException {
        return getService("web");
    }

    public Service getWebServicesService() throws ServiceException {
        return getService("ws");
    }

    public Service getMailService() throws ServiceException {
        return getService("mail");
    }

    public Service getDataBaseService() throws ServiceException {
        return getService("dbm");
    }

    public Service getTransactionService() throws ServiceException {
        return getService("jtm");
    }

    public Service getJmsService() throws ServiceException {
        return getService("jms");
    }

    public Service getSecurityService() throws ServiceException {
        return getService("security");
    }

    public Service getJmxService() throws ServiceException {
        return getService("jmx");
    }

    public Service getRegistryService() throws ServiceException {
        return getService("registry");
    }

    public Service getResourceService() throws ServiceException {
        return getService("resource");
    }

    public void startRegistry() throws ServiceException {
        logger.log(BasicLevel.DEBUG, "");
        Service reg = getRegistryService();
        try {
            reg.init((Context) contextsByService.get(reg));
            reg.start();
            logger.log(BasicLevel.INFO, "registry service started");
        } catch (ServiceException e) {
            throw new ServiceException("Cannot init/start registry" + e);
        }
    }

    public void startJmx() throws ServiceException {
        logger.log(BasicLevel.DEBUG, "");
        Service jmxService = getJmxService();
        try {
            jmxService.init((Context) contextsByService.get(jmxService));
            jmxService.start();
            logger.log(BasicLevel.INFO, "jmx service started");
        } catch (ServiceException e) {
            throw e;
        }
    }

    public void startServices() throws ServiceException {
        logger.log(BasicLevel.DEBUG, "");
        Service[] services = getServices();
        Context serviceContext = null;
        // registry = service 0, already started.
        // jmx = service 1, already started
        for (int i = 2; i < services.length; i++) {
            Service service = services[i];
            try {
                serviceContext = (Context) contextsByService.get(service);
                service.init(serviceContext);
                service.start();
                logger.log(BasicLevel.INFO, service.getName() + " service started");
            } catch (ServiceException e) {
                throw new ServiceException("Cannot init/start service '" + service.getName() + "': " + e.getMessage(), e);
            }
        }
    }

    public Service[] getServices() throws ServiceException {
        Service[] ss = new Service[services.size()];
        for (int i = 0; i < services.size(); i++) {
            ss[i] = (Service) services.get(i);
        }
        return ss;
    }

    public String[] getServiceNames() {
        logger.log(BasicLevel.DEBUG, "");
        String [] serviceNames;
        serviceNames = props.getValueAsArray(SERVICES_PROP_NAME);
        if (serviceNames == null) {
            return null;
        }
        if (serviceNames[0].equals("registry") && serviceNames[1].equals("jmx")) {
            return serviceNames;
        }
        ArrayList services = new ArrayList();
        services.add(0, "registry");
        services.add(1, "jmx");
        int nbServices = 2;
        for (int i = 0; i < serviceNames.length; i++) {
            if (!serviceNames[i].equals("registry") && !serviceNames[i].equals("jmx")) {
                services.add(serviceNames[i]);
                nbServices++;
            }
        }
        serviceNames = new String[nbServices];
        logger.log(BasicLevel.DEBUG, "Created new array of String of size " + services.size());
        for (int i = 0; i < nbServices; i++) {
            serviceNames[i] = (String) services.get(i);
        }
        return serviceNames;
    }

    protected void readServices() throws ServiceException {
        logger.log(BasicLevel.DEBUG, "");
        services = new ArrayList();
        contextsByService = new Hashtable();
        servicesByName = new Hashtable();
        String [] serviceNames;
        serviceNames = getServiceNames();
        if (serviceNames == null) {
            throw new ServiceException("Property '" + SERVICES_PROP_NAME + "' is missing in '"
                                       + JProp.JONASPREFIX + "' properties file");
        }
        for (int i = 0; i < serviceNames.length; i++) {
            String serviceName = serviceNames[i];
            Service serviceObj = createServiceFrom(serviceName);
            if (serviceObj != null) {
                try {
                    Context ctx = createServiceContextFor(serviceName);
                    services.add(serviceObj);
                    contextsByService.put(serviceObj, ctx);
                    servicesByName.put(serviceName, serviceObj);
                } catch (NamingException e) {
                    throw new ServiceException("cannot create the context name of the service '"
                                               + serviceName + "'",
                                               e);
                }
            }
        }
    }

    protected Service createServiceFrom(String serviceName) throws ServiceException {
        logger.log(BasicLevel.DEBUG, serviceName);
        String prefixPropName = PREFIX_SERVICE_PROP_NAME + "." + serviceName;
        String serviceClassName = props.getValue(prefixPropName + ".class");
        if (serviceClassName == null) {
            throw new ServiceException("Property '" + prefixPropName + ".class' missing in '"
                                       + JProp.JONASPREFIX + "' properties file");
        }
        try {
            ClassLoader classLoader = this.getClass().getClassLoader();
            if (classLoader == null) {
                classLoader = Thread.currentThread().getContextClassLoader();
            }
            Class serviceClass = classLoader.loadClass(serviceClassName);
            Service service = (Service) serviceClass.newInstance();
            service.setName(serviceName);
            logger.log(BasicLevel.DEBUG, "class used: " + serviceClassName);
            return (service);
        } catch (NoClassDefFoundError ncdfe) {
            logger.log(BasicLevel.WARN, "WARNING : The service '" + serviceName
                       + "' is disabled because a class for this service is missing."
                       + " Check your services in jonas.properties file and your environment variables. Missing class : '"
                       + ncdfe.getMessage() + "'", ncdfe);
            // Return null so the service won't be added.
            return null;
        } catch (ClassNotFoundException cnfe) {
            logger.log(BasicLevel.WARN, "WARNING : The service '" + serviceName
                       + "' is disabled because a class for this service is missing."
                       + " Check your services in jonas.properties file and your environment variables. Missing class : '"
                       + cnfe.getMessage() + "'", cnfe);
            // Return null so the service won't be added.
            return null;
        } catch (Exception e) {
            throw new ServiceException("Error when creating the service '" + serviceName + "'", e);
        }
    }

    protected Context createServiceContextFor(String serviceName) throws NamingException {
        logger.log(BasicLevel.DEBUG, serviceName);
        String prefixPropName = PREFIX_SERVICE_PROP_NAME + "." + serviceName;
        CompNamingContext ctx = new CompNamingContext(serviceName);
        for (Enumeration e = props.getEnv().propertyNames(); e.hasMoreElements();) {
            String propName = (String) e.nextElement();
            if (propName.startsWith(prefixPropName + ".")) {
                ctx.rebind(propName, props.getValue(propName));
            }
        }
        // set Jonas name properties to all ctx
        ctx.rebind(JProp.JONAS_NAME, props.getValue(JProp.JONAS_NAME));
        ctx.rebind(JProp.DOMAIN_NAME, props.getValue(JProp.DOMAIN_NAME));
        // Test JMX Remote
        // Get specific JMX props
        if (serviceName.equals("jmx")) {
            String prop = props.getValue("host.name");
            if (prop != null) {
                ctx.rebind("host.name", prop);
            }
            prop = props.getValue("jmxconnector.port");
            if (prop != null) {
                ctx.rebind("jmxconnector.port", prop);
            }
        }
        return ctx;
    }

    public void stopServices() throws ServiceException  {
        String msgError = new String();
        String sepError = "";
        Service[] services = getServices();
        for (int i = services.length - 1; i >= 0; i--) {
            Service service = services[i];
            if (service.isStarted()) {
                try {
                    service.stop();
                    logger.log(BasicLevel.DEBUG, service.getName() + " service stopped");
                } catch (ServiceException e) {
                    msgError = msgError.concat(sepError + "Cannot stop the service '"
                                               + service.getName() + "': " + e);
                    sepError = "\n";
                }
            }
        }
        if (msgError.length() != 0) {
            throw new ServiceException(msgError);
        }
    }
}

---