Author: mageshbk(a)jboss.com Date: 2007-11-29 07:28:47 -0500 (Thu, 29 Nov 2007) New Revision: 5146 Added: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLFactoryImpl.java legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLReaderImpl.java Modified: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/WSDLDefinitionsFactory.java Log: [JBPAPP-460] WSDLDefinitionsFactory doesn't resolve schema references locally Added: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLFactoryImpl.java =================================================================== --- legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLFactoryImpl.java (rev 0) +++ legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLFactoryImpl.java 2007-11-29 12:28:47 UTC (rev 5146) @@ -0,0 +1,83 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2005, JBoss Inc., and individual contributors as indicated + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.ws.tools.wsdl; + +import com.ibm.wsdl.DefinitionImpl; +import com.ibm.wsdl.extensions.PopulatedExtensionRegistry; +import com.ibm.wsdl.xml.WSDLWriterImpl; + +import javax.wsdl.Definition; +import javax.wsdl.extensions.ExtensionRegistry; +import javax.wsdl.factory.WSDLFactory; +import javax.wsdl.xml.WSDLReader; +import javax.wsdl.xml.WSDLWriter; + +/** + * A fork of the original wsdl4j 1.6.2 package + * that delegates to the {@link JBossWSDLReaderImpl}. + * <p> + * Original author: Matthew J. Duftler (duftler(a)us.ibm.com) + * + * @version $Revision$ + */ +public class JBossWSDLFactoryImpl extends WSDLFactory +{ + /** + * Create a new instance of a Definition, with an instance + * of a PopulatedExtensionRegistry as its ExtensionRegistry. + * + * @see com.ibm.wsdl.extensions.PopulatedExtensionRegistry + */ + public Definition newDefinition() + { + Definition def = new DefinitionImpl(); + ExtensionRegistry extReg = newPopulatedExtensionRegistry(); + + def.setExtensionRegistry(extReg); + + return def; + } + + /** + * Create a new instance of a WSDLReader. + */ + public WSDLReader newWSDLReader() + { + return new JBossWSDLReaderImpl(); + } + + public WSDLWriter newWSDLWriter() + { + return new WSDLWriterImpl(); + } + + /** + * Create a new instance of an ExtensionRegistry with pre-registered + * serializers/deserializers for the SOAP, HTTP and MIME + * extensions. Java extensionTypes are also mapped for all + * the SOAP, HTTP and MIME extensions. + */ + public ExtensionRegistry newPopulatedExtensionRegistry() + { + return new PopulatedExtensionRegistry(); + } +} \ No newline at end of file Property changes on: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLFactoryImpl.java ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Added: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLReaderImpl.java =================================================================== --- legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLReaderImpl.java (rev 0) +++ legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLReaderImpl.java 2007-11-29 12:28:47 UTC (rev 5146) @@ -0,0 +1,2372 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2005, JBoss Inc., and individual contributors as indicated + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * This is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.ws.tools.wsdl; + +import com.ibm.wsdl.Constants; +import com.ibm.wsdl.extensions.schema.SchemaConstants; +import com.ibm.wsdl.util.StringUtils; +import com.ibm.wsdl.util.xml.DOMUtils; +import com.ibm.wsdl.util.xml.QNameUtils; +import com.ibm.wsdl.util.xml.XPathUtils; +import org.jboss.ws.core.utils.JBossWSEntityResolver; +import org.w3c.dom.Attr; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.xml.sax.InputSource; + +import javax.wsdl.*; +import javax.wsdl.extensions.AttributeExtensible; +import javax.wsdl.extensions.ExtensibilityElement; +import javax.wsdl.extensions.ExtensionDeserializer; +import javax.wsdl.extensions.ExtensionRegistry; +import javax.wsdl.extensions.schema.Schema; +import javax.wsdl.extensions.schema.SchemaReference; +import javax.wsdl.factory.WSDLFactory; +import javax.wsdl.xml.WSDLLocator; +import javax.wsdl.xml.WSDLReader; +import javax.xml.namespace.QName; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import java.io.InputStream; +import java.net.URL; +import java.util.*; + + +/** + * A WSDLReader fork of the original wsdl4j 1.6.2 package + * that delegates to the JBossWSEntityResolver in + * <code>private static Document getDocument(InputSource inputSource,String desc)</code> + * <p> + * Original authors: Matthew J. Duftler,Nirmal Mukhi + * + * @version $Revision$ + */ +public class JBossWSDLReaderImpl implements WSDLReader +{ + // Used for determining the style of operations. + private static final List STYLE_ONE_WAY = + Arrays.asList(new String[]{Constants.ELEM_INPUT}); + private static final List STYLE_REQUEST_RESPONSE = + Arrays.asList(new String[]{Constants.ELEM_INPUT, Constants.ELEM_OUTPUT}); + private static final List STYLE_SOLICIT_RESPONSE = + Arrays.asList(new String[]{Constants.ELEM_OUTPUT, Constants.ELEM_INPUT}); + private static final List STYLE_NOTIFICATION = + Arrays.asList(new String[]{Constants.ELEM_OUTPUT}); + + protected boolean verbose = true; + protected boolean importDocuments = true; + protected ExtensionRegistry extReg = null; + protected String factoryImplName = null; + protected WSDLLocator loc = null; + protected WSDLFactory factory = null; + + //Contains all schemas used by this wsdl, either in-line or nested + //via wsdl imports or schema imports, includes or redefines + protected Map allSchemas = new Hashtable(); + + + /** + * Sets the specified feature to the specified value. + * <p> + * The supported features are: + * <p> + * <table border=1> + * <tr> + * <th>Name</th> + * <th>Description</th> + * <th>Default Value</th> + * </tr> + * <tr> + * <td><center>javax.wsdl.verbose</center></td> + * <td>If set to true, status messages will be displayed.</td> + * <td><center>true</center></td> + * </tr> + * <tr> + * <td><center>javax.wsdl.importDocuments</center></td> + * <td>If set to true, imported WSDL documents will be + * retrieved and processed.</td> + * <td><center>true</center></td> + * </tr> + * </table> + * <p> + * All feature names must be fully-qualified, Java package style. All + * names starting with javax.wsdl. are reserved for features defined + * by the JWSDL specification. It is recommended that implementation- + * specific features be fully-qualified to match the package name + * of that implementation. For example: com.abc.featureName + * + * @param name the name of the feature to be set. + * @param value the value to set the feature to. + * @throws IllegalArgumentException if the feature name is not recognized. + * @see #getFeature(String) + */ + public void setFeature(String name, boolean value) + throws IllegalArgumentException + { + if (name == null) + { + throw new IllegalArgumentException("Feature name must not be null."); + } + + if (name.equals(Constants.FEATURE_VERBOSE)) + { + verbose = value; + } + else if (name.equals(Constants.FEATURE_IMPORT_DOCUMENTS)) + { + importDocuments = value; + } + else + { + throw new IllegalArgumentException("Feature name '" + name + + "' not recognized."); + } + } + + /** + * Gets the value of the specified feature. + * + * @param name the name of the feature to get the value of. + * @return the value of the feature. + * @throws IllegalArgumentException if the feature name is not recognized. + * @see #setFeature(String, boolean) + */ + public boolean getFeature(String name) throws IllegalArgumentException + { + if (name == null) + { + throw new IllegalArgumentException("Feature name must not be null."); + } + + if (name.equals(Constants.FEATURE_VERBOSE)) + { + return verbose; + } + else if (name.equals(Constants.FEATURE_IMPORT_DOCUMENTS)) + { + return importDocuments; + } + else + { + throw new IllegalArgumentException("Feature name '" + name + + "' not recognized."); + } + } + + /** + * Set the extension registry to be used when reading + * WSDL documents into a WSDL definition. If an + * extension registry is set, that is the extension + * registry that will be set as the extensionRegistry + * property of the definitions resulting from invoking + * readWSDL(...). Default is null. + * + * @param extReg the extension registry to use for new + * definitions + */ + public void setExtensionRegistry(ExtensionRegistry extReg) + { + this.extReg = extReg; + } + + /** + * Get the extension registry, if one was set. Default is + * null. + */ + public ExtensionRegistry getExtensionRegistry() + { + return extReg; + } + + /** + * Get the WSDLFactory object cached in the reader, or use lazy + * instantiation if it is not cached yet. + */ + protected WSDLFactory getWSDLFactory() throws WSDLException + { + if (factory == null) + { + factory = (factoryImplName != null) + ? WSDLFactory.newInstance(factoryImplName) + : WSDLFactory.newInstance(); + } + return factory; + } + + /** + * Set a different factory implementation to use for + * creating definitions when reading WSDL documents. + * As some WSDLReader implementations may only be + * capable of creating definitions using the same + * factory implementation from which the reader was + * obtained, this method is optional. Default is null. + * + * @param factoryImplName the fully-qualified class name of the + * class which provides a concrete implementation of the abstract + * class WSDLFactory. + * @throws UnsupportedOperationException if this method + * is invoked on an implementation which does not + * support it. + */ + public void setFactoryImplName(String factoryImplName) + throws UnsupportedOperationException + { + //check to see if we really need to change the factory name and clear the cache + if((this.factoryImplName == null && factoryImplName != null) || + (this.factoryImplName != null && !this.factoryImplName.equals(factoryImplName))) + { + //the factory object is cached in the reader so set it + //to null if the factory impl name is reset. + this.factory = null; + + this.factoryImplName = factoryImplName; + //if(verbose) System.out.println("WSDLFactory Impl Name set to : "+factoryImplName); + } + } + + /** + * Get the factoryImplName, if one was set. Default is null. + */ + public String getFactoryImplName() + { + return factoryImplName; + } + + protected Definition parseDefinitions(String documentBaseURI, + Element defEl, + Map importedDefs) + throws WSDLException + { + checkElementName(defEl, Constants.Q_ELEM_DEFINITIONS); + + WSDLFactory factory = getWSDLFactory(); + Definition def = factory.newDefinition(); + + if (extReg != null) + { + def.setExtensionRegistry(extReg); + } + + String name = DOMUtils.getAttribute(defEl, Constants.ATTR_NAME); + String targetNamespace = DOMUtils.getAttribute(defEl, + Constants.ATTR_TARGET_NAMESPACE); + NamedNodeMap attrs = defEl.getAttributes(); + + if (importedDefs == null) + { + importedDefs = new Hashtable(); + } + + if (documentBaseURI != null) + { + def.setDocumentBaseURI(documentBaseURI); + importedDefs.put(documentBaseURI, def); + } + + if (name != null) + { + def.setQName(new QName(targetNamespace, name)); + } + + if (targetNamespace != null) + { + def.setTargetNamespace(targetNamespace); + } + + int size = attrs.getLength(); + + for (int i = 0; i < size; i++) + { + Attr attr = (Attr)attrs.item(i); + String namespaceURI = attr.getNamespaceURI(); + String localPart = attr.getLocalName(); + String value = attr.getValue(); + + if (namespaceURI != null && namespaceURI.equals(Constants.NS_URI_XMLNS)) + { + if (localPart != null && !localPart.equals(Constants.ATTR_XMLNS)) + { + def.addNamespace(localPart, value); + } + else + { + def.addNamespace(null, value); + } + } + } + + Element tempEl = DOMUtils.getFirstChildElement(defEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_IMPORT, tempEl)) + { + def.addImport(parseImport(tempEl, def, importedDefs)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + def.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_TYPES, tempEl)) + { + def.setTypes(parseTypes(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_MESSAGE, tempEl)) + { + def.addMessage(parseMessage(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_PORT_TYPE, tempEl)) + { + def.addPortType(parsePortType(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_BINDING, tempEl)) + { + def.addBinding(parseBinding(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_SERVICE, tempEl)) + { + def.addService(parseService(tempEl, def)); + } + else + { + def.addExtensibilityElement( + parseExtensibilityElement(Definition.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(defEl, Definition.class, def, def); + + return def; + } + + protected Import parseImport(Element importEl, + Definition def, + Map importedDefs) + throws WSDLException + { + Import importDef = def.createImport(); + + try + { + String namespaceURI = DOMUtils.getAttribute(importEl, + Constants.ATTR_NAMESPACE); + String locationURI = DOMUtils.getAttribute(importEl, + Constants.ATTR_LOCATION); + String contextURI = null; + + if (namespaceURI != null) + { + importDef.setNamespaceURI(namespaceURI); + } + + if (locationURI != null) + { + importDef.setLocationURI(locationURI); + + if (importDocuments) + { + try + { + contextURI = def.getDocumentBaseURI(); + Definition importedDef = null; + InputStream inputStream = null; + InputSource inputSource = null; + URL url = null; + + if (loc != null) + { + inputSource = loc.getImportInputSource(contextURI, locationURI); + + /* + We now have available the latest import URI. This might + differ from the locationURI so check the importedDefs for it + since it is this that we pass as the documentBaseURI later. + */ + String liu = loc.getLatestImportURI(); + + importedDef = (Definition)importedDefs.get(liu); + + inputSource.setSystemId(liu); + } + else + { + URL contextURL = (contextURI != null) + ? StringUtils.getURL(null, contextURI) + : null; + + url = StringUtils.getURL(contextURL, locationURI); + importedDef = (Definition)importedDefs.get(url.toString()); + + if (importedDef == null) + { + inputStream = StringUtils.getContentAsInputStream(url); + + if (inputStream != null) + { + inputSource = new InputSource(inputStream); + inputSource.setSystemId(url.toString()); + } + } + } + + if (importedDef == null) + { + if (inputSource == null) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to locate imported document " + + "at '" + locationURI + "'" + + (contextURI == null + ? "." + : ", relative to '" + contextURI + + "'.")); + } + + Document doc = getDocument(inputSource, inputSource.getSystemId()); + + if (inputStream != null) + { + inputStream.close(); + } + + Element documentElement = doc.getDocumentElement(); + + /* + Check if it's a wsdl document. + If it's not, don't retrieve and process it. + This should later be extended to allow other types of + documents to be retrieved and processed, such as schema + documents (".xsd"), etc... + */ + if (QNameUtils.matches(Constants.Q_ELEM_DEFINITIONS, + documentElement)) + { + if (verbose) + { + System.out.println("Retrieving document at '" + locationURI + + "'" + + (contextURI == null + ? "." + : ", relative to '" + contextURI + "'.")); + } + + String urlString = + (loc != null) + ? loc.getLatestImportURI() + : (url != null) + ? url.toString() + : locationURI; + + importedDef = readWSDL(urlString, + documentElement, + importedDefs); + } + else + { + QName docElementQName = QNameUtils.newQName(documentElement); + + if (SchemaConstants.XSD_QNAME_LIST.contains(docElementQName)) + { + if (verbose) + { + System.out.println("Retrieving schema wsdl:imported from '" + locationURI + + "'" + + (contextURI == null + ? "." + : ", relative to '" + contextURI + "'.")); + } + + WSDLFactory factory = getWSDLFactory(); + + importedDef = factory.newDefinition(); + + if (extReg != null) + { + importedDef.setExtensionRegistry(extReg); + } + + String urlString = + (loc != null) + ? loc.getLatestImportURI() + : (url != null) + ? url.toString() + : locationURI; + + importedDef.setDocumentBaseURI(urlString); + + Types types = importedDef.createTypes(); + types.addExtensibilityElement( + parseSchema(Types.class, documentElement, importedDef)); + importedDef.setTypes(types); + } + } + } + + if (importedDef != null) + { + importDef.setDefinition(importedDef); + } + } + catch (WSDLException e) + { + throw e; + } + catch (RuntimeException e) + { + throw e; + } + catch (Exception e) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to resolve imported document at '" + + locationURI + + (contextURI == null + ? "'." : "', relative to '" + contextURI + "'") + , e); + } + } //end importDocs + } //end locationURI + + } + catch (WSDLException e) + { + if (e.getLocation() == null) + { + e.setLocation(XPathUtils.getXPathExprFromNode(importEl)); + } + else + { + //If definitions are being parsed recursively for nested imports + //the exception location must be built up recursively too so + //prepend this element's xpath to exception location. + String loc = XPathUtils.getXPathExprFromNode(importEl) + e.getLocation(); + e.setLocation(loc); + } + + throw e; + } + + //register any NS decls with the Definition + NamedNodeMap attrs = importEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(importEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + importDef.setDocumentationElement(tempEl); + } + else + { + importDef.addExtensibilityElement( + parseExtensibilityElement(Import.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(importEl, Import.class, importDef, def); + + return importDef; + + } + + protected Types parseTypes(Element typesEl, Definition def) + throws WSDLException + { + //register any NS decls with the Definition + NamedNodeMap attrs = typesEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Types types = def.createTypes(); + Element tempEl = DOMUtils.getFirstChildElement(typesEl); + QName tempElType; + + while (tempEl != null) + { + tempElType = QNameUtils.newQName(tempEl); + + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + types.setDocumentationElement(tempEl); + } + else if ((SchemaConstants.XSD_QNAME_LIST).contains(tempElType)) + { + //the element qname indicates it is a schema. + types.addExtensibilityElement( + parseSchema(Types.class, tempEl, def)); + } + else + { + types.addExtensibilityElement( + parseExtensibilityElement(Types.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(typesEl, Types.class, types, def); + + return types; + } + + protected ExtensibilityElement parseSchema( Class parentType, + Element el, + Definition def) + throws WSDLException + { + QName elementType = null; + ExtensionRegistry extReg = null; + + try + { + extReg = def.getExtensionRegistry(); + + if (extReg == null) + { + throw new WSDLException(WSDLException.CONFIGURATION_ERROR, + "No ExtensionRegistry set for this " + + "Definition, so unable to deserialize " + + "a '" + elementType + "' element in the " + + "context of a '" + parentType.getName() + + "'."); + } + + return parseSchema(parentType, el, def, extReg); + } + catch (WSDLException e) + { + if (e.getLocation() == null) + { + e.setLocation(XPathUtils.getXPathExprFromNode(el)); + } + + throw e; + } + } + + + protected ExtensibilityElement parseSchema( Class parentType, + Element el, + Definition def, + ExtensionRegistry extReg) + throws WSDLException + { + /* + * This method returns ExtensibilityElement rather than Schema because we + * do not insist that a suitable XSD schema deserializer is registered. + * PopulatedExtensionRegistry registers SchemaDeserializer by default, but + * if the user chooses not to register a suitable deserializer then the + * UnknownDeserializer will be used, returning an UnknownExtensibilityElement. + */ + + Schema schema = null; + SchemaReference schemaRef = null; + try + { + + QName elementType = QNameUtils.newQName(el); + + ExtensionDeserializer exDS = + extReg.queryDeserializer(parentType, elementType); + + //Now unmarshall the DOM element. + ExtensibilityElement ee = + exDS.unmarshall(parentType, elementType, el, def, extReg); + + if (ee instanceof Schema) + { + schema = (Schema) ee; + } + else + { + //Unknown extensibility element, so don't do any more schema parsing on it. + return ee; + } + + + //Keep track of parsed schemas to avoid duplicating Schema objects + //through duplicate or circular references (eg: A imports B imports A). + if (schema.getDocumentBaseURI() != null) + { + this.allSchemas.put(schema.getDocumentBaseURI(), schema); + } + + //At this point, any SchemaReference objects held by the schema will not + //yet point to their referenced schemas, so we must now retrieve these + //schemas and set the schema references. + + //First, combine the schema references for imports, includes and redefines + //into a single list + + ArrayList allSchemaRefs = new ArrayList(); + + Collection ic = schema.getImports().values(); + Iterator importsIterator = ic.iterator(); + while(importsIterator.hasNext()) + { + allSchemaRefs.addAll( (Collection) importsIterator.next() ); + } + + allSchemaRefs.addAll(schema.getIncludes()); + allSchemaRefs.addAll(schema.getRedefines()); + + //Then, retrieve the schema referred to by each schema reference. If the + //schema has been read in previously, use the existing schema object. + //Otherwise unmarshall the DOM element into a new schema object. + + ListIterator schemaRefIterator = allSchemaRefs.listIterator(); + + while(schemaRefIterator.hasNext()) + { + try + { + schemaRef = (SchemaReference) schemaRefIterator.next(); + + if (schemaRef.getSchemaLocationURI() == null) + { + //cannot get the referenced schema, so ignore this schema reference + continue; + } + + if (verbose) + { + System.out.println("Retrieving schema at '" + + schemaRef.getSchemaLocationURI() + + (schema.getDocumentBaseURI() == null + ? "'." + : "', relative to '" + + schema.getDocumentBaseURI() + "'.")); + } + + + InputStream inputStream = null; + InputSource inputSource = null; + + //This is the child schema referred to by the schemaReference + Schema referencedSchema = null; + + //This is the child schema's location obtained from the WSDLLocator or the URL + String location = null; + + if (loc != null) + { + //Try to get the referenced schema using the wsdl locator + inputSource = loc.getImportInputSource( + schema.getDocumentBaseURI(), schemaRef.getSchemaLocationURI()); + + if (inputSource == null) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to locate with a locator " + + "the schema referenced at '" + + schemaRef.getSchemaLocationURI() + + "' relative to document base '" + + schema.getDocumentBaseURI() + "'"); + } + location = loc.getLatestImportURI(); + + //if a schema from this location has been read previously, use it. + referencedSchema = (Schema) this.allSchemas.get(location); + } + else + { + // We don't have a wsdl locator, so try to retrieve the schema by its URL + String contextURI = schema.getDocumentBaseURI(); + URL contextURL = (contextURI != null) ? StringUtils.getURL(null, contextURI) : null; + URL url = StringUtils.getURL(contextURL, schemaRef.getSchemaLocationURI()); + location = url.toExternalForm(); + + //if a schema from this location has been retrieved previously, use it. + referencedSchema = (Schema) this.allSchemas.get(location); + + if (referencedSchema == null) + { + // We haven't read this schema in before so do it now + inputStream = StringUtils.getContentAsInputStream(url); + + if (inputStream != null) + { + inputSource = new InputSource(inputStream); + } + + if (inputSource == null) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to locate with a url " + + "the document referenced at '" + + schemaRef.getSchemaLocationURI() + + "'" + + (contextURI == null ? "." : ", relative to '" + + contextURI + "'.")); + } + } + + } //end if loc + + // If we have not previously read the schema, get its DOM element now. + if (referencedSchema == null) + { + inputSource.setSystemId(location); + Document doc = getDocument(inputSource, location); + + if (inputStream != null) + { + inputStream.close(); + } + + Element documentElement = doc.getDocumentElement(); + + // If it's a schema doc process it, otherwise the schema reference remains null + + QName docElementQName = QNameUtils.newQName(documentElement); + + if (SchemaConstants.XSD_QNAME_LIST.contains(docElementQName)) + { + //We now need to call parseSchema recursively to parse the referenced + //schema. The document base URI of the referenced schema will be set to + //the document base URI of the current schema plus the schemaLocation in + //the schemaRef. We cannot explicitly pass in a new document base URI + //to the schema deserializer, so instead we will create a dummy + //Definition and set its documentBaseURI to the new document base URI. + //We can leave the other definition fields empty because we know + //that the SchemaDeserializer.unmarshall method uses the definition + //parameter only to get its documentBaseURI. If the unmarshall method + //implementation changes (ie: its use of definition changes) we may need + //to rethink this approach. + + WSDLFactory factory = getWSDLFactory(); + Definition dummyDef = factory.newDefinition(); + + dummyDef.setDocumentBaseURI(location); + + //By this point, we know we have a SchemaDeserializer registered + //so we can safely cast the ExtensibilityElement to a Schema. + referencedSchema = (Schema) parseSchema( parentType, + documentElement, + dummyDef, + extReg); + } + + } //end if referencedSchema + + schemaRef.setReferencedSchema(referencedSchema); + } + catch (WSDLException e) + { + throw e; + } + catch (RuntimeException e) + { + throw e; + } + catch (Exception e) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "An error occurred trying to resolve schema referenced at '" + + schemaRef.getSchemaLocationURI() + + "'" + + (schema.getDocumentBaseURI() == null ? "." : ", relative to '" + + schema.getDocumentBaseURI() + "'."), + e); + } + + } //end while loop + + return schema; + + } + catch (WSDLException e) + { + if (e.getLocation() == null) + { + e.setLocation(XPathUtils.getXPathExprFromNode(el)); + } + else + { + //If this method has been called recursively for nested schemas + //the exception location must be built up recursively too so + //prepend this element's xpath to exception location. + String loc = XPathUtils.getXPathExprFromNode(el) + e.getLocation(); + e.setLocation(loc); + } + + throw e; + } + + } + + + protected Binding parseBinding(Element bindingEl, Definition def) + throws WSDLException + { + Binding binding = null; + + List remainingAttrs = DOMUtils.getAttributes(bindingEl); + String name = DOMUtils.getAttribute(bindingEl, Constants.ATTR_NAME, remainingAttrs); + QName portTypeName = getQualifiedAttributeValue(bindingEl, + Constants.ATTR_TYPE, + Constants.ELEM_BINDING, + def, + remainingAttrs); + + PortType portType = null; + + if (name != null) + { + QName bindingName = new QName(def.getTargetNamespace(), name); + + binding = def.getBinding(bindingName); + + if (binding == null) + { + binding = def.createBinding(); + binding.setQName(bindingName); + } + } + else + { + binding = def.createBinding(); + } + + // Whether it was retrieved or created, the definition has been found. + binding.setUndefined(false); + + if (portTypeName != null) + { + portType = def.getPortType(portTypeName); + + if (portType == null) + { + portType = def.createPortType(); + portType.setQName(portTypeName); + def.addPortType(portType); + } + + binding.setPortType(portType); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = bindingEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(bindingEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + binding.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_OPERATION, tempEl)) + { + binding.addBindingOperation(parseBindingOperation(tempEl, + portType, + def)); + } + else + { + binding.addExtensibilityElement(parseExtensibilityElement( + Binding.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + return binding; + } + + protected BindingOperation parseBindingOperation( + Element bindingOperationEl, + PortType portType, + Definition def) + throws WSDLException + { + BindingOperation bindingOperation = def.createBindingOperation(); + + List remainingAttrs = DOMUtils.getAttributes(bindingOperationEl); + String name = DOMUtils.getAttribute(bindingOperationEl, + Constants.ATTR_NAME, + remainingAttrs); + + if (name != null) + { + bindingOperation.setName(name); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = bindingOperationEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(bindingOperationEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + bindingOperation.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_INPUT, tempEl)) + { + bindingOperation.setBindingInput(parseBindingInput(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_OUTPUT, tempEl)) + { + bindingOperation.setBindingOutput(parseBindingOutput(tempEl, def)); + } + else if (QNameUtils.matches(Constants.Q_ELEM_FAULT, tempEl)) + { + bindingOperation.addBindingFault(parseBindingFault(tempEl, def)); + } + else + { + bindingOperation.addExtensibilityElement( + parseExtensibilityElement(BindingOperation.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + if (portType != null) + { + BindingInput bindingInput = bindingOperation.getBindingInput(); + BindingOutput bindingOutput = bindingOperation.getBindingOutput(); + String inputName = (bindingInput != null + ? (bindingInput.getName() != null ? bindingInput.getName() : Constants.NONE) + : null); + String outputName = (bindingOutput != null + ? (bindingOutput.getName() != null ? bindingOutput.getName() : Constants.NONE) + : null); + Operation op = portType.getOperation(name, inputName, outputName); + + /* + * If the bindingOp input or output message names are null we will search first + * for a porttypeOp with corresponding unnamed input or output messages (using + * Constants.NONE for inputName or outputName, as above). + * However, input and output message names need not be used at all if operation + * overloading is not used, so if no match was found we will try again ignoring + * these unnamed messages from the search criteria (i.e. using null instead of + * Constants.NONE for inputName or outputName). + */ + + if(op == null) + { + if(Constants.NONE.equals(inputName) && Constants.NONE.equals(outputName)) + { + //There was no porttype op with unnamed input and output messages, + //so ignore input and output name and search on the op name only. + op = portType.getOperation(name, null, null); + } + else if(Constants.NONE.equals(inputName)) + { + //There was no porttype op with an unnamed input message, + //so ignore input name and search on the op name and output name only. + op = portType.getOperation(name, null, outputName); + } + else if(Constants.NONE.equals(outputName)) + { + //There was no porttype op with an unnamed output message, + //so ignore output name and search on the op name and input name only. + op = portType.getOperation(name, inputName, null); + } + } + + if (op == null) + { + Input input = def.createInput(); + Output output = def.createOutput(); + + op = def.createOperation(); + op.setName(name); + input.setName(inputName); + output.setName(outputName); + op.setInput(input); + op.setOutput(output); + portType.addOperation(op); + } + + bindingOperation.setOperation(op); + } + + parseExtensibilityAttributes(bindingOperationEl, BindingOperation.class, bindingOperation, def); + + return bindingOperation; + } + + protected BindingInput parseBindingInput(Element bindingInputEl, + Definition def) + throws WSDLException + { + BindingInput bindingInput = def.createBindingInput(); + + List remainingAttrs = DOMUtils.getAttributes(bindingInputEl); + String name = DOMUtils.getAttribute(bindingInputEl, + Constants.ATTR_NAME, + remainingAttrs); + + if (name != null) + { + bindingInput.setName(name); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = bindingInputEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(bindingInputEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + bindingInput.setDocumentationElement(tempEl); + } + else + { + bindingInput.addExtensibilityElement( + parseExtensibilityElement(BindingInput.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + return bindingInput; + } + + protected BindingOutput parseBindingOutput(Element bindingOutputEl, + Definition def) + throws WSDLException + { + BindingOutput bindingOutput = def.createBindingOutput(); + + List remainingAttrs = DOMUtils.getAttributes(bindingOutputEl); + String name = DOMUtils.getAttribute(bindingOutputEl, + Constants.ATTR_NAME, + remainingAttrs); + + if (name != null) + { + bindingOutput.setName(name); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = bindingOutputEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(bindingOutputEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + bindingOutput.setDocumentationElement(tempEl); + } + else + { + bindingOutput.addExtensibilityElement( + parseExtensibilityElement(BindingOutput.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + return bindingOutput; + } + + protected BindingFault parseBindingFault(Element bindingFaultEl, + Definition def) + throws WSDLException + { + BindingFault bindingFault = def.createBindingFault(); + + List remainingAttrs = DOMUtils.getAttributes(bindingFaultEl); + String name = DOMUtils.getAttribute(bindingFaultEl, + Constants.ATTR_NAME, + remainingAttrs); + + if (name != null) + { + bindingFault.setName(name); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = bindingFaultEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(bindingFaultEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + bindingFault.setDocumentationElement(tempEl); + } + else + { + bindingFault.addExtensibilityElement( + parseExtensibilityElement(BindingFault.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(bindingFaultEl, BindingFault.class, bindingFault, def); + + return bindingFault; + } + + protected Message parseMessage(Element msgEl, Definition def) + throws WSDLException + { + Message msg = null; + + List remainingAttrs = DOMUtils.getAttributes(msgEl); + String name = DOMUtils.getAttribute(msgEl, Constants.ATTR_NAME, remainingAttrs); + + if (name != null) + { + QName messageName = new QName(def.getTargetNamespace(), name); + + msg = def.getMessage(messageName); + + if (msg == null) + { + msg = def.createMessage(); + msg.setQName(messageName); + } + } + else + { + msg = def.createMessage(); + } + + // Whether it was retrieved or created, the definition has been found. + msg.setUndefined(false); + + //register any NS decls with the Definition + NamedNodeMap attrs = msgEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(msgEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + msg.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_PART, tempEl)) + { + msg.addPart(parsePart(tempEl, def)); + } + else + { + msg.addExtensibilityElement( + parseExtensibilityElement(Message.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(msgEl, Message.class, msg, def); + + return msg; + } + + protected Part parsePart(Element partEl, Definition def) + throws WSDLException + { + Part part = def.createPart(); + String name = DOMUtils.getAttribute(partEl, Constants.ATTR_NAME); + QName elementName = getQualifiedAttributeValue(partEl, + Constants.ATTR_ELEMENT, + Constants.ELEM_MESSAGE, + def); + QName typeName = getQualifiedAttributeValue(partEl, + Constants.ATTR_TYPE, + Constants.ELEM_MESSAGE, + def); + + if (name != null) + { + part.setName(name); + } + + if (elementName != null) + { + part.setElementName(elementName); + } + + if (typeName != null) + { + part.setTypeName(typeName); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = partEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(partEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + part.setDocumentationElement(tempEl); + } + else + { + part.addExtensibilityElement( + parseExtensibilityElement(Part.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(partEl, Part.class, part, def); + + return part; + } + + protected void parseExtensibilityAttributes(Element el, + Class parentType, + AttributeExtensible attrExt, + Definition def) + throws WSDLException + { + List nativeAttributeNames = attrExt.getNativeAttributeNames(); + NamedNodeMap nodeMap = el.getAttributes(); + int length = nodeMap.getLength(); + + for (int i = 0; i < length; i++) + { + Attr attribute = (Attr)nodeMap.item(i); + String localName = attribute.getLocalName(); + String namespaceURI = attribute.getNamespaceURI(); + String prefix = attribute.getPrefix(); + QName qname = new QName(namespaceURI, localName); + + if (namespaceURI != null && !namespaceURI.equals(Constants.NS_URI_WSDL)) + { + if (!namespaceURI.equals(Constants.NS_URI_XMLNS)) + { + DOMUtils.registerUniquePrefix(prefix, namespaceURI, def); + + String strValue = attribute.getValue(); + int attrType = AttributeExtensible.NO_DECLARED_TYPE; + ExtensionRegistry extReg = def.getExtensionRegistry(); + + if (extReg != null) + { + attrType = extReg.queryExtensionAttributeType(parentType, qname); + } + + Object val = parseExtensibilityAttribute(el, attrType, strValue, def); + + attrExt.setExtensionAttribute(qname, val); + } + } + else if (!nativeAttributeNames.contains(localName)) + { + WSDLException wsdlExc = new WSDLException(WSDLException.INVALID_WSDL, + "Encountered illegal " + + "extension attribute '" + + qname + "'. Extension " + + "attributes must be in " + + "a namespace other than " + + "WSDL's."); + + wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(el)); + + throw wsdlExc; + } + } + } + + protected Object parseExtensibilityAttribute(Element el, + int attrType, + String attrValue, + Definition def) + throws WSDLException + { + if (attrType == AttributeExtensible.QNAME_TYPE) + { + return DOMUtils.getQName(attrValue, el, def); + } + else if (attrType == AttributeExtensible.LIST_OF_STRINGS_TYPE) + { + return StringUtils.parseNMTokens(attrValue); + } + else if (attrType == AttributeExtensible.LIST_OF_QNAMES_TYPE) + { + List oldList = StringUtils.parseNMTokens(attrValue); + int size = oldList.size(); + List newList = new Vector(size); + + for (int i = 0; i < size; i++) + { + String str = (String)oldList.get(i); + QName qValue = DOMUtils.getQName(str, el, def); + + newList.add(qValue); + } + + return newList; + } + else if (attrType == AttributeExtensible.STRING_TYPE) + { + return attrValue; + } + else + { + QName qValue = null; + + try + { + qValue = DOMUtils.getQName(attrValue, el, def); + } + catch (WSDLException e) + { + qValue = new QName(attrValue); + } + + return qValue; + } + } + + protected PortType parsePortType(Element portTypeEl, Definition def) + throws WSDLException + { + PortType portType = null; + String name = DOMUtils.getAttribute(portTypeEl, Constants.ATTR_NAME); + + if (name != null) + { + QName portTypeName = new QName(def.getTargetNamespace(), name); + + portType = def.getPortType(portTypeName); + + if (portType == null) + { + portType = def.createPortType(); + portType.setQName(portTypeName); + } + } + else + { + portType = def.createPortType(); + } + + // Whether it was retrieved or created, the definition has been found. + portType.setUndefined(false); + + //register any NS decls with the Definition + NamedNodeMap attrs = portTypeEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(portTypeEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + portType.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_OPERATION, tempEl)) + { + Operation op = parseOperation(tempEl, portType, def); + + if (op != null) + { + portType.addOperation(op); + } + } + else + { + portType.addExtensibilityElement( + parseExtensibilityElement(PortType.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(portTypeEl, PortType.class, portType, def); + + return portType; + } + + protected Operation parseOperation(Element opEl, + PortType portType, + Definition def) + throws WSDLException + { + Operation op = null; + + List remainingAttrs = DOMUtils.getAttributes(opEl); + String name = DOMUtils.getAttribute(opEl, Constants.ATTR_NAME, remainingAttrs); + String parameterOrderStr = DOMUtils.getAttribute(opEl, + Constants.ATTR_PARAMETER_ORDER, + remainingAttrs); + + //register any NS decls with the Definition + NamedNodeMap attrs = opEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(opEl); + List messageOrder = new Vector(); + Element docEl = null; + Input input = null; + Output output = null; + List faults = new Vector(); + List extElements = new Vector(); + boolean retrieved = true; + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + docEl = tempEl; + } + else if (QNameUtils.matches(Constants.Q_ELEM_INPUT, tempEl)) + { + input = parseInput(tempEl, def); + messageOrder.add(Constants.ELEM_INPUT); + } + else if (QNameUtils.matches(Constants.Q_ELEM_OUTPUT, tempEl)) + { + output = parseOutput(tempEl, def); + messageOrder.add(Constants.ELEM_OUTPUT); + } + else if (QNameUtils.matches(Constants.Q_ELEM_FAULT, tempEl)) + { + faults.add(parseFault(tempEl, def)); + } + else + { + extElements.add( + parseExtensibilityElement(Operation.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + if (name != null) + { + String inputName = (input != null + ? (input.getName() != null ? input.getName() : Constants.NONE) + : null); + String outputName = (output != null + ? (output.getName() != null ? output.getName() : Constants.NONE) + : null); + + op = portType.getOperation(name, inputName, outputName); + + if (op != null && !op.isUndefined()) + { + op = null; + } + + if (op != null) + { + if (inputName == null) + { + Input tempIn = op.getInput(); + + if (tempIn != null) + { + if (tempIn.getName() != null) + { + op = null; + } + } + } + } + + if (op != null) + { + if (outputName == null) + { + Output tempOut = op.getOutput(); + + if (tempOut != null) + { + if (tempOut.getName() != null) + { + op = null; + } + } + } + } + + if (op == null) + { + op = def.createOperation(); + op.setName(name); + retrieved = false; + } + } + else + { + op = def.createOperation(); + retrieved = false; + } + + // Whether it was retrieved or created, the definition has been found. + op.setUndefined(false); + + if (parameterOrderStr != null) + { + op.setParameterOrdering(StringUtils.parseNMTokens(parameterOrderStr)); + } + + if (docEl != null) + { + op.setDocumentationElement(docEl); + } + + if (input != null) + { + op.setInput(input); + } + + if (output != null) + { + op.setOutput(output); + } + + if (faults.size() > 0) + { + Iterator faultIterator = faults.iterator(); + + while (faultIterator.hasNext()) + { + op.addFault((Fault)faultIterator.next()); + } + } + + if (extElements.size() > 0) + { + Iterator eeIterator = extElements.iterator(); + + while (eeIterator.hasNext()) + { + op.addExtensibilityElement( + (ExtensibilityElement) eeIterator.next() ); + } + } + + OperationType style = null; + + if (messageOrder.equals(STYLE_ONE_WAY)) + { + style = OperationType.ONE_WAY; + } + else if (messageOrder.equals(STYLE_REQUEST_RESPONSE)) + { + style = OperationType.REQUEST_RESPONSE; + } + else if (messageOrder.equals(STYLE_SOLICIT_RESPONSE)) + { + style = OperationType.SOLICIT_RESPONSE; + } + else if (messageOrder.equals(STYLE_NOTIFICATION)) + { + style = OperationType.NOTIFICATION; + } + + if (style != null) + { + op.setStyle(style); + } + + if (retrieved) + { + op = null; + } + + parseExtensibilityAttributes(opEl, Operation.class, op, def); + + return op; + } + + protected Service parseService(Element serviceEl, Definition def) + throws WSDLException + { + Service service = def.createService(); + + List remainingAttrs = DOMUtils.getAttributes(serviceEl); + String name = DOMUtils.getAttribute(serviceEl, Constants.ATTR_NAME, remainingAttrs); + + if (name != null) + { + service.setQName(new QName(def.getTargetNamespace(), name)); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = serviceEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(serviceEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + service.setDocumentationElement(tempEl); + } + else if (QNameUtils.matches(Constants.Q_ELEM_PORT, tempEl)) + { + service.addPort(parsePort(tempEl, def)); + } + else + { + service.addExtensibilityElement( + parseExtensibilityElement(Service.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(serviceEl, Service.class, service, def); + + return service; + } + + protected Port parsePort(Element portEl, Definition def) + throws WSDLException + { + Port port = def.createPort(); + + List remainingAttrs = DOMUtils.getAttributes(portEl); + String name = DOMUtils.getAttribute(portEl, Constants.ATTR_NAME, remainingAttrs); + QName bindingStr = getQualifiedAttributeValue(portEl, + Constants.ATTR_BINDING, + Constants.ELEM_PORT, + def, + remainingAttrs); + + if (name != null) + { + port.setName(name); + } + + if (bindingStr != null) + { + Binding binding = def.getBinding(bindingStr); + + if (binding == null) + { + binding = def.createBinding(); + binding.setQName(bindingStr); + def.addBinding(binding); + } + + port.setBinding(binding); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = portEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(portEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + port.setDocumentationElement(tempEl); + } + else + { + port.addExtensibilityElement(parseExtensibilityElement(Port.class, + tempEl, + def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(portEl, Port.class, port, def); + + return port; + } + + protected ExtensibilityElement parseExtensibilityElement( + Class parentType, + Element el, + Definition def) + throws WSDLException + { + QName elementType = QNameUtils.newQName(el); + + String namespaceURI = el.getNamespaceURI(); + + try + { + if (namespaceURI == null || namespaceURI.equals(Constants.NS_URI_WSDL)) + { + throw new WSDLException(WSDLException.INVALID_WSDL, + "Encountered illegal extension element '" + + elementType + + "' in the context of a '" + + parentType.getName() + + "'. Extension elements must be in " + + "a namespace other than WSDL's."); + } + + ExtensionRegistry extReg = def.getExtensionRegistry(); + + if (extReg == null) + { + throw new WSDLException(WSDLException.CONFIGURATION_ERROR, + "No ExtensionRegistry set for this " + + "Definition, so unable to deserialize " + + "a '" + elementType + "' element in the " + + "context of a '" + parentType.getName() + + "'."); + } + + ExtensionDeserializer extDS = extReg.queryDeserializer(parentType, + elementType); + + return extDS.unmarshall(parentType, elementType, el, def, extReg); + } + catch (WSDLException e) + { + if (e.getLocation() == null) + { + e.setLocation(XPathUtils.getXPathExprFromNode(el)); + } + + throw e; + } + } + + protected Input parseInput(Element inputEl, Definition def) + throws WSDLException + { + Input input = def.createInput(); + String name = DOMUtils.getAttribute(inputEl, Constants.ATTR_NAME); + QName messageName = getQualifiedAttributeValue(inputEl, + Constants.ATTR_MESSAGE, + Constants.ELEM_INPUT, + def); + + if (name != null) + { + input.setName(name); + } + + if (messageName != null) + { + Message message = def.getMessage(messageName); + + if (message == null) + { + message = def.createMessage(); + message.setQName(messageName); + def.addMessage(message); + } + + input.setMessage(message); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = inputEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(inputEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + input.setDocumentationElement(tempEl); + } + else + { + input.addExtensibilityElement( + parseExtensibilityElement(Input.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(inputEl, Input.class, input, def); + + return input; + } + + protected Output parseOutput(Element outputEl, Definition def) + throws WSDLException + { + Output output = def.createOutput(); + String name = DOMUtils.getAttribute(outputEl, Constants.ATTR_NAME); + QName messageName = getQualifiedAttributeValue(outputEl, + Constants.ATTR_MESSAGE, + Constants.ELEM_OUTPUT, + def); + + if (name != null) + { + output.setName(name); + } + + if (messageName != null) + { + Message message = def.getMessage(messageName); + + if (message == null) + { + message = def.createMessage(); + message.setQName(messageName); + def.addMessage(message); + } + + output.setMessage(message); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = outputEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(outputEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + output.setDocumentationElement(tempEl); + } + else + { + output.addExtensibilityElement( + parseExtensibilityElement(Output.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(outputEl, Output.class, output, def); + + return output; + } + + protected Fault parseFault(Element faultEl, Definition def) + throws WSDLException + { + Fault fault = def.createFault(); + String name = DOMUtils.getAttribute(faultEl, Constants.ATTR_NAME); + QName messageName = getQualifiedAttributeValue(faultEl, + Constants.ATTR_MESSAGE, + Constants.ELEM_FAULT, + def); + + if (name != null) + { + fault.setName(name); + } + + if (messageName != null) + { + Message message = def.getMessage(messageName); + + if (message == null) + { + message = def.createMessage(); + message.setQName(messageName); + def.addMessage(message); + } + + fault.setMessage(message); + } + + //register any NS decls with the Definition + NamedNodeMap attrs = faultEl.getAttributes(); + registerNSDeclarations(attrs, def); + + Element tempEl = DOMUtils.getFirstChildElement(faultEl); + + while (tempEl != null) + { + if (QNameUtils.matches(Constants.Q_ELEM_DOCUMENTATION, tempEl)) + { + fault.setDocumentationElement(tempEl); + } + else + { + fault.addExtensibilityElement( + parseExtensibilityElement(Fault.class, tempEl, def)); + } + + tempEl = DOMUtils.getNextSiblingElement(tempEl); + } + + parseExtensibilityAttributes(faultEl, Fault.class, fault, def); + + return fault; + } + + /** + * This method should be used for elements that support extension + * attributes because it does not track unexpected remaining attributes. + */ + private static QName getQualifiedAttributeValue(Element el, + String attrName, + String elDesc, + Definition def) + throws WSDLException + { + try + { + return DOMUtils.getQualifiedAttributeValue(el, + attrName, + elDesc, + false, + def); + } + catch (WSDLException e) + { + if (e.getFaultCode().equals(WSDLException.NO_PREFIX_SPECIFIED)) + { + String attrValue = DOMUtils.getAttribute(el, attrName); + + return new QName(attrValue); + } + else + { + throw e; + } + } + } + + /** + * This method should be used for elements that do not support extension + * attributes because it tracks unexpected remaining attributes. + */ + private static QName getQualifiedAttributeValue(Element el, + String attrName, + String elDesc, + Definition def, + List remainingAttrs) + throws WSDLException + { + try + { + return DOMUtils.getQualifiedAttributeValue(el, + attrName, + elDesc, + false, + def, + remainingAttrs); + } + catch (WSDLException e) + { + if (e.getFaultCode().equals(WSDLException.NO_PREFIX_SPECIFIED)) + { + String attrValue = DOMUtils.getAttribute(el, attrName, remainingAttrs); + + return new QName(attrValue); + } + else + { + throw e; + } + } + } + + private static void checkElementName(Element el, QName qname) + throws WSDLException + { + if (!QNameUtils.matches(qname, el)) + { + WSDLException wsdlExc = new WSDLException(WSDLException.INVALID_WSDL, + "Expected element '" + + qname + "'."); + + wsdlExc.setLocation(XPathUtils.getXPathExprFromNode(el)); + + throw wsdlExc; + } + } + + private static Document getDocument(InputSource inputSource, + String desc) throws WSDLException + { + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + + factory.setNamespaceAware(true); + factory.setValidating(false); + + try + { + DocumentBuilder builder = factory.newDocumentBuilder(); + builder.setEntityResolver( new JBossWSEntityResolver() ); + Document doc = builder.parse(inputSource); + + return doc; + } + catch (RuntimeException e) + { + throw e; + } + catch (Exception e) + { + throw new WSDLException(WSDLException.PARSER_ERROR, + "Problem parsing '" + desc + "'.", + e); + } + } + + private static void registerNSDeclarations(NamedNodeMap attrs, Definition def) + { + int size = attrs.getLength(); + + for (int i = 0; i < size; i++) + { + Attr attr = (Attr)attrs.item(i); + String namespaceURI = attr.getNamespaceURI(); + String localPart = attr.getLocalName(); + String value = attr.getValue(); + + if (namespaceURI != null && namespaceURI.equals(Constants.NS_URI_XMLNS)) + { + if (localPart != null && !localPart.equals(Constants.ATTR_XMLNS)) + { + DOMUtils.registerUniquePrefix(localPart, value, def); + } + else + { + DOMUtils.registerUniquePrefix(null, value, def); + } + } + } + } + + /** + * Read the WSDL document accessible via the specified + * URI into a WSDL definition. + * + * @param wsdlURI a URI (can be a filename or URL) pointing to a + * WSDL XML definition. + * @return the definition. + */ + public Definition readWSDL(String wsdlURI) throws WSDLException + { + return readWSDL(null, wsdlURI); + } + + /** + * Read the WSDL document accessible via the specified + * URI into a WSDL definition. + * + * @param contextURI the context in which to resolve the + * wsdlURI, if the wsdlURI is relative. Can be null, in which + * case it will be ignored. + * @param wsdlURI a URI (can be a filename or URL) pointing to a + * WSDL XML definition. + * @return the definition. + */ + public Definition readWSDL(String contextURI, String wsdlURI) + throws WSDLException + { + try + { + if (verbose) + { + System.out.println("Retrieving document at '" + wsdlURI + "'" + + (contextURI == null + ? "." + : ", relative to '" + contextURI + "'.")); + } + + URL contextURL = (contextURI != null) + ? StringUtils.getURL(null, contextURI) + : null; + URL url = StringUtils.getURL(contextURL, wsdlURI); + InputStream inputStream = StringUtils.getContentAsInputStream(url); + InputSource inputSource = new InputSource(inputStream); + inputSource.setSystemId(url.toString()); + Document doc = getDocument(inputSource, url.toString()); + + inputStream.close(); + + Definition def = readWSDL(url.toString(), doc); + + return def; + } + catch (WSDLException e) + { + throw e; + } + catch (RuntimeException e) + { + throw e; + } + catch (Exception e) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to resolve imported document at '" + + wsdlURI + + (contextURI == null + ? "'." + : "', relative to '" + contextURI + "'.") + , e); + } + } + + /** + * Read the specified &lt;wsdl:definitions&gt; element into a WSDL + * definition. + * + * @param documentBaseURI the document base URI of the WSDL definition + * described by the element. Will be set as the documentBaseURI + * of the returned Definition. Can be null, in which case it + * will be ignored. + * @param definitionsElement the &lt;wsdl:definitions&gt; element + * @return the definition described by the element. + */ + public Definition readWSDL(String documentBaseURI, + Element definitionsElement) + throws WSDLException + { + return readWSDL(documentBaseURI, definitionsElement, null); + } + + /** + * Read the specified &lt;wsdl:definitions&gt; element into a WSDL + * definition. The WSDLLocator is used to provide the document + * base URIs. The InputSource of the WSDLLocator is ignored, instead + * the WSDL is parsed from the given Element. + * + * @param locator A WSDLLocator object used to provide + * the document base URI of the WSDL definition described by the + * element. + * @param definitionsElement the &lt;wsdl:definitions&gt; element + * @return the definition described by the element. + */ + public Definition readWSDL(WSDLLocator locator, + Element definitionsElement) + throws WSDLException + { + try + { + this.loc = locator; + return readWSDL(locator.getBaseURI(), definitionsElement, null); + } + finally + { + locator.close(); + this.loc = null; + } + } + + protected Definition readWSDL(String documentBaseURI, + Element definitionsElement, + Map importedDefs) + throws WSDLException + { + return parseDefinitions(documentBaseURI, definitionsElement, importedDefs); + } + + /** + * Read the specified WSDL document into a WSDL definition. + * + * @param documentBaseURI the document base URI of the WSDL definition + * described by the document. Will be set as the documentBaseURI + * of the returned Definition. Can be null, in which case it + * will be ignored. + * @param wsdlDocument the WSDL document, an XML + * document obeying the WSDL schema. + * @return the definition described in the document. + */ + public Definition readWSDL(String documentBaseURI, Document wsdlDocument) + throws WSDLException + { + return readWSDL(documentBaseURI, wsdlDocument.getDocumentElement()); + } + + /** + * Read a WSDL document into a WSDL definition. + * + * @param documentBaseURI the document base URI of the WSDL definition + * described by the document. Will be set as the documentBaseURI + * of the returned Definition. Can be null, in which case it + * will be ignored. + * @param inputSource an InputSource pointing to the + * WSDL document, an XML document obeying the WSDL schema. + * @return the definition described in the document pointed to + * by the InputSource. + */ + public Definition readWSDL(String documentBaseURI, InputSource inputSource) + throws WSDLException + { + String location = (inputSource.getSystemId() != null ? + inputSource.getSystemId() : "- WSDL Document -"); + + return readWSDL(documentBaseURI, + getDocument(inputSource, location)); + } + + /** + * Read a WSDL document into a WSDL definition. + * + * @param locator A WSDLLocator object used to provide InputSources + * pointing to the wsdl file. + * @return the definition described in the document + */ + public Definition readWSDL(WSDLLocator locator) throws WSDLException + { + InputSource is = locator.getBaseInputSource(); + String base = locator.getBaseURI(); + + if (is == null) + { + throw new WSDLException(WSDLException.OTHER_ERROR, + "Unable to locate document at '" + base + "'."); + } + is.setSystemId(base); + + this.loc = locator; + + if (verbose) + { + System.out.println("Retrieving document at '" + base + "'."); + } + + try + { + return readWSDL(base, is); + } + finally + { + this.loc.close(); + this.loc = null; + } + } +} + Property changes on: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/JBossWSDLReaderImpl.java ___________________________________________________________________ Name: svn:keywords + Id Revision Name: svn:eol-style + LF Modified: legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/WSDLDefinitionsFactory.java =================================================================== --- legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/WSDLDefinitionsFactory.java 2007-11-29 11:18:14 UTC (rev 5145) +++ legacy/branches/jbossws-1.2.1.GA_CP/jbossws-core/src/java/org/jboss/ws/tools/wsdl/WSDLDefinitionsFactory.java 2007-11-29 12:28:47 UTC (rev 5146) @@ -109,7 +109,7 @@ String defaultNamespace = getDefaultNamespace(wsdlDoc); if (Constants.NS_WSDL11.equals(defaultNamespace)) { - WSDLFactory wsdlFactory = WSDLFactory.newInstance(); + WSDLFactory wsdlFactory = WSDLFactory.newInstance(JBossWSDLFactoryImpl.class.getName()); WSDLReader wsdlReader = wsdlFactory.newWSDLReader(); wsdlReader.setFeature("javax.wsdl.verbose", false); @@ -132,8 +132,9 @@ wsdlDefinitions.setWsdlDocument(wsdlDoc); } else + { throw new WSDLException("Invalid default namespace: " + defaultNamespace); - + } if (log.isTraceEnabled()) { StringWriter stwr = new StringWriter();