| /* |
| * 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.deployment.util; |
| |
| import org.apache.axiom.om.OMAbstractFactory; |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axiom.om.OMFactory; |
| import org.apache.axiom.soap.SOAP11Constants; |
| import org.apache.axiom.soap.SOAP12Constants; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.jaxrs.JAXRSModel; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.deployment.DeploymentClassLoader; |
| import org.apache.axis2.deployment.DeploymentConstants; |
| import org.apache.axis2.deployment.DeploymentErrorMsgs; |
| import org.apache.axis2.deployment.DeploymentException; |
| import org.apache.axis2.deployment.repository.util.ArchiveReader; |
| import org.apache.axis2.deployment.repository.util.DeploymentFileData; |
| import org.apache.axis2.description.*; |
| import org.apache.axis2.description.java2wsdl.DefaultSchemaGenerator; |
| import org.apache.axis2.description.java2wsdl.DocLitBareSchemaGenerator; |
| import org.apache.axis2.description.java2wsdl.Java2WSDLConstants; |
| import org.apache.axis2.description.java2wsdl.SchemaGenerator; |
| import org.apache.axis2.engine.AxisConfiguration; |
| import org.apache.axis2.engine.Handler; |
| import org.apache.axis2.engine.MessageReceiver; |
| import org.apache.axis2.i18n.Messages; |
| import org.apache.axis2.util.JavaUtils; |
| import org.apache.axis2.util.Loader; |
| import org.apache.axis2.util.PolicyUtil; |
| import org.apache.axis2.util.FaultyServiceData; |
| import org.apache.axis2.wsdl.WSDLConstants; |
| import org.apache.axis2.wsdl.WSDLUtil; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.neethi.PolicyComponent; |
| import org.apache.ws.commons.schema.utils.NamespaceMap; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.FactoryConfigurationError; |
| import javax.xml.stream.XMLStreamException; |
| import java.io.*; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.net.URLClassLoader; |
| import java.net.URLDecoder; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.security.PrivilegedActionException; |
| import java.security.PrivilegedExceptionAction; |
| import java.util.*; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| public class Utils { |
| |
| public static String defaultEncoding = new OutputStreamWriter(System.out).getEncoding(); |
| |
| private static Log log = LogFactory.getLog(Utils.class); |
| |
| public static void addFlowHandlers(Flow flow, ClassLoader clsLoader) |
| throws AxisFault { |
| int count = flow.getHandlerCount(); |
| |
| for (int j = 0; j < count; j++) { |
| HandlerDescription handlermd = flow.getHandler(j); |
| Handler handler; |
| |
| final Class handlerClass = getHandlerClass( |
| handlermd.getClassName(), clsLoader); |
| |
| try { |
| handler = (Handler)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws InstantiationException, |
| IllegalAccessException { |
| return handlerClass.newInstance(); |
| } |
| }); |
| handler.init(handlermd); |
| handlermd.setHandler(handler); |
| } catch (PrivilegedActionException e) { |
| throw AxisFault.makeFault(e); |
| } |
| } |
| } |
| |
| public static boolean loadHandler(ClassLoader loader1, |
| HandlerDescription desc) throws DeploymentException { |
| String handlername = desc.getClassName(); |
| Handler handler; |
| try { |
| final Class handlerClass = Loader.loadClass(loader1, handlername); |
| Package aPackage = (Package)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return handlerClass.getPackage(); |
| } |
| }); |
| if (aPackage != null |
| && aPackage.getName().equals("org.apache.axis2.engine")) { |
| String name = handlerClass.getName(); |
| log.warn("Dispatcher " + name + " is now deprecated."); |
| if (name.indexOf("InstanceDispatcher") != -1) { |
| log.warn("Please remove the entry for " |
| + handlerClass.getName() + "from axis2.xml"); |
| } else { |
| log.warn( |
| "Please edit axis2.xml and replace with the same class in org.apache.axis2.dispatchers package"); |
| } |
| } |
| handler = (Handler)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws InstantiationException, |
| IllegalAccessException { |
| return handlerClass.newInstance(); |
| } |
| }); |
| handler.init(desc); |
| desc.setHandler(handler); |
| } catch (ClassNotFoundException e) { |
| if (handlername.indexOf("jaxws") > 0) { |
| log.warn("[JAXWS] - unable to load " + handlername); |
| return false; |
| } |
| throw new DeploymentException(e); |
| } catch (Exception e) { |
| throw new DeploymentException(e); |
| } |
| return true; |
| } |
| |
| public static URL[] getURLsForAllJars(URL url, File tmpDir) { |
| InputStream in = null; |
| ZipInputStream zin = null; |
| try { |
| ArrayList<URL> array = new ArrayList<URL>(); |
| in = url.openStream(); |
| if (url.getProtocol().equals("file")) { |
| array.add(url); |
| } else { |
| String fileName = url.getFile(); |
| int index = fileName.lastIndexOf('/'); |
| if (index != -1) { |
| fileName = fileName.substring(index + 1); |
| } |
| final File f = createTempFile(fileName, in, tmpDir); |
| in.close(); |
| |
| in = org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedExceptionAction<InputStream>() { |
| public InputStream run() throws FileNotFoundException { |
| return new FileInputStream(f); |
| } |
| }); |
| array.add(f.toURI().toURL()); |
| } |
| zin = new ZipInputStream(in); |
| |
| ZipEntry entry; |
| String entryName; |
| while ((entry = zin.getNextEntry()) != null) { |
| entryName = entry.getName(); |
| /** |
| * id the entry name start with /lib and end with .jar then |
| * those entry name will be added to the arraylist |
| */ |
| if ((entryName != null) |
| && entryName.toLowerCase().startsWith("lib/") |
| && entryName.toLowerCase().endsWith(".jar")) { |
| String suffix = entryName.substring(4); |
| File f2 = createTempFile(suffix, zin, tmpDir); |
| array.add(f2.toURI().toURL()); |
| } |
| } |
| return array.toArray(new URL[array.size()]); |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } finally { |
| if (in != null) { |
| try { |
| in.close(); |
| } catch (IOException e) { |
| // |
| } |
| } |
| if (zin != null) { |
| try { |
| zin.close(); |
| } catch (IOException e) { |
| // |
| } |
| } |
| } |
| } |
| |
| public static File createTempFile(final String suffix, InputStream in, |
| final File tmpDir) throws IOException { |
| byte data[] = new byte[2048]; |
| int count; |
| File f = TempFileManager.createTempFile("axis2", suffix); |
| |
| // if (tmpDir == null) { |
| // String directory = (String)org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedAction() { |
| // public Object run() { |
| // return System.getProperty("java.io.tmpdir"); |
| // } |
| // }); |
| // final File tempFile = new File(directory, "_axis2"); |
| // Boolean exists = (Boolean)org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedAction() { |
| // public Object run() { |
| // return tempFile.exists(); |
| // } |
| // }); |
| // if (!exists) { |
| // Boolean mkdirs = (Boolean)org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedAction() { |
| // public Object run() { |
| // return tempFile.mkdirs(); |
| // } |
| // }); |
| // if (!mkdirs) { |
| // throw new IOException("Unable to create the directory"); |
| // } |
| // } |
| // try { |
| // f = (File)org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedExceptionAction() { |
| // public Object run() throws IOException { |
| // return File.createTempFile("axis2", suffix, |
| // tempFile); |
| // } |
| // }); |
| // f.deleteOnExit(); |
| // } catch (PrivilegedActionException e) { |
| // throw (IOException)e.getException(); |
| // } |
| // } else { |
| // try { |
| // f = (File)org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedExceptionAction() { |
| // public Object run() throws IOException { |
| // return File.createTempFile("axis2", suffix, |
| // tmpDir); |
| // } |
| // }); |
| // f.deleteOnExit(); |
| // } catch (PrivilegedActionException e) { |
| // throw (IOException)e.getException(); |
| // } |
| // } |
| // if (log.isDebugEnabled()) { |
| // log.debug("Created temporary file : " + f.getAbsolutePath());// $NON-SEC-4 |
| // } |
| // final File f2 = f; |
| // org.apache.axis2.java.security.AccessController |
| // .doPrivileged(new PrivilegedAction() { |
| // public Object run() { |
| // f2.deleteOnExit(); |
| // return null; |
| // } |
| // }); |
| FileOutputStream out; |
| final File f2 = f; |
| try { |
| out = (FileOutputStream)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedExceptionAction() { |
| public Object run() throws FileNotFoundException { |
| return new FileOutputStream(f2); |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| throw (FileNotFoundException)e.getException(); |
| } |
| while ((count = in.read(data, 0, 2048)) != -1) { |
| out.write(data, 0, count); |
| } |
| out.close(); |
| return f; |
| } |
| |
| public static ClassLoader getClassLoader(ClassLoader parent, String path, boolean isChildFirstClassLoading) |
| throws DeploymentException { |
| return getClassLoader(parent, new File(path), isChildFirstClassLoading); |
| } |
| |
| /** |
| * Get a ClassLoader which contains a classpath of a) the passed directory and b) any jar files |
| * inside the "lib/" or "Lib/" subdirectory of the passed directory. |
| * |
| * @param parent parent ClassLoader which will be the parent of the result of this method |
| * @param file a File which must be a directory for this to be useful |
| * @return a new ClassLoader pointing to both the passed dir and jar files under lib/ |
| * @throws DeploymentException if problems occur |
| */ |
| public static ClassLoader getClassLoader(final ClassLoader parent, File file, final boolean isChildFirstClassLoading) |
| throws DeploymentException { |
| if (file == null) |
| return null; // Shouldn't this just return the parent? |
| |
| try { |
| ArrayList<URL> urls = new ArrayList<URL>(); |
| urls.add(file.toURI().toURL()); |
| |
| // lower case directory name |
| File libfiles = new File(file, "lib"); |
| if (!addFiles(urls, libfiles)) { |
| // upper case directory name |
| libfiles = new File(file, "Lib"); |
| addFiles(urls, libfiles); |
| } |
| |
| final URL urllist[] = new URL[urls.size()]; |
| for (int i = 0; i < urls.size(); i++) { |
| urllist[i] = urls.get(i); |
| } |
| if (log.isDebugEnabled()) { |
| log.debug("Creating class loader with the following libraries: " + Arrays.asList(urllist)); |
| } |
| return createDeploymentClassLoader(urllist, parent, isChildFirstClassLoading); |
| } catch (MalformedURLException e) { |
| throw new DeploymentException(e); |
| } |
| } |
| |
| private static boolean addFiles(ArrayList<URL> urls, final File libfiles) |
| throws MalformedURLException { |
| Boolean exists = org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction<Boolean>() { |
| public Boolean run() { |
| return libfiles.exists(); |
| } |
| }); |
| if (exists) { |
| urls.add(libfiles.toURI().toURL()); |
| File jarfiles[] = org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction<File[]>() { |
| public File[] run() { |
| return libfiles.listFiles(); |
| } |
| }); |
| int i = 0; |
| while (i < jarfiles.length) { |
| File jarfile = jarfiles[i]; |
| if (jarfile.getName().endsWith(".jar")) { |
| urls.add(jarfile.toURI().toURL()); |
| } |
| i++; |
| } |
| } |
| return exists; |
| } |
| |
| private static Class getHandlerClass(String className, ClassLoader loader1) |
| throws AxisFault { |
| Class handlerClass; |
| |
| try { |
| handlerClass = Loader.loadClass(loader1, className); |
| } catch (ClassNotFoundException e) { |
| throw AxisFault.makeFault(e); |
| } |
| |
| return handlerClass; |
| } |
| |
| /** |
| * This guy will create a AxisService using java reflection |
| * |
| * @param axisService the target AxisService |
| * @param axisConfig the in-scope AxisConfiguration |
| * @param excludeOperations a List of Strings (or null), each containing a method to exclude |
| * @param nonRpcMethods a List of Strings (or null), each containing a non-rpc method name |
| * @throws Exception if a problem occurs |
| */ |
| public static void fillAxisService(final AxisService axisService, |
| AxisConfiguration axisConfig, ArrayList<String> excludeOperations, |
| ArrayList<String> nonRpcMethods) throws Exception { |
| Class<?> serviceClass = org.apache.axis2.util.Utils.getServiceClass(axisService); |
| if (serviceClass == null) { |
| return; |
| } |
| ClassLoader serviceClassLoader = axisService.getClassLoader(); |
| // adding name spaces |
| NamespaceMap map = new NamespaceMap(); |
| map.put(Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX, |
| Java2WSDLConstants.AXIS2_XSD); |
| map.put(Java2WSDLConstants.DEFAULT_SCHEMA_NAMESPACE_PREFIX, |
| Java2WSDLConstants.URI_2001_SCHEMA_XSD); |
| axisService.setNamespaceMap(map); |
| SchemaGenerator schemaGenerator; |
| Parameter generateBare = axisService |
| .getParameter(Java2WSDLConstants.DOC_LIT_BARE_PARAMETER); |
| if (generateBare != null && "true".equals(generateBare.getValue())) { |
| schemaGenerator = new DocLitBareSchemaGenerator(serviceClassLoader, |
| serviceClass.getName(), |
| axisService.getSchemaTargetNamespace(), |
| axisService |
| .getSchemaTargetNamespacePrefix(), |
| axisService); |
| } else { |
| schemaGenerator = new DefaultSchemaGenerator(serviceClassLoader, |
| serviceClass.getName(), |
| axisService.getSchemaTargetNamespace(), |
| axisService |
| .getSchemaTargetNamespacePrefix(), |
| axisService); |
| } |
| schemaGenerator.setExcludeMethods(excludeOperations); |
| schemaGenerator.setNonRpcMethods(nonRpcMethods); |
| if (!axisService.isElementFormDefault()) { |
| schemaGenerator |
| .setElementFormDefault(Java2WSDLConstants.FORM_DEFAULT_UNQUALIFIED); |
| } |
| // package to namespace map |
| schemaGenerator.setPkg2nsmap(axisService.getP2nMap()); |
| Collection schemas = schemaGenerator.generateSchema(); |
| axisService.addSchema(schemas); |
| axisService.setSchemaTargetNamespace(schemaGenerator |
| .getSchemaTargetNameSpace()); |
| axisService.setTypeTable(schemaGenerator.getTypeTable()); |
| if (Java2WSDLConstants.DEFAULT_TARGET_NAMESPACE.equals(axisService |
| .getTargetNamespace())) { |
| axisService |
| .setTargetNamespace(schemaGenerator.getTargetNamespace()); |
| } |
| |
| Method[] method = schemaGenerator.getMethods(); |
| PhasesInfo pinfo = axisConfig.getPhasesInfo(); |
| |
| for (Method jmethod : method) { |
| String opName = jmethod.getName(); |
| AxisOperation operation = axisService |
| .getOperation(new QName(opName)); |
| // if the operation there in services.xml then try to set it schema |
| // element name |
| if (operation == null) { |
| operation = axisService.getOperation(new QName( |
| jmethod.getName())); |
| } |
| MessageReceiver mr = |
| axisService.getMessageReceiver(operation.getMessageExchangePattern()); |
| if (mr == null) { |
| mr = axisConfig.getMessageReceiver(operation.getMessageExchangePattern()); |
| } |
| if (operation.getMessageReceiver() == null) { |
| operation.setMessageReceiver(mr); |
| } |
| pinfo.setOperationPhases(operation); |
| axisService.addOperation(operation); |
| if (operation.getSoapAction() == null) { |
| operation.setSoapAction("urn:" + opName); |
| } |
| } |
| } |
| |
| public static AxisOperation getAxisOperationForJmethod(Method method) |
| throws AxisFault { |
| AxisOperation operation; |
| if ("void".equals(method.getReturnType().getName())) { |
| if (method.getExceptionTypes().length > 0) { |
| operation = AxisOperationFactory |
| .getAxisOperation(WSDLConstants.MEP_CONSTANT_IN_OUT); |
| } else { |
| operation = AxisOperationFactory |
| .getAxisOperation(WSDLConstants.MEP_CONSTANT_IN_ONLY); |
| } |
| } else { |
| operation = AxisOperationFactory |
| .getAxisOperation(WSDLConstants.MEP_CONSTANT_IN_OUT); |
| } |
| String opName = method.getName(); |
| |
| |
| operation.setName(new QName(opName)); |
| return operation; |
| } |
| |
| public static OMElement getParameter(String name, String value, |
| boolean locked) { |
| OMFactory fac = OMAbstractFactory.getOMFactory(); |
| OMElement parameter = fac.createOMElement("parameter", null); |
| parameter.addAttribute("name", name, null); |
| parameter.addAttribute("locked", Boolean.toString(locked), null); |
| parameter.setText(value); |
| return parameter; |
| } |
| |
| /** |
| * Modules can contain services in some cases. This method will deploy all the services |
| * for a given AxisModule into the current AxisConfiguration. |
| * <p> |
| * The code looks for an "aars/" directory inside the module (either .mar or exploded), |
| * and an "aars.list" file inside that to figure out which services to deploy. Note that all |
| * services deployed this way will have access to the Module's classes. |
| * </p> |
| * |
| * @param module the AxisModule to search for services |
| * @param configCtx ConfigurationContext in which to deploy |
| */ |
| |
| public static void deployModuleServices(AxisModule module, |
| ConfigurationContext configCtx) throws AxisFault { |
| try { |
| AxisConfiguration axisConfig = configCtx.getAxisConfiguration(); |
| ArchiveReader archiveReader = new ArchiveReader(); |
| PhasesInfo phasesInfo = axisConfig.getPhasesInfo(); |
| final ClassLoader moduleClassLoader = module.getModuleClassLoader(); |
| ArrayList services = new ArrayList(); |
| final InputStream in = (InputStream)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return moduleClassLoader |
| .getResourceAsStream("aars/aars.list"); |
| } |
| }); |
| if (in != null) { |
| BufferedReader input; |
| try { |
| input = new BufferedReader( |
| (InputStreamReader)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return new InputStreamReader(in); |
| } |
| })); |
| String line; |
| while ((line = input.readLine()) != null) { |
| line = line.trim(); |
| if (line.length() > 0 && line.charAt(0) != '#') { |
| services.add(line); |
| } |
| } |
| input.close(); |
| } catch (IOException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| if (services.size() > 0) { |
| for (Object service1 : services) { |
| final String servicename = (String)service1; |
| if (servicename == null || "".equals(servicename)) { |
| continue; |
| } |
| InputStream fin = (InputStream)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return moduleClassLoader |
| .getResourceAsStream("aars/" |
| + servicename); |
| } |
| }); |
| if (fin == null) { |
| throw new AxisFault("No service archive found : " |
| + servicename); |
| } |
| File inputFile = Utils |
| .createTempFile( |
| servicename, |
| fin, |
| (File)axisConfig |
| .getParameterValue( |
| Constants.Configuration.ARTIFACTS_TEMP_DIR)); |
| DeploymentFileData filedata = new DeploymentFileData( |
| inputFile); |
| |
| filedata.setClassLoader(false, |
| moduleClassLoader, |
| (File)axisConfig.getParameterValue(Constants.Configuration.ARTIFACTS_TEMP_DIR), |
| axisConfig.isChildFirstClassLoading()); |
| HashMap wsdlservice = archiveReader.processWSDLs(filedata); |
| if (wsdlservice != null && wsdlservice.size() > 0) { |
| Iterator servicesitr = wsdlservice.values().iterator(); |
| while (servicesitr.hasNext()) { |
| AxisService service = (AxisService)servicesitr |
| .next(); |
| Iterator operations = service.getOperations(); |
| while (operations.hasNext()) { |
| AxisOperation axisOperation = (AxisOperation)operations |
| .next(); |
| phasesInfo.setOperationPhases(axisOperation); |
| } |
| } |
| } |
| AxisServiceGroup serviceGroup = new AxisServiceGroup( |
| axisConfig); |
| serviceGroup.setServiceGroupClassLoader(filedata |
| .getClassLoader()); |
| ArrayList serviceList = archiveReader.processServiceGroup( |
| filedata.getAbsolutePath(), filedata, serviceGroup, |
| false, wsdlservice, configCtx); |
| for (Object aServiceList : serviceList) { |
| AxisService axisService = (AxisService)aServiceList; |
| Parameter moduleService = new Parameter(); |
| moduleService.setValue("true"); |
| moduleService.setName(AxisModule.MODULE_SERVICE); |
| axisService.addParameter(moduleService); |
| serviceGroup.addService(axisService); |
| } |
| axisConfig.addServiceGroup(serviceGroup); |
| fin.close(); |
| } |
| } |
| } catch (IOException e) { |
| throw AxisFault.makeFault(e); |
| } |
| } |
| |
| /** |
| * Normalize a uri containing ../ and ./ paths. |
| * |
| * @param uri The uri path to normalize |
| * @return The normalized uri |
| */ |
| public static String normalize(String uri) { |
| if ("".equals(uri)) { |
| return uri; |
| } |
| int leadingSlashes; |
| for (leadingSlashes = 0; leadingSlashes < uri.length() |
| && uri.charAt(leadingSlashes) == '/'; ++leadingSlashes) { |
| // FIXME: this block is empty!! |
| } |
| boolean isDir = (uri.charAt(uri.length() - 1) == '/'); |
| StringTokenizer st = new StringTokenizer(uri, "/"); |
| LinkedList clean = new LinkedList(); |
| while (st.hasMoreTokens()) { |
| String token = st.nextToken(); |
| if ("..".equals(token)) { |
| if (!clean.isEmpty() && !"..".equals(clean.getLast())) { |
| clean.removeLast(); |
| if (!st.hasMoreTokens()) { |
| isDir = true; |
| } |
| } else { |
| clean.add(".."); |
| } |
| } else if (!".".equals(token) && !"".equals(token)) { |
| clean.add(token); |
| } |
| } |
| StringBuffer sb = new StringBuffer(); |
| while (leadingSlashes-- > 0) { |
| sb.append('/'); |
| } |
| for (Iterator it = clean.iterator(); it.hasNext();) { |
| sb.append(it.next()); |
| if (it.hasNext()) { |
| sb.append('/'); |
| } |
| } |
| if (isDir && sb.length() > 0 && sb.charAt(sb.length() - 1) != '/') { |
| sb.append('/'); |
| } |
| return sb.toString(); |
| } |
| |
| public static String getPath(String parent, String childPath) { |
| Stack parentStack = new Stack(); |
| Stack childStack = new Stack(); |
| if (parent != null) { |
| String[] values = parent.split("/"); |
| if (values.length > 0) { |
| for (String value : values) { |
| parentStack.push(value); |
| } |
| } |
| } |
| String[] values = childPath.split("/"); |
| if (values.length > 0) { |
| for (String value : values) { |
| childStack.push(value); |
| } |
| } |
| String filepath = ""; |
| while (!childStack.isEmpty()) { |
| String value = (String)childStack.pop(); |
| if ("..".equals(value)) { |
| parentStack.pop(); |
| } else if (!"".equals(value)) { |
| if ("".equals(filepath)) { |
| filepath = value; |
| } else { |
| filepath = value + "/" + filepath; |
| } |
| } |
| } |
| while (!parentStack.isEmpty()) { |
| String value = (String)parentStack.pop(); |
| if (!"".equals(value)) { |
| filepath = value + "/" + filepath; |
| } |
| } |
| return filepath; |
| } |
| |
| /** |
| * Add the Axis2 lifecycle / session methods to a pre-existing list of names that will be |
| * excluded when generating schemas. |
| * |
| * @param excludeList an ArrayList containing method names - we'll add ours to this. |
| */ |
| public static void addExcludeMethods(List<String> excludeList) { |
| excludeList.add("init"); |
| excludeList.add("setOperationContext"); |
| excludeList.add("startUp"); |
| excludeList.add("destroy"); |
| excludeList.add("shutDown"); |
| } |
| |
| public static DeploymentClassLoader createClassLoader(File serviceFile, boolean isChildFirstClassLoading) |
| throws MalformedURLException { |
| ClassLoader contextClassLoader = |
| (ClassLoader)org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| }); |
| return createDeploymentClassLoader(new URL[]{serviceFile.toURI().toURL()}, |
| contextClassLoader, isChildFirstClassLoading); |
| } |
| |
| public static File toFile(URL url) throws UnsupportedEncodingException { |
| String path = URLDecoder.decode(url.getPath(), defaultEncoding); |
| return new File(path.replace('/', File.separatorChar).replace('|', ':')); |
| } |
| |
| public static ClassLoader createClassLoader(URL archiveUrl, URL[] extraUrls, |
| ClassLoader serviceClassLoader, |
| File tmpDir, |
| boolean isChildFirstClassLoading) { |
| List<URL> urls = new ArrayList<>(); |
| urls.addAll(Arrays.asList(Utils.getURLsForAllJars(archiveUrl, tmpDir))); |
| if (extraUrls != null) { |
| urls.addAll(Arrays.asList(extraUrls)); |
| } |
| return createDeploymentClassLoader(urls.toArray(new URL[urls.size()]), serviceClassLoader, |
| isChildFirstClassLoading); |
| } |
| |
| private static DeploymentClassLoader createDeploymentClassLoader( |
| final URL[] urls, final ClassLoader serviceClassLoader, |
| final boolean isChildFirstClassLoading) { |
| return AccessController |
| .doPrivileged(new PrivilegedAction<DeploymentClassLoader>() { |
| public DeploymentClassLoader run() { |
| return new DeploymentClassLoader(urls, |
| serviceClassLoader, isChildFirstClassLoading); |
| } |
| }); |
| } |
| |
| /** |
| * This method is to process bean exclude parameter and the XML format of that would be |
| * <parameter name="beanPropertyRules"> <bean class="full qualified class name" |
| * excludeProperties="name,age"/>+ </parameter> |
| * |
| * @param service , AxisService object |
| */ |
| public static void processBeanPropertyExclude(AxisService service) { |
| Parameter excludeBeanProperty = service |
| .getParameter("beanPropertyRules"); |
| if (excludeBeanProperty != null) { |
| OMElement parameterElement = excludeBeanProperty |
| .getParameterElement(); |
| Iterator<OMElement> bneasItr = parameterElement.getChildrenWithName(new QName( |
| "bean")); |
| ExcludeInfo excludeInfo = new ExcludeInfo(); |
| while (bneasItr.hasNext()) { |
| OMElement bean = bneasItr.next(); |
| String clazz = bean.getAttributeValue(new QName( |
| DeploymentConstants.TAG_CLASS_NAME)); |
| String excludePropertees = bean.getAttributeValue(new QName( |
| DeploymentConstants.TAG_EXCLUDE_PROPERTIES)); |
| String includeProperties = bean.getAttributeValue(new QName( |
| DeploymentConstants.TAG_INCLUDE_PROPERTIES)); |
| excludeInfo.putBeanInfo(clazz, new BeanExcludeInfo( |
| excludePropertees, includeProperties)); |
| } |
| service.setExcludeInfo(excludeInfo); |
| } |
| } |
| |
| public static String getShortFileName(String filename) { |
| File file = new File(filename); |
| return file.getName(); |
| } |
| |
| |
| public static void addEndpointsToService(AxisService axisService) |
| throws AxisFault { |
| |
| String serviceName = axisService.getName(); |
| Iterator transportInValues = null; |
| |
| if (axisService.isEnableAllTransports()) { |
| AxisConfiguration axisConfiguration = axisService |
| .getAxisConfiguration(); |
| if (axisConfiguration != null) { |
| ArrayList transports = new ArrayList(); |
| for (Object o : axisConfiguration.getTransportsIn().values()) { |
| TransportInDescription transportInDescription = (TransportInDescription)o; |
| transports.add(transportInDescription.getName()); |
| } |
| transportInValues = transports.iterator(); |
| } |
| } else { |
| transportInValues = axisService.getExposedTransports().iterator(); |
| } |
| |
| HashMap bindingCache = new HashMap(); |
| |
| if (transportInValues != null) { |
| for (; transportInValues.hasNext();) { |
| String transportName = (String)transportInValues.next(); |
| String protocol = transportName.substring(0, 1).toUpperCase() |
| + transportName.substring(1, transportName.length()) |
| .toLowerCase(); |
| |
| //TODO do we use this method , we need to disable Http, SOAP11,SOAP12 |
| // Bindings according to parameters if we are using this |
| /* |
| * populates soap11 endpoint |
| */ |
| String soap11EndpointName = serviceName + protocol |
| + "Soap11Endpoint"; |
| |
| AxisEndpoint httpSoap11Endpoint = new AxisEndpoint(); |
| httpSoap11Endpoint.setName(soap11EndpointName); |
| httpSoap11Endpoint.setParent(axisService); |
| httpSoap11Endpoint.setTransportInDescription(transportName); |
| populateSoap11Endpoint(axisService, httpSoap11Endpoint, |
| bindingCache); |
| axisService.addEndpoint(httpSoap11Endpoint.getName(), |
| httpSoap11Endpoint); |
| // setting soap11 endpoint as the default endpoint |
| axisService.setEndpointName(soap11EndpointName); |
| |
| /* |
| * generating Soap12 endpoint |
| */ |
| String soap12EndpointName = serviceName + protocol |
| + "Soap12Endpoint"; |
| AxisEndpoint httpSoap12Endpoint = new AxisEndpoint(); |
| httpSoap12Endpoint.setName(soap12EndpointName); |
| httpSoap12Endpoint.setParent(axisService); |
| httpSoap12Endpoint.setTransportInDescription(transportName); |
| populateSoap12Endpoint(axisService, httpSoap12Endpoint, |
| bindingCache); |
| axisService.addEndpoint(httpSoap12Endpoint.getName(), |
| httpSoap12Endpoint); |
| |
| /* |
| * generating Http endpoint |
| */ |
| if ("http".equals(transportName)) { |
| String httpEndpointName = serviceName + protocol |
| + "Endpoint"; |
| AxisEndpoint httpEndpoint = new AxisEndpoint(); |
| httpEndpoint.setName(httpEndpointName); |
| httpEndpoint.setParent(axisService); |
| httpEndpoint.setTransportInDescription(transportName); |
| populateHttpEndpoint(axisService, httpEndpoint, bindingCache); |
| axisService.addEndpoint(httpEndpoint.getName(), |
| httpEndpoint); |
| } |
| } |
| } |
| } |
| |
| public static void setEndpointsToAllUsedBindings(AxisService axisService) { |
| |
| Map<QName, AxisBinding> usedBindings = new HashMap<QName, AxisBinding>(); |
| AxisBinding axisBinding = null; |
| for (AxisEndpoint axisEndpoint : axisService.getEndpoints().values()) { |
| axisBinding = axisEndpoint.getBinding(); |
| if (!usedBindings.containsKey(axisBinding.getName())) { |
| usedBindings.put(axisBinding.getName(), axisBinding); |
| } |
| } |
| |
| // now remove all existing end points |
| axisService.getEndpoints().clear(); |
| |
| // add new end points according to the available transports |
| List<String> availableTransports = new ArrayList<String>(); |
| if (axisService.isEnableAllTransports()) { |
| AxisConfiguration axisConfiguration = axisService.getAxisConfiguration(); |
| for (TransportInDescription transportIn : axisConfiguration.getTransportsIn().values()) { |
| availableTransports.add(transportIn.getName()); |
| } |
| } else { |
| availableTransports = axisService.getExposedTransports(); |
| } |
| |
| // add an end point per service per transport description |
| for (AxisBinding usedAxisBinding : usedBindings.values()) { |
| |
| for (String transportIn : availableTransports) { |
| String bindingType = usedAxisBinding.getType(); |
| // for http bindings we can use only the http transport |
| if (WSDL2Constants.URI_WSDL2_HTTP.equals(bindingType) && !transportIn.startsWith("http")){ |
| continue; |
| } |
| AxisEndpoint axisEndpoint = new AxisEndpoint(); |
| axisEndpoint.setName(axisService.getName() + transportIn + usedAxisBinding.getName().getLocalPart() + "Endpoint"); |
| axisEndpoint.setBinding(usedAxisBinding); |
| axisEndpoint.setTransportInDescription(transportIn); |
| axisEndpoint.setParent(axisService); |
| axisService.addEndpoint(axisEndpoint.getName(), axisEndpoint); |
| //set a valid endpoint name as the default endpoint of the service |
| axisService.setEndpointName(axisEndpoint.getName()); |
| } |
| } |
| } |
| |
| public static void addEndpointsToService(AxisService axisService, |
| AxisConfiguration axisConfiguration) throws AxisFault { |
| |
| String serviceName = axisService.getName(); |
| Iterator transportInValues = null; |
| |
| if (axisConfiguration != null) { |
| ArrayList transports = new ArrayList(); |
| for (Object o : axisConfiguration.getTransportsIn().values()) { |
| TransportInDescription transportInDescription = (TransportInDescription)o; |
| transports.add(transportInDescription.getName()); |
| } |
| transportInValues = transports.iterator(); |
| } |
| |
| HashMap bindingCache = new HashMap(); |
| if (transportInValues != null) { |
| for (; transportInValues.hasNext();) { |
| String transportName = (String)transportInValues.next(); |
| String protocol = transportName.substring(0, 1).toUpperCase() |
| + transportName.substring(1, transportName.length()) |
| .toLowerCase(); |
| |
| // axis2.xml indicated no HTTP binding? |
| boolean disableREST = false; |
| Parameter disableRESTParameter = axisService |
| .getParameter(org.apache.axis2.Constants.Configuration.DISABLE_REST); |
| if (disableRESTParameter != null |
| && JavaUtils.isTrueExplicitly(disableRESTParameter.getValue())) { |
| disableREST = true; |
| } |
| |
| boolean disableSOAP11 = false; |
| Parameter disableSOAP11Parameter = axisService |
| .getParameter(org.apache.axis2.Constants.Configuration.DISABLE_SOAP11); |
| if (disableSOAP11Parameter != null |
| && JavaUtils.isTrueExplicitly(disableSOAP11Parameter.getValue())) { |
| disableSOAP11 = true; |
| } |
| |
| boolean disableSOAP12 = false; |
| Parameter disableSOAP12Parameter = axisService |
| .getParameter(org.apache.axis2.Constants.Configuration.DISABLE_SOAP12); |
| if (disableSOAP12Parameter != null |
| && JavaUtils |
| .isTrueExplicitly(disableSOAP12Parameter.getValue())) { |
| disableSOAP12 = true; |
| } |
| |
| /* |
| * populates soap11 endpoint |
| */ |
| if (!disableSOAP11) { |
| String soap11EndpointName = serviceName + protocol |
| + "Soap11Endpoint"; |
| |
| AxisEndpoint httpSoap11Endpoint = new AxisEndpoint(); |
| httpSoap11Endpoint.setName(soap11EndpointName); |
| httpSoap11Endpoint.setParent(axisService); |
| httpSoap11Endpoint.setTransportInDescription(transportName); |
| populateSoap11Endpoint(axisService, httpSoap11Endpoint, |
| bindingCache); |
| axisService.addEndpoint(httpSoap11Endpoint.getName(), |
| httpSoap11Endpoint); |
| // setting soap11 endpoint as the default endpoint |
| axisService.setEndpointName(soap11EndpointName); |
| } |
| |
| /* |
| * generating Soap12 endpoint |
| */ |
| if (!disableSOAP12) { |
| String soap12EndpointName = serviceName + protocol |
| + "Soap12Endpoint"; |
| AxisEndpoint httpSoap12Endpoint = new AxisEndpoint(); |
| httpSoap12Endpoint.setName(soap12EndpointName); |
| httpSoap12Endpoint.setParent(axisService); |
| httpSoap12Endpoint.setTransportInDescription(transportName); |
| populateSoap12Endpoint(axisService, httpSoap12Endpoint, |
| bindingCache); |
| axisService.addEndpoint(httpSoap12Endpoint.getName(), |
| httpSoap12Endpoint); |
| } |
| |
| /* |
| * generating Http endpoint |
| */ |
| if (("http".equals(transportName) |
| || "https".equals(transportName)) && !disableREST) { |
| String httpEndpointName = serviceName + protocol |
| + "Endpoint"; |
| AxisEndpoint httpEndpoint = new AxisEndpoint(); |
| httpEndpoint.setName(httpEndpointName); |
| httpEndpoint.setParent(axisService); |
| httpEndpoint.setTransportInDescription(transportName); |
| populateHttpEndpoint(axisService, httpEndpoint, bindingCache); |
| axisService.addEndpoint(httpEndpoint.getName(), |
| httpEndpoint); |
| } |
| } |
| } |
| } |
| |
| private static String getEndpointName(AxisService axisService, String protocol, |
| String soapVersion) { |
| |
| StringBuilder buffer = new StringBuilder(); |
| buffer.append(axisService.getName()); |
| buffer.append(protocol.substring(0, 1).toUpperCase()); |
| buffer.append(protocol.substring(1, protocol.length()).toLowerCase()); |
| if (soapVersion != null) { |
| buffer.append(soapVersion); |
| } |
| buffer.append("Endpoint"); |
| return buffer.toString(); |
| } |
| |
| public static void addSoap11Endpoint(AxisService axisService, String url) |
| throws Exception { |
| String protocol = org.apache.axis2.util.Utils.getURIScheme(url); |
| String soap11EndpointName = getEndpointName(axisService, protocol, "Soap11"); |
| |
| AxisEndpoint httpSoap11Endpoint = new AxisEndpoint(); |
| httpSoap11Endpoint.setName(soap11EndpointName); |
| httpSoap11Endpoint.setParent(axisService); |
| httpSoap11Endpoint.setEndpointURL(url.toString()); |
| httpSoap11Endpoint.setTransportInDescription(protocol); |
| |
| populateSoap11Endpoint(axisService, httpSoap11Endpoint, null); |
| axisService.addEndpoint(httpSoap11Endpoint.getName(), |
| httpSoap11Endpoint); |
| // setting soap11 endpoint as the default endpoint |
| axisService.setEndpointName(soap11EndpointName); |
| } |
| |
| public static void addSoap11Endpoint(AxisService axisService, String protocol, |
| String endpointName) throws Exception { |
| AxisEndpoint httpSoap11Endpoint = new AxisEndpoint(); |
| httpSoap11Endpoint.setName(endpointName); |
| httpSoap11Endpoint.setParent(axisService); |
| httpSoap11Endpoint.setTransportInDescription(protocol); |
| |
| populateSoap11Endpoint(axisService, httpSoap11Endpoint, null); |
| axisService.addEndpoint(httpSoap11Endpoint.getName(), httpSoap11Endpoint); |
| // setting soap11 endpoint as the default endpoint |
| axisService.setEndpointName(endpointName); |
| } |
| |
| public static void addSoap12Endpoint(AxisService axisService, String url) |
| throws Exception { |
| String protocol = org.apache.axis2.util.Utils.getURIScheme(url); |
| String soap12EndpointName = getEndpointName(axisService, protocol, "Soap12"); |
| |
| AxisEndpoint httpSoap12Endpoint = new AxisEndpoint(); |
| httpSoap12Endpoint.setName(soap12EndpointName); |
| httpSoap12Endpoint.setParent(axisService); |
| httpSoap12Endpoint.setEndpointURL(url.toString()); |
| httpSoap12Endpoint.setTransportInDescription(protocol); |
| |
| populateSoap12Endpoint(axisService, httpSoap12Endpoint, null); |
| axisService.addEndpoint(httpSoap12Endpoint.getName(), |
| httpSoap12Endpoint); |
| } |
| |
| public static void addSoap12Endpoint(AxisService axisService, String protocol, |
| String endpointName) throws Exception { |
| AxisEndpoint httpSoap12Endpoint = new AxisEndpoint(); |
| httpSoap12Endpoint.setName(endpointName); |
| httpSoap12Endpoint.setParent(axisService); |
| httpSoap12Endpoint.setTransportInDescription(protocol); |
| |
| populateSoap12Endpoint(axisService, httpSoap12Endpoint, null); |
| axisService.addEndpoint(httpSoap12Endpoint.getName(), httpSoap12Endpoint); |
| } |
| |
| public static void addHttpEndpoint(AxisService axisService, String url) { |
| String protocol = org.apache.axis2.util.Utils.getURIScheme(url); |
| String httpEndpointName = getEndpointName(axisService, protocol, null); |
| |
| AxisEndpoint httpEndpoint = new AxisEndpoint(); |
| httpEndpoint.setName(httpEndpointName); |
| httpEndpoint.setParent(axisService); |
| httpEndpoint.setEndpointURL(url.toString()); |
| httpEndpoint.setTransportInDescription(protocol); |
| populateHttpEndpoint(axisService, httpEndpoint, null); |
| axisService.addEndpoint(httpEndpoint.getName(), httpEndpoint); |
| } |
| |
| public static void addHttpEndpoint(AxisService axisService, |
| String protocol, String endpointName) { |
| AxisEndpoint httpEndpoint = new AxisEndpoint(); |
| httpEndpoint.setName(endpointName); |
| httpEndpoint.setParent(axisService); |
| httpEndpoint.setTransportInDescription(protocol); |
| populateHttpEndpoint(axisService, httpEndpoint, null); |
| axisService.addEndpoint(httpEndpoint.getName(), httpEndpoint); |
| } |
| |
| public static void processPolicyAttachments(Iterator attachmentElements, |
| AxisService service) throws XMLStreamException, |
| FactoryConfigurationError { |
| OMElement attachmentElement; |
| HashMap attachmentsMap = new HashMap(); |
| |
| for (; attachmentElements.hasNext();) { |
| attachmentElement = (OMElement)attachmentElements.next(); |
| OMElement appliesToElem = null; |
| for (Iterator it = attachmentElement.getChildElements(); it.hasNext(); ) { |
| OMElement elem = (OMElement)it.next(); |
| if (org.apache.neethi.Constants.isPolicyNS(elem.getNamespaceURI()) |
| && elem.getLocalName().equals(DeploymentConstants.TAG_APPLIES_TO)) { |
| appliesToElem = elem; |
| break; |
| } |
| } |
| ArrayList policyComponents = new ArrayList(); |
| |
| // process <wsp:Policy> elements .. |
| for (Iterator policyElements = PolicyUtil.getPolicyChildren(attachmentElement); |
| policyElements.hasNext();) { |
| PolicyComponent policy = PolicyUtil |
| .getPolicyFromOMElement((OMElement)policyElements |
| .next()); |
| policyComponents.add(policy); |
| } |
| |
| // process <wsp:PolicyReference> elements .. |
| for (Iterator policyRefElements = PolicyUtil.getPolicyRefChildren(attachmentElement); |
| policyRefElements.hasNext();) { |
| PolicyComponent policyRef = PolicyUtil |
| .getPolicyReferenceFromOMElement((OMElement)policyRefElements |
| .next()); |
| policyComponents.add(policyRef); |
| } |
| |
| for (Iterator<OMElement> policySubjects = appliesToElem |
| .getChildrenWithName(new QName("policy-subject")); policySubjects |
| .hasNext();) { |
| OMElement policySubject = policySubjects.next(); |
| String identifier = policySubject.getAttributeValue(new QName( |
| "identifier")); |
| |
| ArrayList values = (ArrayList)attachmentsMap.get(identifier); |
| if (values == null) { |
| values = new ArrayList(); |
| attachmentsMap.put(identifier, values); |
| } |
| values.addAll(policyComponents); |
| } |
| } |
| |
| for (Object o : attachmentsMap.keySet()) { |
| String identifier = (String)o; |
| if (identifier.startsWith("binding:soap")) { |
| processSoapAttachments(identifier, (List)attachmentsMap |
| .get(identifier), service); |
| } |
| } |
| } |
| |
| private static void populateSoap11Endpoint(AxisService axisService, |
| AxisEndpoint axisEndpoint, HashMap bindingCache) { |
| String serviceName = axisService.getName(); |
| String name = serviceName + "Soap11Binding"; |
| |
| Parameter parameter = |
| axisService.getParameter(Java2WSDLConstants.SOAP11_BINDING_NAME_OPTION_LONG); |
| if (parameter != null) { |
| name = (String) parameter.getValue(); |
| } |
| |
| QName bindingName = new QName(name); |
| |
| AxisBinding axisBinding = (bindingCache != null) ? (AxisBinding)bindingCache |
| .get(name) |
| : null; |
| if (axisBinding == null) { |
| axisBinding = new AxisBinding(); |
| axisBinding.setName(bindingName); |
| |
| axisBinding.setType(Java2WSDLConstants.TRANSPORT_URI); |
| axisBinding.setProperty(WSDLConstants.WSDL_1_1_STYLE, |
| WSDLConstants.STYLE_DOC); |
| |
| axisBinding.setProperty(WSDL2Constants.ATTR_WSOAP_VERSION, |
| SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI); |
| |
| for (Iterator iterator = axisService.getChildren(); iterator |
| .hasNext();) { |
| AxisOperation operation = (AxisOperation)iterator.next(); |
| AxisBindingOperation axisBindingOperation = new AxisBindingOperation(); |
| |
| axisBindingOperation.setName(operation.getName()); |
| axisBindingOperation.setAxisOperation(operation); |
| |
| String soapAction = operation.getSoapAction(); |
| if (soapAction != null) { |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WSOAP_ACTION, soapAction); |
| } |
| axisBinding.addChild(axisBindingOperation.getName(), |
| axisBindingOperation); |
| populateBindingOperation(axisBinding, |
| axisBindingOperation); |
| } |
| if (bindingCache != null) { |
| bindingCache.put(name, axisBinding); |
| } |
| } |
| axisBinding.setParent(axisEndpoint); |
| axisEndpoint.setBinding(axisBinding); |
| } |
| |
| private static void populateSoap12Endpoint(AxisService axisService, |
| AxisEndpoint axisEndpoint, HashMap bindingCache) { |
| String serviceName = axisService.getName(); |
| String name = serviceName + "Soap12Binding"; |
| |
| Parameter parameter = |
| axisService.getParameter(Java2WSDLConstants.SOAP12_BINDING_NAME_OPTION_LONG); |
| if (parameter != null) { |
| name = (String) parameter.getValue(); |
| } |
| |
| QName bindingName = new QName(name); |
| |
| AxisBinding axisBinding = (bindingCache != null) ? (AxisBinding)bindingCache |
| .get(name) |
| : null; |
| if (axisBinding == null) { |
| axisBinding = new AxisBinding(); |
| axisBinding.setName(bindingName); |
| |
| axisBinding.setType(Java2WSDLConstants.TRANSPORT_URI); |
| axisBinding.setProperty(WSDLConstants.WSDL_1_1_STYLE, |
| WSDLConstants.STYLE_DOC); |
| |
| axisBinding.setProperty(WSDL2Constants.ATTR_WSOAP_VERSION, |
| SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI); |
| |
| for (Iterator iterator = axisService.getChildren(); iterator |
| .hasNext();) { |
| AxisOperation operation = (AxisOperation)iterator.next(); |
| AxisBindingOperation axisBindingOperation = new AxisBindingOperation(); |
| |
| axisBindingOperation.setName(operation.getName()); |
| axisBindingOperation.setAxisOperation(operation); |
| |
| String soapAction = operation.getSoapAction(); |
| if (soapAction != null) { |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WSOAP_ACTION, soapAction); |
| } |
| axisBinding.addChild(axisBindingOperation.getName(), |
| axisBindingOperation); |
| |
| populateBindingOperation(axisBinding, |
| axisBindingOperation); |
| } |
| if (bindingCache != null) { |
| bindingCache.put(name, axisBinding); |
| } |
| } |
| axisBinding.setParent(axisEndpoint); |
| axisEndpoint.setBinding(axisBinding); |
| } |
| |
| private static void populateHttpEndpoint(AxisService axisService, |
| AxisEndpoint axisEndpoint, HashMap bindingCache) { |
| String serviceName = axisService.getName(); |
| String name = serviceName + "HttpBinding"; |
| |
| Parameter param = |
| axisService.getParameter(Java2WSDLConstants.REST_BINDING_NAME_OPTION_LONG); |
| if (param != null) { |
| name = (String) param.getValue(); |
| } |
| |
| QName bindingName = new QName(name); |
| |
| AxisBinding axisBinding = (bindingCache != null) ? (AxisBinding)bindingCache |
| .get(name) |
| : null; |
| |
| if (axisBinding == null) { |
| axisBinding = new AxisBinding(); |
| axisBinding.setName(bindingName); |
| |
| axisBinding.setType(WSDL2Constants.URI_WSDL2_HTTP); |
| axisBinding.setProperty(WSDL2Constants.ATTR_WHTTP_METHOD, "POST"); |
| |
| |
| Map httpLocationMap = new TreeMap<String, AxisOperation>(new Comparator() { |
| public int compare(Object o1, Object o2) { |
| return (-1 * ((Comparable) o1).compareTo(o2)); |
| } |
| }); |
| |
| for (Iterator iterator = axisService.getChildren(); iterator |
| .hasNext();) { |
| AxisOperation operation = (AxisOperation)iterator.next(); |
| AxisBindingOperation axisBindingOperation = new AxisBindingOperation(); |
| |
| QName operationQName = operation.getName(); |
| axisBindingOperation.setName(operationQName); |
| axisBindingOperation.setAxisOperation(operation); |
| String httpLocation = operationQName.getLocalPart(); |
| String tempParam=null; |
| String tempHTTPMethodParam=null; |
| String tempHTTPLocationParam=null; |
| // dealing with the REST data specified in Service.xml @ service class itself(using annotations) |
| Parameter parameter = operation.getParameter(Constants.JSR311_ANNOTATIONS); |
| JAXRSModel methodModel = (parameter != null && (parameter.getValue() instanceof |
| JAXRSModel)) ? (JAXRSModel) parameter.getValue() : null; |
| |
| // Setting the Produces value in the operation |
| if ( (tempParam=Utils.getHTTPOutputSerializationFromservicesXML(operation)) != null) { // first we get produce from services xml if available |
| |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WHTTP_OUTPUT_SERIALIZATION, |
| tempParam); |
| |
| |
| } else if (methodModel != null && methodModel.getProduces() != |
| null) { // then get it from the JAX-RS if available |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WHTTP_OUTPUT_SERIALIZATION, |
| methodModel.getProduces()); |
| |
| } |
| |
| //Setting the Consumes value in the operation |
| if ((tempParam=Utils.getHTTPInputSerializationFromServicesXML(operation)) != null) { // first we get Consumes from services xml if available |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WHTTP_INPUT_SERIALIZATION, |
| tempParam); |
| |
| } else if (methodModel != null && methodModel.getConsumes() != |
| null) { // then get it from the JAX-RS if available |
| |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WHTTP_INPUT_SERIALIZATION, |
| methodModel.getConsumes()); |
| |
| } |
| |
| |
| |
| //Setting the HttpMethod in the operation |
| if ((tempHTTPMethodParam=Utils.getHTTPMethodFromServicesXML(operation))!=null) { // first we get Consumes from services xml if available |
| |
| axisBindingOperation.setProperty( |
| WSDL2Constants.ATTR_WHTTP_METHOD, |
| tempHTTPMethodParam); |
| |
| } else if (methodModel != null && (tempHTTPMethodParam=methodModel.getHTTPMethod()) != |
| null) { // then get it from the JAX-RS if available |
| |
| if (tempHTTPMethodParam.equals(Constants.Configuration.HTTP_METHOD_HEAD)) { |
| log.warn("[JAXRS] http method HEAD is not supported by AXIS2 " + |
| operation.getName()); |
| tempHTTPMethodParam=null; // resetting the HTTP Method if it is head |
| } else { |
| |
| axisBindingOperation.setProperty(WSDL2Constants.ATTR_WHTTP_METHOD, |
| tempHTTPMethodParam); |
| } |
| |
| } |
| |
| |
| |
| //setting the Http Location in the operation |
| if((tempHTTPLocationParam=Utils.getHTTPLoacationFromServicesXML(operation) )==null){ |
| tempHTTPLocationParam=(methodModel!=null)?methodModel.getPath():null; |
| } |
| |
| |
| if (tempHTTPLocationParam!=null && tempHTTPMethodParam != null ){ |
| axisBindingOperation |
| .setProperty(WSDL2Constants.ATTR_WHTTP_LOCATION, tempHTTPLocationParam); |
| httpLocationMap.put(WSDLUtil.getConstantFromHTTPLocation(tempHTTPLocationParam, |
| tempHTTPMethodParam),operation); |
| |
| }else if(tempHTTPLocationParam != null && tempHTTPMethodParam == null){ |
| axisBindingOperation |
| .setProperty(WSDL2Constants.ATTR_WHTTP_LOCATION, tempHTTPLocationParam); |
| httpLocationMap.put(WSDLUtil.getConstantFromHTTPLocation(tempHTTPLocationParam, |
| Constants.Configuration.HTTP_METHOD_POST),operation); |
| } else if(tempHTTPLocationParam == null && tempHTTPMethodParam != null){ |
| axisBindingOperation |
| .setProperty(WSDL2Constants.ATTR_WHTTP_LOCATION, httpLocation); |
| httpLocationMap.put(WSDLUtil.getConstantFromHTTPLocation(httpLocation, |
| tempHTTPMethodParam),operation); |
| } else{ // default scenario : No REST related params in services XML or source file |
| axisBindingOperation |
| .setProperty(WSDL2Constants.ATTR_WHTTP_LOCATION, httpLocation); |
| } |
| |
| |
| axisBinding.addChild(axisBindingOperation.getName(), |
| axisBindingOperation); |
| |
| populateBindingOperation(axisBinding, |
| axisBindingOperation); |
| |
| // resetting my temperory parameters |
| tempParam=null; |
| tempHTTPMethodParam=null; |
| tempHTTPLocationParam=null; |
| |
| } |
| |
| if (!httpLocationMap.isEmpty()) { |
| axisBinding.setProperty(WSDL2Constants.HTTP_LOCATION_TABLE, httpLocationMap); |
| } |
| |
| if (bindingCache != null) { |
| bindingCache.put(name, axisBinding); |
| } |
| } |
| axisBinding.setParent(axisEndpoint); |
| axisEndpoint.setBinding(axisBinding); |
| } |
| |
| private static void populateBindingOperation(AxisBinding axisBinding, |
| AxisBindingOperation axisBindingOperation) { |
| |
| AxisOperation axisOperation = axisBindingOperation.getAxisOperation(); |
| |
| if (WSDLUtil.isInputPresentForMEP(axisOperation |
| .getMessageExchangePattern())) { |
| AxisMessage axisInMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE); |
| AxisBindingMessage axisBindingInMessage = new AxisBindingMessage(); |
| |
| axisBindingInMessage.setName(axisInMessage.getName()); |
| axisBindingInMessage.setDirection(axisInMessage.getDirection()); |
| axisBindingInMessage.setAxisMessage(axisInMessage); |
| |
| axisBindingInMessage.setParent(axisBindingOperation); |
| axisBindingOperation.addChild(WSDLConstants.MESSAGE_LABEL_IN_VALUE, |
| axisBindingInMessage); |
| } |
| |
| if (WSDLUtil.isOutputPresentForMEP(axisOperation |
| .getMessageExchangePattern())) { |
| AxisMessage axisOutMessage = axisOperation |
| .getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE); |
| AxisBindingMessage axisBindingOutMessage = new AxisBindingMessage(); |
| |
| axisBindingOutMessage.setName(axisOutMessage.getName()); |
| axisBindingOutMessage.setDirection(axisOutMessage.getDirection()); |
| axisBindingOutMessage.setAxisMessage(axisOutMessage); |
| |
| axisBindingOutMessage.setParent(axisBindingOperation); |
| axisBindingOperation.addChild( |
| WSDLConstants.MESSAGE_LABEL_OUT_VALUE, |
| axisBindingOutMessage); |
| } |
| |
| ArrayList faultMessagesList = axisOperation.getFaultMessages(); |
| for (Object aFaultMessagesList : faultMessagesList) { |
| AxisMessage axisFaultMessage = (AxisMessage)aFaultMessagesList; |
| AxisBindingMessage axisBindingFaultMessage = new AxisBindingMessage(); |
| axisBindingFaultMessage.setName(axisFaultMessage.getName()); |
| axisBindingFaultMessage.setFault(true); |
| axisBindingFaultMessage.setAxisMessage(axisFaultMessage); |
| axisBindingFaultMessage.setParent(axisBindingOperation); |
| axisBindingOperation.addFault(axisBindingFaultMessage); |
| axisBinding.addFault(axisBindingFaultMessage); |
| } |
| |
| axisBindingOperation.setAxisOperation(axisOperation); |
| axisBindingOperation.setParent(axisBinding); |
| } |
| |
| private static void processSoapAttachments(String identifier, |
| List policyComponents, AxisService service) { |
| Map map = service.getEndpoints(); |
| String soapVersion = |
| (identifier.indexOf("soap12") > -1) ? SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI |
| : SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI; |
| |
| for (Object o : map.values()) { |
| AxisEndpoint axisEndpoint = (AxisEndpoint)o; |
| AxisBinding axisBinding = axisEndpoint.getBinding(); |
| String wsoap = (String)axisBinding |
| .getProperty(WSDL2Constants.ATTR_WSOAP_VERSION); |
| if (soapVersion.equals(wsoap)) { |
| String[] identifiers = identifier.split("/"); |
| int key = identifiers.length; |
| if (key == 1) { |
| axisBinding.getPolicySubject().attachPolicyComponents( |
| policyComponents); |
| } else if (key == 2 || key == 3) { |
| String opName = identifiers[1]; |
| opName = opName.substring(opName.indexOf(":") + 1, opName |
| .length()); |
| AxisBindingOperation bindingOperation = null; |
| boolean found = false; |
| for (Iterator i = axisBinding.getChildren(); i.hasNext();) { |
| bindingOperation = (AxisBindingOperation)i.next(); |
| if (opName.equals(bindingOperation.getName() |
| .getLocalPart())) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| throw new IllegalArgumentException( |
| "Invalid binding operation " + opName); |
| } |
| |
| if (key == 2) { |
| bindingOperation.getPolicySubject() |
| .attachPolicyComponents(policyComponents); |
| } else { |
| if ("in".equals(identifiers[2])) { |
| AxisBindingMessage bindingInMessage = |
| (AxisBindingMessage)bindingOperation |
| .getChild(WSDLConstants.MESSAGE_LABEL_IN_VALUE); |
| bindingInMessage.getPolicySubject() |
| .attachPolicyComponents(policyComponents); |
| |
| } else if ("out".equals(identifiers[2])) { |
| AxisBindingMessage bindingOutMessage = |
| (AxisBindingMessage)bindingOperation |
| .getChild(WSDLConstants.MESSAGE_LABEL_OUT_VALUE); |
| bindingOutMessage.getPolicySubject() |
| .attachPolicyComponents(policyComponents); |
| } else { |
| // FIXME faults |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| public static boolean isSoap11Binding(AxisBinding binding) { |
| String type = binding.getType(); |
| if (Java2WSDLConstants.TRANSPORT_URI.equals(type) |
| || WSDL2Constants.URI_WSDL2_SOAP.equals(type)) { |
| String v = (String)binding |
| .getProperty(WSDL2Constants.ATTR_WSOAP_VERSION); |
| if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(v)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isSoap12Binding(AxisBinding binding) { |
| String type = binding.getType(); |
| if (Java2WSDLConstants.TRANSPORT_URI.equals(type) |
| || WSDL2Constants.URI_WSDL2_SOAP.equals(type)) { |
| String v = (String)binding |
| .getProperty(WSDL2Constants.ATTR_WSOAP_VERSION); |
| if (SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(v)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isHttpBinding(AxisBinding binding) { |
| String type = binding.getType(); |
| return WSDL2Constants.URI_WSDL2_HTTP.equals(type); |
| } |
| |
| public static AxisBinding getSoap11Binding(AxisService service) { |
| for (Object o : service.getEndpoints().values()) { |
| AxisEndpoint endpoint = (AxisEndpoint)o; |
| AxisBinding binding = endpoint.getBinding(); |
| |
| if (isSoap11Binding(binding)) { |
| return binding; |
| } |
| } |
| return null; |
| } |
| |
| public static AxisBinding getSoap12Binding(AxisService service) { |
| for (Object o : service.getEndpoints().values()) { |
| AxisEndpoint endpoint = (AxisEndpoint)o; |
| AxisBinding binding = endpoint.getBinding(); |
| |
| if (isSoap12Binding(binding)) { |
| return binding; |
| } |
| } |
| return null; |
| } |
| |
| public static AxisBinding getHttpBinding(AxisService service) { |
| for (Object o : service.getEndpoints().values()) { |
| AxisEndpoint endpoint = (AxisEndpoint)o; |
| AxisBinding binding = endpoint.getBinding(); |
| |
| if (isHttpBinding(binding)) { |
| return binding; |
| } |
| } |
| return null; |
| } |
| |
| public static AxisBindingOperation getBindingOperation(AxisBinding binding, |
| AxisOperation operation) { |
| QName opName = operation.getName(); |
| for (Iterator bindingOps = binding.getChildren(); bindingOps.hasNext();) { |
| AxisBindingOperation bindingOp = (AxisBindingOperation)bindingOps.next(); |
| if (opName.equals(bindingOp.getName())) { |
| return bindingOp; |
| } |
| } |
| return null; |
| } |
| |
| public static AxisBindingMessage getBindingMessage(AxisBindingOperation bindingOperation, |
| AxisMessage message) { |
| String msgName = message.getName(); |
| for (Iterator bindingMessages = bindingOperation.getChildren(); |
| bindingMessages.hasNext();) { |
| AxisBindingMessage bindingMessage = (AxisBindingMessage)bindingMessages.next(); |
| if (msgName.equals(bindingMessage.getName())) { |
| return bindingMessage; |
| } |
| } |
| return null; |
| } |
| |
| |
| /** |
| * extract the http location from services xml related to given operation |
| * @param operation |
| * @return |
| */ |
| public static String getHTTPLoacationFromServicesXML(AxisOperation operation) { |
| |
| Parameter locationParam = operation.getParameter(Constants.Configuration.REST_LOCATION_PARAM); |
| if (locationParam != null && locationParam.getValue() != null && |
| locationParam.getValue() instanceof String) { |
| String location = ((String) locationParam.getValue()).trim(); |
| if (location.equals("")) { |
| return null; |
| } else{ |
| if(location.startsWith("/")){ |
| location= location.substring(1); |
| } |
| |
| return location; |
| |
| } |
| } else |
| return null; |
| |
| } |
| |
| /** |
| * extract the http method from services xml related to given operation |
| * @param operation |
| * @return |
| */ |
| public static String getHTTPMethodFromServicesXML(AxisOperation operation) { |
| Parameter methodParam = operation.getParameter(Constants.Configuration.REST_METHOD_PARAM); |
| if (methodParam != null && methodParam.getValue() != null && |
| methodParam.getValue() instanceof String) { |
| String method = ((String) methodParam.getValue()).trim(); |
| if (method.equals("")) { |
| return null; |
| } else if (method.equals(Constants.Configuration.HTTP_METHOD_GET) || method.equals(Constants.Configuration.HTTP_METHOD_POST) || |
| method.equals(Constants.Configuration.HTTP_METHOD_PUT) || method.equals(Constants.Configuration.HTTP_METHOD_DELETE)) { |
| return method; |
| } else if (method.equals(Constants.Configuration.HTTP_METHOD_HEAD)) { |
| log.warn("Axis2 doesn't support httpMethod HEAD "); |
| return null; |
| } else { |
| log.warn("cannot identify the HTTP method"); |
| return null; |
| } |
| } else |
| return null; |
| } |
| |
| /** |
| * get http input mime type from the services xml |
| * @param operation |
| * @return |
| */ |
| public static String getHTTPInputSerializationFromServicesXML(AxisOperation operation) { |
| Parameter inputSerializationParam = operation.getParameter(Constants.Configuration.REST_INPUTSERIALIZE_PARAM); |
| if (inputSerializationParam != null && inputSerializationParam.getValue() != null |
| && inputSerializationParam.getValue() instanceof String) { |
| String inputSerialization = ((String) inputSerializationParam.getValue()).trim(); |
| |
| if (inputSerialization.equals("")) { |
| return null; |
| } else { |
| String[] array = inputSerialization.split(","); |
| if (array.length > 1) { |
| log.warn("WSDL2 supports only one input-serialization"); |
| return array[0]; |
| } else { |
| return array[0]; |
| } |
| } |
| |
| } else |
| return null; |
| |
| |
| } |
| |
| /** |
| * get http output mime type from the services xml |
| * @param operation |
| * @return |
| */ |
| public static String getHTTPOutputSerializationFromservicesXML(AxisOperation operation) { |
| Parameter outputSerializationParam = operation.getParameter(Constants.Configuration.REST_OUTPUTSERIALIZE_PARAM); |
| if (outputSerializationParam != null && outputSerializationParam.getValue() != null |
| && outputSerializationParam.getValue() instanceof String) { |
| String outputSerialization = ((String) outputSerializationParam.getValue()).trim(); |
| |
| if (outputSerialization.equals("")) { |
| return null; |
| } else { |
| String[] array = outputSerialization.split(","); |
| if (array.length > 1) { |
| log.warn("WSDL2 supports only one input-serialization"); |
| return array[0]; |
| } else { |
| return array[0]; |
| } |
| } |
| } else |
| return null; |
| |
| } |
| |
| /** |
| * Log faulty services info due to unavailability of modules and transports |
| * @param axisConfig |
| */ |
| public static void logFaultyServiceInfo(AxisConfiguration axisConfig){ |
| Map<String, Map<String, FaultyServiceData>> faultyServices = axisConfig.getFaultyServicesDuetoModules(); |
| if (faultyServices != null && !faultyServices.isEmpty()) { |
| for (String moduleName : faultyServices.keySet()) { |
| Map<String, FaultyServiceData> faultyServicesDueToModule = faultyServices.get(moduleName); |
| for (String s : faultyServicesDueToModule.keySet()) { |
| log.warn("Service :" + s + " is faulty, due to unavailability of the module :" + moduleName); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Computes the hierarchical part of the service name if this is such a service path. |
| * Ex: filePath = .../repository/services/foo/1.0.0/version.aar -> "foo/1.0.0/" |
| * filePath = .../repository/services/version.aar -> "" |
| * @param filePath - input file path of the deploying file |
| * @param serviceDir - 'services', 'pojo', 'servicejars' etc.. |
| * @return hierarchical path. either "" or a '/' separated string (Ex: foo/1.0.0/) |
| */ |
| public static String getServiceHierarchy(String filePath, String serviceDir) { |
| if (filePath == null || serviceDir == null) { |
| return ""; |
| } |
| filePath = formatPath(filePath); |
| String[] splited = filePath.split("/" + serviceDir + "/"); |
| String serviceHierarchy = null; |
| if (splited.length > 1) { |
| String temp = splited[splited.length - 1]; |
| //if this is a directory, there can be a '/' at the end. Remove it.. |
| if (temp.endsWith("/")) { |
| temp = temp.substring(0, temp.length() - 1); |
| } |
| //if this is not a hierarchical path, return a 0 length string |
| if (temp.lastIndexOf('/') == -1) { |
| return ""; |
| } |
| serviceHierarchy = temp.substring(0, temp.lastIndexOf('/') + 1); |
| } |
| return serviceHierarchy; |
| } |
| |
| /** |
| * Format the string paths to match any platform.. windows, linux etc.. |
| * |
| * @param path - input file path |
| * @return formatted file path |
| */ |
| public static String formatPath(String path) { |
| // removing white spaces |
| path = path.replaceAll("\\b\\s+\\b", "%20"); |
| // replacing all "\" with "/" |
| return path.replace('\\', '/'); |
| } |
| |
| /** |
| * Get the class name from a resource name referring to a class file. |
| * |
| * @param resourceName the resource name |
| * @return the class name |
| */ |
| public static String getClassNameFromResourceName(String resourceName) { |
| if (!resourceName.endsWith(".class")) { |
| throw new IllegalArgumentException("The resource name doesn't refer to a class file"); |
| } |
| return resourceName.substring(0, resourceName.length()-6).replace('/', '.'); |
| } |
| |
| /** |
| * Scan a JAR file and return the list of classes contained in the JAR. |
| * |
| * @param deploymentFileData |
| * the JAR to scan |
| * @return a list of Java class names |
| * @throws DeploymentException |
| * if an error occurs while scanning the file |
| */ |
| public static List<String> getListOfClasses(DeploymentFileData deploymentFileData) throws DeploymentException { |
| try { |
| List<String> classList = null; |
| if(DeploymentFileData.isServiceArchiveFile(deploymentFileData.getAbsolutePath())){ |
| FileInputStream fin = new FileInputStream(deploymentFileData.getAbsolutePath()); |
| try { |
| ZipInputStream zin = new ZipInputStream(fin); |
| try { |
| ZipEntry entry; |
| classList = new ArrayList<String>(); |
| while ((entry = zin.getNextEntry()) != null) { |
| String name = entry.getName(); |
| if (name.endsWith(".class")) { |
| classList.add(getClassNameFromResourceName(name)); |
| } |
| } |
| return classList; |
| } finally { |
| zin.close(); |
| } |
| } finally { |
| fin.close(); |
| } |
| } else { |
| File directory = deploymentFileData.getFile(); |
| classList = new ArrayList<String>(); |
| for(Iterator<File> fileItr= FileUtils.iterateFiles(directory, new String[]{"class"}, true); fileItr.hasNext();){ |
| String fileName = fileItr.next().getPath(); |
| String className = getClassNameFromResourceName(fileName.replace(directory.getPath(), "").substring(1)); |
| classList.add(className); |
| } |
| return classList; |
| } |
| } catch (IOException e) { |
| log.debug(Messages.getMessage(DeploymentErrorMsgs.DEPLOYING_EXCEPTION, e.getMessage()), e); |
| throw new DeploymentException(e); |
| } |
| } |
| } |
