geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From xuhaih...@apache.org
Subject svn commit: r1097373 [4/5] - in /geronimo/bundles/trunk/axis2: ./ src/main/java/org/apache/axis2/addressing/ src/main/java/org/apache/axis2/description/ src/main/java/org/apache/axis2/jaxws/addressing/ src/main/java/org/apache/axis2/jaxws/addressing/po...
Date Thu, 28 Apr 2011 09:03:02 GMT
Added: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/impl/EndpointDescriptionImpl.java
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/impl/EndpointDescriptionImpl.java?rev=1097373&view=auto
==============================================================================
--- geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/impl/EndpointDescriptionImpl.java (added)
+++ geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/impl/EndpointDescriptionImpl.java Thu Apr 28 09:03:01 2011
@@ -0,0 +1,2339 @@
+/*
+ * 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.addressing.policy.AddressingPolicyUtil;
+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()));
+        }
+        
+        if(isAxisServiceBuiltFromWSDL) {
+            AddressingPolicyUtil.configureAddressingPolicyFromWSDL(axisService, axisConfig);
+        }
+        
+        // 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()));
+        }
+        
+        if(isAxisServiceBuiltFromWSDL) {
+            AddressingPolicyUtil.configureAddressingPolicyFromWSDL(axisService, axisConfig);
+        }
+        
+        //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() {

[... 455 lines stripped ...]


Mime
View raw message