org/objectweb/proactive/ProActive.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;

import java.io.IOException;
import java.lang.reflect.Array;
import java.net.UnknownHostException;
import java.rmi.AlreadyBoundException;
import java.util.Collection;
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;
import org.objectweb.fractal.api.Component;
import org.objectweb.fractal.api.NoSuchInterfaceException;
import org.objectweb.fractal.api.factory.GenericFactory;
import org.objectweb.fractal.api.factory.InstantiationException;
import org.objectweb.fractal.util.Fractal;
import org.objectweb.proactive.core.Constants;
import org.objectweb.proactive.core.ProActiveException;
import org.objectweb.proactive.core.ProActiveRuntimeException;
import org.objectweb.proactive.core.body.BodyAdapter;
import org.objectweb.proactive.core.body.LocalBodyStore;
import org.objectweb.proactive.core.body.MetaObjectFactory;
import org.objectweb.proactive.core.body.ProActiveMetaObjectFactory;
import org.objectweb.proactive.core.body.UniversalBody;
import org.objectweb.proactive.core.body.future.Future;
import org.objectweb.proactive.core.body.future.FuturePool;
import org.objectweb.proactive.core.body.http.HttpBodyAdapter;
import org.objectweb.proactive.core.body.ibis.IbisBodyAdapter;
import org.objectweb.proactive.core.body.migration.Migratable;
import org.objectweb.proactive.core.body.migration.MigrationException;
import org.objectweb.proactive.core.body.proxy.AbstractProxy;
import org.objectweb.proactive.core.body.proxy.BodyProxy;
import org.objectweb.proactive.core.body.request.BodyRequest;
import org.objectweb.proactive.core.body.rmi.RmiBodyAdapter;
import org.objectweb.proactive.core.body.rmi.SshRmiBodyAdapter;
import org.objectweb.proactive.core.component.ComponentParameters;
import org.objectweb.proactive.core.component.ContentDescription;
import org.objectweb.proactive.core.component.ControllerDescription;
import org.objectweb.proactive.core.component.factory.ProActiveGenericFactory;
import org.objectweb.proactive.core.config.ProActiveConfiguration;
import org.objectweb.proactive.core.descriptor.data.ProActiveDescriptor;
import org.objectweb.proactive.core.descriptor.data.VirtualNode;
import org.objectweb.proactive.core.descriptor.data.VirtualNodeImpl;
import org.objectweb.proactive.core.descriptor.xml.ProActiveDescriptorHandler;
import org.objectweb.proactive.core.event.NodeCreationEventProducerImpl;
import org.objectweb.proactive.core.exceptions.manager.ExceptionHandler;
import org.objectweb.proactive.core.exceptions.manager.NFEListener;
import org.objectweb.proactive.core.exceptions.manager.NFEManager;
import org.objectweb.proactive.core.group.Group;
import org.objectweb.proactive.core.group.ProActiveGroup;
import org.objectweb.proactive.core.group.ProxyForGroup;
import org.objectweb.proactive.core.mop.ClassNotReifiableException;
import org.objectweb.proactive.core.mop.ConstructionOfProxyObjectFailedException;
import org.objectweb.proactive.core.mop.MOP;
import org.objectweb.proactive.core.mop.MOPException;
import org.objectweb.proactive.core.mop.Proxy;
import org.objectweb.proactive.core.mop.StubObject;
import org.objectweb.proactive.core.node.Node;
import org.objectweb.proactive.core.node.NodeException;
import org.objectweb.proactive.core.node.NodeFactory;
import org.objectweb.proactive.core.runtime.ProActiveRuntime;
import org.objectweb.proactive.core.runtime.ProActiveRuntimeImpl;
import org.objectweb.proactive.core.runtime.RuntimeFactory;
import org.objectweb.proactive.core.util.NodeCreationListenerForAoCreation;
import org.objectweb.proactive.core.util.NonFunctionalServices;
import org.objectweb.proactive.core.util.ProcessForAoCreation;
import org.objectweb.proactive.core.util.UrlBuilder;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.objectweb.proactive.core.util.profiling.PAProfilerEngine;
import org.objectweb.proactive.core.util.profiling.Profiling;
import org.objectweb.proactive.core.util.timer.CompositeAverageMicroTimer;
import org.objectweb.proactive.core.xml.VariableContract;
import org.objectweb.proactive.ext.security.ProActiveSecurityManager;
import org.objectweb.proactive.ext.webservices.soap.ProActiveDeployer;

import ibis.rmi.RemoteException;


public class ProActive {
    protected final static Logger logger = ProActiveLogger.getLogger(Loggers.CORE);
    public final static Logger loggerGroup = ProActiveLogger.getLogger(Loggers.GROUPS);

    private static CompositeAverageMicroTimer timer;

    static {
        ProActiveConfiguration.load();
        
        @SuppressWarnings("unused") // Execute RuntimeFactory's static blocks  
        Class c = org.objectweb.proactive.core.runtime.RuntimeFactory.class;
    }

    //
    // -- CONSTRUCTORS -----------------------------------------------
    //
    private ProActive() {
    }

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

    public static void newMain(String classname, String[] mainParameters,
        Node node)
        throws ClassNotFoundException, NoSuchMethodException, ProActiveException {
        ProActiveRuntime part = node.getProActiveRuntime();
        part.launchMain(classname, mainParameters);
    }

    public static void newRemote(String classname, Node node)
        throws ClassNotFoundException, ProActiveException {
        ProActiveRuntime part = node.getProActiveRuntime();
        part.newRemote(classname);
    }

    public static Object newActive(String classname,
        Object[] constructorParameters)
        throws ActiveObjectCreationException, NodeException {
        return newActive(classname, null, constructorParameters, (Node) null,
            null, null);
    }

    public static Object newActive(String classname,
        Object[] constructorParameters, String nodeURL)
        throws ActiveObjectCreationException, NodeException {
        if (nodeURL == null) {
            return newActive(classname, null, constructorParameters,
                (Node) null, null, null);
        } else {
            return newActive(classname, null, constructorParameters,
                NodeFactory.getNode(nodeURL), null, null);
        }
    }

    public static Object newActive(String classname,
        Object[] constructorParameters, Node node)
        throws ActiveObjectCreationException, NodeException {
        return newActive(classname, null, constructorParameters, node, null,
            null);
    }

    public static Object[] newActiveInParallel(String className,
        Object[][] constructorParameters, Node[] nodes)
        throws ClassNotFoundException {
        return newActiveInParallel(className, null, constructorParameters, nodes);
    }

    public static Object[] newActiveInParallel(String className,
        Object[] constructorParameters, VirtualNode virtualNode)
        throws NodeException, ClassNotFoundException {
        return newActiveInParallel(className, null, constructorParameters,
            virtualNode);
    }

    public static Object newActiveAsGroup(String classname,
        Object[] constructorParameters, VirtualNode virtualnode)
        throws ActiveObjectCreationException, NodeException {
        return ProActive.newActiveAsGroup(classname, null,
            constructorParameters, virtualnode, null, null);
    }

    public static Object newActiveAsGroup(String className,
        Object[] constructorParameters, VirtualNode virtualNode,
        Active activity, MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        return newActiveAsGroup(className, null, constructorParameters,
            virtualNode, activity, factory);
    }

    public static Component newActiveComponent(String className,
        Object[] constructorParameters, Node node, Active activity,
        MetaObjectFactory factory, ComponentParameters componentParameters)
        throws ActiveObjectCreationException, NodeException {
        return newActiveComponent(className, null, constructorParameters, node,
            activity, factory, componentParameters);
    }

    public static Component newActiveComponent(String className,
        Object[] constructorParameters, VirtualNode vn,
        ComponentParameters componentParameters)
        throws ActiveObjectCreationException, NodeException {
        return newActiveComponent(className, null, constructorParameters, vn,
            componentParameters);
    }

    public static Object turnActive(Object target)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, (Class[]) null, (Node) null);
    }

    public static Object turnActive(Object target, String nodeURL)
        throws ActiveObjectCreationException, NodeException {
        if (nodeURL == null) {
            return turnActive(target, null, target.getClass().getName(), null,
                null, null);
        } else {
            return turnActive(target, null, target.getClass().getName(),
                NodeFactory.getNode(nodeURL), null, null);
        }
    }

    public static Object turnActive(Object target, Node node)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, null, target.getClass().getName(), node,
            null, null);
    }

    public static Object turnActive(Object target, Node node, Active activity,
        MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, null, target.getClass().getName(), node,
            activity, factory);
    }

    public static Object turnActive(Object target, String nameOfTargetType,
        Node node) throws ActiveObjectCreationException, NodeException {
        return turnActive(target, null, nameOfTargetType, node, null, null);
    }

    public static Object turnActive(Object target, String nameOfTargetType,
        Node node, Active activity, MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, null, nameOfTargetType, node, activity,
            factory);
    }

    public static Object turnActiveAsGroup(Object target,
        String nameOfTargetType, VirtualNode virtualnode)
        throws ActiveObjectCreationException, NodeException {
        return turnActiveAsGroup(target, null, nameOfTargetType, virtualnode);
    }


    public static Object newActive(String classname, Class[] genericParameters,
        Object[] constructorParameters)
        throws ActiveObjectCreationException, NodeException {
        // avoid ambiguity for method parameters types
        Node nullNode = null;
        return newActive(classname, genericParameters, constructorParameters,
            nullNode, null, null);
    }

    public static Object newActive(String classname, Class[] genericParameters,
        Object[] constructorParameters, String nodeURL)
        throws ActiveObjectCreationException, NodeException {
        if (nodeURL == null) {
            // avoid ambiguity for method parameters types
            Node nullNode = null;
            return newActive(classname, genericParameters,
                constructorParameters, nullNode, null, null);
        } else {
            return newActive(classname, genericParameters,
                constructorParameters, NodeFactory.getNode(nodeURL), null, null);
        }
    }

    public static Object newActive(String classname, Class[] genericParameters,
        Object[] constructorParameters, Node node)
        throws ActiveObjectCreationException, NodeException {
        return newActive(classname, genericParameters, constructorParameters,
            node, null, null);
    }

    public static Object newActive(String classname, Class[] genericParameters,
        Object[] constructorParameters, Node node, Active activity,
        MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        //using default proactive node
        if (node == null) {
            node = NodeFactory.getDefaultNode();
        }

        if (factory == null) {
            factory = ProActiveMetaObjectFactory.newInstance();
        }

        if (Profiling.SECURITY) {
            if (timer == null) {
                timer = new CompositeAverageMicroTimer("newActiveSecurityTimer");
                PAProfilerEngine.registerTimer(timer);
            }
            timer.setTimer("constructing certificate");
            timer.start();
        }

        MetaObjectFactory clonedFactory = factory;

        ProActiveSecurityManager factorySM = factory.getProActiveSecurityManager();
        if (factorySM != null) {
            try {
                clonedFactory = (MetaObjectFactory) factory.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }

            ProActiveSecurityManager psm = clonedFactory.getProActiveSecurityManager();
            psm = psm.generateSiblingCertificate(classname);
            clonedFactory.setProActiveSecurityManager(psm);
        }
        if (Profiling.SECURITY) {
            timer.stop();
        }

        try {
            //          create stub object
            Object stub = createStubObject(classname, genericParameters,
                    constructorParameters, node, activity, clonedFactory);

            return stub;
        } catch (MOPException e) {
            Throwable t = e;

            if (e.getTargetException() != null) {
                t = e.getTargetException();
            }

            throw new ActiveObjectCreationException(t);
        }
    }

    public static Object[] newActiveInParallel(String className,
        Class[] genericParameters, Object[][] constructorParameters,
        Node[] nodes) throws ClassNotFoundException {
        if (constructorParameters.length != nodes.length) {
            throw new ProActiveRuntimeException(
                "The total of constructors must" +
                " be equal to the total of nodes");
        }

        ExecutorService threadPool = Executors.newCachedThreadPool();

        Vector result = new Vector();

        // TODO execute tasks
        // The Virtual Node is already activate
        for (int i = 0; i < constructorParameters.length; i++) {
            threadPool.execute(new ProcessForAoCreation(result, className,
                    genericParameters, constructorParameters[i],
                    nodes[i % nodes.length]));
        }

        threadPool.shutdown();
        try {
            threadPool.awaitTermination(new Integer(System.getProperty(
                        "components.creation.timeout")), TimeUnit.SECONDS);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        Class classForResult = Class.forName(className);
        return result.toArray((Object[]) Array.newInstance(classForResult,
                result.size()));
    }

    public static Object[] newActiveInParallel(String className,
        Class[] genericParameters, Object[] constructorParameters,
        VirtualNode virtualNode) throws NodeException, ClassNotFoundException {
        // Creation of the thread pool
        ExecutorService threadPool = Executors.newCachedThreadPool();

        Vector result = new Vector();
        if (virtualNode.isActivated()) {
            // The Virtual Node is already activate
            Node[] nodes = virtualNode.getNodes();
            for (int i = 0; i < nodes.length; i++) {
                threadPool.execute(new ProcessForAoCreation(result, className,
                        genericParameters, constructorParameters, nodes[i]));
            }
        } else {
            // Use the node creation event mechanism
            ((NodeCreationEventProducerImpl) virtualNode).addNodeCreationEventListener(new NodeCreationListenerForAoCreation(
                    result, className, genericParameters,
                    constructorParameters, threadPool));
            virtualNode.activate();
            ((VirtualNodeImpl) virtualNode).waitForAllNodesCreation();
        }
        threadPool.shutdown();
        try {
            threadPool.awaitTermination(new Integer(System.getProperty(
                        "components.creation.timeout")), TimeUnit.SECONDS);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        Class classForResult = Class.forName(className);
        return result.toArray((Object[]) Array.newInstance(classForResult,
                result.size()));
    }

    public static Object newActiveAsGroup(String classname,
        Class[] genericParameters, Object[] constructorParameters,
        VirtualNode virtualnode)
        throws ActiveObjectCreationException, NodeException {
        return ProActive.newActiveAsGroup(classname, genericParameters,
            constructorParameters, virtualnode, null, null);
    }

    public static Object newActiveAsGroup(String classname,
        Class[] genericParameters, Object[] constructorParameters,
        VirtualNode virtualnode, Active activity, MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        if (virtualnode != null) {
            if (!virtualnode.isActivated()) {
                virtualnode.activate();
            }
            Node[] nodeTab = virtualnode.getNodes();
            Group aoGroup = null;
            try {
                aoGroup = ProActiveGroup.getGroup(ProActiveGroup.newGroup(
                            classname, genericParameters));
            } catch (ClassNotFoundException e) {
                throw new ActiveObjectCreationException(
                    "Cannot create group of active objects" + e);
            } catch (ClassNotReifiableException e) {
                throw new ActiveObjectCreationException(
                    "Cannot create group of active objects" + e);
            }
            for (int i = 0; i < nodeTab.length; i++) {
                Object tmp = newActive(classname, null, constructorParameters,
                        (Node) nodeTab[i], activity, factory);
                aoGroup.add(tmp);
            }

            return aoGroup.getGroupByType();
        } else {
            throw new NodeException(
                "VirtualNode is null, unable to activate the object");
        }
    }

    public static Object turnActive(Object target, String nameOfTargetType,
        Class[] genericParameters, Node node, Active activity,
        MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        if (node == null) {
            //using default proactive node
            node = NodeFactory.getDefaultNode();
        }

        if (factory == null) {
            factory = ProActiveMetaObjectFactory.newInstance();
        }

        ProActiveSecurityManager factorySM = factory.getProActiveSecurityManager();

        MetaObjectFactory clonedFactory = factory;

        if (factorySM != null) {
            try {
                clonedFactory = (MetaObjectFactory) factory.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }

            clonedFactory.setProActiveSecurityManager(factory.getProActiveSecurityManager()
                                                             .generateSiblingCertificate(nameOfTargetType));

            ProActiveLogger.getLogger(Loggers.SECURITY)
                           .debug("new active object with security manager");
        }

        try {
            return createStubObject(target, nameOfTargetType,
                genericParameters, node, activity, clonedFactory);
        } catch (MOPException e) {
            Throwable t = e;

            if (e.getTargetException() != null) {
                t = e.getTargetException();
            }

            throw new ActiveObjectCreationException(t);
        }
    }

    public static Component newActiveComponent(String classname,
        Class[] genericParameters, Object[] constructorParameters, Node node,
        Active activity, MetaObjectFactory factory,
        ComponentParameters componentParameters)
        throws ActiveObjectCreationException, NodeException {
        try {
            Component boot = Fractal.getBootstrapComponent();
            GenericFactory cf = Fractal.getGenericFactory(boot);
            return cf.newFcInstance(componentParameters.getComponentType(),
                new ControllerDescription(componentParameters.getName(),
                    componentParameters.getHierarchicalType()),
                new ContentDescription(classname, constructorParameters,
                    activity, factory));
        } catch (NoSuchInterfaceException e) {
            throw new ActiveObjectCreationException(e);
        } catch (InstantiationException e) {
            if (e.getCause() instanceof NodeException) {
                throw new NodeException(e);
            } else {
                throw new ActiveObjectCreationException(e);
            }
        }
    }

    public static Component newActiveComponent(String className,
        Class[] genericParameters, Object[] constructorParameters,
        VirtualNode vn, ComponentParameters componentParameters)
        throws ActiveObjectCreationException, NodeException {
        try {
            Component boot = Fractal.getBootstrapComponent();
            ProActiveGenericFactory cf = (ProActiveGenericFactory) Fractal.getGenericFactory(boot);
            return cf.newFcInstance(componentParameters.getComponentType(),
                new ControllerDescription(componentParameters.getName(),
                    componentParameters.getHierarchicalType()),
                new ContentDescription(className, constructorParameters));
        } catch (NoSuchInterfaceException e) {
            throw new ActiveObjectCreationException(e);
        } catch (InstantiationException e) {
            if (e.getCause() instanceof NodeException) {
                throw new NodeException(e);
            } else {
                throw new ActiveObjectCreationException(e);
            }
        }
    }

    public static Object turnActive(Object target, Class[] genericParameters)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, genericParameters, (Node) null,
            (Active) null, (MetaObjectFactory) null);
    }

    public static Object turnActive(Object target, Class[] genericParameters,
        String nodeURL) throws ActiveObjectCreationException, NodeException {
        if (nodeURL == null) {
            return turnActive(target, genericParameters,
                target.getClass().getName(), null, null, null);
        } else {
            return turnActive(target, genericParameters,
                target.getClass().getName(), NodeFactory.getNode(nodeURL),
                null, null);
        }
    }

    public static Object turnActive(Object target, Class[] genericParameters,
        Node node) throws ActiveObjectCreationException, NodeException {
        return turnActive(target, genericParameters,
            target.getClass().getName(), node, null, null);
    }

    public static Object turnActive(Object target, Class[] genericParameters,
        Node node, Active activity, MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, genericParameters,
            target.getClass().getName(), node, activity, factory);
    }

    public static Object turnActive(Object target, Class[] genericParameters,
        String nameOfTargetType, Node node)
        throws ActiveObjectCreationException, NodeException {
        return turnActive(target, genericParameters, nameOfTargetType, node,
            null, null);
    }

    public static Object turnActive(Object target, Class[] genericParameters,
        String nameOfTargetType, Node node, Active activity,
        MetaObjectFactory factory)
        throws ActiveObjectCreationException, NodeException {
        if (node == null) {
            //using default proactive node
            node = NodeFactory.getDefaultNode();
        }

        if (factory == null) {
            factory = ProActiveMetaObjectFactory.newInstance();
        }

        ProActiveSecurityManager factorySM = factory.getProActiveSecurityManager();

        MetaObjectFactory clonedFactory = factory;

        if (factorySM != null) {
            try {
                clonedFactory = (MetaObjectFactory) factory.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }

            clonedFactory.setProActiveSecurityManager(factory.getProActiveSecurityManager()
                                                             .generateSiblingCertificate(nameOfTargetType));

            ProActiveLogger.getLogger(Loggers.SECURITY)
                           .debug("new active object with security manager");
        }

        try {
            return createStubObject(target, nameOfTargetType,
                genericParameters, node, activity, clonedFactory);
        } catch (MOPException e) {
            Throwable t = e;

            if (e.getTargetException() != null) {
                t = e.getTargetException();
            }

            throw new ActiveObjectCreationException(t);
        }
    }

    public static Object turnActiveAsGroup(Object target,
        Class[] genericParameters, String nameOfTargetType,
        VirtualNode virtualnode)
        throws ActiveObjectCreationException, NodeException {
        if (virtualnode != null) {
            Node[] nodeTab = virtualnode.getNodes();
            Group aoGroup = null;
            try {
                aoGroup = ProActiveGroup.getGroup(ProActiveGroup.newGroup(
                            target.getClass().getName(), genericParameters));
            } catch (ClassNotFoundException e) {
                throw new ActiveObjectCreationException(
                    "Cannot create group of active objects" + e);
            } catch (ClassNotReifiableException e) {
                throw new ActiveObjectCreationException(
                    "Cannot create group of active objects" + e);
            }

            for (int i = 0; i < nodeTab.length; i++) {
                Object tmp = turnActive(target, genericParameters,
                        nameOfTargetType, (Node) nodeTab[i], null, null);
                aoGroup.add(tmp);
            }

            return aoGroup;
        } else {
            throw new NodeException(
                "VirtualNode is null, unable to active the object");
        }
    }

    public static void register(Object obj, String url)
        throws java.io.IOException {
        BodyAdapter body = getRemoteBody(obj);
        body.register(url);
        if (logger.isInfoEnabled()) {
            logger.info("Success at binding url " + url);
        }
    }

    public static void unregister(String url) throws java.io.IOException {
        String protocol = UrlBuilder.getProtocol(url);

        // First step towards Body factory, will be introduced after the release
        if (protocol.equals("rmi:")) {
            new RmiBodyAdapter().unregister(url);
        } else if (protocol.equals("rmissh:")) {
            new SshRmiBodyAdapter().unregister(url);
        } else if (protocol.equals("http:")) {
            new HttpBodyAdapter().unregister(url);
        } else if (protocol.equals("ibis:")) {
            new IbisBodyAdapter().unregister(url);
        } else {
            throw new IOException("Protocol " + protocol + " not defined");
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Success at unbinding url " + url);
        }
    }

    public static Object lookupActive(String classname, String url)
        throws ActiveObjectCreationException, java.io.IOException {
        //      try {
        //              // this ensures the class server is initialized,
        //              // which ensures that the java.rmi.server.codebase property is initialized,
        //              // which ensures parameters are annotated with the correct codebase in RMI communications
        //                      RuntimeFactory.getDefaultRuntime();
        //              } catch (ProActiveException e1) {
        //                      throw new ActiveObjectCreationException("Exception occured when trying to get default runtime",e1);
        //              }
        UniversalBody b = null;

        String protocol = UrlBuilder.getProtocol(url);

        // First step towards Body factory, will be introduced after the release
        if (protocol.equals("rmi:")) {
            b = new RmiBodyAdapter().lookup(url);
        } else if (protocol.equals("rmissh:")) {
            b = new SshRmiBodyAdapter().lookup(url);
        } else if (protocol.equals("http:")) {
            b = new HttpBodyAdapter().lookup(url);
        } else if (protocol.equals("ibis:")) {
            b = new IbisBodyAdapter().lookup(url);
        } else {
            throw new IOException("Protocol " + protocol + " not defined");
        }

        try {
            return createStubObject(classname, b);
        } catch (MOPException e) {
            Throwable t = e;

            if (e.getTargetException() != null) {
                t = e.getTargetException();
            }

            throw new ActiveObjectCreationException("Exception occured when trying to create stub-proxy",
                t);
        }
    }

    public static String[] listActive(String url) throws java.io.IOException {
        String[] activeNames = null;

        String protocol = UrlBuilder.getProtocol(url);

        // First step towards Body factory, will be introduced after the release
        if (protocol.equals("rmi:")) {
            activeNames = new RmiBodyAdapter().list(url);
        } else if (protocol.equals("rmissh:")) {
            activeNames = new SshRmiBodyAdapter().list(url);
        } else if (protocol.equals("http:")) {
            activeNames = new HttpBodyAdapter().list(url);
        } else if (protocol.equals("ibis:")) {
            activeNames = new IbisBodyAdapter().list(url);
        } else {
            throw new IOException("Protocol " + protocol + " not defined");
        }

        return activeNames;
    }

    public static String getActiveObjectNodeUrl(Object activeObject) {
        UniversalBody body = getRemoteBody(activeObject);
        return body.getNodeURL();
    }

    public static boolean isException(Object future) {
        // If the object is not reified, it cannot be a future
        if ((MOP.isReifiedObject(future)) == false) {
            return false;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ((StubObject) future).getProxy();

            // If it is reified but its proxy is not of type future it's not an exception
            if (!(theProxy instanceof Future)) {
                return false;
            } else {
                return ((Future) theProxy).getRaisedException() != null;
            }
        }
    }

    public static void waitFor(Object future) {
        // If the object is not reified, it cannot be a future
        if ((MOP.isReifiedObject(future)) == false) {
            return;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ((StubObject) future).getProxy();

            // If it is reified but its proxy is not of type future, we cannot wait
            if (!(theProxy instanceof Future)) {
                return;
            } else {
                ((Future) theProxy).waitFor();
            }
        }
    }

    public static void waitFor(Object future, long timeout)
        throws ProActiveException {
        // If the object is not reified, it cannot be a future
        if ((MOP.isReifiedObject(future)) == false) {
            return;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ((StubObject) future).getProxy();

            // If it is reified but its proxy is not of type future, we cannot wait
            if (!(theProxy instanceof Future)) {
                return;
            } else {
                ((Future) theProxy).waitFor(timeout);
            }
        }
    }

    public static ProActiveDescriptor getProactiveDescriptor()
        throws ProActiveException, IOException {
        String padURL = System.getProperty("proactive.pad");

        //System.out.println("pad propertie : " + padURL) ;
        if (padURL == null) {
            //System.out.println("pad null");
            return null;
        } else {
            return getProActiveDescriptor(padURL, new VariableContract(), true);
        }
    }

    public static ProActiveDescriptor getProactiveDescriptor(
        String xmlDescriptorUrl) throws ProActiveException {
        return getProActiveDescriptor(xmlDescriptorUrl, new VariableContract(),
            false);
    }

    public static ProActiveDescriptor getProactiveDescriptor(
        String xmlDescriptorUrl, VariableContract variableContract)
        throws ProActiveException {
        if (variableContract == null) {
            throw new NullPointerException(
                "Argument variableContract can not be null");
        }

        return getProActiveDescriptor(xmlDescriptorUrl, variableContract, false);
    }

    private static ProActiveDescriptor getProActiveDescriptor(
        String xmlDescriptorUrl, VariableContract variableContract,
        boolean hierarchicalSearch) throws ProActiveException {
        //Get lock on XMLProperties global static variable
        org.objectweb.proactive.core.xml.VariableContract.lock.aquire();
        org.objectweb.proactive.core.xml.VariableContract.xmlproperties = variableContract;

        //Get the pad
        ProActiveDescriptor pad;
        try {
            pad = internalGetProActiveDescriptor(xmlDescriptorUrl,
                    variableContract, hierarchicalSearch);
        } catch (ProActiveException e) {
            org.objectweb.proactive.core.xml.VariableContract.lock.release();
            throw e;
        }

        //No further modifications can be donde on the xmlproperties, thus we close the contract
        variableContract.close();

        //Check the contract (proposed optimization: Do this when parsing </variable> tag instead of here!)
        if (!variableContract.checkContract()) {
            logger.error(variableContract.toString());
            org.objectweb.proactive.core.xml.VariableContract.lock.release();
            throw new ProActiveException("Variable Contract has not been met!");
        }

        //Release lock on static global variable XMLProperties
        VariableContract.xmlproperties = new VariableContract();
        org.objectweb.proactive.core.xml.VariableContract.lock.release();

        return pad;
        //return getProactiveDescriptor(xmlDescriptorUrl, false);
    }

    private static ProActiveDescriptor internalGetProActiveDescriptor(
        String xmlDescriptorUrl, VariableContract variableContract,
        boolean hierarchicalSearch) throws ProActiveException {
        RuntimeFactory.getDefaultRuntime();
        if (!xmlDescriptorUrl.startsWith("file:")) {
            xmlDescriptorUrl = "file:" + xmlDescriptorUrl;
        }
        ProActiveRuntimeImpl part = (ProActiveRuntimeImpl) ProActiveRuntimeImpl.getProActiveRuntime();
        ProActiveDescriptor pad;
        try {
            if (!hierarchicalSearch) {
                //if not hierarchical search, we assume that the descriptor might has been
                //register with the default jobID
                pad = part.getDescriptor(xmlDescriptorUrl +
                        ProActive.getJobId(), hierarchicalSearch);
            } else {
                pad = part.getDescriptor(xmlDescriptorUrl, hierarchicalSearch);
            }
        } catch (Exception e) {
            throw new ProActiveException(e);
        }

        // if pad found, returns it
        if (pad != null) {
            return pad;
        }

        // else parses it
        try {
            if (logger.isInfoEnabled()) {
                logger.info("************* Reading deployment descriptor: " +
                    xmlDescriptorUrl + " ********************");
            }
            ProActiveDescriptorHandler proActiveDescriptorHandler = ProActiveDescriptorHandler.createProActiveDescriptor(xmlDescriptorUrl,
                    variableContract);
            pad = (ProActiveDescriptor) proActiveDescriptorHandler.getResultObject();
            part.registerDescriptor(pad.getUrl(), pad);
            return pad;
        } catch (org.xml.sax.SAXException e) {
            //e.printStackTrace(); hides errors when testing parameters in xml descriptors
            logger.fatal(
                "A problem occured when getting the proActiveDescriptor at location \""+xmlDescriptorUrl+"\".");
            throw new ProActiveException("A problem occured when getting the proActiveDescriptor at location \""+xmlDescriptorUrl+"\"."+e);
        } catch (java.io.IOException e) {
            //e.printStackTrace(); hides errors when testing parameters in xml descriptors
            logger.fatal(
                "A problem occured when getting the proActiveDescriptor at location \""+xmlDescriptorUrl+"\".");
            throw new ProActiveException(e);
        }
    }

    public static void registerVirtualNode(VirtualNode virtualNode,
        String registrationProtocol, boolean replacePreviousBinding)
        throws ProActiveException, AlreadyBoundException {
        if (!(virtualNode instanceof VirtualNodeImpl)) {
            throw new ProActiveException(
                "Cannot register such virtualNode since it results from a lookup!");
        }
        if (registrationProtocol == null) {
            registrationProtocol = System.getProperty(
                    "proactive.communication.protocol");
        }
        String virtualnodeName = virtualNode.getName();
        ProActiveRuntime part = RuntimeFactory.getProtocolSpecificRuntime(registrationProtocol);
        VirtualNode vn = part.getVirtualNode(virtualnodeName);
        if (vn == null) {
            throw new ProActiveException("VirtualNode " + virtualnodeName +
                " has not been yet activated or does not exist! Try to activate it first !");
        }
        part.registerVirtualNode(UrlBuilder.appendVnSuffix(virtualnodeName),
            replacePreviousBinding);
    }

    public static VirtualNode lookupVirtualNode(String url)
        throws ProActiveException {
        ProActiveRuntime remoteProActiveRuntime = null;
        try {
            remoteProActiveRuntime = RuntimeFactory.getRuntime(UrlBuilder.buildVirtualNodeUrl(
                        url), UrlBuilder.getProtocol(url));
        } catch (UnknownHostException ex) {
            throw new ProActiveException(ex);
        }
        return remoteProActiveRuntime.getVirtualNode(UrlBuilder.getNameFromUrl(
                url));
    }

    public static void unregisterVirtualNode(VirtualNode virtualNode)
        throws ProActiveException {
        //VirtualNode vn = ((VirtualNodeStrategy)virtualNode).getVirtualNode();
        if (!(virtualNode instanceof VirtualNodeImpl)) {
            throw new ProActiveException(
                "Cannot unregister such virtualNode since it results from a lookup!");
        }
        String virtualNodeName = virtualNode.getName();
        ProActiveRuntime part = RuntimeFactory.getProtocolSpecificRuntime(((VirtualNodeImpl) virtualNode).getRegistrationProtocol());
        part.unregisterVirtualNode(UrlBuilder.appendVnSuffix(
                virtualNode.getName()));
        if (logger.isInfoEnabled()) {
            logger.info("Success at unbinding " + virtualNodeName);
        }
    }

    public static Body getBodyOnThis() {
        return LocalBodyStore.getInstance().getCurrentThreadBody();
    }

    public static StubObject getStubOnThis() {
        Body body = getBodyOnThis();

        if (logger.isDebugEnabled()) {
            //logger.debug("ProActive: getStubOnThis() returns " + body);
        }
        if (body == null) {
            return null;
        }

        return getStubForBody(body);
    }

    public static void migrateTo(Object activeObject) throws MigrationException {
        migrateTo(getNodeFromURL(getNodeURLFromActiveObject(activeObject)));
    }

    public static void migrateTo(String nodeURL) throws MigrationException {
        if (logger.isDebugEnabled()) {
            logger.debug("migrateTo " + nodeURL);
        }
        ProActive.migrateTo(getNodeFromURL(nodeURL));
    }

    public static void migrateTo(Node node) throws MigrationException {
        if (logger.isDebugEnabled()) {
            logger.debug("migrateTo " + node);
        }
        Body bodyToMigrate = getBodyOnThis();
        if (!(bodyToMigrate instanceof Migratable)) {
            throw new MigrationException(
                "This body cannot migrate. It doesn't implement Migratable interface");
        }

        ((Migratable) bodyToMigrate).migrateTo(node);
    }

    public static void migrateTo(Body bodyToMigrate, Object activeObject,
        boolean isNFRequest) throws MigrationException {
        ProActive.migrateTo(bodyToMigrate,
            getNodeFromURL(getNodeURLFromActiveObject(activeObject)),
            isNFRequest);
    }

    public static void migrateTo(Body bodyToMigrate, String nodeURL,
        boolean isNFRequest) throws MigrationException {
        ProActive.migrateTo(bodyToMigrate, getNodeFromURL(nodeURL), isNFRequest);
    }

    public static void migrateTo(Body bodyToMigrate, Node node,
        boolean isNFRequest) throws MigrationException {
        //In the context of ProActive, migration of an active object is considered as a non functional request. 
        //That's why "true" is set by default for the "isNFRequest" parameter. 
        ProActive.migrateTo(bodyToMigrate, node, true,
            org.objectweb.proactive.core.body.request.Request.NFREQUEST_IMMEDIATE_PRIORITY);
    }

    public static void migrateTo(Body bodyToMigrate, Node node,
        boolean isNFRequest, int priority) throws MigrationException {
        if (!(bodyToMigrate instanceof Migratable)) {
            throw new MigrationException(
                "This body cannot migrate. It doesn't implement Migratable interface");
        }

        Object[] arguments = { node };

        try {
            BodyRequest request = new BodyRequest(bodyToMigrate, "migrateTo",
                    new Class[] { Node.class }, arguments, isNFRequest, priority);
            request.send(bodyToMigrate);
        } catch (NoSuchMethodException e) {
            throw new MigrationException("Cannot find method migrateTo this body. Non sense since the body is instance of Migratable",
                e);
        } catch (java.io.IOException e) {
            throw new MigrationException("Cannot send the request to migrate", e);
        }
    }

    public static int waitForAny(java.util.Vector futures) {
        try {
            return waitForAny(futures, 0);
        } catch (ProActiveException e) {
            //Exception above should never be thrown since timeout=0 means no timeout
            e.printStackTrace();
            return -1;
        }
    }

    public static int waitForAny(java.util.Vector futures, long timeout)
        throws ProActiveException {
        FuturePool fp = getBodyOnThis().getFuturePool();

        synchronized (fp) {
            while (true) {
                java.util.Iterator it = futures.iterator();
                int index = 0;

                while (it.hasNext()) {
                    Object current = it.next();

                    if (!isAwaited(current)) {
                        return index;
                    }

                    index++;
                }
                fp.waitForReply(timeout);
            }
        }
    }

    public static void waitForAll(java.util.Vector futures) {
        try {
            ProActive.waitForAll(futures, 0);
        } catch (ProActiveException e) {
            //Exception above should never be thrown since timeout=0 means no timeout
            e.printStackTrace();
        }
    }

    public static void waitForAll(java.util.Vector futures, long timeout)
        throws ProActiveException {
        FuturePool fp = getBodyOnThis().getFuturePool();

        synchronized (fp) {
            boolean oneIsMissing = true;

            while (oneIsMissing) {
                oneIsMissing = false;

                java.util.Iterator it = futures.iterator();

                while (it.hasNext()) {
                    Object current = it.next();

                    if (isAwaited(current)) {
                        oneIsMissing = true;
                    }
                }

                if (oneIsMissing) {
                    fp.waitForReply(timeout);
                }
            }
        }
    }

    public static void waitForTheNth(java.util.Vector futures, int n) {
        FuturePool fp = getBodyOnThis().getFuturePool();

        synchronized (fp) {
            Object current = futures.get(n);

            if (isAwaited(current)) {
                waitFor(current);
            }
        }
    }

    public static void waitForTheNth(java.util.Vector futures, int n,
        long timeout) throws ProActiveException {
        FuturePool fp = getBodyOnThis().getFuturePool();

        synchronized (fp) {
            Object current = futures.get(n);

            if (isAwaited(current)) {
                waitFor(current, timeout);
            }
        }
    }

    public static boolean allAwaited(java.util.Vector futures) {
        FuturePool fp = getBodyOnThis().getFuturePool();

        synchronized (fp) {
            java.util.Iterator it = futures.iterator();

            while (it.hasNext()) {
                Object current = it.next();

                if (!isAwaited(current)) {
                    return false;
                }
            }
            return true;
        }
    }

    public static boolean isAwaited(Object future) {
        // If the object is not reified, it cannot be a future
        if ((MOP.isReifiedObject(future)) == false) {
            return false;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ((StubObject) future).getProxy();

            // If it is reified but its proxy is not of type future, we cannot wait
            if (!(theProxy instanceof Future)) {
                return false;
            } else {
                if (((Future) theProxy).isAwaited()) {
                    return true;
                } else {
                    return isAwaited(((Future) theProxy).getResult());
                }
            }
        }
    }

    public static Object getFutureValue(Object future) {
        // If the object is not reified, it cannot be a future
        if ((MOP.isReifiedObject(future)) == false) {
            return future;
        } else {
            org.objectweb.proactive.core.mop.Proxy theProxy = ((StubObject) future).getProxy();

            // If it is reified but its proxy is not of type future, we cannot wait
            if (!(theProxy instanceof Future)) {
                return future;
            } else {
                Object o = ((Future) theProxy).getResult();

                return getFutureValue(o);
            }
        }
    }

    public static void enableAC(Object obj) throws java.io.IOException {
        UniversalBody body = getRemoteBody(obj);
        body.enableAC();
    }

    public static void disableAC(Object obj) throws java.io.IOException {
        UniversalBody body = getRemoteBody(obj);
        body.disableAC();
    }

    public static void terminateActiveObject(Object ao, boolean immediate) {
        Proxy proxy = ((StubObject) ao).getProxy();
        try {
            if (immediate) {
                NonFunctionalServices.terminateAOImmediately(proxy);
            } else {
                NonFunctionalServices.terminateAO(proxy);
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    public static void setImmediateService(Object obj, String methodName)
        throws java.io.IOException {
        UniversalBody body = getRemoteBody(obj);
        body.setImmediateService(methodName);
    }

    public static void setImmediateService(Object obj, String methodName,
        Class[] parametersTypes) throws IOException {
        UniversalBody body = getRemoteBody(obj);
        body.setImmediateService(methodName, parametersTypes);
    }

    public static void removeImmediateService(Object obj, String methodName,
        Class[] parametersTypes) throws IOException {
        UniversalBody body = getRemoteBody(obj);
        body.removeImmediateService(methodName, parametersTypes);
    }

    private static BodyAdapter getRemoteBody(Object obj) {
        // Check if obj is really a reified object
        if (!(MOP.isReifiedObject(obj))) {
            throw new ProActiveRuntimeException("The given object " + obj +
                " is not a reified object");
        }

        // Find the appropriate remoteBody
        org.objectweb.proactive.core.mop.Proxy myProxy = ((StubObject) obj).getProxy();

        if (myProxy == null) {
            throw new ProActiveRuntimeException(
                "Cannot find a Proxy on the stub object: " + obj);
        }

        BodyProxy myBodyProxy = (BodyProxy) myProxy;
        BodyAdapter body = myBodyProxy.getBody().getRemoteAdapter();
        return body;
    }

    public static String getJobId() {
        return ProActive.getBodyOnThis().getJobID();
    }

    public static void exposeAsWebService(Object o, String url, String urn,
        String[] methods) {
        ProActiveDeployer.deploy(urn, url, o, methods);
    }

    public static void unExposeAsWebService(String urn, String url) {
        ProActiveDeployer.undeploy(urn, url);
    }

    public static void exposeComponentAsWebService(Component component,
        String url, String componentName) {
        ProActiveDeployer.deployComponent(componentName, url, component);
    }

    public static void unExposeComponentAsWebService(String componentName,
        String url, Component component) {
        ProActiveDeployer.undeployComponent(componentName, url, component);
    }

    //
    // -- PRIVATE METHODS -----------------------------------------------
    //
    private static String getNodeURLFromActiveObject(Object o)
        throws MigrationException {
        //first we check if the parameter is an active object,
        if (!org.objectweb.proactive.core.mop.MOP.isReifiedObject(o)) {
            throw new MigrationException(
                "The parameter is not an active object");
        }

        //now we get a reference on the remoteBody of this guy
        BodyProxy destProxy = (BodyProxy) ((org.objectweb.proactive.core.mop.StubObject) o).getProxy();

        return destProxy.getBody().getNodeURL();
    }

    private static Node getNodeFromURL(String url) throws MigrationException {
        try {
            return NodeFactory.getNode(url);
        } catch (NodeException e) {
            throw new MigrationException("The node of given URL " + url +
                " cannot be localized", e);
        }
    }

    // -------------------------------------------------------------------------------------------
    // 
    // STUB CREATION
    // 
    // -------------------------------------------------------------------------------------------
    private static StubObject getStubForBody(Body body) {
        try {
            return createStubObject(body.getReifiedObject(),
                new Object[] { body },
                body.getReifiedObject().getClass().getName(), null);
        } catch (MOPException e) {
            throw new ProActiveRuntimeException(
                "Cannot create Stub for this Body e=" + e);
        }
    }

    public static Object createStubObject(String className, UniversalBody body)
        throws MOPException {
        return createStubObject(className, null, null, new Object[] { body });
    }

    private static Object createStubObject(String className,
        Class[] genericParameters, Object[] constructorParameters, Node node,
        Active activity, MetaObjectFactory factory) throws MOPException {
        return createStubObject(className, genericParameters,
            constructorParameters,
            new Object[] { node, activity, factory, ProActive.getJobId() });
    }

    private static Object createStubObject(String className,
        Class[] genericParameters, Object[] constructorParameters,
        Object[] proxyParameters) throws MOPException {
        try {
            return MOP.newInstance(className, genericParameters,
                constructorParameters, Constants.DEFAULT_BODY_PROXY_CLASS_NAME,
                proxyParameters);
        } catch (ClassNotFoundException e) {
            throw new ConstructionOfProxyObjectFailedException(
                "Class can't be found e=" + e);
        }
    }

    private static Object createStubObject(Object target,
        String nameOfTargetType, Class[] genericParameters, Node node,
        Active activity, MetaObjectFactory factory) throws MOPException {
        return createStubObject(target,
            new Object[] { node, activity, factory, ProActive.getJobId() },
            nameOfTargetType, genericParameters);
    }

    private static StubObject createStubObject(Object object,
        Object[] proxyParameters, String nameOfTargetType,
        Class[] genericParameters) throws MOPException {
        try {
            return (StubObject) MOP.turnReified(nameOfTargetType,
                Constants.DEFAULT_BODY_PROXY_CLASS_NAME, proxyParameters,
                object, genericParameters);
        } catch (ClassNotFoundException e) {
            throw new ConstructionOfProxyObjectFailedException(
                "Class can't be found e=" + e);
        }
    }

    /*** <Exceptions> See ExceptionHandler.java for the documentation ***/
    public static void tryWithCatch(Class c) {
        tryWithCatch(new Class[] { c });
    }

    public static void tryWithCatch(Class[] c) {
        ExceptionHandler.tryWithCatch(c);
    }

    public static void endTryWithCatch() {
        ExceptionHandler.endTryWithCatch();
    }

    public static void removeTryWithCatch() {
        ExceptionHandler.removeTryWithCatch();
    }

    public static void throwArrivedException() {
        ExceptionHandler.throwArrivedException();
    }

    public static void waitForPotentialException() {
        ExceptionHandler.waitForPotentialException();
    }

    public static void addNFEListenerOnJVM(NFEListener listener) {
        NFEManager.addNFEListener(listener);
    }

    public static void removeNFEListenerOnJVM(NFEListener listener) {
        NFEManager.removeNFEListener(listener);
    }

    public static void addNFEListenerOnAO(Object ao, NFEListener listener) {

        /* Security hazard: arbitrary code execution by the ao... */
        BodyAdapter body = getRemoteBody(ao);
        body.addNFEListener(listener);
    }

    public static void removeNFEListenerOnAO(Object ao, NFEListener listener) {
        BodyAdapter body = getRemoteBody(ao);
        body.removeNFEListener(listener);
    }

    public static void addNFEListenerOnProxy(Object ao, NFEListener listener) {
        try {
            ((AbstractProxy) ao).addNFEListener(listener);
        } catch (ClassCastException cce) {
            throw new IllegalArgumentException(
                "The object must be a proxy to an active object");
        }
    }

    public static void removeNFEListenerOnProxy(Object ao, NFEListener listener) {
        try {
            ((AbstractProxy) ao).removeNFEListener(listener);
        } catch (ClassCastException cce) {
            throw new IllegalArgumentException(
                "The object must be a proxy to an active object");
        }
    }

    private static ProxyForGroup getGroupProxy(Object group) {
        ProxyForGroup pfg;

        try {
            pfg = (ProxyForGroup) ProActiveGroup.getGroup(group);
        } catch (ClassCastException cce) {
            pfg = null;
        }

        if (pfg == null) {
            throw new IllegalArgumentException("The argument must be a group");
        }

        return pfg;
    }

    public static void addNFEListenerOnGroup(Object group, NFEListener listener) {
        getGroupProxy(group).addNFEListener(listener);
    }

    public static void removeNFEListenerOnGroup(Object group,
        NFEListener listener) {
        getGroupProxy(group).removeNFEListener(listener);
    }

    public static Collection getAllExceptions() {
        return ExceptionHandler.getAllExceptions();
    }

    public static Node getNode() throws NodeException {
        BodyProxy destProxy = (BodyProxy) ((StubObject) getStubOnThis()).getProxy();

        return NodeFactory.getNode(destProxy.getBody().getNodeURL());
    }

    public static void exitSuccess() {
        System.exit(0);
    }

    public static void exitFailure() {
        System.exit(1);
    }

    public void enableExitOnEmpty() {
        LocalBodyStore.getInstance().enableExitOnEmpty();
    }

    public static String getProActiveVersion() {
        return "3.2";
    }
}

---