package org.apache.axis2.description;
import com.ibm.wsdl.util.xml.DOM2Writer;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.AddressingConstants;
import org.apache.axis2.addressing.AddressingHelper;
import org.apache.axis2.addressing.wsdl.WSDL11ActionHelper;
import org.apache.axis2.util.PolicyUtil;
import org.apache.axis2.util.XMLUtils;
import org.apache.axis2.wsdl.SOAPHeaderMessage;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.axis2.wsdl.WSDLUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.neethi.Constants;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyReference;
import org.apache.ws.commons.schema.utils.NamespaceMap;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import javax.wsdl.*;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.UnknownExtensibilityElement;
import javax.wsdl.extensions.schema.Schema;
import javax.wsdl.extensions.soap.*;
import javax.wsdl.extensions.soap12.*;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLLocator;
import javax.wsdl.xml.WSDLReader;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
/*
* Copyright 2004,2005 The Apache Software Foundation.
*
* Licensed 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.
*
*
*/
public class WSDL11ToAxisServiceBuilder extends WSDLToAxisServiceBuilder {
protected static final Log log = LogFactory
.getLog(WSDL11ToAxisServiceBuilder.class);
protected String portName;
private static final String BINDING = "Binding";
private static final String SERVICE = "Service";
private static final String PORT = "Port";
private static final String PORT_TYPE = "PortType";
private static final String PORT_TYPE_OPERATION = "PortType.Operation";
private static final String PORT_TYPE_OPERATION_INPUT = "PortType.Operation.Input";
private static final String PORT_TYPE_OPERATION_OUTPUT = "PortType.Operation.Output";
private static final String PORT_TYPE_OPERATION_FAULT = "PortType.Operation.Fault";
private static final String BINDING_OPERATION = "Binding.Operation";
private static final String BINDING_OPERATION_INPUT = "Binding.Operation.Input";
private static final String BINDING_OPERATION_OUTPUT = "Binding.Operation.Output";
protected Definition wsdl4jDefinition = null;
private WSDLLocator customWSLD4JResolver;
public static final String RPC_STYLE = "rpc";
public static final String DOCUMENT_STYLE = "document";
/**
* Keeps a list of processable operations initiate to an empty list
*/
private List wrappableOperations = new ArrayList();
public static final String WRAPPED_OUTPUTNAME_SUFFIX = "Response";
public static final String XML_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
public static final String NAMESPACE_DECLARATION_PREFIX = "xmlns:";
private static int prefixCounter = 0;
public static final String NAMESPACE_URI = "namespace";
public static final String TRAGET_NAMESPACE = "targetNamespace";
/**
* keep track of whether setup code related to the entire wsdl is complete.
* Note that WSDL11ToAllAxisServices will call setup multiple times, so this
* field is used to make subsequent calls no-ops.
*/
private boolean setupComplete = false;
private Map schemaMap = null;
private static final String JAVAX_WSDL_VERBOSE_MODE_KEY = "javax.wsdl.verbose";
private static final String JAVAX_WSDL_IMPORT_DOCUMENTS_MODE_KEY = "javax.wsdl.importDocuments";
/**
* constructor taking in the service name and the port name
*
* @param in
* @param serviceName
* @param portName
*/
public WSDL11ToAxisServiceBuilder(InputStream in, QName serviceName,
String portName) {
super(in, serviceName);
this.portName = portName;
}
/**
* @param def
* @param serviceName
* @param portName
*/
public WSDL11ToAxisServiceBuilder(Definition def, QName serviceName,
String portName) {
super(null, serviceName);
this.wsdl4jDefinition = def;
this.portName = portName;
}
/**
* @param in
* @param service
*/
public WSDL11ToAxisServiceBuilder(InputStream in, AxisService service) {
super(in, service);
}
/**
* @param in
*/
public WSDL11ToAxisServiceBuilder(InputStream in) {
this(in, null, null);
}
/**
* sets a custem WSDL4J locator
*
* @param customWSLD4JResolver
*/
public void setCustomWSLD4JResolver(WSDLLocator customWSLD4JResolver) {
this.customWSLD4JResolver = customWSLD4JResolver;
}
/**
* populates a given service This is the only publicly accessible method in
* this class
*
* @throws AxisFault
*/
public AxisService populateService() throws AxisFault {
try {
setup();
// Setting wsdl4jdefintion to axisService , so if some one want
// to play with it he can do that by getting the parameter
Parameter wsdlDefinitionParameter = new Parameter();
wsdlDefinitionParameter.setName(WSDLConstants.WSDL_4_J_DEFINITION);
wsdlDefinitionParameter.setValue(wsdl4jDefinition);
axisService.addParameter(wsdlDefinitionParameter);
if (wsdl4jDefinition == null) {
return null;
}
// setting target name space
axisService.setTargetNamespace(wsdl4jDefinition
.getTargetNamespace());
axisService.setNameSpacesMap(new NamespaceMap(wsdl4jDefinition
.getNamespaces()));
Binding binding = findBinding(wsdl4jDefinition);
if (binding.getPortType() == null) {
throw new AxisFault("Unable to find wsdl:binding named " + binding.getQName());
}
// create new Schema extensions element for wrapping
// (if its present)
Element[] schemaElements = generateWrapperSchema(schemaMap, binding);
// we might have modified the schemas by now so the addition should
// happen here
Types wsdl4jTypes = wsdl4jDefinition.getTypes();
if (null != wsdl4jTypes) {
this.copyExtensibleElements(wsdl4jTypes
.getExtensibilityElements(), wsdl4jDefinition,
axisService, TYPES);
}
// add the newly created schemas
if (schemaElements != null && schemaElements.length > 0) {
for (int i = 0; i < schemaElements.length; i++) {
Element schemaElement = schemaElements[i];
if (schemaElement != null) {
axisService
.addSchema(getXMLSchema(schemaElement, null));
}
}
}
// copy the documentation element content to the description
Element documentationElement = wsdl4jDefinition
.getDocumentationElement();
if ((documentationElement != null) && (documentationElement.getFirstChild() != null)) {
Node firstChild = documentationElement.getFirstChild();
String serviceDes;
if (firstChild.getNodeType() == Node.TEXT_NODE) {
serviceDes = firstChild.getNodeValue();
} else {
serviceDes = DOM2Writer.nodeToString(firstChild);
}
axisService.setServiceDescription(serviceDes);
}
processBinding(binding, wsdl4jDefinition);
return axisService;
} catch (WSDLException e) {
log.error(e);
throw new AxisFault(e);
} catch (Exception e) {
log.error(e);
throw new AxisFault(e);
}
}
/**
* contains all code which gathers non-service specific information from the
* wsdl. <p/> After all the setup completes successfully, the setupComplete
* field is set so that any subsequent calls to setup() will result in a
* no-op. Note that subclass WSDL11ToAllAxisServicesBuilder will call
* populateService for each port in the WSDL. Separating the non-service
* specific information here allows WSDL11ToAllAxisServicesBuilder to only
* do this work 1 time per WSDL, instead of for each port on each service.
*
* @throws WSDLException if readInTheWSDLFile fails
*/
protected void setup() throws WSDLException {
if (setupComplete) { // already setup, just do nothing and return
return;
}
if (wsdl4jDefinition == null) {
wsdl4jDefinition = readInTheWSDLFile(in);
}
if (wsdl4jDefinition == null) {
return; // can't continue without wsdl
}
// process the imports
// send an empty list as the processed namespace list since this
// is the first call
processImports(wsdl4jDefinition, new ArrayList());
// Adding the policies in the Definition to the the PolicyRegistry
processPoliciesInDefintion(wsdl4jDefinition);
// setup the schemaMap
schemaMap = populateSchemaMap(wsdl4jDefinition.getTypes());
setupComplete = true; // if any part of setup fails, don't mark
// setupComplete
}
/**
* Populate a map of targetNamespace vs DOM schema element This is used to
* grab the correct schema element when adding a new element
*
* @param wsdl4jTypes
*/
private Map populateSchemaMap(Types wsdl4jTypes) {
Map schemaMap = new HashMap();
if (wsdl4jTypes != null) {
List typesExtensibilityElements = wsdl4jTypes
.getExtensibilityElements();
for (int i = 0; i < typesExtensibilityElements.size(); i++) {
Object o = typesExtensibilityElements.get(i);
if (o instanceof Schema) {
Schema s = (Schema) o;
String targetNamespace = s.getElement().getAttribute(
TRAGET_NAMESPACE);
schemaMap.put(targetNamespace, s.getElement());
}
}
}
return schemaMap;
}
/**
* Look for the relevant binding!
*
* @param dif
* @throws AxisFault
*/
private Binding findBinding(Definition dif) throws AxisFault {
Map services = dif.getServices();
Service service = null;
Binding binding = null;
Port port = null;
if (serviceName != null) {
service = (Service) services.get(serviceName);
if (service == null) {
throw new AxisFault("Service " + serviceName + " was not found in the WSDL");
}
} else {
if (services.size() > 0) {
// pick the first service - we don't really have a choice here
service = (Service) services.values().toArray()[0];
}
}
if (service != null) {
copyExtensibleElements(service.getExtensibilityElements(), dif,
axisService, SERVICE);
if (portName != null) {
port = service.getPort(portName);
if (port == null) {
throw new AxisFault("No port found for the given name :"
+ portName);
}
} else {
Map ports = service.getPorts();
if (ports != null && ports.size() > 0) {
// pick the port with the SOAP address as the default port
port = findSOAPPort(ports);
if (port == null) {
// a SOAP port was not found - log a warning
// and use the first port in the list
log.info("A SOAP port was not found - "
+ "picking a random port!");
port = (Port) ports.values().toArray()[0];
}
}
}
axisService.setName(service.getQName().getLocalPart());
if (port != null) {
copyExtensibleElements(port.getExtensibilityElements(), dif,
axisService, PORT);
binding = dif.getBinding(port.getBinding().getQName());
if (binding == null) {
binding = port.getBinding();
}
}
} else {
log.info("A service element was not found - "
+ "picking a random binding!");
Collection bindings = dif.getBindings().values();
if (bindings == null || bindings.isEmpty()) {
throw new AxisFault("No bindings found in wsdl");
}
binding = (Binding) bindings.iterator().next();
axisService.setName(binding.getQName().getLocalPart() + "Service");
}
return binding;
}
/**
* Finds a SOAP port given the port map
*
* @param ports
*/
private Port findSOAPPort(Map ports) {
Port port;
for (Iterator portsIterator = ports.values().iterator(); portsIterator
.hasNext();) {
port = (Port) portsIterator.next();
List extensibilityElements = port.getExtensibilityElements();
for (int i = 0; i < extensibilityElements.size(); i++) {
Object extElement = extensibilityElements.get(i);
if (extElement instanceof SOAPAddress) {
// SOAP 1.1 address found - return that port and we are done
return port;
}
if (extElement instanceof SOAP12Address) {
// SOAP 1.2 address found - return that port and we are done
return port;
}
}
}
// None found - just return null.
return null;
}
/**
* Process the binding
*
* @param binding
* @param dif
* @throws Exception
*/
private void processBinding(Binding binding, Definition dif)
throws Exception {
if (binding != null) {
copyExtensibleElements(binding.getExtensibilityElements(), dif,
axisService, BINDING);
PortType portType = dif.getPortType(binding.getPortType().getQName());
processPortType(portType, dif);
axisService.setBindingName(binding.getQName().getLocalPart());
// String portTypeNs = portType.getQName().getNamespaceURI();
List list = binding.getBindingOperations();
for (int i = 0; i < list.size(); i++) {
BindingOperation wsdl4jBindingOperation = (BindingOperation) list
.get(i);
AxisOperation operation = axisService.getOperation(new QName(
wsdl4jBindingOperation.getName()));
// this should first check the style of the binding
// and then set the style in the axis operation
// if that is not present, then only the global style applies
// this style is either rpc or doc
String style = getSOAPStyle(wsdl4jBindingOperation);
if (style != null) {
operation.setStyle(style);
} else if (this.style != null) {
operation.setStyle(this.style);
}
copyExtensibleElements(wsdl4jBindingOperation
.getExtensibilityElements(), dif, operation,
BINDING_OPERATION);
BindingInput bindingInput = wsdl4jBindingOperation
.getBindingInput();
BindingOutput bindingOutput = wsdl4jBindingOperation
.getBindingOutput();
Map bindingFaultsMap = wsdl4jBindingOperation
.getBindingFaults();
Operation wsdl4jOperation = findOperation(portType, wsdl4jBindingOperation);
String MEP = operation.getMessageExchangePattern();
/* Process the binding inputs */
if (bindingInput != null) {
if (WSDLUtil.isInputPresentForMEP(MEP)) {
AxisMessage inAxisMessage = operation
.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
// Add the Qname reference - this has to be done by
// looking at the
// binding
AddQNameReference(inAxisMessage, wsdl4jOperation,
bindingInput, wrappableOperations
.contains(wsdl4jBindingOperation
.getOperation()));
copyExtensibleElements(bindingInput
.getExtensibilityElements(), dif,
inAxisMessage, BINDING_OPERATION_INPUT);
}
}
/*
* Process the binding outputs
*/
if (bindingOutput != null) {
if (WSDLUtil.isOutputPresentForMEP(MEP)) {
AxisMessage outAxisMessage = operation
.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
// Add the Qname reference - this has to be done by
// looking at the
// binding
AddQNameReference(outAxisMessage, wsdl4jOperation,
bindingOutput, wrappableOperations
.contains(wsdl4jBindingOperation
.getOperation()));
copyExtensibleElements(bindingOutput
.getExtensibilityElements(), dif,
outAxisMessage, BINDING_OPERATION_OUTPUT);
}
}
/* process the binding faults */
for (Iterator faultKeys = bindingFaultsMap.keySet().iterator(); faultKeys
.hasNext();) {
Object faultMapKey = faultKeys.next();
BindingFault bindingFault = (BindingFault) bindingFaultsMap
.get(faultMapKey);
Fault wsdl4jFault = wsdl4jOperation.getFault(bindingFault
.getName());
if (wsdl4jFault == null || wsdl4jFault.getMessage().getParts().size() == 0) {
throw new AxisFault("fault \"" + bindingFault.getName()
+ "\" not found in the Operation "
+ wsdl4jOperation.getName());
}
AxisMessage faultMessage = findFaultMessage(wsdl4jFault
.getMessage().getQName().getLocalPart(), operation
.getFaultMessages());
AddQNameReference(faultMessage, wsdl4jFault.getMessage());
}
Iterator iterator = operation.getFaultMessages().iterator();
while (iterator.hasNext()) {
AxisMessage faultMessage = (AxisMessage) iterator.next();
if (faultMessage.getElementQName() == null) {
log.warn("Unable to find a wsdl:binding/wsdl:operation/wsdl:fault for fault named " + faultMessage.getName() + " defined in wsdl:portType/wsdl:operation/@name=" + operation.getName().getLocalPart());
}
}
}
}
}
private Operation findOperation(PortType portType, BindingOperation wsdl4jBindingOperation) {
Operation op = wsdl4jBindingOperation
.getOperation();
String input = null;
if (op != null && op.getInput() != null) {
input = op.getInput().getName();
if (":none".equals(input)) {
input = null;
}
}
String output = null;
if (op != null && op.getOutput() != null) {
output = op.getOutput().getName();
if (":none".equals(output)) {
output = null;
}
}
Operation op2 = portType.getOperation(op.getName(), input, output);
return ((op2 == null) ? op : op2);
}
/**
* Find the fault message relevant to a given name from the fault message
* list
*
* @param name
* @param faultMessages
*/
private AxisMessage findFaultMessage(String name, ArrayList faultMessages) {
AxisMessage tempMessage;
for (int i = 0; i < faultMessages.size(); i++) {
tempMessage = (AxisMessage) faultMessages.get(i);
if (name.equals(tempMessage.getName())) {
return tempMessage;
}
}
return null;
}
/**
* Add the QName for the binding input
*
* @param inMessage
* @param wsdl4jOperation
* @param bindingInput
* @param isWrapped
*/
private void AddQNameReference(AxisMessage inMessage,
Operation wsdl4jOperation, BindingInput bindingInput,
boolean isWrapped) {
List extensibilityElements = bindingInput.getExtensibilityElements();
Message wsdl4jMessage = wsdl4jOperation.getInput().getMessage();
for (int i = 0; i < extensibilityElements.size(); i++) {
ExtensibilityElement extElement = (ExtensibilityElement) extensibilityElements
.get(i);
// SOAP 1.1 body element found!
if (extElement instanceof SOAPBody) {
SOAPBody soapBody = (SOAPBody) extElement;
List bindingPartsList = soapBody.getParts();
if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
// we can process a single part only
processPartsList(bindingPartsList, wsdl4jMessage, inMessage);
// there are no parts named in the binding - process the
// items normally
// by looking at the single message part - or the wrapped
// items if wrapped by us
} else {
// for the wrapped types we need to find this from the
// wrapper schema map
if (isWrapped) {
// The schema for this should be already made ! Find the
// QName from
// the list and add it - the name for this is just the
inMessage
.setElementQName((QName) resolvedRpcWrappedElementMap
.get(wsdl4jOperation.getName()));
} else if (wsdl4jMessage != null) {
// pick the first part from the list and take that as
// the relevant part
// it is somewhat questionnable whether the first part
// gets picked
// but we'll have to take a chance here
Map wsdl4jPartsMap = wsdl4jMessage.getParts();
if (!wsdl4jPartsMap.isEmpty()) {
Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
.toArray()[0];
if (wsdl4jPart.getElementName() != null) {
inMessage.setElementQName(wsdl4jPart
.getElementName());
}
}
}
}
break;
} else if (extElement instanceof SOAP12Body) {
SOAP12Body soapBody = (SOAP12Body) extElement;
List bindingPartsList = soapBody.getParts();
if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
// we can process a single part only
processPartsList(bindingPartsList, wsdl4jMessage, inMessage);
// there are no parts named in the binding - process the
// items normally
// by looking at the single message part - or the wrapped
// items if wrapped by us
} else {
// for the wrapped types we need to find this from the
// wrapper schema map
if (isWrapped) {
// The schema for this should be already made ! Find the
// QName from
// the list and add it - the name for this is just the
inMessage
.setElementQName((QName) resolvedRpcWrappedElementMap
.get(wsdl4jOperation.getName()));
} else if (wsdl4jMessage != null) {
// pick the first part from the list and take that as
// the relevant part
// it is somewhat questionnable whether the first part
// gets picked
// but we'll have to take a chance here
Map wsdl4jPartsMap = wsdl4jMessage.getParts();
if (!wsdl4jPartsMap.isEmpty()) {
Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
.toArray()[0];
if (wsdl4jPart.getElementName() != null) {
inMessage.setElementQName(wsdl4jPart
.getElementName());
}
}
}
}
break;
}
}
}
/**
* A reusable method to both the input and output QName populators
*
* @param bindingPartsList
* @param wsdl4jMessage
* @param axisMessage
*/
private void processPartsList(List bindingPartsList, Message wsdl4jMessage,
AxisMessage axisMessage) {
if (bindingPartsList.size() > 1) {
// do something here - perhaps throw and exception
} else {
// find the part from the relevant message
Part wsdl4jMessagePart = wsdl4jMessage
.getPart((String) bindingPartsList.get(0));
// the part name better be there - if not throw an exception
if (wsdl4jMessagePart == null) {
throw new WSDLProcessingException("Missing part named \""
+ bindingPartsList.get(0) + "\"");
}
QName name = wsdl4jMessagePart.getElementName();
if (name == null) {
name = wsdl4jMessagePart.getTypeName();
}
if (name == null) {
throw new WSDLProcessingException(
"Element reference / Type name missing for "
+ bindingPartsList.get(0) + "!");
}
axisMessage.setElementQName(wsdl4jMessagePart.getElementName());
}
}
/**
* Add the QName for the binding output
*
* @param outMessage
* @param wsdl4jOperation
* @param isWrapped
*/
private void AddQNameReference(AxisMessage outMessage,
Operation wsdl4jOperation, BindingOutput bindingOutput,
boolean isWrapped) {
List extensibilityElements = bindingOutput.getExtensibilityElements();
if (wsdl4jOperation.getOutput() == null) {
return;
}
Message wsdl4jMessage = wsdl4jOperation.getOutput().getMessage();
for (int i = 0; i < extensibilityElements.size(); i++) {
ExtensibilityElement extElement = (ExtensibilityElement) extensibilityElements
.get(i);
// SOAP 1.1 body element found!
if (extElement instanceof SOAPBody) {
SOAPBody soapBody = (SOAPBody) extElement;
List bindingPartsList = soapBody.getParts();
if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
// we can process a single part only so delegate the task
// of processing
processPartsList(bindingPartsList, wsdl4jMessage,
outMessage);
// there are no parts named in the binding - process the
// items normally
// by looking at the single message part - or the wrapped
// items if wrapped by us
} else {
// for the wrapped types we need to find this from the
// wrapper schema map
if (isWrapped) {
// The schema for this should be already made ! Find the
// QName from
// the list and add it
outMessage
.setElementQName((QName) resolvedRpcWrappedElementMap
.get(wsdl4jOperation.getName()
+ WRAPPED_OUTPUTNAME_SUFFIX));
} else if (wsdl4jMessage != null) {
// pick the first part from the list and take that as
// the relevant part
// it is somewhat questionable whether the first part
// gets picked
// but we'll have to take a chance here
Map wsdl4jPartsMap = wsdl4jMessage.getParts();
if (!wsdl4jPartsMap.isEmpty()) {
Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
.toArray()[0];
if (wsdl4jPart.getElementName() != null) {
outMessage.setElementQName(wsdl4jPart
.getElementName());
}
}
}
}
} else if (extElement instanceof SOAP12Body) {
SOAP12Body soapBody = (SOAP12Body) extElement;
List bindingPartsList = soapBody.getParts();
if (bindingPartsList != null && !bindingPartsList.isEmpty()) {
// we can process a single part only
processPartsList(bindingPartsList, wsdl4jMessage, outMessage);
// there are no parts named in the binding - process the
// items normally
// by looking at the single message part - or the wrapped
// items if wrapped by us
} else {
// for the wrapped types we need to find this from the
// wrapper schema map
if (isWrapped) {
// The schema for this should be already made ! Find the
// QName from
// the list and add it - the name for this is just the
outMessage
.setElementQName((QName) resolvedRpcWrappedElementMap
.get(wsdl4jOperation.getName()
+ WRAPPED_OUTPUTNAME_SUFFIX));
} else if (wsdl4jMessage != null) {
// pick the first part from the list and take that as
// the relevant part
// it is somewhat questionnable whether the first part
// gets picked
// but we'll have to take a chance here
Map wsdl4jPartsMap = wsdl4jMessage.getParts();
if (!wsdl4jPartsMap.isEmpty()) {
Part wsdl4jPart = (Part) wsdl4jPartsMap.values()
.toArray()[0];
if (wsdl4jPart.getElementName() != null) {
outMessage.setElementQName(wsdl4jPart
.getElementName());
}
}
}
}
}
}
}
/**
* Add the QName for the binding output
*/
private void AddQNameReference(AxisMessage faultMessage,
Message wsdl4jMessage) throws AxisFault {
// for a fault this is trivial - All faults are related directly to a
// message by the name and are supposed to have a single part. So it is
// a matter of copying the right QName from the message part
// get the part
Part wsdl4jMessagePart = (Part) wsdl4jMessage.getParts().values()
.toArray()[0];
if (wsdl4jMessagePart == null) {
throw new WSDLProcessingException();
}
QName name = wsdl4jMessagePart.getElementName();
if (name == null) {
String message = "Part '" + wsdl4jMessagePart.getName() +
"' of fault message '" + wsdl4jMessage.getQName()
+ "' must be defined with 'element=QName' and not 'type=QName'";
log.error(message);
throw new AxisFault(message);
}
faultMessage.setElementQName(name);
}
/**
* A util method that returns the SOAP style included in the binding
* operation
*
* @param bindingOp
*/
private String getSOAPStyle(BindingOperation bindingOp) {
List extensibilityElements = bindingOp.getExtensibilityElements();
for (int i = 0; i < extensibilityElements.size(); i++) {
Object extElement = extensibilityElements.get(i);
if (extElement instanceof SOAPOperation) {
return ((SOAPOperation) extElement).getStyle();
} else if (extElement instanceof SOAP12Operation) {
return ((SOAP12Operation) extElement).getStyle();
}
}
return null;
}
/**
* Simply Copy information.
*
* @param wsdl4jPortType
*/
// FIXME Evaluate a way of injecting features and priperties with a general
// formatted input
private void processPortType(PortType wsdl4jPortType, Definition dif)
throws Exception {
copyExtensionAttributes(wsdl4jPortType.getExtensionAttributes(),
axisService, PORT_TYPE);
// set port the type name
axisService.setPortTypeName(wsdl4jPortType.getQName().getLocalPart());
Iterator wsdl4JOperationsIterator = wsdl4jPortType.getOperations()
.iterator();
Operation wsdl4jOperation;
while (wsdl4JOperationsIterator.hasNext()) {
wsdl4jOperation = (Operation) wsdl4JOperationsIterator.next();
axisService.addOperation(populateOperations(wsdl4jOperation,
wsdl4jPortType, dif));
}
}
/**
* Copy the component from the operation
*
* @param wsdl4jOperation
* @param dif
* @throws Exception
*/
private AxisOperation populateOperations(Operation wsdl4jOperation,
PortType wsdl4jPortType, Definition dif) throws Exception {
QName opName = new QName(wsdl4jOperation.getName());
// Copy Name Attribute
AxisOperation axisOperation = axisService.getOperation(opName);
if (axisOperation == null) {
String MEP = getMEP(wsdl4jOperation);
axisOperation = AxisOperationFactory.getOperationDescription(MEP);
axisOperation.setName(opName);
// setting the PolicyInclude property of the AxisOperation
PolicyInclude policyInclude = new PolicyInclude(axisOperation);
axisOperation.setPolicyInclude(policyInclude);
}
copyExtensibleElements(wsdl4jOperation.getExtensibilityElements(), dif,
axisOperation, PORT_TYPE_OPERATION);
Input wsdl4jInputMessage = wsdl4jOperation.getInput();
if (isServerSide) {
if (null != wsdl4jInputMessage) {
AxisMessage inMessage = axisOperation
.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
Message message = wsdl4jInputMessage.getMessage();
if (null != message) {
inMessage.setName(message.getQName().getLocalPart());
copyExtensibleElements(message.getExtensibilityElements(),
dif, inMessage, PORT_TYPE_OPERATION_INPUT);
}
// Check if the action is already set as we don't want to
// override it
// with the Default Action Pattern
ArrayList inputActions = axisOperation.getWsamappingList();
String action = null;
if (inputActions == null || inputActions.size() == 0) {
action = WSDL11ActionHelper
.getActionFromInputElement(dif, wsdl4jPortType,
wsdl4jOperation, wsdl4jInputMessage);
}
if (action != null) {
if (inputActions == null) {
inputActions = new ArrayList();
axisOperation.setWsamappingList(inputActions);
}
inputActions.add(action);
}
}
// Create an output message and add
Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
if (null != wsdl4jOutputMessage) {
AxisMessage outMessage = axisOperation
.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
Message message = wsdl4jOutputMessage.getMessage();
if (null != message) {
outMessage.setName(message.getQName().getLocalPart());
copyExtensibleElements(message.getExtensibilityElements(),
dif, outMessage, PORT_TYPE_OPERATION_OUTPUT);
// wsdl:portType -> wsdl:operation -> wsdl:output
}
// Check if the action is already set as we don't want to
// override it
// with the Default Action Pattern
String action = axisOperation.getOutputAction();
if (action == null) {
action = WSDL11ActionHelper.getActionFromOutputElement(dif,
wsdl4jPortType, wsdl4jOperation,
wsdl4jOutputMessage);
}
if (action != null) {
axisOperation.setOutputAction(action);
}
}
} else {
// for the client side we have to do something that is a bit
// weird. The in message is actually taken from the output
// and the output is taken from the in
if (null != wsdl4jInputMessage) {
AxisMessage inMessage = axisOperation
.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE);
Message message = wsdl4jInputMessage.getMessage();
if (null != message) {
inMessage.setName(message.getQName().getLocalPart());
copyExtensibleElements(message.getExtensibilityElements(),
dif, inMessage, PORT_TYPE_OPERATION_OUTPUT);
}
// Check if the action is already set as we don't want to
// override it
// with the Default Action Pattern
String action = axisOperation.getOutputAction();
if (action == null) {
action = WSDL11ActionHelper
.getActionFromInputElement(dif, wsdl4jPortType,
wsdl4jOperation, wsdl4jInputMessage);
}
if (action != null) {
axisOperation.setOutputAction(action);
}
}
// Create an output message and add
Output wsdl4jOutputMessage = wsdl4jOperation.getOutput();
if (null != wsdl4jOutputMessage) {
AxisMessage outMessage = axisOperation
.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
Message message = wsdl4jOutputMessage.getMessage();
if (null != message) {
outMessage.setName(message.getQName().getLocalPart());
copyExtensibleElements(message.getExtensibilityElements(),
dif, outMessage, PORT_TYPE_OPERATION_INPUT);
// wsdl:portType -> wsdl:operation -> wsdl:output
}
// Check if the action is already set as we don't want to
// override it
// with the Default Action Pattern
ArrayList inputActions = axisOperation.getWsamappingList();
String action = null;
if (inputActions == null || inputActions.size() == 0) {
action = WSDL11ActionHelper.getActionFromOutputElement(dif,
wsdl4jPortType, wsdl4jOperation,
wsdl4jOutputMessage);
}
if (action != null) {
if (inputActions == null) {
inputActions = new ArrayList();
axisOperation.setWsamappingList(inputActions);
}
inputActions.add(action);
}
}
}
Map faults = wsdl4jOperation.getFaults();
Iterator faultKeyIterator = faults.keySet().iterator();
while (faultKeyIterator.hasNext()) {
Fault fault = (Fault) faults.get(faultKeyIterator.next());
AxisMessage axisFaultMessage = new AxisMessage();
Message faultMessage = fault.getMessage();
if (null != faultMessage) {
axisFaultMessage
.setName(faultMessage.getQName().getLocalPart());
copyExtensibleElements(faultMessage.getExtensibilityElements(),
dif, axisFaultMessage, PORT_TYPE_OPERATION_FAULT);
}
// Check if the action is already set as we don't want to override
// it
// with the Default Action Pattern
String action = axisOperation.getFaultAction(fault.getName());
if (action == null) {
action = WSDL11ActionHelper.getActionFromFaultElement(dif,
wsdl4jPortType, wsdl4jOperation, fault);
}
if (action != null) {
axisOperation.addFaultAction(fault.getName(), action);
}
axisOperation.setFaultMessages(axisFaultMessage);
}
return axisOperation;
}
/**
* Generates a list of wrapper schemas
*
* @param wsdl4jBinding
*/
private Element[] generateWrapperSchema(Map schemaMap, Binding wsdl4jBinding) {
List schemaElementList = new ArrayList();
// target namespace for this should be the namespace URI for
// the porttype
String porttypeNamespaceURI = wsdl4jBinding.getPortType().getQName()
.getNamespaceURI();
// //////////////////////////////////////////////////////////////////////
// if there are any bindings present then we have to process them. we
// have to generate a schema per wsdl4jBinding (that is the safest
// option).
// if not we just resolve to
// the good old port type
// list, in which case we'll generate a schema per porttype
// //////////////////////////////////////////////////////////////////////
Element schemaElement = createSchemaForPorttype(porttypeNamespaceURI,
findWrappableOperations(wsdl4jBinding), schemaMap);
if (schemaElement != null) {
schemaElementList.add(schemaElement);
}
return (Element[]) schemaElementList
.toArray(new Element[schemaElementList.size()]);
}
/**
* Create a schema by looking at the port type
*
* @param namespaceURI
* @return null if there is no element
*/
private Element createSchemaForPorttype(String namespaceURI,
List operationListToProcess, Map existingSchemaMap) {
// first of all look at the operations list
// we can return immediately if we get the operations list
// as empty
if (operationListToProcess.isEmpty()) {
return null;
}
// loop through the messages. We'll populate thins map with the relevant
// messages
// from the operations
Map messagesMap = new HashMap();
Map inputOperationsMap = new HashMap();
Map outputOperationsMap = new HashMap();
Map faultyOperationsMap = new HashMap();
// this contains the required namespace imports. the key in this
// map would be the namaspace URI
Map namespaceImportsMap = new HashMap();
// generated complextypes. Keep in the list for writing later
// the key for the complexType map is the message QName
Map complexTypeElementsMap = new HashMap();
// generated Elements. Kep in the list for later writing
List elementElementsList = new ArrayList();
// list namespace prefix map. This map will include uri -> prefix
Map namespacePrefixMap = new HashMap();
// //////////////////////////////////////////////////////////////////////////////////////////////////
// First thing is to populate the message map with the messages to
// process.
// //////////////////////////////////////////////////////////////////////////////////////////////////
// we really need to do this for a single porttype!
Operation op;
for (int k = 0; k < operationListToProcess.size(); k++) {
op = (Operation) operationListToProcess.get(k);
Input input = op.getInput();
Message message;
if (input != null) {
message = input.getMessage();
messagesMap.put(message.getQName(), message);
inputOperationsMap.put(op.getName(), message);
}
Output output = op.getOutput();
if (output != null) {
message = output.getMessage();
messagesMap.put(message.getQName(), message);
outputOperationsMap.put(op.getName(), message);
}
Map faultMap = op.getFaults();
if (faultMap != null && faultMap.size() > 0) {
Iterator keys = faultMap.keySet().iterator();
while (keys.hasNext()) {
Object key = keys.next();
Fault fault = (Fault) faultMap.get(key);
if (fault != null) {
message = fault.getMessage();
messagesMap.put(message.getQName(), message);
faultyOperationsMap.put(key, message);
}
}
}
}
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////
// check whether there are messages that are wrappable. If there are no
// messages that are wrappable we'll
// just return null and endup this process. However we need to take the
// force flag into account here
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////
QName[] keys;
// just take all the messages and wrap them, we've already selected
// the relevant messages by looking at the SOAP binding
keys = (QName[]) messagesMap.keySet().toArray(
new QName[messagesMap.size()]);
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Now we have the message list to process - Process the whole list of
// messages at once
// since we need to generate one single schema
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////
List resolvedMessageQNames = new ArrayList();
// find the xsd prefix
String xsdPrefix = findSchemaPrefix();
Message wsdl4jMessage;
// DOM document that will be the ultimate creator
Document document = getDOMDocumentBuilder().newDocument();
for (int i = 0; i < keys.length; i++) {
wsdl4jMessage = (Message) messagesMap.get(keys[i]);
// No need to check the wrappable,
// This message is wrappabel. However we need to see whether the
// message is already
// resolved!
if (!resolvedMessageQNames.contains(wsdl4jMessage.getQName())) {
// This message has not been touched before!. So we can go ahead
// now
Map parts = wsdl4jMessage.getParts();
// add the complex type
Element newComplexType = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_COMPLEX_TYPE_LOCAL_NAME);
Element cmplxTypeSequence = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_SEQUENCE_LOCAL_NAME);
Element child;
Iterator iterator = parts.keySet().iterator();
while (iterator.hasNext()) {
Part part = (Part) parts.get(iterator.next());
// the part name
String elementName = part.getName();
boolean isTyped = true;
// the type name
QName schemaTypeName;
if (part.getTypeName() != null) {
schemaTypeName = part.getTypeName();
} else if (part.getElementName() != null) {
schemaTypeName = part.getElementName();
isTyped = false;
} else {
throw new RuntimeException(" Unqualified Message part!");
}
child = document.createElementNS(XMLSCHEMA_NAMESPACE_URI,
xsdPrefix + ":" + XML_SCHEMA_ELEMENT_LOCAL_NAME);
String prefix;
if (XMLSCHEMA_NAMESPACE_URI.equals(schemaTypeName
.getNamespaceURI())) {
prefix = xsdPrefix;
} else {
// this schema is a third party one. So we need to have
// an import statement in our generated schema
String uri = schemaTypeName.getNamespaceURI();
if (!namespaceImportsMap.containsKey(uri)) {
// create Element for namespace import
Element namespaceImport = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_IMPORT_LOCAL_NAME);
namespaceImport.setAttribute(NAMESPACE_URI, uri);
// add this to the map
namespaceImportsMap.put(uri, namespaceImport);
// we also need to associate this uri with a prefix
// and include that prefix
// in the schema's namspace declarations. So add
// theis particular namespace to the
// prefix map as well
prefix = getTemporaryNamespacePrefix();
namespacePrefixMap.put(uri, prefix);
} else {
// this URI should be already in the namspace prefix
// map
prefix = (String) namespacePrefixMap.get(uri);
}
}
// If it's from a type the element we need to add a name and
// the type
// if not it's the element reference
if (isTyped) {
child.setAttribute(XSD_NAME, elementName);
child.setAttribute(XSD_TYPE, prefix + ":"
+ schemaTypeName.getLocalPart());
} else {
child.setAttribute(XSD_REF, prefix + ":"
+ schemaTypeName.getLocalPart());
}
cmplxTypeSequence.appendChild(child);
}
newComplexType.appendChild(cmplxTypeSequence);
// add this newly created complextype to the list
complexTypeElementsMap.put(wsdl4jMessage.getQName(),
newComplexType);
resolvedMessageQNames.add(wsdl4jMessage.getQName());
}
}
Element elementDeclaration;
// loop through the input op map and generate the elements
String[] inputOperationtNames = (String[]) inputOperationsMap.keySet()
.toArray(new String[inputOperationsMap.size()]);
for (int j = 0; j < inputOperationtNames.length; j++) {
String inputOpName = inputOperationtNames[j];
elementDeclaration = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_ELEMENT_LOCAL_NAME);
elementDeclaration.setAttribute(XSD_NAME, inputOpName);
QName typeQName = ((Message) inputOperationsMap.get(inputOpName))
.getQName();
// add the anonymous
elementDeclaration.appendChild(((Element) complexTypeElementsMap
.get(typeQName)).cloneNode(true));
elementElementsList.add(elementDeclaration);
resolvedRpcWrappedElementMap.put(inputOpName, new QName(
namespaceURI, inputOpName, AXIS2WRAPPED));
}
// loop through the output op map and generate the elements
String[] outputOperationtNames = (String[]) outputOperationsMap
.keySet().toArray(new String[outputOperationsMap.size()]);
for (int j = 0; j < outputOperationtNames.length; j++) {
String baseoutputOpName = outputOperationtNames[j];
String outputOpName = baseoutputOpName + WRAPPED_OUTPUTNAME_SUFFIX;
elementDeclaration = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_ELEMENT_LOCAL_NAME);
elementDeclaration.setAttribute(XSD_NAME, outputOpName);
QName typeQName = ((Message) outputOperationsMap
.get(baseoutputOpName)).getQName();
// add the anonymous
elementDeclaration.appendChild(((Element) complexTypeElementsMap
.get(typeQName)).cloneNode(true));
elementElementsList.add(elementDeclaration);
resolvedRpcWrappedElementMap.put(outputOpName, new QName(
namespaceURI, outputOpName, AXIS2WRAPPED));
}
// loop through the faultoutput op map and generate the elements
String[] faultyOperationtNames = (String[]) faultyOperationsMap
.keySet().toArray(new String[faultyOperationsMap.size()]);
for (int j = 0; j < faultyOperationtNames.length; j++) {
String baseFaultOpName = faultyOperationtNames[j];
elementDeclaration = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_ELEMENT_LOCAL_NAME);
elementDeclaration.setAttribute(XSD_NAME, baseFaultOpName);
QName typeQName = ((Message) faultyOperationsMap
.get(baseFaultOpName)).getQName();
elementDeclaration.appendChild(((Element) complexTypeElementsMap
.get(typeQName)).cloneNode(true));
elementElementsList.add(elementDeclaration);
resolvedRpcWrappedElementMap.put(baseFaultOpName, new QName(
namespaceURI, baseFaultOpName, AXIS2WRAPPED));
}
// /////////////////////////////////////////////////////////////////////
//
// Now we are done with processing the messages and generating the right
// schema object model
// time to write out the schema
//
// There is a catch here - when the target namespace of the generated
// schema is equivalent to one of the existing schemas we'll have to
// insert the elements there rather than creating a new Schema element
// //////////////////////////////////////////////////////////////////////
//
if (existingSchemaMap.containsKey(namespaceURI)) {
// get the relevant schema element
Element schemaElement = (Element) existingSchemaMap
.get(namespaceURI);
Document ownerDocument = schemaElement.getOwnerDocument();
// loop through the namespace declarations first and add them
String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap
.keySet().toArray(new String[namespacePrefixMap.size()]);
for (int i = 0; i < nameSpaceDeclarationArray.length; i++) {
String s = nameSpaceDeclarationArray[i];
checkAndAddNamespaceDeclarations(s, namespacePrefixMap,
schemaElement);
}
// add imports - check whether it is the targetnamespace before
// adding
Element[] namespaceImports = (Element[]) namespaceImportsMap
.values().toArray(new Element[namespaceImportsMap.size()]);
for (int i = 0; i < namespaceImports.length; i++) {
if (!namespaceURI.equals(namespaceImports[i]
.getAttribute(NAMESPACE_URI))) {
schemaElement.appendChild(ownerDocument.importNode(
namespaceImports[i], true));
}
}
Element[] elementDeclarations = (Element[]) elementElementsList
.toArray(new Element[elementElementsList.size()]);
for (int i = 0; i < elementDeclarations.length; i++) {
schemaElement.appendChild(ownerDocument.importNode(
elementDeclarations[i], true));
}
// don't return anything!!
return null;
} else {
// there is no element in the
Element schemaElement = document.createElementNS(
XMLSCHEMA_NAMESPACE_URI, xsdPrefix + ":"
+ XML_SCHEMA_LOCAL_NAME);
// loop through the namespace declarations first
String[] nameSpaceDeclarationArray = (String[]) namespacePrefixMap
.keySet().toArray(new String[namespacePrefixMap.size()]);
for (int i = 0; i < nameSpaceDeclarationArray.length; i++) {
String s = nameSpaceDeclarationArray[i];
schemaElement.setAttributeNS(XML_NAMESPACE_URI,
NAMESPACE_DECLARATION_PREFIX
+ namespacePrefixMap.get(s).toString(), s);
}
if (schemaElement.getAttributeNS(XML_NAMESPACE_URI, xsdPrefix)
.length() == 0) {
schemaElement.setAttributeNS(XML_NAMESPACE_URI,
NAMESPACE_DECLARATION_PREFIX + xsdPrefix,
XMLSCHEMA_NAMESPACE_URI);
}
// add the targetNamespace
schemaElement.setAttributeNS(XML_NAMESPACE_URI, XMLNS_AXIS2WRAPPED,
namespaceURI);
schemaElement.setAttribute(XSD_TARGETNAMESPACE, namespaceURI);
schemaElement.setAttribute(XSD_ELEMENT_FORM_DEFAULT,
XSD_UNQUALIFIED);
// add imports
Element[] namespaceImports = (Element[]) namespaceImportsMap
.values().toArray(new Element[namespaceImportsMap.size()]);
for (int i = 0; i < namespaceImports.length; i++) {
schemaElement.appendChild(namespaceImports[i]);
}
// add element declarations
Element[] elementDeclarations = (Element[]) elementElementsList
.toArray(new Element[elementElementsList.size()]);
for (int i = 0; i < elementDeclarations.length; i++) {
schemaElement.appendChild(elementDeclarations[i]);
}
return schemaElement;
}
}
/**
* @param prefixMap
*/
private void checkAndAddNamespaceDeclarations(String namespace,
Map prefixMap, Element schemaElement) {
// get the attribute for the current namespace
String prefix = (String) prefixMap.get(namespace);
// A prefix must be found at this point!
String existingURL = schemaElement.getAttributeNS(XML_NAMESPACE_URI,
NAMESPACE_DECLARATION_PREFIX + prefix);
if (existingURL == null) {
// there is no existing URL by that prefix - declare a new namespace
schemaElement.setAttributeNS(XML_NAMESPACE_URI,
NAMESPACE_DECLARATION_PREFIX + prefix, namespace);
} else if (existingURL.equals(namespace)) {
// this namespace declaration is already there with the same prefix
// ignore it
} else {
// there is a different namespace declared in the given prefix
// change the prefix in the prefix map to a new one and declare it
// create a prefix
String generatedPrefix = "ns" + prefixCounter++;
while (prefixMap.containsKey(generatedPrefix)) {
generatedPrefix = "ns" + prefixCounter++;
}
schemaElement.setAttributeNS(XML_NAMESPACE_URI,
NAMESPACE_DECLARATION_PREFIX + generatedPrefix, namespace);
// add to the map
prefixMap.put(generatedPrefix, namespace);
}
}
/**
* The intention of this procedure is to process the imports. When
* processing the imports the imported documents will be populating the
* items in the main document recursivley
*
* @param wsdl4JDefinition
*/
private void processImports(Definition wsdl4JDefinition,
List processedDocuments) {
Map wsdlImports = wsdl4JDefinition.getImports();
if (null != wsdlImports && !wsdlImports.isEmpty()) {
Collection importsCollection = wsdlImports.values();
for (Iterator iterator = importsCollection.iterator(); iterator
.hasNext();) {
Vector values = (Vector) iterator.next();
for (int i = 0; i < values.size(); i++) {
Import wsdlImport = (Import) values.elementAt(i);
if (wsdlImport.getDefinition() != null) {
Definition importedDef = wsdlImport.getDefinition();
if (importedDef != null) {
String key = importedDef.getDocumentBaseURI();
if (key == null) {
key = importedDef.getTargetNamespace();
}
// stop recursive imports!
if (processedDocuments.contains(key)) {
return;
}
processedDocuments.add(key);
processImports(importedDef,
processedDocuments);
// copy ns
Map namespaces = importedDef.getNamespaces();
Iterator keys = namespaces.keySet().iterator();
while (keys.hasNext()) {
Object key2 = keys.next();
if (!wsdl4jDefinition.getNamespaces()
.containsValue(namespaces.get(key2))) {
wsdl4jDefinition.getNamespaces().put(key2,
namespaces.get(key2));
}
}
wsdl4jDefinition.getNamespaces().putAll(namespaces);
// copy types
Types t = importedDef.getTypes();
if (t != null) {
List typesList = t.getExtensibilityElements();
for (int j = 0; j < typesList.size(); j++) {
Types types = wsdl4JDefinition.getTypes();
if (types == null) {
types = wsdl4JDefinition.createTypes();
wsdl4JDefinition.setTypes(types);
}
types
.addExtensibilityElement((ExtensibilityElement) typesList
.get(j));
}
}
// add messages
Map messagesMap = importedDef.getMessages();
wsdl4JDefinition.getMessages().putAll(messagesMap);
// add portypes
Map porttypeMap = importedDef.getPortTypes();
wsdl4JDefinition.getPortTypes().putAll(porttypeMap);
// add bindings
Map bindingMap = importedDef.getBindings();
wsdl4JDefinition.getBindings().putAll(bindingMap);
// add services
Map serviceMap = importedDef.getServices();
wsdl4JDefinition.getServices().putAll(serviceMap);
List extElementList = importedDef
.getExtensibilityElements();
wsdl4JDefinition.getExtensibilityElements().addAll(
extElementList);
}
}
}
}
}
}
/**
* Read the WSDL file given the inputstream for the WSDL source
*
* @param in
* @throws WSDLException
*/
private Definition readInTheWSDLFile(InputStream in) throws WSDLException {
WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();
// switch off the verbose mode for all usecases
reader.setFeature(JAVAX_WSDL_VERBOSE_MODE_KEY, false);
// if the custem resolver is present then use it
if (customWSLD4JResolver != null) {
return reader.readWSDL(customWSLD4JResolver);
} else {
Document doc;
try {
doc = XMLUtils.newDocument(in);
} catch (ParserConfigurationException e) {
throw new WSDLException(WSDLException.PARSER_ERROR,
"Parser Configuration Error", e);
} catch (SAXException e) {
throw new WSDLException(WSDLException.PARSER_ERROR,
"Parser SAX Error", e);
} catch (IOException e) {
throw new WSDLException(WSDLException.INVALID_WSDL, "IO Error",
e);
}
return reader.readWSDL(getBaseUri(), doc);
}
}
/**
* Get the Extensible elements form wsdl4jExtensibleElements
* <code>Vector</code> if any and copy them to <code>Component</code>
* <p/> Note - SOAP body extensible element will be processed differently
*
* @param wsdl4jExtensibleElements
* @param description where is the ext element (port , portype , biding)
* @param wsdl4jDefinition
* @param originOfExtensibilityElements -
* this will indicate the place this extensibility element came
* from.
*/
private void copyExtensibleElements(List wsdl4jExtensibleElements,
Definition wsdl4jDefinition, AxisDescription description,
String originOfExtensibilityElements) throws AxisFault {
Iterator iterator = wsdl4jExtensibleElements.iterator();
while (iterator.hasNext()) {
ExtensibilityElement wsdl4jElement = (ExtensibilityElement) iterator
.next();
if (wsdl4jElement instanceof UnknownExtensibilityElement) {
UnknownExtensibilityElement unknown = (UnknownExtensibilityElement) (wsdl4jElement);
if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown
.getElementType())) {
Policy policy = (Policy) PolicyUtil
.getPolicyComponent(unknown.getElement());
addPolicy(description, originOfExtensibilityElements,
policy);
} else if (WSDLConstants.WSDL11Constants.POLICY_REFERENCE
.equals(unknown.getElementType())) {
PolicyReference policyReference = (PolicyReference) PolicyUtil
.getPolicyComponent(unknown.getElement());
addPolicyRef(description, originOfExtensibilityElements,
policyReference);
} else if (AddressingConstants.Final.WSAW_USING_ADDRESSING
.equals(unknown.getElementType())
|| AddressingConstants.Submission.WSAW_USING_ADDRESSING
.equals(unknown.getElementType())) {
// Read the wsaw:UsingAddressing flag from the WSDL. It is
// only valid on the Port or Binding
// so only recognise it as en extensibility elemtn of one of
// those.
if (originOfExtensibilityElements.equals(PORT)
|| originOfExtensibilityElements.equals(BINDING)) {
if (Boolean.TRUE.equals(unknown.getRequired())) {
axisService
.setWSAddressingFlag(AddressingConstants.ADDRESSING_REQUIRED);
} else {
axisService
.setWSAddressingFlag(AddressingConstants.ADDRESSING_OPTIONAL);
}
}
} else if (AddressingConstants.Final.WSAW_ANONYMOUS
.equals(unknown.getElementType())) {
if (originOfExtensibilityElements.equals(BINDING_OPERATION)) {
AxisOperation axisOperation = (AxisOperation) description;
if (unknown.getElement().getFirstChild() != null
&& unknown.getElement().getFirstChild()
.getNodeType() == Node.TEXT_NODE) {
String anonymousValue = unknown.getElement()
.getFirstChild().getNodeValue();
AddressingHelper.setAnonymousParameterValue(
axisOperation, anonymousValue);
}
}
} else {
// Ignore this element - it is a totally unknown element
// and we don't care!
}
// WSDL4J has all the SOAP 1.1 and SOAP 1.2 Items built in. So we can check
// the items directly
} else if (wsdl4jElement instanceof SOAP12Address) {
SOAP12Address soapAddress = (SOAP12Address) wsdl4jElement;
axisService.setEndpoint(soapAddress.getLocationURI());
} else if (wsdl4jElement instanceof SOAPAddress) {
SOAPAddress soapAddress = (SOAPAddress) wsdl4jElement;
axisService.setEndpoint(soapAddress.getLocationURI());
} else if (wsdl4jElement instanceof Schema) {
Schema schema = (Schema) wsdl4jElement;
// just add this schema - no need to worry about the imported
// ones
axisService.addSchema(getXMLSchema(schema.getElement(), schema
.getDocumentBaseURI()));
} else if (wsdl4jElement instanceof SOAP12Operation) {
SOAP12Operation soapOperation = (SOAP12Operation) wsdl4jElement;
if (description instanceof AxisOperation) {
AxisOperation axisOperation = (AxisOperation) description;
if (soapOperation.getStyle() != null) {
axisOperation.setStyle(soapOperation.getStyle());
}
axisOperation.setSoapAction(soapOperation
.getSoapActionURI());
}
} else if (wsdl4jElement instanceof SOAPOperation) {
SOAPOperation soapOperation = (SOAPOperation) wsdl4jElement;
if (description instanceof AxisOperation) {
AxisOperation axisOperation = (AxisOperation) description;
if (soapOperation.getStyle() != null) {
axisOperation.setStyle(soapOperation.getStyle());
}
axisOperation.setSoapAction(soapOperation
.getSoapActionURI());
}
} else if (wsdl4jElement instanceof SOAP12Header) {
SOAP12Header soapHeader = (SOAP12Header) wsdl4jElement;
SOAPHeaderMessage headerMessage = new SOAPHeaderMessage();
headerMessage.setNamespaceURI(soapHeader.getNamespaceURI());
headerMessage.setUse(soapHeader.getUse());
Boolean required = soapHeader.getRequired();
if (null != required) {
headerMessage.setRequired(required.booleanValue());
}
if (null != wsdl4jDefinition) {
// find the relevant schema part from the messages
Message msg = wsdl4jDefinition.getMessage(soapHeader
.getMessage());
if (msg == null) {
// todo i18n this
throw new AxisFault("message "
+ soapHeader.getMessage()
+ " not found in the WSDL ");
}
Part msgPart = msg.getPart(soapHeader.getPart());
if (msgPart == null) {
// todo i18n this
throw new AxisFault("message part "
+ soapHeader.getPart()
+ " not found in the WSDL ");
}
headerMessage.setElement(msgPart.getElementName());
}
headerMessage.setMessage(soapHeader.getMessage());
headerMessage.setPart(soapHeader.getPart());
if (description instanceof AxisMessage) {
((AxisMessage) description).addSoapHeader(headerMessage);
}
} else if (wsdl4jElement instanceof SOAPHeader) {
SOAPHeader soapHeader = (SOAPHeader) wsdl4jElement;
SOAPHeaderMessage headerMessage = new SOAPHeaderMessage();
headerMessage.setNamespaceURI(soapHeader.getNamespaceURI());
headerMessage.setUse(soapHeader.getUse());
Boolean required = soapHeader.getRequired();
if (null != required) {
headerMessage.setRequired(required.booleanValue());
}
if (null != wsdl4jDefinition) {
// find the relevant schema part from the messages
Message msg = wsdl4jDefinition.getMessage(soapHeader
.getMessage());
if (msg == null) {
// todo i18n this
throw new AxisFault("message "
+ soapHeader.getMessage()
+ " not found in the WSDL ");
}
Part msgPart = msg.getPart(soapHeader.getPart());
if (msgPart == null) {
// todo i18n this
throw new AxisFault("message part "
+ soapHeader.getPart()
+ " not found in the WSDL ");
}
headerMessage.setElement(msgPart.getElementName());
}
headerMessage.setMessage(soapHeader.getMessage());
headerMessage.setPart(soapHeader.getPart());
if (description instanceof AxisMessage) {
((AxisMessage) description).addSoapHeader(headerMessage);
}
} else if (wsdl4jElement instanceof SOAPBinding) {
SOAPBinding soapBinding = (SOAPBinding) wsdl4jElement;
style = soapBinding.getStyle();
axisService.setSoapNsUri(soapBinding.getElementType()
.getNamespaceURI());
} else if (wsdl4jElement instanceof SOAP12Binding) {
SOAP12Binding soapBinding = (SOAP12Binding) wsdl4jElement;
style = soapBinding.getStyle();
axisService.setSoapNsUri(soapBinding.getElementType()
.getNamespaceURI());
}
}
}
/**
* Add a policy
*
* @param description
* @param originOfExtensibilityElements
* @param policy
*/
private void addPolicy(AxisDescription description,
String originOfExtensibilityElements, Policy policy) {
if (description instanceof AxisService) {
// wsdl:service
if (SERVICE.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.SERVICE_POLICY, policy);
// wsdl:service -> wsdl:port
} else if (PORT.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.PORT_POLICY, policy);
// wsdl:binding
} else if (BINDING.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.BINDING_POLICY, policy);
}
// TODO wsdl:portType ?
} else if (description instanceof AxisOperation) {
// wsdl:portType -> wsdl:operation
if (PORT_TYPE_OPERATION.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.OPERATION_POLICY, policy);
// wsdl:binding -> wsdl:operation
} else {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.BINDING_OPERATION_POLICY, policy);
}
} else {
// wsdl:portType -> wsdl:operation -> wsdl:input
if (PORT_TYPE_OPERATION_INPUT.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.INPUT_POLICY, policy);
// wsdl:binding -> wsdl:operation -> wsdl:input
} else if (BINDING_OPERATION_INPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.BINDING_INPUT_POLICY, policy);
// wsdl:portType -> wsdl:operation -> wsdl:put
} else if (PORT_TYPE_OPERATION_OUTPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.OUTPUT_POLICY, policy);
// wsdl:binding -> wsdl:operation -> wsdl:output
} else if (BINDING_OPERATION_OUTPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyElement(
PolicyInclude.BINDING_OUTPUT_POLICY, policy);
}
}
}
/**
* Add a policy reference
*
* @param description
* @param originOfExtensibilityElements
* @param policyRefElement
*/
private void addPolicyRef(AxisDescription description,
String originOfExtensibilityElements,
PolicyReference policyRefElement) {
if (description instanceof AxisService) {
// wsdl:service
if (SERVICE.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.SERVICE_POLICY, policyRefElement);
// wsdl:service -> wsdl:port
} else if (PORT.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.PORT_POLICY, policyRefElement);
// wsdl:binding
} else if (BINDING.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.BINDING_POLICY, policyRefElement);
}
// TODO policy for wsdl:portType ?
} else if (description instanceof AxisOperation) {
// wsdl:portType -> wsdl:operation
if (PORT_TYPE_OPERATION.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.OPERATION_POLICY, policyRefElement);
// wsdl:binding -> wsdl:operation
} else {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.BINDING_POLICY, policyRefElement);
}
} else {
// wsdl:portType -> wsdl:operation -> wsdl:input
if (PORT_TYPE_OPERATION_INPUT.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.INPUT_POLICY, policyRefElement);
// wsdl:binding -> wsdl:operation -> wsdl:input
} else if (BINDING_OPERATION_INPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.BINDING_INPUT_POLICY, policyRefElement);
// wsdl:portType -> wsdl:operation -> wsdl:put
} else if (PORT_TYPE_OPERATION_OUTPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.OUTPUT_POLICY, policyRefElement);
// wsdl:binding -> wsdl:operation -> wsdl:output
} else if (BINDING_OPERATION_OUTPUT
.equals(originOfExtensibilityElements)) {
description.getPolicyInclude().addPolicyRefElement(
PolicyInclude.BINDING_OUTPUT_POLICY, policyRefElement);
}
// TODO Faults ..
}
}
/**
* Look for the wrappable operations depending on the style
*
* @param binding
*/
private List findWrappableOperations(Binding binding) {
// first find the global style declaration.
// for a SOAP binding this can be only rpc or document
// as per the WSDL spec (section 3.4) the default style is document
boolean isRPC = false;
boolean isSOAPBinding = false;
List extElements = binding.getExtensibilityElements();
for (int i = 0; i < extElements.size(); i++) {
if (extElements.get(i) instanceof SOAPBinding) {
// we have a global SOAP binding!
isSOAPBinding = true;
SOAPBinding soapBinding = (SOAPBinding) extElements.get(i);
if (RPC_STYLE.equals(soapBinding.getStyle())) {
// set the global style to rpc
isRPC = true;
}
break;
}
}
// if SOAPBinding is not present just return an empty list
if (!isSOAPBinding) {
return new ArrayList();
}
// go through every operation and get their styles.
// each one can have a style override from the global
// styles. Depending on the style add the relevant operations
// to the return list
List returnList = new ArrayList();
BindingOperation bindingOp;
for (Iterator bindingOperationsIterator = binding
.getBindingOperations().iterator(); bindingOperationsIterator
.hasNext();) {
bindingOp = (BindingOperation) bindingOperationsIterator.next();
String style = getSOAPStyle(bindingOp);
if (style == null) {
// no style specified
// use the global style to determine whether to put this one or
// not
if (isRPC) {
returnList.add(bindingOp.getOperation());
}
} else if (RPC_STYLE.equals(style)) {
// add to the list
returnList.add(bindingOp.getOperation());
}
// if not RPC we just leave it - default is doc
}
// set this to the global list
wrappableOperations = returnList;
return returnList;
}
/**
* Guess the MEP based on the order of messages
*
* @param operation
* @throws Exception
*/
private String getMEP(Operation operation) throws Exception {
OperationType operationType = operation.getStyle();
if (isServerSide) {
if (null != operationType) {
if (operationType.equals(OperationType.REQUEST_RESPONSE))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_OUT;
if (operationType.equals(OperationType.ONE_WAY)) {
if (operation.getFaults().size() > 0) {
return WSDLConstants.WSDL20_2004Constants.MEP_URI_ROBUST_IN_ONLY;
}
return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_ONLY;
}
if (operationType.equals(OperationType.NOTIFICATION))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_ONLY;
if (operationType.equals(OperationType.SOLICIT_RESPONSE))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_IN;
throw new Exception("Cannot Determine the MEP");
}
} else {
if (null != operationType) {
if (operationType.equals(OperationType.REQUEST_RESPONSE))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_IN;
if (operationType.equals(OperationType.ONE_WAY))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_OUT_ONLY;
if (operationType.equals(OperationType.NOTIFICATION))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_ONLY;
if (operationType.equals(OperationType.SOLICIT_RESPONSE))
return WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_OUT;
throw new Exception("Cannot Determine the MEP");
}
}
throw new Exception("Cannot Determine the MEP");
}
/**
* Copies the extension attributes
*
* @param extAttributes
* @param description
* @param origin
*/
private void copyExtensionAttributes(Map extAttributes,
AxisDescription description, String origin) {
QName key;
QName value;
for (Iterator iterator = extAttributes.keySet().iterator(); iterator
.hasNext();) {
key = (QName) iterator.next();
if (Constants.URI_POLICY_NS.equals(key.getNamespaceURI())
&& "PolicyURIs".equals(key.getLocalPart())) {
value = (QName) extAttributes.get(key);
String policyURIs = value.getLocalPart();
if (policyURIs.length() != 0) {
String[] uris = policyURIs.split(" ");
PolicyReference ref;
for (int i = 0; i < uris.length; i++) {
ref = new PolicyReference();
ref.setURI(uris[i]);
if (PORT_TYPE.equals(origin)) {
PolicyInclude include = description
.getPolicyInclude();
include.addPolicyRefElement(
PolicyInclude.PORT_TYPE_POLICY, ref);
}
}
}
}
}
}
/**
* Process the policy definitions
*
* @param definition
*/
private void processPoliciesInDefintion(Definition definition) {
List extElements = definition.getExtensibilityElements();
ExtensibilityElement extElement;
for (Iterator iterator = extElements.iterator(); iterator.hasNext();) {
extElement = (ExtensibilityElement) iterator.next();
if (extElement instanceof UnknownExtensibilityElement) {
UnknownExtensibilityElement unknown = (UnknownExtensibilityElement) extElement;
if (WSDLConstants.WSDL11Constants.POLICY.equals(unknown
.getElementType())) {
Policy policy = (Policy) PolicyUtil
.getPolicyComponent(unknown.getElement());
String key;
if ((key = policy.getName()) != null
|| (key = policy.getId()) != null) {
registry.register(key, policy);
}
}
}
}
}
/**
* Inner class declaration for the processing exceptions
*/
public static class WSDLProcessingException extends RuntimeException {
public WSDLProcessingException() {
}
public WSDLProcessingException(String message) {
super(message);
}
public WSDLProcessingException(Throwable cause) {
super(cause);
}
public WSDLProcessingException(String message, Throwable cause) {
super(message, cause);
}
}
}