Java tutorial
/* * 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.axis2.util.JavaUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.w3c.dom.Element; 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.lang.ref.SoftReference; 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. * * The Type and Documentation objects consume the most space * in many scenarios. This implementation reloads these objects * when then they are requested. */ 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; // The wsdlDefinition always has the Types and DocumentElement // purged from it. // If USE_SOFT_REFERENCES is true, then we keep a SOFT reference // to these objects. // If USE_SOFT_REFERENCES is false, then a loadDefinition is always // performed to get the Type or DocumentationElement private static boolean USE_SOFT_REFERENCES = true; private transient SoftReference softTypes = null; private transient SoftReference softDocElement = null; /** * Constructor * The WSDL Defintion object is owned by the WSDLWrapperReloadImpl object. * * @param def The WSDL Definition */ public WSDLWrapperReloadImpl(Definition def) { if (log.isDebugEnabled()) { log.debug("WSDLWrapperReloadImpl(Definition def) called"); log.trace(JavaUtils.callStackToString()); } prepare(def, null); } /** * Constructor * The WSDL Defintion object is owned by the WSDLWrapperReloadImpl object. * * @param def The WSDL Definition * @param wURL The URL for the wsdl */ public WSDLWrapperReloadImpl(Definition def, URL wURL) { if (log.isDebugEnabled()) { log.debug("WSDLWrapperReloadImpl(Definition def, URL wURL) called"); log.trace(JavaUtils.callStackToString()); } prepare(def, wURL); } public static boolean isReloadable(Definition def, URL wURL) { if (isDebugEnabled) { log.debug("Enter " + myClassName + ".isReloadable(): " + wURL); } String explicitURI = null; if (def != null) { try { String documentBaseURI = def.getDocumentBaseURI(); // build up the wURL if possible if ((wURL == null) && (documentBaseURI != null)) { wURL = new URL(documentBaseURI); } // get the explicit location of the wsdl if possible if (wURL != null) { explicitURI = getExplicitURI(wURL); } } catch (Exception e) { if (isDebugEnabled) { log.debug(myClassName + ".isReloaded(): [" + e.getClass().getName() + "] error [" + e.getMessage() + "]", e); log.debug("Processing continues."); } } } // Return true if explicitURI is available if (isDebugEnabled) { log.debug(" explicitURI=" + explicitURI); } boolean rc = explicitURI != null && explicitURI.length() > 0; if (isDebugEnabled) { log.debug("Exit " + myClassName + ".isReloadable(): " + rc); } return rc; } /** * 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) { if (isDebugEnabled) { log.debug(myClassName + ".prepare()"); } 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); } // Release the Types and DocumentationElement Resources releaseResources(); } 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 Type and DocumentElement Resources */ public void releaseResources() { if (wsdlDefinition != null) { Types types = wsdlDefinition.getTypes(); if (types != null) { wsdlDefinition.setTypes(null); } this.setCachedTypes(types); Element element = wsdlDefinition.getDocumentationElement(); if (element != null) { wsdlDefinition.setDocumentationElement(null); } this.setCachedDocElement(element); } } /** * Store the cached type. Since this is a SOFT reference, * the gc may remove it. * @param types */ private void setCachedTypes(Types types) { if (USE_SOFT_REFERENCES) { if (softTypes == null || softTypes.get() == null) { if (types != null) { softTypes = new SoftReference(types); } else { // The wsdl has no types softTypes = new SoftReference(Boolean.FALSE); } } } } /** * Get the cached type. Since this is a SOFT reference, * the gc may remove it. * @return types */ private Types getCachedTypes() { if (USE_SOFT_REFERENCES) { if (softTypes == null || softTypes.get() == null) { return null; } else if (softTypes.get().equals(Boolean.FALSE)) { // The wsdl has no types return null; } else { return (Types) softTypes.get(); } } else { return null; } } private boolean hasCachedTypes() { if (USE_SOFT_REFERENCES) { return (softTypes != null && softTypes.get() != null); } else { return false; } } /** * Store the cached document element. Since this is a SOFT reference, * the gc may remove it. * @param e Element */ private void setCachedDocElement(Element e) { if (USE_SOFT_REFERENCES) { if (softDocElement == null || softDocElement.get() == null) { if (e != null) { softDocElement = new SoftReference(e); } else { // The wsdl has no document element softDocElement = new SoftReference(Boolean.FALSE); } } } } /** * Get the cached type. Since this is a SOFT reference, * the gc may remove it. * @return types */ private Element getCachedDocElement() { if (USE_SOFT_REFERENCES) { if (softDocElement == null || softDocElement.get() == null) { return null; } else if (softDocElement.get().equals(Boolean.FALSE)) { // The wsdl has no document element return null; } else { return (Element) softDocElement.get(); } } else { return null; } } private boolean hasCachedDocElement() { if (USE_SOFT_REFERENCES) { return (softDocElement != null && softDocElement.get() != null); } else { return false; } } /* * Returns a full, reloaded,WSDL4J Definition object. * This avoids the memory saving capabilities of this wrapper. * The caller must not save the returned defintion. * @return Defintion */ public Definition getUnwrappedDefinition() { Definition def; if (wsdlDefinition == null) { // If no definiotn, load one 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) { // If wrapping another wrapper, then delegate def = ((WSDLWrapperBasicImpl) wsdlDefinition).getUnwrappedDefinition(); } else { // The question is whether a new WSDLDefinition should be loaded and // returned or whether the existing definition (w/o the Type // and DocumentElement) should be returned. // // The answer is to reload the WSDLDefinition and provide the new // one without affecting the existing WSDLDefintion that is stored. // The onus is on the caller to free this new WSDLDefinition and // not hold onto it. If the calller wants memory saving // capabilities, then the caller should be using this wrapper directly. 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() { if (isDebugEnabled) { log.trace(myClassName + ".getTypes() call stack =" + JavaUtils.callStackToString()); } // See if we have a soft reference to the Type if (hasCachedTypes()) { Types t = getCachedTypes(); if (isDebugEnabled) { log.debug(myClassName + ".getTypes() from soft reference [" + t + "]"); } return t; } // 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(); setCachedTypes(t); setCachedDocElement(def.getDocumentationElement()); 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() { if (isDebugEnabled) { log.trace(myClassName + ".getDocumentationElement() call stack =" + JavaUtils.callStackToString()); } // See if we have a soft reference to the DocumentElement if (hasCachedDocElement()) { Element e = getCachedDocElement(); if (log.isDebugEnabled()) { log.debug(myClassName + ".getDocumentationElement() from soft reference "); } return e; } // 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(); setCachedDocElement(docElement); setCachedTypes(def.getTypes()); 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 this.getClass().getName() + "\n" + wsdlDefinition.toString(); } return this.getClass().getName(); } //------------------------------------------------------------------------- // 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 static 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 = new URI(url.toString()); } // 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, wsdlURL); 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, wsdlURL); 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 static URL getAbsoluteURL(final ClassLoader classLoader, final String filePath, URL wURL) throws WSDLException { URL url = (URL) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return 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, wURL); } } return url; } /** * Load and Return a Definition object. * (The caller will determine if the Definition object should have * its resources freed or not) * @return Definition * @throws WSDLException */ 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); log.trace("Call Stack = " + JavaUtils.callStackToString()); } WSDLException we = new WSDLException("WSDLWrapperReloadImpl : ", e.getMessage(), e); throw we; } } // Loading the wsdl is expensive. Dump the callstack.. so that we // support can look at the trace and determine if this class is being used incorrectly. if (isDebugEnabled) { log.debug(myClassName + ".loadDefinition(): returning Definition [" + def + "]"); log.trace("Call Stack = " + JavaUtils.callStackToString()); } return def; } private static 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 static 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; } }