path: root/sandbox/slaws/modules/domain-rework/src/main/java/org/apache/tuscany/sca/domain/rework/DomainServiceImpl.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.domain.rework;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;

import org.apache.tuscany.sca.assembly.AssemblyFactory;
import org.apache.tuscany.sca.assembly.Binding;
import org.apache.tuscany.sca.assembly.Component;
import org.apache.tuscany.sca.assembly.ComponentService;
import org.apache.tuscany.sca.assembly.Composite;
import org.apache.tuscany.sca.assembly.Reference;
import org.apache.tuscany.sca.assembly.builder.CompositeBuilder;
import org.apache.tuscany.sca.assembly.xml.CompositeProcessor;
import org.apache.tuscany.sca.assembly.xml.Constants;
import org.apache.tuscany.sca.contribution.Artifact;
import org.apache.tuscany.sca.contribution.Contribution;
import org.apache.tuscany.sca.contribution.ContributionFactory;
import org.apache.tuscany.sca.contribution.DefaultContributionFactory;
import org.apache.tuscany.sca.contribution.Export;
import org.apache.tuscany.sca.contribution.Import;
import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
import org.apache.tuscany.sca.contribution.java.JavaExport;
import org.apache.tuscany.sca.contribution.java.JavaImport;
import org.apache.tuscany.sca.contribution.namespace.NamespaceExport;
import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;
import org.apache.tuscany.sca.contribution.processor.ExtensiblePackageProcessor;
import org.apache.tuscany.sca.contribution.processor.ExtensibleStAXArtifactProcessor;
import org.apache.tuscany.sca.contribution.processor.ExtensibleURLArtifactProcessor;
import org.apache.tuscany.sca.contribution.processor.PackageProcessor;
import org.apache.tuscany.sca.contribution.processor.PackageProcessorExtensionPoint;
import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessorExtensionPoint;
import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessorExtensionPoint;
import org.apache.tuscany.sca.contribution.resolver.ExtensibleModelResolver;
import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
import org.apache.tuscany.sca.contribution.resolver.ModelResolverExtensionPoint;
import org.apache.tuscany.sca.contribution.service.ContributionException;
import org.apache.tuscany.sca.contribution.service.ContributionListenerExtensionPoint;
import org.apache.tuscany.sca.contribution.service.ContributionReadException;
import org.apache.tuscany.sca.contribution.service.ContributionRepository;
import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
import org.apache.tuscany.sca.contribution.service.ExtensibleContributionListener;
import org.apache.tuscany.sca.contribution.service.TypeDescriber;
import org.apache.tuscany.sca.contribution.service.impl.ContributionRepositoryImpl;
import org.apache.tuscany.sca.contribution.service.impl.PackageTypeDescriberImpl;
import org.apache.tuscany.sca.contribution.xml.ContributionMetadataDocumentProcessor;
import org.apache.tuscany.sca.core.ExtensionPointRegistry;
import org.apache.tuscany.sca.definitions.SCADefinitions;
import org.apache.tuscany.sca.definitions.xml.SCADefinitionsDocumentProcessor;
import org.apache.tuscany.sca.host.embedded.impl.ReallySmallRuntime;
import org.apache.tuscany.sca.implementation.node.NodeImplementation;
import org.apache.tuscany.sca.policy.PolicyFactory;
import org.apache.tuscany.sca.workspace.DefaultWorkspaceFactory;
import org.apache.tuscany.sca.workspace.Workspace;
import org.apache.tuscany.sca.workspace.WorkspaceFactory;
import org.apache.tuscany.sca.workspace.configuration.impl.NodeAssigner;
import org.apache.tuscany.sca.workspace.configuration.impl.NodeInfo;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
import org.osoa.sca.ServiceRuntimeException;
import org.osoa.sca.annotations.Property;
import org.osoa.sca.annotations.Scope;
import org.osoa.sca.annotations.Service;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

/**
 * Stores details of services exposed and retrieves details of remote services
 * 
 * @version $Rev$ $Date$
 */
@Scope("COMPOSITE")
@Service(interfaces = {DomainServiceInit.class, DomainService.class})
public class DomainServiceImpl implements DomainServiceInit, DomainService {
    
    private final static Logger logger = Logger.getLogger(DomainServiceImpl.class.getName());
    
    private ReallySmallRuntime runtime;
    private String domainURI;
    
    private File uploaded;
    private File repository;
    
    private ExtensionPointRegistry registry;
    
    private ContributionFactory contributionFactory;
    private ContributionRepository contributionRepository;
    
    private WorkspaceFactory workspaceFactory;
    private Workspace contributionWorkspace;
    
    private XMLInputFactory xmlFactory;
    private XMLOutputFactory xmlOutputFactory;
    
    private PackageProcessor packageProcessor;
    
    private ExtensibleURLArtifactProcessor artifactProcessor;
    
    private ExtensibleStAXArtifactProcessor staxProcessor;
    
    private ExtensibleContributionListener contributionListener;
    
    private ModelResolverExtensionPoint modelResolvers;
    
    private ModelFactoryExtensionPoint modelFactories;
    
    private AssemblyFactory assemblyFactory;
    
    private ModelResolver domainModelResolver;
    
    private CompositeBuilder compositeBuilder;
    
    private CompositeProcessor compositeProcessor;
    
    private PolicyFactory policyFactory;
    
    private DocumentBuilder documentBuilder;    
    
    private Composite domainComposite;
    
    @Property 
    protected String repositoryLocation;
    
    //@Reference
    //protected Collection<NodeService> nodes;    
    
    public DomainServiceImpl(){        
    }
    
    // from tuscany-runtime
    private List<URL> getJARsInFolder(File repository) {

        String[] jarNames = repository.list(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.endsWith(".jar");
            }
        });

        List<URL> contributionJars = new ArrayList<URL>();
        if (jarNames != null) {
            for (String jar : jarNames) {
                try {
                    contributionJars.add(new File(repository, jar).toURL());
                } catch (MalformedURLException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        return contributionJars;
    }
    
    // from domain impl
    private String getComposite(Composite composite){       
        ExtensionPointRegistry registry = runtime.getExtensionPointRegistry();
        
        StAXArtifactProcessorExtensionPoint staxProcessors =
            registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class);
        
        StAXArtifactProcessor<Composite> processor = staxProcessors.getProcessor(Composite.class);
        
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
            //outputFactory.setProperty("javax.xml.stream.isPrefixDefaulting",Boolean.TRUE);
            XMLStreamWriter writer = outputFactory.createXMLStreamWriter(bos);
            
            processor.write(composite, writer);
            writer.flush();
            writer.close();
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
        
        String compositeString = bos.toString();
        
        return compositeString;
    }    
    
    // from ContributionService
    private void findContributionArtifacts(Contribution contribution){
        try {
            // read contribution meta data
            URL contributionURL = new URL(contribution.getLocation());
            URL[] clUrls = {contributionURL};
            URLClassLoader cl = new URLClassLoader(clUrls, null);
    
            ContributionMetadataDocumentProcessor metadataDocumentProcessor =
                new ContributionMetadataDocumentProcessor(staxProcessor, xmlFactory);
            
            for (String path: new String[]{
                                           Contribution.SCA_CONTRIBUTION_GENERATED_META,
                                           Contribution.SCA_CONTRIBUTION_META}) {
                URL url = cl.getResource(path);
                if (url != null) {
                    Contribution tmpContribution = metadataDocumentProcessor.read(contributionURL, URI.create(path), url);
                    contribution.getImports().addAll(tmpContribution.getImports());
                    contribution.getExports().addAll(tmpContribution.getExports());
                    contribution.getDeployables().addAll(tmpContribution.getDeployables());
                }
            }
            
            // set the model resolver
            ModelResolver modelResolver = new ExtensibleModelResolver(contribution, modelResolvers, modelFactories, domainModelResolver);
            contribution.setModelResolver(modelResolver);
            
            // find all the contribution artifacts
            InputStream contributionStream = contributionURL.openStream();
            List<URI> contributionArtifacts = this.packageProcessor.getArtifacts(contributionURL, contributionStream);
            
            // add the artifacts to the contribution model
            for (URI anArtifactUri : contributionArtifacts) {
                URL artifactURL = packageProcessor.getArtifactURL(new URL(contribution.getLocation()), anArtifactUri);
                System.out.println("  Artifact URL: " + artifactURL.toString());
                Artifact artifact = contributionFactory.createArtifact();
                artifact.setURI(anArtifactUri.toString());
                artifact.setLocation(artifactURL.toString());
                contribution.getArtifacts().add(artifact);
                modelResolver.addModel(artifact);
            }
            
        } catch(Exception ex){
            logger.warning(ex.toString());
        }
    }  
    
    private void readContributionArtifacts(Contribution contribution){
        try {
            // add the artifacts to the contribution model
            for (Artifact artifact : contribution.getArtifacts()) {
                Object model = null;
                
                // WARNING - I've missed out Venkat's "applies to" function to make life a
                //           little clearer
                model = artifactProcessor.read(new URL(contribution.getLocation()), 
                                               new URI(artifact.getURI()),
                                               new URL(artifact.getLocation()));
            
                if (model != null) {
                    artifact.setModel(model);

                    // Add the loaded model to the model resolver
                    contribution.getModelResolver().addModel(model);
                    
                    if ( model instanceof Composite) {
                        ((Composite)model).setURI(artifact.getURI());
                    }
                    
                    /*
                    if ( model instanceof SCADefinitions ) {
                        contributionSCADefinitions.add((SCADefinitions)model);
                        updatePolicySetMap((SCADefinitions)model);
                    }
                    */
                }

            }
            
        } catch(Exception ex){
            logger.warning(ex.toString());
        }
    } 
    
    private void resolveContributionArtifacts(Contribution contribution){
        try {
            for (Artifact artifact : contribution.getArtifacts()) {
                // resolve the model object
                if (/*(artifact.getURI().endsWith(".composite") == false) &&*/ (artifact.getModel() != null)) {
                    artifactProcessor.resolve(artifact.getModel(), contribution.getModelResolver());
                }
            }
        } catch(Exception ex){
            logger.warning(ex.toString());
        }
    }
    
    /*
    private void resolveComposite(Contribution contribution, Composite composite){
        try {
            artifactProcessor.resolve(composite, contribution.getModelResolver());
        } catch(Exception ex){
            logger.warning(ex.toString());
        }
    }
    */
    
    

    
    /**
     * A test method to fire up the various steps in the process of handling contributions
     * So I can get to the stage of being able to process contributions
     * TODO - replace with real workspace that Sebastien is working on
     */
    public void test(){

        try {
            // set up the repository where contributions will be stored
            repository = new File(repositoryLocation);
            
            if ((!repository.exists()) || (!repository.isDirectory())){
                logger.warning("Can't find repository - " + repositoryLocation);
            }
            
            // set up the dummy location where contributions are uploaded to
            String uploadedLocation = repository.getParent() + "/uploaded";
            uploaded = new File(uploadedLocation);
            
            if ((!uploaded.exists()) || (!uploaded.isDirectory())){
                logger.warning("Can't find uploaded dir");
            }
            
            // create the repository and the workspace
            contributionRepository = new ContributionRepositoryImpl(repositoryLocation, 
                                                                    XMLInputFactory.newInstance());
            contributionWorkspace = workspaceFactory.createWorkspace();

            
            // pretend that contributions are being added by reading the list of jars in the
            // uploaded dir
            List<URL> contributionJars = getJARsInFolder(uploaded);
            
            // copy uploaded contributions to the repository
            // TODO - no clear how this relates to the workspace. Need more info on workspace
            // but for now just create a contribution model and add to the workspace
            for (URL contributionURL : contributionJars){
                String contributionName = new File(contributionURL.toURI()).getName();
                System.out.println("Processing: " + contributionName);
                
                contributionRepository.store(contributionName, contributionURL);
                
                Contribution contribution = contributionFactory.createContribution();
                contribution.setURI(contributionName);
                contribution.setLocation(contributionURL.toString());  
                
                contributionWorkspace.getContributions().add(contribution);
            }
            
            // find the artifacts in the contributions in the workspace 
            for (Contribution contribution : contributionWorkspace.getContributions()){
                findContributionArtifacts(contribution);
            }
            
            // read the artifacts in the contributions in the workspace 
            for (Contribution contribution : contributionWorkspace.getContributions()){
                readContributionArtifacts(contribution);
            }
            
            // resolve the artifacts in the contributions in the workspace 
            for (Contribution contribution : contributionWorkspace.getContributions()){
                resolveContributionArtifacts(contribution);
            }
            
            /*
            // parse the contributions into a model
            for (URL contributionURL : contributions){
                
                Contribution contribution = runtime.getContributionService().contribute(new File(contributionURL.toURI()).getName(), 
                                                                                        contributionURL, 
                                                                                        false); 
                // workspace or repository?
                //contributionRepository.addContribution(contribution);
                contributionWorkspace.getContributions().add(contribution);
            }
            */  
            
            // For interest look at contribution contents
            for (Contribution contribution : contributionWorkspace.getContributions()){
                System.out.println("Contribution URI: " + contribution.getURI());
                
                for (Artifact artifact : contribution.getArtifacts()){
                    System.out.println("  Artifact URI: " + artifact.getURI().toString());
                }
                
                // report which contribution satisfies which import
                for (Import anImport : contribution.getImports()){
                    if (anImport instanceof JavaImport){
                        System.out.println("  Java Import: " + ((JavaImport)anImport).getPackage());
                    }
                    if (anImport instanceof NamespaceImport){
                        System.out.println("  Namespace Import: " + ((NamespaceImport)anImport).getNamespace());
                    }
                    /*
                    for (Contribution importContribution : anImport.getExportContributions()){
                      System.out.println("  Import contribution: " + importContribution.getURI().toString());
                    }
                    */
                }
                
                for (Export anExport : contribution.getExports()){
                    if (anExport instanceof JavaExport){
                        System.out.println("  Java Export: " + ((JavaExport)anExport).getPackage());
                    }
                    if (anExport instanceof NamespaceExport){
                        System.out.println("  Namespace Export: " + ((NamespaceExport)anExport).getNamespace());
                    }
                }                
                
                for (Composite composite : contribution.getDeployables()){
                    System.out.println("  Deployable Composite URI: " + composite.getName().toString());
                }                
            }
            
            // create a domain level virtual composite
            AssemblyFactory assemblyFactory = runtime.getAssemblyFactory();
            domainComposite = assemblyFactory.createComposite();
            domainComposite.setName(new QName(Constants.SCA10_NS, "domainComposite"));
            domainComposite.setURI(domainURI); 
            
            // Use the deployable composite list to find the composites to load into the domain
            // TODO - there will be some selection process here
            for (Contribution contribution : contributionWorkspace.getContributions()){
                for (Composite deployableComposite : contribution.getDeployables()) {
                    Composite deployable = contribution.getModelResolver().resolveModel(Composite.class, deployableComposite);
                    domainComposite.getIncludes().add(deployable);
                }
            }
             
           
            System.out.println("\nVANILLA");
            System.out.println("========================================================================");
            writeComposite(domainComposite);
            for (Composite composite : domainComposite.getIncludes()){
                writeComposite(composite);
            }
            
            // assign individual deployed composites to nodes
            //   Use the node model on disc to do this in lieu of user input
            URL contributionURL = DomainServiceImpl.class.getClassLoader().getResource("domain/nodes.composite");
            Contribution contribution = contributionFactory.createContribution();
            contribution.setURI("nodes");
            String contributionURLString = contributionURL.toString();
            contribution.setLocation(contributionURLString.substring(0, contributionURLString.lastIndexOf("nodes.composite")));  
            
            findContributionArtifacts(contribution);
            readContributionArtifacts(contribution);
            resolveContributionArtifacts(contribution);
            
            // find node.composite
            Artifact nodeArtifact = null;
            for (Artifact artifact : contribution.getArtifacts()){
                System.out.println("  Artifact URI: " + artifact.getURI());
                if (artifact.getURI().equals("nodes.composite")){
                    nodeArtifact = artifact;
                }
            }
            
            Composite nodes = (Composite)nodeArtifact.getModel();

            // Configure the endpoints of services based on the defaults found in the 
            // nodes configuration 
            NodeAssigner nodeAssigner = new NodeAssigner(registry);
            
            for (Component node : nodes.getComponents()){
                QName compositeName = ((NodeImplementation)node.getImplementation()).getComposite().getName();
                
                Composite compositeModel = null;
                
                // find the named composite in the domain
                for (Composite deployable : domainComposite.getIncludes()){
                    if (deployable.getName().equals(compositeName)){
                        compositeModel = deployable;
                        break;
                    }
                }
                
                if (compositeModel != null){
                    // configure the composite
                    
                    NodeInfo nodeInfo = new NodeInfo(node);
                    nodeAssigner.assignEndpointsToServiceBinding(nodeInfo, compositeModel, null);
                }
            }
            
            System.out.println("\nAFTER ENDPOINT INITIALIZATION");
            System.out.println("========================================================================");
            writeComposite(domainComposite);
            for (Composite composite : domainComposite.getIncludes()){
                writeComposite(composite);
            }
            
            // build the domain composite 
            compositeBuilder.build(domainComposite);
            
            // print out the domain composite
            System.out.println("\nAFTER BUILDING");
            System.out.println("========================================================================");
            writeComposite(domainComposite);
            for (Composite composite : domainComposite.getIncludes()){
                writeComposite(composite);
            }
            
            // remove the contributions from the repository
            for (URL jarURL : contributionJars){
                contributionRepository.remove(new File(jarURL.toURI()).getName());
            }
        
        } catch (Exception ex) {
            logger.warning(ex.toString());
        }
        
    }
    
    private void writeComposite(Composite composite) throws Exception {
        // First write to a byte stream
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        XMLStreamWriter writer = xmlOutputFactory.createXMLStreamWriter(bos);
        compositeProcessor.write(composite, writer);
        
        // Parse again to pretty format the document
        Document document = documentBuilder.parse(new ByteArrayInputStream(bos.toByteArray()));
        
        OutputFormat format = new OutputFormat();
        format.setIndenting(true);
        format.setIndent(2);
        
        // Write to domain.composite
        //FileOutputStream os = new FileOutputStream(new File(compositeFileName));
        XMLSerializer serializer = new XMLSerializer(System.out, format);
        serializer.serialize(document);

    }
    
    // DomainServiceInit methods
    public void setDomainURI(String domainURI){
        this.domainURI = domainURI;
    }
    
    // We use an existing runtime to save much repeated work in this test class
    // TODO - look at how we get hold of these things for real 
    public void setRuntime(ReallySmallRuntime domainRuntime){
        try {
            this.runtime = domainRuntime;
            
            registry = runtime.getExtensionPointRegistry();
    
            xmlFactory = XMLInputFactory.newInstance();
            
            TypeDescriber describer = new PackageTypeDescriberImpl();
            packageProcessor = new ExtensiblePackageProcessor(registry.getExtensionPoint(PackageProcessorExtensionPoint.class), describer);
         
            artifactProcessor = new ExtensibleURLArtifactProcessor(registry.getExtensionPoint(URLArtifactProcessorExtensionPoint.class));
    
            staxProcessor = new ExtensibleStAXArtifactProcessor(registry.getExtensionPoint(StAXArtifactProcessorExtensionPoint.class), xmlFactory, XMLOutputFactory.newInstance());
            
            contributionListener = new ExtensibleContributionListener(registry.getExtensionPoint(ContributionListenerExtensionPoint.class));
            
            modelResolvers = registry.getExtensionPoint(ModelResolverExtensionPoint.class);
            
            modelFactories = registry.getExtensionPoint(ModelFactoryExtensionPoint.class);
            
            assemblyFactory = runtime.getAssemblyFactory();
            
            contributionFactory = new DefaultContributionFactory();
            
            workspaceFactory = new DefaultWorkspaceFactory();
            
            URLArtifactProcessorExtensionPoint documentProcessors = registry.getExtensionPoint(URLArtifactProcessorExtensionPoint.class);
            SCADefinitionsDocumentProcessor definitionsDocumentProcessor = (SCADefinitionsDocumentProcessor)documentProcessors.getProcessor(SCADefinitions.class);
            domainModelResolver = definitionsDocumentProcessor.getSCADefinitionsResolver();
            
            compositeBuilder = runtime.getCompositeBuilder();
            
            policyFactory = modelFactories.getFactory(PolicyFactory.class);
            compositeProcessor = new CompositeProcessor(contributionFactory, assemblyFactory, policyFactory, staxProcessor);
    
            xmlOutputFactory = modelFactories.getFactory(XMLOutputFactory.class);
            
            documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();        
            
            /*
            this.domainResolver = domainResolver;
            this.systemSCADefinitions = scaDefinitions; 
            */
        
        } catch (Exception ex) {
            System.out.println("Exception setting runtime on domain service " + ex.toString());
        }
    }
    
    // DomainService methods
    public List<ArtifactImpl> getContributions(){
        List<ArtifactImpl> artifacts = new ArrayList<ArtifactImpl>();
        
        for (Contribution contribution : contributionWorkspace.getContributions()){
            ArtifactImpl artifact = new ArtifactImpl();
            
            artifact.setName(contribution.getURI());
            artifact.setURL(contribution.getLocation());
            artifacts.add(artifact);
        }
        
        return artifacts;
    }
   
}