path: root/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/context/impl/AbstractAggregateContext.java

package org.apache.tuscany.core.context.impl;

import static org.apache.tuscany.core.context.EventContext.HTTP_SESSION;
import static org.apache.tuscany.core.context.EventContext.REQUEST_END;
import static org.apache.tuscany.core.context.EventContext.SESSION_NOTIFY;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import javax.wsdl.Part;

import org.apache.tuscany.common.monitor.MonitorFactory;
import org.apache.tuscany.core.builder.BuilderConfigException;
import org.apache.tuscany.core.builder.RuntimeConfiguration;
import org.apache.tuscany.core.config.ConfigurationException;
import org.apache.tuscany.core.context.AbstractContext;
import org.apache.tuscany.core.context.AggregateContext;
import org.apache.tuscany.core.context.AutowireContext;
import org.apache.tuscany.core.context.ConfigurationContext;
import org.apache.tuscany.core.context.ContextInitException;
import org.apache.tuscany.core.context.CoreRuntimeException;
import org.apache.tuscany.core.context.DuplicateNameException;
import org.apache.tuscany.core.context.EntryPointContext;
import org.apache.tuscany.core.context.EventContext;
import org.apache.tuscany.core.context.EventException;
import org.apache.tuscany.core.context.InstanceContext;
import org.apache.tuscany.core.context.QualifiedName;
import org.apache.tuscany.core.context.RuntimeEventListener;
import org.apache.tuscany.core.context.ScopeAwareContext;
import org.apache.tuscany.core.context.ScopeContext;
import org.apache.tuscany.core.context.ScopeRuntimeException;
import org.apache.tuscany.core.context.ScopeStrategy;
import org.apache.tuscany.core.context.SimpleComponentContext;
import org.apache.tuscany.core.context.TargetException;
import org.apache.tuscany.core.context.scope.DefaultScopeStrategy;
import org.apache.tuscany.core.invocation.InvocationConfiguration;
import org.apache.tuscany.core.invocation.spi.ProxyFactory;
import org.apache.tuscany.core.invocation.spi.ProxyInitializationException;
import org.apache.tuscany.core.system.annotation.Autowire;
import org.apache.tuscany.core.system.annotation.ParentContext;
import org.apache.tuscany.model.assembly.Aggregate;
import org.apache.tuscany.model.assembly.Component;
import org.apache.tuscany.model.assembly.EntryPoint;
import org.apache.tuscany.model.assembly.Extensible;
import org.apache.tuscany.model.assembly.ExternalService;
import org.apache.tuscany.model.assembly.Module;
import org.apache.tuscany.model.assembly.Scope;
import org.apache.tuscany.model.assembly.ComponentImplementation;
import org.apache.tuscany.model.assembly.impl.AssemblyFactoryImpl;

/**
 * The base implementation of an aggregate context
 * 
 * @version $Rev$ $Date$
 */
public abstract class AbstractAggregateContext extends AbstractContext implements AutowireContext, ScopeAwareContext {

    public static final int DEFAULT_WAIT = 1000 * 60;

    // ----------------------------------
    // Fields
    // ----------------------------------

    // The parent context, if one exists
    @ParentContext
    protected AggregateContext parentContext;

    // The parent configuration context, if one exists
    @Autowire(required = false)
    protected ConfigurationContext configurationContext;

    // The system monitor factory
    @Autowire(required = false)
    protected MonitorFactory monitorFactory;

    // The logical model representing the module assembly
    // protected ModuleComponent moduleComponent;
    protected Module module;

    protected Map<String, RuntimeConfiguration<InstanceContext>> configurations = new HashMap();

    // Factory for scope contexts
    @Autowire(required = false)
    protected ScopeStrategy scopeStrategy;

    // The event context for associating context events to threads
    protected EventContext eventContext;

    // The scopes for this context
    protected Map<Scope, ScopeContext> scopeContexts;

    protected Map<Scope, ScopeContext> immutableScopeContexts;

    // A component context name to scope context index
    protected Map<String, ScopeContext> scopeIndex;

    // Listeners for context events
    protected List<RuntimeEventListener> listeners = new CopyOnWriteArrayList();

    // Blocking latch to ensure the module is initialized exactly once prior to servicing requests
    protected CountDownLatch initializeLatch = new CountDownLatch(1);

    // Indicates whether the module context has been initialized
    protected boolean initialized;

    // ----------------------------------
    // Constructors
    // ----------------------------------

    public AbstractAggregateContext() {
        scopeIndex = new ConcurrentHashMap();
        // FIXME the factory should be injected
        module = new AssemblyFactoryImpl().createModule();
    }

    public AbstractAggregateContext(String name, AggregateContext parent, ScopeStrategy strategy, EventContext ctx,
            ConfigurationContext configCtx, MonitorFactory factory) {
        super(name);
        this.scopeStrategy = strategy;
        this.eventContext = ctx;
        this.configurationContext = configCtx;
        this.monitorFactory = factory;
        scopeIndex = new ConcurrentHashMap();
        parentContext = parent;
        // FIXME the factory should be injected
        module = new AssemblyFactoryImpl().createModule();
    }

    // ----------------------------------
    // Lifecycle methods
    // ----------------------------------

    public void start() {
        synchronized (initializeLatch) {
            try {
                if (lifecycleState != UNINITIALIZED && lifecycleState != STOPPED) {
                    throw new IllegalStateException("Context not in UNINITIALIZED state");
                }
                lifecycleState = INITIALIZING;
                initializeScopes();

                Map<Scope, List<RuntimeConfiguration<SimpleComponentContext>>> configurationsByScope = new HashMap();
                if (configurations != null) {
                    for (RuntimeConfiguration source : configurations.values()) {
                        // FIXME scopes are defined at the interface level
                        Scope sourceScope = source.getScope();
                        wireSource(source);
                        buildTarget(source);
                        scopeIndex.put(source.getName(), scopeContexts.get(sourceScope));
                        List<RuntimeConfiguration<SimpleComponentContext>> list = configurationsByScope.get(sourceScope);
                        if (list == null) {
                            list = new ArrayList();
                            configurationsByScope.put(sourceScope, list);
                        }
                        list.add(source);
                    }
                }
                for (EntryPoint ep : module.getEntryPoints()) {
                    registerAutowire(ep);
                }
                for (Component component : module.getComponents()) {
                    registerAutowire(component);
                }
                for (ExternalService es : module.getExternalServices()) {
                    registerAutowire(es);
                }
                for (Map.Entry entries : configurationsByScope.entrySet()) {
                    // register configurations with scope contexts
                    ScopeContext scope = scopeContexts.get(entries.getKey());
                    scope.registerConfigurations((List<RuntimeConfiguration<InstanceContext>>) entries.getValue());
                }
                initializeProxies();
                for (ScopeContext scope : scopeContexts.values()) {
                    // register scope contexts as a listeners for events in the aggregate context
                    registerListener(scope);
                    scope.start();
                }
                lifecycleState = RUNNING;
            } catch (ProxyInitializationException e) {
                lifecycleState = ERROR;
                ContextInitException cie = new ContextInitException(e);
                cie.addContextName(getName());
                throw cie;
            } catch (ConfigurationException e) {
                lifecycleState = ERROR;
                throw new ContextInitException(e);
            } catch (CoreRuntimeException e) {
                lifecycleState = ERROR;
                e.addContextName(getName());
                throw e;
            } finally {
                initialized = true;
                // release the latch and allow requests to be processed
                initializeLatch.countDown();
            }
        }
    }

    public void stop() {
        if (lifecycleState == STOPPED) {
            return;
        }
        // need to block a start until reset is complete
        initializeLatch = new CountDownLatch(2);
        lifecycleState = STOPPING;
        initialized = false;
        if (scopeContexts != null) {
            for (ScopeContext scope : scopeContexts.values()) {
                try {
                    if (scope.getLifecycleState() == ScopeContext.RUNNING) {
                        scope.stop();
                    }
                } catch (ScopeRuntimeException e) {
                    // log.error("Error stopping scope container [" + scopeContainers[i].getName() + "]", e);
                }
            }
        }
        scopeContexts = null;
        scopeIndex.clear();
        // allow initialized to be called
        initializeLatch.countDown();
        lifecycleState = STOPPED;
    }

    // ----------------------------------
    // Methods
    // ----------------------------------

    public void setModule(Module module) {
        assert (module != null) : "Module cannot be null";
        name = module.getName();
        this.module = module;
    }

    public void setScopeStrategy(ScopeStrategy scopeStrategy) {
        this.scopeStrategy = scopeStrategy;
    }

    public void setEventContext(EventContext eventContext) {
        this.eventContext = eventContext;
    }

    public void setMonitorFactory(MonitorFactory factory) {
        this.monitorFactory = factory;
    }

    public AggregateContext getParent() {
        return parentContext;
    }

    public void registerModelObjects(List<Extensible> models) throws ConfigurationException {
        assert (models != null) : "Model object collection was null";
        for (Extensible model : models) {
            registerModelObject(model);
        }
    }

    public void registerModelObject(Extensible model) throws ConfigurationException {
        assert (model != null) : "Model object was null";
        initializeScopes();
        if (configurationContext != null) {
            try {
                configurationContext.configure(model);
                configurationContext.build(this, model);
            } catch (ConfigurationException e) {
                e.addContextName(getName());
                throw e;
            } catch (BuilderConfigException e) {
                e.addContextName(getName());
                throw e;
            }
        }
        RuntimeConfiguration<InstanceContext> configuration = null;
        if (model instanceof Module) {
            // merge new module definition with the existing one
            Module oldModule = module;
            Module newModule = (Module) model;
            module = newModule;
            for (Component component : newModule.getComponents()) {
                ComponentImplementation componentImplementation = component.getComponentImplementation();
                if (componentImplementation == null) {
                    ConfigurationException e = new ConfigurationException("Component implementation not set");
                    e.addContextName(component.getName());
                    e.addContextName(getName());
                    throw e;
                }
                configuration = (RuntimeConfiguration<InstanceContext>) componentImplementation.getRuntimeConfiguration();
                if (configuration == null) {
                    ConfigurationException e = new ConfigurationException("Runtime configuration not set");
                    e.addContextName(component.getName());
                    e.addContextName(getName());
                    throw e;
                }
                registerConfiguration(configuration);
                registerAutowire(component);
            }
            for (EntryPoint ep : newModule.getEntryPoints()) {
                configuration = (RuntimeConfiguration<InstanceContext>) ep.getConfiguredReference().getRuntimeConfiguration();
                if (configuration == null) {
                    ConfigurationException e = new ConfigurationException("Runtime configuration not set");
                    e.setIdentifier(ep.getName());
                    e.addContextName(getName());
                    throw e;
                }
                registerConfiguration(configuration);
                registerAutowire(ep);
            }
            for (ExternalService service : newModule.getExternalServices()) {
                configuration = (RuntimeConfiguration<InstanceContext>) service.getConfiguredService().getRuntimeConfiguration();
                if (configuration == null) {
                    ConfigurationException e = new ConfigurationException("Runtime configuration not set");
                    e.setIdentifier(service.getName());
                    e.addContextName(getName());
                    throw e;
                }
                registerConfiguration(configuration);
                registerAutowire(service);
            }
            if (lifecycleState == RUNNING) {
                for (Component component : newModule.getComponents()) {
                    RuntimeConfiguration<InstanceContext> config = (RuntimeConfiguration<InstanceContext>) component
                            .getComponentImplementation().getRuntimeConfiguration();
                    wireSource(config);
                    buildTarget(config);
                    try {
                        if (config.getSourceProxyFactories() != null) {
                            for (ProxyFactory sourceProxyFactory : (Collection<ProxyFactory>) config.getSourceProxyFactories()
                                    .values()) {
                                sourceProxyFactory.initialize();
                            }
                        }
                        if (config.getTargetProxyFactories() != null) {
                            for (ProxyFactory targetProxyFactory : (Collection<ProxyFactory>) config.getTargetProxyFactories()
                                    .values()) {
                                targetProxyFactory.initialize();
                            }
                        }
                    } catch (ProxyInitializationException e) {
                        throw new ConfigurationException(e);
                    }

                }
                for (EntryPoint ep : newModule.getEntryPoints()) {
                    RuntimeConfiguration<InstanceContext> config = (RuntimeConfiguration<InstanceContext>) ep
                            .getConfiguredReference().getRuntimeConfiguration();
                    wireSource(config);
                    buildTarget(config);
                    try {
                        if (config.getSourceProxyFactories() != null) {
                            for (ProxyFactory sourceProxyFactory : (Collection<ProxyFactory>) config.getSourceProxyFactories()
                                    .values()) {
                                sourceProxyFactory.initialize();
                            }
                        }
                        if (config.getTargetProxyFactories() != null) {
                            for (ProxyFactory targetProxyFactory : (Collection<ProxyFactory>) config.getTargetProxyFactories()
                                    .values()) {
                                targetProxyFactory.initialize();
                            }
                        }
                    } catch (ProxyInitializationException e) {
                        throw new ConfigurationException(e);
                    }

                }
                for (ExternalService es : newModule.getExternalServices()) {
                    RuntimeConfiguration<InstanceContext> config = (RuntimeConfiguration<InstanceContext>) es
                            .getConfiguredService().getRuntimeConfiguration();
                    buildTarget(config);
                    try {
                        if (config.getSourceProxyFactories() != null) {
                            for (ProxyFactory sourceProxyFactory : (Collection<ProxyFactory>) config.getSourceProxyFactories()
                                    .values()) {
                                sourceProxyFactory.initialize();
                            }
                        }
                        if (config.getTargetProxyFactories() != null) {
                            for (ProxyFactory targetProxyFactory : (Collection<ProxyFactory>) config.getTargetProxyFactories()
                                    .values()) {
                                targetProxyFactory.initialize();
                            }
                        }
                    } catch (ProxyInitializationException e) {
                        throw new ConfigurationException(e);
                    }

                }

            }
            // merge existing module component assets
            module.getComponents().addAll(oldModule.getComponents());
            module.getEntryPoints().addAll(oldModule.getEntryPoints());
            module.getExternalServices().addAll(oldModule.getExternalServices());
        } else {
            if (model instanceof Component) {
                Component component = (Component) model;
                module.getComponents().add(component);
                configuration = (RuntimeConfiguration<InstanceContext>) component.getComponentImplementation()
                        .getRuntimeConfiguration();
            } else if (model instanceof EntryPoint) {
                EntryPoint ep = (EntryPoint) model;
                module.getEntryPoints().add(ep);
                configuration = (RuntimeConfiguration<InstanceContext>) ep.getConfiguredReference().getRuntimeConfiguration();
            } else if (model instanceof ExternalService) {
                ExternalService service = (ExternalService) model;
                module.getExternalServices().add(service);
                configuration = (RuntimeConfiguration<InstanceContext>) service.getConfiguredService().getRuntimeConfiguration();
            } else {
                BuilderConfigException e = new BuilderConfigException("Unknown model type");
                e.setIdentifier(model.getClass().getName());
                e.addContextName(getName());
                throw e;
            }
            if (configuration == null) {
                ConfigurationException e = new ConfigurationException("Runtime configuration not set");
                if (model instanceof Part) {
                    e.setIdentifier(((Part) model).getName());
                }
                e.addContextName(getName());
                throw e;
            }
            registerConfiguration(configuration);
            registerAutowire(model);
        }
    }

    protected void registerConfiguration(RuntimeConfiguration<InstanceContext> configuration) throws ConfigurationException {
        if (lifecycleState == RUNNING) {
            if (scopeIndex.get(configuration.getName()) != null) {
                throw new DuplicateNameException(configuration.getName());
            }
            ScopeContext scope = scopeContexts.get(configuration.getScope());
            if (scope == null) {
                ConfigurationException e = new ConfigurationException("Component has an unknown scope");
                e.addContextName(configuration.getName());
                e.addContextName(getName());
                throw e;
            }
            scope.registerConfiguration(configuration);
            scopeIndex.put(configuration.getName(), scope);
            configurations.put(configuration.getName(), configuration); // xcv
        } else {
            if (configurations.get(configuration.getName()) != null) {
                throw new DuplicateNameException(configuration.getName());
            }
            configurations.put(configuration.getName(), configuration);
        }

    }

    public void registerListener(RuntimeEventListener listener) {
        assert (listener != null) : "Listener cannot be null";
        listeners.add(listener);
    }

    public void fireEvent(int eventType, Object message) throws EventException {
        checkInit();
        if (eventType == SESSION_NOTIFY) {
            // update context
            eventContext.setIdentifier(HTTP_SESSION, message);
        } else if (eventType == REQUEST_END) {
            // be very careful with pooled threads, ensuring threadlocals are cleaned up
            eventContext.clearIdentifier(HTTP_SESSION);
        }
        for (RuntimeEventListener listener : listeners) {
            listener.onEvent(eventType, message);
        }
    }

    public InstanceContext getContext(String componentName) {
        checkInit();
        assert (componentName != null) : "Name was null";
        ScopeContext scope = scopeIndex.get(componentName);
        if (scope == null) {
            return null;
        }
        return scope.getContext(componentName);

    }

    public Object getInstance(QualifiedName qName) throws TargetException {
        return getInstance(qName, true);
    }

    public Object getInstance(QualifiedName qName, boolean notify) throws TargetException {
        assert (qName != null) : "Name was null ";
        // use the port name to get the context since entry points ports
        ScopeContext scope = scopeIndex.get(qName.getPortName());
        if (scope == null) {
            return null;
        }
        InstanceContext ctx = scope.getContext(qName.getPortName());
        if (!(ctx instanceof EntryPointContext)) {
            TargetException e = new TargetException("Target not an entry point");
            e.setIdentifier(qName.getQualifiedName());
            e.addContextName(name);
            throw e;
        }
        return ctx.getInstance(null, notify);
    }

    public Object locateInstance(String qualifiedName) throws TargetException {
        checkInit();
        QualifiedName qName = new QualifiedName(qualifiedName);
        ScopeContext scope = scopeIndex.get(qName.getPartName());
        if (scope == null) {
            TargetException e = new TargetException("Component not found");
            e.setIdentifier(qualifiedName);
            e.addContextName(getName());
            throw e;
        }
        InstanceContext ctx = scope.getContext(qName.getPartName());
        try {
            return ctx.getInstance(qName, true);
        } catch (TargetException e) {
            e.addContextName(getName());
            throw e;
        }
    }

    public Map<Scope, ScopeContext> getScopeContexts() {
        initializeScopes();
        return immutableScopeContexts;
    }

    // ----------------------------------
    // Abstract methods
    // ----------------------------------

    /**
     * Registers a model object as autowirable
     * 
     * @throws ContextInitException
     */
    protected abstract void registerAutowire(Extensible model) throws ConfigurationException;

    // ----------------------------------
    // Protected methods
    // ----------------------------------

    /**
     * Blocks until the module context has been initialized
     */
    protected void checkInit() {
        if (!initialized) {
            try {
                /* block until the module has initialized */
                boolean success = initializeLatch.await(DEFAULT_WAIT, TimeUnit.MILLISECONDS);
                if (!success) {
                    throw new ContextInitException("Timeout waiting for module context to initialize");
                }
            } catch (InterruptedException e) { // should not happen
            }
        }

    }

    protected void initializeScopes() {
        if (scopeContexts == null) {
            if (scopeStrategy == null) {
                scopeStrategy = new DefaultScopeStrategy();
            }
            scopeContexts = scopeStrategy.createScopes(eventContext);
            immutableScopeContexts = Collections.unmodifiableMap(scopeContexts);
        }
    }

    /**
     * Iterates through references and delegates to the configuration context to wire them to their targets
     */
    protected void wireSource(RuntimeConfiguration source) {
        Scope sourceScope = source.getScope();
        if (source.getSourceProxyFactories() != null) {
            for (ProxyFactory sourceFactory : ((Map<String, ProxyFactory>) source.getSourceProxyFactories()).values()) {
                QualifiedName targetName = sourceFactory.getProxyConfiguration().getTargetName();
                RuntimeConfiguration target = configurations.get(targetName.getPartName());
                if (target == null) {
                    ContextInitException e = new ContextInitException("Target not found");
                    e.setIdentifier(targetName.getPartName());
                    e.addContextName(source.getName());
                    e.addContextName(name);
                    throw e;
                }
                // get the proxy chain for the target
                ProxyFactory targetFactory = target.getTargetProxyFactory(sourceFactory.getProxyConfiguration().getTargetName()
                        .getPortName());
                if (targetFactory == null) {
                    ContextInitException e = new ContextInitException("No proxy factory found for service");
                    e.setIdentifier(sourceFactory.getProxyConfiguration().getTargetName().getPortName());
                    e.addContextName(target.getName());
                    e.addContextName(source.getName());
                    e.addContextName(name);
                    throw e;
                }
                boolean downScope = scopeStrategy.downScopeReference(sourceScope, target.getScope());
                configurationContext.wire(sourceFactory, targetFactory, target.getClass(), downScope, scopeContexts.get(target
                        .getScope()));
            }
        }
        // wire invokers when the proxy only contains the target chain
        if (source.getTargetProxyFactories() != null) {
            for (ProxyFactory targetFactory : ((Map<String, ProxyFactory>) source.getTargetProxyFactories()).values()) {
                configurationContext.wire(targetFactory, source.getClass(), scopeContexts.get(sourceScope));
            }
        }
        source.prepare();
    }

    /**
     * Signals to target side of reference configurations to initialize
     */
    protected void buildTarget(RuntimeConfiguration target) {
        if (target.getTargetProxyFactories() != null) {
            for (ProxyFactory targetFactory : ((Map<String, ProxyFactory>) target.getTargetProxyFactories()).values()) {
                for (InvocationConfiguration iConfig : (Collection<InvocationConfiguration>) targetFactory
                        .getProxyConfiguration().getInvocationConfigurations().values()) {
                    iConfig.build();
                }
            }
        }
    }

    protected void initializeProxies() throws ProxyInitializationException {
        for (RuntimeConfiguration config : configurations.values()) {
            if (config.getSourceProxyFactories() != null) {
                for (ProxyFactory sourceProxyFactory : (Collection<ProxyFactory>) config.getSourceProxyFactories().values()) {
                    sourceProxyFactory.initialize();
                }
            }
            if (config.getSourceProxyFactories() != null) {
                for (ProxyFactory targetProxyFactory : (Collection<ProxyFactory>) config.getTargetProxyFactories().values()) {
                    targetProxyFactory.initialize();
                }
            }
        }
    }

    /**
     * @see org.apache.tuscany.core.context.AggregateContext#getAggregate()
     */
    public Aggregate getAggregate() {
        return module;
    }
}