/*
* 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.jaxws.description.impl;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.Constants.Configuration;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.deployment.util.Utils;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.AxisEndpoint;
import org.apache.axis2.description.AxisServiceGroup;
import org.apache.axis2.description.OutInAxisOperation;
import org.apache.axis2.description.OutOnlyAxisOperation;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.WSDL11ToAllAxisServicesBuilder;
import org.apache.axis2.description.WSDL11ToAxisServiceBuilder;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.catalog.JAXWSCatalogManager;
import org.apache.axis2.jaxws.common.config.WSDLValidatorElement;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.description.EndpointDescriptionJava;
import org.apache.axis2.jaxws.description.EndpointDescriptionWSDL;
import org.apache.axis2.jaxws.description.EndpointInterfaceDescription;
import org.apache.axis2.jaxws.description.ServiceDescription;
import org.apache.axis2.jaxws.description.ServiceDescriptionWSDL;
import org.apache.axis2.jaxws.description.builder.CustomAnnotationInstance;
import org.apache.axis2.jaxws.description.builder.CustomAnnotationProcessor;
import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite;
import org.apache.axis2.jaxws.description.builder.MDQConstants;
import org.apache.axis2.jaxws.description.builder.WsdlComposite;
import org.apache.axis2.jaxws.description.builder.JAXWSRIWSDLGenerator;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType;
import org.apache.axis2.jaxws.feature.ServerConfigurator;
import org.apache.axis2.jaxws.feature.ServerFramework;
import org.apache.axis2.jaxws.i18n.Messages;
import org.apache.axis2.jaxws.registry.ServerConfiguratorRegistry;
import org.apache.axis2.jaxws.util.CatalogURIResolver;
import org.apache.axis2.jaxws.util.WSDL4JWrapper;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.axis2.wsdl.util.WSDLDefinitionWrapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.jws.HandlerChain;
import javax.jws.WebService;
import javax.wsdl.Binding;
import javax.wsdl.Definition;
import javax.wsdl.Port;
import javax.wsdl.extensions.ExtensibilityElement;
import javax.wsdl.extensions.http.HTTPBinding;
import javax.wsdl.extensions.soap.SOAPAddress;
import javax.wsdl.extensions.soap12.SOAP12Address;
import javax.wsdl.extensions.soap12.SOAP12Binding;
import javax.xml.namespace.QName;
import javax.xml.ws.BindingType;
import javax.xml.ws.Service;
import javax.xml.ws.ServiceMode;
import javax.xml.ws.WebServiceProvider;
import javax.xml.ws.handler.PortInfo;
import javax.xml.ws.soap.MTOM;
import javax.xml.ws.soap.MTOMFeature;
import javax.xml.ws.soap.SOAPBinding;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.net.URL;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
/** @see ../EndpointDescription */
/*
* IMPORTANT NOTE: Axis2 currently only supports 1 service and 1 port under that service. When that is
* fixed, that will probably have an impact on this class. In particular, I think this should be created
* somehow from an AxisService/AxisPort combination, and not directly from the WSDL.
*/
public class EndpointDescriptionImpl
implements EndpointDescription, EndpointDescriptionJava, EndpointDescriptionWSDL {
private ServiceDescriptionImpl parentServiceDescription;
private AxisService axisService;
private AxisConfiguration axisConfig;
// In some environments some of the resources on an AxisService can lead to OOMs.
// However, releasing these resources can have other implications.
private boolean releaseAxisServiceResources = false;
private QName portQName;
private QName serviceQName;
// Corresponds to a port that was added dynamically via addPort and is not declared (either in WSDL or annotations)
private boolean isDynamicPort;
// If the WSDL is fully specified, we could build the AxisService from the WSDL
private boolean isAxisServiceBuiltFromWSDL;
private String serviceImplName; //class name of the service impl or SEI
// Note that an EndpointInterfaceDescription will ONLY be set for an Endpoint-based implementation;
// it will NOT be set for a Provider-based implementation
private EndpointInterfaceDescription endpointInterfaceDescription;
//On Client side, there should be One ServiceClient instance per AxisSerivce
private ServiceClient serviceClient = null;
//This is the base WebService or WebServiceProvider that we are processing
DescriptionBuilderComposite composite = null;
// Set of packages that are needed to marshal/unmashal data (used to set JAXBContext)
TreeSet<String> packages = null;
// The JAX-WS Handler port information corresponding to this endpoint
private PortInfo portInfo;
private String clientBindingID;
// The effective endpoint address. It could be set by the client or come from the WSDL SOAP address
private String endpointAddress;
// The endpoint address from the WSDL soap:address extensibility element if present.
private String wsdlSOAPAddress;
private static final Log log = LogFactory.getLog(EndpointDescriptionImpl.class);
// ===========================================
// ANNOTATION related information
// ===========================================
// ANNOTATION: @WebService and @WebServiceProvider
// Only one of these two annotations will be set; they are mutually exclusive
private WebService webServiceAnnotation;
private WebServiceProvider webServiceProviderAnnotation;
//ANNOTATION: @HandlerChain
private HandlerChain handlerChainAnnotation;
private HandlerChainsType handlerChainsType;
// Information common to both WebService and WebServiceProvider annotations
private String annotation_WsdlLocation;
private String annotation_ServiceName;
private String annotation_PortName;
private String annotation_TargetNamespace;
// Information only set on WebService annotation
// ANNOTATION: @WebService
private String webService_EndpointInterface;
private String webService_Name;
// ANNOTATION: @ServiceMode
// Note this is only valid on a Provider-based endpoint
private ServiceMode serviceModeAnnotation;
private Service.Mode serviceModeValue;
// Default ServiceMode.value per JAXWS Spec 7.1 "javax.xml.ServiceMode" pg 79
public static final javax.xml.ws.Service.Mode ServiceMode_DEFAULT =
javax.xml.ws.Service.Mode.PAYLOAD;
// ANNOTATION: @BindingType
private BindingType bindingTypeAnnotation;
private String bindingTypeValue;
// Default BindingType.value per JAXWS Spec Sec 7.8 "javax.xml.ws.BindingType" pg 83
// and Sec 1.4 "SOAP Transport and Transfer Bindings" pg 119
public static final String BindingType_DEFAULT =
javax.xml.ws.soap.SOAPBinding.SOAP11HTTP_BINDING;
// ANNOTATION: @RespectBinding
private Boolean respectBinding = false;
private Set<WSDLValidatorElement> requiredBindings = new HashSet<WSDLValidatorElement>();
private Integer portCompositeIndex = null;
private List<CustomAnnotationInstance> customAnnotations;
private Map<String, CustomAnnotationProcessor> customAnnotationProcessors;
// Supports WebServiceFeatureAnnotations
private ServerFramework framework = new ServerFramework();
private Map<String, Object> properties;
// Remembers if this endpoint description is MTOMEnabled
private Boolean isMTOMEnabledCache = null;
/**
* Create a service-requester side EndpointDescription based on the WSDL port.
* Note that per the JAX-WS Spec (Final
* Release, 4/19/2006 Section 4.2.3 Proxies, page 55)the "namespace component of the port is the
* target namespace of the WSDL definition document". Note this is currently only used on the
* client-side (this may change).
*
* @param theClass The SEI or Impl class. This will be NULL for Dispatch clients since they
* don't use an SEI
*/
EndpointDescriptionImpl(Class theClass, QName portName, ServiceDescriptionImpl parent) {
this(theClass, portName, parent, null, null);
}
EndpointDescriptionImpl(Class theClass, QName portName, ServiceDescriptionImpl parent,
DescriptionBuilderComposite dbc, Object compositeKey ) {
this(theClass, portName, false, parent, dbc, compositeKey);
}
EndpointDescriptionImpl(Class theClass, QName portName, boolean dynamicPort,
ServiceDescriptionImpl parent) {
this(theClass, portName, dynamicPort, parent, null, null);
}
EndpointDescriptionImpl(Class theClass, QName portName, boolean dynamicPort,
ServiceDescriptionImpl parent,
DescriptionBuilderComposite sparseComposite,
Object sparseCompositeKey) {
if (log.isDebugEnabled()) {
log.debug("entry ");
log.debug(" theClass=" + theClass);
log.debug(" portName= " + portName);
log.debug(" dynamicPort= " + dynamicPort);
log.debug(" parent=" + parent);
log.debug(" sparseComposite=" + DescriptionUtils.dumpString(sparseComposite));
}
this.axisConfig = parent.getAxisConfigContext().getAxisConfiguration();
this.parentServiceDescription = parent;
composite = new DescriptionBuilderComposite();
composite.setSparseComposite(sparseCompositeKey, sparseComposite);
composite.setCorrespondingClass(theClass);
ClassLoader loader = (ClassLoader) AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return this.getClass().getClassLoader();
}
}
);
composite.setClassLoader(loader);
composite.setIsServiceProvider(false);
webServiceAnnotation = composite.getWebServiceAnnot();
this.isDynamicPort = dynamicPort;
if (DescriptionUtils.isEmpty(portName)) {
// If the port name is null, then per JAX-WS 2.0 spec p. 55, the runtime is responsible for selecting the port.
this.portQName = selectPortToUse();
} else {
this.portQName = portName;
}
// At this point, there must be a port QName set, either as passed in, or determined from the WSDL and/or annotations.
// If not, that is an error.
if (this.portQName == null) {
String msg = Messages.getMessage("endpointDescriptionErr1",theClass.getName(),parent.getClass().getName());
throw ExceptionFactory.makeWebServiceException(msg);
}
setupAxisService(sparseCompositeKey);
addToAxisService();
setupReleaseResources(getServiceDescription().getAxisConfigContext());
buildDescriptionHierachy();
addAnonymousAxisOperations();
// This will set the serviceClient field after adding the AxisService to the AxisConfig
getServiceClient();
// Give the configuration builder a chance to finalize configuration for this service
try {
getServiceDescriptionImpl().getClientConfigurationFactory()
.completeAxis2Configuration(axisService);
} catch (Exception e) {
String msg = Messages.getMessage("endpointDescriptionErr2",e.getClass().getName(),parent.getClass().getName());
throw ExceptionFactory.makeWebServiceException(msg, e);
} finally {
releaseAxisServiceResources();
}
if (log.isDebugEnabled()) {
log.debug("exit");
}
}
private void setupReleaseResources(ConfigurationContext configurationContext) {
if (configurationContext != null) {
AxisConfiguration axisConfiguration = configurationContext.getAxisConfiguration();
if (axisConfiguration != null) {
Parameter param =
axisConfiguration.getParameter(Constants.Configuration.REDUCE_WSDL_MEMORY_CACHE);
if (param != null) {
releaseAxisServiceResources = ((String) param.getValue()).equalsIgnoreCase("true");
if (log.isDebugEnabled()) {
log.debug("EndpointDescription configured to release AxisService resources via "
+ Constants.Configuration.REDUCE_WSDL_MEMORY_CACHE);
}
}
}
}
else if(composite != null) {
Boolean reduceCache = (Boolean) composite.getProperties().get(Constants.Configuration.REDUCE_WSDL_MEMORY_CACHE);
if(reduceCache != null) {
if(log.isDebugEnabled()) {
log.debug("Retrieved the following reduce WSDL cache value: " + reduceCache +
" from the composite: " + composite.getClassName());
}
releaseAxisServiceResources = reduceCache;
}
}
}
EndpointDescriptionImpl(ServiceDescriptionImpl parent, String serviceImplName) {
this(parent, serviceImplName, null, null);
}
/**
* Create a service-provider side EndpointDescription based on the DescriptionBuilderComposite.
* Note that per the
* JAX-WS Spec (Final Release, 4/19/2006 Section 4.2.3 Proxies, page 55)the "namespace component
* of the port is the target namespace of the WSDL definition document".
*
* @param theClass The SEI or Impl class. This will be NULL for Dispatch clients since they
* don't use an SEI
*/
EndpointDescriptionImpl(ServiceDescriptionImpl parent, String serviceImplName, Map<String, Object>
properties, Integer portCompositeIndex) {
if (log.isDebugEnabled()) {
log.debug("entry EndpointDescriptionImpl(ServiceDescriptionImpl, String, Map<String, Object>, Integer)");
log.debug(" parent=" + parent);
log.debug(" serviceImplName=" + parent);
log.debug(" portCompositeIndex=" + portCompositeIndex);
}
this.axisConfig = parent.getAxisConfigContext().getAxisConfiguration();
// initialize CustomAnnotationIntance list and CustomAnnotationProcessor map
customAnnotations = new ArrayList<CustomAnnotationInstance>();
customAnnotationProcessors = new HashMap<String, CustomAnnotationProcessor>();
this.portCompositeIndex = portCompositeIndex;
// set properties map
this.properties = properties;
this.parentServiceDescription = parent;
this.serviceImplName = serviceImplName;
// if the ServiceDescription's service QName is specified, let's use that to get the
// correct DescriptionBuilderComposite
if(parent.getServiceQName() != null) {
composite = getServiceDescriptionImpl().getDescriptionBuilderComposite(parent.getServiceQName(),
portCompositeIndex);
}
// otherwise we will get the DescriptionBuilderComposite by the current index
else {
composite = getServiceDescriptionImpl().getDescriptionBuilderComposite(null,
portCompositeIndex);
}
if (composite == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("endpointDescriptionErr3"));
}
if(composite.getHandlerChainAnnot() != null && composite.getHandlerChainsType() != null) {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("handlerSourceFail", composite.getClassName()));
}
handlerChainsType = composite.getHandlerChainsType();
//Set the base level of annotation that we are processing...currently
// a 'WebService' or a 'WebServiceProvider'
if (composite.getWebServiceAnnot() != null)
webServiceAnnotation = composite.getWebServiceAnnot();
else
webServiceProviderAnnotation = composite.getWebServiceProviderAnnot();
// now get the custom annotation and process information from the DBC
customAnnotations.addAll(composite.getCustomAnnotationInstances());
customAnnotationProcessors.putAll(composite.getCustomAnnotationProcessors());
// Note that on the client side, the service QN should be set; on the server side it will not be.
if (DescriptionUtils.isEmpty(getServiceDescription().getServiceQName())) {
getServiceDescriptionImpl().setServiceQName(getServiceQName());
}
//Call the getter to insure the qualified port name is set.
getPortQName();
setupAxisServiceFromDBL();
addToAxisService(); //Add a reference to this EndpointDescription to the AxisService
buildDescriptionHierachy();
WsdlComposite wsdlComposite = null;
String bindingType = getBindingType();
boolean isSOAP11 =
(bindingType.equals(javax.xml.ws.soap.SOAPBinding.SOAP11HTTP_BINDING) ||
bindingType.equals(javax.xml.ws.soap.SOAPBinding.SOAP11HTTP_MTOM_BINDING))
? true : false;
// Determine if we need to generate WSDL
// First, make sure that this is only a SOAP 1.1 based binding, per JAXWS spec. we cannot
// generate WSDL if the binding type is not SOAP 1.1 based.
// Then, assuming the composite does not contain a
// Wsdl Definition, go ahead and generate it
if (isSOAP11){
if (
(isEndpointBased() &&
DescriptionUtils.isEmpty(getAnnoWebServiceEndpointInterface()))
||
(!isEndpointBased())
) {
//This is either an implicit SEI, or a WebService Provider
wsdlComposite = generateWSDL(composite);
} else if (isEndpointBased()) {
//This impl class specifies an SEI...this is a special case. There is a bug
//in the tooling that allows for the wsdllocation to be specifed on either the
//impl. class, or the SEI, or both. So, we need to look for the wsdl as follows:
// 1. If the Wsdl exists on the SEI, then check for it on the impl.
// 2. If it is not found in either location, in that order, then generate
DescriptionBuilderComposite seic =
getServiceDescriptionImpl().getDBCMap()
.get(composite.getWebServiceAnnot().endpointInterface());
//Only generate WSDL if a definition doesn't already exist
if (seic.getWsdlDefinition() == null)
wsdlComposite = generateWSDL(composite);
}
} else if (composite.getWsdlDefinition() == null) {
//This is a SOAP12 binding that does not contain a WSDL definition, log a WARNING
log.warn(Messages.getMessage("generateWSDLNonSoap11", composite.getClassName()));
}
if (isSOAP11){
//Save the WSDL Location and the WsdlDefinition, value depends on whether wsdl was generated
Parameter wsdlLocationParameter = new Parameter();
wsdlLocationParameter.setName(MDQConstants.WSDL_LOCATION);
Parameter wsdlDefParameter = new Parameter();
wsdlDefParameter.setName(MDQConstants.WSDL_DEFINITION);
Parameter wsdlCompositeParameter = new Parameter();
wsdlCompositeParameter.setName(MDQConstants.WSDL_COMPOSITE);
if (wsdlComposite != null) {
//We have a wsdl composite, so set these values for the generated wsdl
wsdlCompositeParameter.setValue(wsdlComposite);
wsdlLocationParameter.setValue(wsdlComposite.getWsdlFileName());
Definition def =
getServiceDescriptionImpl().getGeneratedWsdlWrapper().getDefinition();
URL wsdlUrl = getServiceDescriptionImpl().getGeneratedWsdlWrapper().getWSDLLocation();
if (def instanceof WSDLDefinitionWrapper) {
wsdlDefParameter.setValue(def);
} else {
// Create WSDLDefinitionWrapper
WSDLDefinitionWrapper wrap = null;
ConfigurationContext cc = composite.getConfigurationContext();
if (cc != null && cc.getAxisConfiguration() != null) {
wrap = new WSDLDefinitionWrapper(def, wsdlUrl,
cc.getAxisConfiguration());
} else {
// Probably shouldn't get here. But if we do, use
// a memory sensitve wsdl wrapper
wrap = new WSDLDefinitionWrapper(def, wsdlUrl, true, 2);
}
wsdlDefParameter.setValue(wrap);
}
} else if (getServiceDescriptionImpl().getWSDLWrapper() != null) {
//No wsdl composite because wsdl already exists
wsdlLocationParameter.setValue(getAnnoWebServiceWSDLLocation());
Definition def = getServiceDescriptionImpl().getWSDLWrapper().getDefinition();
URL wsdlUrl = getServiceDescriptionImpl().getWSDLWrapper().getWSDLLocation();
if (def instanceof WSDLDefinitionWrapper) {
wsdlDefParameter.setValue(def);
} else {
// Create WSDLDefinitionWrapper
WSDLDefinitionWrapper wrap = null;
ConfigurationContext cc = composite.getConfigurationContext();
if (cc != null && cc.getAxisConfiguration() != null) {
wrap = new WSDLDefinitionWrapper(def, wsdlUrl,
cc.getAxisConfiguration());
} else {
// Probably shouldn't get here. But if we do, use
// a memory sensitve wsdl wrapper
wrap = new WSDLDefinitionWrapper(def, wsdlUrl, true, 2);
}
wsdlDefParameter.setValue(wrap);
}
} else {
//There is no wsdl composite and there is NOT a wsdl definition
wsdlLocationParameter.setValue(null);
wsdlDefParameter.setValue(null);
}
try {
if (wsdlComposite != null) {
axisService.addParameter(wsdlCompositeParameter);
}
axisService.addParameter(wsdlDefParameter);
axisService.addParameter(wsdlLocationParameter);
} catch (Exception e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("endpointDescriptionErr4"));
}
}
else {
// Need to account for SOAP 1.2 WSDL when supplied with application
Parameter wsdlDefParameter = new Parameter();
wsdlDefParameter.setName(MDQConstants.WSDL_DEFINITION);
Parameter wsdlLocationParameter = new Parameter();
wsdlLocationParameter.setName(MDQConstants.WSDL_LOCATION);
if (getServiceDescriptionImpl().getWSDLWrapper() != null) {
wsdlLocationParameter.setValue(getAnnoWebServiceWSDLLocation());
Definition def = getServiceDescriptionImpl().getWSDLWrapper().getDefinition();
URL wsdlUrl = getServiceDescriptionImpl().getWSDLWrapper().getWSDLLocation();
if (def instanceof WSDLDefinitionWrapper) {
wsdlDefParameter.setValue(def);
} else {
// Create WSDLDefinitionWrapper
WSDLDefinitionWrapper wrap = null;
ConfigurationContext cc = composite.getConfigurationContext();
if (cc != null && cc.getAxisConfiguration() != null) {
wrap = new WSDLDefinitionWrapper(def, wsdlUrl,
cc.getAxisConfiguration());
} else {
// Probably shouldn't get here. But if we do, use
// a memory sensitve wsdl wrapper
wrap = new WSDLDefinitionWrapper(def, wsdlUrl, true, 2);
}
wsdlDefParameter.setValue(wrap);
}
}
// No WSDL supplied and we do not generate for non-SOAP 1.1/HTTP
// endpoints
else {
wsdlLocationParameter.setValue(null);
wsdlDefParameter.setValue(null);
}
try {
axisService.addParameter(wsdlDefParameter);
axisService.addParameter(wsdlLocationParameter);
} catch (Exception e) {
throw ExceptionFactory
.makeWebServiceException(Messages.getMessage("endpointDescriptionErr4"),e);
}
}
// Before we leave we need to drive the CustomAnnotationProcessors if
// there were any CustomAnnotationInstance objects registered
Iterator<CustomAnnotationInstance> annotationIter = customAnnotations.iterator();
while(annotationIter.hasNext()) {
CustomAnnotationInstance annotation = annotationIter.next();
if(log.isDebugEnabled()) {
log.debug("Checking for CustomAnnotationProcessor for CustomAnnotationInstance " +
"class: " + annotation.getClass().getName());
}
CustomAnnotationProcessor processor = customAnnotationProcessors.get(annotation.getClass().getName());
if(processor != null) {
if(log.isDebugEnabled()) {
log.debug("Found CustomAnnotationProcessor: " + processor.getClass().getName() +
" for CustomAnnotationInstance: " + annotation.getClass().getName());
}
processor.processTypeLevelAnnotation(this, annotation);
}
}
// Configure any available WebServiceFeatures on the endpoint.
configureWebServiceFeatures();
// REVIEW: there are some throws above that won't cause the release
setupReleaseResources(composite.getConfigurationContext());
releaseAxisServiceResources();
if (log.isDebugEnabled()) {
log.debug("exit EndpointDescriptionImpl(ServiceDescriptionImpl, String, Map<String, Object>, Integer)");
}
}
private void addToAxisService() {
// Add a reference to this EndpointDescription object to the AxisService
if (axisService != null) {
Parameter parameter = new Parameter();
parameter.setName(EndpointDescription.AXIS_SERVICE_PARAMETER);
parameter.setValue(this);
try {
axisService.addParameter(parameter);
} catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("endpointDescriptionErr5", EndpointDescription.AXIS_SERVICE_PARAMETER), e);
}
}
}
private void buildEndpointDescriptionFromAnnotations() {
// TODO: The comments below are not quite correct; this method is used on BOTH the
// client and server. On the client the class is always an SEI. On the server it
// is always a service impl which may be a provider or endpoint based;
// endpoint based may reference an SEI class
// The Service Implementation class could be either Provider-based or Endpoint-based. The
// annotations that are present are similar but different. Conformance requirements
// per JAX-WS
// - A Provider based implementation MUST carry the @WebServiceProvider annotation
// per section 5.1 javax.xml.ws.Provider on page 63
// - An Endpoint based implementation MUST carry the @WebService annotation per JSR-181
// (reference TBD) and JAX-WS (reference TBD)
// - An Endpoint based implementation @WebService annotation MAY reference an endpoint
// interface
// - The @WebService and @WebServiceProvider annotations can not appear in the same class per
// JAX-WS section 7.7 on page 82.
// If portName was specified, set it. Otherwise, we will get it from the appropriate
// annotation when the getter is called.
// If this is an Endpoint-based service implementation (i.e. not a
// Provider-based one), then create the EndpointInterfaceDescription to contain
// the operations on the endpoint. Provider-based endpoints don't have operations
// associated with them, so they don't have an EndpointInterfaceDescription.
if (webServiceAnnotation != null) {
// If this impl class references an SEI, then use that SEI to create the EndpointInterfaceDesc.
String seiClassName = getAnnoWebServiceEndpointInterface();
if (!composite.isServiceProvider()) {
Class seiClass = null;
if (DescriptionUtils.isEmpty(seiClassName)) {
// This is the client code path; the @WebServce will not have an endpointInterface member
// For now, just build the EndpointInterfaceDesc based on the class itself.
seiClass = composite.getCorrespondingClass();
}
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(seiClass, this);
} else {
if (DescriptionUtils.isEmpty(getAnnoWebServiceEndpointInterface())) {
endpointInterfaceDescription =
new EndpointInterfaceDescriptionImpl(composite, true, this);
} else {
//Otherwise, build the EID based on the SEI composite
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(
getServiceDescriptionImpl().getDBCMap().get(seiClassName),
false,
this);
// after this is constructed, we need to update the @WebService.name
// attribute on the axisService instance
if(axisService != null) {
updateWebServiceNameParameter(((EndpointInterfaceDescriptionImpl)
endpointInterfaceDescription).getAnnoWebServiceName(), axisService);
}
}
}
} else {
if (log.isDebugEnabled()) {
log.debug("WebServiceProvider without WSDL encountered");
}
String bindingType = getBindingType();
if (javax.xml.ws.http.HTTPBinding.HTTP_BINDING.equals(bindingType)||
SOAPBinding.SOAP11HTTP_BINDING.equals(bindingType)||
SOAPBinding.SOAP12HTTP_BINDING.equals(bindingType)||
MDQConstants.SOAP_HTTP_BINDING.equals(bindingType)) {
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(composite, this);
}
}
}
public QName getPortQName() {
if (portQName == null) {
// The name was not set by the constructors, so get it from the
// appropriate annotation.
String name = getAnnoWebServicePortName();
String tns = getAnnoWebServiceTargetNamespace();
portQName = new QName(tns, name);
}
return portQName;
}
public QName getServiceQName() {
if (serviceQName == null) {
// If the service name has been set on the Service, use that. Otherwise
// get the name off the annotations
QName serviceDescQName = getServiceDescription().getServiceQName();
if (!DescriptionUtils.isEmpty(serviceDescQName)) {
serviceQName = serviceDescQName;
} else {
String localPart = getAnnoWebServiceServiceName();
String tns = getAnnoWebServiceTargetNamespace();
serviceQName = new QName(tns, localPart);
}
}
return serviceQName;
}
public ServiceDescription getServiceDescription() {
return parentServiceDescription;
}
public ServiceDescriptionImpl getServiceDescriptionImpl() {
return (ServiceDescriptionImpl)parentServiceDescription;
}
public EndpointInterfaceDescription getEndpointInterfaceDescription() {
return endpointInterfaceDescription;
}
public AxisService getAxisService() {
return axisService;
}
boolean isDynamicPort() {
return isDynamicPort;
}
void updateWithSEI(Class sei, DescriptionBuilderComposite sparseComposite, Object sparseCompositeKey) {
// Updating with an SEI is only valid for declared ports; it is not valid for dynamic ports.
if (isDynamicPort()) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("updateWithSEIErr1",portQName.toString()));
}
if (sei == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("updateWithSEIErr2",portQName.toString()));
}
composite.setSparseComposite(sparseCompositeKey, sparseComposite);
if (endpointInterfaceDescription != null) {
// The EndpointInterfaceDescription was created previously based on the port declaration (i.e. WSDL)
// so update that with information from the SEI annotations
((EndpointInterfaceDescriptionImpl)endpointInterfaceDescription).updateWithSEI(sei);
} else {
// An EndpointInterfaceDescription does not exist yet. This currently happens in the case where there is
// NO WSDL provided and a Dispatch client is created for prior to a getPort being done for that port.
// There was no WSDL to create the EndpointInterfaceDescription from and there was no annotated SEI to
// use at that time. Now we have an annotated SEI, so create the EndpointInterfaceDescription now.
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(sei, this);
}
return;
}
private void setupAxisService(Object sparseCompositeKey) {
// Build up the AxisService. Note that if this is a dynamic port, then we don't use the
// WSDL to build up the AxisService since the port added to the Service by the client is not
// one that will be present in the WSDL. A null class passed in as the SEI indicates this
// is a dispatch client.
if (!isDynamicPort && getServiceDescriptionImpl().getWSDLWrapper() != null) {
isAxisServiceBuiltFromWSDL = buildAxisServiceFromWSDL();
} else {
if (useGeneratedWSDL()) {
buildAxisServiceFromGeneratedWSDL();
} else {
buildAxisServiceFromAnnotations();
addAnnotationParamToService();
}
}
if (axisService == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("setupAxisServiceErr1",createAxisServiceName()));
}
// Save the Service QName as a parameter.
Parameter serviceNameParameter = new Parameter();
serviceNameParameter.setName(WSDL11ToAllAxisServicesBuilder.WSDL_SERVICE_QNAME);
serviceNameParameter.setValue(getServiceDescription().getServiceQName());
// Save the Port name. Note: Axis does not expect a QName since the namespace for the port is the ns from the WSDL definition
Parameter portParameter = new Parameter();
portParameter.setName(WSDL11ToAllAxisServicesBuilder.WSDL_PORT);
portParameter.setValue(portQName.getLocalPart());
// Store the service class fully qualified name
Parameter serviceClassNameParam = new Parameter();
serviceClassNameParam.setName(MDQConstants.CLIENT_SERVICE_CLASS);
String serviceClassName = this.getServiceDescriptionImpl().getServiceClassName();
if(log.isDebugEnabled()) {
log.debug("Setting service class name parameter to: " + serviceClassName +
" on AxisService: " + axisService + "@" + axisService.hashCode());
}
serviceClassNameParam.setValue(serviceClassName);
// Store the sei class fully qualified name, if it is available
Parameter seiClassNameParam = new Parameter();
seiClassNameParam.setName(MDQConstants.CLIENT_SEI_CLASS);
String seiClassName = composite.getClassName();
if(log.isDebugEnabled()) {
log.debug("Setting sei class name parameter to: " + seiClassName +
" on AxisService: " + axisService + "@" + axisService.hashCode());
}
seiClassNameParam.setValue(seiClassName);
// If a ServiceRef Name was set on the sparse composite for the service, then store that
Parameter serviceRefNameParam = getServiceRefNameParam(sparseCompositeKey);
try {
axisService.addParameter(serviceNameParameter);
axisService.addParameter(portParameter);
axisService.addParameter(serviceClassNameParam);
axisService.addParameter(seiClassNameParam);
if (serviceRefNameParam != null) {
axisService.addParameter(serviceRefNameParam);
}
}
catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("setupAxisServiceErr2"),e);
}
}
/**
* Return a Parameter instance for ServiceRefName if that name was specified on the sparse composite when the Service was created.
* @param sparseCompositeKey identifies the instance of the service (i.e. Service Delegate)
* @return A Parameter containing the ServiceRefName or null if one was not specified.
*/
private Parameter getServiceRefNameParam(Object sparseCompositeKey) {
Parameter serviceRefNameParam = null;
// The ServiceRefName, if specified, is set on the sparse composite associated with the service.
String serviceRefName = getServiceDescriptionImpl().getDescriptionBuilderComposite().getServiceRefName(sparseCompositeKey);
if (!DescriptionUtils.isEmpty(serviceRefName)) {
if (log.isDebugEnabled()) {
log.debug("Setting service ref name: " + serviceRefName
+ " on AxisService: " + axisService + "@" + axisService.hashCode());
}
serviceRefNameParam = new Parameter();
serviceRefNameParam.setName(MDQConstants.SERVICE_REF_NAME);
serviceRefNameParam.setValue(serviceRefName);
}
return serviceRefNameParam;
}
/*
* This setups and builds the AxisService using only the DescriptionBuilderCompositeList
*
*/
private void setupAxisServiceFromDBL() {
// Build up the AxisService. Note that if this is a dispatch client, then we don't use the
// WSDL to build up the AxisService since the port added to the Service by the client is not
// one that will be present in the WSDL. A null class passed in as the SEI indicates this
// is a dispatch client.
// If WSDL is present, it may be full or only partial. If we can create the AxisService from
// the WSDL, that WSDL is fully specified. Otherwise, it is "partial WSDL". In that case
// we use annotaions to build the AxisService
isAxisServiceBuiltFromWSDL = false;
if (getServiceDescriptionImpl().getWSDLWrapper() != null) {
isAxisServiceBuiltFromWSDL = buildAxisServiceFromWSDL();
}
if (!isAxisServiceBuiltFromWSDL) {
//generateWSDL(composite);
if (useGeneratedWSDL()) {
buildAxisServiceFromGeneratedWSDL();
} else {
buildAxisServiceFromAnnotations();
addAnnotationParamToService();
}
}
if (axisService == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("setupAxisServiceErr1",createAxisServiceName()));
}
//Save the Port Type name
Parameter portTypeNameParameter = new Parameter();
portTypeNameParameter.setName(MDQConstants.WSDL_PORTTYPE_NAME);
portTypeNameParameter.setValue(getName());
// Save the Service QName as a parameter.
Parameter serviceNameParameter = new Parameter();
serviceNameParameter.setName(MDQConstants.WSDL_SERVICE_QNAME);
serviceNameParameter.setValue(getServiceDescription().getServiceQName());
// Save the Port name. Note: Axis does not expect a QName since the namespace
// for the port is the ns from the WSDL definition
Parameter portParameter = new Parameter();
portParameter.setName(MDQConstants.WSDL_PORT);
portParameter.setValue(getPortQName().getLocalPart());
//Save the fully qualified class name for the serviceImpl
Parameter serviceClassNameParameter = new Parameter();
serviceClassNameParameter.setName(MDQConstants.SERVICE_CLASS);
serviceClassNameParameter
.setValue(DescriptionUtils.javifyClassName(composite.getClassName()));
try {
axisService.addParameter(portTypeNameParameter);
axisService.addParameter(serviceNameParameter);
axisService.addParameter(portParameter);
axisService.addParameter(serviceClassNameParameter);
}
catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("setupAxisServiceErr2"),e);
}
}
private boolean buildAxisServiceFromWSDL() {
if (log.isDebugEnabled()) {
log.debug("entry");
}
boolean isBuiltFromWSDL = false;
try {
// Note that the axis service builder takes only the localpart of the port qname.
// TODO:: This should check that the namespace of the definition matches the namespace of the portQName per JAXRPC spec
// Use getDefinition() so that we have the advantages of the memory features.
Definition def = getServiceDescriptionImpl().getWSDLWrapper().getDefinition();
WSDL11ToAxisServiceBuilder serviceBuilder =
new WSDL11ToAxisServiceBuilder(def,
getServiceDescription().getServiceQName(),
getPortQName().getLocalPart());
if (log.isDebugEnabled()) {
log.debug("Building AxisService from wsdl: " + getServiceDescriptionImpl().getWSDLWrapper().getWSDLLocation());
log.debug("Build Axis Service from WSDL ");
log.debug(" Service QName =" + getServiceDescription().getServiceQName());
log.debug(" Port QName = " + getPortQName());
log.debug(" WSDL = " + def.toString());
}
ClassLoader classLoader;
if (composite.isServiceProvider()) {
classLoader = composite.getClassLoader();
} else {
classLoader = getContextClassLoader(null);
}
JAXWSCatalogManager catalogManager = getServiceDescriptionImpl().getCatalogManager();
CatalogURIResolver uriResolver = new CatalogURIResolver(catalogManager, classLoader);
serviceBuilder.setCustomResolver(uriResolver);
if (getServiceDescriptionImpl().isServerSide())
serviceBuilder.setServerSide(true);
else
serviceBuilder.setServerSide(false);
// Associate the AxisConfiguration with the ServiceBuilder if it
// is available. This is done so that the serviceBuilder can
// use the appropriate WSDL wrapper memory parameters.
AxisConfiguration ac = null;
if (composite.getConfigurationContext() != null) {
ac = composite.getConfigurationContext().getAxisConfiguration();
if (ac != null) {
serviceBuilder.useAxisConfiguration(ac);
}
}
// Create and populate the AxisService
axisService = serviceBuilder.populateService();
// If an AxisConfiguration was not available,
// default to using a memory efficient wrapper
if (ac == null) {
Parameter wsdlWrapperParam =
axisService.getParameter(WSDLConstants.WSDL_4_J_DEFINITION);
if (wsdlWrapperParam != null &&
wsdlWrapperParam.getValue() instanceof WSDLDefinitionWrapper) {
WSDLDefinitionWrapper wrapper =
(WSDLDefinitionWrapper) wsdlWrapperParam.getValue();
// If only the basic wrapper is being used, upgrade to the
// RELOAD wrapper
if (wrapper.getMemoryLimitType() == 0) {
Definition wsdlDef = wrapper.getUnwrappedDefinition();
WSDLDefinitionWrapper wrapper2 =
new WSDLDefinitionWrapper(wsdlDef, true, 2);
wsdlWrapperParam.setValue(wrapper2);
}
}
}
axisService.setName(createAxisServiceName());
isBuiltFromWSDL = true;
} catch (AxisFault e) {
String wsdlLocation = (getServiceDescriptionImpl().getWSDLLocation() != null) ?
getServiceDescriptionImpl().getWSDLLocation().toString() : null;
String implClassName = composite.getClassName();
log.warn(Messages.getMessage("bldAxisSrvcFromWSDLErr", implClassName, wsdlLocation, e.getMessage()));
if (log.isDebugEnabled()) {
log.debug("Exception processing WSDL file. Impl class: " + implClassName + "; WSDL Location: "+ wsdlLocation, e);
}
isBuiltFromWSDL = false;
}
if (log.isDebugEnabled()) {
log.debug("exit isBuiltFromWSDL = " + isBuiltFromWSDL);
}
return isBuiltFromWSDL;
}
/**
* If a WSDL is not already found, this method can be used to generate a WSDL and create
* the AxisService using that WSDL
*/
private void buildAxisServiceFromGeneratedWSDL() {
/**
* First we create a dummy axis service to get the information for WSDL generation.
* When the new axis service is created from the WSDL, this one is overidden by the
* new service.
*/
buildAxisServiceFromAnnotations();
//Save the fully qualified class name for the serviceImpl
Parameter serviceClassNameParameter = new Parameter();
serviceClassNameParameter.setName(MDQConstants.SERVICE_CLASS);
serviceClassNameParameter
.setValue(DescriptionUtils.javifyClassName(composite.getClassName()));
try {
this.axisService.addParameter(serviceClassNameParameter);
} catch (AxisFault axisFault) {
throw ExceptionFactory.makeWebServiceException(Messages
.getMessage("setupAxisServiceErr2"), axisFault);
}
addToAxisService();
JAXWSRIWSDLGenerator wsdlGenerator =
new JAXWSRIWSDLGenerator(this.axisService, this.axisConfig);
try {
//generate the wsdl
Definition def = wsdlGenerator.getWSDL(axisService);
//create the new axis service from the generated wsdl
WSDL11ToAxisServiceBuilder axisServiceBuilder = new WSDL11ToAxisServiceBuilder(def,
getServiceDescription().getServiceQName(), getPortQName().getLocalPart());
if (getServiceDescriptionImpl().isServerSide()) {
axisServiceBuilder.setServerSide(true);
} else {
axisServiceBuilder.setServerSide(false);
}
this.axisService = axisServiceBuilder.populateService();
axisService.setName(getServiceDescription().getServiceQName().getLocalPart());
axisService.setParent(axisConfig);
// we always get only one endpoint as there's only one port in the generated WSDL
// from wsgen. Set the transport for that endpoint as http by default.
for (AxisEndpoint axisEndpoint : axisService.getEndpoints().values()) {
axisEndpoint.setTransportInDescription("http");
axisEndpoint.setEndpointURL(null);
}
} catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(Messages
.getMessage("setupAxisServiceErr3"),e);
}
}
/**
* Reads the property in axis config (comes from axis2.xml) and decides whether we have to
* build the AxisService using a generated WSDL.
* @return true if param true
*/
private boolean useGeneratedWSDL(){
Parameter param = this.axisConfig.getParameter(MDQConstants.USE_GENERATED_WSDL);
return param != null && "true".equals(param.getValue());
}
private void addAnnotationParamToService() {
//Add a parameter to identify that this AxisService is created only using annotations
try {
axisService.addParameter(MDQConstants.USED_ANNOTATIONS_ONLY, "true");
} catch (AxisFault axisFault) {
throw ExceptionFactory.makeWebServiceException(Messages
.getMessage("setupAxisServiceErr2"), axisFault);
}
}
private void buildAxisServiceFromAnnotations() {
String serviceName = null;
if (portQName != null) {
serviceName = createAxisServiceName();
} else {
// Make this service name unique. The Axis2 engine assumes that a service it can not find is a client-side service.
serviceName = ServiceClient.ANON_SERVICE + this.hashCode() + System.currentTimeMillis();
}
axisService = new AxisService(serviceName);
// Now we have to add an Endpoint to the AxisService instance according to the generated
// WSDL. Binding type can be SOAP 1.1, SOAP 1.2 or HTTP. Always we have to use the
// annotated port name as the endpoint name.
try {
String bindingType = getBindingType();
// Default transport protocol is set to HTTP
String protocol = "http";
if (bindingType.startsWith(SOAPBinding.SOAP12HTTP_BINDING)) {
Utils.addSoap12Endpoint(axisService, protocol, getPortQName().getLocalPart());
} else if (bindingType.startsWith(javax.xml.ws.http.HTTPBinding.HTTP_BINDING)) {
Utils.addHttpEndpoint(axisService, protocol, getPortQName().getLocalPart());
} else {
// Assume SOAP 1.1 over HTTP for all other cases
Utils.addSoap11Endpoint(axisService, protocol, getPortQName().getLocalPart());
}
} catch (Exception e) {
log.error("Error while generating the Endpoint for service :" + axisService.getName());
}
}
private void releaseAxisServiceResources() {
// release the schema list in the AxisService
if (releaseAxisServiceResources && axisService != null) {
axisService.releaseSchemaList();
}
}
private void buildDescriptionHierachy() {
// Build up the Description Hierachy. Note that if this is a dynamic port, then we don't use the
// WSDL to build up the hierachy since the port added to the Service by the client is not
// one that will be present in the WSDL.
if (composite.isServiceProvider()) {
if (!isDynamicPort && isWSDLFullySpecified())
buildEndpointDescriptionFromWSDL();
else
buildEndpointDescriptionFromAnnotations();
} else {
//Still processing annotations from the class
// This path was not updated
if (!isDynamicPort && isWSDLFullySpecified()) {
buildEndpointDescriptionFromWSDL();
} else if (composite.getCorrespondingClass() != null) {
// Create the rest of the description hierachy from annotations on the class.
// If there is no SEI class, then this is a Distpach case, and we currently
// don't create the rest of the description hierachy (since it is not an SEI and thus
// not operation-based client.
buildEndpointDescriptionFromAnnotations();
}
}
}
private void buildEndpointDescriptionFromWSDL() {
Definition wsdlDefinition = getServiceDescriptionImpl().getWSDLWrapper().getDefinition();
javax.wsdl.Service wsdlService =
wsdlDefinition.getService(getServiceDescription().getServiceQName());
if (wsdlService == null) {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("serviceDescErr2", createAxisServiceName()));
}
Map wsdlPorts = wsdlService.getPorts();
boolean wsdlPortFound = false;
if (wsdlPorts != null && wsdlPorts.size() > 0) {
Iterator wsdlPortIterator = wsdlPorts.values().iterator();
while (wsdlPortIterator.hasNext() && !wsdlPortFound) {
Port wsdlPort = (Port)wsdlPortIterator.next();
// Note the namespace is not included on the WSDL Port.
if (wsdlPort.getName().equals(portQName.getLocalPart())) {
// Build the EndpointInterface based on the specified SEI if there is one
// or on the service impl class (i.e. an implicit SEI).
if (composite.isServiceProvider()) {
String seiClassName = getAnnoWebServiceEndpointInterface();
if (DescriptionUtils.isEmpty(seiClassName)) {
// No SEI specified, so use the service impl as an implicit SEI
endpointInterfaceDescription =
new EndpointInterfaceDescriptionImpl(composite, true, this);
} else {
// Otherwise, build the EID based on the SEI composite
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(
getServiceDescriptionImpl().getDBCMap().get(seiClassName),
false,
this);
// after this is constructed, we need to update the @WebService.name
// attribute on the axisService instance
if(axisService != null) {
updateWebServiceNameParameter(((EndpointInterfaceDescriptionImpl)
endpointInterfaceDescription).getAnnoWebServiceName(), axisService);
}
}
} else {
// Create the Endpoint Interface Description based on the WSDL.
endpointInterfaceDescription = new EndpointInterfaceDescriptionImpl(this);
// Update the EndpointInterfaceDescription created with WSDL with information from the
// annotations in the SEI
((EndpointInterfaceDescriptionImpl)endpointInterfaceDescription)
.updateWithSEI(composite.getCorrespondingClass());
}
wsdlPortFound = true;
}
}
}
if (!wsdlPortFound) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("serviceDescErr3",portQName.getLocalPart()));
}
}
/**
* Adds the anonymous axis operations to the AxisService. Note that this is only needed on the
* client side, and they are currently used in two cases (1) For Dispatch clients (which don't
* use SEIs and thus don't use operations) (2) TEMPORARLIY for Services created without WSDL
* (and thus which have no AxisOperations created) See the AxisInvocationController invoke
* methods for more details.
* <p/>
* Based on ServiceClient.createAnonymouService
*/
private void addAnonymousAxisOperations() {
if (axisService != null) {
OutOnlyAxisOperation outOnlyOperation =
new OutOnlyAxisOperation(ServiceClient.ANON_OUT_ONLY_OP);
axisService.addOperation(outOnlyOperation);
outOnlyOperation.setSoapAction(null);
OutInAxisOperation outInOperation =
new OutInAxisOperation(ServiceClient.ANON_OUT_IN_OP);
axisService.addOperation(outInOperation);
outInOperation.setSoapAction(null);
}
}
public synchronized ServiceClient getServiceClient() {
try {
if (serviceClient == null) {
ConfigurationContext configCtx = getServiceDescription().getAxisConfigContext();
AxisService axisSvc = getAxisService();
AxisConfiguration axisCfg = configCtx.getAxisConfiguration();
// The method synchronization prevents more than 1 service client being created
// for the same EndpointDescription instance by multiple threads. We also need
// to prevent different EndpointDescription instances from creating service client
// instances using the same AxisService name under multiple threads. We do that by
// synchronizing on the AxisConfiguration instance.
synchronized(axisCfg) {
if (axisCfg.getService(axisSvc.getName()) != null) {
axisSvc.setName(axisSvc.getName() + uniqueID());
if (log.isDebugEnabled()) {
log.debug("AxisService name is now " + axisSvc.getName() + ". This name should be unique; if not, errors might occur.");
}
}
serviceClient = new ServiceClient(configCtx, axisSvc);
// Disable automatic cleanup to avoid threading issues in Axis2 during the cleanup. JAXWS will
// drive the cleanup based on ServiceDelegate finalization
serviceClient.getOptions().setProperty(ServiceClient.AUTO_OPERATION_CLEANUP, false);
}
}
} catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("serviceClientCreateError"), e);
}
return serviceClient;
}
//This should eventually be deprecated in favor 'createAxisServiceNameFromDBL
private String createAxisServiceName() {
return getServiceDescription().getServiceQName().getLocalPart();
}
public boolean isWSDLFullySpecified() {
return isAxisServiceBuiltFromWSDL;
}
public boolean isProviderBased() {
return webServiceProviderAnnotation != null;
}
public boolean isEndpointBased() {
return webServiceAnnotation != null;
}
// ===========================================
// ANNOTATION: WebService and WebServiceProvider
// ===========================================
public String getAnnoWebServiceWSDLLocation() {
if (annotation_WsdlLocation == null) {
if (getAnnoWebService() != null) {
annotation_WsdlLocation = getAnnoWebService().wsdlLocation();
//If this is not an implicit SEI, then make sure that its not on the SEI
if (composite.isServiceProvider()) {
if (!DescriptionUtils.isEmpty(getAnnoWebServiceEndpointInterface())) {
DescriptionBuilderComposite seic =
getServiceDescriptionImpl().getDBCMap()
.get(composite.getWebServiceAnnot().endpointInterface());
if (!DescriptionUtils.isEmpty(seic.getWebServiceAnnot().wsdlLocation())) {
annotation_WsdlLocation = seic.getWebServiceAnnot().wsdlLocation();
}
}
}
} else if (getAnnoWebServiceProvider() != null
&& !DescriptionUtils.isEmpty(getAnnoWebServiceProvider().wsdlLocation())) {
annotation_WsdlLocation = getAnnoWebServiceProvider().wsdlLocation();
} else {
// There is no default value per JSR-181 MR Sec 4.1 pg 16
annotation_WsdlLocation = "";
}
}
return annotation_WsdlLocation;
}
public String getAnnoWebServiceServiceName() {
if (annotation_ServiceName == null) {
if (getAnnoWebService() != null
&& !DescriptionUtils.isEmpty(getAnnoWebService().serviceName())) {
annotation_ServiceName = getAnnoWebService().serviceName();
} else if (getAnnoWebServiceProvider() != null
&& !DescriptionUtils.isEmpty(getAnnoWebServiceProvider().serviceName())) {
annotation_ServiceName = getAnnoWebServiceProvider().serviceName();
} else {
// Default value is the "simple name" of the class or interface + "Service"
// Per JSR-181 MR Sec 4.1, pg 15
annotation_ServiceName = DescriptionUtils.getSimpleJavaClassName(composite.getClassName()) + "Service";
}
}
return annotation_ServiceName;
}
public String getAnnoWebServicePortName() {
if (annotation_PortName == null) {
if (getAnnoWebService() != null
&& !DescriptionUtils.isEmpty(getAnnoWebService().portName())) {
annotation_PortName = getAnnoWebService().portName();
} else if (getAnnoWebServiceProvider() != null
&& !DescriptionUtils.isEmpty(getAnnoWebServiceProvider().portName())) {
annotation_PortName = getAnnoWebServiceProvider().portName();
} else {
// Default the value
if (isProviderBased()) {
// This is the @WebServiceProvider annotation path
// Default value is not specified in JSR-224, but we can assume it is
// similar to the default in the WebService case, however there is no
// name attribute for a WebServiceProvider. So in this case we use
// the default value for WebService.name per JSR-181 MR sec 4.1 pg 15.
// Note that this is really the same thing as the call to getWebServiceName()
// in the WebService case; it is done sepertely just to be clear there is no
// name element on the WebServiceProvider annotation
annotation_PortName = DescriptionUtils.getSimpleJavaClassName(composite.getClassName())
+ "Port";
} else {
// This is the @WebService annotation path
// Default value is the @WebService.name of the class or interface + "Port"
// Per JSR-181 MR Sec 4.1, pg 15
annotation_PortName = getAnnoWebServiceName() + "Port";
}
}
}
return annotation_PortName;
}
public String getAnnoWebServiceTargetNamespace() {
if (annotation_TargetNamespace == null) {
if (getAnnoWebService() != null
&& !DescriptionUtils.isEmpty(getAnnoWebService().targetNamespace())) {
annotation_TargetNamespace = getAnnoWebService().targetNamespace();
} else if (getAnnoWebServiceProvider() != null
&& !DescriptionUtils.isEmpty(getAnnoWebServiceProvider().targetNamespace())) {
annotation_TargetNamespace = getAnnoWebServiceProvider().targetNamespace();
} else {
// Default value per JSR-181 MR Sec 4.1 pg 15 defers to "Implementation defined,
// as described in JAX-WS 2.0, section 3.2" which is JAX-WS 2.0 Sec 3.2, pg 29.
annotation_TargetNamespace =
DescriptionUtils.makeNamespaceFromPackageName(
DescriptionUtils.getJavaPackageName(composite.getClassName()),
"http");
}
}
return annotation_TargetNamespace;
}
// ===========================================
// ANNOTATION: WebServiceProvider
// ===========================================
public WebServiceProvider getAnnoWebServiceProvider() {
return webServiceProviderAnnotation;
}
// ===========================================
// ANNOTATION: WebService
// ===========================================
public WebService getAnnoWebService() {
return webServiceAnnotation;
}
public String getAnnoWebServiceEndpointInterface() {
// TODO: Validation: Not allowed on WebServiceProvider
if (webService_EndpointInterface == null) {
if (!isProviderBased() && getAnnoWebService() != null
&& !DescriptionUtils.isEmpty(getAnnoWebService().endpointInterface())) {
webService_EndpointInterface = getAnnoWebService().endpointInterface();
} else {
// This element is not valid on a WebServiceProvider annotation
webService_EndpointInterface = "";
}
}
return webService_EndpointInterface;
}
public String getAnnoWebServiceName() {
// TODO: Validation: Not allowed on WebServiceProvider
//TODO: Per JSR109 v1.2 Sec. 5.3.2.1
// If not specified then we can use the default value as specified in JSR 181
// (but only if it is unique within the module)...or If the name is
// not specified in the Service Implementation Bean then fully
// qualified name of the Bean class is used to guarantee uniqueness
// If the above is not unique then fully qualified name of the
// Bean class is used to guarantee uniqueness
if (webService_Name == null) {
if (!isProviderBased()) {
if (getAnnoWebService() != null
&& !DescriptionUtils.isEmpty(getAnnoWebService().name())) {
webService_Name = getAnnoWebService().name();
} else {
webService_Name =
DescriptionUtils.getSimpleJavaClassName(composite.getClassName());
}
} else {
// This element is not valid on a WebServiceProvider annotation
webService_Name = "";
}
}
return webService_Name;
}
// ===========================================
// ANNOTATION: ServiceMode
// ===========================================
public ServiceMode getAnnoServiceMode() {
if (serviceModeAnnotation == null) {
serviceModeAnnotation = composite.getServiceModeAnnot();
}
return serviceModeAnnotation;
}
public Service.Mode getServiceMode() {
return getAnnoServiceModeValue();
}
public Service.Mode getAnnoServiceModeValue() {
// This annotation is only valid on Provider-based endpoints.
if (isProviderBased() && serviceModeValue == null) {
if (getAnnoServiceMode() != null) {
serviceModeValue = getAnnoServiceMode().value();
} else {
serviceModeValue = ServiceMode_DEFAULT;
}
}
return serviceModeValue;
}
// ===========================================
// ANNOTATION: BindingType
// ===========================================
public BindingType getAnnoBindingType() {
if (bindingTypeAnnotation == null) {
bindingTypeAnnotation = composite.getBindingTypeAnnot();
}
return bindingTypeAnnotation;
}
public String getBindingType() {
return getAnnoBindingTypeValue();
}
public String getAnnoBindingTypeValue() {
if (bindingTypeValue == null) {
if (getAnnoBindingType() != null &&
!DescriptionUtils.isEmpty(getAnnoBindingType().value())) {
bindingTypeValue = getAnnoBindingType().value();
} else {
// No BindingType annotation present or value was empty; use default value
bindingTypeValue = BindingType_DEFAULT;
}
}
return bindingTypeValue;
}
// ===========================================
// ANNOTATION: HandlerChain
// ===========================================
public void setHandlerChain(HandlerChainsType handlerChain) {
handlerChainsType = handlerChain;
}
public HandlerChainsType getHandlerChain() {
return getHandlerChain(null);
}
/**
* Returns a schema derived java class containing the the handler configuration information.
* That information, returned in the HandlerChainsType object, is looked for in the following
* places in this order:
* - Set on the sparseComposite for the given key
* - Set on the composite
* - Read in from the file specified on HandlerChain annotation
*
* @return HandlerChainsType This is the top-level element for the Handler configuration file
*
*/
public HandlerChainsType getHandlerChain(Object sparseCompositeKey) {
DescriptionBuilderComposite sparseComposite = null;
// If there is a HandlerChainsType in the sparse composite for this ServiceDelegate
// (i.e. this sparseCompositeKey), then return that.
if (sparseCompositeKey != null) {
sparseComposite = composite.getSparseComposite(sparseCompositeKey);
if (sparseComposite != null && sparseComposite.getHandlerChainsType() != null) {
HandlerChainsType hct = sparseComposite.getHandlerChainsType();
return hct;
}
}
// If there is no HandlerChainsType in the composite, then read in the file specified
// on the HandlerChain annotation if it is present.
if (handlerChainsType == null) {
getAnnoHandlerChainAnnotation(sparseCompositeKey);
if (handlerChainAnnotation != null) {
String handlerFileName = handlerChainAnnotation.file();
if (log.isDebugEnabled()) {
log.debug(Messages.getMessage("handlerChainsTypeErr",handlerFileName,composite.getClassName()));
}
String className = composite.getClassName();
// REVIEW: This is using the classloader for EndpointDescriptionImpl; is that OK?
ClassLoader classLoader = (composite.isServiceProvider()) ?
composite.getClassLoader() :
(ClassLoader) AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return this.getClass().getClassLoader();
}
}
);
if(log.isDebugEnabled()){
log.debug("Trying to load file " + handlerFileName + " relative to " + className);
}
InputStream is = DescriptionUtils.openHandlerConfigStream(
handlerFileName,
className,
classLoader);
if (is == null) {
// config stream is still null. This may mean the @HandlerChain annotation is on a *driver* class
// next to a @WebServiceRef annotation, so the path is relative to the class declaring @HandlerChain
// and NOT relative to the Service or Endpoint class, which also means we should use the sparseComposite
// since that is where the @HandlerChain annotation info would have been loaded.
if (sparseComposite != null) {
String handlerChainDeclaringClass = (String)sparseComposite.getProperties().get(MDQConstants.HANDLER_CHAIN_DECLARING_CLASS);
if (handlerChainDeclaringClass != null) {
className = handlerChainDeclaringClass;
is = DescriptionUtils.openHandlerConfigStream(handlerFileName, className, classLoader);
}
}
}
if(is == null) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("handlerChainNS",
handlerFileName, className));
} else {
ClassLoader classLoader1 = (ClassLoader) AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return this.getClass().getClassLoader();
}
}
);
handlerChainsType =
DescriptionUtils.loadHandlerChains(is, classLoader1);
}
}
}
return handlerChainsType;
}
public HandlerChain getAnnoHandlerChainAnnotation(Object sparseCompositeKey) {
if (this.handlerChainAnnotation == null) {
if (composite.isServiceProvider()) {
/*
* Per JSR-181 The @HandlerChain annotation MAY be present on
* the endpoint interface and service implementation bean. The
* service implementations bean's @HandlerChain is used if
* @HandlerChain is present on both. So, if we do find the
* annotation on this impl, then don't worry about else
* Otherwise, check to see if the SEI might be annotated with
* @HandlerChain
*/
handlerChainAnnotation = composite.getHandlerChainAnnot();
if (handlerChainAnnotation == null) {
// If this is NOT an implicit SEI, then check for the
// annotation on the SEI
if (!DescriptionUtils.isEmpty(getAnnoWebServiceEndpointInterface())) {
DescriptionBuilderComposite seic = getServiceDescriptionImpl().getDBCMap()
.get(composite.getWebServiceAnnot().endpointInterface());
if (seic != null) {
handlerChainAnnotation = seic.getHandlerChainAnnot();
}
}
}
} else {
handlerChainAnnotation = composite.getHandlerChainAnnot();
}
}
if (handlerChainAnnotation == null) {
if (sparseCompositeKey != null) {
DescriptionBuilderComposite sparseComposite = composite.getSparseComposite(sparseCompositeKey);
if (sparseComposite != null && sparseComposite.getHandlerChainAnnot() != null) {
handlerChainAnnotation = sparseComposite.getHandlerChainAnnot();
}
}
}
return handlerChainAnnotation;
}
// ===========================================
// ANNOTATION: MTOM
// ===========================================
/*
* (non-Javadoc)
* @see org.apache.axis2.jaxws.description.EndpointDescription#isMTOMEnabled()
*/
public boolean isMTOMEnabled() {
if (isMTOMEnabledCache != null) {
return isMTOMEnabledCache.booleanValue();
}
// isMTOMEnabled is a combination of the @BindingType and the @MTOM setting.
MTOM mtomAnnotation =
(MTOM) getAnnoFeature(MTOMFeature.ID);
// If the @MTOM annotation is set, it wins
if (mtomAnnotation != null) {
isMTOMEnabledCache = Boolean.valueOf(mtomAnnotation.enabled());
return isMTOMEnabledCache.booleanValue();
}
// Else look at the bindingType
String bindingType = getBindingType();
isMTOMEnabledCache = Boolean.valueOf(isMTOMBinding(bindingType));
return isMTOMEnabledCache.booleanValue();
}
private static boolean isMTOMBinding(String url) {
if (url != null &&
(url.equals(SOAPBinding.SOAP11HTTP_MTOM_BINDING) ||
url.equals(SOAPBinding.SOAP12HTTP_MTOM_BINDING) ||
url.equals(MDQConstants.SOAP11JMS_MTOM_BINDING) ||
url.equals(MDQConstants.SOAP12JMS_MTOM_BINDING))) {
return true;
}
return false;
}
// ===========================================
// ANNOTATION: RespectBinding
// ===========================================
public boolean respectBinding() {
return respectBinding;
}
public void setRespectBinding(boolean r) {
respectBinding = r;
}
public boolean addRequiredBinding(WSDLValidatorElement element) {
return requiredBindings.add(element);
}
public Set<WSDLValidatorElement> getRequiredBindings() {
return requiredBindings;
}
/*
* (non-Javadoc)
* @see org.apache.axis2.jaxws.description.EndpointDescription#getMTOMThreshold()
*/
public int getMTOMThreshold() {
if (axisService != null) {
// We should cache this call here so we don't have to make
// it on every pass through.
Parameter mtomThreshold = axisService.getParameter(Configuration.MTOM_THRESHOLD);
if (mtomThreshold != null) {
return (Integer) mtomThreshold.getValue();
}
}
return -1;
}
// Get the specified WebServiceFeatureAnnotation
public Annotation getAnnoFeature(String id) {
return framework.getAnnotation(id);
}
//The WebServiceFeatures should be configued last so that any other
//configuration can be overridden. Should only be called on the
//server side.
private void configureWebServiceFeatures() {
if(log.isDebugEnabled()){
log.debug("Start configureWebServiceFeatures().");
}
String bindingType = getBindingType();
Set<String> ids = ServerConfiguratorRegistry.getIds();
for (String id : ids) {
ServerConfigurator configurator = ServerConfiguratorRegistry.getConfigurator(id);
if (configurator.supports(bindingType))
framework.addConfigurator(id, configurator);
}
// The feature instances are stored on the composite from either the
// Java class or from something else building the list and setting it there.
List<Annotation> features = composite.getWebServiceFeatures();
if (features != null && features.size() > 0) {
// Add each of the annotation instances to the WebServiceFeature framework
Iterator<Annotation> itr = features.iterator();
while (itr.hasNext()) {
Annotation feature = (Annotation) itr.next();
framework.addAnnotation(feature);
}
// Kick off the configuration of the WebServiceFeature instances.
framework.configure(this);
}
else {
if (log.isDebugEnabled()) {
log.debug("No WebServiceFeatureAnnotation instances were found on the composite.");
}
}
if(log.isDebugEnabled()){
log.debug("Exit configureWebServiceFeatures().");
}
}
public Definition getWSDLDefinition() {
return ((ServiceDescriptionWSDL)getServiceDescription()).getWSDLDefinition();
}
public javax.wsdl.Service getWSDLService() {
Definition defn = getWSDLDefinition();
if (defn != null) {
return defn.getService(getServiceQName());
} else {
return null;
}
}
public Port getWSDLPort() {
javax.wsdl.Service service = getWSDLService();
if (service != null) {
return service.getPort(getPortQName().getLocalPart());
} else {
return null;
}
}
public Binding getWSDLBinding() {
Binding wsdlBinding = null;
Port wsdlPort = getWSDLPort();
Definition wsdlDef = getWSDLDefinition();
if (wsdlPort != null && wsdlDef != null) {
wsdlBinding = wsdlPort.getBinding();
}
return wsdlBinding;
}
public String getWSDLBindingType() {
String wsdlBindingType = null;
String soapTransport = null;
Binding wsdlBinding = getWSDLBinding();
if (wsdlBinding != null) {
// If a WSDL binding was found, we need to find the proper extensibility
// element and return the namespace. The namespace for the binding element will
// determine whether it is SOAP 1.1 vs. SOAP 1.2 vs. HTTP (or other). If the namespace
// indicates SOAP we then need to determine what the transport is (HTTP vs. JMS)
// TODO: What do we do if no extensibility element exists?
List<ExtensibilityElement> elements = wsdlBinding.getExtensibilityElements();
Iterator<ExtensibilityElement> itr = elements.iterator();
while (itr.hasNext()) {
ExtensibilityElement e = itr.next();
if (javax.wsdl.extensions.soap.SOAPBinding.class.isAssignableFrom(e.getClass())) {
javax.wsdl.extensions.soap.SOAPBinding soapBnd =
(javax.wsdl.extensions.soap.SOAPBinding)e;
//representation: this is soap:binding = elementType where NamespaceURI is "soap"
// The transport is represented by the 'transport' attribute within this binding element
wsdlBindingType = soapBnd.getElementType().getNamespaceURI();
soapTransport = soapBnd.getTransportURI();
break;
} else if (SOAP12Binding.class.isAssignableFrom(e.getClass())) {
SOAP12Binding soapBnd = (SOAP12Binding)e;
wsdlBindingType = soapBnd.getElementType().getNamespaceURI();
soapTransport = soapBnd.getTransportURI();
break;
} else if (HTTPBinding.class.isAssignableFrom(e.getClass())) {
HTTPBinding httpBnd = (HTTPBinding)e;
wsdlBindingType = httpBnd.getElementType().getNamespaceURI();
break;
}
}
// We need to convert the wsdl-based SOAP and HTTP namespace into the expected Binding Type for
// HTTP or SOAPBindings with the appropriate transport (HTTP, JMS, etc.)
//
// Note that what we're actually returning is the WSDL binding type value conveted
// to the corresponding SOAPBinding or HTTPBinding value. We are overwite the
// wsdlBindingType with that converted JAXWS annotation binding type value and
// return it.
wsdlBindingType = DescriptionUtils.mapBindingTypeWsdlToAnnotation(wsdlBindingType, soapTransport);
}
return wsdlBindingType;
}
public String getName() {
return getAnnoWebServiceName();
}
public String getTargetNamespace() {
return getAnnoWebServiceTargetNamespace();
}
public PortInfo getPortInfo() {
if (portInfo == null) {
portInfo = new PortInfoImpl(getServiceQName(), getPortQName(), getBindingType());
}
return portInfo;
}
public void setClientBindingID(String clientBindingID) {
if (clientBindingID == null) {
this.clientBindingID = DEFAULT_CLIENT_BINDING_ID;
} else if (validateClientBindingID(clientBindingID)) {
this.clientBindingID = clientBindingID;
} else {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("addPortErr0", getPortQName().toString()));
}
}
private boolean validateClientBindingID(String bindingId) {
boolean isValid = true;
if (bindingId != null && !(bindingId.equals(SOAPBinding.SOAP11HTTP_BINDING) ||
bindingId.equals(javax.xml.ws.http.HTTPBinding.HTTP_BINDING) ||
bindingId.equals(SOAPBinding.SOAP12HTTP_BINDING) ||
bindingId.equals(SOAPBinding.SOAP11HTTP_MTOM_BINDING) ||
bindingId.equals(SOAPBinding.SOAP12HTTP_MTOM_BINDING) ||
bindingId.equals(MDQConstants.SOAP11JMS_BINDING) ||
bindingId.equals(MDQConstants.SOAP12JMS_BINDING) ||
bindingId.equals(MDQConstants.SOAP11JMS_MTOM_BINDING) ||
bindingId.equals(MDQConstants.SOAP12JMS_MTOM_BINDING))) {
throw ExceptionFactory.makeWebServiceException(
Messages.getMessage("addPortErr0", getPortQName().toString()));
}
return isValid;
}
public String getClientBindingID() {
if (clientBindingID == null) {
if (getWSDLDefinition() != null) {
clientBindingID = getWSDLBindingType();
if (clientBindingID == null) {
clientBindingID = DEFAULT_CLIENT_BINDING_ID;
}
} else {
clientBindingID = DEFAULT_CLIENT_BINDING_ID;
}
}
return clientBindingID;
}
public void setEndpointAddress(String endpointAddress) {
// REVIEW: Should this be called whenever BindingProvider.ENDPOINT_ADDRESS_PROPERTY is set by the client?
if (!DescriptionUtils.isEmpty(endpointAddress)) {
this.endpointAddress = endpointAddress;
} else {
// Since a port can be added without setting an endpoint address, this is not an error.
if (log.isDebugEnabled())
log.debug("A null or empty endpoint address was attempted to be set",
new Throwable("Stack Traceback"));
}
}
public String getEndpointAddress() {
if (endpointAddress == null) {
// If the endpointAddress has not been set explicitly by a call to setEndpointAddress()
// then try to get it from the WSDL
endpointAddress = getWSDLSOAPAddress();
}
return endpointAddress;
}
public void setProperty(String key, Object value) {
if(properties == null) {
properties = new HashMap<String, Object>();
}
properties.put(key, value);
}
public Object getProperty(String key) {
if(properties != null) {
return properties.get(key);
}
return null;
}
/**
* Return the SOAP Address from the WSDL for this port.
*
* @return The SOAP Address from the WSDL for this port or null.
*/
public String getWSDLSOAPAddress() {
if (wsdlSOAPAddress == null) {
Port wsdlPort = getWSDLPort();
if (wsdlPort != null) {
// The port is in the WSDL, so see if it has a SOAP address extensibility element specified.
List extElementList = wsdlPort.getExtensibilityElements();
for (Object listElement : extElementList) {
ExtensibilityElement extElement = (ExtensibilityElement)listElement;
if (isSOAPAddressElement(extElement)) {
String soapAddress = getSOAPAddressFromElement(extElement);
if (!DescriptionUtils.isEmpty(soapAddress)) {
wsdlSOAPAddress = soapAddress;
}
}
}
}
}
return wsdlSOAPAddress;
}
/**
* Determine if the WSDL Extensibility element corresponds to the SOAP Address element.
*
* @param exElement
* @return
*/
static boolean isSOAPAddressElement(ExtensibilityElement exElement) {
boolean isAddress = false;
if (exElement != null) {
isAddress = (SOAP_11_ADDRESS_ELEMENT.equals(exElement.getElementType())
||
(SOAP_12_ADDRESS_ELEMENT.equals(exElement.getElementType())));
}
return isAddress;
}
static String getSOAPAddressFromElement(ExtensibilityElement extElement) {
String returnAddress = null;
if (extElement != null) {
if (SOAP_11_ADDRESS_ELEMENT.equals(extElement.getElementType())) {
returnAddress = ((SOAPAddress)extElement).getLocationURI();
} else if (SOAP_12_ADDRESS_ELEMENT.equals(extElement.getElementType())) {
returnAddress = ((SOAP12Address)extElement).getLocationURI();
}
}
return returnAddress;
}
/**
* Selects a port to use in the case where a portQName was not specified by the client on the
* Service.getPort(Class) call. If WSDL is present, then an appropriate port is looked for
* under the service element, and an exception is thrown if none can be found. If WSDL is not
* present, then the selected port is simply the one determined by annotations.
*
* @return A QName representing the port that is to be used.
*/
private QName selectPortToUse() {
QName portToUse = null;
// If WSDL Service for this port is present, then we'll find an appropriate port defined in there and set
// the name accordingly. If no WSDL is present, the the PortQName getter will use annotations to set the value.
if (getWSDLService() != null) {
portToUse = selectWSDLPortToUse();
} else {
// No WSDL, so the port to use is the one defined by the annotations.
portToUse = getPortQName();
}
return portToUse;
}
/**
* Look through the WSDL Service for a port that should be used. If none can be found, then
* throw an exception.
*
* @param wsdlService
* @return A QName representing the port from the WSDL that should be used.
*/
private QName selectWSDLPortToUse() {
QName wsdlPortToUse = null;
// To select which WSDL Port to use, we do the following
// 1) Find the subset of all ports under the service that use the PortType represented by the SEI
// 2) From the subset in (1) find all those ports that specify a SOAP Address
// 3) Use the first port from (2)
// Per JSR-181,
// - The portType name corresponds to the WebService.name annotation value, which is
// returned by getName()
// - The portType namespace corresponds to the WebService.targetNamespace annotation, which
// is returned by getTargetNamespace()
String portTypeLP = getName();
String portTypeTNS = getTargetNamespace();
QName portTypeQN = new QName(portTypeTNS, portTypeLP);
ServiceDescriptionWSDL serviceDescWSDL = (ServiceDescriptionWSDL)getServiceDescription();
List<Port> wsdlPortsUsingPortType = serviceDescWSDL.getWSDLPortsUsingPortType(portTypeQN);
List<Port> wsdlPortsUsingSOAPAddresses =
serviceDescWSDL.getWSDLPortsUsingSOAPAddress(wsdlPortsUsingPortType);
if (wsdlPortsUsingSOAPAddresses != null && !wsdlPortsUsingSOAPAddresses.isEmpty()) {
// We return the first port that uses the particluar PortType and has a SOAP address.
// HOWEVER, that is not necessarily the first one in the WSDL that meets that criteria!
// The problem is that WSDL4J Service.getPorts(), which is used to get a Map of ports under the service
// DOES NOT return the ports in the order they are defined in the WSDL.
// Therefore, we can't necessarily predict which one we'll get back as the "first" one in the collection.
// REVIEW: Note the above comment; is there anything more predictible and determinstic we can do?
Port portToUse = (Port)wsdlPortsUsingSOAPAddresses.toArray()[0];
String portLocalPart = portToUse.getName();
String portNamespace = serviceDescWSDL.getWSDLService().getQName().getNamespaceURI();
wsdlPortToUse = new QName(portNamespace, portLocalPart);
}
return wsdlPortToUse;
}
private WsdlComposite generateWSDL(DescriptionBuilderComposite dbc) {
WsdlComposite wsdlComposite = null;
Definition defn = dbc.getWsdlDefinition(getServiceQName());
if(defn == null) {
defn = dbc.getWsdlDefinition();
}
if (defn == null || !isAxisServiceBuiltFromWSDL) {
//Invoke the callback for generating the wsdl
if (dbc.getCustomWsdlGenerator() != null) {
String implName = null;
if (axisService == null) {
implName = DescriptionUtils.javifyClassName(composite.getClassName());
} else {
implName = (String)axisService.getParameterValue(MDQConstants.SERVICE_CLASS);
}
wsdlComposite =
dbc.getCustomWsdlGenerator().generateWsdl(implName, this);
if (wsdlComposite != null) {
if(wsdlComposite.getWsdlFileName() == null
||
"".equals(wsdlComposite.getWsdlFileName())) {
wsdlComposite.setWsdlFileName(
(this.getAnnoWebServiceServiceName() + ".wsdl").toLowerCase());
}
Definition wsdlDef = wsdlComposite.getRootWsdlDefinition();
try {
ConfigurationContext cc = dbc.getConfigurationContext();
WSDL4JWrapper wsdl4jWrapper = null;
if (cc != null) {
wsdl4jWrapper = new WSDL4JWrapper(dbc.getWsdlURL(), wsdlDef, cc);
} else {
wsdl4jWrapper = new WSDL4JWrapper(dbc.getWsdlURL(), wsdlDef, true, 2);
}
getServiceDescriptionImpl().setGeneratedWsdlWrapper(wsdl4jWrapper);
} catch (Exception e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("generateWSDLErr"),e);
}
} else {
// REVIEW:Determine if we should always throw an exception on this, or at this point
//throw ExceptionFactory.makeWebServiceException("EndpointDescriptionImpl: Unable to find custom WSDL generator");
if (log.isDebugEnabled()) {
log.debug(
"The custom WSDL generator returned null, so no generated WSDL is available");
}
}
} else {
// REVIEW: This used to throw an exception, but it seems we shouldn't require
// a wsdl generator be provided.
// throw ExceptionFactory.makeWebServiceException("EndpointDescriptionImpl: Unable to find custom WSDL generator");
if (log.isDebugEnabled()) {
log.debug(
"No custom WSDL generator was supplied, so WSDL can not be generated");
}
}
}
return wsdlComposite;
}
List<CustomAnnotationInstance> getCustomAnnotationInstances() {
return customAnnotations;
}
CustomAnnotationProcessor getCustomAnnotationProcessor(String annotationInstanceClassName) {
return customAnnotationProcessors != null ?
customAnnotationProcessors.get(annotationInstanceClassName) : null;
}
public DescriptionBuilderComposite getDescriptionBuilderComposite() {
return composite;
}
public String toString() {
final String newline = "\n";
final String sameline = "; ";
StringBuffer string = new StringBuffer();
try {
string.append(super.toString());
string.append(newline);
string.append("Name: " + getName());
string.append(sameline);
string.append("Endpoint Address: " + getEndpointAddress());
//
string.append(newline);
string.append("ServiceQName: " + getServiceQName());
string.append(sameline);
string.append("PortQName: " + getPortQName());
string.append(sameline);
string.append("TargetNamespace: " + getTargetNamespace());
//
string.append(newline);
string.append("Service Mode: " + getServiceMode());
string.append(sameline);
string.append("Binding Type: " + getBindingType());
string.append(sameline);
string.append("Client Binding Type: " + getClientBindingID());
//
string.append(newline);
string.append("Is provider-based: " + (isProviderBased() == true));
string.append(sameline);
string.append("Is proxy-based: " + (isEndpointBased() == true));
string.append(sameline);
string.append("Is WSDL fully specified: " + (isWSDLFullySpecified() == true));
//
string.append(newline);
string.append("AxisService: " + getAxisService());
//
string.append(newline);
EndpointInterfaceDescription endpointInterfaceDesc = getEndpointInterfaceDescription();
if (endpointInterfaceDesc != null) {
string.append("EndpointInterfaceDescription: " + endpointInterfaceDesc.toString());
} else {
string.append("EndpointInterfaceDescription is null.");
}
}
catch (Throwable t) {
string.append(newline);
string.append("Complete debug information not currently available for " +
"EndpointDescription");
return string.toString();
}
return string.toString();
}
/**
* Get an annotation. This is wrappered to avoid a Java2Security violation.
* @param cls Class that contains annotation
* @param annotation Class of requrested Annotation
* @return annotation or null
*/
private static Annotation getAnnotation(final Class cls, final Class annotation) {
return (Annotation) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return cls.getAnnotation(annotation);
}
});
}
/**
* Return the class for this name
*
* @return Class
*/
private static Class forName(final String className, final boolean initialize,
final ClassLoader classloader) throws ClassNotFoundException {
Class cl = null;
try {
cl = (Class) AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Object run() throws ClassNotFoundException {
return Class.forName(className, initialize, classloader);
}
}
);
} catch (PrivilegedActionException e) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from AccessController: " + e.getMessage(), e);
}
throw (ClassNotFoundException) e.getException();
}
return cl;
}
private static ClassLoader getContextClassLoader(final ClassLoader classLoader) {
ClassLoader cl;
try {
cl = (ClassLoader) AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public Object run() throws ClassNotFoundException {
return classLoader != null ? classLoader : Thread.currentThread().getContextClassLoader();
}
}
);
} catch (PrivilegedActionException e) {
if (log.isDebugEnabled()) {
log.debug("Exception thrown from AccessController: " + e.getMessage(), e);
}
throw ExceptionFactory.makeWebServiceException(e.getException());
}
return cl;
}
/**
* This will update or set the parameter on the AxisService that represents the
* value of the @WebService.name attribute. This is needed since the @WebService.name
* value may not be known until the EndpointInterfaceDescription is created for
* the explicitly defined SEI.
*/
void updateWebServiceNameParameter(String newName, AxisService service) {
if(log.isDebugEnabled()) {
log.debug("Setting @WebService.name value on the " + service.getName() +
" AxisService to: " + newName);
}
Parameter param = service.getParameter(MDQConstants.WSDL_PORTTYPE_NAME);
if(param != null) {
param.setValue(newName);
}
else {
param = new Parameter();
param.setName(MDQConstants.WSDL_PORTTYPE_NAME);
param.setValue(newName);
try {
service.addParameter(param);
}
catch (AxisFault e) {
throw ExceptionFactory.makeWebServiceException(Messages.getMessage("setupAxisServiceErr2"),e);
}
}
}
private static long currentUniqueID = 0;
private long uniqueID() {
if (currentUniqueID == 0) {
currentUniqueID = System.currentTimeMillis();
}
return currentUniqueID++;
}
/**
* Release the AxisService objects associated with this EndpointDescription. Note that
* this should only be called by the ServiceDescription that owns this EndpointDescrition.
*
* @param configurationContext The Axis2 ConfigurationContext holding the AxisConfiguration
* from which the AxisServices should be removed.
*/
void releaseResources(ConfigurationContext configurationContext) {
if (configurationContext != null) {
AxisConfiguration axisConfig = configurationContext.getAxisConfiguration();
AxisService axisService = getAxisService();
AxisServiceGroup axisServiceGroup = axisService.getAxisServiceGroup();
try {
axisConfig.removeServiceGroup(axisServiceGroup.getServiceGroupName());
} catch (AxisFault e) {
if (log.isDebugEnabled()) {
log.debug("EndpointDescriptionImpl release resources caught exception which it is ignoring", e);
}
}
}
}
}