Move Tuscany from Incubator to top level.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 1307 insertions, 0 deletions

diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLConstants.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLConstants.java
new file mode 100644
index 0000000000..7de5d5349f
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLConstants.java
@@ -0,0 +1,35 @@
+/*
+ * 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.interfacedef.wsdl.xml;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.xml.Constants;
+
+public interface WSDLConstants {
+
+    String INTERFACE_WSDL = "interface.wsdl";
+    QName INTERFACE_WSDL_QNAME = new QName(Constants.SCA10_NS, "interface.wsdl");
+    String INTERFACE = "interface";
+    String CALLBACK_INTERFACE = "callbackInterface";
+    String WSDL_LOCATION = "wsdlLocation";
+    String WSDLI_NS = "http://www.w3.org/2004/08/wsdl-instance";
+    QName WSDL_LOCATION_QNAME = new QName(WSDLI_NS, WSDL_LOCATION); 
+
+}
diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLDocumentProcessor.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLDocumentProcessor.java
new file mode 100644
index 0000000000..202a5ad8a4
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLDocumentProcessor.java
@@ -0,0 +1,187 @@
+/*
+ * 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.interfacedef.wsdl.xml;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.util.List;
+
+import javax.wsdl.Definition;
+import javax.wsdl.Import;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory;
+import org.apache.tuscany.sca.interfacedef.wsdl.XSDefinition;
+
+/**
+ * An ArtifactProcessor for WSDL documents.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WSDLDocumentProcessor implements URLArtifactProcessor<WSDLDefinition> {
+
+    public static final QName WSDL11 = new QName("http://schemas.xmlsoap.org/wsdl/", "definitions");
+    public static final QName WSDL11_IMPORT = new QName("http://schemas.xmlsoap.org/wsdl/", "import");
+    public static final QName XSD = new QName("http://www.w3.org/2001/XMLSchema", "schema");
+
+    private final static XMLInputFactory inputFactory = XMLInputFactory.newInstance();
+
+    private WSDLFactory factory;
+
+    public WSDLDocumentProcessor(ModelFactoryExtensionPoint modelFactories) {
+        this.factory = modelFactories.getFactory(WSDLFactory.class);
+    }
+
+    public WSDLDefinition read(URL contributionURL, URI artifactURI, URL artifactURL) throws ContributionReadException {
+        try {
+            return indexRead(artifactURL);
+        } catch (Exception e) {
+            throw new ContributionReadException(e);
+        }
+    }
+
+    public void resolve(WSDLDefinition model, ModelResolver resolver) throws ContributionResolveException {
+        Definition definition = model.getDefinition();
+        if (definition != null) {
+            for (Object imports : definition.getImports().values()) {
+                List importList = (List)imports;
+                for (Object i : importList) {
+                    Import imp = (Import)i;
+                    if (imp.getDefinition() != null) {
+                        continue;
+                    }
+                    if (imp.getLocationURI() == null) {
+                        // FIXME: [rfeng] By the WSDL 1.1 spec, the location attribute is required
+                        // We need to resolve it by QName
+                        WSDLDefinition proxy = factory.createWSDLDefinition();
+                        proxy.setUnresolved(true);
+                        proxy.setNamespace(imp.getNamespaceURI());
+                        WSDLDefinition resolved = resolver.resolveModel(WSDLDefinition.class, proxy);
+                        if (resolved != null && !resolved.isUnresolved()) {
+                            imp.setDefinition(resolved.getDefinition());
+                        }
+                    } else {
+                        String location = imp.getLocationURI();
+                        URI uri = URI.create(location);
+                        if (uri.isAbsolute()) {
+                            WSDLDefinition resolved;
+                            try {
+                                resolved = read(null, uri, uri.toURL());
+                                imp.setDefinition(resolved.getDefinition());
+                            } catch (Exception e) {
+                                throw new ContributionResolveException(e);
+                            }
+                        } else {
+                            if (location.startsWith("/")) {
+                                // This is a relative URI against a contribution
+                                location = location.substring(1);
+                                // TODO: Need to resolve it against the contribution
+                            } else {
+                                // This is a relative URI against the WSDL document
+                                URI baseURI = URI.create(model.getDefinition().getDocumentBaseURI());
+                                URI locationURI = baseURI.resolve(location);
+                                WSDLDefinition resolved;
+                                try {
+                                    resolved = read(null, locationURI, locationURI.toURL());
+                                    imp.setDefinition(resolved.getDefinition());
+                                } catch (Exception e) {
+                                    throw new ContributionResolveException(e);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public String getArtifactType() {
+        return ".wsdl";
+    }
+
+    public Class<WSDLDefinition> getModelType() {
+        return WSDLDefinition.class;
+    }
+
+    /**
+     * Read the namespace for the WSDL definition and inline schemas
+     * 
+     * @param doc
+     * @return
+     * @throws IOException
+     * @throws XMLStreamException
+     */
+    protected WSDLDefinition indexRead(URL doc) throws Exception {
+        WSDLDefinition wsdlDefinition = factory.createWSDLDefinition();
+        wsdlDefinition.setUnresolved(true);
+        wsdlDefinition.setLocation(doc.toURI());
+
+        InputStream is = doc.openStream();
+        try {
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+            int eventType = reader.getEventType();
+            int index = 0;
+            while (true) {
+                if (eventType == XMLStreamConstants.START_ELEMENT) {
+                    if (WSDL11.equals(reader.getName())) {
+                        String tns = reader.getAttributeValue(null, "targetNamespace");
+                        wsdlDefinition.setNamespace(tns);
+                        // The definition is marked as resolved but not loaded
+                        wsdlDefinition.setUnresolved(false);
+                        wsdlDefinition.setDefinition(null);
+                    }
+                    if (XSD.equals(reader.getName())) {
+                        String tns = reader.getAttributeValue(null, "targetNamespace");
+                        XSDefinition xsd = factory.createXSDefinition();
+                        xsd.setUnresolved(true);
+                        xsd.setNamespace(tns);
+                        xsd.setLocation(URI.create(doc.toURI() + "#" + index));
+                        index++;
+                        // The definition is marked as resolved but not loaded
+                        xsd.setUnresolved(false);
+                        xsd.setSchema(null);
+                        wsdlDefinition.getXmlSchemas().add(xsd);
+                    }
+                }
+                if (reader.hasNext()) {
+                    eventType = reader.next();
+                } else {
+                    break;
+                }
+            }
+            return wsdlDefinition;
+        } finally {
+            is.close();
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLInterfaceProcessor.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLInterfaceProcessor.java
new file mode 100644
index 0000000000..45ae17b784
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLInterfaceProcessor.java
@@ -0,0 +1,182 @@
+/*
+ * 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.interfacedef.wsdl.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+
+import javax.wsdl.PortType;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.xml.Constants;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterface;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterfaceContract;
+
+public class WSDLInterfaceProcessor implements StAXArtifactProcessor<WSDLInterfaceContract>, WSDLConstants {
+
+    private WSDLFactory wsdlFactory;
+
+    public WSDLInterfaceProcessor(ModelFactoryExtensionPoint modelFactories) {
+        this.wsdlFactory = modelFactories.getFactory(WSDLFactory.class);
+    }
+    
+    /**
+     * Create a WSDL interface from a URI.
+     * @param uri
+     * @return
+     * @throws ContributionReadException
+     */
+    private WSDLInterface createWSDLInterface(String uri) throws ContributionReadException {
+        WSDLInterface wsdlInterface = wsdlFactory.createWSDLInterface();
+        wsdlInterface.setUnresolved(true);
+
+        // Read a qname in the form:
+        // namespace#wsdl.interface(name)
+        int index = uri.indexOf('#');
+        if (index == -1) {
+            throw new ContributionReadException("Invalid WSDL interface attribute: " + uri);
+        }
+        String namespace = uri.substring(0, index);
+        String name = uri.substring(index + 1);
+        name = name.substring("wsdl.interface(".length(), name.length() - 1);
+        wsdlInterface.setName(new QName(namespace, name));
+        
+        return wsdlInterface;
+    }
+
+    public WSDLInterfaceContract read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        // Read an <interface.wsdl>
+        WSDLInterfaceContract wsdlInterfaceContract = wsdlFactory.createWSDLInterfaceContract();
+        
+        // Read wsdlLocation
+        String location = reader.getAttributeValue(WSDLI_NS, WSDL_LOCATION);
+        wsdlInterfaceContract.setLocation(location);
+        
+        String uri = reader.getAttributeValue(null, INTERFACE);
+        if (uri != null) {
+            WSDLInterface wsdlInterface = createWSDLInterface(uri);
+            wsdlInterfaceContract.setInterface(wsdlInterface);
+        }
+        
+        uri = reader.getAttributeValue(null, CALLBACK_INTERFACE);
+        if (uri != null) {
+            WSDLInterface wsdlCallbackInterface = createWSDLInterface(uri);
+            wsdlInterfaceContract.setCallbackInterface(wsdlCallbackInterface);
+        }
+            
+        // Skip to end element
+        while (reader.hasNext()) {
+            if (reader.next() == END_ELEMENT && INTERFACE_WSDL_QNAME.equals(reader.getName())) {
+                break;
+            }
+        }
+        return wsdlInterfaceContract;
+    }
+    
+    public void write(WSDLInterfaceContract wsdlInterfaceContract, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+        // Write an <interface.wsdl>
+        writer.writeStartElement(Constants.SCA10_NS, INTERFACE_WSDL);
+
+        // Write interface name
+        WSDLInterface wsdlInterface = (WSDLInterface)wsdlInterfaceContract.getInterface();
+        if (wsdlInterface != null) {
+            QName qname = wsdlInterface.getName();
+            String uri = qname.getNamespaceURI() + "#wsdl.interface(" + qname.getLocalPart() + ")";
+            writer.writeAttribute(INTERFACE, uri);
+        }
+
+        WSDLInterface wsdlCallbackInterface = (WSDLInterface)wsdlInterfaceContract.getCallbackInterface();
+        if (wsdlCallbackInterface != null) {
+            QName qname = wsdlCallbackInterface.getName();
+            String uri = qname.getNamespaceURI() + "#wsdl.interface(" + qname.getLocalPart() + ")";
+            writer.writeAttribute(CALLBACK_INTERFACE, uri);
+        }
+        
+        // Write location
+        if (wsdlInterfaceContract.getLocation() != null) {
+            writer.writeAttribute(WSDLI_NS, WSDL_LOCATION, wsdlInterfaceContract.getLocation());
+        }
+        
+        writer.writeEndElement();
+    }
+    
+    private WSDLInterface resolveWSDLInterface(WSDLInterface wsdlInterface, ModelResolver resolver) throws ContributionResolveException {
+        
+        if (wsdlInterface != null && wsdlInterface.isUnresolved()) {
+
+            // Resolve the WSDL interface
+            wsdlInterface = resolver.resolveModel(WSDLInterface.class, wsdlInterface);
+            if (wsdlInterface.isUnresolved()) {
+
+                // If the WSDL interface has never been resolved yet, do it now
+                // First, resolve the WSDL definition for the given namespace
+                WSDLDefinition wsdlDefinition = wsdlFactory.createWSDLDefinition();
+                wsdlDefinition.setUnresolved(true);
+                wsdlDefinition.setNamespace(wsdlInterface.getName().getNamespaceURI());
+                wsdlDefinition = resolver.resolveModel(WSDLDefinition.class, wsdlDefinition);
+                if (!wsdlDefinition.isUnresolved()) {
+                    PortType portType = wsdlDefinition.getDefinition().getPortType(wsdlInterface.getName());
+                    if (portType != null) {
+                        
+                        // Introspect the WSDL portType and add the resulting
+                        // WSDLInterface to the resolver
+                        try {
+                            wsdlInterface = wsdlFactory.createWSDLInterface(portType, wsdlDefinition, resolver);
+                        } catch (InvalidInterfaceException e) {
+                            throw new ContributionResolveException(e);
+                        }
+                        resolver.addModel(wsdlInterface);
+                        wsdlInterface.setWsdlDefinition(wsdlDefinition);
+                    }
+                }
+            }
+        }
+        return wsdlInterface;
+    }
+    
+    public void resolve(WSDLInterfaceContract wsdlInterfaceContract, ModelResolver resolver) throws ContributionResolveException {
+        
+        // Resolve the interface and callback interface
+        WSDLInterface wsdlInterface = resolveWSDLInterface((WSDLInterface)wsdlInterfaceContract.getInterface(), resolver);
+        wsdlInterfaceContract.setInterface(wsdlInterface);
+        
+        WSDLInterface wsdlCallbackInterface = resolveWSDLInterface((WSDLInterface)wsdlInterfaceContract.getCallbackInterface(), resolver);
+        wsdlInterfaceContract.setCallbackInterface(wsdlCallbackInterface);
+    }
+    
+    public QName getArtifactType() {
+        return WSDLConstants.INTERFACE_WSDL_QNAME;
+    }
+    
+    public Class<WSDLInterfaceContract> getModelType() {
+        return WSDLInterfaceContract.class;
+    }
+}
diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLModelResolver.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLModelResolver.java
new file mode 100644
index 0000000000..877133735a
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/WSDLModelResolver.java
@@ -0,0 +1,408 @@
+/*

+ * 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.interfacedef.wsdl.xml;

+

+import java.io.IOException;

+import java.io.InputStream;

+import java.net.URI;

+import java.net.URL;

+import java.util.ArrayList;

+import java.util.Arrays;

+import java.util.HashMap;

+import java.util.List;

+import java.util.Map;

+

+import javax.wsdl.Definition;

+import javax.wsdl.Types;

+import javax.wsdl.WSDLException;

+import javax.wsdl.extensions.ExtensibilityElement;

+import javax.wsdl.extensions.ExtensionDeserializer;

+import javax.wsdl.extensions.ExtensionRegistry;

+import javax.wsdl.extensions.ExtensionSerializer;

+import javax.wsdl.extensions.UnknownExtensibilityElement;

+import javax.wsdl.extensions.UnknownExtensionDeserializer;

+import javax.wsdl.extensions.UnknownExtensionSerializer;

+import javax.wsdl.extensions.schema.Schema;

+import javax.wsdl.xml.WSDLLocator;

+import javax.wsdl.xml.WSDLReader;

+import javax.xml.namespace.QName;

+

+import org.apache.tuscany.sca.contribution.Contribution;

+import org.apache.tuscany.sca.contribution.ContributionFactory;

+import org.apache.tuscany.sca.contribution.DeployedArtifact;

+import org.apache.tuscany.sca.contribution.Import;

+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;

+import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;

+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;

+import org.apache.tuscany.sca.contribution.service.ContributionReadException;

+import org.apache.tuscany.sca.contribution.service.ContributionRuntimeException;

+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition;

+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory;

+import org.apache.tuscany.sca.interfacedef.wsdl.XSDefinition;

+import org.w3c.dom.Attr;

+import org.w3c.dom.Document;

+import org.w3c.dom.Element;

+import org.w3c.dom.NamedNodeMap;

+import org.w3c.dom.Node;

+import org.xml.sax.InputSource;

+

+/**

+ * A Model Resolver for WSDL models.

+ * 

+ * @version $Rev: 557916 $ $Date: 2007-07-20 01:04:40 -0700 (Fri, 20 Jul 2007) $

+ */

+public class WSDLModelResolver implements ModelResolver {

+    //Schema element names

+    public static final String ELEM_SCHEMA = "schema";

+

+    //Schema uri

+    public static final String NS_URI_XSD_1999 = "http://www.w3.org/1999/XMLSchema";

+    public static final String NS_URI_XSD_2000 = "http://www.w3.org/2000/10/XMLSchema";

+    public static final String NS_URI_XSD_2001 = "http://www.w3.org/2001/XMLSchema";

+

+    //Schema qnames

+    public static final QName Q_ELEM_XSD_1999 = new QName(NS_URI_XSD_1999, ELEM_SCHEMA);

+    public static final QName Q_ELEM_XSD_2000 = new QName(NS_URI_XSD_2000, ELEM_SCHEMA);

+    public static final QName Q_ELEM_XSD_2001 = new QName(NS_URI_XSD_2001, ELEM_SCHEMA);

+    public static final List<QName> XSD_QNAME_LIST =

+        Arrays.asList(new QName[] {Q_ELEM_XSD_1999, Q_ELEM_XSD_2000, Q_ELEM_XSD_2001});

+

+    private Contribution contribution;

+    private Map<String, List<WSDLDefinition>> map = new HashMap<String, List<WSDLDefinition>>();

+

+    private ExtensionRegistry wsdlExtensionRegistry;

+

+    private WSDLFactory wsdlFactory;

+    private javax.wsdl.factory.WSDLFactory wsdl4jFactory;

+    private ContributionFactory contributionFactory;

+

+    public WSDLModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {

+        this.contribution = contribution;

+

+        this.wsdlFactory = modelFactories.getFactory(WSDLFactory.class);

+        this.wsdl4jFactory = modelFactories.getFactory(javax.wsdl.factory.WSDLFactory.class);

+        this.contributionFactory = modelFactories.getFactory(ContributionFactory.class);

+

+        wsdlExtensionRegistry = this.wsdl4jFactory.newPopulatedExtensionRegistry();

+        // REVIEW: [rfeng] Disable the schema extension for WSDL4J to avoid aggressive loading 

+        ExtensionDeserializer deserializer = new UnknownExtensionDeserializer();

+        ExtensionSerializer serializer = new UnknownExtensionSerializer();

+        for (QName schema : XSD_QNAME_LIST) {

+            wsdlExtensionRegistry.registerSerializer(Types.class, schema, serializer);

+            wsdlExtensionRegistry.registerDeserializer(Types.class, schema, deserializer);

+        }

+    }

+

+    /**

+     * Implementation of a WSDL locator.

+     */

+    private class WSDLLocatorImpl implements WSDLLocator {

+        private InputStream inputStream;

+        private URL base;

+        private String latestImportURI;

+

+        public WSDLLocatorImpl(URL base, InputStream is) {

+            this.base = base;

+            this.inputStream = is;

+        }

+

+        public void close() {

+            try {

+                inputStream.close();

+            } catch (IOException e) {

+                // Ignore

+            }

+        }

+

+        public InputSource getBaseInputSource() {

+            try {

+                return XMLDocumentHelper.getInputSource(base, inputStream);

+            } catch (IOException e) {

+                throw new IllegalArgumentException(e);

+            }

+        }

+

+        public String getBaseURI() {

+            return base.toString();

+        }

+

+        public InputSource getImportInputSource(String parentLocation, String importLocation) {

+            try {

+                if (importLocation == null) {

+                    throw new IllegalArgumentException("Required attribute 'location' is missing.");

+                }

+

+                URL url = null;

+                if (importLocation.startsWith("/")) {

+                    // The URI is relative to the contribution

+                    String uri = importLocation.substring(1);

+

+                    DeployedArtifact proxyArtifact = contributionFactory.createDeployedArtifact();

+                    proxyArtifact.setURI(uri);

+

+                    //use contribution resolution (this supports import/export)

+                    DeployedArtifact importedArtifact =

+                        contribution.getModelResolver().resolveModel(DeployedArtifact.class, proxyArtifact);

+                    if (importedArtifact.getLocation() != null) {

+                        //get the artifact URL

+                        url = new URL(importedArtifact.getLocation());

+                    }

+                } else {

+                    url = new URL(new URL(parentLocation), importLocation);

+                }

+                if (url == null) {

+                    return null;

+                }

+                latestImportURI = url.toString();

+                return XMLDocumentHelper.getInputSource(url);

+            } catch (Exception e) {

+                throw new ContributionRuntimeException(e);

+            }

+        }

+

+        public String getLatestImportURI() {

+            return latestImportURI;

+        }

+

+    }

+

+    public void addModel(Object resolved) {

+        WSDLDefinition definition = (WSDLDefinition)resolved;

+        for (XSDefinition d : definition.getXmlSchemas()) {

+            if (contribution != null) {

+                contribution.getModelResolver().addModel(d);

+            }

+        }

+        List<WSDLDefinition> list = map.get(definition.getNamespace());

+        if (list == null) {

+            list = new ArrayList<WSDLDefinition>();

+            map.put(definition.getNamespace(), list);

+        }

+        list.add(definition);

+    }

+

+    public Object removeModel(Object resolved) {

+        WSDLDefinition definition = (WSDLDefinition)resolved;

+        List<WSDLDefinition> list = map.get(definition.getNamespace());

+        if (list == null) {

+            return null;

+        } else {

+            return list.remove(definition);

+        }

+    }

+

+    /**

+     * Create a facade Definition which imports all the defintions

+     * 

+     * @param definitions A list of the WSDL definitions under the same target namespace

+     * @return The aggregated WSDL definition

+     */

+    private WSDLDefinition aggregate(List<WSDLDefinition> definitions) {

+        if (definitions == null || definitions.size() == 0) {

+            return null;

+        }

+        if (definitions.size() == 1) {

+            WSDLDefinition d = definitions.get(0);

+            loadOnDemand(d);

+            return d;

+        }

+        WSDLDefinition aggregated = wsdlFactory.createWSDLDefinition();

+        for (WSDLDefinition d : definitions) {

+            loadOnDemand(d);

+        }

+        Definition facade = wsdl4jFactory.newDefinition();

+        String ns = definitions.get(0).getNamespace();

+        facade.setQName(new QName(ns, "$aggregated$"));

+        facade.setTargetNamespace(ns);

+

+        for (WSDLDefinition d : definitions) {

+            if (d.getDefinition() != null) {

+                javax.wsdl.Import imp = facade.createImport();

+                imp.setNamespaceURI(d.getNamespace());

+                imp.setDefinition(d.getDefinition());

+                imp.setLocationURI(d.getDefinition().getDocumentBaseURI());

+                facade.addImport(imp);

+                aggregated.getXmlSchemas().addAll(d.getXmlSchemas());

+            }

+        }

+        aggregated.setDefinition(facade);

+        definitions.clear();

+        definitions.add(aggregated);

+        return aggregated;

+    }

+

+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {

+

+        // Lookup a definition for the given namespace

+        String namespace = ((WSDLDefinition)unresolved).getNamespace();

+        List<WSDLDefinition> list = map.get(namespace);

+        WSDLDefinition resolved = aggregate(list);

+        if (resolved != null && !resolved.isUnresolved()) {

+            return modelClass.cast(resolved);

+        }

+

+        // No definition found, delegate the resolution to the imports

+        for (Import import_ : this.contribution.getImports()) {

+            if (import_ instanceof NamespaceImport) {

+                NamespaceImport namespaceImport = (NamespaceImport)import_;

+                if (namespaceImport.getNamespace().equals(namespace)) {

+

+                    // Delegate the resolution to the import resolver

+                    resolved =

+                        namespaceImport.getModelResolver().resolveModel(WSDLDefinition.class,

+                                                                        (WSDLDefinition)unresolved);

+                    if (!resolved.isUnresolved()) {

+                        return modelClass.cast(resolved);

+                    }

+                }

+            }

+        }

+        return modelClass.cast(unresolved);

+    }

+

+    /**

+     * Load the WSDL definition on demand

+     * @param def

+     */

+    private void loadOnDemand(WSDLDefinition def) {

+        if (def.getDefinition() == null && def.getLocation() != null) {

+            // Load the definition on-demand

+            try {

+                loadDefinition(def);

+            } catch (ContributionReadException e) {

+                throw new RuntimeException(e);

+            }

+        }

+    }

+

+    // private Map<String, WSDLDefinition> loadedDefinitions = new Hashtable<String, WSDLDefinition>();

+

+    /**

+     * Load the WSDL definition and inline schemas

+     * 

+     * @param wsdlDef

+     * @throws ContributionReadException

+     */

+    private void loadDefinition(WSDLDefinition wsdlDef) throws ContributionReadException {

+        if (wsdlDef.getDefinition() != null || wsdlDef.getLocation() == null) {

+            return;

+        }

+        try {

+            URL artifactURL = wsdlDef.getLocation().toURL();

+            // Read a WSDL document

+            InputStream is = artifactURL.openStream();

+            WSDLReader reader = wsdl4jFactory.newWSDLReader();

+            reader.setFeature("javax.wsdl.verbose", false);

+            reader.setFeature("javax.wsdl.importDocuments", true);

+            // FIXME: We need to decide if we should disable the import processing by WSDL4J

+            // reader.setFeature("javax.wsdl.importDocuments", false);

+            reader.setExtensionRegistry(wsdlExtensionRegistry);

+

+            WSDLLocatorImpl locator = new WSDLLocatorImpl(artifactURL, is);

+            Definition definition = reader.readWSDL(locator);

+            wsdlDef.setDefinition(definition);

+

+            //Read inline schemas 

+            readInlineSchemas(wsdlDef, definition);

+        } catch (WSDLException e) {

+            throw new ContributionReadException(e);

+        } catch (IOException e) {

+            throw new ContributionReadException(e);

+        }

+    }

+

+    private Document promote(Element element) {

+        Document doc = (Document)element.getOwnerDocument().cloneNode(false);

+        Element schema = (Element)doc.importNode(element, true);

+        doc.appendChild(schema);

+        Node parent = element.getParentNode();

+        while (parent instanceof Element) {

+            Element root = (Element)parent;

+            NamedNodeMap nodeMap = root.getAttributes();

+            for (int i = 0; i < nodeMap.getLength(); i++) {

+                Attr attr = (Attr)nodeMap.item(i);

+                String name = attr.getName();

+                if ("xmlns".equals(name) || name.startsWith("xmlns:")) {

+                    if (schema.getAttributeNode(name) == null) {

+                        schema.setAttributeNodeNS((Attr)doc.importNode(attr, true));

+                    }

+                }

+            }

+            parent = parent.getParentNode();

+        }

+        doc.setDocumentURI(element.getOwnerDocument().getDocumentURI());

+        return doc;

+    }

+

+    /**

+     * Populate the inline schemas including those from the imported definitions

+     * 

+     * @param definition

+     * @param schemaCollection

+     */

+    private void readInlineSchemas(WSDLDefinition wsdlDefinition, Definition definition) {

+        if (contribution == null) {

+            // Check null for test cases

+            return;

+        }

+        Types types = definition.getTypes();

+        if (types != null) {

+            int index = 0;

+            for (Object ext : types.getExtensibilityElements()) {

+                ExtensibilityElement extElement = (ExtensibilityElement)ext;

+                Element element = null;

+                if (XSD_QNAME_LIST.contains(extElement.getElementType())) {

+                    if (extElement instanceof Schema) {

+                        element = ((Schema)extElement).getElement();

+                    } else if (extElement instanceof UnknownExtensibilityElement) {

+                        element = ((UnknownExtensibilityElement)extElement).getElement();

+                    }

+                }

+                if (element != null) {

+                    Document doc = promote(element);

+                    XSDefinition xsDefinition = wsdlFactory.createXSDefinition();

+                    xsDefinition.setUnresolved(true);

+                    xsDefinition.setNamespace(element.getAttribute("targetNamespace"));

+                    xsDefinition.setDocument(doc);

+                    xsDefinition.setLocation(URI.create(doc.getDocumentURI() + "#" + index));

+                    XSDefinition resolved =

+                        contribution.getModelResolver().resolveModel(XSDefinition.class, xsDefinition);

+                    if (resolved != null && !resolved.isUnresolved()) {

+                        if (!wsdlDefinition.getXmlSchemas().contains(resolved)) {

+                            wsdlDefinition.getXmlSchemas().add(xsDefinition);

+                        }

+                    }

+                    index++;

+                }

+            }

+        }

+        for (Object imports : definition.getImports().values()) {

+            List impList = (List)imports;

+            for (Object i : impList) {

+                javax.wsdl.Import anImport = (javax.wsdl.Import)i;

+                // Read inline schemas 

+                if (anImport.getDefinition() != null) {

+                    readInlineSchemas(wsdlDefinition, anImport.getDefinition());

+                }

+            }

+        }

+    }

+

+}

diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XMLDocumentHelper.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XMLDocumentHelper.java
new file mode 100644
index 0000000000..e5cd9d9a15
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XMLDocumentHelper.java
@@ -0,0 +1,181 @@
+/*
+ * 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.interfacedef.wsdl.xml;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.xml.sax.InputSource;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class XMLDocumentHelper {
+    public static final QName WSDL11 = new QName("http://schemas.xmlsoap.org/wsdl/", "definitions");
+    public static final QName XSD = new QName("http://www.w3.org/2001/XMLSchema", "schema");
+    public static final QName WSDL20 = new QName("http://www.w3.org/ns/wsdl", "description");
+
+    protected static final int BUFFER_SIZE = 256;
+
+    /**
+     * Detect the XML encoding of the WSDL document
+     * 
+     * @param is The input stream
+     * @return The encoding
+     * @throws IOException
+     */
+    public static String getEncoding(InputStream is) throws IOException {
+        if (!is.markSupported())
+            is = new BufferedInputStream(is);
+
+        byte[] buffer = readBuffer(is);
+        return getXMLEncoding(buffer);
+    }
+
+    /**
+     * Searches the array of bytes to determine the XML encoding.
+     */
+    protected static String getXMLEncoding(byte[] bytes) {
+        String javaEncoding = null;
+
+        if (bytes.length >= 4) {
+            if (((bytes[0] == -2) && (bytes[1] == -1)) || ((bytes[0] == 0) && (bytes[1] == 60)))
+                javaEncoding = "UnicodeBig";
+            else if (((bytes[0] == -1) && (bytes[1] == -2)) || ((bytes[0] == 60) && (bytes[1] == 0)))
+                javaEncoding = "UnicodeLittle";
+            else if ((bytes[0] == -17) && (bytes[1] == -69) && (bytes[2] == -65))
+                javaEncoding = "UTF8";
+        }
+
+        String header = null;
+
+        try {
+            if (javaEncoding != null)
+                header = new String(bytes, 0, bytes.length, javaEncoding);
+            else
+                header = new String(bytes, 0, bytes.length);
+        } catch (UnsupportedEncodingException e) {
+            return null;
+        }
+
+        if (!header.startsWith("<?xml"))
+            return "UTF-8";
+
+        int endOfXMLPI = header.indexOf("?>");
+        int encodingIndex = header.indexOf("encoding", 6);
+
+        if ((encodingIndex == -1) || (encodingIndex > endOfXMLPI))
+            return "UTF-8";
+
+        int firstQuoteIndex = header.indexOf("\"", encodingIndex);
+        int lastQuoteIndex;
+
+        if ((firstQuoteIndex == -1) || (firstQuoteIndex > endOfXMLPI)) {
+            firstQuoteIndex = header.indexOf("'", encodingIndex);
+            lastQuoteIndex = header.indexOf("'", firstQuoteIndex + 1);
+        } else
+            lastQuoteIndex = header.indexOf("\"", firstQuoteIndex + 1);
+
+        return header.substring(firstQuoteIndex + 1, lastQuoteIndex);
+    }
+
+    protected static byte[] readBuffer(InputStream is) throws IOException {
+        if (is.available() == 0) {
+            return new byte[0];
+        }
+
+        byte[] buffer = new byte[BUFFER_SIZE];
+        is.mark(BUFFER_SIZE);
+        int bytesRead = is.read(buffer, 0, BUFFER_SIZE);
+        int totalBytesRead = bytesRead;
+
+        while (bytesRead != -1 && (totalBytesRead < BUFFER_SIZE)) {
+            bytesRead = is.read(buffer, totalBytesRead, BUFFER_SIZE - totalBytesRead);
+
+            if (bytesRead != -1)
+                totalBytesRead += bytesRead;
+        }
+
+        if (totalBytesRead < BUFFER_SIZE) {
+            byte[] smallerBuffer = new byte[totalBytesRead];
+            System.arraycopy(buffer, 0, smallerBuffer, 0, totalBytesRead);
+            smallerBuffer = buffer;
+        }
+
+        is.reset();
+        return buffer;
+    }
+
+    public static InputSource getInputSource(URL url) throws IOException {
+        InputStream is = url.openStream();
+        return getInputSource(url, is);
+    }
+
+    public static InputSource getInputSource(URL url, InputStream is) throws IOException {
+        is = new BufferedInputStream(is);
+        String encoding = getEncoding(is);
+        InputSource inputSource = new InputSource(is);
+        inputSource.setEncoding(encoding);
+        // [rfeng] Make sure we set the system id as it will be used as the base URI for nested import/include 
+        inputSource.setSystemId(url.toString());
+        return inputSource;
+    }
+
+    private final static XMLInputFactory inputFactory = XMLInputFactory.newInstance();
+
+    public static String readTargetNamespace(URL doc, QName element, boolean rootOnly, String attribute)
+        throws IOException, XMLStreamException {
+        if (attribute == null) {
+            attribute = "targetNamespace";
+        }
+        InputStream is = doc.openStream();
+        try {
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(is);
+            int eventType = reader.getEventType();
+            while (true) {
+                if (eventType == XMLStreamConstants.START_ELEMENT) {
+                    if (element.equals(reader.getName())) {
+                        return reader.getAttributeValue(null, attribute);
+                    } else if (rootOnly) {
+                        return null;
+                    }
+                }
+                if (reader.hasNext()) {
+                    eventType = reader.next();
+                } else {
+                    break;
+                }
+            }
+            return null;
+        } finally {
+            is.close();
+        }
+    }
+
+}
diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDDocumentProcessor.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDDocumentProcessor.java
new file mode 100644
index 0000000000..02c5593f86
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDDocumentProcessor.java
@@ -0,0 +1,77 @@
+/*
+ * 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.interfacedef.wsdl.xml;
+
+import java.net.URI;
+import java.net.URL;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory;
+import org.apache.tuscany.sca.interfacedef.wsdl.XSDefinition;
+
+/**
+ * An ArtifactProcessor for XSD documents.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class XSDDocumentProcessor implements URLArtifactProcessor<XSDefinition> {
+
+    private WSDLFactory factory;
+
+    public XSDDocumentProcessor(ModelFactoryExtensionPoint modelFactories) {
+        this.factory = modelFactories.getFactory(WSDLFactory.class);
+    }
+
+    public XSDefinition read(URL contributionURL, URI artifactURI, URL artifactURL) throws ContributionReadException {
+        try {
+            return indexRead(artifactURL);
+        } catch (Exception e) {
+            throw new ContributionReadException(e);
+        }
+    }
+
+    public void resolve(XSDefinition model, ModelResolver resolver) throws ContributionResolveException {
+    }
+
+    public String getArtifactType() {
+        return ".xsd";
+    }
+
+    public Class<XSDefinition> getModelType() {
+        return XSDefinition.class;
+    }
+
+    public static final QName XSD = new QName("http://www.w3.org/2001/XMLSchema", "schema");
+
+    protected XSDefinition indexRead(URL doc) throws Exception {
+        XSDefinition xsd = factory.createXSDefinition();
+        xsd.setUnresolved(true);
+        xsd.setNamespace(XMLDocumentHelper.readTargetNamespace(doc, XSD, true, "targetNamespace"));
+        xsd.setLocation(doc.toURI());
+        xsd.setUnresolved(false);
+        return xsd;
+    }
+}
diff --git a/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDModelResolver.java b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDModelResolver.java
new file mode 100644
index 0000000000..8d89455424
--- /dev/null
+++ b/branches/sca-java-1.1/modules/interface-wsdl-xml/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/xml/XSDModelResolver.java
@@ -0,0 +1,237 @@
+/*

+ * 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.interfacedef.wsdl.xml;

+

+import java.io.IOException;

+import java.net.URL;

+import java.util.ArrayList;

+import java.util.HashMap;

+import java.util.List;

+import java.util.Map;

+

+import org.apache.tuscany.sca.contribution.Contribution;

+import org.apache.tuscany.sca.contribution.DeployedArtifact;

+import org.apache.tuscany.sca.contribution.Import;

+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;

+import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;

+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;

+import org.apache.tuscany.sca.contribution.service.ContributionRuntimeException;

+import org.apache.tuscany.sca.interfacedef.wsdl.DefaultWSDLFactory;

+import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory;

+import org.apache.tuscany.sca.interfacedef.wsdl.XSDefinition;

+import org.apache.ws.commons.schema.XmlSchema;

+import org.apache.ws.commons.schema.XmlSchemaCollection;

+import org.apache.ws.commons.schema.XmlSchemaInclude;

+import org.apache.ws.commons.schema.resolver.URIResolver;

+import org.xml.sax.InputSource;

+

+/**

+ * A Model Resolver for XSD models.

+ * 

+ * @version $Rev: 557916 $ $Date: 2007-07-20 01:04:40 -0700 (Fri, 20 Jul 2007) $

+ */

+public class XSDModelResolver implements ModelResolver {

+    private WSDLFactory factory;

+    private Contribution contribution;

+    private Map<String, List<XSDefinition>> map = new HashMap<String, List<XSDefinition>>();

+    private XmlSchemaCollection schemaCollection;

+

+    public XSDModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {

+        this.contribution = contribution;

+        this.schemaCollection = new XmlSchemaCollection();

+        schemaCollection.setSchemaResolver(new URIResolverImpl(contribution));

+        this.factory = new DefaultWSDLFactory();

+    }

+

+    public void addModel(Object resolved) {

+        XSDefinition definition = (XSDefinition)resolved;

+        List<XSDefinition> list = map.get(definition.getNamespace());

+        if (list == null) {

+            list = new ArrayList<XSDefinition>();

+            map.put(definition.getNamespace(), list);

+        }

+        list.add(definition);

+    }

+

+    public Object removeModel(Object resolved) {

+        XSDefinition definition = (XSDefinition)resolved;

+        List<XSDefinition> list = map.get(definition.getNamespace());

+        if (list == null) {

+            return null;

+        } else {

+            return list.remove(definition);

+        }

+    }

+

+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {

+

+        XSDefinition definition = (XSDefinition)unresolved;

+        // Lookup a definition for the given namespace

+        String namespace = definition.getNamespace();

+        List<XSDefinition> list = map.get(namespace);

+        if (list != null && definition.getDocument() != null) {

+            // Set the document for the inline schema

+            int index = list.indexOf(definition);

+            if (index != -1) {

+                list.get(index).setDocument(definition.getDocument());

+            }

+        }

+        if (list == null && definition.getDocument() != null) {

+            // Hit for the 1st time

+            list = new ArrayList<XSDefinition>();

+            list.add(definition);

+            map.put(namespace, list);

+        }

+        XSDefinition resolved = null;

+        try {

+            resolved = aggregate(list);

+        } catch (IOException e) {

+            throw new ContributionRuntimeException(e);

+        }

+        if (resolved != null && !resolved.isUnresolved()) {

+            return modelClass.cast(resolved);

+        }

+

+        // No definition found, delegate the resolution to the imports

+        for (Import import_ : this.contribution.getImports()) {

+            if (import_ instanceof NamespaceImport) {

+                NamespaceImport namespaceImport = (NamespaceImport)import_;

+                if (namespaceImport.getNamespace().equals(namespace)) {

+

+                    // Delegate the resolution to the import resolver

+                    resolved =

+                        namespaceImport.getModelResolver().resolveModel(XSDefinition.class, (XSDefinition)unresolved);

+                    if (!resolved.isUnresolved()) {

+                        return modelClass.cast(resolved);

+                    }

+                }

+            }

+        }

+        return modelClass.cast(unresolved);

+    }

+

+    private void loadOnDemand(XSDefinition definition) throws IOException {

+        if (definition.getSchema() != null) {

+            return;

+        }

+        if (definition.getDocument() != null) {

+            String uri = null;

+            if (definition.getLocation() != null) {

+                uri = definition.getLocation().toString();

+            }

+            XmlSchema schema = schemaCollection.read(definition.getDocument(), uri, null);

+            definition.setSchemaCollection(schemaCollection);

+            definition.setSchema(schema);

+            definition.setUnresolved(false);

+        } else if (definition.getLocation() != null) {

+            if (definition.getLocation().getFragment() != null) {

+                // It's an inline schema

+                return;

+            }

+            // Read an XSD document

+            InputSource xsd = XMLDocumentHelper.getInputSource(definition.getLocation().toURL());

+            XmlSchema schema = schemaCollection.read(xsd, null);

+            definition.setSchemaCollection(schemaCollection);

+            definition.setSchema(schema);

+        }

+    }

+

+    /**

+     * Create a facade XmlSchema which includes all the defintions

+     * 

+     * @param definitions A list of the XmlSchema under the same target

+     *                namespace

+     * @return The aggregated XmlSchema

+     */

+    private XSDefinition aggregate(List<XSDefinition> definitions) throws IOException {

+        if (definitions == null || definitions.size() == 0) {

+            return null;

+        }

+        if (definitions.size() == 1) {

+            XSDefinition d = definitions.get(0);

+            loadOnDemand(d);

+            return d;

+        }

+        XSDefinition aggregated = factory.createXSDefinition();

+        for (XSDefinition d : definitions) {

+            loadOnDemand(d);

+        }

+        String ns = definitions.get(0).getNamespace();

+        XmlSchema facade = new XmlSchema(ns, schemaCollection);

+

+        for (XmlSchema d : schemaCollection.getXmlSchemas()) {

+            if (ns.equals(d.getTargetNamespace())) {

+                XmlSchemaInclude include = new XmlSchemaInclude();

+                include.setSchema(d);

+                include.setSourceURI(d.getSourceURI());

+                include.setSchemaLocation(d.getSourceURI());

+                facade.getIncludes().add(include);

+                facade.getItems().add(include);

+            }

+        }

+        aggregated.setUnresolved(true);

+        aggregated.setSchema(facade);

+        aggregated.setNamespace(ns);

+        aggregated.setUnresolved(false);

+

+        // FIXME: [rfeng] This is hacky

+        definitions.clear();

+        definitions.add(aggregated);

+        return aggregated;

+    }

+

+    /**

+     * URI resolver implementation for xml schema

+     */

+    public static class URIResolverImpl implements URIResolver {

+        private Contribution contribution;

+

+        public URIResolverImpl(Contribution contribution) {

+            this.contribution = contribution;

+        }

+

+        public org.xml.sax.InputSource resolveEntity(java.lang.String targetNamespace,

+                                                     java.lang.String schemaLocation,

+                                                     java.lang.String baseUri) {

+            try {

+                if (schemaLocation == null || schemaLocation.startsWith("/")) {

+                    return null;

+                }

+                URL url = null;

+                if (schemaLocation.startsWith("/")) {

+                    // The URI is relative to the contribution

+                    String uri = schemaLocation.substring(1);

+                    for (DeployedArtifact a : contribution.getArtifacts()) {

+                        if (a.getURI().equals(uri)) {

+                            url = new URL(a.getLocation());

+                            break;

+                        }

+                    }

+                } else {

+                    url = new URL(new URL(baseUri), schemaLocation);

+                }

+                return XMLDocumentHelper.getInputSource(url);

+            } catch (IOException e) {

+                return null;

+            }

+        }

+    }

+

+}