You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by ro...@apache.org on 2007/10/12 21:55:02 UTC
svn commit: r584248 [2/4] - in /webservices/axis2/trunk/java/modules:
codegen/src/org/apache/axis2/wsdl/codegen/ kernel/conf/
kernel/src/org/apache/axis2/ kernel/src/org/apache/axis2/deployment/
kernel/src/org/apache/axis2/deployment/repository/util/ k...
Added: webservices/axis2/trunk/java/modules/kernel/src/org/apache/axis2/wsdl/util/WSDLWrapperReloadImpl.java
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/java/modules/kernel/src/org/apache/axis2/wsdl/util/WSDLWrapperReloadImpl.java?rev=584248&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/kernel/src/org/apache/axis2/wsdl/util/WSDLWrapperReloadImpl.java (added)
+++ webservices/axis2/trunk/java/modules/kernel/src/org/apache/axis2/wsdl/util/WSDLWrapperReloadImpl.java Fri Oct 12 12:53:43 2007
@@ -0,0 +1,1320 @@
+/*
+ * 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.wsdl.util;
+
+import org.apache.axis2.java.security.AccessController;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.wsdl.Binding;
+import javax.wsdl.BindingFault;
+import javax.wsdl.BindingInput;
+import javax.wsdl.BindingOperation;
+import javax.wsdl.BindingOutput;
+import javax.wsdl.Definition;
+import javax.wsdl.Fault;
+import javax.wsdl.Import;
+import javax.wsdl.Input;
+import javax.wsdl.Message;
+import javax.wsdl.Operation;
+import javax.wsdl.Output;
+import javax.wsdl.Part;
+import javax.wsdl.Port;
+import javax.wsdl.PortType;
+import javax.wsdl.Service;
+import javax.wsdl.Types;
+import javax.wsdl.WSDLException;
+import javax.wsdl.extensions.ExtensibilityElement;
+import javax.wsdl.extensions.ExtensionRegistry;
+import javax.wsdl.factory.WSDLFactory;
+import javax.wsdl.xml.WSDLReader;
+import javax.xml.namespace.QName;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.URLConnection;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+
+/**
+ * This class provides support for processing a WSDL4J definition
+ * with a lower memory footprint. This is useful for certain
+ * environments.
+ */
+public class WSDLWrapperReloadImpl implements WSDLWrapperImpl {
+
+ private static final Log log = LogFactory.getLog(WSDLWrapperReloadImpl.class);
+ private static final boolean isDebugEnabled = log.isDebugEnabled();
+ private static final String myClassName = "WSDLWrapperReloadImpl";
+
+ // javax.wsdl.Definition implements java.io.Serializable
+ static final long serialVersionUID = -2788807375814097409L;
+
+ // the wsdl4j wsdl definition object that is being wrapped
+ private Definition wsdlDefinition = null;
+
+ // the location of the base document used in the wsdl4j definition
+ private URL wsdlURL = null;
+ private String wsdlExplicitURI = null;
+ private String wsdlDocumentBaseURI = null;
+
+ /**
+ * Constructor
+ *
+ * @param def The WSDL Definition
+ */
+ public WSDLWrapperReloadImpl(Definition def) {
+ prepare(def, null);
+ }
+
+
+ /**
+ * Constructor
+ *
+ * @param def The WSDL Definition
+ * @param wURL The URL for the wsdl
+ */
+ public WSDLWrapperReloadImpl(Definition def, URL wURL) {
+ prepare(def, wURL);
+ }
+
+
+ /**
+ * Initialize the wsdl definition wrapper
+ *
+ * @param def The WSDL4J definition
+ * @param wURL The URL where the WSDL is obtained
+ */
+ private void prepare(Definition def, URL wURL) {
+ wsdlDefinition = def;
+ wsdlURL = wURL;
+
+ if (def != null) {
+ try {
+ wsdlDocumentBaseURI = def.getDocumentBaseURI();
+
+ // build up the wsdlURL if possible
+ if ((wsdlURL == null) && (wsdlDocumentBaseURI != null)) {
+ try {
+ URL locURL = new URL(wsdlDocumentBaseURI);
+ wsdlURL = locURL;
+ } catch (Exception uex) {
+ // keep going
+ }
+ }
+
+ // get the explicit location of the wsdl if possible
+ if (wsdlURL != null) {
+ wsdlExplicitURI = getExplicitURI(wsdlURL);
+ }
+
+ // remove the types section
+ def.setTypes(null);
+
+ // remove the dom section
+ def.setDocumentationElement(null);
+
+ } catch (Exception e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".prepare(): Caught exception ["
+ + e.getClass().getName() + "] error [" + e.getMessage() + "]", e);
+ }
+ }
+ }
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".prepare(): wsdlDocumentBaseURI [" + wsdlDocumentBaseURI
+ + "] wsdlExplicitURI [" + wsdlExplicitURI + "] wsdlURL [" + wsdlURL + "]");
+ }
+
+ }
+
+
+ //-------------------------------------------------------------------------
+ // public WSDLWrapperImpl methods
+ //-------------------------------------------------------------------------
+
+ /*
+ * Releases objects to reduce memory footprint.
+ */
+ public void releaseResources() {
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setTypes(null);
+ wsdlDefinition.setDocumentationElement(null);
+ }
+ }
+
+
+ /*
+ * Returns the WSDL4J Definition object that is being wrapped
+ */
+ public Definition getUnwrappedDefinition() {
+ Definition def;
+ if (wsdlDefinition == null) {
+ try {
+ def = loadDefinition();
+ } catch (Exception e) {
+ // unable to load the definition
+ if (isDebugEnabled) {
+ log.debug(myClassName
+ + ".getUnwrappedDefinition(): error trying to load Definition ["
+ + e.getClass().getName() + "] error [" + e.getMessage() + "] ", e);
+ }
+ def = null;
+ }
+ } else if (wsdlDefinition instanceof WSDLWrapperBasicImpl) {
+ def = ((WSDLWrapperBasicImpl) wsdlDefinition).getUnwrappedDefinition();
+ } else {
+ // we should reinflate the WSDL when this method is called
+ try {
+ def = loadDefinition();
+ if(def == null) {
+ def = wsdlDefinition;
+ }
+ }
+ catch (Exception e) {
+ // unable to load the definition
+ if (isDebugEnabled) {
+ log.debug(myClassName
+ + ".getUnwrappedDefinition(): error trying to load Definition ["
+ + e.getClass().getName() + "] error [" + e.getMessage() + "] ", e);
+ }
+ def = wsdlDefinition;
+ }
+ }
+ return def;
+ }
+
+
+
+ /**
+ * Sets the WSDL4J Definition object that is being wrapped
+ *
+ * @param d the WSDL4J Definition object
+ */
+ public void setDefinitionToWrap(Definition d) {
+ wsdlDefinition = d;
+ }
+
+
+ /**
+ * Sets the location for the WSDL4J Definition object that is being wrapped
+ */
+ public void setWSDLLocation(String uriLocation) {
+ if (uriLocation != null) {
+ try {
+ wsdlURL = new URL(uriLocation);
+ }
+ catch (Exception e) {
+ // todo
+ }
+ }
+ }
+
+
+ /**
+ * Gets the location for the WSDL4J Definition object that is being wrapped
+ */
+ public String getWSDLLocation() {
+ if (wsdlURL != null) {
+ return wsdlURL.toString();
+ }
+ else {
+ return null;
+ }
+ }
+
+
+ /**
+ * Closes the use of the wrapper implementation and allows
+ * internal resources to be released.
+ */
+ public void close() {
+ // nothing to do for this implementation
+ }
+
+
+
+ //-------------------------------------------------------------------------
+ // javax.wsdl.Defintion interface methods
+ //-------------------------------------------------------------------------
+
+ public void setDocumentBaseURI(String d) {
+
+ // Set the URI of the base document for the Definition.
+ // This identifies the origin of the Definition and
+ // allows the Definition to be reloaded.
+ // Note that this is the URI of the base document, not the imports.
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setDocumentBaseURI(" + d + ")");
+ }
+
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setDocumentBaseURI(d);
+ }
+ }
+
+ public String getDocumentBaseURI() {
+
+ // Get the URI of the base document for the Definition.
+ // This identifies the origin of the Definition and
+ // allows the Definition to be reloaded.
+ // Note that this is the URI of the base document, not the imports.
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getDocumentBaseURI()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getDocumentBaseURI();
+ }
+ return null;
+ }
+
+ public void setQName(QName n) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setQName(" + n + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setQName(n);
+ }
+ }
+
+ public QName getQName() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getQName()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getQName();
+ }
+ return null;
+ }
+
+ public void setTargetNamespace(String t) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setTargetNamespace(" + t + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setTargetNamespace(t);
+ }
+ }
+
+ public String getTargetNamespace() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getTargetNamespace()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getTargetNamespace();
+ }
+ return null;
+ }
+
+ public void addNamespace(String prefix, String namespaceURI) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addNamespace(" + prefix + ", " + namespaceURI + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addNamespace(prefix, namespaceURI);
+ }
+ }
+
+ public String removeNamespace(String prefix) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeNamespace(" + prefix + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeNamespace(prefix);
+ }
+ return null;
+ }
+
+ public String getNamespace(String prefix) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getNamespace(" + prefix + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getNamespace(prefix);
+ }
+ return null;
+ }
+
+ public String getPrefix(String namespaceURI) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getPrefix(" + namespaceURI + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getPrefix(namespaceURI);
+ }
+ return null;
+ }
+
+ public Map getNamespaces() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getNamespaces()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getNamespaces();
+ }
+ return null;
+ }
+
+ public List getNativeAttributeNames() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getNativeAttributeNames()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getNativeAttributeNames();
+ }
+ return null;
+ }
+
+ public void setTypes(Types types) {
+
+ if (wsdlDefinition != null) {
+ // note: the wsdl definition implementation can't re-create the types
+ // after the types got set to null so the wsdl definition would
+ // need to be reloaded
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setTypes() from wsdl Definition");
+ }
+
+ wsdlDefinition.setTypes(types);
+
+ // TODO: should we keep the types object if it gets set?
+ wsdlDefinition.setTypes(null);
+ } else {
+ /*
+ // reload the wsdl definition object
+ // TODO: what about any online changes that have been made to the definition?
+
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setTypes() from reloaded wsdl Definition");
+ }
+
+ Definition def = null;
+ try {
+ def = loadDefinition();
+ }
+ catch (Exception e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setTypes(): error trying to load Definition ["+e.getClass().getName()+"] error ["+e.getMessage()+"] ", e);
+ }
+ }
+
+ if (def != null) {
+ def.setTypes(types);
+ }
+ else {
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setTypes(): nothing to set");
+ }
+ }
+ */
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setTypes(): nothing to set");
+ }
+ }
+ }
+
+
+ public Types getTypes() {
+
+ // reload the wsdl definition object
+ // TODO: what about any changes that have been made to the definition?
+
+ Definition def = null;
+ try {
+ def = loadDefinition();
+ } catch (Exception e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getTypes(): error trying to load Definition ["
+ + e.getClass().getName() + "] error [" + e.getMessage() + "] ", e);
+ }
+ }
+
+ if (def != null) {
+ Types t = def.getTypes();
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getTypes() from reloaded wsdl Definition returning [" + t
+ + "]");
+ }
+
+ return t;
+ } else {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getTypes() returning NULL");
+ }
+ return null;
+ }
+
+ }
+
+ public void addImport(Import importDef) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addImport(" + importDef + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addImport(importDef);
+ }
+ }
+
+ public Import removeImport(Import importDef) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeImport(" + importDef + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeImport(importDef);
+ }
+ return null;
+ }
+
+ public List getImports(String namespaceURI) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getImports(" + namespaceURI + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getImports(namespaceURI);
+ }
+ return null;
+ }
+
+ public Map getImports() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getImports()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getImports();
+ }
+ return null;
+ }
+
+ public void addMessage(Message message) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addMessage(" + message + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addMessage(message);
+ }
+ }
+
+ public Message getMessage(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getMessage(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getMessage(name);
+ }
+ return null;
+ }
+
+ public Message removeMessage(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeMessage(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeMessage(name);
+ }
+ return null;
+ }
+
+ public Map getMessages() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getMessages()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getMessages();
+ }
+ return null;
+ }
+
+ public void addBinding(Binding binding) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addBinding(" + binding + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addBinding(binding);
+ }
+ }
+
+ public Binding getBinding(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getBinding(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getBinding(name);
+ }
+ return null;
+ }
+
+ public Binding removeBinding(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeBinding(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeBinding(name);
+ }
+ return null;
+ }
+
+ public Map getBindings() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getBindings()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getBindings();
+ }
+ return null;
+ }
+
+ public Map getAllBindings() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getAllBindings()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getAllBindings();
+ }
+ return null;
+ }
+
+ public void addPortType(PortType portType) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addPortType(" + portType + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addPortType(portType);
+ }
+ }
+
+ public PortType getPortType(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getPortType(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getPortType(name);
+ }
+ return null;
+ }
+
+ public PortType removePortType(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removePortType(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removePortType(name);
+ }
+ return null;
+ }
+
+ public Map getPortTypes() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getPortTypes()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getPortTypes();
+ }
+ return null;
+ }
+
+ public Map getAllPortTypes() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getAllPortTypes()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getAllPortTypes();
+ }
+ return null;
+ }
+
+ public void addService(Service service) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addService(" + service + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addService(service);
+ }
+ }
+
+ public Service getService(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getService(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getService(name);
+ }
+ return null;
+ }
+
+ public Service removeService(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeService(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeService(name);
+ }
+ return null;
+ }
+
+ public Map getServices() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getServices()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getServices();
+ }
+ return null;
+ }
+
+ public Map getAllServices() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getAllServices()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getAllServices();
+ }
+ return null;
+ }
+
+ public void setDocumentationElement(org.w3c.dom.Element docEl) {
+
+ if (wsdlDefinition != null) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setDocumentationElement(docEl) from wsdl Definition");
+ }
+
+ // set the element in the definition
+ // don't make assumptions about what the implementation does
+ wsdlDefinition.setDocumentationElement(docEl);
+ // reset the element
+ wsdlDefinition.setDocumentationElement(null);
+ } else {
+ /*
+ // reload the wsdl definition object
+ // TODO: what about any online changes that have been made to the definition
+
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setDocumentationElement(docEl) from reloaded wsdl Definition");
+ }
+
+ Definition def = null;
+ try {
+ def = loadDefinition();
+ }
+ catch (Exception e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setDocumentationElement(docEl): error trying to load Definition ["+e.getClass().getName()+"] error ["+e.getMessage()+"] ", e);
+ }
+ }
+
+ if (def != null) {
+ def.setDocumentationElement(docEl);
+ }
+ else {
+ if (isDebugEnabled) {
+ log.debug(myClassName+".setDocumentationElement(docEl): nothing to set");
+ }
+ }
+ */
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setDocumentationElement(docEl): nothing to set");
+ }
+ }
+ }
+
+ public org.w3c.dom.Element getDocumentationElement() {
+
+ // reload the wsdl definition object
+ // TODO: what about any online changes that have been made to the definition?
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getDocumentationElement() from reloaded wsdl Definition");
+ }
+
+ Definition def = null;
+ try {
+ def = loadDefinition();
+ } catch (Exception e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName
+ + ".getDocumentationElement(): error trying to load Definition ["
+ + e.getClass().getName() + "] error [" + e.getMessage() + "] ", e);
+ }
+ }
+
+ if (def != null) {
+ org.w3c.dom.Element docElement = def.getDocumentationElement();
+
+ if (isDebugEnabled) {
+ if (docElement != null) {
+ log.debug(myClassName
+ + ".getDocumentationElement() from reloaded wsdl Definition returning NON-NULL org.w3c.dom.Element");
+ } else {
+ log.debug(myClassName
+ + ".getDocumentationElement() from reloaded wsdl Definition returning NULL org.w3c.dom.Element");
+ }
+ }
+ return docElement;
+ } else {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getDocumentationElement() returning NULL");
+ }
+ return null;
+ }
+ }
+
+ public void addExtensibilityElement(ExtensibilityElement extElement) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".addExtensibilityElement(" + extElement + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.addExtensibilityElement(extElement);
+ }
+ }
+
+ public List getExtensibilityElements() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExtensibilityElements()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getExtensibilityElements();
+ }
+ return null;
+ }
+
+ public Binding createBinding() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createBinding()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createBinding();
+ }
+ return null;
+ }
+
+ public BindingFault createBindingFault() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createBindingFault()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createBindingFault();
+ }
+ return null;
+ }
+
+ public BindingInput createBindingInput() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createBindingInput()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createBindingInput();
+ }
+ return null;
+ }
+
+ public BindingOperation createBindingOperation() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createBindingOperation()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createBindingOperation();
+ }
+ return null;
+ }
+
+ public BindingOutput createBindingOutput() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createBindingOutput()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createBindingOutput();
+ }
+ return null;
+ }
+
+ public Fault createFault() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createFault()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createFault();
+ }
+ return null;
+ }
+
+ public Import createImport() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createImport()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createImport();
+ }
+ return null;
+ }
+
+ public Input createInput() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createInput()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createInput();
+ }
+ return null;
+ }
+
+ public Message createMessage() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createMessage()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createMessage();
+ }
+ return null;
+ }
+
+ public Operation createOperation() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createOperation()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createOperation();
+ }
+ return null;
+ }
+
+ public Output createOutput() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createOutput()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createOutput();
+ }
+ return null;
+ }
+
+ public Part createPart() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createPart()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createPart();
+ }
+ return null;
+ }
+
+ public Port createPort() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createPort()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createPort();
+ }
+ return null;
+ }
+
+ public PortType createPortType() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createPortType()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createPortType();
+ }
+ return null;
+ }
+
+ public Service createService() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createService()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createService();
+ }
+ return null;
+ }
+
+ public Types createTypes() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".createTypes()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.createTypes();
+ }
+ return null;
+ }
+
+ public void setExtensionRegistry(ExtensionRegistry extReg) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setExtensionRegistry(" + extReg + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setExtensionRegistry(extReg);
+ }
+ }
+
+ public ExtensionRegistry getExtensionRegistry() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExtensionRegistry()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getExtensionRegistry();
+ }
+ return null;
+ }
+
+ public String toString() {
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.toString();
+ }
+ return "";
+ }
+
+ //-------------------------------------------------------------------------
+ // other AbstractWSDLElement methods
+ //-------------------------------------------------------------------------
+
+ public ExtensibilityElement removeExtensibilityElement(ExtensibilityElement extElement) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".removeExtensibilityElement(" + extElement + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.removeExtensibilityElement(extElement);
+ }
+ return null;
+
+ }
+
+ public java.lang.Object getExtensionAttribute(QName name) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExtensionAttribute(" + name + ")");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getExtensionAttribute(name);
+ }
+ return null;
+ }
+
+ public Map getExtensionAttributes() {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExtensionAttributes()");
+ }
+ if (wsdlDefinition != null) {
+ return wsdlDefinition.getExtensionAttributes();
+ }
+ return null;
+ }
+
+ public void setExtensionAttribute(QName name, java.lang.Object value) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".setExtensionAttribute(" + name + ", " + value + ")");
+ }
+ if (wsdlDefinition != null) {
+ wsdlDefinition.setExtensionAttribute(name, value);
+ }
+ }
+
+
+ //-------------------------------------------------------------------------
+ // private methods
+ //-------------------------------------------------------------------------
+
+
+ private String getExplicitURI(URL wsdlURL) throws WSDLException {
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + ") ");
+ }
+
+ String explicitURI = null;
+
+ ClassLoader classLoader =
+ (ClassLoader) AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ return Thread.currentThread().getContextClassLoader();
+ }
+ });
+
+ try {
+ URL url = wsdlURL;
+ String filePath = null;
+ boolean isFileProtocol =
+ (url != null && "file".equals(url.getProtocol())) ? true : false;
+
+ if (isFileProtocol) {
+ filePath = (url != null) ? url.getPath() : null;
+
+ URI uri = null;
+ if (url != null) {
+ uri = url.toURI();
+ }
+
+ // Check if the uri has relative path
+ // ie path is not absolute and is not starting with a "/"
+ boolean isRelativePath =
+ (filePath != null && !new File(filePath).isAbsolute()) ? true : false;
+
+ if (isRelativePath) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL
+ + "): WSDL URL has a relative path");
+ }
+
+ // Lets read the complete WSDL URL for relative path from class loader
+ // Use relative path of url to fetch complete URL.
+ url = getAbsoluteURL(classLoader, filePath);
+
+ if (url == null) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + "): "
+ + "WSDL URL for relative path not found in ClassLoader");
+ log.debug(myClassName
+ + ".getExplicitURI("
+ + wsdlURL
+ + "): "
+ + "Unable to read WSDL from relative path, check the relative path");
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + "): "
+ + "Relative path example: file:/WEB-INF/wsdl/<wsdlfilename>");
+ log.debug(myClassName
+ + ".getExplicitURI("
+ + wsdlURL
+ + "): "
+ + "Using relative path as default wsdl URL to load wsdl Definition.");
+ }
+ url = wsdlURL;
+ }
+ else {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + "): "
+ + "WSDL URL found for relative path: " + filePath + " scheme: "
+ + uri.getScheme());
+ }
+ }
+ }
+ }
+
+ URLConnection urlCon = url.openConnection();
+ InputStream is = null;
+ try {
+ is = getInputStream(urlCon);
+ } catch (IOException e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + "): "
+ + "Could not open url connection. Trying to use "
+ + "classloader to get another URL.");
+ }
+
+ if (filePath != null) {
+
+ url = getAbsoluteURL(classLoader, filePath);
+ if (url == null) {
+ if (log.isDebugEnabled()) {
+ log.debug("Could not locate URL for wsdl. Reporting error");
+ }
+ throw new WSDLException("WSDL4JWrapper : ", e.getMessage(), e);
+ } else {
+ urlCon = url.openConnection();
+ if (log.isDebugEnabled()) {
+ log.debug("Found URL for WSDL from jar");
+ }
+ }
+ } else {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".getExplicitURI(" + wsdlURL + "): "
+ + "Could not get URL from classloader. Reporting "
+ + "error due to no file path.");
+ }
+ throw new WSDLException("WSDLWrapperReloadImpl : ", e.getMessage(), e);
+ }
+ }
+ if (is != null) {
+ is.close();
+ }
+
+ explicitURI = urlCon.getURL().toString();
+
+ } catch (Exception ex) {
+ throw new WSDLException("WSDLWrapperReloadImpl : ", ex.getMessage(), ex);
+ }
+
+ return explicitURI;
+ }
+
+
+ private URL getAbsoluteURL(ClassLoader classLoader, String filePath) throws WSDLException {
+ URL url = classLoader.getResource(filePath);
+ if (url == null) {
+ if (log.isDebugEnabled()) {
+ log.debug("Could not get URL from classloader. Looking in a jar.");
+ }
+ if (classLoader instanceof URLClassLoader) {
+ URLClassLoader urlLoader = (URLClassLoader) classLoader;
+ url = getURLFromJAR(urlLoader, wsdlURL);
+ }
+ }
+ return url;
+ }
+
+ private Definition loadDefinition() throws WSDLException {
+
+ Definition def = null;
+
+ if (wsdlExplicitURI != null) {
+ try {
+ def = (Definition) AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws WSDLException {
+ WSDLReader reader = getWSDLReader();
+ return reader.readWSDL(wsdlExplicitURI);
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".loadDefinition(): "
+ + "Exception thrown from AccessController: " + e);
+ }
+ WSDLException we = new WSDLException("WSDLWrapperReloadImpl : ", e.getMessage(), e);
+ throw we;
+ }
+ }
+
+ if (isDebugEnabled) {
+ log.debug(myClassName + ".loadDefinition(): returning Definition [" + def + "]");
+ }
+
+ return def;
+ }
+
+ private URL getURLFromJAR(URLClassLoader urlLoader, URL relativeURL) throws WSDLException {
+
+ URL[] urlList = urlLoader.getURLs();
+
+ if (urlList == null) {
+ return null;
+ }
+
+ for (int i = 0; i < urlList.length; i++) {
+ URL url = urlList[i];
+
+ if (url == null) {
+ return null;
+ }
+
+ if ("file".equals(url.getProtocol())) {
+
+ File f = new File(url.getPath());
+
+ //If file is not of type directory then its a jar file
+ if (f.exists() && !f.isDirectory()) {
+ try {
+ JarFile jf = new JarFile(f);
+ Enumeration entries = jf.entries();
+ // read all entries in jar file and return the first
+ // wsdl file that matches the relative path
+ while (entries.hasMoreElements()) {
+ JarEntry je = (JarEntry) entries.nextElement();
+ String name = je.getName();
+ if (name.endsWith(".wsdl")) {
+ String relativePath = relativeURL.getPath();
+ if (relativePath.endsWith(name)) {
+ String path = f.getAbsolutePath();
+
+ // This check is necessary because Unix/Linux file paths begin
+ // with a '/'. When adding the prefix 'jar:file:/' we may end
+ // up with '//' after the 'file:' part. This causes the URL
+ // object to treat this like a remote resource
+ if (path != null && path.indexOf("/") == 0) {
+ path = path.substring(1, path.length());
+ }
+
+ URL absoluteUrl =
+ new URL("jar:file:/" + path + "!/" + je.getName());
+ return absoluteUrl;
+ }
+ }
+ }
+ } catch (Exception e) {
+ WSDLException we =
+ new WSDLException("WSDLWrapperReloadImpl : ", e.getMessage(), e);
+ throw we;
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Returns a wsdl reader for the wsdl
+ *
+ * @return WSDLReader
+ * @exception WSDLException
+ */
+ private WSDLReader getWSDLReader() throws WSDLException {
+ WSDLReader reader;
+ try {
+ reader = (WSDLReader) AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws WSDLException {
+ WSDLFactory factory = WSDLFactory.newInstance();
+ return factory.newWSDLReader();
+ }
+ });
+ } catch (PrivilegedActionException e) {
+ throw (WSDLException) e.getException();
+ }
+ // prevent system out from occurring
+ reader.setFeature(com.ibm.wsdl.Constants.FEATURE_VERBOSE, false);
+ return reader;
+ }
+
+
+ /**
+ * This method provides a Java2 Security compliant way to obtain the InputStream
+ * for a given URLConnection object. This is needed as a given URLConnection object
+ * may be an instance of a FileURLConnection object which would require access
+ * permissions if Java2 Security was enabled.
+ */
+ private InputStream getInputStream(URLConnection urlCon) throws Exception {
+ final URLConnection finalURLCon = urlCon;
+ InputStream is = null;
+ try {
+ is = (InputStream) AccessController.doPrivileged(
+ new PrivilegedExceptionAction() {
+ public Object run() throws IOException {
+ return finalURLCon.getInputStream();
+ }
+ });
+ }
+ catch(PrivilegedActionException e) {
+ throw e.getException();
+ }
+ return is;
+ }
+
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org