path: root/sca-java-2.x/contrib/modules/section10/src/main/java/org/apache/tuscany/sca/something/impl/Section10Impl.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */

package org.apache.tuscany.sca.something.impl;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.Reader;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.xml.namespace.QName;
import javax.xml.stream.XMLOutputFactory;

import org.apache.tuscany.sca.assembly.Component;
import org.apache.tuscany.sca.assembly.Composite;
import org.apache.tuscany.sca.common.java.io.IOHelper;
import org.apache.tuscany.sca.context.CompositeContext;
import org.apache.tuscany.sca.contribution.Artifact;
import org.apache.tuscany.sca.contribution.Contribution;
import org.apache.tuscany.sca.contribution.processor.ContributionReadException;
import org.apache.tuscany.sca.contribution.processor.ProcessorContext;
import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
import org.apache.tuscany.sca.core.ExtensionPointRegistry;
import org.apache.tuscany.sca.core.FactoryExtensionPoint;
import org.apache.tuscany.sca.core.UtilityExtensionPoint;
import org.apache.tuscany.sca.deployment.Deployer;
import org.apache.tuscany.sca.monitor.Monitor;
import org.apache.tuscany.sca.monitor.MonitorFactory;
import org.apache.tuscany.sca.monitor.Problem;
import org.apache.tuscany.sca.monitor.Problem.Severity;
import org.apache.tuscany.sca.node.NodeFactory;
import org.apache.tuscany.sca.node.configuration.NodeConfiguration;
import org.apache.tuscany.sca.node.impl.NodeFactoryImpl;
import org.apache.tuscany.sca.runtime.CompositeActivator;
import org.apache.tuscany.sca.runtime.DomainRegistryFactory;
import org.apache.tuscany.sca.runtime.EndpointRegistry;
import org.apache.tuscany.sca.runtime.ExtensibleDomainRegistryFactory;
import org.apache.tuscany.sca.something.Section10;
import org.oasisopen.sca.NoSuchDomainException;
import org.oasisopen.sca.NoSuchServiceException;
import org.oasisopen.sca.ServiceRuntimeException;
import org.oasisopen.sca.client.SCAClientFactory;

public class Section10Impl implements Section10 {

    protected NodeFactoryImpl nodeFactory;
    protected Map<String, InstalledContribution> installedContributions = new HashMap<String, InstalledContribution>();
    
    public Section10Impl(Properties config) {
        this.nodeFactory = (NodeFactoryImpl)NodeFactory.newInstance(config);
        ((NodeFactoryImpl)nodeFactory).start();
    }

    public String installContribution(String contributionURL) throws ContributionReadException, MalformedURLException {
        installContribution(contributionURL, contributionURL, null, true);
        return contributionURL;
    }

    public String installContribution(String contributionURL, boolean autoDeploy) throws ContributionReadException, MalformedURLException {
        installContribution(contributionURL, contributionURL, null, autoDeploy);
        return contributionURL;
    }

    public void installContribution(String uri, String contributionURL) throws ContributionReadException, MalformedURLException {
        installContribution(uri, contributionURL, null, true);
    }

    public void installContribution(String uri, String contributionURL, List<String> dependentContributionURIs) throws ContributionReadException, MalformedURLException {
        installContribution(uri, contributionURL, dependentContributionURIs, true);
    }
    
    public void installContribution(String uri, String contributionURL, List<String> dependentContributionURIs, boolean autoDeploy) throws ContributionReadException, MalformedURLException {
        Deployer deployer = nodeFactory.getDeployer();
        Monitor monitor = deployer.createMonitor();
        URL url = getLocationAsURL(contributionURL);
        Contribution contribution = deployer.loadContribution(URI.create(uri), url, monitor);
        InstalledContribution ic = new InstalledContribution(uri, url.toString(), contribution);
        installedContributions.put(uri, ic);
        if (autoDeploy) {
            for (Composite c : contribution.getDeployables()) {
                try {
                    deployComposite(c, ic);
                } catch (Throwable e) {
                    // TODO tidy up the exceptions
                    throw new RuntimeException(e);
                }
            }
        }
    }

    public String addDeploymentComposite(String contriubutionURI, String compositeXML) {
        // TODO Auto-generated method stub
        return null;
    }

    public String addDeploymentComposite(String contriubutionURI, Reader compositeXML) {
        // TODO Auto-generated method stub
        return null;
    }

    public void addToDomainLevelComposite(String compositeURI) {
        String contributionURI = getContributionUriForArtifact(compositeURI);
        InstalledContribution ic = installedContributions.get(contributionURI);
        if (ic == null) {
            throw new IllegalArgumentException("Contribution not installed: " + contributionURI);
        }
        String relativeURI = compositeURI.substring(contributionURI.length()+1);
        for (Artifact a : ic.getContribution().getArtifacts()) {
            if (a.getURI().equals(relativeURI)) {
                Composite c = (Composite) a.getModel();
                try {
                    deployComposite(c, ic);
                } catch (Throwable e) {
                    // TODO tidy up the exceptions
                    throw new RuntimeException(e);
                }
                return;
            }
        }
        throw new IllegalArgumentException("composite not found: " + compositeURI);
    }

    public void removeFromDomainLevelComposite(String compositeURI) {
        String contributionURI = getContributionUriForArtifact(compositeURI);
        InstalledContribution ic = installedContributions.get(contributionURI);
        String relativeURI = compositeURI.substring(contributionURI.length()+1);
        for (Composite c : ic.getDeployedComposites()) {
            if (relativeURI.equals(c.getURI())) {
                undeployComposite(c, ic);
                return;
            }
        }
        throw new IllegalStateException("composite not deployed: " + compositeURI);
    }

    public Composite getDomainLevelComposite() {
        // TODO Auto-generated method stub
        return null;
    }

    public String getDomainLevelCompositeAsString() {
        StAXArtifactProcessorExtensionPoint xmlProcessors = getExtensionRegistry().getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
        StAXArtifactProcessor<Composite>  compositeProcessor = xmlProcessors.getProcessor(Composite.class);   
        return writeComposite(getDomainLevelComposite(), compositeProcessor);
    }

    public Object getQNameDefinition(String contributionURI, QName definition, QName symbolSpace) {
        // TODO Auto-generated method stub
        return null;
    }

    public void removeContribution(String contributionURI) {
        // TODO: what about dependent contributions
        InstalledContribution ic = installedContributions.remove(contributionURI);
        if (ic == null) {
            throw new IllegalArgumentException("Contribution not installed: " + contributionURI);
        }
        for (Composite c : ic.getDeployedComposites()) {
            undeployComposite(c, ic);
        }
    }

    public void updateContribution(String uri, String contributionURL) {
        // TODO Auto-generated method stub
        // is this just removeContribution/installContribution?
    }

    public String updateDeploymentComposite(String uri, String compositeXML) {
        // TODO Auto-generated method stub
        // is this removeFromDomainLevelComposite/addDeploymentComposite
        return null;
    }

    public String updateDeploymentComposite(String uri, Reader compositeXML) {
        // TODO Auto-generated method stub
        // is this removeFromDomainLevelComposite/addDeploymentComposite
        return null;
    }

    public void shutdown() {
        nodeFactory.destroy();
    }

    public <T> T getService(Class<T> interfaze, String serviceURI) throws NoSuchServiceException {
        try {
            return SCAClientFactory.newInstance(URI.create(getDomainName())).getService(interfaze, serviceURI);
        } catch (NoSuchDomainException e) {
            // shouldn't ever happen as we know this is the domain so it must exist
            throw new IllegalStateException(e);
        }
    }
   
    public String getDomainName() {
        // TODO Auto-generated method stub
        return "default";
    }

    public List<String> getDeployedCompostes(String contributionURI) {
        // TODO Auto-generated method stub
        return null;
    }

    public List<String> getInstalledContributions(String contributionURI) {
        // TODO Auto-generated method stub
        return null;
    }

    protected String getContributionUriForArtifact(String artifactURI) {
        String contributionURI = null;
        for (String uri : installedContributions.keySet()) {
            if (artifactURI.startsWith(uri)) {
                contributionURI = uri;
                break;
            }
        }
        if (contributionURI == null) {
            throw new IllegalArgumentException("no contribution found for: " + artifactURI);
        }
        return contributionURI;
    }

    protected void deployComposite(Composite c, InstalledContribution ic) throws Throwable {
        // TODO Auto-generated method stub
        
        UtilityExtensionPoint utilities = getExtensionRegistry().getExtensionPoint(UtilityExtensionPoint.class);
        CompositeActivator compositeActivator = utilities.getUtility(CompositeActivator.class);
        MonitorFactory monitorFactory = utilities.getUtility(MonitorFactory.class);

        DomainRegistryFactory domainRegistryFactory = ExtensibleDomainRegistryFactory.getInstance(getExtensionRegistry());
        EndpointRegistry endpointRegistry = domainRegistryFactory.getEndpointRegistry("default", getDomainName());
        
        Monitor monitor = monitorFactory.createMonitor();
        ProcessorContext context = new ProcessorContext(monitor);
        
        Composite domainComposite;
        CompositeContext compositeContext;
        Monitor tcm = monitorFactory.setContextMonitor(monitor);
        try {

            NodeConfiguration configuration;
            List<Contribution> allContributions = new ArrayList<Contribution>();
            for (InstalledContribution ics : installedContributions.values()) {
                allContributions.add(ics.getContribution());
            }
            
            List<Contribution> contributions = new ArrayList<Contribution>();
            contributions.add(ic.getContribution());
            contributions.get(0).getDeployables().clear();
            contributions.get(0).getDeployables().add(c);
            domainComposite = nodeFactory.getDeployer().build(contributions, allContributions, new HashMap<QName, List<String>>(), monitor);
            analyzeProblems(monitor);

            compositeContext = new CompositeContext(getExtensionRegistry(), 
                                     endpointRegistry, 
                                     domainComposite, 
                                     getDomainName(), 
                                     "whatIsThisURIfor",
                                     nodeFactory.getDeployer().getSystemDefinitions());
            
            CompositeContext.setThreadCompositeContext(compositeContext);
        } finally {
            monitorFactory.setContextMonitor(tcm);
        }
        
        compositeActivator.activate(compositeContext, domainComposite);
        compositeActivator.start(compositeContext, domainComposite);

        ic.getDeployedComposites().add(c);
    }

    protected void undeployComposite(Composite c, InstalledContribution ic) {
        ic.getDeployedComposites().remove(c);
        // TODO Auto-generated method stub
    }

    protected ExtensionPointRegistry getExtensionRegistry() {
        ExtensionPointRegistry reg = nodeFactory.getExtensionPointRegistry();
        return reg;
    }

    protected String writeComposite(Composite composite, StAXArtifactProcessor<Composite> compositeProcessor){
        XMLOutputFactory outputFactory = getExtensionRegistry().getExtensionPoint(FactoryExtensionPoint.class).getFactory(XMLOutputFactory.class);
        
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            compositeProcessor.write(composite, outputFactory.createXMLStreamWriter(bos), new ProcessorContext(getExtensionRegistry()));
        } catch(Exception e) {
            throw new RuntimeException(e);
        }
        
        String result = bos.toString();
        
        // write out and nested composites
        for (Component component : composite.getComponents()) {
            if (component.getImplementation() instanceof Composite) {
                result += "\n<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->\n";
                result += writeComposite((Composite)component.getImplementation(), compositeProcessor);
            }
        }
        
        return result;
    }

    protected URL getLocationAsURL(String location) throws MalformedURLException {
        URI uri = IOHelper.createURI(location);
        if (uri.getScheme() == null) {
            uri = new File(location).toURI();
        }
        URL url = uri.toURL();
        return url;
    }
    
    protected void analyzeProblems(Monitor monitor) throws Throwable {
        try {
            for (Problem problem : monitor.getProblems()) {
                if ((problem.getSeverity() == Severity.ERROR)) {
                    if (problem.getCause() != null) {
                        throw problem.getCause();
                    } else {
                        throw new ServiceRuntimeException(problem.toString());
                    }
                }
            }
        } finally {
            // FIXME: Clear problems so that the monitor is clean again
            monitor.reset();
        }
    }

}