Server.java

package org.objectweb.jonas.server;

import java.rmi.RMISecurityManager;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;
import java.util.StringTokenizer;

import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.modelmbean.ModelMBean;
import javax.naming.InitialContext;
import javax.security.jacc.PolicyContext;
import javax.security.jacc.PolicyContextException;
import javax.security.jacc.PolicyContextHandler;

import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;
import org.objectweb.carol.util.configuration.CarolConfiguration;
import org.objectweb.carol.util.configuration.CarolCurrentConfiguration;
import org.objectweb.jonas.adm.Adm;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.common.LogManagement;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.jtm.TransactionService;
import org.objectweb.jonas.management.JonasMBeanTools;
import org.objectweb.jonas.management.ReconfigManager;
import org.objectweb.jonas.management.j2eemanagement.J2EEDomain;
import org.objectweb.jonas.naming.JNDIResource;
import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.jonas.security.PolicyProvider;
import org.objectweb.jonas.security.jacc.JPolicyContextHandler;
import org.objectweb.jonas.service.JonasAlreadyStartedException;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.jonas_lib.I18n;
import org.objectweb.jonas_lib.deployment.work.WorkCleaner;
import org.objectweb.jonas_lib.version.Version;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;
import org.objectweb.util.monolog.wrapper.javaLog.MonologFormatter;

public class Server {


    private static final String DEF_LOG_CONFIGFILE = "trace";

    private static final String DEF_ORB_PORT = "0";

    private static I18n i18n = I18n.getInstance(Server.class);

    private static final String LOG_CONFIGFILE = "jonas.log.configfile";

    private static Logger logger = null;

    private static final String ORB_PORT = "jonas.orb.port";

    private static final String SECURITY_PROPAGATION = "jonas.security.propagation";

    private static final String CSIV2_PROPAGATION = "jonas.csiv2.propagation";

    private static final String SECURITY_MANAGER = "jonas.security.manager";

    private static final String SERVERNAME = "JOnAS";

    private static final int SLEEP_VALUE = 10000;

    private static final String TRANSACTION_PROPAGATION = "jonas.transaction.propagation";

    private static Server unique = null;

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

    public static void main(String[] args) throws Exception {
        Server server = null;

        // Add Mx4J logger as wrapper (allow to put the right class for debug in
        // the log)
        System.setProperty(MonologFormatter.WRAPPERS_PROPERTY, "mx4j.log.CommonsLogger,mx4j.log.Logger");

        try {
            server = Server.getInstance();
            server.start();
        } catch (JonasAlreadyStartedException e) {
            // if we get this exception this means that
            // we are trying to restart the same JOnAS
            System.err.println(i18n.getMessage("Server.main.alreadyStarted", SERVERNAME));
            // rethrow JonasAlreadyStartedException
            throw e;
        } catch (Exception e) {
            // We don't use here the trace system.
            System.err.println("JOnAS error: " + e);
            e.printStackTrace(System.err);
            System.err.println(SERVERNAME + " halting");
            try {
                if (server != null) {
                    server.stop();
                }
            } catch (Exception he) {
                System.err.println("Exception when halting" + he.getMessage());
                throw he;
            }
            throw e;
        }
    }

    private Adm adm = null;

    private String domainName = null;

    private J2EEServer j2EEServer = null;

    private String logConfigFile;

    private JProp props = null;

    private String serverName = null;

    private ServiceManager sm = null;

    private HashMap environments = new HashMap();

    private int nbCarolProtocols = 0;

    private String theProtocol = null;

    private Server() throws Exception {
        // read the JOnAS properties
        props = JProp.getInstance();

        // set configuration info into the Log System (monolog)
        logConfigFile = props.getValue(LOG_CONFIGFILE, DEF_LOG_CONFIGFILE);
        Log.configure(logConfigFile);

        // get a logger for server traces
        logger = Log.getLogger(Log.JONAS_SERVER_PREFIX);

        // create the service manager
        sm = ServiceManager.getInstance();

        // called only once for a JVM
        PolicyProvider.init();

    }



    public J2EEServer getJ2EEServer() {
        return j2EEServer;
    }

    public String initCarol(JProp props) throws Exception {

        // Intialize Carol
        CarolConfiguration.init(Log.getLoggerFactory());

        // Initialize Interceptors
        String sec = props.getValue(SECURITY_PROPAGATION, "false").trim();
        String trans = props.getValue(TRANSACTION_PROPAGATION, "false").trim();
        String csiv2 = props.getValue(CSIV2_PROPAGATION, "true").trim();

        if (sec.equals("true")) {
            // jrmp interceptors
            CarolConfiguration.addInterceptors("jrmp",
                    "org.objectweb.jonas.security.interceptors.jrmp.SecurityInitializer");
            // cmi interceptors
            CarolConfiguration.addInterceptors("cmi",
                    "org.objectweb.jonas.security.interceptors.jrmp.SecurityInitializer");
            // iiop interceptors flag
            CarolConfiguration.addInterceptors("iiop",
                    "org.objectweb.jonas.security.interceptors.iiop.SecurityInitializer");

        }

        if (csiv2.equals("true")) {
            CarolConfiguration.addInterceptors("iiop", "org.objectweb.jonas.security.iiop.Csiv2Initializer");
        }


        if (trans.equals("true")) {
            // jrmp interceptors flag
            CarolConfiguration.addInterceptors("jrmp", "org.objectweb.jotm.jta.rmi.JTAInterceptorInitializer");
            // jrmp interceptors flag
            CarolConfiguration.addInterceptors("cmi", "org.objectweb.jotm.jta.rmi.JTAInterceptorInitializer");
            // iiop interceptors flag
            CarolConfiguration.addInterceptors("iiop", "org.objectweb.jotm.ots.OTSORBInitializer");
        }

        // intialize port number
        System.setProperty("rmi.server.port", props.getValue(ORB_PORT, DEF_ORB_PORT));

        // get Carol configuration
        CarolCurrentConfiguration carolConfig = CarolCurrentConfiguration.getCurrent();
        String s = CarolConfiguration.getProtocols();
        StringTokenizer st = new StringTokenizer(s, ",", false);
        String pn = " ";

        int idx = 0;
        while (st.hasMoreElements()) {
            String token = st.nextToken().trim();
            if (idx != 0) {
                pn = pn + ", ";
            }
            pn = pn + "rmi/" + token;
            idx++;
            // initialize environments by creating one environment for each
            // protocol
            Properties protocolProps = carolConfig.getRMIProperties(token);
            if (protocolProps == null) {
                throw new Exception("no protocol properties for " + token);
            }
            Properties environment = new Properties();
            for (Enumeration pNames = protocolProps.propertyNames(); pNames.hasMoreElements();) {
                String pName = (String) pNames.nextElement();
                String pValue = protocolProps.getProperty(pName);
                if ((pName != null) && (pValue != null)) {
                    environment.setProperty(pName, pValue);
                }
            }
            environments.put(token, environment);
            theProtocol = token;
        }
        nbCarolProtocols = idx;
        return pn;
    }

    private void initJACCPolicyContextHandlers() throws PolicyContextException {
        PolicyContextHandler policyContextHandler = new JPolicyContextHandler();
        String[] keys = policyContextHandler.getKeys();
        for (int k = 0; k < keys.length; k++) {
            PolicyContext.registerHandler(keys[k], policyContextHandler, true);
        }
    }

    public void kill() throws Exception {
        if (adm != null) {
            adm.killServer();
        }
    }

    public void start() throws Exception {
        // Server name
        serverName = props.getValue(JProp.JONAS_NAME, JProp.JONAS_DEF_NAME);

        // Initialize Context Interceptors and Carol
        String protocols = initCarol(props);

        // RMI Security Manager
        boolean useSecurityManager = new Boolean(props.getValue(SECURITY_MANAGER, "true").trim()).booleanValue();

        if (useSecurityManager) {
            if (System.getSecurityManager() == null) {
                System.setSecurityManager(new RMISecurityManager());
            }
        } else {
            logger.log(BasicLevel.INFO, "Security manager is not set.");
        }

        // Initialize Policy Context handlers (JACC)
        try {
            initJACCPolicyContextHandlers();
        } catch (PolicyContextException pce) {
            logger.log(BasicLevel.ERROR, "Could not register JOnAS Policy Context Handlers");
            throw pce;
        }

        // First of all, start registry service
        sm.startRegistry();

        // then, start JMX service (start an MBean server and create RMI
        // connector for it registered in JNDI)

        sm.startJmx();

        // start the cleaner thread (deleting unused working files)
        //get the cleaner ref
        WorkCleaner.getInstance().start();

        // Get the MBean server reference
        JmxService jmxService = null;
        MBeanServer mbeanServer = null;
        try {
            jmxService = (JmxService) ServiceManager.getInstance().getJmxService();
            mbeanServer = jmxService.getJmxServer();
        } catch (Exception se) {
            // this could mean that jmx service not available
            // this is not possible, as we started it even if it does not appear
            // in the services list configuration parameter
            logger.log(BasicLevel.ERROR, "Could not access the jmx service");
            throw se;
        }

        // -----------------------------------------------------
        // J2EE Management
        // -----------------------------------------------------

        // Get the MBean register (and load mbeans-descriptors)
        Registry oRegistry = JonasMBeanTools.getRegistry();

        // Get domain name from environment
        domainName = props.getValue(JProp.DOMAIN_NAME);
        
        // Create and register a MBean for the Management Domain
        ObjectName domainOn = null;
        boolean domainOK = false;
        J2EEDomain j2eeDomain = null;
        try {
            // Create a JMX object name for the Domain MBean
            domainOn = J2eeObjectName.J2EEDomain(domainName);
            j2eeDomain = new J2EEDomain(domainOn.toString(), false, false, false);
            ManagedBean oManaged = oRegistry.findManagedBean("J2EEDomain");
            ModelMBean oMBean = oManaged.createMBean(j2eeDomain);
            mbeanServer.registerMBean(oMBean, domainOn);
            domainOK = true;
        } catch (javax.management.InstanceAlreadyExistsException ae) {
            // should never occur
            logger.log(BasicLevel.DEBUG, ae.getMessage());
        } catch (Exception e) {
            logger.log(BasicLevel.WARN, "Could not register J2EEDomain MBean");
            e.printStackTrace();
            domainOK = false;
        }

        // Create and register necessary MBeans for the server management
        ObjectName serverOn = null;
        try {
            // Create and register a MBean allowing server reconfiguration
            ReconfigManager reconfigManagerMBean = new ReconfigManager(props.getConfigFileEnv(), mbeanServer);
            mbeanServer.registerMBean(reconfigManagerMBean, JonasObjectName.serverConfig());

            // Create and register a MBean allowing the JOnAS server management
            serverOn = J2eeObjectName.J2EEServer(domainName, serverName);
            j2EEServer = new J2EEServer(serverOn.toString(), this, serverName, Version.NUMBER, Version.VENDOR,
                    protocols);
            ManagedBean oManaged = oRegistry.findManagedBean("J2EEServer");
            ModelMBean oMBean = oManaged.createMBean(j2EEServer);
            mbeanServer.registerMBean(oMBean, serverOn);
            // Update J2EEDomain MBean
            j2eeDomain.addServer(serverOn.toString());

            // Create and register a MBean for the logging service management
            LogManagement logMBean = LogManagement.getInstance();
            mbeanServer.registerMBean(logMBean, JonasObjectName.logService(logConfigFile));
        } catch (Exception e) {
            // Cannot administrate this server through JMX
            jmxService.stop();
        }

        // Create the MBean for the corresponding JVM
        ObjectName onJvm = null;
        try {
            onJvm = J2eeObjectName.JVM(domainName, serverName, serverName);
            ManagedBean oManaged = oRegistry.findManagedBean("JVM");
            JavaVm oJvm = new JavaVm(onJvm.toString(), props);
            ModelMBean oMBean = oManaged.createMBean(oJvm);
            mbeanServer.registerMBean(oMBean, onJvm);
            // Update J2EEServer MBean
            j2EEServer.addJavaVM(onJvm.toString());
        } catch (Exception e) {
            logger.log(BasicLevel.WARN, "Could not create JVM MBean : " + e.getMessage(), e);
        }

        ObjectName on = null;
        // create and register JNDI resource MBeans
        ManagedBean oManaged = oRegistry.findManagedBean("JNDIResource");
        if (nbCarolProtocols == 1) {
            // keep initial solution (use NamingManager)
            try {
                on = J2eeObjectName.JNDIResource(domainName, "jndi", serverName);
                // JNDI resource creation + registration
                NamingManager naming = NamingManager.getInstance();
                JNDIResource resMBean = new JNDIResource(on.toString(), naming.getInitialContext(), theProtocol);
                ModelMBean oMBean = oManaged.createMBean(resMBean);
                mbeanServer.registerMBean(oMBean, on);
            } catch (Exception e) {
                logger.log(BasicLevel.WARN, "Problem with J2EEResource MBean " + on.toString()
                        + " creation or registration: " + e.getMessage(), e);
            }
        } else {
            // Treat multi-protocol case
            InitialContext protocolContext = null;
            for (Iterator it = environments.keySet().iterator(); it.hasNext();) {
                String protocol = (String) it.next();
                on = J2eeObjectName.JNDIResource(domainName, "jndi_" + protocol, serverName);
                protocolContext = new InitialContext((Properties) environments.get(protocol));
                JNDIResource resMBean = new JNDIResource(on.toString(), protocolContext, protocol);
                ModelMBean oMBean = oManaged.createMBean(resMBean);
                mbeanServer.registerMBean(oMBean, on);
            }
        }

        // Creates the Adm instance for remote administration
        try {
            adm = new Adm(props);
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("Cannot create Adm : " + e);
        }

        // start all other services
        sm.startServices();

        // TM Server or EJB Server ?
        boolean isEJB = true;
        try {
            sm.getEjbService();
        } catch (ServiceException se) {
            isEJB = false;
        }
        adm.serverReady(isEJB);

        // Get the transaction service to allow recovery to start if necessary
        try {
            TransactionService ts = (TransactionService) sm.getTransactionService();
            ts.getCurrent().getTransactionRecovery().startResourceManagerRecovery();
        } catch (Exception ex) {
            logger.log(BasicLevel.DEBUG, "JOTM startResourceManagerRecovery failed: " + ex.getMessage());
            ex.printStackTrace();
            throw ex;
        }

        System.out.println(i18n.getMessage("Server.start.serverIsReady", serverName, Version.NUMBER));
        logger.log(BasicLevel.INFO, i18n.getMessage("Server.start.serverStarted", serverName, protocols));

        // Don't stop this thread to keep the server alive.

        while (true) {
            Thread.sleep(SLEEP_VALUE);
        }
    }

    public void stop() throws Exception {
        if (adm != null) {
            System.out.println(i18n.getMessage("Server.stop.serverIsStopped", serverName));
            logger.log(BasicLevel.INFO, i18n.getMessage("Server.stop.serverStopped", serverName));
            adm.stopServer();
        }
    }

}

---