/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.axis2.description;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMAttribute;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMNamespace;
import org.apache.axiom.om.OMNode;
import org.apache.axiom.soap.SOAP11Constants;
import org.apache.axiom.soap.SOAP12Constants;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.addressing.AddressingConstants;
import org.apache.axis2.addressing.AddressingHelper;
import org.apache.axis2.description.java2wsdl.Java2WSDLConstants;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.util.ExternalPolicySerializer;
import org.apache.axis2.util.JavaUtils;
import org.apache.axis2.util.PolicyLocator;
import org.apache.axis2.util.PolicyUtil;
import org.apache.axis2.util.WSDLSerializationUtil;
import org.apache.axis2.util.XMLUtils;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyComponent;
import org.apache.neethi.PolicyReference;
import org.apache.ws.commons.schema.XmlSchema;
import org.apache.ws.commons.schema.XmlSchemaComplexType;
import org.apache.ws.commons.schema.XmlSchemaElement;
import org.apache.ws.commons.schema.XmlSchemaParticle;
import org.apache.ws.commons.schema.XmlSchemaSequence;
import org.apache.ws.commons.schema.XmlSchemaSequenceMember;
import org.apache.ws.commons.schema.XmlSchemaSimpleType;
import org.apache.ws.commons.schema.XmlSchemaType;
import javax.xml.namespace.QName;
import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLStreamException;
import java.io.ByteArrayInputStream;
import java.io.StringWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class AxisService2WSDL20 implements WSDL2Constants {
protected AxisService axisService;
protected String serviceName;
private String[] eprs = null;
private OMNamespace wsaw;
private OMNamespace wsdl;
private OMNamespace wsoap;
private OMNamespace whttp;
private OMNamespace wsdlx;
private OMNamespace wrpc;
private OMNamespace tns;
private String interfaceName;
private HashMap policiesInDescription = new HashMap();
private ExternalPolicySerializer filter = null;
private boolean checkIfEndPointActive = true;
public AxisService2WSDL20() { }
protected void init() throws AxisFault {
}
public AxisService2WSDL20(AxisService service) {
this.axisService = service;
this.serviceName = service.getName();
}
public AxisService2WSDL20(AxisService service, String serviceName) {
this.axisService = service;
this.serviceName = serviceName;
}
/**
* Sets whether to make a check if endpoint is active before adding the endpoint
* to the WSDL. By default an endpoint is not added if a transport for the endpoint
* is not found.
*
* @param flag true=check if endpoint is active before adding endpoint.
* false=add endpoint independent of whether endpoint is active.
*/
public void setCheckIfEndPointActive(boolean flag) {
checkIfEndPointActive = flag;
}
/**
* Generates a WSDL 2.0 document for this web service
* @return The WSDL2 document element
* @throws Exception - Thrown in case an exception occurs
*/
public OMElement generateOM() throws Exception {
OMFactory omFactory = OMAbstractFactory.getOMFactory();
OMElement descriptionElement = generateDescription(omFactory);
// Add the documentation element
OMElement documentation = generateDocumentation(omFactory);
if (documentation != null) {
descriptionElement.addChild(documentation);
}
OMElement types = generateTypes(omFactory);
if (types != null) {
descriptionElement.addChild(types);
}
OMElement interfaces = generateInterface(omFactory);
if (interfaces != null) {
descriptionElement.addChild(interfaces);
}
generateService(omFactory, descriptionElement, isDisableREST(), isDisableSOAP12(),
isDisableSOAP11());
addPoliciesToDescriptionElement(getPoliciesInDefinitions(),
descriptionElement);
return descriptionElement;
}
/**
* Generates the interface element for the service
*
* @param wsdl The WSDL namespace
* @param tns The target namespace
* @param wsdlx The WSDL extensions namespace
* @param fac The active OMFactory
* @param interfaceName The name of the interface
* @return The generated interface element
* @throws FactoryConfigurationError
* @throws XMLStreamException
*/
private OMElement getInterfaceElement(OMNamespace wsdl, OMNamespace tns, OMNamespace wsdlx,
OMNamespace wrpc, OMFactory fac, String interfaceName)
throws URISyntaxException, AxisFault, XMLStreamException, FactoryConfigurationError {
OMElement interfaceElement = fac.createOMElement(WSDL2Constants.INTERFACE_LOCAL_NAME, wsdl);
interfaceElement.addAttribute(fac.createOMAttribute(WSDL2Constants.ATTRIBUTE_NAME, null,
interfaceName));
addPolicyAsExtensibleElement(axisService, interfaceElement);
Iterator iterator = axisService.getOperations();
ArrayList interfaceOperations = new ArrayList();
ArrayList interfaceFaults = new ArrayList();
int i = 0;
while (iterator.hasNext()) {
AxisOperation axisOperation = (AxisOperation) iterator.next();
if (axisOperation.isControlOperation()) {
continue;
}
interfaceOperations.add(i, generateInterfaceOperationElement(axisOperation, wsdl, tns,
wsdlx, wrpc));
i++;
Iterator faultsIterator = axisOperation.getFaultMessages().iterator();
while (faultsIterator.hasNext()) {
AxisMessage faultMessage = (AxisMessage) faultsIterator.next();
String name = faultMessage.getName();
if (!interfaceFaults.contains(name)) {
OMElement faultElement =
fac.createOMElement(WSDL2Constants.FAULT_LOCAL_NAME, wsdl);
faultElement.addAttribute(
fac.createOMAttribute(WSDL2Constants.ATTRIBUTE_NAME, null, name));
faultElement.addAttribute(fac.createOMAttribute(
WSDL2Constants.ATTRIBUTE_ELEMENT, null, WSDLSerializationUtil
.getElementName(faultMessage, axisService.getNamespaceMap())));
interfaceFaults.add(name);
interfaceElement.addChild(faultElement);
}
}
}
for (i = 0; i < interfaceOperations.size(); i++) {
interfaceElement.addChild((OMNode) interfaceOperations.get(i));
}
return interfaceElement;
}
/**
* Generates the service element for the service
*
* @param wsdl the WSDL namespace
* @param tns the target namespace
* @param omFactory the active OMFactory
* @param interfaceName the name of the interface
* @return the generated service element
*/
private OMElement getServiceElement(OMNamespace wsdl, OMNamespace tns, OMFactory omFactory,
String interfaceName) {
OMElement serviceElement =
omFactory.createOMElement(WSDL2Constants.SERVICE_LOCAL_NAME, wsdl);
serviceElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_NAME, null,
serviceName));
serviceElement.addAttribute(omFactory.createOMAttribute(WSDL2Constants.INTERFACE_LOCAL_NAME,
null, tns.getPrefix() + ":" +
interfaceName));
return serviceElement;
}
/**
* Generates the interface Operation element. As with the binding operations we dont need to
* ask AxisMessage to serialize its message cause AxisMessage does not have specific properties
* as bindings.
*
* @param axisOperation the operation to write
* @param wsdl the WSDL namespace
* @param tns the target namespace
* @param wsdlx the WSDL extentions namespace (WSDL 2.0)
* @return the generated <operation> element
* @throws FactoryConfigurationError
* @throws XMLStreamException
*/
public OMElement generateInterfaceOperationElement(AxisOperation axisOperation,
OMNamespace wsdl,
OMNamespace tns,
OMNamespace wsdlx,
OMNamespace wrpc) throws
URISyntaxException, AxisFault, XMLStreamException, FactoryConfigurationError {
OMFactory omFactory = OMAbstractFactory.getOMFactory();
OMElement axisOperationElement =
omFactory.createOMElement(WSDL2Constants.OPERATION_LOCAL_NAME, wsdl);
WSDLSerializationUtil
.addWSDLDocumentationElement(axisOperation, axisOperationElement, omFactory, wsdl);
axisOperationElement.addAttribute(omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_NAME,
null,
axisOperation
.getName().getLocalPart()));
addPolicyAsExtensibleElement(axisOperation, axisOperationElement);
URI[] opStyle = (URI[]) axisOperation.getParameterValue(WSDL2Constants.OPERATION_STYLE);
if (opStyle == null) {
opStyle = checkStyle(axisOperation);
Parameter opStyleParameter = new Parameter();
opStyleParameter.setName(WSDL2Constants.OPERATION_STYLE);
opStyleParameter.setValue(opStyle);
axisOperation.addParameter(opStyleParameter);
}
if (opStyle != null && opStyle.length > 0) {
String style = opStyle[0].toString();
for (int i = 1; i < opStyle.length; i++) {
URI uri = opStyle[i];
style = style + " " + uri;
}
axisOperationElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_STYLE, null, style));
if (style.indexOf(WSDL2Constants.STYLE_RPC) >= 0) {
axisOperationElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_SIGNATURE, wrpc,
(String) axisOperation.getParameterValue(
WSDL2Constants.ATTR_WRPC_SIGNATURE)));
}
}
axisOperationElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_NAME_PATTERN, null, axisOperation.getMessageExchangePattern()));
Parameter param = axisOperation.getParameter(WSDL2Constants.ATTR_WSDLX_SAFE);
if (param != null) {
axisOperationElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_SAFE, wsdlx, (param.getValue()).toString()));
}
AxisService axisService = axisOperation.getAxisService();
Map nameSpaceMap = axisService.getNamespaceMap();
// Add the input element
AxisMessage inMessage = (AxisMessage) axisOperation.getChild(WSDLConstants.WSDL_MESSAGE_IN_MESSAGE);
if (inMessage != null) {
OMElement inMessageElement = omFactory.createOMElement(WSDL2Constants.IN_PUT_LOCAL_NAME, wsdl);
inMessageElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_ELEMENT, null,
WSDLSerializationUtil.getElementName(inMessage, nameSpaceMap)));
WSDLSerializationUtil.addWSAWActionAttribute(inMessageElement, axisOperation.getInputAction(),wsaw);
WSDLSerializationUtil.addWSDLDocumentationElement(inMessage, inMessageElement, omFactory, wsdl);
axisOperationElement.addChild(inMessageElement);
}
// Add the output element
// here we need to consider the mep. since at the AxisOperationFactory class even for the roubust in only
// messages it creates an InOutAxis Operation
// case WSDLConstants.MEP_CONSTANT_ROBUST_IN_ONLY : {
// abOpdesc = new InOutAxisOperation();
// abOpdesc.setMessageExchangePattern(WSDL2Constants.MEP_URI_ROBUST_IN_ONLY);
// break;
// }
// get the same logic from the AxisServiceToWSDL11 class.
String mep = axisOperation.getMessageExchangePattern();
if (WSDL2Constants.MEP_URI_OUT_ONLY.equals(mep)
|| WSDL2Constants.MEP_URI_OUT_OPTIONAL_IN.equals(mep)
|| WSDL2Constants.MEP_URI_IN_OPTIONAL_OUT.equals(mep)
|| WSDL2Constants.MEP_URI_ROBUST_OUT_ONLY.equals(mep)
|| WSDL2Constants.MEP_URI_IN_OUT.equals(mep)) {
AxisMessage outMessage = (AxisMessage) axisOperation.getChild(WSDLConstants.WSDL_MESSAGE_OUT_MESSAGE);
if (outMessage != null) {
OMElement outMessageElement = omFactory.createOMElement(WSDL2Constants.OUT_PUT_LOCAL_NAME, wsdl);
outMessageElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_ELEMENT, null,
WSDLSerializationUtil.getElementName(outMessage, nameSpaceMap)));
WSDLSerializationUtil.addWSAWActionAttribute(outMessageElement, axisOperation.getOutputAction(), wsaw);
WSDLSerializationUtil.addWSDLDocumentationElement(outMessage, outMessageElement, omFactory, wsdl);
axisOperationElement.addChild(outMessageElement);
}
}
// Add the fault element
ArrayList faults = axisOperation.getFaultMessages();
if (faults != null) {
Iterator iterator = faults.iterator();
while (iterator.hasNext()) {
AxisMessage faultMessage = (AxisMessage) iterator.next();
OMElement faultElement;
if (WSDLConstants.WSDL_MESSAGE_DIRECTION_IN.equals(faultMessage.getDirection())) {
faultElement = omFactory.createOMElement(WSDL2Constants.IN_FAULT_LOCAL_NAME, wsdl);
} else {
faultElement = omFactory.createOMElement(WSDL2Constants.OUT_FAULT_LOCAL_NAME, wsdl);
}
faultElement.addAttribute(omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_REF,
null, tns.getPrefix() + ":" +
faultMessage.getName()));
WSDLSerializationUtil.addWSAWActionAttribute(faultElement,
axisOperation.getFaultAction(
faultMessage.getName()), wsaw);
WSDLSerializationUtil
.addWSDLDocumentationElement(faultMessage, faultElement, omFactory, wsdl);
axisOperationElement.addChild(faultElement);
}
}
return axisOperationElement;
}
public void setEPRs(String[] eprs) {
this.eprs = eprs;
}
/**
* This function checks the schema and returns the WSDL 2.0 styles that it conform to.
* It checks for RPC, IRI and Multipart styles.
* For full details on the rules please refer http://www.w3.org/TR/2007/REC-wsdl20-adjuncts-20070626/#styles
* @param axisOperation - The axisOperation that needs to be checked
* @return String [] - An array of styles that the operation adheres to.
*/
private URI [] checkStyle(AxisOperation axisOperation) throws URISyntaxException, AxisFault {
boolean isRPC = true;
boolean isMultipart = true;
boolean isIRI = true;
ArrayList styles = new ArrayList(3);
String mep = axisOperation.getMessageExchangePattern();
if (!(WSDL2Constants.MEP_URI_IN_ONLY.equals(mep) ||
WSDL2Constants.MEP_URI_IN_OUT.equals(mep))) {
isRPC = false;
}
QName inMessageElementQname;
Map inMessageElementDetails = new LinkedHashMap();
AxisMessage inMessage = axisOperation.getMessage(WSDL2Constants.MESSAGE_LABEL_IN);
if (inMessage != null) {
QName qName = inMessage.getElementQName();
if (qName == null || Constants.XSD_ANY.equals(qName)) {
return new URI [0];
}
XmlSchemaElement schemaElement = inMessage.getSchemaElement();
if (schemaElement != null) {
if (!axisOperation.getName().getLocalPart().equals(schemaElement.getName())) {
return new URI [0];
}
inMessageElementQname = schemaElement.getQName();
XmlSchemaType type = schemaElement.getSchemaType();
if (type != null && type instanceof XmlSchemaComplexType) {
XmlSchemaComplexType complexType = (XmlSchemaComplexType) type;
XmlSchemaParticle particle = complexType.getParticle();
if (particle != null && particle instanceof XmlSchemaSequence) {
XmlSchemaSequence xmlSchemaSequence = (XmlSchemaSequence) particle;
if (!xmlSchemaSequence.getItems().isEmpty()) {
for (XmlSchemaSequenceMember member : xmlSchemaSequence.getItems()) {
if (!(member instanceof XmlSchemaElement)) {
return new URI[0];
}
XmlSchemaElement innerElement = (XmlSchemaElement) member;
if (innerElement.getRef().getTargetQName() != null) {
return new URI[0];
}
if (innerElement.getMinOccurs() != 1 ||
innerElement.getMaxOccurs() != 1) {
isMultipart = false;
}
XmlSchemaType schemaType = innerElement.getSchemaType();
QName innerElementQName = innerElement.getSchemaTypeName();
if (schemaType instanceof XmlSchemaSimpleType) {
if (Constants.XSD_QNAME.equals(innerElementQName) ||
Constants.XSD_NOTATION.equals(innerElementQName) ||
Constants.XSD_HEXBIN.equals(innerElementQName) ||
Constants.XSD_BASE64.equals(innerElementQName)) {
isIRI = false;
}
} else {
isIRI = false;
}
if (Constants.XSD_ANY.equals(innerElementQName)) {
isRPC = false;
}
String name = innerElement.getName();
if (inMessageElementDetails.get(name) != null) {
isRPC = false;
isMultipart = false;
}
inMessageElementDetails.put(name, innerElementQName);
}
}
} else {
return new URI[0];
}
} else {
return new URI[0];
}
} else {
return new URI [0];
}
} else {
return new URI [0];
}
AxisMessage outMessage = null;
Map outMessageElementDetails = new LinkedHashMap();
if (isRPC && !WSDL2Constants.MEP_URI_IN_ONLY.equals(mep)) {
outMessage = axisOperation.getMessage(WSDL2Constants.MESSAGE_LABEL_OUT);
QName qName = outMessage.getElementQName();
if (qName == null && Constants.XSD_ANY.equals(qName)) {
isRPC = false;
}
XmlSchemaElement schemaElement = outMessage.getSchemaElement();
if (schemaElement != null) {
if (!(axisOperation.getName().getLocalPart() + Java2WSDLConstants.RESPONSE)
.equals(schemaElement.getName())) {
isRPC = false;
}
if (!schemaElement.getQName().getNamespaceURI()
.equals(inMessageElementQname.getNamespaceURI())) {
isRPC = false;
}
XmlSchemaType type = schemaElement.getSchemaType();
if (type != null && type instanceof XmlSchemaComplexType) {
XmlSchemaComplexType complexType = (XmlSchemaComplexType) type;
XmlSchemaParticle particle = complexType.getParticle();
if (particle != null && particle instanceof XmlSchemaSequence) {
XmlSchemaSequence xmlSchemaSequence = (XmlSchemaSequence) particle;
if (!xmlSchemaSequence.getItems().isEmpty()) {
for (XmlSchemaSequenceMember member : xmlSchemaSequence.getItems()) {
if (!(member instanceof XmlSchemaElement)) {
isRPC = false;
}
XmlSchemaElement innerElement = (XmlSchemaElement) member;
QName schemaTypeName = innerElement.getSchemaTypeName();
String name = innerElement.getName();
if (innerElement.getRef().getTargetQName() != null) {
isRPC = false;
}
if (outMessageElementDetails.get(name) != null) {
isRPC = false;
}
QName inMessageElementType =
(QName) inMessageElementDetails.get(name);
if (inMessageElementType != null &&
inMessageElementType != schemaTypeName) {
isRPC = false;
}
outMessageElementDetails.put(name, schemaTypeName);
}
}
} else {
isRPC = false;
}
} else {
isRPC = false;
}
} else {
isRPC = false;
}
}
int count = 0;
if (isRPC) {
styles.add(new URI(WSDL2Constants.STYLE_RPC));
axisOperation.addParameter(WSDL2Constants.ATTR_WRPC_SIGNATURE, generateRPCSignature(
inMessageElementDetails, outMessageElementDetails));
count ++;
}
if (isIRI) {
styles.add(new URI(WSDL2Constants.STYLE_IRI));
count ++;
}
if (isMultipart) {
styles.add(new URI(WSDL2Constants.STYLE_MULTIPART));
count ++;
}
return (URI[]) styles.toArray(new URI[count]);
}
private String generateRPCSignature(Map inMessageElementDetails, Map outMessageElementDetails) {
String in = "";
String out = "";
String inOut = "";
Set inElementSet = inMessageElementDetails.keySet();
Set outElementSet = outMessageElementDetails.keySet();
Iterator inElementIterator = inElementSet.iterator();
while (inElementIterator.hasNext()) {
String inElementName = (String) inElementIterator.next();
if (outElementSet.contains(inElementName)) {
inOut = inOut + inElementName + " " + WSDL2Constants.RPC_INOUT + " ";
outElementSet.remove(inElementName);
} else {
in = in + inElementName + " " + WSDL2Constants.RPC_IN + " ";
}
}
Iterator outElementIterator = outElementSet.iterator();
while (outElementIterator.hasNext()) {
String outElementName = (String) outElementIterator.next();
out = out + outElementName + " " + WSDL2Constants.RPC_RETURN + " ";
}
return in + out + inOut;
}
private void addPolicyAsExtensibleElement(AxisDescription axisDescription,
OMElement descriptionElement) throws XMLStreamException,
FactoryConfigurationError, AxisFault {
PolicySubject policySubject = axisDescription.getPolicySubject();
Collection attachPolicyComponents = policySubject
.getAttachedPolicyComponents();
for (Iterator iterator = attachPolicyComponents.iterator(); iterator
.hasNext();) {
Object policyElement = iterator.next();
if (policyElement instanceof Policy) {
PolicyReference policyReference = PolicyUtil
.createPolicyReference((Policy) policyElement);
OMElement policyRefElement = PolicyUtil
.getPolicyComponentAsOMElement(
(PolicyComponent) policyReference, filter);
OMNode firstChildElem = descriptionElement.getFirstElement();
if (firstChildElem == null) {
descriptionElement.addChild(policyRefElement);
} else {
firstChildElem.insertSiblingBefore(policyRefElement);
}
String key = ((PolicyReference) policyReference).getURI();
if (key.startsWith("#")) {
key = key.substring(key.indexOf("#") + 1);
}
policiesInDescription.put(key, (Policy) policyElement);
} else if (policyElement instanceof PolicyReference) {
OMElement child = PolicyUtil
.getPolicyComponentAsOMElement((PolicyComponent) policyElement);
OMElement firstChildElem = descriptionElement.getFirstElement();
if (firstChildElem == null) {
descriptionElement.addChild(child);
} else {
firstChildElem.insertSiblingBefore(child);
}
String key = ((PolicyReference) policyElement).getURI();
if (key.startsWith("#")) {
key = key.substring(key.indexOf("#") + 1);
}
PolicyLocator locator = new PolicyLocator(axisService);
Policy p = locator.lookup(key);
if (p == null) {
throw new AxisFault("Policy not found for uri : " + key);
}
policiesInDescription.put(key, p);
}
}
}
protected void addPoliciesToDescriptionElement(List policies,
OMElement descriptionElement) throws XMLStreamException,
FactoryConfigurationError {
for (int i = 0; i < policies.size(); i++) {
Policy policy = (Policy) policies.get(i);
OMElement policyElement = PolicyUtil.getPolicyComponentAsOMElement(
policy, filter);
OMNode firstChild = descriptionElement.getFirstOMChild();
if (firstChild != null) {
firstChild.insertSiblingBefore(policyElement);
} else {
descriptionElement.addChild(policyElement);
}
}
}
protected OMElement generateDescription(OMFactory omFactory) {
Map nameSpacesMap = axisService.getNamespaceMap();
filter = new ExternalPolicySerializer();
AxisConfiguration axisConfiguration = axisService
.getAxisConfiguration();
if (axisConfiguration != null) {
filter.setAssertionsToFilter(axisConfiguration
.getLocalPolicyAssertions());
}
//
if (nameSpacesMap != null && nameSpacesMap.containsValue(WSDL2Constants.WSDL_NAMESPACE)) {
wsdl = omFactory
.createOMNamespace(WSDL2Constants.WSDL_NAMESPACE,
WSDLSerializationUtil.getPrefix(
WSDL2Constants.WSDL_NAMESPACE, nameSpacesMap));
} else {
wsdl = omFactory
.createOMNamespace(WSDL2Constants.WSDL_NAMESPACE,
WSDL2Constants.DEFAULT_WSDL_NAMESPACE_PREFIX);
}
OMElement descriptionElement = omFactory.createOMElement(WSDL2Constants.DESCRIPTION, wsdl);
// Declare all the defined namespaces in the document
WSDLSerializationUtil.populateNamespaces(descriptionElement, nameSpacesMap);
descriptionElement.declareNamespace(axisService.getTargetNamespace(),
axisService.getTargetNamespacePrefix());
wsaw = descriptionElement.declareNamespace(AddressingConstants.Final.WSAW_NAMESPACE, "wsaw");
// Need to add the targetnamespace as an attribute according to the wsdl 2.0 spec
OMAttribute targetNamespace = omFactory
.createOMAttribute(WSDL2Constants.TARGET_NAMESPACE, null,
axisService.getTargetNamespace());
descriptionElement.addAttribute(targetNamespace);
// Check whether the required namespaces are already in namespaceMap, if they are not
// present declare them.
tns = omFactory
.createOMNamespace(axisService.getTargetNamespace(),
axisService.getTargetNamespacePrefix());
if (nameSpacesMap != null && nameSpacesMap.containsValue(WSDL2Constants.URI_WSDL2_SOAP)) {
wsoap = omFactory
.createOMNamespace(WSDL2Constants.URI_WSDL2_SOAP,
WSDLSerializationUtil.getPrefix(
WSDL2Constants.URI_WSDL2_SOAP, nameSpacesMap));
} else {
wsoap = descriptionElement
.declareNamespace(WSDL2Constants.URI_WSDL2_SOAP, WSDL2Constants.SOAP_PREFIX);
}
if (nameSpacesMap != null && nameSpacesMap.containsValue(WSDL2Constants.URI_WSDL2_HTTP)) {
whttp = omFactory
.createOMNamespace(WSDL2Constants.URI_WSDL2_HTTP,
WSDLSerializationUtil.getPrefix(
WSDL2Constants.URI_WSDL2_HTTP, nameSpacesMap));
} else {
whttp = descriptionElement
.declareNamespace(WSDL2Constants.URI_WSDL2_HTTP, WSDL2Constants.HTTP_PREFIX);
}
if (nameSpacesMap != null && nameSpacesMap.containsValue(WSDL2Constants.URI_WSDL2_EXTENSIONS)) {
wsdlx = omFactory
.createOMNamespace(WSDL2Constants.URI_WSDL2_EXTENSIONS,
WSDLSerializationUtil.getPrefix(
WSDL2Constants.URI_WSDL2_EXTENSIONS, nameSpacesMap));
} else {
wsdlx = descriptionElement.declareNamespace(WSDL2Constants.URI_WSDL2_EXTENSIONS,
WSDL2Constants.WSDL_EXTENTION_PREFIX);
}
if (nameSpacesMap != null && nameSpacesMap.containsValue(WSDL2Constants.URI_WSDL2_RPC)) {
wrpc = omFactory
.createOMNamespace(WSDL2Constants.URI_WSDL2_RPC,
WSDLSerializationUtil.getPrefix(
WSDL2Constants.URI_WSDL2_RPC, nameSpacesMap));
} else {
wrpc = descriptionElement.declareNamespace(WSDL2Constants.URI_WSDL2_RPC,
WSDL2Constants.WSDL_RPC_PREFIX);
}
return descriptionElement;
}
protected OMElement generateDocumentation(OMFactory omFactory) {
return WSDLSerializationUtil.generateDocumentationElement(axisService,
omFactory, wsdl);
}
protected OMElement generateTypes(OMFactory omFactory) throws AxisFault {
// Add types element
OMElement typesElement = omFactory.createOMElement(WSDL2Constants.TYPES_LOCAL_NALE, wsdl);
axisService.populateSchemaMappings();
ArrayList schemas = axisService.getSchema();
for (int i = 0; i < schemas.size(); i++) {
StringWriter writer = new StringWriter();
XmlSchema schema = axisService.getSchema(i);
if (!org.apache.axis2.namespace.Constants.URI_2001_SCHEMA_XSD
.equals(schema.getTargetNamespace())) {
schema.write(writer);
String schemaString = writer.toString();
if (!"".equals(schemaString)) {
try {
typesElement.addChild(
XMLUtils.toOM(new ByteArrayInputStream(schemaString.getBytes())));
} catch (XMLStreamException e) {
throw AxisFault.makeFault(e);
}
}
}
}
return typesElement;
}
protected OMElement generateInterface(OMFactory omFactory) throws AxisFault, URISyntaxException, XMLStreamException, FactoryConfigurationError {
Parameter parameter = axisService.getParameter(WSDL2Constants.INTERFACE_LOCAL_NAME);
if (parameter != null) {
interfaceName = (String) parameter.getValue();
} else {
interfaceName = WSDL2Constants.DEFAULT_INTERFACE_NAME;
}
// Add the interface element
return getInterfaceElement(wsdl, tns, wsdlx, wrpc, omFactory,
interfaceName);
}
protected OMElement generateService(OMFactory omFactory, OMElement descriptionElement,
boolean disableREST, boolean disableSOAP12, boolean disableSOAP11) throws AxisFault {
// Check whether the axisService has any endpoints. If they exists serialize them else
// generate default endpoint elements.
OMElement serviceElement;
Set bindings = new HashSet();
Map endpointMap = axisService.getEndpoints();
Object value = axisService.getParameterValue("isCodegen");
boolean isCodegen = false;
if (JavaUtils.isTrueExplicitly(value)) {
isCodegen = true;
}
if (endpointMap != null && endpointMap.size() > 0) {
serviceElement = getServiceElement(wsdl, tns, omFactory, interfaceName);
Iterator iterator = endpointMap.values().iterator();
while (iterator.hasNext()) {
// With the new binding hierachy in place we need to do some extra checking here.
// If a service has both http and https listners up we should show two separate eprs
// If the service was deployed with a WSDL and it had two endpoints for http and
// https then we have two endpoints populated so we should serialize them instead
// of updating the endpoints.
AxisEndpoint axisEndpoint = (AxisEndpoint) iterator.next();
/*
* Some transports might not be active at runtime.
*/
if (!isCodegen && checkIfEndPointActive && !axisEndpoint.isActive()) {
continue;
}
AxisBinding axisBinding = axisEndpoint.getBinding();
String type = axisBinding.getType();
// If HTTP binding is disabled, do not add.
if (WSDL2Constants.URI_WSDL2_HTTP.equals(type)) {
if (isDisableREST()) {
continue;
}
}
// If SOAP 1.2 binding is disabled, do not add.
String propertySOAPVersion =
(String) axisBinding.getProperty(WSDL2Constants.ATTR_WSOAP_VERSION);
if (SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(propertySOAPVersion)) {
if (isDisableSOAP12()) {
continue;
}
}
if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(propertySOAPVersion)) {
if (isDisableSOAP11()) {
continue;
}
}
bindings.add(axisBinding);
OMElement endpointElement = axisEndpoint.toWSDL20(wsdl, tns, whttp);
boolean endpointAlreadyAdded = false;
Iterator endpointsAdded = serviceElement.getChildren();
while (endpointsAdded.hasNext()) {
OMElement endpoint = (OMElement) endpointsAdded.next();
// Checking whether a endpoint with the same binding and address exists.
if (endpoint.getAttribute(new QName(WSDL2Constants.BINDING_LOCAL_NAME))
.getAttributeValue().equals(endpointElement.getAttribute(
new QName(WSDL2Constants.BINDING_LOCAL_NAME)).getAttributeValue())
&& endpoint
.getAttribute(new QName(WSDL2Constants.ATTRIBUTE_ADDRESS))
.getAttributeValue().equals(endpointElement.getAttribute(
new QName(WSDL2Constants.ATTRIBUTE_ADDRESS)).getAttributeValue())) {
endpointAlreadyAdded = true;
}
}
if (!endpointAlreadyAdded) {
// addPolicyAsExtensibleElement(axisEndpoint, endpointElement);
Parameter modifyAddressParam = axisService
.getParameter("modifyUserWSDLPortAddress");
if (modifyAddressParam != null) {
if (Boolean.parseBoolean((String) modifyAddressParam
.getValue())) {
String endpointURL = axisEndpoint
.calculateEndpointURL();
endpointElement
.getAttribute(
new QName(
WSDL2Constants.ATTRIBUTE_ADDRESS))
.setAttributeValue(endpointURL);
}
}
serviceElement.addChild(modifyEndpoint(endpointElement));
}
}
Iterator iter = bindings.iterator();
while (iter.hasNext()) {
AxisBinding binding = (AxisBinding) iter.next();
OMElement bindingElement = binding.toWSDL20(wsdl, tns, wsoap, whttp,
interfaceName,
axisService.getNamespaceMap(),
AddressingHelper.getAddressingRequirementParemeterValue(axisService),
serviceName,wsaw);
descriptionElement
.addChild(modifyBinding(bindingElement));
}
descriptionElement.addChild(serviceElement);
} else {
// There are no andpoints defined hence generate default bindings and endpoints
descriptionElement.addChild(
WSDLSerializationUtil.generateSOAP11Binding(omFactory, axisService, wsdl, wsoap,
tns, serviceName));
if (!isDisableSOAP12()) {
descriptionElement.addChild(modifyBinding(
WSDLSerializationUtil.generateSOAP12Binding(omFactory, axisService, wsdl, wsoap,
tns, serviceName)));
}
if (!isDisableSOAP11()) {
descriptionElement.addChild(modifyBinding(
WSDLSerializationUtil.generateSOAP11Binding(omFactory, axisService, wsdl, wsoap,
tns, serviceName)));
}
if (!isDisableREST()) {
descriptionElement.addChild(modifyBinding(
WSDLSerializationUtil.generateHTTPBinding(omFactory, axisService, wsdl,
whttp,
tns, serviceName)));
}
serviceElement = generateServiceElement(omFactory, wsdl, tns, axisService,
isDisableREST(), isDisableSOAP12(), isDisableSOAP11(), eprs, serviceName);
descriptionElement.addChild(serviceElement);
}
return serviceElement;
}
protected boolean isDisableREST() {
// axis2.xml indicated no HTTP binding?
boolean disableREST = false;
Parameter disableRESTParameter = axisService
.getParameter(org.apache.axis2.Constants.Configuration.DISABLE_REST);
if (disableRESTParameter != null
&& JavaUtils.isTrueExplicitly(disableRESTParameter.getValue())) {
disableREST = true;
}
return disableREST;
}
protected boolean isDisableSOAP11() {
boolean disableSOAP11 = false;
Parameter disableSOAP11Parameter = axisService
.getParameter(org.apache.axis2.Constants.Configuration.DISABLE_SOAP11);
if (disableSOAP11Parameter != null
&& JavaUtils.isTrueExplicitly(disableSOAP11Parameter.getValue())) {
disableSOAP11 = true;
}
return disableSOAP11;
}
protected boolean isDisableSOAP12() {
// axis2.xml indicated no SOAP 1.2 binding?
boolean disableSOAP12 = false;
Parameter disableSOAP12Parameter = axisService
.getParameter(org.apache.axis2.Constants.Configuration.DISABLE_SOAP12);
if (disableSOAP12Parameter != null
&& JavaUtils.isTrueExplicitly(disableSOAP12Parameter.getValue())) {
disableSOAP12 = true;
}
return disableSOAP12;
}
protected List getPoliciesInDefinitions() {
return new ArrayList(policiesInDescription.values());
}
protected OMElement modifyEndpoint(OMElement endpoint) {
return endpoint;
}
protected OMElement modifyBinding(OMElement binding) {
return binding;
}
/**
* Generates a default service element
* @param omFactory - The OMFactory
* @param wsdl the WSDL namespace
* @param tns - The targetnamespace
* @param axisService - The AxisService
* @param disableREST only generate REST endpoint if this is false
* @param disableSOAP12 only generate SOAP 1.2 endpoint if this is false
* @return - The generated service element
* @throws AxisFault - Thrown in case an exception occurs
*/
public OMElement generateServiceElement(OMFactory omFactory, OMNamespace wsdl,
OMNamespace tns, AxisService axisService,
boolean disableREST, boolean disableSOAP12, boolean disableSOAP11,
String serviceName)
throws AxisFault {
return generateServiceElement(omFactory, wsdl, tns, axisService, disableREST, disableSOAP12,disableSOAP11,
null, serviceName);
}
/**
* Generates a default service element
* @param omFactory - The OMFactory
* @param wsdl the WSDL namespace
* @param tns - The targetnamespace
* @param axisService - The AxisService
* @param disableREST only generate REST endpoint if this is false
* @param disableSOAP12 only generate SOAP 1.2 endpoint if this is false
* @return - The generated service element
* @throws AxisFault - Thrown in case an exception occurs
*/
public OMElement generateServiceElement(OMFactory omFactory, OMNamespace wsdl,
OMNamespace tns, AxisService axisService,
boolean disableREST, boolean disableSOAP12, boolean disableSOAP11,
String[] eprs, String serviceName)
throws AxisFault {
if(eprs == null){
eprs = axisService.getEPRs();
if (eprs == null) {
eprs = new String[]{serviceName};
}
}
OMElement serviceElement;
serviceElement = omFactory.createOMElement(WSDL2Constants.SERVICE_LOCAL_NAME, wsdl);
serviceElement.addAttribute(omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_NAME,
null, serviceName));
serviceElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.INTERFACE_LOCAL_NAME, null,
tns.getPrefix() + ":" + WSDL2Constants.DEFAULT_INTERFACE_NAME));
for (int i = 0; i < eprs.length; i++) {
String name = "";
String epr = eprs[i];
if (epr.startsWith("https://")) {
name = WSDL2Constants.DEFAULT_HTTPS_PREFIX;
}
OMElement soap11EndpointElement =
null;
if (!disableSOAP11) {
soap11EndpointElement = omFactory.createOMElement(WSDL2Constants.ENDPOINT_LOCAL_NAME, wsdl);
soap11EndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_NAME, null,
name + WSDL2Constants.DEFAULT_SOAP11_ENDPOINT_NAME));
soap11EndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.BINDING_LOCAL_NAME, null,
tns.getPrefix() + ":" + serviceName +
Java2WSDLConstants.BINDING_NAME_SUFFIX));
soap11EndpointElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_ADDRESS, null, epr));
serviceElement.addChild(modifyEndpoint(soap11EndpointElement));
}
OMElement soap12EndpointElement = null;
if (!disableSOAP12) {
soap12EndpointElement =
omFactory.createOMElement(WSDL2Constants.ENDPOINT_LOCAL_NAME, wsdl);
soap12EndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_NAME, null,
name + WSDL2Constants.DEFAULT_SOAP12_ENDPOINT_NAME));
soap12EndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.BINDING_LOCAL_NAME, null,
tns.getPrefix() + ":" + serviceName +
Java2WSDLConstants.SOAP12BINDING_NAME_SUFFIX));
soap12EndpointElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_ADDRESS, null, epr));
serviceElement.addChild(modifyEndpoint(soap12EndpointElement));
}
OMElement httpEndpointElement = null;
if (!disableREST) {
httpEndpointElement =
omFactory.createOMElement(WSDL2Constants.ENDPOINT_LOCAL_NAME, wsdl);
httpEndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.ATTRIBUTE_NAME, null,
name + WSDL2Constants.DEFAULT_HTTP_ENDPOINT_NAME));
httpEndpointElement.addAttribute(omFactory.createOMAttribute(
WSDL2Constants.BINDING_LOCAL_NAME, null,
tns.getPrefix() + ":" + serviceName + Java2WSDLConstants
.HTTP_BINDING));
httpEndpointElement.addAttribute(
omFactory.createOMAttribute(WSDL2Constants.ATTRIBUTE_ADDRESS, null, epr));
serviceElement.addChild(modifyEndpoint(httpEndpointElement));
}
if (epr.startsWith("https://")) {
if (!disableSOAP11) {
OMElement soap11Documentation = omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
soap11Documentation.setText("This endpoint exposes a SOAP 11 binding over a HTTPS");
soap11EndpointElement.addChild(soap11Documentation);
}
if (!disableSOAP12) {
OMElement soap12Documentation = omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
soap12Documentation.setText("This endpoint exposes a SOAP 12 binding over a HTTPS");
soap12EndpointElement.addChild(soap12Documentation);
}
if (!disableREST) {
OMElement httpDocumentation =
omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
httpDocumentation.setText("This endpoint exposes a HTTP binding over a HTTPS");
httpEndpointElement.addChild(httpDocumentation);
}
} else if (epr.startsWith("http://")) {
if (!disableSOAP11) {
OMElement soap11Documentation = omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
soap11Documentation.setText("This endpoint exposes a SOAP 11 binding over a HTTP");
soap11EndpointElement.addChild(soap11Documentation);
}
if (!disableSOAP12) {
OMElement soap12Documentation = omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
soap12Documentation.setText("This endpoint exposes a SOAP 12 binding over a HTTP");
soap12EndpointElement.addChild(soap12Documentation);
}
if (!disableREST) {
OMElement httpDocumentation =
omFactory.createOMElement(WSDL2Constants.DOCUMENTATION, wsdl);
httpDocumentation.setText("This endpoint exposes a HTTP binding over a HTTP");
httpEndpointElement.addChild(httpDocumentation);
}
}
}
return serviceElement;
}
}