geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From xuhaih...@apache.org
Subject svn commit: r1089448 - in /geronimo/bundles/trunk: axis2-saaj/ axis2/ axis2/src/main/java/org/apache/axis2/jaxws/description/ axis2/src/main/java/org/apache/axis2/jaxws/runtime/ axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/ axis2/src/...
Date Wed, 06 Apr 2011 13:32:02 GMT
Author: xuhaihong
Date: Wed Apr  6 13:32:02 2011
New Revision: 1089448

URL: http://svn.apache.org/viewvc?rev=1089448&view=rev
Log:
a. Update Axis2 version to 1.6.1-SNAPSHOT
b. Remove committed changes in Axis2 from Geronimo side
c. Add some new changes on Geronimo side, check the parameter style before checking the wrapper
class

Added:
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
  (with props)
Removed:
    geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/
Modified:
    geronimo/bundles/trunk/axis2-saaj/pom.xml
    geronimo/bundles/trunk/axis2/pom.xml

Modified: geronimo/bundles/trunk/axis2-saaj/pom.xml
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2-saaj/pom.xml?rev=1089448&r1=1089447&r2=1089448&view=diff
==============================================================================
--- geronimo/bundles/trunk/axis2-saaj/pom.xml (original)
+++ geronimo/bundles/trunk/axis2-saaj/pom.xml Wed Apr  6 13:32:02 2011
@@ -28,7 +28,7 @@
 
     <groupId>org.apache.geronimo.bundles</groupId>
     <artifactId>${pkgArtifactId}</artifactId>
-    <version>1.6.0_1-SNAPSHOT</version>
+    <version>1.6.1_1-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>Apache Geronimo Bundles: ${pkgArtifactId}-${pkgVersion}</name>
     <description>
@@ -44,7 +44,7 @@
     <properties>
         <pkgGroupId>org.apache.axis2</pkgGroupId>
         <pkgArtifactId>axis2-saaj</pkgArtifactId>
-        <pkgVersion>1.6.0-SNAPSHOT</pkgVersion>
+        <pkgVersion>1.6.1-SNAPSHOT</pkgVersion>
     </properties>
 
     <dependencies>

Modified: geronimo/bundles/trunk/axis2/pom.xml
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/pom.xml?rev=1089448&r1=1089447&r2=1089448&view=diff
==============================================================================
--- geronimo/bundles/trunk/axis2/pom.xml (original)
+++ geronimo/bundles/trunk/axis2/pom.xml Wed Apr  6 13:32:02 2011
@@ -26,13 +26,13 @@
     </parent>
     <groupId>org.apache.geronimo.bundles</groupId>
     <artifactId>axis2</artifactId>
-    <version>1.6.0_1-SNAPSHOT</version>
+    <version>1.6.1_1-SNAPSHOT</version>
     <packaging>bundle</packaging>
     <name>Apache Geronimo Bundles: Axis2-${pkgVersion}</name>
     <description> This bundle simply wraps all required Axis2 components </description>
     <properties>
         <pkgGroupId>org.apache.axis2</pkgGroupId>
-        <pkgVersion>1.6.0-SNAPSHOT</pkgVersion>
+        <pkgVersion>1.6.1-SNAPSHOT</pkgVersion>
     </properties>
     <scm>
         <connection>scm:svn:http://svn.apache.org/repos/asf/geronimo/bundles/trunk/axis2</connection>
@@ -222,12 +222,6 @@
                         <Embed-Dependency> *;inline=META-INF/services/**|META-INF/*.xml|*.xml|org/apache/axis2**</Embed-Dependency>
                         <Include-Resource>
                            {maven-resources},
-                           org/apache/axis2/jaxws/description/builder/MDQConstants.class=target/classes/org/apache/axis2/jaxws/description/builder/MDQConstants.class,
-                           org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl.class,
-                           org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$1.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$1.class,
-                           org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$2.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$2.class,
-                           org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$3.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$3.class,
-                           org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$4.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$4.class,
                            org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler.class,
                            org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$1.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$1.class,
                            org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$2.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$2.class,
@@ -243,7 +237,12 @@
                            org/apache/axis2/jaxws/message/databinding/JAXBUtils$4.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$4.class,
                            org/apache/axis2/jaxws/message/databinding/JAXBUtils$3.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$3.class,
                            org/apache/axis2/jaxws/message/databinding/JAXBUtils$2.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$2.class,
-                           org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class
+                           org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class,
+                           org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.class,
+                           org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$1.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$1.class,
+                           org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$2.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$2.class,
+                           org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$3.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$3.class,
+                           org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$4.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$4.class
                         </Include-Resource>
                         <SPI-Provider>true</SPI-Provider>
                     </instructions>

Added: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java?rev=1089448&view=auto
==============================================================================
--- geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
(added)
+++ geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
Wed Apr  6 13:32:02 2011
@@ -0,0 +1,758 @@
+/*
+ * 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.runtime.description.marshal.impl;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.jws.soap.SOAPBinding;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+import org.apache.axis2.java.security.AccessController;
+import org.apache.axis2.jaxws.Constants;
+import org.apache.axis2.jaxws.ExceptionFactory;
+import org.apache.axis2.jaxws.description.EndpointDescription;
+import org.apache.axis2.jaxws.description.FaultDescription;
+import org.apache.axis2.jaxws.description.OperationDescription;
+import org.apache.axis2.jaxws.description.ServiceDescription;
+import org.apache.axis2.jaxws.message.databinding.ClassFinder;
+import org.apache.axis2.jaxws.message.factory.ClassFinderFactory;
+import org.apache.axis2.jaxws.registry.FactoryRegistry;
+import org.apache.axis2.jaxws.runtime.description.marshal.AnnotationDesc;
+import org.apache.axis2.jaxws.runtime.description.marshal.FaultBeanDesc;
+import org.apache.axis2.jaxws.utility.ClassUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * Examines a ServiceDesc and locates and/or builds the JAX-WS artifacts. The JAX-WS artifacts
are:
+ * - request wrapper classes - response wrapper classes - fault beans for non-JAX-WS compliant
+ * exceptions
+ */
+class ArtifactProcessor {
+
+    private static final Log log = LogFactory.getLog(ArtifactProcessor.class);
+
+    private ServiceDescription serviceDesc;
+    private Map<OperationDescription, String> requestWrapperMap =
+        new HashMap<OperationDescription, String>();
+    private Map<OperationDescription, String> responseWrapperMap =
+        new HashMap<OperationDescription, String>();
+    private Map<OperationDescription, Method> methodMap =
+        new HashMap<OperationDescription, Method>();
+    private Map<FaultDescription, FaultBeanDesc> faultBeanDescMap =
+        new HashMap<FaultDescription, FaultBeanDesc>();
+
+    static final String JAXWS_SUBPACKAGE = "jaxws";
+
+    /**
+     * Artifact Processor
+     *
+     * @param serviceDesc
+     */
+    ArtifactProcessor(ServiceDescription serviceDesc) {
+        this.serviceDesc = serviceDesc;
+    }
+
+    Map<OperationDescription, String> getRequestWrapperMap() {
+        return requestWrapperMap;
+    }
+
+    Map<OperationDescription, String> getResponseWrapperMap() {
+        return responseWrapperMap;
+    }
+
+    Map<FaultDescription, FaultBeanDesc> getFaultBeanDescMap() {
+        return faultBeanDescMap;
+    }
+
+    Map<OperationDescription, Method> getMethodMap() {
+        return methodMap;
+    }
+
+    void build() {
+        for (EndpointDescription ed : serviceDesc.getEndpointDescriptions()) {
+            if (ed.getEndpointInterfaceDescription() != null && ed.getEndpointInterfaceDescription().getSoapBindingParameterStyle()
== SOAPBinding.ParameterStyle.WRAPPED) {
+                for (OperationDescription opDesc : ed.getEndpointInterfaceDescription()
+                    .getOperations()) {
+
+                    String declaringClassName = opDesc.getJavaDeclaringClassName();
+                    String packageName = getPackageName(declaringClassName);
+                    String simpleName = getSimpleClassName(declaringClassName);
+                    String methodName = opDesc.getJavaMethodName();
+
+
+                    // There is no default for @RequestWrapper/@ResponseWrapper classname
 None is listed in Sec. 7.3 on p. 80 of
+                    // the JAX-WS spec, BUT Conformance(Using javax.xml.ws.RequestWrapper)
in Sec 2.3.1.2 on p. 13
+                    // says the entire annotation "...MAY be omitted if all its properties
would have default values."
+                    // We will assume that this statement gives us the liberty to find a
wrapper class/build a wrapper class or 
+                    // implement an engine w/o the wrapper class.
+
+                    // @RequestWrapper className processing
+                    String requestWrapperName = opDesc.getRequestWrapperClassName();
+                    String foundRequestWrapperName = getWrapperClass("@RequestWrapper",
+                        requestWrapperName, 
+                        packageName, 
+                        javaMethodToClassName(methodName),
+                        ed.getAxisService().getClassLoader(),
+                        serviceDesc);
+
+                    if (foundRequestWrapperName != null) {
+                        requestWrapperMap.put(opDesc, foundRequestWrapperName);
+                    }
+
+                    // @ResponseWrapper className processing
+                    String responseWrapperName = opDesc.getResponseWrapperClassName();
+                    String foundResponseWrapperName = getWrapperClass("@ResponseWrapper",
+                        responseWrapperName, 
+                        packageName, 
+                        javaMethodToClassName(methodName) + "Response",
+                        ed.getAxisService().getClassLoader(),
+                        serviceDesc);
+
+                    if (foundResponseWrapperName != null) {
+                        responseWrapperMap.put(opDesc, foundResponseWrapperName);
+                    }
+
+                    for (FaultDescription faultDesc : opDesc.getFaultDescriptions()) {
+                        FaultBeanDesc faultBeanDesc = create(ed, faultDesc, opDesc);
+                        faultBeanDescMap.put(faultDesc, faultBeanDesc);
+                    }
+
+                    // Get the Method
+                    Class cls = null;
+                    try {
+                        cls = loadClass(declaringClassName, getContextClassLoader());
+                    } catch(Exception e) {
+                        if (log.isDebugEnabled()) {
+                            log.debug("Class " + declaringClassName + " was not found by
the Context ClassLoader.  " +
+                                "Will use the ClassLoader associated with the service.  The
exception is: " +e);
+                        }
+                    }
+
+                    if (cls == null) {
+                        try {
+                            cls = loadClass(declaringClassName, ed.getAxisService().getClassLoader());
+                        } catch(Exception e) {
+                            if (log.isDebugEnabled()) {
+                                log.debug("Class " + declaringClassName + " was not found
by the AxisService ClassLoader.  " +
+                                    "Processing continues.  The exception is:" +e);
+                            }
+
+                        }
+                    }
+                    if (cls != null) {
+                        Method method = getMethod(opDesc.getJavaMethodName(), cls);
+                        if (method != null) {
+                            methodMap.put(opDesc, method);
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    /**
+     * @param type "@RequestWrapper", "@ResponseWrapper", and "@WebFault"
+     * @param providedValue String name of the Wrapper or Fault Bean from annotations
+     * @param defaultPkg String name of the package to use for defaulting
+     * @param defaultClassName name of the class to use if defaulting
+     * @param altClassLoader name of the alternative classloader
+     * @return
+     */
+    static private String getWrapperClass(String type,
+        String providedValue, 
+        String defaultPkg, 
+        String defaultClassName, 
+        ClassLoader altClassLoader,
+        ServiceDescription serviceDesc) {
+
+        if (log.isDebugEnabled()) {
+            log.debug("getWrapperClass for " + type + " with value (" + providedValue + ")");
+        }
+
+        String wrapperClass = null;
+        try {
+           
+            ClassLoader cl = getContextClassLoader();
+            if (providedValue != null  && providedValue.length() > 0) {
+                Class cls = null;
+                // If a className is provided try to load it with the context classloader
+                // and then the alternate classloader.
+                // If the class still cannot be loaded, then try inserting the
+                // jaxws sub-package.
+
+                if (log.isDebugEnabled()) {
+                    log.debug("Try finding the class with the name provided = " + providedValue);
+                }
+                cls = loadClassOrNull(providedValue, cl);
+                if (cls != null) {
+                    wrapperClass = providedValue;
+                }
+                else {
+                    cls = loadClassOrNull(providedValue, altClassLoader);
+                    if (cls != null) {
+                        wrapperClass = providedValue;
+                    }
+                }
+                // Legacy
+                if (cls == null) {
+                    String origPackage = getPackageName(providedValue);
+                    if (origPackage.length() > 0) {
+                        String newPackage = origPackage + "." + JAXWS_SUBPACKAGE;
+                        String clsName = getSimpleClassName(providedValue);
+                        String newValue = newPackage + "." + clsName;
+                        if (log.isDebugEnabled()) {
+                            log.debug("Did not find the name provided.  Now trying " + newValue);
+                        }
+                        cls = loadClassOrNull(newValue, cl);
+                        if (cls != null) {
+                            wrapperClass = newValue;
+                        } else {
+                            cls = loadClassOrNull(newValue, altClassLoader);
+                            if (cls != null) {
+                                wrapperClass = newValue;
+                            }
+                        }
+                        
+                        if(cls==null && 
+                            (type.equals("@RequestWrapper")|| type.equals("@ResponseWrapper")||type.equals("@WebFault")||
type.equals("faultInfo"))){
+                            
+                            //Support for Fault Bean Generation
+                            //As per JAX-WS 2.2 Specification section 3.7 an application
programmer can choose not to
+                            //package the faultBeans, if we have reached this point in the
code then user has choosen
+                            //not to package the fault bean. If there is a cache of generated
artifacts available then 
+                            //lets look for the missing faultBean there.
+                            
+                            //Support for Wrapper Bean Generation
+                            //As per JAX-WS 2.2 Specificaiton section 3.6.2.1 pg 41 an application
programmer does not use
+                            //the wrapper bean classes, so the application need not package
these classes. If we have reached
+                            //this point in the code then user has choosen not to package
these beans.
+                            
+                            //NOTE:If we find Generated artifacts from cache this guarantees
that we will not use
+                            //DocLitWrappedMinimum marshaller code. The advantage of normal
DocLitWrappedMarshaller is
+                            //that it is very robust and has support of lot more datatypes
than in DocLitWrappedMinimum.
+                            if(log.isDebugEnabled()){
+                                log.debug("Adding cache to classpath");
+                            }
+                            ClassFinderFactory cff =
+                                (ClassFinderFactory)FactoryRegistry.getFactory(ClassFinderFactory.class);
+                            ClassFinder cf = cff.getClassFinder();
+                            String cachePath = (String)serviceDesc.getAxisConfigContext().getProperty(Constants.WS_CACHE);
+                            if(cachePath!=null){
+                                //lets add the cache to classpath and retry loading missing
artifacts.
+                                if(log.isDebugEnabled()){
+                                    log.debug("updating classpath with cache location");
+                                }
+                                cf.updateClassPath(cachePath, cl);
+                                if(log.isDebugEnabled()){
+                                    log.debug("trying to load class "+newValue+" from cache.");
+                                }
+                                cls=loadClassOrNull(newValue, cl);
+                                if(cls!=null){
+                                    wrapperClass=newValue;
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                // If no value is provided by the annotation, then the we try default values.
+                // The wsgen tool generates classes in the jaxws subpackage.
+                // The wsimport tool generates classes in the same package as the SEI.
+                // Note that from reading the JAX-WS spec, it seems that WSGen is doing that
+                // correctly; See the conformance requirement in JAX-WS 2.0 Spec Section
3.6.2.1 Document
+                // Wrapped on page 36: Conformance (Default wrapper bean package): In the
absence of
+                // customizations, the wrapper beans package MUST be a generated jaxws subpackage
of the SEI
+                // package.
+                // However, if the class is in both places the runtime should prefer the
one
+                // in the non-jaxws package.  Why ?
+                // The other classes in the non-jaxws package will cause the non-jaxws 
+                // wrapper to get pulled in first....thus the jaxws wrapper will cause a
collision.
+                // 
+                // Thus the following algorithm with check the non-jaxws package first
+                
+                Class cls1 = null;  // Class from the non-JAXWS package
+                Class cls2 = null;  // Class from the JAX-WS package
+                boolean cls1IsJAXB = false;
+                boolean cls2IsJAXB = false;
+                
+                
+                // Look for the class in the non-jaxws package first
+                String defaultValue = null;
+                if (defaultPkg.length() > 0) {
+                    defaultValue = defaultPkg + "." + defaultClassName;
+                } else {
+                    defaultValue = defaultClassName;
+                }
+                if (log.isDebugEnabled()) {
+                    log.debug("No provided value.  Try the default class name =  " + defaultValue);
+                }
+                cls1 = loadClassOrNull(defaultValue, cl);
+
+                if (cls1 == null) {
+                    cls1 = loadClassOrNull(defaultValue, altClassLoader);
+                }
+                if (cls1 != null) {
+                    cls1IsJAXB = isJAXB(cls1);
+                }
+
+                // Now try the one in the jaxws subpackage (if cls1 is missing or perhaps
not a JAXB class)
+                if (cls1 == null || !cls1IsJAXB) {
+                    if (defaultPkg.length() > 0) {
+                        defaultValue = defaultPkg + "." + JAXWS_SUBPACKAGE + "." + defaultClassName;
+                        if (log.isDebugEnabled()) {
+                            log.debug("Did not find the default name.  Try a different default
class name =  " + defaultValue);
+                        }
+                        cls2 = loadClassOrNull(defaultValue, cl);
+                        if (cls2 == null) {
+                            cls2 = loadClassOrNull(defaultValue, altClassLoader);
+                        }
+                        if(cls2==null && 
+                        		(type.equals("@RequestWrapper")|| type.equals("@ResponseWrapper")||type.equals("@WebFault")||
type.equals("faultInfo"))){
+
+                        	//Support for Fault Bean Generation
+                        	//As per JAX-WS 2.2 Specification section 3.7 an application programmer
can choose not to
+                        	//package the faultBeans, if we have reached this point in the code
then user has choosen
+                        	//not to package the fault bean. If there is a cache of generated
artifacts available then 
+                        	//lets look for the missing faultBean there.
+
+                        	//Support for Wrapper Bean Generation
+                        	//As per JAX-WS 2.2 Specificaiton section 3.6.2.1 pg 41 an application
programmer does not use
+                        	//the wrapper bean classes, so the application need not package
these classes. If we have reached
+                        	//this point in the code then user has choosen not to package these
beans.
+
+                        	//NOTE:If we find Generated artifacts from cache this guarantees
that we will not use
+                        	//DocLitWrappedMinimum marshaller code. The advantage of normal
DocLitWrappedMarshaller is
+                        	//that it is very robust and has support of lot more datatypes than
in DocLitWrappedMinimum.
+                        	if(log.isDebugEnabled()){
+                        		log.debug("Adding cache to classpath");
+                        	}
+                            if(log.isDebugEnabled()){
+                                log.debug("Adding cache to classpath");
+                            }
+                            ClassFinderFactory cff =
+                                (ClassFinderFactory)FactoryRegistry.getFactory(ClassFinderFactory.class);
+                            ClassFinder cf = cff.getClassFinder();
+                            String cachePath = (String)serviceDesc.getAxisConfigContext().getProperty(Constants.WS_CACHE);
+                            if(log.isDebugEnabled()){
+                                log.debug("cachePath = "+cachePath);
+                            }
+                            if(cachePath!=null){
+                                //lets add the cache to classpath and retry loading missing
artifacts.
+                                if(log.isDebugEnabled()){
+                                    log.debug("updating classpath with cache location");
+                                }
+                                cf.updateClassPath(cachePath, cl);
+                                if(log.isDebugEnabled()){
+                                    log.debug("trying to load class "+defaultValue+" from
cache.");
+                                }
+                                cls2=loadClassOrNull(defaultValue, cl);
+                            }
+                        }
+                    }  
+                }
+                
+                if (cls2 !=null) {
+                    cls2IsJAXB = isJAXB(cls2);
+                }
+                
+                // Choose the wrapper class
+                if (cls1 == null && cls2 == null) {
+                    if(log.isDebugEnabled()){
+                        log.debug("Could not find a wrapper class");
+                    }
+                    wrapperClass = null;
+                } else if (cls1 == null) {
+                    wrapperClass = cls2.getCanonicalName();
+                    if(log.isDebugEnabled()){
+                        log.debug("Choosing " + wrapperClass);
+                    }
+                } else if (cls2 == null) {
+                    wrapperClass = cls1.getCanonicalName();
+                    if(log.isDebugEnabled()){
+                        log.debug("Choosing " + wrapperClass);
+                    }
+                } else {
+                    if(log.isDebugEnabled()){
+                        log.debug("There are two classes that are present " + cls1 + " and
" + cls2);
+                    }
+                    // Choose the one that is JAXB enabled
+                    if (!cls1IsJAXB && !cls2IsJAXB) {
+                        // If neither is JAXB enabled.  Choose the one in the jaxws package.
+                        // This is the one most likely provided by tooling.
+                        if(log.isDebugEnabled()){
+                            log.debug("Neither are JAXB enabled. Choosing " + cls2);
+                        }
+                        wrapperClass = cls2.getCanonicalName();
+                    } else if (cls1IsJAXB && cls2IsJAXB) {
+                        // If both are JAXB enabled, choose the one in the non-JAXWS package.
+                        // This generally means that multiple tools generated the packages.
+                        // Choosing the one in the non-JAXWS package will avoid a JAXBContext
collision.
+                        if(log.isDebugEnabled()){
+                            log.debug("Both are JAXB enabled. Choosing " + cls1);
+                        }
+                        wrapperClass = cls1.getCanonicalName();
+                    } else if (cls1IsJAXB) {
+                        if(log.isDebugEnabled()){
+                            log.debug("Choosing " + cls1 + " because it is JAXB enabled");
+                        }
+                        wrapperClass = cls1.getCanonicalName();
+                    } else {
+                        if(log.isDebugEnabled()){
+                            log.debug("Choosing " + cls2 + " because it is JAXB enabled");
+                        }
+                        wrapperClass = cls2.getCanonicalName();
+                    }
+                }
+                
+            } 
+        } catch (Throwable t) {
+            if (log.isDebugEnabled()) {
+                log.debug("Unexpected error.  Processing continues. ", t);
+            }
+        } 
+        if (log.isDebugEnabled()) {
+            log.debug("exit getWrapperClass with " + wrapperClass);
+        }  
+        return wrapperClass;
+
+    }
+
+    private FaultBeanDesc create(EndpointDescription ed, FaultDescription faultDesc, OperationDescription
opDesc) {
+        /* FaultBeanClass algorithm
+         *   1) The class defined on @WebFault of the exception
+         *   2) If not present or invalid, the class defined by getFaultInfo.
+         *   3) If not present, the class is found using the default name and location
+         */
+        String declaringClassName = opDesc.getJavaDeclaringClassName();
+
+        String type = "@WebFault";
+        String faultBeanClassName = faultDesc.getFaultBean();
+        if (faultBeanClassName == null || faultBeanClassName.length() == 0) {
+            type = "faultInfo";
+            faultBeanClassName = faultDesc.getFaultInfo();
+        }
+        String foundClassName = getWrapperClass(type,
+            faultBeanClassName,
+            getPackageName(declaringClassName), 
+            getSimpleClassName(faultDesc.getExceptionClassName()) + "Bean",
+            ed.getAxisService().getClassLoader(),
+            serviceDesc);
+        if (foundClassName == null) {
+            faultBeanClassName = missingArtifact(faultBeanClassName);
+        }
+        if (foundClassName != null) {
+            faultBeanClassName = foundClassName;
+        }
+
+        /* Local NameAlgorithm:
+         *   1) The name defined on the @WebFault of the exception.
+         *   2) If not present, the name defined via the @XmlRootElement of the fault bean
class.
+         *   3) If not present, the <exceptionName>Bean
+         */
+        String faultBeanLocalName = faultDesc.getName();
+        if (faultBeanLocalName == null || faultBeanLocalName.length() == 0) {
+            if (faultBeanClassName != null && faultBeanClassName.length() > 0)
{
+                try {
+                    Class faultBean;
+                    try {
+                        faultBean = loadClass(faultBeanClassName, getContextClassLoader());
+                    } catch (ClassNotFoundException e){
+                        faultBean = loadClass(faultBeanClassName, ed.getAxisService().getClassLoader());
+                    }
+                    AnnotationDesc aDesc = AnnotationDescImpl.create(faultBean);
+                    if (aDesc.hasXmlRootElement()) {
+                        faultBeanLocalName = aDesc.getXmlRootElementName();
+                    }
+                } catch (Throwable t) {
+                    throw ExceptionFactory.makeWebServiceException(t);
+                }
+            }
+        }
+        if (faultBeanLocalName == null || faultBeanLocalName.length() == 0) {
+            faultBeanLocalName = getSimpleClassName(faultDesc.getExceptionClassName()) +
"Bean";
+        }
+
+        /* Algorithm for fault bean namespace
+         *   1) The namespace defined on the @WebFault of the exception.
+         *   2) If not present, the namespace defined via the @XmlRootElement of the class
name.
+         *   3) If not present, the namespace of the method's declared class + "/jaxws"
+         */
+        String faultBeanNamespace = faultDesc.getTargetNamespace();
+        if (faultBeanNamespace == null || faultBeanNamespace.length() == 0) {
+            if (faultBeanClassName != null && faultBeanClassName.length() > 0)
{
+                try {
+                    Class faultBean;
+                    try {
+                        faultBean = loadClass(faultBeanClassName, getContextClassLoader());
+                    } catch (ClassNotFoundException e){
+                        faultBean = loadClass(faultBeanClassName, ed.getAxisService().getClassLoader());
+                    }
+                    AnnotationDesc aDesc = AnnotationDescImpl.create(faultBean);
+                    if (aDesc.hasXmlRootElement()) {
+                        faultBeanNamespace = aDesc.getXmlRootElementNamespace();
+                    }
+                } catch (Throwable t) {
+                    throw ExceptionFactory.makeWebServiceException(t);
+                }
+            }
+        }
+        if (faultBeanNamespace == null || faultBeanNamespace.length() == 0) {
+            faultBeanNamespace = opDesc.getEndpointInterfaceDescription().getTargetNamespace();
+        }
+
+        return new FaultBeanDescImpl(
+            faultBeanClassName,
+            faultBeanLocalName,
+            faultBeanNamespace);
+    }
+
+    /**
+     * @param className
+     * @return package name
+     */
+    private static String getPackageName(String className) {
+        int index = className.lastIndexOf(".");
+        if (index <= 0) {
+            return "";
+        } else {
+            return className.substring(0, index);
+        }
+    }
+
+    /**
+     * @param className
+     * @return simple class name
+     */
+    private static String getSimpleClassName(String className) {
+        int index = className.lastIndexOf(".");
+        if (index <= 0) {
+            return className;
+        } else {
+            return className.substring(index + 1);
+        }
+    }
+
+    /**
+     * @param methodName
+     * @return method name converted into a class name
+     */
+    private static String javaMethodToClassName(String methodName) {
+        String className = null;
+        if (methodName != null) {
+            StringBuffer buildClassName = new StringBuffer(methodName);
+            buildClassName.replace(0, 1, methodName.substring(0, 1).toUpperCase());
+            className = buildClassName.toString();
+        }
+        return className;
+    }
+
+    /**
+     * This method is invoked if the artifact is missing
+     *
+     * @param artifactName
+     * @return newly constructed name or null
+     */
+    private String missingArtifact(String artifactName) {
+
+        if (log.isDebugEnabled()) {
+            log.debug("The following class was not found: " + artifactName + " Processing
continues without this class.");
+        }
+        return null;
+    }
+
+    /**
+     * @param className
+     * @param classLoader
+     * @return Class or Null
+     */
+    private static Class loadClassOrNull(String className, ClassLoader classLoader) {
+        try {
+            return loadClass(className, classLoader);
+        } catch (Throwable t) {
+            return null;
+        }  
+    }
+
+    private static Class loadClass(String className, ClassLoader classLoader) throws ClassNotFoundException
{
+        // Don't make this public, its a security exposure
+        return forName(className, true, classLoader);
+    }
+
+    /**
+     * Return the class for this name
+     *
+     * @return Class
+     */
+    private static Class forName(final String className, final boolean initialize,
+        final ClassLoader classloader) throws ClassNotFoundException {
+        // NOTE: This method must remain protected because it uses AccessController
+        Class cl = null;
+        try {
+            cl = (Class)AccessController.doPrivileged(
+                new PrivilegedExceptionAction() {
+                    public Object run() throws ClassNotFoundException {
+                        // Class.forName does not support primitives
+                        Class cls = ClassUtils.getPrimitiveClass(className);
+                        try{
+                            if (cls == null) {
+                                cls = Class.forName(className, initialize, classloader);
+                            }
+                            return cls;
+                            //Lets catch NoClassDefFoundError as its part of Throwable
+                            //Any Exception that extends Exception will be handled by doPriv
method.    
+                        } catch (NoClassDefFoundError e) {
+                            /**
+                             * In different jaxws scenarios, some classes may be missing.
 So it is normal behavior
+                             * to get to this point.  The exception is swallowed and a null
is returned.  
+                             * The exception is not logged...as this would give servicability
folks the idea that a problem occurred.
+                             */
+                        } 
+                        return cls;
+                    }
+                }
+            );
+        } catch (PrivilegedActionException e) {
+            /**
+             * In different jaxws scenarios, some classes may be missing.  So it is normal
behavior
+             * to get to this point. 
+             * The exception is not logged...as this would give servicability folks the idea
that a problem occurred.
+             */
+            throw (ClassNotFoundException)e.getException();
+        }
+
+        return cl;
+    }
+
+    /**
+     * Return the Method matching the method name or null
+     * @param methodName String containing method name
+     * @param cls Class of the class that declares the method
+     *
+     * @return Method or null
+     */
+    private static Method getMethod(final String methodName, final Class cls) {
+        // NOTE: This method must remain protected because it uses AccessController
+        Method method = null;
+        try {
+            method = (Method)AccessController.doPrivileged(
+                new PrivilegedExceptionAction() {
+                    public Object run()  {
+                        Method[] methods = cls.getMethods();
+                        if (methods != null) {
+                            for (int i=0; i<methods.length; i++) {
+                                if (methods[i].getName().equals(methodName)) {
+                                    return methods[i];
+                                }
+                            }
+                        }
+                        return null;
+                    }
+                }
+            );
+        } catch (PrivilegedActionException e) {
+
+        }
+
+        return method;
+    }
+
+    /** @return ClassLoader */
+    private static ClassLoader getContextClassLoader() {
+        // NOTE: This method must remain private because it uses AccessController
+        ClassLoader cl = null;
+        try {
+            cl = (ClassLoader)AccessController.doPrivileged(
+                new PrivilegedExceptionAction() {
+                    public Object run() throws ClassNotFoundException {
+                        return Thread.currentThread().getContextClassLoader();
+                    }
+                }
+            );
+        } catch (PrivilegedActionException e) {
+            if (log.isDebugEnabled()) {
+                log.debug("Exception thrown from AccessController: " + e);
+            }
+            throw (RuntimeException)e.getException();
+        }
+
+        return cl;
+    }
+    
+    /**
+     * @param cls
+     * @return true if cls appears to be a JAXB enabled class
+     */
+    private static boolean isJAXB(Class cls) {
+        // See if the object represents a root element
+        XmlRootElement root = (XmlRootElement)
+            getAnnotation(cls,XmlRootElement.class);
+        if (root != null) {
+            if (log.isDebugEnabled()) {
+                log.debug("isJAXB returns true due to presence of @XmlRootElement on " +
cls);
+            }
+            return true;
+        }
+        
+        // See if the object represents an type
+        XmlType type = (XmlType)
+            getAnnotation(cls,XmlType.class);
+        if (type != null) {
+            if (log.isDebugEnabled()) {
+                log.debug("isJAXB returns true due to presence of @XmlType on " + cls);
+            }
+            return true;
+        }
+        if (log.isDebugEnabled()) {
+            log.debug("isJAXB returns false for" + cls);
+        }
+        return false;
+    }
+    /**
+     * Get an annotation.  This is wrappered to avoid a Java2Security violation.
+     * @param cls Class that contains annotation 
+     * @param annotation Class of requested Annotation
+     * @return annotation or null
+     */
+    private static Annotation getAnnotation(final AnnotatedElement element, final Class annotation)
{
+        Annotation anno = null;
+        try {
+        anno = (Annotation) AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+                return element.getAnnotation(annotation);
+            }
+        });
+        } catch (Throwable t) {
+            if (log.isDebugEnabled()) {
+                log.debug("Problem occurred.  Continuing.  The problem is " + t);
+            }
+        }
+        return anno;
+    }
+}

Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
    svn:keywords = Date Revision

Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message