org/objectweb/proactive/core/component/Fractive.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.component;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import javax.naming.NamingException;

import org.apache.log4j.Logger;
import org.objectweb.fractal.api.Component;
import org.objectweb.fractal.api.NoSuchInterfaceException;
import org.objectweb.fractal.api.Type;
import org.objectweb.fractal.api.factory.Factory;
import org.objectweb.fractal.api.factory.GenericFactory;
import org.objectweb.fractal.api.factory.InstantiationException;
import org.objectweb.fractal.api.type.ComponentType;
import org.objectweb.fractal.api.type.InterfaceType;
import org.objectweb.fractal.api.type.TypeFactory;
import org.objectweb.proactive.ActiveObjectCreationException;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.ProActiveRuntimeException;
import org.objectweb.proactive.core.body.ProActiveMetaObjectFactory;
import org.objectweb.proactive.core.body.UniversalBody;
import org.objectweb.proactive.core.body.http.HttpBodyAdapter;
import org.objectweb.proactive.core.body.ibis.IbisBodyAdapter;
import org.objectweb.proactive.core.body.rmi.RmiBodyAdapter;
import org.objectweb.proactive.core.body.rmi.SshRmiBodyAdapter;
import org.objectweb.proactive.core.component.body.ComponentBody;
import org.objectweb.proactive.core.component.controller.ComponentParametersController;
import org.objectweb.proactive.core.component.controller.GathercastController;
import org.objectweb.proactive.core.component.controller.MigrationController;
import org.objectweb.proactive.core.component.controller.MulticastController;
import org.objectweb.proactive.core.component.controller.ProActiveBindingController;
import org.objectweb.proactive.core.component.controller.ProActiveContentController;
import org.objectweb.proactive.core.component.exceptions.InstantiationExceptionListException;
import org.objectweb.proactive.core.component.factory.ProActiveGenericFactory;
import org.objectweb.proactive.core.component.identity.ProActiveComponent;
import org.objectweb.proactive.core.component.representative.ProActiveComponentRepresentative;
import org.objectweb.proactive.core.component.representative.ProActiveComponentRepresentativeFactory;
import org.objectweb.proactive.core.component.type.Composite;
import org.objectweb.proactive.core.component.type.ProActiveInterfaceType;
import org.objectweb.proactive.core.component.type.ProActiveTypeFactory;
import org.objectweb.proactive.core.component.type.ProActiveTypeFactoryImpl;
import org.objectweb.proactive.core.descriptor.data.VirtualNode;
import org.objectweb.proactive.core.group.ProActiveComponentGroup;
import org.objectweb.proactive.core.group.ProActiveGroup;
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.util.UrlBuilder;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;


public class Fractive implements ProActiveGenericFactory, Component, Factory {
    private static Fractive instance = null;
    private TypeFactory typeFactory = (TypeFactory) ProActiveTypeFactoryImpl.instance();
    private Type type = null;
    private static Logger logger = ProActiveLogger.getLogger(Loggers.COMPONENTS);

    public Fractive() {
    }

    private static Fractive instance() {
        if (instance == null) {
            instance = new Fractive();
        }
        return instance;
    }

    public static ComponentParametersController getComponentParametersController(
        final Component component) throws NoSuchInterfaceException {
        return (ComponentParametersController) component.getFcInterface(Constants.COMPONENT_PARAMETERS_CONTROLLER);
    }
    
    public static ProActiveBindingController getBindingController(
            final ProActiveComponent component) throws NoSuchInterfaceException {
            return (ProActiveBindingController) component.getFcInterface(Constants.BINDING_CONTROLLER);
        }

    public static MulticastController getMulticastController(
        final Component component) throws NoSuchInterfaceException {
        return (MulticastController) component.getFcInterface(Constants.MULTICAST_CONTROLLER);
    }
    
    public static ProActiveContentController getProActiveContentController(
        final Component component) throws NoSuchInterfaceException {
        return (ProActiveContentController) component.getFcInterface(Constants.CONTENT_CONTROLLER);
    }
    
    public static GathercastController getGathercastController(
        final Component component) throws NoSuchInterfaceException {
        return (GathercastController) component.getFcInterface(Constants.GATHERCAST_CONTROLLER);
    }

    public static MigrationController getMigrationController(
        final Component component) throws NoSuchInterfaceException {
        return (MigrationController) component.getFcInterface(Constants.MIGRATION_CONTROLLER);
    }

    public static ProActiveInterface createCollectiveClientInterface(
        String itfName, String itfSignature, Component owner)
        throws ProActiveRuntimeException {
        try {
            ProActiveInterfaceType itf_type = (ProActiveInterfaceType) ProActiveTypeFactoryImpl.instance()
                                                                                               .createFcItfType(itfName,
                    itfSignature, TypeFactory.CLIENT, TypeFactory.MANDATORY,
                    TypeFactory.COLLECTION);
            ProActiveInterface itf_ref_group = ProActiveComponentGroup.newComponentInterfaceGroup(itf_type,
                    owner);
            return itf_ref_group;
        } catch (Exception e) {
            throw new ProActiveRuntimeException("Impossible to create a collective client interface ",
                e);
        }
    }

    public static ProActiveInterface createMulticastClientInterface(
        String itfName, String itfSignature, Component owner)
        throws ProActiveRuntimeException {
        try {
            ProActiveInterfaceType itf_type = (ProActiveInterfaceType) ProActiveTypeFactoryImpl.instance()
                                                                                               .createFcItfType(itfName,
                    itfSignature, TypeFactory.CLIENT, TypeFactory.MANDATORY,
                    ProActiveTypeFactory.MULTICAST_CARDINALITY);

            ProActiveInterface itf_ref_group = ProActiveComponentGroup.newComponentInterfaceGroup(itf_type,
                    owner);
            return itf_ref_group;
        } catch (Exception e) {
            throw new ProActiveRuntimeException("Impossible to create a collective client interface ",
                e);
        }
    }

    //    public static ProActiveInterface createCollectiveClientInterface(
    //        String itfName, String itfSignature) throws ProActiveRuntimeException {
    //        return Fractive.createCollectiveClientInterface(itfName, itfSignature,
    //            null);
    //    }

    public static ProActiveInterface createMulticastClientInterface(
        String itfName, String itfSignature) throws ProActiveRuntimeException {
        return Fractive.createCollectiveClientInterface(itfName, itfSignature,
            null);
    }

    /*
     *
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstance(org.objectweb.fractal.api.Type, org.objectweb.proactive.core.component.ControllerDescription, org.objectweb.proactive.core.component.ContentDescription)
     */
    public Component newFcInstance(Type type,
        ControllerDescription controllerDesc, ContentDescription contentDesc)
        throws InstantiationException {
        return newFcInstance(type, controllerDesc, contentDesc, (Node) null);
    }

    /*
     *
     * @see org.objectweb.fractal.api.factory.GenericFactory#newFcInstance(org.objectweb.fractal.api.Type, java.lang.Object, java.lang.Object)
     */
    public Component newFcInstance(Type type, Object controllerDesc,
        Object contentDesc) throws InstantiationException {
        try {
            return newFcInstance(type, (ControllerDescription) controllerDesc,
                (ContentDescription) contentDesc);
        } catch (ClassCastException e) {
            if ((type == null) && (controllerDesc == null) &&
                    (contentDesc instanceof Map)) {
                // for compatibility with the new
                // org.objectweb.fractal.util.Fractal class
                return this;
            }
            if ((controllerDesc instanceof ControllerDescription) &&
                    ((contentDesc instanceof String) || (contentDesc == null))) {
                // for the ADL, when only type and ControllerDescription are
                // given
                return newFcInstance(type, controllerDesc,
                    (contentDesc == null) ? null
                                          : new ContentDescription(
                        (String) contentDesc));
            }

            // code compatibility with Julia
            if ("composite".equals(controllerDesc) && (contentDesc == null)) {
                return newFcInstance(type,
                    new ControllerDescription(null, Constants.COMPOSITE), null);
            }
            if ("primitive".equals(controllerDesc) &&
                    (contentDesc instanceof String)) {
                return newFcInstance(type,
                    new ControllerDescription(null, Constants.PRIMITIVE),
                    new ContentDescription((String) contentDesc));
            }

            // any other case
            throw new InstantiationException(
                "With this implementation, parameters must be of respective types : " +
                Type.class.getName() + ',' +
                ControllerDescription.class.getName() + ',' +
                ContentDescription.class.getName());
        }
    }

    /*
     *
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstance(org.objectweb.fractal.api.Type, org.objectweb.proactive.core.component.ControllerDescription, org.objectweb.proactive.core.component.ContentDescription, org.objectweb.proactive.core.node.Node)
     */
    public Component newFcInstance(Type type,
        ControllerDescription controllerDesc, ContentDescription contentDesc,
        Node node) throws InstantiationException {
        if (contentDesc == null) {
            // either a parallel or a composite component, no
            // activitiy/factory/node specified
            if (Constants.COMPOSITE.equals(controllerDesc.getHierarchicalType())) {
                contentDesc = new ContentDescription(Composite.class.getName());
            } else {
                throw new InstantiationException(
                    "Content can be null only if the hierarchical type of the component is composite");
            }
        }
        try {
            // instantiate the component metaobject factory with parameters of
            // the component
            ComponentParameters componentParameters = new ComponentParameters((ComponentType) type,
                    controllerDesc);
            if (contentDesc.getFactory() == null) {
                // first create a map with the parameters
                Map<String, Object> factory_params = new Hashtable<String, Object>(1);

                factory_params.put(ProActiveMetaObjectFactory.COMPONENT_PARAMETERS_KEY,
                    componentParameters);
                if (controllerDesc.isSynchronous() &&
                        (Constants.COMPOSITE.equals(
                            controllerDesc.getHierarchicalType()))) {
                    factory_params.put(ProActiveMetaObjectFactory.SYNCHRONOUS_COMPOSITE_COMPONENT_KEY,
                            Constants.SYNCHRONOUS);
                }
                contentDesc.setFactory(new ProActiveMetaObjectFactory(
                        factory_params));
                // factory =
                // ProActiveComponentMetaObjectFactory.newInstance(componentParameters);
            }

            // TODO_M : add controllers in the component metaobject factory?
            Object ao = null ;

                
            // 3 possibilities : either the component is created on a node (or
            // null), it is created on a virtual node, or on multiple nodes
            ao = ProActive.newActive(contentDesc.getClassName(),
                    null, contentDesc.getConstructorParameters(),
                    node, contentDesc.getActivity(), contentDesc.getFactory());

            // Find the proxy
            org.objectweb.proactive.core.mop.Proxy myProxy = ((StubObject) ao).getProxy();
            if (myProxy == null) {
                throw new ProActiveRuntimeException(
                    "Cannot find a Proxy on the stub object: " + ao);
            }
            ProActiveComponentRepresentative representative = ProActiveComponentRepresentativeFactory.instance()
                                                                                                     .createComponentRepresentative((ComponentType) type,
                    componentParameters.getHierarchicalType(), myProxy,
                    componentParameters.getControllerDescription()
                                       .getControllersConfigFileLocation());
            representative.setStubOnBaseObject((StubObject) ao);
            return representative;
        } catch (ActiveObjectCreationException e) {
            e.printStackTrace();
            throw new InstantiationException(e.getMessage());
        } catch (NodeException e) {
            throw new InstantiationException(e.getMessage());
        }
    }

    /*
     *
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstance(org.objectweb.fractal.api.Type, org.objectweb.proactive.core.component.ControllerDescription, org.objectweb.proactive.core.component.ContentDescription, org.objectweb.proactive.core.descriptor.data.VirtualNode)
     */
    public Component newFcInstance(Type type,
        ControllerDescription controllerDesc, ContentDescription contentDesc,
        VirtualNode virtualNode) throws InstantiationException {
        if (virtualNode == null) {
            return newFcInstance(type, controllerDesc, contentDesc, (Node) null);
        }
        try {
            virtualNode.activate();
            if (virtualNode.getNodes().length == 0) {
                throw new InstantiationException(
                    "Cannot create component on virtual node as no node is associated with this virtual node");
            }
            return newFcInstance(type, controllerDesc, contentDesc,
                virtualNode.getNode());
        } catch (NodeException e) {
            throw new InstantiationException(
                "could not instantiate components due to a deployment problem : " +
                e.getMessage());
        }
    }

    /*
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstanceAsList(org.objectweb.fractal.api.Type,
     *      org.objectweb.proactive.core.component.ControllerDescription,
     *      org.objectweb.proactive.core.component.ContentDescription,
     *      org.objectweb.proactive.core.descriptor.data.VirtualNode)
     */
    public List<Component> newFcInstanceAsList(Type type,
        ControllerDescription controllerDesc, ContentDescription contentDesc,
        VirtualNode virtualNode) throws InstantiationException {
        if (virtualNode == null) {
            return newFcInstanceAsList(type, controllerDesc, contentDesc,
                (Node[]) null);
        }
        try {
            virtualNode.activate();
            return newFcInstanceAsList(type, controllerDesc, contentDesc,
                virtualNode.getNodes());
        } catch (NodeException e) {
            throw new InstantiationException(
                "could not instantiate components due to a deployment problem : " +
                e.getMessage());
        }
    }

    /*
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstanceAsList(org.objectweb.fractal.api.Type,
     *      org.objectweb.proactive.core.component.ControllerDescription,
     *      org.objectweb.proactive.core.component.ContentDescription,
     *      org.objectweb.proactive.core.node.Node[])
     */
    public List<Component> newFcInstanceAsList(Type type,
        ControllerDescription controllerDesc, ContentDescription contentDesc,
        Node[] nodes) throws InstantiationException {
        ContentDescription[] contentDescArray = new ContentDescription[nodes.length];
        Arrays.fill(contentDescArray, contentDesc);
        return newFcInstanceAsList(type, controllerDesc, contentDescArray, nodes);
    }

    /*
     *
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstanceAsList(org.objectweb.fractal.api.Type, org.objectweb.proactive.core.component.ControllerDescription, org.objectweb.proactive.core.component.ContentDescription[], org.objectweb.proactive.core.node.Node[])
     */
    public List<Component> newFcInstanceAsList(Type type,
        ControllerDescription controllerDesc, ContentDescription[] contentDesc,
        Node[] nodes) throws InstantiationException {
        try {
            Component components = ProActiveComponentGroup.newComponentRepresentativeGroup((ComponentType) type,
                    controllerDesc);
            List<Component> componentsList = ProActiveGroup.getGroup(components);
            if (Constants.PRIMITIVE.equals(controllerDesc.getHierarchicalType())) {
                if (contentDesc.length > 1) { // cyclic
                                              // node
                                              // + 1
                                              // instance
                                              // per
                                              // node
                                              // task = instantiate a component with a different name
                                              // on each of the node mapped to the given virtual node
                    String original_component_name = controllerDesc.getName();

                    // TODO: reuse pool for whole class ?
                    ExecutorService threadPool = Executors.newCachedThreadPool();

                    List<InstantiationException> exceptions = new Vector<InstantiationException>();

                    Component c = new MockComponent();

                    for (int i = 0; i < nodes.length; i++) {
                        componentsList.add(c);
                    }

                    for (int i = 0; i < nodes.length; i++) {
                        ComponentBuilderTask task = new ComponentBuilderTask(exceptions,
                                componentsList, i, type, controllerDesc,
                                original_component_name, contentDesc, nodes);
                        threadPool.execute(task);
                    }
                    threadPool.shutdown();
                    try {
                        threadPool.awaitTermination(new Integer(
                                System.getProperty(
                                    "components.creation.timeout")),
                            TimeUnit.SECONDS);
                    } catch (InterruptedException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    if (!exceptions.isEmpty()) {
                        InstantiationException e = new InstantiationException(
                                "Creation of some of the components failed");
                        e.initCause(new InstantiationExceptionListException(
                                exceptions));
                        throw e;
                    }
                } else {
                    // component is a composite : it will be
                    // created on the first node from this virtual node
                    componentsList.add(newFcInstance(type, controllerDesc,
                            contentDesc[0], nodes[0]));
                }
            }
            return componentsList;
        } catch (ClassNotFoundException e) {
            throw new InstantiationException(e.getMessage());
        }
    }

    /*
     *
     * @see org.objectweb.proactive.core.component.factory.ProActiveGenericFactory#newFcInstanceAsList(org.objectweb.fractal.api.Type, org.objectweb.proactive.core.component.ControllerDescription, org.objectweb.proactive.core.component.ContentDescription[], org.objectweb.proactive.core.descriptor.data.VirtualNode)
     */
    public List<Component> newFcInstanceAsList(Type type,
        ControllerDescription controllerDesc, ContentDescription[] contentDesc,
        VirtualNode virtualNode) throws InstantiationException {
        if (virtualNode == null) {
            return newFcInstanceAsList(type, controllerDesc, contentDesc,
                (Node[]) null);
        }
        try {
            virtualNode.activate();

            return newFcInstanceAsList(type, controllerDesc, contentDesc,
                virtualNode.getNodes());
        } catch (NodeException e) {
            throw new InstantiationException(
                "could not instantiate components due to a deployment problem : " +
                e.getMessage());
        }
    }

    /*
     *
     * @see org.objectweb.fractal.api.Component#getFcInterface(java.lang.String)
     */
    public Object getFcInterface(String itfName)
        throws NoSuchInterfaceException {
        if ("generic-factory".equals(itfName)) {
            return this;
        } else if ("type-factory".equals(itfName)) {
            return typeFactory;
        } else {
            throw new NoSuchInterfaceException(itfName);
        }
    }

    /*
     *
     * @see org.objectweb.fractal.api.Component#getFcInterfaces()
     */
    public Object[] getFcInterfaces() {
        return null;
    }

    /*
     *
     * @see org.objectweb.fractal.api.Component#getFcType()
     */
    public Type getFcType() {
        if (type == null) {
            try {
                return type = typeFactory.createFcType(new InterfaceType[] {
                            typeFactory.createFcItfType("generic-factory",
                                GenericFactory.class.getName(), false, false,
                                false),
                            typeFactory.createFcItfType("type-factory",
                                TypeFactory.class.getName(), false, false, false)
                        });
            } catch (InstantiationException e) {
                ProActiveLogger.getLogger(Loggers.COMPONENTS)
                               .error(e.getMessage());
                return null;
            }
        } else {
            return type;
        }
    }

    /*
     *
     * @see org.objectweb.fractal.api.factory.Factory#getFcContentDesc()
     */
    public Object getFcContentDesc() {
        return null;
    }

    /*
     *
     * @see org.objectweb.fractal.api.factory.Factory#getFcControllerDesc()
     */
    public Object getFcControllerDesc() {
        return null;
    }

    /*
     *
     * @see org.objectweb.fractal.api.factory.Factory#getFcInstanceType()
     */
    public Type getFcInstanceType() {
        return null;
    }

    /*
     *
     * @see org.objectweb.fractal.api.factory.Factory#newFcInstance()
     */
    public Component newFcInstance() throws InstantiationException {
        return this;
    }

    public static InterfaceType[] getClientInterfaceTypes(
        ComponentType componentType) {
        ArrayList<InterfaceType> client_interfaces = new ArrayList<InterfaceType>();
        InterfaceType[] interfaceTypes = componentType.getFcInterfaceTypes();
        for (int i = 0; i < interfaceTypes.length; i++) {
            if (interfaceTypes[i].isFcClientItf()) {
                client_interfaces.add(interfaceTypes[i]);
            }
        }
        return client_interfaces.toArray(new InterfaceType[client_interfaces.size()]);
    }

    public static Component getComponentRepresentativeOnThis() {
        ComponentBody componentBody;
        try {
            componentBody = (ComponentBody) ProActive.getBodyOnThis();
        } catch (ClassCastException e) {
            logger.error(
                "Cannot get a component representative from the current object, because this object is not a component");
            return null;
        }
        ProActiveComponent currentComponent = componentBody.getProActiveComponentImpl();
        return currentComponent.getRepresentativeOnThis();
    }

    public static void register(Component ref, String url)
        throws IOException {
        if (!(ref instanceof ProActiveComponentRepresentative)) {
            throw new IllegalArgumentException(
                "This method can only register ProActive components");
        }
        ProActive.register(ref, url);
    }

    public static ProActiveComponentRepresentative lookup(String url)
        throws IOException, NamingException {
        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 {
            StubObject stub = (StubObject) ProActive.createStubObject(ProActiveComponentRepresentative.class.getName(),
                    b);
            return ProActiveComponentRepresentativeFactory.instance()
                                                          .createComponentRepresentative(stub.getProxy());
        } catch (Throwable t) {
            t.printStackTrace();
            logger.error("Could not perform lookup for component at URL: " +
                url +
                ", because construction of component representative failed." +
                t.toString());
            throw new NamingException(
                "Could not perform lookup for component at URL: " +
                url+
                ", because construction of component representative failed.");
        }
    }

    public static ProActiveGenericFactory getGenericFactory(
        final Component component) throws NoSuchInterfaceException {
        return (ProActiveGenericFactory) component.getFcInterface(
            "generic-factory");
    }

    private static class ComponentBuilderTask implements Runnable {
        List<InstantiationException> exceptions;
        List<Component> targetList;
        int indexInList;
        Type type;
        ControllerDescription controllerDesc;
        ContentDescription[] contentDesc;
        String originalName;
        Node[] nodes;

        public ComponentBuilderTask(List<InstantiationException> exceptions,
            List<Component> targetList, int indexInList, Type type,
            ControllerDescription controllerDesc, String originalName,
            ContentDescription[] contentDesc, Node[] nodes) {
            this.exceptions = exceptions;
            this.targetList = targetList;
            this.indexInList = indexInList;
            this.type = type;
            this.controllerDesc = controllerDesc;
            this.contentDesc = contentDesc;
            this.originalName = originalName;
            this.nodes = nodes;
        }

        public void run() {
            controllerDesc.setName(originalName + Constants.CYCLIC_NODE_SUFFIX +
                indexInList);
            Component instance;
            try {
                instance = Fractive.instance()
                                   .newFcInstance(type, controllerDesc,
                        contentDesc[indexInList],
                        nodes[indexInList % nodes.length]);
                //                              System.out.println("[fractive] created component " + originalName + Constants.CYCLIC_NODE_SUFFIX + indexInList);
                targetList.set(indexInList, instance);
            } catch (InstantiationException e) {
                e.printStackTrace();
                //                              targetList.add(null);
                exceptions.add(e);
            }
        }
    }

    // a utility class mocking a component
    private static class MockComponent implements Component, Serializable {
        public Object getFcInterface(String interfaceName)
            throws NoSuchInterfaceException {
            // TODO Auto-generated method stub
            return null;
        }

        public Object[] getFcInterfaces() {
            // TODO Auto-generated method stub
            return null;
        }

        public Type getFcType() {
            // TODO Auto-generated method stub
            return null;
        }
    }
}

---