diff options
Diffstat (limited to '')
17 files changed, 1948 insertions, 0 deletions
diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/DefaultWSDLFactory.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/DefaultWSDLFactory.java new file mode 100644 index 0000000000..2a5dd07d08 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/DefaultWSDLFactory.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; + +import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint; +import org.apache.tuscany.sca.interfacedef.wsdl.impl.WSDLFactoryImpl; + +/** + * A factory for the WSDL model. + * + * @version $Rev$ $Date$ + */ +public class DefaultWSDLFactory extends WSDLFactoryImpl implements WSDLFactory { + + public DefaultWSDLFactory(ModelFactoryExtensionPoint modelFactories) { + super(modelFactories); + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLDefinition.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLDefinition.java new file mode 100644 index 0000000000..039e75f437 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLDefinition.java @@ -0,0 +1,140 @@ +/* + * 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; + +import java.net.URI; +import java.util.List; + +import javax.wsdl.Binding; +import javax.wsdl.Definition; +import javax.wsdl.WSDLElement; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.Base; +import org.apache.tuscany.sca.xsd.XSDefinition; +import org.apache.ws.commons.schema.XmlSchemaElement; +import org.apache.ws.commons.schema.XmlSchemaType; + +/** + * Represents a WSDL definition. + * WSDLDefinition + * + * @version $Rev$ $Date$ + */ +public interface WSDLDefinition extends Base { + + /** + * Returns the WSDL definition model, if there are more than one WSDL definition under the + * same namespace, the definition will be a facade which imports all the physical WSDL + * definitions + * + * @return the WSDL definition model + */ + Definition getDefinition(); + + /** + * Sets the WSDL definition model + * @param definition the WSDL definition model + */ + void setDefinition(Definition definition); + + /** + * Returns the namespace of this WSDL definition. + * @return the namespace of this WSDL definition + */ + String getNamespace(); + + /** + * Sets the namespace of this WSDL definition. + * @param namespace the namespace of this WSDL definition + */ + void setNamespace(String namespace); + + /** + * Get a list of inline XML schema definitions + * @return A list of inline XML schema definitions + */ + List<XSDefinition> getXmlSchemas(); + + /** + * Get the location of the WSDL file + * @return The location of the WSDL file + */ + URI getLocation(); + + /** + * Set the location of the WSDL file + * @param url + */ + void setLocation(URI url); + + /** + * Get the contribution artifact URI of the WSDL document + * @return The URI of the WSDL document + */ + URI getURI(); + + /** + * Set the contribution artifact URI of the WSDL document + * @param uri + */ + void setURI(URI uri); + + /** + * Get the WSDL definitions imported by this definition + * @return A list of imported WSDL definitions + */ + List<WSDLDefinition> getImportedDefinitions(); + + /** + * Get an XSD element by QName + * @param name + * @return + */ + XmlSchemaElement getXmlSchemaElement(QName name); + + /** + * Get an XSD type by QName + * @param name + * @return + */ + XmlSchemaType getXmlSchemaType(QName name); + + /** + * Get the WSDL object by type and name + * @param <T> + * @param type javax.wsdl.Service/PortType/Binding/Message.class + * @param name The QName of the object + * @return WSDLObject + */ + <T extends WSDLElement> WSDLObject<T> getWSDLObject(Class<T> type, QName name); + + /** + * Get the generated binding for a WSDLDefinition + * @return the WSDL binding + */ + Binding getBinding(); + + /** + * Set the generated binding for a WSDLDefinition + * @param binding the WSDL binding + */ + void setBinding(Binding binding); +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLFactory.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLFactory.java new file mode 100644 index 0000000000..95985dcc28 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLFactory.java @@ -0,0 +1,70 @@ +/* + * 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; + +import javax.wsdl.PortType; + +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; + +/** + * Factory for the WSDL model. + * + * @version $Rev$ $Date$ + */ +public interface WSDLFactory { + + /** + * Creates a new WSDL interface. + * + * @return a new WSDL interface + */ + WSDLInterface createWSDLInterface(); + + /** + * Creates a new WSDL interface from a WSDL portType. + * + * @param portType the portType to inspect + * @return a WSDLInterface corresponding to the WSDL portType + */ + WSDLInterface createWSDLInterface(PortType portType, WSDLDefinition wsdlDefinition, ModelResolver resolver) throws InvalidInterfaceException; + + /** + * Creates the contents of a WSDL interface from a WSDL portType. + * + * @param portType the portType to inspect + * @return a WSDLInterface corresponding to the WSDL portType + */ + void createWSDLInterface(WSDLInterface wsdlInterface, PortType portType, WSDLDefinition wsdlDefinition, ModelResolver resolver) throws InvalidInterfaceException; + + /** + * Creates a new WSDL definition. + * + * @return a new WSDL definition + */ + WSDLDefinition createWSDLDefinition(); + + /** + * Creates a new WSDL interface contract. + * + * @return + */ + WSDLInterfaceContract createWSDLInterfaceContract(); + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterface.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterface.java new file mode 100644 index 0000000000..c0da060af2 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterface.java @@ -0,0 +1,67 @@ +/* + * 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; + +import javax.wsdl.PortType; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.assembly.Base; +import org.apache.tuscany.sca.interfacedef.Interface; + + +/** + * Represents a WSDL interface. + * + * @version $Rev$ $Date$ + */ +public interface WSDLInterface extends Interface, Base { + + /** + * Returns the name of the WSDL interface. + * + * @return the name of the WSDL interface + */ + QName getName(); + + /** + * Sets the name of the WSDL interface. + * + * @param interfaceName the name of the WSDL interface + */ + void setName(QName interfaceName); + + /** + * Returns the WSDL interface portType. + * + * @return the WSDL interface portType + */ + PortType getPortType(); + + /** + * Sets the WSDL interface portType + * + * @param portType the WSDL interface portType + */ + void setPortType(PortType portType); + + WSDLDefinition getWsdlDefinition(); + + void setWsdlDefinition(WSDLDefinition wsdlDefinition); + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterfaceContract.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterfaceContract.java new file mode 100644 index 0000000000..2ef21a50cf --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLInterfaceContract.java @@ -0,0 +1,44 @@ +/* + * 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; + +import org.apache.tuscany.sca.assembly.Extensible; +import org.apache.tuscany.sca.interfacedef.InterfaceContract; + + +/** + * Represents a WSDL interface contract. + * + * @version $Rev$ $Date$ + */ +public interface WSDLInterfaceContract extends InterfaceContract, Extensible { + + /** + * Sets the WSDL location. + * @param location the WSDL location + */ + void setLocation(String location); + + /** + * Returns the WSDL location + * @return the WSDL location + */ + String getLocation(); + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLObject.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLObject.java new file mode 100644 index 0000000000..0b707163da --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLObject.java @@ -0,0 +1,54 @@ +/* + * 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; + +import java.io.Serializable; + +import javax.wsdl.Definition; + +/** + * Model for objects in a WSDL definition + * @version $Rev$ $Date$ + */ +public interface WSDLObject<T extends Serializable> { + /** + * Get the owning definition where the element is declared + * @return The owning definition + */ + Definition getDefinition(); + + /** + * Set the owning definition + * @param definition + */ + void setDefinition(Definition definition); + + /** + * Get the WSDL element such as Service, PortType, Binding or Message + * @return The WSDL element + */ + T getElement(); + + /** + * Set the WSDL element + * @param element + */ + void setElement(T element); +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLOperation.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLOperation.java new file mode 100644 index 0000000000..d73cccb714 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/WSDLOperation.java @@ -0,0 +1,40 @@ +/* + * 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; + +import org.apache.tuscany.sca.interfacedef.Operation; + +/** + * WSDL 1.1 Operation + * @version $Rev$ $Date$ + */ +public interface WSDLOperation extends Operation { + /** + * Get the underlying WSDL operation + * @return + */ + javax.wsdl.Operation getWsdlOperation(); + + /** + * Set the underlying WSDL operation + * @param operation + */ + void setWsdlOperation(javax.wsdl.Operation operation); +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/InvalidWSDLException.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/InvalidWSDLException.java new file mode 100644 index 0000000000..1e7b4faa32 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/InvalidWSDLException.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.impl; + +import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException; + +/** + * An exception to indicate the WSDL definition is invalid + * + * @version $Rev$ $Date$ + */ +public class InvalidWSDLException extends InvalidInterfaceException { + private static final long serialVersionUID = 3742887584293256519L; + + public InvalidWSDLException(String message) { + super(message); + } +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLDefinitionImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLDefinitionImpl.java new file mode 100644 index 0000000000..16e9cf43f3 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLDefinitionImpl.java @@ -0,0 +1,289 @@ +/* + * 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.impl; + +import static org.apache.tuscany.sca.xsd.impl.XSDefinitionImpl.getXmlSchemaObject; + +import java.net.URI; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import javax.wsdl.Binding; +import javax.wsdl.Definition; +import javax.wsdl.Import; +import javax.wsdl.Message; +import javax.wsdl.PortType; +import javax.wsdl.Service; +import javax.wsdl.WSDLElement; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLObject; +import org.apache.tuscany.sca.xsd.XSDefinition; +import org.apache.ws.commons.schema.XmlSchema; +import org.apache.ws.commons.schema.XmlSchemaCollection; +import org.apache.ws.commons.schema.XmlSchemaElement; +import org.apache.ws.commons.schema.XmlSchemaType; + +/** + * Represents a WSDL definition. + * + * @version $Rev$ $Date$ + */ +public class WSDLDefinitionImpl implements WSDLDefinition { + + private Definition definition; + private String namespace; + private URI location; + private URI uri; + private List<WSDLDefinition> imported = new ArrayList<WSDLDefinition>(); + private List<XSDefinition> schemas = new ArrayList<XSDefinition>(); + private boolean unresolved; + private Binding binding; + + protected WSDLDefinitionImpl() { + } + + public Definition getDefinition() { + return definition; + } + + public void setDefinition(Definition definition) { + this.definition = definition; + } + + public boolean isUnresolved() { + return unresolved; + } + + public void setUnresolved(boolean undefined) { + this.unresolved = undefined; + } + + public String getNamespace() { + if (isUnresolved()) { + return namespace; + } else if (definition != null) { + return definition.getTargetNamespace(); + } else { + return namespace; + } + } + + public void setNamespace(String namespace) { + if (!isUnresolved()) { + throw new IllegalStateException(); + } else { + this.namespace = namespace; + } + } + + /* + @Override + public int hashCode() { + return String.valueOf(getNamespace()).hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } else if (obj instanceof WSDLDefinition) { + WSDLDefinition def = (WSDLDefinition)obj; + if (getNamespace() != null) { + return getNamespace().equals(def.getNamespace()); + } else { + return def.getNamespace() == null; + } + } else { + return false; + } + } + */ + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getXmlSchemas() + */ + public List<XSDefinition> getXmlSchemas() { + return schemas; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getLocation() + */ + public URI getLocation() { + return location; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#setLocation(java.net.URI) + */ + public void setLocation(URI url) { + this.location = url; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getURI() + */ + public URI getURI() { + return uri; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#setURI(java.net.URI) + */ + public void setURI(URI uri) { + this.uri = uri; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getImportedDefinitions() + */ + public List<WSDLDefinition> getImportedDefinitions() { + return imported; + } + + /** + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((location == null) ? 0 : location.hashCode()); + result = prime * result + ((namespace == null) ? 0 : namespace.hashCode()); + return result; + } + + /** + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (!(obj instanceof WSDLDefinitionImpl)) + return false; + final WSDLDefinitionImpl other = (WSDLDefinitionImpl)obj; + if (location == null) { + if (other.location != null) + return false; + } else if (!location.equals(other.location)) + return false; + if (namespace == null) { + if (other.namespace != null) + return false; + } else if (!namespace.equals(other.namespace)) + return false; + return true; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getXmlSchemaElement(javax.xml.namespace.QName) + */ + public XmlSchemaElement getXmlSchemaElement(QName name) { + XmlSchemaCollection schemaCollection = null; + for (XSDefinition xsd : schemas) { + if (schemaCollection == null && xsd.getSchemaCollection() != null) { + schemaCollection = xsd.getSchemaCollection(); + } + XmlSchema schema = xsd.getSchema(); + XmlSchemaElement element = getXmlSchemaObject(schema, name, XmlSchemaElement.class); + if (element != null) { + return element; + } + } + if (schemaCollection != null) { + return schemaCollection.getElementByQName(name); + } + return null; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition#getXmlSchemaType(javax.xml.namespace.QName) + */ + public XmlSchemaType getXmlSchemaType(QName name) { + XmlSchemaCollection schemaCollection = null; + for (XSDefinition xsd : schemas) { + if (xsd.getSchemaCollection() != null) { + schemaCollection = xsd.getSchemaCollection(); + } + XmlSchema schema = xsd.getSchema(); + XmlSchemaType type = getXmlSchemaObject(schema, name, XmlSchemaType.class); + if (type != null) { + return type; + } + } + if (schemaCollection != null) { + return schemaCollection.getTypeByQName(name); + } + return null; + } + + @SuppressWarnings("unchecked") + private static <T extends WSDLElement> WSDLObject<T> getWSDLObject(Definition definition, Class<T> type, QName name) { + if (definition == null) { + return null; + } + Map<QName, WSDLElement> map = null; + if (type == PortType.class) { + map = definition.getPortTypes(); + } else if (type == Service.class) { + map = definition.getServices(); + } else if (type == Binding.class) { + map = definition.getBindings(); + } else if (type == Message.class) { + map = definition.getMessages(); + } else { + throw new IllegalArgumentException("Invalid type: " + type.getName()); + } + if (map.containsKey(name)) { + return (WSDLObject<T>)new WSDLObjectImpl(definition, map.get(name)); + } else { + for (Object imports : definition.getImports().values()) { + List<Import> importList = (List<Import>)imports; + for (Import i : importList) { + definition = i.getDefinition(); + WSDLObject<T> element = getWSDLObject(definition, type, name); + if (element != null) { + return element; + } + } + } + } + return null; + } + + public <T extends WSDLElement> WSDLObject<T> getWSDLObject(Class<T> type, QName name) { + return getWSDLObject(definition, type, name); + } + + public Binding getBinding() { + return binding; + } + + public void setBinding(Binding binding) { + this.binding = binding; + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLFactoryImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLFactoryImpl.java new file mode 100644 index 0000000000..1f2263e1c9 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLFactoryImpl.java @@ -0,0 +1,75 @@ +/* + * 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.impl; + +import javax.wsdl.PortType; + +import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +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; + +/** + * A factory for the WSDL model. + * + * @version $Rev$ $Date$ + */ +public abstract class WSDLFactoryImpl implements WSDLFactory { + + private WSDLInterfaceIntrospectorImpl introspector; + + public WSDLFactoryImpl(ModelFactoryExtensionPoint modelFactories) { + introspector = new WSDLInterfaceIntrospectorImpl(modelFactories); + } + + public WSDLInterface createWSDLInterface() { + return new WSDLInterfaceImpl(); + } + + public WSDLInterface createWSDLInterface(PortType portType, + WSDLDefinition wsdlDefinition, + ModelResolver resolver) throws InvalidInterfaceException { + WSDLInterface wsdlInterface = createWSDLInterface(); + introspector.introspectPortType(wsdlInterface, portType, wsdlDefinition, resolver); + return wsdlInterface; + } + + public void createWSDLInterface(WSDLInterface wsdlInterface, + PortType portType, + WSDLDefinition wsdlDefinition, + ModelResolver resolver) throws InvalidInterfaceException { + introspector.introspectPortType(wsdlInterface, portType, wsdlDefinition, resolver); + } + + public WSDLDefinition createWSDLDefinition() { + return new WSDLDefinitionImpl(); + } + + public WSDLInterfaceContract createWSDLInterfaceContract() { + return new WSDLInterfaceContractImpl(); + } + + public WSDLInterfaceIntrospectorImpl getWSDLInterfaceIntrospector() { + return introspector; + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceContractImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceContractImpl.java new file mode 100644 index 0000000000..e116f567c1 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceContractImpl.java @@ -0,0 +1,64 @@ +/* + * 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.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.assembly.Extension; +import org.apache.tuscany.sca.interfacedef.impl.InterfaceContractImpl; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterfaceContract; + +/** + * Represents a WSDL interface contract. + * + * @version $Rev$ $Date$ + */ +public class WSDLInterfaceContractImpl extends InterfaceContractImpl implements WSDLInterfaceContract { + private String location; + private List<Object> extensions = new ArrayList<Object>(); + private List<Extension> attributeExtensions = new ArrayList<Extension>(); + + + protected WSDLInterfaceContractImpl() { + } + + public String getLocation() { + return location; + } + + public void setLocation(String location) { + this.location = location; + } + + + public List<Object> getExtensions() { + return extensions; + } + + public List<Extension> getAttributeExtensions() { + return attributeExtensions; + } + + + @Override + public WSDLInterfaceContractImpl clone() throws CloneNotSupportedException { + return (WSDLInterfaceContractImpl) super.clone(); + } +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceImpl.java new file mode 100644 index 0000000000..3719bbd79a --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceImpl.java @@ -0,0 +1,99 @@ +/* + * 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.impl; + +import javax.wsdl.PortType; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.interfacedef.impl.InterfaceImpl; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterface; + +/** + * Represents a WSDL interface. + * + * @version $Rev$ $Date$ + */ +public class WSDLInterfaceImpl extends InterfaceImpl implements WSDLInterface { + + private QName name; + private PortType portType; + private WSDLDefinition wsdlDefinition; + + protected WSDLInterfaceImpl() { + setRemotable(true); + } + + public QName getName() { + if (isUnresolved()) { + return name; + } else { + return portType.getQName(); + } + } + + public void setName(QName interfaceName) { + if (!isUnresolved()) { + throw new IllegalStateException(); + } + this.name = interfaceName; + } + + public PortType getPortType() { + return portType; + } + + public void setPortType(PortType portType) { + this.portType = portType; + } + + @Override + public int hashCode() { + return String.valueOf(getName()).hashCode(); + } + + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } else if (obj instanceof WSDLInterface) { + if (getName() != null) { + return getName().equals(((WSDLInterface)obj).getName()); + } else { + return ((WSDLInterface)obj).getName() == null; + } + } else { + return false; + } + } + + public WSDLDefinition getWsdlDefinition() { + return wsdlDefinition; + } + + public void setWsdlDefinition(WSDLDefinition wsdlDefinition) { + this.wsdlDefinition = wsdlDefinition; + } + + @Override + public WSDLInterfaceImpl clone() throws CloneNotSupportedException { + return (WSDLInterfaceImpl) super.clone(); + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceIntrospectorImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceIntrospectorImpl.java new file mode 100644 index 0000000000..18fce72f90 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLInterfaceIntrospectorImpl.java @@ -0,0 +1,159 @@ +/* + * 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.impl; + +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.List; +import java.util.Vector; + +import javax.wsdl.PortType; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.interfacedef.ConversationSequence; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLInterface; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.PolicyFactory; +import org.apache.tuscany.sca.xsd.XSDFactory; + +/** + * Introspector for creating WSDLInterface definitions from WSDL PortTypes. + * + * @version $Rev$ $Date$ + */ +public class WSDLInterfaceIntrospectorImpl { + private static final QName POLICY_REQUIRES = new QName("http://www.osoa.org/xmlns/sca/1.0", "requires"); + private static final QName POLICY_CONVERSATIONAL = new QName("http://www.osoa.org/xmlns/sca/1.0", "conversational"); + public static final QName POLICY_END_CONVERSATION = new QName("http://www.osoa.org/xmlns/sca/1.0", "endsConversation"); + + private XSDFactory xsdFactory; + private PolicyFactory policyFactory; + + public WSDLInterfaceIntrospectorImpl(ModelFactoryExtensionPoint modelFactories) { + this.xsdFactory = modelFactories.getFactory(XSDFactory.class);; + this.policyFactory = modelFactories.getFactory(PolicyFactory.class);; + } + + // FIXME: Do we want to deal with document-literal wrapped style based on the JAX-WS Specification? + private List<Operation> introspectOperations(PortType portType, WSDLDefinition wsdlDefinition, ModelResolver resolver) throws InvalidWSDLException { + List<Operation> operations = new ArrayList<Operation>(); + for (Object o : portType.getOperations()) { + javax.wsdl.Operation wsdlOp = (javax.wsdl.Operation)o; + Operation operation = getOperation(wsdlOp, wsdlDefinition, resolver, xsdFactory); + if(isEndConversation(wsdlOp)) { + operation.setConversationSequence(ConversationSequence.CONVERSATION_END); + } + operations.add(operation); + } + return operations; + } + + public void introspectPortType(WSDLInterface wsdlInterface, PortType portType, WSDLDefinition wsdlDefinition, ModelResolver resolver) throws InvalidWSDLException { + processIntents(wsdlInterface, portType); + wsdlInterface.setPortType(portType); + wsdlInterface.getOperations().addAll(introspectOperations(portType, wsdlDefinition, resolver)); + wsdlInterface.setConversational(isConversational(portType)); + } + + public static Operation getOperation(javax.wsdl.Operation wsdlOp, + WSDLDefinition wsdlDefinition, + ModelResolver resolver, + XSDFactory xsdFactory) throws InvalidWSDLException { + WSDLOperationIntrospectorImpl op = new WSDLOperationIntrospectorImpl(xsdFactory, wsdlOp, wsdlDefinition, null, resolver); + return op.getOperation(); + } + + private void processIntents(WSDLInterface wsdlInterface, PortType portType) { + Object o; + try { + o = portType.getExtensionAttribute(POLICY_REQUIRES); + } catch (NoSuchMethodError e) { + // That method does not exist on older WSDL4J levels + o = null; + } + if(o != null && o instanceof Vector) { + Vector<QName> policyAttributes = (Vector<QName>) o; + + Enumeration<QName> policyItents = policyAttributes.elements(); + while(policyItents.hasMoreElements()) { + QName intentName = policyItents.nextElement(); + + //ignores conversational, as it will have it's own + //attribute in the wsdl interface model + if(! intentName.equals(POLICY_CONVERSATIONAL)) { + //process the intent + System.out.println(">>> Intent : " + intentName); + + // Add each intent to the list + Intent intent = policyFactory.createIntent(); + intent.setName(intentName); + + wsdlInterface.getRequiredIntents().add(intent); + } + } + + } + } + + private boolean isConversational(PortType portType) { + boolean conversational = false; + + Object o; + try { + o = portType.getExtensionAttribute(POLICY_REQUIRES); + } catch (NoSuchMethodError e) { + // That method does not exist on older WSDL4J levels + o =null; + } + if(o != null && o instanceof Vector) { + Vector<QName> policyAttributes = (Vector<QName>) o; + + if(policyAttributes.contains(POLICY_CONVERSATIONAL)) { + return true; + } + + } + + return conversational; + } + + private boolean isEndConversation(javax.wsdl.Operation operation) { + boolean endConversation = false; + + Object o; + try { + o = operation.getExtensionAttribute(POLICY_END_CONVERSATION); + } catch (NoSuchMethodError e) { + // That method does not exist on older WSDL4J levels + o = null; + } + if(o != null && o instanceof String) { + endConversation = Boolean.valueOf((String)o); + } + + return endConversation; + + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLObjectImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLObjectImpl.java new file mode 100644 index 0000000000..f18eaef27b --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLObjectImpl.java @@ -0,0 +1,61 @@ +/* + * 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.impl; + +import java.io.Serializable; + +import javax.wsdl.Definition; + +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLObject; + +/** + * @version $Rev$ $Date$ + */ +public class WSDLObjectImpl<T extends Serializable> implements WSDLObject<T> { + private Definition definition; + private T element; + + public WSDLObjectImpl() { + super(); + } + + public WSDLObjectImpl(Definition definition, T element) { + super(); + this.definition = definition; + this.element = element; + } + + public Definition getDefinition() { + return definition; + } + + public void setDefinition(Definition definition) { + this.definition = definition; + } + + public T getElement() { + return element; + } + + public void setElement(T element) { + this.element = element; + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationImpl.java new file mode 100644 index 0000000000..317b9cce81 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationImpl.java @@ -0,0 +1,81 @@ +/* + * 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.impl; + +import javax.wsdl.Operation; + +import org.apache.tuscany.sca.interfacedef.impl.OperationImpl; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLOperation; + +/** + * @version $Rev$ $Date$ + */ +public class WSDLOperationImpl extends OperationImpl implements WSDLOperation { + private Operation operation; + + public WSDLOperationImpl() { + super(); + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLOperation#getWsdlOperation() + */ + public Operation getWsdlOperation() { + return operation; + } + + /** + * @see org.apache.tuscany.sca.interfacedef.wsdl.WSDLOperation#setWsdlOperation(javax.wsdl.Operation) + */ + public void setWsdlOperation(Operation operation) { + this.operation = operation; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + ((operation == null) ? 0 : operation.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + final WSDLOperationImpl other = (WSDLOperationImpl)obj; + if (operation == null) { + if (other.operation != null) + return false; + } else if (!operation.equals(other.operation)) + return false; + return true; + } + + @Override + public String toString() { + return operation == null ? null : operation.toString(); + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationIntrospectorImpl.java b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationIntrospectorImpl.java new file mode 100644 index 0000000000..19b14336f5 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/java/org/apache/tuscany/sca/interfacedef/wsdl/impl/WSDLOperationIntrospectorImpl.java @@ -0,0 +1,617 @@ +/* + * 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.impl; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +import javax.wsdl.Fault; +import javax.wsdl.Input; +import javax.wsdl.Message; +import javax.wsdl.Output; +import javax.wsdl.Part; +import javax.xml.XMLConstants; +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.interfacedef.ConversationSequence; +import org.apache.tuscany.sca.interfacedef.DataType; +import org.apache.tuscany.sca.interfacedef.Operation; +import org.apache.tuscany.sca.interfacedef.ParameterMode; +import org.apache.tuscany.sca.interfacedef.impl.DataTypeImpl; +import org.apache.tuscany.sca.interfacedef.util.ElementInfo; +import org.apache.tuscany.sca.interfacedef.util.FaultException; +import org.apache.tuscany.sca.interfacedef.util.TypeInfo; +import org.apache.tuscany.sca.interfacedef.util.WrapperInfo; +import org.apache.tuscany.sca.interfacedef.util.XMLType; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLOperation; +import org.apache.tuscany.sca.xsd.XSDFactory; +import org.apache.tuscany.sca.xsd.XSDefinition; +import org.apache.ws.commons.schema.XmlSchemaComplexType; +import org.apache.ws.commons.schema.XmlSchemaElement; +import org.apache.ws.commons.schema.XmlSchemaObject; +import org.apache.ws.commons.schema.XmlSchemaObjectCollection; +import org.apache.ws.commons.schema.XmlSchemaParticle; +import org.apache.ws.commons.schema.XmlSchemaSequence; +import org.apache.ws.commons.schema.XmlSchemaSimpleType; +import org.apache.ws.commons.schema.XmlSchemaType; + +/** + * Metadata for a WSDL operation + * + * @version $Rev$ $Date$ + */ +public class WSDLOperationIntrospectorImpl { + private static final Logger logger = Logger.getLogger(WSDLOperationIntrospectorImpl.class.getName()); + private static final QName ANY = new QName(XMLConstants.W3C_XML_SCHEMA_NS_URI, "any"); + + private XSDFactory xsdFactory; + private ModelResolver resolver; + private WSDLDefinition wsdlDefinition; + private javax.wsdl.Operation operation; + private WSDLOperation operationModel; + private DataType<List<DataType>> inputType; + private DataType outputType; + private List<DataType> faultTypes; + private String dataBinding; + + /** + * @param wsdlFactory The WSDLFactory to use + * @param operation The WSDL4J operation + * @param wsdlDefinition The WSDL Definition + * @param dataBinding The default databinding + * @param resolver The ModelResolver to use + */ + public WSDLOperationIntrospectorImpl(XSDFactory xsdFactory, + javax.wsdl.Operation operation, + WSDLDefinition wsdlDefinition, + String dataBinding, + ModelResolver resolver) { + super(); + this.xsdFactory = xsdFactory; + this.operation = operation; + this.wsdlDefinition = wsdlDefinition; + this.resolver = resolver; + this.dataBinding = dataBinding; + this.wrapper = new Wrapper(); + } + + private Wrapper wrapper; + + private Boolean wrapperStyle; + + /** + * Test if the operation qualifies wrapper style as defined by the JAX-WS + * 2.0 Specification + * + * @return true if the operation qualifies wrapper style, otherwise false + */ + public boolean isWrapperStyle() throws InvalidWSDLException { + if (wrapperStyle == null) { + wrapperStyle = + (operation.getInput() == null || operation.getInput().getMessage() == null + || operation.getInput().getMessage().getParts().size() == 0 || wrapper.getInputChildElements() != null) && (operation + .getOutput() == null || operation.getOutput().getMessage() == null + || operation.getOutput().getMessage().getParts().size() == 0 || wrapper.getOutputChildElements() != null); + } + return wrapperStyle; + } + + public Wrapper getWrapper() throws InvalidWSDLException { + if (!isWrapperStyle()) { + throw new IllegalStateException("The operation is not wrapper style."); + } else { + return wrapper; + } + } + + /** + * @return + * @throws InvalidServiceContractException + */ + public DataType<List<DataType>> getInputType() throws InvalidWSDLException { + if (inputType == null) { + Input input = operation.getInput(); + Message message = (input == null) ? null : input.getMessage(); + inputType = getMessageType(message); + inputType.setDataBinding("idl:input"); + } + return inputType; + } + + /** + * @return + * @throws NotSupportedWSDLException + */ + @SuppressWarnings("unchecked") + public DataType<XMLType> getOutputType() throws InvalidWSDLException { + if (outputType == null) { + Output output = operation.getOutput(); + Message outputMsg = (output == null) ? null : output.getMessage(); + + List outputParts = (outputMsg == null) ? null : outputMsg.getOrderedParts(null); + if (outputParts != null && outputParts.size() > 0) { + if (outputParts.size() > 1) { + // We don't support output with multiple parts + if (logger.isLoggable(Level.WARNING)) { + logger.warning("Multi-part output is not supported, please use BARE parameter style."); + } + // throw new InvalidWSDLException("Multi-part output is not supported"); + } + Part part = (Part)outputParts.get(0); + outputType = new WSDLPart(part, Object.class).getDataType(); + // outputType.setMetadata(WSDLOperation.class.getName(), this); + } + } + return outputType; + } + + /** + * @return + * @throws NotSupportedWSDLException + */ + public List<DataType> getFaultTypes() throws InvalidWSDLException { + if (faultTypes == null) { + Collection faults = operation.getFaults().values(); + faultTypes = new ArrayList<DataType>(); + for (Object f : faults) { + Fault fault = (Fault)f; + Message faultMsg = fault.getMessage(); + List faultParts = faultMsg.getOrderedParts(null); + if (faultParts.size() != 1) { + throw new InvalidWSDLException("The fault message MUST have a single part"); + } + Part part = (Part)faultParts.get(0); + WSDLPart wsdlPart = new WSDLPart(part, Object.class); + faultTypes.add(new DataTypeImpl<DataType>(FaultException.class, wsdlPart.getDataType())); + } + } + return faultTypes; + } + + private DataType<List<DataType>> getMessageType(Message message) throws InvalidWSDLException { + List<DataType> partTypes = new ArrayList<DataType>(); + if (message != null) { + Collection parts = message.getOrderedParts(null); + for (Object p : parts) { + WSDLPart part = new WSDLPart((Part)p, Object.class); + DataType<XMLType> partType = part.getDataType(); + partTypes.add(partType); + } + } + return new DataTypeImpl<List<DataType>>(dataBinding, Object[].class, partTypes); + } + + /** + * @return + * @throws NotSupportedWSDLException + */ + public Operation getOperation() throws InvalidWSDLException { + if (operationModel == null) { + boolean oneway = (operation.getOutput() == null); + operationModel = new WSDLOperationImpl(); + operationModel.setWsdlOperation(operation); + operationModel.setName(operation.getName()); + operationModel.setFaultTypes(getFaultTypes()); + operationModel.setNonBlocking(oneway); + operationModel.setConversationSequence(ConversationSequence.CONVERSATION_NONE); + operationModel.setInputType(getInputType()); + operationModel.setOutputType(getOutputType()); + + // FIXME: [rfeng] How to determine the parameter mode? + for (DataType d : operationModel.getInputType().getLogical()) { + operationModel.getParameterModes().add(ParameterMode.IN); + } + + operationModel.setInputWrapperStyle(isWrapperStyle()); + operationModel.setOutputWrapperStyle(isWrapperStyle()); + if (isWrapperStyle()) { + operationModel.setInputWrapper(getWrapper().getInputWrapperInfo()); + operationModel.setOutputWrapper(getWrapper().getOutputWrapperInfo()); + } + } + return operationModel; + } + + private XmlSchemaElement getElement(QName elementName) { + + XmlSchemaElement element = wsdlDefinition.getXmlSchemaElement(elementName); + if (element == null) { + XSDefinition definition = xsdFactory.createXSDefinition(); + definition.setUnresolved(true); + definition.setNamespace(elementName.getNamespaceURI()); + definition = resolver.resolveModel(XSDefinition.class, definition); + if (definition.getSchema() != null) { + element = definition.getSchema().getElementByName(elementName); + } + } + return element; + } + + private XmlSchemaType getType(QName typeName) { + XmlSchemaType type = wsdlDefinition.getXmlSchemaType(typeName); + if (type == null) { + XSDefinition definition = xsdFactory.createXSDefinition(); + definition.setUnresolved(true); + definition.setNamespace(typeName.getNamespaceURI()); + definition = resolver.resolveModel(XSDefinition.class, definition); + if (definition.getSchema() != null) { + type = definition.getSchema().getTypeByName(typeName); + } + } + return type; + } + + /** + * Metadata for a WSDL part + */ + public class WSDLPart { + private Part part; + + private XmlSchemaElement element; + + private DataType dataType; + + public WSDLPart(Part part, Class javaType) throws InvalidWSDLException { + this.part = part; + QName elementName = part.getElementName(); + if (elementName != null) { + element = WSDLOperationIntrospectorImpl.this.getElement(elementName); + if (element == null) { + throw new InvalidWSDLException("Element cannot be resolved: " + elementName.toString()); + } + } else { + // Create an faked XSD element to host the metadata + element = new XmlSchemaElement(); + element.setName(part.getName()); + element.setQName(new QName(null, part.getName())); + QName typeName = part.getTypeName(); + if (typeName != null) { + XmlSchemaType type = WSDLOperationIntrospectorImpl.this.getType(typeName); + if (type == null) { + throw new InvalidWSDLException("Type cannot be resolved: " + typeName.toString()); + } + element.setSchemaType(type); + element.setSchemaTypeName(type.getQName()); + } + } + XMLType xmlType = new XMLType(getElementInfo(element)); + xmlType.setNillable(element.isNillable()); + xmlType.setMany(element.getMaxOccurs() > 1); + dataType = new DataTypeImpl<XMLType>(dataBinding, javaType, xmlType); + } + + /** + * @return the element + */ + public XmlSchemaElement getElement() { + return element; + } + + /** + * @return the part + */ + public Part getPart() { + return part; + } + + /** + * @return the dataType + */ + public DataType<XMLType> getDataType() { + return dataType; + } + } + + /** + * The "Wrapper Style" WSDL operation is defined by The Java API for + * XML-Based Web Services (JAX-WS) 2.0 specification, section 2.3.1.2 + * Wrapper Style. <p/> A WSDL operation qualifies for wrapper style mapping + * only if the following criteria are met: + * <ul> + * <li>(i) The operation�s input and output messages (if present) each + * contain only a single part + * <li>(ii) The input message part refers to a global element declaration + * whose localname is equal to the operation name + * <li>(iii) The output message part refers to a global element declaration + * <li>(iv) The elements referred to by the input and output message parts + * (henceforth referred to as wrapper elements) are both complex types + * defined using the xsd:sequence compositor + * <li>(v) The wrapper elements only contain child elements, they must not + * contain other structures such as wildcards (element or attribute), + * xsd:choice, substitution groups (element references are not permitted) or + * attributes; furthermore, they must not be nillable. + * </ul> + */ + public class Wrapper { + private XmlSchemaElement inputWrapperElement; + + private XmlSchemaElement outputWrapperElement; + + private List<XmlSchemaElement> inputElements; + + private List<XmlSchemaElement> outputElements; + + // private DataType<List<DataType<XMLType>>> unwrappedInputType; + // + // private DataType<XMLType> unwrappedOutputType; + + private transient WrapperInfo inputWrapperInfo; + private transient WrapperInfo outputWrapperInfo; + + private List<XmlSchemaElement> getChildElements(XmlSchemaElement element) throws InvalidWSDLException { + if (element == null) { + return null; + } + if (element.isNillable()) { + // Wrapper element cannot be nillable + return null; + } + XmlSchemaType type = element.getSchemaType(); + if (type == null) { + String qName = element.getQName().toString(); + throw new InvalidWSDLException("The XML schema element does not have a type: " + qName); + } + if (!(type instanceof XmlSchemaComplexType)) { + // Has to be a complexType + return null; + } + XmlSchemaComplexType complexType = (XmlSchemaComplexType)type; + if (complexType.getAttributes().getCount() != 0 || complexType.getAnyAttribute() != null) { + // No attributes + return null; + } + XmlSchemaParticle particle = complexType.getParticle(); + if (particle == null) { + // No particle + return Collections.emptyList(); + } + if (!(particle instanceof XmlSchemaSequence)) { + return null; + } + XmlSchemaSequence sequence = (XmlSchemaSequence)complexType.getParticle(); + XmlSchemaObjectCollection items = sequence.getItems(); + List<XmlSchemaElement> childElements = new ArrayList<XmlSchemaElement>(); + for (int i = 0; i < items.getCount(); i++) { + XmlSchemaObject schemaObject = items.getItem(i); + if (!(schemaObject instanceof XmlSchemaElement)) { + // Should contain elements only + return null; + } + XmlSchemaElement childElement = (XmlSchemaElement)schemaObject; + /* + if (childElement.getSubstitutionGroup() != null) { + return null; + } + */ + if (childElement.getName() == null || childElement.getRefName() != null) { + XmlSchemaElement ref = getElement(childElement.getRefName()); + if (ref == null) { + throw new InvalidWSDLException("XML schema element ref cannot be resolved: " + childElement); + } + childElement = ref; + } + if (ANY.equals(childElement.getQName())) { + // Wildcard is not allowed + return null; + } + // TODO: Do we support maxOccurs >1 ? + if (childElement.getMaxOccurs() > 1) { + // TODO: [rfeng] To be implemented + /* + if(logger.isLoggable(Level.WARNING)) { + logger.warning("Support for elements with maxOccurs>1 is not implemented."); + } + */ + // return null; + } + childElements.add(childElement); + } + return childElements; + } + + /** + * Return a list of child XSD elements under the wrapped request element + * + * @return a list of child XSD elements or null if if the request + * element is not wrapped + */ + public List<XmlSchemaElement> getInputChildElements() throws InvalidWSDLException { + if (inputElements != null) { + return inputElements; + } + Input input = operation.getInput(); + if (input != null) { + Message inputMsg = input.getMessage(); + Collection parts = inputMsg.getParts().values(); + if (parts.size() != 1) { + return null; + } + Part part = (Part)parts.iterator().next(); + QName elementName = part.getElementName(); + if (elementName == null) { + return null; + } + if (!operation.getName().equals(elementName.getLocalPart())) { + return null; + } + inputWrapperElement = getElement(elementName); + if (inputWrapperElement == null) { + throw new InvalidWSDLException("The element is not declared in a XML schema: " + elementName + .toString()); + } + if (inputWrapperElement.isNillable()) { + // The wrapper element cannot be nilable + return null; + } + inputElements = getChildElements(inputWrapperElement); + return inputElements; + } else { + return null; + } + } + + /** + * Return a list of child XSD elements under the wrapped response + * element + * + * @return a list of child XSD elements or null if if the response + * element is not wrapped + */ + public List<XmlSchemaElement> getOutputChildElements() throws InvalidWSDLException { + if (outputElements != null) { + return outputElements; + } + Output output = operation.getOutput(); + if (output != null) { + Message outputMsg = output.getMessage(); + Collection parts = outputMsg.getParts().values(); + if (parts.size() != 1) { + return null; + } + Part part = (Part)parts.iterator().next(); + QName elementName = part.getElementName(); + if (elementName == null) { + throw new InvalidWSDLException("The element is not declared in the XML schema: " + part.getName()); + } + outputWrapperElement = WSDLOperationIntrospectorImpl.this.getElement(elementName); + if (outputWrapperElement == null) { + return null; + } + if (outputWrapperElement.isNillable()) { + // The wrapper element cannot be nilable + return null; + } + outputElements = getChildElements(outputWrapperElement); + // FIXME: Do we support multiple child elements for the response? + return outputElements; + } else { + return null; + } + } + + /** + * @return the inputWrapperElement + */ + public XmlSchemaElement getInputWrapperElement() { + return inputWrapperElement; + } + + /** + * @return the outputWrapperElement + */ + public XmlSchemaElement getOutputWrapperElement() { + return outputWrapperElement; + } + + /* + public DataType<List<DataType<XMLType>>> getUnwrappedInputType() throws InvalidWSDLException { + if (unwrappedInputType == null) { + List<DataType<XMLType>> childTypes = new ArrayList<DataType<XMLType>>(); + for (XmlSchemaElement element : getInputChildElements()) { + DataType<XMLType> type = + new DataType<XMLType>(dataBinding, Object.class, new XMLType(getElementInfo(element))); + // type.setMetadata(ElementInfo.class.getName(), getElementInfo(element)); + childTypes.add(type); + } + unwrappedInputType = + new DataType<List<DataType<XMLType>>>("idl:unwrapped.input", Object[].class, childTypes); + } + return unwrappedInputType; + } + + public DataType<XMLType> getUnwrappedOutputType() throws InvalidServiceContractException { + if (unwrappedOutputType == null) { + List<XmlSchemaElement> elements = getOutputChildElements(); + if (elements != null && elements.size() > 0) { + if (elements.size() > 1) { + // We don't support output with multiple parts + throw new NotSupportedWSDLException("Multi-part output is not supported"); + } + XmlSchemaElement element = elements.get(0); + unwrappedOutputType = + new DataType<XMLType>(dataBinding, Object.class, new XMLType(getElementInfo(element))); + // unwrappedOutputType.setMetadata(ElementInfo.class.getName(), getElementInfo(element)); + } + } + return unwrappedOutputType; + } + */ + + public WrapperInfo getInputWrapperInfo() throws InvalidWSDLException { + if (inputWrapperInfo == null) { + ElementInfo in = getElementInfo(getInputWrapperElement()); + List<ElementInfo> inChildren = new ArrayList<ElementInfo>(); + if (in != null) { + for (XmlSchemaElement e : getInputChildElements()) { + inChildren.add(getElementInfo(e)); + } + } + + inputWrapperInfo = new WrapperInfo(dataBinding, in, inChildren); + } + return inputWrapperInfo; + } + + public WrapperInfo getOutputWrapperInfo() throws InvalidWSDLException { + if (outputWrapperInfo == null) { + ElementInfo out = getElementInfo(getOutputWrapperElement()); + List<ElementInfo> outChildren = new ArrayList<ElementInfo>(); + if (out != null) { + for (XmlSchemaElement e : getOutputChildElements()) { + outChildren.add(getElementInfo(e)); + } + } + outputWrapperInfo = new WrapperInfo(dataBinding, out, outChildren); + } + return outputWrapperInfo; + } + } + + private static ElementInfo getElementInfo(XmlSchemaElement element) { + if (element == null) { + return null; + } + ElementInfo elementInfo = new ElementInfo(element.getQName(), getTypeInfo(element.getSchemaType())); + elementInfo.setMany(element.getMaxOccurs() > 1); + elementInfo.setNillable(element.isNillable()); + return elementInfo; + } + + private static TypeInfo getTypeInfo(XmlSchemaType type) { + if (type == null) { + return null; + } + XmlSchemaType baseType = (XmlSchemaType)type.getBaseSchemaType(); + QName name = type.getQName(); + boolean simple = (type instanceof XmlSchemaSimpleType); + if (baseType == null) { + return new TypeInfo(name, simple, null); + } else { + return new TypeInfo(name, simple, getTypeInfo(baseType)); + } + } + +} diff --git a/branches/sca-java-1.5/modules/interface-wsdl/src/main/resources/META-INF/services/org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory b/branches/sca-java-1.5/modules/interface-wsdl/src/main/resources/META-INF/services/org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory new file mode 100644 index 0000000000..c11d22d7b2 --- /dev/null +++ b/branches/sca-java-1.5/modules/interface-wsdl/src/main/resources/META-INF/services/org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory @@ -0,0 +1,18 @@ +# 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. + +org.apache.tuscany.sca.interfacedef.wsdl.DefaultWSDLFactory
\ No newline at end of file |