| /* |
| * 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.util; |
| |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.description.Parameter; |
| import org.apache.axis2.engine.AxisConfiguration; |
| import org.apache.axis2.java.security.AccessController; |
| import org.apache.axis2.jaxws.ExceptionFactory; |
| import org.apache.axis2.jaxws.catalog.JAXWSCatalogManager; |
| import org.apache.axis2.jaxws.catalog.impl.OASISCatalogManager; |
| import org.apache.axis2.jaxws.i18n.Messages; |
| import org.apache.axis2.jaxws.wsdl.WSDLReaderConfigurator; |
| import org.apache.axis2.metadata.factory.ResourceFinderFactory; |
| import org.apache.axis2.metadata.registry.MetadataFactoryRegistry; |
| import org.apache.axis2.metadata.resource.ResourceFinder; |
| import org.apache.axis2.wsdl.util.WSDLDefinitionWrapper; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| import javax.wsdl.Binding; |
| import javax.wsdl.BindingOperation; |
| import javax.wsdl.Definition; |
| import javax.wsdl.Port; |
| import javax.wsdl.Service; |
| import javax.wsdl.WSDLException; |
| import javax.wsdl.extensions.ExtensibilityElement; |
| import javax.wsdl.extensions.soap.SOAPOperation; |
| import javax.wsdl.factory.WSDLFactory; |
| import javax.wsdl.xml.WSDLReader; |
| import javax.xml.namespace.QName; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.ConnectException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.net.URLConnection; |
| import java.net.UnknownHostException; |
| import java.security.PrivilegedAction; |
| import java.security.PrivilegedActionException; |
| import java.security.PrivilegedExceptionAction; |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.jar.JarEntry; |
| import java.util.jar.JarFile; |
| |
| |
| /** |
| * Implementation of WSDLWrapper interface which controls access |
| * to the underlying Definition (WSDLDefinitionWrapper). |
| * The WSDLDefinitionWrapper implementation uses various strategies |
| * to control its in-memory footprint. |
| */ |
| public class WSDL4JWrapper implements WSDLWrapper { |
| private static final Log log = LogFactory.getLog(WSDL4JWrapper.class); |
| |
| private WSDLDefinitionWrapper wsdlDefinition = null; |
| |
| private URL wsdlURL; |
| private String wsdlExplicitURL; |
| private ConfigurationContext configContext; |
| private JAXWSCatalogManager catalogManager = null; |
| |
| // By default, use a reload strategy for the WSDLWrapper |
| private boolean limitMemory = true; |
| private int memoryType = 2; |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @deprecated Use a constructor that passes in the ConfigContext, or memoryLimit parameter |
| */ |
| public WSDL4JWrapper(URL wsdlURL) throws FileNotFoundException, UnknownHostException, |
| ConnectException, IOException, WSDLException { |
| super(); |
| this.commonPartsURLConstructor(wsdlURL, (ConfigurationContext)null); |
| } |
| |
| /** |
| * @param wsdlURL |
| * @param limitMemory true if memory should be limited |
| * @throws FileNotFoundException |
| * @throws UnknownHostException |
| * @throws ConnectException |
| * @throws IOException |
| * @throws WSDLException |
| */ |
| public WSDL4JWrapper(URL wsdlURL, boolean limitMemory, int memoryType) throws FileNotFoundException, UnknownHostException, |
| ConnectException, IOException, WSDLException { |
| super(); |
| this.limitMemory = limitMemory; |
| this.memoryType = memoryType; |
| this.commonPartsURLConstructor(wsdlURL, (ConfigurationContext)null); |
| } |
| |
| /** |
| * @param wsdlURL |
| * @param catalogManager |
| * @throws FileNotFoundException |
| * @throws UnknownHostException |
| * @throws ConnectException |
| * @throws IOException |
| * @throws WSDLException |
| * @deprecated use a constructor with a ConfigurationContext or limitMemory parameter |
| */ |
| public WSDL4JWrapper(URL wsdlURL, JAXWSCatalogManager catalogManager) throws FileNotFoundException, |
| UnknownHostException, ConnectException, IOException, WSDLException { |
| this(wsdlURL, catalogManager, false, 0); |
| } |
| |
| public WSDL4JWrapper(URL wsdlURL, JAXWSCatalogManager catalogManager, boolean limitMemory) throws FileNotFoundException, |
| UnknownHostException, ConnectException, IOException, WSDLException { |
| super(); |
| this.catalogManager = catalogManager; |
| this.limitMemory = limitMemory; |
| this.commonPartsURLConstructor(wsdlURL, (ConfigurationContext)null); |
| } |
| public WSDL4JWrapper(URL wsdlURL, JAXWSCatalogManager catalogManager, boolean limitMemory, int memoryType) throws FileNotFoundException, |
| UnknownHostException, ConnectException, IOException, WSDLException { |
| super(); |
| this.catalogManager = catalogManager; |
| this.limitMemory = limitMemory; |
| this.memoryType = memoryType; |
| this.commonPartsURLConstructor(wsdlURL, (ConfigurationContext)null); |
| } |
| |
| public WSDL4JWrapper(URL wsdlURL, ConfigurationContext configContext, |
| JAXWSCatalogManager catalogManager) throws FileNotFoundException, |
| UnknownHostException, ConnectException, IOException, WSDLException { |
| super(); |
| this.catalogManager = catalogManager; |
| this.commonPartsURLConstructor(wsdlURL, configContext); |
| } |
| |
| public WSDL4JWrapper(URL wsdlURL, ConfigurationContext configContext) throws FileNotFoundException, |
| UnknownHostException, ConnectException, IOException, WSDLException { |
| super(); |
| this.commonPartsURLConstructor(wsdlURL, configContext); |
| } |
| |
| private void commonPartsURLConstructor(URL wsdlURL, ConfigurationContext configContext) throws FileNotFoundException, UnknownHostException, |
| ConnectException, IOException, WSDLException { |
| this.configContext = configContext; |
| // debugMemoryParms(configContext); |
| if(log.isDebugEnabled()) { |
| log.debug("WSDL4JWrapper(URL,ConfigurationContext) - Looking for wsdl file on client: " + (wsdlURL != null ? |
| wsdlURL.getPath():null)); |
| } |
| ClassLoader classLoader = (ClassLoader) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| public Object run() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| }); |
| this.wsdlURL = wsdlURL; |
| |
| URLConnection urlCon; |
| try { |
| |
| urlCon = getPrivilegedURLConnection(this.wsdlURL); |
| |
| InputStream is = null; |
| |
| try { |
| is = getInputStream(urlCon); |
| } |
| catch(IOException e) { |
| if(log.isDebugEnabled()) { |
| log.debug("Could not open url connection. Trying to use " + |
| "classloader to get another URL."); |
| } |
| String filePath = wsdlURL != null ? wsdlURL.getPath() : null; |
| if(filePath != null) { |
| URL 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 = openConnection(url); |
| if(log.isDebugEnabled()) { |
| log.debug("Found URL for WSDL from jar"); |
| } |
| } |
| } |
| else { |
| if(log.isDebugEnabled()) { |
| log.debug("Could not get URL from classloader. Reporting " + |
| "error due to no file path."); |
| } |
| throw new WSDLException("WSDL4JWrapper : ", e.getMessage(), e); |
| } |
| } |
| if(is != null) { |
| is.close(); |
| } |
| this.wsdlExplicitURL = urlCon.getURL().toString(); |
| getDefinition(); |
| } catch (FileNotFoundException ex) { |
| throw ex; |
| } catch (UnknownHostException ex) { |
| throw ex; |
| } catch (ConnectException ex) { |
| throw ex; |
| } catch(IOException ex) { |
| throw ex; |
| } catch (Exception ex) { |
| throw new WSDLException("WSDL4JWrapper : ", ex.getMessage(), ex); |
| } |
| } |
| |
| /** |
| * This is a helper method to retrieve a URLConnection object |
| * based on a URL for the WSDL document. |
| */ |
| private URLConnection getURLConnection(URL url) throws IOException { |
| String filePath = null; |
| boolean isFileProtocol = |
| (url != null && "file".equals(url.getProtocol())) ? true : false; |
| if (isFileProtocol) { |
| filePath = (url != null) ? url.getPath() : null; |
| //Check is the uri has relative path i.e path is not absolute and is not starting with a "/" |
| boolean isRelativePath = |
| (filePath != null && !new File(filePath).isAbsolute()) ? true : false; |
| if (isRelativePath) { |
| if (log.isDebugEnabled()) { |
| log.debug("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(getThreadClassLoader(), filePath); |
| if (url == null) { |
| if (log.isDebugEnabled()) { |
| log.debug("WSDL URL for relative path not found in ClassLoader"); |
| log.warn( |
| "Unable to read WSDL from relative path, check the relative path"); |
| log.info("Relative path example: file:/WEB-INF/wsdl/<wsdlfilename>"); |
| log.warn( |
| "Using relative path as default wsdl URL to create wsdl Definition."); |
| } |
| url = wsdlURL; |
| } |
| else { |
| if(log.isDebugEnabled()) { |
| log.debug("WSDL URL found for relative path: " + filePath + " scheme: " + |
| url.getProtocol()); |
| } |
| } |
| } |
| } |
| URLConnection connection = null; |
| if(url != null) { |
| if(log.isDebugEnabled()) { |
| log.debug("Retrieving URLConnection from WSDL URL"); |
| } |
| connection = openConnection(url); |
| } |
| return connection; |
| } |
| |
| private URLConnection getPrivilegedURLConnection(final URL url) throws IOException { |
| try { |
| |
| return (URLConnection) AccessController.doPrivileged( new PrivilegedExceptionAction() { |
| public Object run() throws IOException { |
| return (getURLConnection(url)); |
| } |
| }); |
| |
| } catch (PrivilegedActionException e) { |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private URLConnection openConnection(final URL url) throws IOException { |
| try { |
| return (URLConnection) AccessController.doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws IOException { |
| return url.openConnection(); |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private ClassLoader getThreadClassLoader() { |
| return (ClassLoader) AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| }); |
| } |
| |
| private URL getAbsoluteURL(final ClassLoader classLoader, final String filePath){ |
| 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){ |
| final URLClassLoader urlLoader = (URLClassLoader)classLoader; |
| |
| url = (URL) AccessController.doPrivileged( new PrivilegedAction() { |
| public Object run() { |
| return (getURLFromJAR(urlLoader, wsdlURL)); |
| } |
| }); |
| |
| } |
| else { |
| final URLClassLoader nestedLoader = (URLClassLoader) getNestedClassLoader(URLClassLoader.class, classLoader); |
| if (nestedLoader != null) { |
| url = (URL) AccessController.doPrivileged( new PrivilegedAction() { |
| public Object run() { |
| return (getURLFromJAR(nestedLoader, wsdlURL)); |
| } |
| }); |
| } |
| } |
| } |
| return url; |
| } |
| |
| private ClassLoader getNestedClassLoader(Class type, ClassLoader root) { |
| if (log.isDebugEnabled()) { |
| log.debug("Searching for nested URLClassLoader"); |
| } |
| while (!(root instanceof URLClassLoader)) { |
| if (root == null) { |
| break; |
| } |
| |
| final ClassLoader current = root; |
| root = (ClassLoader) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| public Object run() { |
| return current.getParent(); |
| } |
| } |
| ); |
| if (log.isDebugEnabled() && root != null) { |
| log.debug("Checking parent ClassLoader: " + root.getClass().getName()); |
| } |
| } |
| |
| return root; |
| } |
| |
| private URL getURLFromJAR(URLClassLoader urlLoader, URL relativeURL) { |
| URL[] urlList = null; |
| ResourceFinderFactory rff =(ResourceFinderFactory)MetadataFactoryRegistry.getFactory(ResourceFinderFactory.class); |
| ResourceFinder cf = rff.getResourceFinder(); |
| if (log.isDebugEnabled()) { |
| log.debug("ResourceFinderFactory: " + rff.getClass().getName()); |
| log.debug("ResourceFinder: " + cf.getClass().getName()); |
| } |
| |
| urlList = cf.getURLs(urlLoader); |
| if(urlList == null){ |
| if(log.isDebugEnabled()){ |
| log.debug("No URL's found in URL ClassLoader"); |
| } |
| throw ExceptionFactory.makeWebServiceException(Messages.getMessage("WSDL4JWrapperErr1")); |
| } |
| |
| for (URL url : urlList) { |
| if ("file".equals(url.getProtocol())) { |
| final File f = new File(url.getPath()); |
| // If file is not of type directory then its a jar file |
| if (isAFile(f)) { |
| try { |
| JarFile jf = (JarFile) AccessController.doPrivileged( |
| new PrivilegedExceptionAction() { |
| public Object run() throws IOException { |
| return new JarFile(f); |
| } |
| } |
| ); |
| Enumeration<JarEntry> 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 = 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) { |
| throw ExceptionFactory.makeWebServiceException(e); |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private boolean isAFile(final File f) { |
| Boolean ret = (Boolean) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| public Object run() { |
| return new Boolean(f.exists() && !f.isDirectory()); |
| } |
| } |
| ); |
| return ret.booleanValue(); |
| } |
| |
| private static WSDLReader getWSDLReader() throws WSDLException { |
| // Keep this method private |
| 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(); |
| } |
| WSDLReaderConfigurator configurator = (WSDLReaderConfigurator) MetadataFactoryRegistry. |
| getFactory(WSDLReaderConfigurator.class); |
| if(configurator != null) { |
| if(log.isDebugEnabled()) { |
| log.debug("Calling configureReaderInstance with: " + configurator.getClass().getName()); |
| } |
| configurator.configureReaderInstance(reader); |
| } |
| return reader; |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @deprecated Use a constructor that has a ConfigContext or memoryLimit parameter |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, null, null); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @param ConfigurationContext |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, |
| ConfigurationContext configContext) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, configContext, null); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @param limitMemory boolean |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, boolean limitMemory, int memoryType) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, null, null, limitMemory, memoryType); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @param JAXWSCatalogManager Catalog Manager to use for locating external resources |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, |
| JAXWSCatalogManager catalogManager, |
| boolean limitMemory, int memoryType) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, null, catalogManager, limitMemory, memoryType); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @param JAXWSCatalogManager Catalog Manager to use for locating external resources |
| * @deprecated Use a constructor with a ConfigurationContext or memory limit setting |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, JAXWSCatalogManager catalogManager) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, null, catalogManager, false, 0); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param URL The URL for the WSDL |
| * @param Definition Definition for the WSDL |
| * @param ConfigurationContext to get parameters for WSDL building |
| * @param JAXWSCatalogManager Catalog Manager to use for locating external resources |
| */ |
| public WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, ConfigurationContext configContext, |
| JAXWSCatalogManager catalogManager) throws WSDLException { |
| this(wsdlURL, wsdlDefinition, configContext, catalogManager, false, 0); |
| } |
| |
| /** |
| * Full Constructor |
| */ |
| private WSDL4JWrapper(URL wsdlURL, Definition wsdlDefinition, ConfigurationContext configContext, |
| JAXWSCatalogManager catalogManager, boolean limitMemory, int memoryType) throws WSDLException { |
| super(); |
| if (log.isDebugEnabled() ) { log.debug("WSDL4JWrapper(...) entry"); } |
| |
| this.configContext = configContext; |
| this.catalogManager = catalogManager; |
| this.wsdlURL = wsdlURL; |
| this.limitMemory = limitMemory; // Only used if configContext is not present |
| this.memoryType = memoryType; |
| if ((wsdlDefinition != null) && !(wsdlDefinition instanceof WSDLDefinitionWrapper)) { |
| if (configContext != null && configContext.getAxisConfiguration() != null) { |
| this.wsdlDefinition = |
| new WSDLDefinitionWrapper(wsdlDefinition, wsdlURL, |
| configContext.getAxisConfiguration() ); |
| } else { |
| this.wsdlDefinition = |
| new WSDLDefinitionWrapper(wsdlDefinition, wsdlURL, |
| limitMemory, 2); |
| } |
| } else { |
| this.wsdlDefinition = (WSDLDefinitionWrapper) wsdlDefinition; |
| } |
| } |
| |
| |
| /** |
| * Constructor |
| * |
| * @param Definition Definition for the WSDL |
| * @deprecated Use WSDL4JWrapper(Definition,ConfigurationContext) |
| */ |
| public WSDL4JWrapper(Definition wsdlDefinition) throws WSDLException { |
| this(wsdlDefinition, false, 0); |
| |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param Definition Definition for the WSDL |
| * @boolean limitMemory |
| */ |
| public WSDL4JWrapper(Definition wsdlDefinition, boolean limitMemory, int memoryType) throws WSDLException { |
| if (log.isDebugEnabled() ) { log.debug("WSDL4JWrapper(Definition, boolean) entry"); } |
| |
| this.limitMemory = limitMemory; |
| this.memoryType = memoryType; |
| if ((wsdlDefinition != null) && !(wsdlDefinition instanceof WSDLDefinitionWrapper)) { |
| this.wsdlDefinition = new WSDLDefinitionWrapper(wsdlDefinition, null, limitMemory, memoryType); |
| } else { |
| this.wsdlDefinition = (WSDLDefinitionWrapper) wsdlDefinition; |
| } |
| |
| if (this.wsdlDefinition != null) { |
| String baseURI = wsdlDefinition.getDocumentBaseURI(); |
| try { |
| wsdlURL = new URL(baseURI); |
| } catch (Exception ex) { |
| // just absorb the error |
| } |
| } |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param Definition Definition for the WSDL |
| * @param ConfigurationContext |
| */ |
| public WSDL4JWrapper(Definition wsdlDefinition, |
| ConfigurationContext configContext) throws WSDLException { |
| super(); |
| if (log.isDebugEnabled() ) { log.debug("WSDL4JWrapper(Definition) entry"); } |
| |
| if ((wsdlDefinition != null) && !(wsdlDefinition instanceof WSDLDefinitionWrapper)) { |
| this.wsdlDefinition = new WSDLDefinitionWrapper(wsdlDefinition, configContext.getAxisConfiguration()); |
| } else { |
| this.wsdlDefinition = (WSDLDefinitionWrapper) wsdlDefinition; |
| } |
| |
| if (this.wsdlDefinition != null) { |
| String baseURI = wsdlDefinition.getDocumentBaseURI(); |
| try { |
| wsdlURL = new URL(baseURI); |
| } catch (Exception ex) { |
| // just absorb the error |
| } |
| } |
| } |
| //TODO: Perform validations for each method to check for null parameters on QName. |
| |
| /* |
| * Returns a wrapped WSDL4J wSDL definition |
| */ |
| public Definition getDefinition() { |
| if (wsdlDefinition == null) { |
| Definition def = loadDefinition(); |
| if (def != null) { |
| if (configContext != null) { |
| wsdlDefinition = new WSDLDefinitionWrapper(def, configContext.getAxisConfiguration() ); |
| } else { |
| wsdlDefinition = new WSDLDefinitionWrapper(def, wsdlURL, limitMemory, memoryType); |
| } |
| } |
| } |
| return wsdlDefinition; |
| } |
| |
| /* |
| * Returns an unwrapped WSDL4J wSDL definition |
| */ |
| public Definition getUnwrappedDefinition() { |
| Definition def; |
| if (wsdlDefinition == null) { |
| def = loadDefinition(); |
| } else if (wsdlDefinition instanceof WSDLDefinitionWrapper) { |
| def = wsdlDefinition.getUnwrappedDefinition(); |
| } else { |
| def = wsdlDefinition; |
| } |
| return def; |
| } |
| |
| |
| /* |
| * Load a WSDL4J WSDL definition from a URL |
| */ |
| public Definition loadDefinition() { |
| |
| Definition def = null; |
| |
| if (wsdlExplicitURL != null) { |
| try { |
| |
| URLConnection urlConn = getPrivilegedURLConnection(this.wsdlURL); |
| if(urlConn != null) { |
| try { |
| InputStream is = getInputStream(urlConn); |
| if(is != null) { |
| if (catalogManager == null) { |
| catalogManager = new OASISCatalogManager(); |
| } |
| final CatalogWSDLLocator locator = new CatalogWSDLLocator(wsdlExplicitURL, is, |
| getThreadClassLoader(), catalogManager); |
| if(log.isDebugEnabled()) { |
| log.debug("Loading WSDL using ModuleWSDLLocator from base " + |
| "location: " + wsdlExplicitURL); |
| } |
| def = (Definition) AccessController.doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws WSDLException { |
| WSDLReader reader = getWSDLReader(); |
| return reader.readWSDL(locator); |
| } |
| }); |
| } |
| } |
| catch(Exception e) { |
| if(log.isDebugEnabled()) { |
| log.debug("Using ModuleWSDLLocator was not successful for loading " + |
| "WSDL due to the following error: " + e.toString() + ". The " + |
| "WSDL will be read from the WSDL location: " + wsdlExplicitURL); |
| } |
| } |
| } |
| if(def == null) { |
| if(log.isDebugEnabled()) { |
| log.debug("Loading WSDL from location: " + wsdlExplicitURL); |
| } |
| def = (Definition) AccessController.doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws WSDLException { |
| WSDLReader reader = getWSDLReader(); |
| return reader.readWSDL(wsdlExplicitURL); |
| } |
| }); |
| } |
| |
| } catch (PrivilegedActionException e) { |
| if (log.isDebugEnabled()) { |
| log.debug("Exception thrown from AccessController: " + e); |
| } |
| throw ExceptionFactory.makeWebServiceException(e.getException()); |
| } |
| catch(IOException ioe) { |
| if(log.isDebugEnabled()) { |
| log.debug("An error occurred while attempting to load the WSDL " + |
| "file at the following location: " + wsdlExplicitURL); |
| } |
| throw ExceptionFactory.makeWebServiceException(ioe); |
| } |
| } |
| |
| |
| if (log.isDebugEnabled()) { |
| if (def != null) { |
| log.debug("loadDefinition() returning a NON-NULL definition"); |
| } else { |
| log.debug("loadDefinition() returning a NULL definition"); |
| } |
| } |
| |
| return def; |
| } |
| |
| public Binding getFirstPortBinding(QName serviceQname) { |
| Service service = getService(serviceQname); |
| if (service == null) { |
| return null; |
| } |
| Map map = getService(serviceQname).getPorts(); |
| if (map == null || map.isEmpty()) { |
| return null; |
| } |
| for (Object listObject : map.values()) { |
| Port wsdlPort = (Port)listObject; |
| return wsdlPort.getBinding(); |
| |
| } |
| return null; |
| |
| } |
| |
| public String getOperationName(QName serviceQname, QName portQname) { |
| Port port = getPort(serviceQname, portQname); |
| Binding binding = port.getBinding(); |
| if (binding == null) { |
| return null; |
| } |
| |
| List operations = binding.getBindingOperations(); |
| for (Object opObj : operations) { |
| BindingOperation operation = (BindingOperation)opObj; |
| return operation.getName(); |
| } |
| return null; |
| } |
| |
| private Port getPort(QName serviceQname, QName eprQname) { |
| Service service = getService(serviceQname); |
| if (service == null) { |
| return null; |
| } |
| return service.getPort(eprQname.getLocalPart()); |
| |
| } |
| |
| public ArrayList getPortBinding(QName serviceQname) { |
| Map map = this.getService(serviceQname).getPorts(); |
| if (map == null || map.isEmpty()) { |
| return null; |
| } |
| ArrayList<Binding> portBindings = new ArrayList<Binding>(); |
| for (Object listObject : map.values()) { |
| Port wsdlPort = (Port)listObject; |
| Binding binding = wsdlPort.getBinding(); |
| if (binding != null) { |
| portBindings.add(binding); |
| } |
| |
| } |
| return portBindings; |
| |
| } |
| |
| public String getPortBinding(QName serviceQname, QName portQname) { |
| Port port = getPort(serviceQname, portQname); |
| if (port == null) { |
| return null; |
| } |
| Binding binding = port.getBinding(); |
| return binding.getQName().getLocalPart(); |
| } |
| |
| public String[] getPorts(QName serviceQname) { |
| String[] portNames = null; |
| Service service = this.getService(serviceQname); |
| if (service == null) { |
| return null; |
| } |
| Map map = service.getPorts(); |
| if (map == null || map.isEmpty()) { |
| return null; |
| } |
| portNames = new String[map.values().size()]; |
| Iterator iter = map.values().iterator(); |
| for (int i = 0; iter.hasNext(); i++) { |
| Port wsdlPort = (Port)iter.next(); |
| if (wsdlPort != null) { |
| portNames[i] = wsdlPort.getName(); |
| } |
| } |
| return portNames; |
| } |
| |
| public Service getService(QName serviceQname) { |
| if (serviceQname == null) { |
| return null; |
| } |
| |
| Definition def = getDefinition(); |
| if (def != null) { |
| return def.getService(serviceQname); |
| } else { |
| return null; |
| } |
| } |
| |
| public String getSOAPAction(QName serviceQname) { |
| Binding binding = getFirstPortBinding(serviceQname); |
| if (binding == null) { |
| return null; |
| } |
| List operations = binding.getBindingOperations(); |
| for (Object opObj : operations) { |
| BindingOperation operation = (BindingOperation)opObj; |
| List exElements = operation.getExtensibilityElements(); |
| for (Object elObj : exElements) { |
| ExtensibilityElement exElement = (ExtensibilityElement)elObj; |
| if (isSoapOperation(exElement)) { |
| SOAPOperation soapOperation = (SOAPOperation)exElement; |
| return soapOperation.getSoapActionURI(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public String getSOAPAction(QName serviceQname, QName portQname) { |
| Port port = getPort(serviceQname, portQname); |
| if (port == null) { |
| return null; |
| } |
| Binding binding = port.getBinding(); |
| if (binding == null) { |
| return null; |
| } |
| List operations = binding.getBindingOperations(); |
| for (Object opObj : operations) { |
| BindingOperation operation = (BindingOperation)opObj; |
| List exElements = operation.getExtensibilityElements(); |
| for (Object elObj : exElements) { |
| ExtensibilityElement exElement = (ExtensibilityElement)elObj; |
| if (isSoapOperation(exElement)) { |
| SOAPOperation soapOperation = (SOAPOperation)exElement; |
| return soapOperation.getSoapActionURI(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public String getSOAPAction(QName serviceQname, QName portQname, QName operationQname) { |
| Port port = getPort(serviceQname, portQname); |
| if (port == null) { |
| return null; |
| } |
| Binding binding = port.getBinding(); |
| if (binding == null) { |
| return null; |
| } |
| List operations = binding.getBindingOperations(); |
| if (operations == null) { |
| return null; |
| } |
| BindingOperation operation = null; |
| for (Object opObj : operations) { |
| operation = (BindingOperation)opObj; |
| } |
| List exElements = operation.getExtensibilityElements(); |
| for (Object elObj : exElements) { |
| ExtensibilityElement exElement = (ExtensibilityElement)elObj; |
| if (isSoapOperation(exElement)) { |
| SOAPOperation soapOperation = (SOAPOperation)exElement; |
| if (soapOperation.getElementType().equals(operationQname)) { |
| return soapOperation.getSoapActionURI(); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| public URL getWSDLLocation() { |
| return this.wsdlURL; |
| } |
| |
| private boolean isSoapOperation(ExtensibilityElement exElement) { |
| return WSDLWrapper.SOAP_11_OPERATION.equals(exElement.getElementType()); |
| //TODO: Add Soap12 support later |
| // || WSDLWrapper.SOAP_12_OPERATION.equals(exElement.getElementType()); |
| } |
| |
| public String getTargetNamespace() { |
| Definition def = getDefinition(); |
| if (def != null) { |
| return def.getTargetNamespace(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * 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; |
| } |
| |
| private void debugMemoryParms(ConfigurationContext configContext) { |
| if (configContext != null) { |
| AxisConfiguration axisCfg = configContext.getAxisConfiguration(); |
| |
| boolean reduceWSDLMemoryCache = false; |
| int reduceWSDLMemoryType = 9; |
| // determine what the setting for the memory optimization is |
| if (axisCfg != null) { |
| Parameter param = axisCfg.getParameter(Constants.Configuration.REDUCE_WSDL_MEMORY_CACHE); |
| |
| reduceWSDLMemoryCache = |
| param != null && ((String) param.getValue()).equalsIgnoreCase("true"); |
| |
| |
| param = axisCfg.getParameter(Constants.Configuration.REDUCE_WSDL_MEMORY_TYPE); |
| |
| if (param != null) { |
| String value = (String) param.getValue(); |
| |
| if (value != null) { |
| Integer i = new Integer(value); |
| reduceWSDLMemoryType = i.intValue(); |
| } |
| } |
| log.debug("reduceWSDLMemoryCache:"+ reduceWSDLMemoryCache + ", reduceWSDLMemoryType:" + reduceWSDLMemoryType ); |
| } else { |
| log.debug("AxisConfiguration is null"); |
| } |
| } else { |
| log.debug("ConfigContext is null"); |
| } |
| } |
| |
| } |
