org/objectweb/proactive/core/runtime/RuntimeFactory.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.runtime;

import org.apache.log4j.Logger;
import org.objectweb.proactive.core.Constants;
import org.objectweb.proactive.core.ProActiveException;
import org.objectweb.proactive.core.UniqueID;
import org.objectweb.proactive.core.config.ProActiveConfiguration;
import org.objectweb.proactive.core.rmi.ClassServerHelper;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;


public abstract class RuntimeFactory {
    public static Logger runtimeLogger = ProActiveLogger.getLogger(Loggers.RUNTIME);

    // test with class loader
    //private static final ClassLoader myClassLoader = new NodeClassLoader();

    private static java.util.HashMap<String, String> protocolFactoryMapping = new java.util.HashMap<String, String>();
    private static java.util.HashMap<String, RuntimeFactory> instanceFactoryMapping = new java.util.HashMap<String, RuntimeFactory>();

    //private static ProActiveRuntime defaultRuntime = null;
    //private static RuntimeFactory defaultRuntimeFactory;
 

    static {
        ProActiveConfiguration.load();
        createClassServer();
        registerProtocolFactories();
        //getLocalRuntime();
    }

    //
    // -- PUBLIC METHODS - STATIC -----------------------------------------------
    //

    public static synchronized void setFactory(String protocol,
        String factoryClassName) {
        if (runtimeLogger.isDebugEnabled()) {
            runtimeLogger.debug("protocol =  " + protocol + " " +
                factoryClassName);
        }
        protocolFactoryMapping.put(protocol, factoryClassName);
    }

    public static synchronized void setFactory(String protocol,
        RuntimeFactory factoryObject) {
        protocolFactoryMapping.put(protocol, factoryObject.getClass().getName());
        instanceFactoryMapping.put(protocol, factoryObject);
    }

    public static boolean isRuntimeLocal(ProActiveRuntime proActiveRuntime) {
        return proActiveRuntime.getVMInformation().getVMID().equals(UniqueID.getCurrentVMID());
    }

    public static synchronized ProActiveRuntime getDefaultRuntime()
        throws ProActiveException {
        ProActiveRuntime defaultRuntime = null;
        try {
            //defaultRuntime = getProtocolSpecificRuntime(Constants.DEFAULT_PROTOCOL_IDENTIFIER);
            defaultRuntime = getProtocolSpecificRuntime(System.getProperty(
                        "proactive.communication.protocol") + ":");
            if (runtimeLogger.isDebugEnabled()) {
                runtimeLogger.debug("default runtime = " +
                    defaultRuntime.getURL());
            }
        } catch (ProActiveException e) {
            //e.printStackTrace();
            if (runtimeLogger.isDebugEnabled()) {
                runtimeLogger.debug("Error with the default ProActiveRuntime");
            }
            throw new ProActiveException("Error when getting the default ProActiveRuntime",
                e);
        }
        return defaultRuntime;
    }

    public static ProActiveRuntime getProtocolSpecificRuntime(String protocol)
        throws ProActiveException {
        RuntimeFactory factory = getFactory(protocol);
        ProActiveRuntime proActiveRuntime = factory.getProtocolSpecificRuntimeImpl();
        if (proActiveRuntime == null) {
            throw new ProActiveException(
                "Cannot create a ProActiveRuntime based on " + protocol);
        }
        return proActiveRuntime;
    }

    public static ProActiveRuntime getRuntime(String proActiveRuntimeURL,
        String protocol) throws ProActiveException {
        runtimeLogger.debug("proActiveRunTimeURL " + proActiveRuntimeURL + " " +
            protocol);

        //do we have any association for this node?
        //String protocol = getProtocol(proActiveRuntimeURL);
        RuntimeFactory factory = getFactory(protocol);

        //proActiveRuntimeURL = removeProtocol(proActiveRuntimeURL, protocol);
        if (runtimeLogger.isDebugEnabled()) {
            runtimeLogger.debug("factory = " + factory);
        }
        return factory.getRemoteRuntimeImpl(proActiveRuntimeURL);
    }

    //
    // -- PROTECTED METHODS -----------------------------------------------
    //

    protected ProActiveRuntimeAdapterImpl createRuntimeAdapter(
        RemoteProActiveRuntime remoteProActiveRuntime)
        throws ProActiveException {
        return new ProActiveRuntimeAdapterImpl(remoteProActiveRuntime);
    }

    protected abstract ProActiveRuntime getProtocolSpecificRuntimeImpl()
        throws ProActiveException;

    protected abstract ProActiveRuntime getRemoteRuntimeImpl(String s)
        throws ProActiveException;

    protected abstract ProActiveRuntimeAdapterImpl createRuntimeAdapter()
        throws ProActiveException;

    //
    // -- PRIVATE METHODS - STATIC -----------------------------------------------
    //
    private static void createClassServer() {
        try {
            new ClassServerHelper().initializeClassServer();
        } catch (Exception e) {
            if (runtimeLogger.isInfoEnabled()) {
                runtimeLogger.info("Error with the ClassServer : " +
                    e.getMessage());
            }
        }
    }

    private static void registerProtocolFactories() {
        setFactory(Constants.JINI_PROTOCOL_IDENTIFIER,
            "org.objectweb.proactive.core.runtime.jini.JiniRuntimeFactory");

        setFactory(Constants.IBIS_PROTOCOL_IDENTIFIER,
            "org.objectweb.proactive.core.runtime.ibis.IbisRuntimeFactory");

        setFactory(Constants.XMLHTTP_PROTOCOL_IDENTIFIER,
            "org.objectweb.proactive.core.runtime.http.HttpRuntimeFactory");

        setFactory(Constants.RMISSH_PROTOCOL_IDENTIFIER,
            "org.objectweb.proactive.core.runtime.rmi.SshRmiRuntimeFactory");

        setFactory(Constants.RMI_PROTOCOL_IDENTIFIER,
            "org.objectweb.proactive.core.runtime.rmi.RmiRuntimeFactory");
    }

    private static RuntimeFactory createRuntimeFactory(Class factoryClass,
        String protocol) throws ProActiveException {
        try {
            RuntimeFactory nf = (RuntimeFactory) factoryClass.newInstance();
            instanceFactoryMapping.put(protocol, nf);
            return nf;
        } catch (Exception e) {
            e.printStackTrace();
            throw new ProActiveException("Error while creating the factory " +
                factoryClass.getName() + " for the protocol " + protocol);
        }
    }

    private static RuntimeFactory createRuntimeFactory(
        String factoryClassName, String protocol) throws ProActiveException {
        Class factoryClass = null;
        if (runtimeLogger.isDebugEnabled()) {
            runtimeLogger.debug("factoryClassName " + factoryClassName);
        }
        try {
            factoryClass = Class.forName(factoryClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new ProActiveException(
                "Error while getting the class of the factory " +
                factoryClassName + " for the protocol " + protocol);
        }
        return createRuntimeFactory(factoryClass, protocol);
    }

    private static synchronized RuntimeFactory getFactory(String protocol)
        throws ProActiveException {
        if (runtimeLogger.isDebugEnabled()) {
            runtimeLogger.debug("protocol = " + protocol);
        }

        RuntimeFactory factory = instanceFactoryMapping.get(protocol);
        if (factory != null) {
            return factory;
        }

        String factoryClassName = protocolFactoryMapping.get(protocol);
        if (runtimeLogger.isDebugEnabled()) {
            runtimeLogger.debug("factoryClassName  = " + factoryClassName);
        }
        if (factoryClassName != null) {
            return createRuntimeFactory(factoryClassName, protocol);
        }
        throw new ProActiveException(
            "No RuntimeFactory is registered for the protocol " + protocol);
    }
}

---