| /* |
| * Copyright 2004,2005 The Apache Software Foundation. |
| * |
| * Licensed 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; |
| |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.deployment.repository.util.ArchiveFileData; |
| import org.apache.axis2.deployment.repository.util.ArchiveReader; |
| import org.apache.axis2.deployment.repository.util.WSInfo; |
| import org.apache.axis2.deployment.scheduler.DeploymentIterator; |
| import org.apache.axis2.deployment.scheduler.Scheduler; |
| import org.apache.axis2.deployment.scheduler.SchedulerTask; |
| import org.apache.axis2.deployment.util.PhasesInfo; |
| import org.apache.axis2.deployment.util.Utils; |
| import org.apache.axis2.description.*; |
| import org.apache.axis2.engine.AxisConfiguration; |
| import org.apache.axis2.engine.MessageReceiver; |
| import org.apache.axis2.i18n.Messages; |
| import org.apache.axis2.wsdl.WSDLConstants; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.XMLStreamException; |
| import java.io.*; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| public class DeploymentEngine implements DeploymentConstants { |
| |
| private static final Log log = LogFactory.getLog(DeploymentEngine.class); |
| private boolean hotUpdate = true; // to do hot update or not |
| private boolean hotDeployment = true; // to do hot deployment or not |
| private boolean antiJARLocking = false; // to do hot deployment or not |
| /** |
| * Stores all the web Services to deploy. |
| */ |
| private List wsToDeploy = new ArrayList(); |
| |
| /** |
| * Stores all the web Services to undeploy. |
| */ |
| private List wsToUnDeploy = new ArrayList(); |
| |
| //to keep the web resource location if any |
| private String webLocationString = null; |
| |
| /** |
| * to keep a ref to engine register |
| * this ref will pass to engine when it call start() |
| * method |
| */ |
| protected AxisConfiguration axisConfig; |
| |
| protected ConfigurationContext configContext; |
| |
| private RepositoryListener repoListener; |
| |
| private String servicesPath = null; |
| private File servicesDir = null; |
| private String modulesPath = null; |
| private File modulesDir = null; |
| |
| public void loadServices() { |
| repoListener.checkServices(); |
| if (hotDeployment) { |
| startSearch(repoListener); |
| } |
| } |
| |
| public void loadRepository(String repoDir) throws DeploymentException { |
| File axisRepo = new File(repoDir); |
| if (!axisRepo.exists()) { |
| throw new DeploymentException( |
| Messages.getMessage("cannotfindrepo", repoDir)); |
| } |
| setDeploymentFeatures(); |
| prepareRepository(repoDir); |
| // setting the CLs |
| setClassLoaders(repoDir); |
| repoListener = new RepositoryListener(this, false); |
| org.apache.axis2.util.Utils.calculateDefaultModuleVersion(axisConfig.getModules(), axisConfig); |
| try { |
| try { |
| axisConfig.setRepository(axisRepo.toURL()); |
| } catch (MalformedURLException e) { |
| log.info(e.getMessage()); |
| } |
| validateSystemPredefinedPhases(); |
| } catch (AxisFault axisFault) { |
| throw new DeploymentException(axisFault); |
| } |
| } |
| |
| public void loadFromClassPath() throws DeploymentException { |
| //loading modules from the classpath |
| new RepositoryListener(this, true); |
| org.apache.axis2.util.Utils.calculateDefaultModuleVersion( |
| axisConfig.getModules(), axisConfig); |
| validateSystemPredefinedPhases(); |
| try { |
| engageModules(); |
| } catch (AxisFault axisFault) { |
| log.info(Messages.getMessage(DeploymentErrorMsgs.MODULE_VALIDATION_FAILED, |
| axisFault.getMessage())); |
| throw new DeploymentException(axisFault); |
| } |
| } |
| |
| public void loadServicesFromUrl(URL repoURL) { |
| try { |
| String path = servicesPath == null ? DeploymentConstants.SERVICE_PATH : servicesPath; |
| if (!path.endsWith("/")) { |
| path = path + "/"; |
| } |
| URL servicesDir = new URL(repoURL, path); |
| URL filelisturl = new URL(servicesDir, "services.list"); |
| ArrayList files = getFileList(filelisturl); |
| Iterator fileIterator = files.iterator(); |
| while (fileIterator.hasNext()) { |
| String fileUrl = (String) fileIterator.next(); |
| if (fileUrl.endsWith(".aar")) { |
| AxisServiceGroup serviceGroup = new AxisServiceGroup(); |
| URL servicesURL = new URL(servicesDir, fileUrl); |
| ArrayList servicelist = populateService(serviceGroup, |
| servicesURL, |
| fileUrl.substring(0, fileUrl.indexOf(".aar"))); |
| addServiceGroup(serviceGroup, servicelist, servicesURL, null); |
| } |
| } |
| } catch (MalformedURLException e) { |
| log.info(e.getMessage()); |
| } catch (IOException e) { |
| log.info(e.getMessage()); |
| } |
| } |
| |
| public void loadRepositoryFromURL(URL repoURL) throws DeploymentException { |
| try { |
| String path = modulesPath == null ? DeploymentConstants.MODULE_PATH : modulesPath; |
| if (!path.endsWith("/")) { |
| path = path + "/"; |
| } |
| URL moduleDir = new URL(repoURL, path); |
| URL filelisturl = new URL(moduleDir, "modules.list"); |
| ArrayList files = getFileList(filelisturl); |
| Iterator fileIterator = files.iterator(); |
| while (fileIterator.hasNext()) { |
| String fileUrl = (String) fileIterator.next(); |
| if (fileUrl.endsWith(".mar")) { |
| URL moduleurl = new URL(moduleDir, fileUrl); |
| DeploymentClassLoader deploymentClassLoader = |
| new DeploymentClassLoader( |
| new URL[]{moduleurl}, |
| axisConfig.getModuleClassLoader(), |
| antiJARLocking); |
| AxisModule module = new AxisModule(); |
| module.setModuleClassLoader(deploymentClassLoader); |
| module.setParent(axisConfig); |
| String moduleName = fileUrl.substring(0, fileUrl.indexOf(".mar")); |
| module.setName(new QName(moduleName)); |
| populateModule(module, moduleurl); |
| module.setFileName(moduleurl); |
| addNewModule(module); |
| } |
| } |
| org.apache.axis2.util.Utils.calculateDefaultModuleVersion( |
| axisConfig.getModules(), axisConfig); |
| validateSystemPredefinedPhases(); |
| } catch (MalformedURLException e) { |
| throw new DeploymentException(e); |
| } catch (IOException e) { |
| throw new DeploymentException(e); |
| } |
| } |
| |
| private void populateModule(AxisModule module, URL moduleUrl) throws DeploymentException { |
| try { |
| ClassLoader classLoadere = module.getModuleClassLoader(); |
| InputStream moduleStream = classLoadere.getResourceAsStream("META-INF/module.xml"); |
| if (moduleStream == null) { |
| moduleStream = classLoadere.getResourceAsStream("meta-inf/module.xml"); |
| } |
| if (moduleStream == null) { |
| throw new DeploymentException( |
| Messages.getMessage( |
| DeploymentErrorMsgs.MODULE_XML_MISSING, moduleUrl.toString())); |
| } |
| ModuleBuilder moduleBuilder = new ModuleBuilder(moduleStream, module, axisConfig); |
| moduleBuilder.populateModule(); |
| } catch (IOException e) { |
| throw new DeploymentException(e); |
| } |
| } |
| |
| private ArrayList populateService(AxisServiceGroup serviceGroup, |
| URL servicesURL, |
| String serviceName) throws DeploymentException { |
| try { |
| serviceGroup.setServiceGroupName(serviceName); |
| DeploymentClassLoader serviceClassLoader = new DeploymentClassLoader( |
| new URL[]{servicesURL}, axisConfig.getServiceClassLoader(), antiJARLocking); |
| String metainf = "meta-inf"; |
| serviceGroup.setServiceGroupClassLoader(serviceClassLoader); |
| InputStream servicexmlStream = serviceClassLoader.getResourceAsStream("META-INF/services.xml"); |
| if (servicexmlStream == null) { |
| servicexmlStream = serviceClassLoader.getResourceAsStream("meta-inf/services.xml"); |
| } else { |
| metainf = "META-INF"; |
| } |
| if (servicexmlStream == null) { |
| throw new DeploymentException( |
| Messages.getMessage(DeploymentErrorMsgs.SERVICE_XML_NOT_FOUND, servicesURL.toString())); |
| } |
| DescriptionBuilder builder = new DescriptionBuilder(servicexmlStream, configContext); |
| OMElement rootElement = builder.buildOM(); |
| String elementName = rootElement.getLocalName(); |
| |
| if (TAG_SERVICE.equals(elementName)) { |
| AxisService axisService = null; |
| InputStream wsdlStream = serviceClassLoader.getResourceAsStream(metainf + "/service.wsdl"); |
| if (wsdlStream == null) { |
| wsdlStream = serviceClassLoader.getResourceAsStream(metainf + "/" + serviceName + ".wsdl"); |
| } |
| if (wsdlStream != null) { |
| WSDL11ToAxisServiceBuilder wsdl2AxisServiceBuilder = |
| new WSDL11ToAxisServiceBuilder(wsdlStream, null, null); |
| axisService = wsdl2AxisServiceBuilder.populateService(); |
| axisService.setWsdlFound(true); |
| axisService.setName(serviceName); |
| } |
| if (axisService == null) { |
| axisService = new AxisService(serviceName); |
| } |
| |
| axisService.setParent(serviceGroup); |
| axisService.setClassLoader(serviceClassLoader); |
| |
| ServiceBuilder serviceBuilder = new ServiceBuilder(configContext, axisService); |
| AxisService service = serviceBuilder.populateService(rootElement); |
| |
| ArrayList serviceList = new ArrayList(); |
| serviceList.add(service); |
| return serviceList; |
| } else if (TAG_SERVICE_GROUP.equals(elementName)) { |
| ServiceGroupBuilder groupBuilder = new ServiceGroupBuilder(rootElement, new HashMap(), |
| configContext); |
| ArrayList servicList = groupBuilder.populateServiceGroup(serviceGroup); |
| Iterator serviceIterator = servicList.iterator(); |
| while (serviceIterator.hasNext()) { |
| AxisService axisService = (AxisService) serviceIterator.next(); |
| InputStream wsdlStream = serviceClassLoader.getResourceAsStream(metainf + "/service.wsdl"); |
| if (wsdlStream == null) { |
| wsdlStream = serviceClassLoader.getResourceAsStream(metainf + "/" + serviceName + ".wsdl"); |
| if (wsdlStream != null) { |
| WSDL11ToAxisServiceBuilder wsdl2AxisServiceBuilder = |
| new WSDL11ToAxisServiceBuilder(wsdlStream, axisService); |
| axisService = wsdl2AxisServiceBuilder.populateService(); |
| axisService.setWsdlFound(true); |
| // Set the default message receiver for the operations that were |
| // not listed in the services.xml |
| Iterator operations = axisService.getOperations(); |
| while (operations.hasNext()) { |
| AxisOperation operation = (AxisOperation) operations.next(); |
| if (operation.getMessageReceiver() == null) { |
| operation.setMessageReceiver(loadDefaultMessageReceiver( |
| operation.getMessageExchangePattern(), axisService)); |
| } |
| } |
| } |
| } |
| } |
| return servicList; |
| } |
| } catch (IOException e) { |
| throw new DeploymentException(e); |
| } catch (XMLStreamException e) { |
| throw new DeploymentException(e); |
| } |
| return null; |
| } |
| |
| protected MessageReceiver loadDefaultMessageReceiver(String mepURL, AxisService service) { |
| MessageReceiver messageReceiver; |
| if (mepURL == null) { |
| mepURL = WSDLConstants.WSDL20_2004Constants.MEP_URI_IN_OUT; |
| } |
| if (service != null) { |
| messageReceiver = service.getMessageReceiver(mepURL); |
| if (messageReceiver != null) { |
| return messageReceiver; |
| } |
| } |
| return axisConfig.getMessageReceiver(mepURL); |
| } |
| |
| private void addNewModule(AxisModule modulemetadata) throws AxisFault { |
| |
| Flow inflow = modulemetadata.getInFlow(); |
| ClassLoader moduleClassLoader = modulemetadata.getModuleClassLoader(); |
| |
| if (inflow != null) { |
| Utils.addFlowHandlers(inflow, moduleClassLoader); |
| } |
| |
| Flow outFlow = modulemetadata.getOutFlow(); |
| |
| if (outFlow != null) { |
| Utils.addFlowHandlers(outFlow, moduleClassLoader); |
| } |
| |
| Flow faultInFlow = modulemetadata.getFaultInFlow(); |
| |
| if (faultInFlow != null) { |
| Utils.addFlowHandlers(faultInFlow, moduleClassLoader); |
| } |
| |
| Flow faultOutFlow = modulemetadata.getFaultOutFlow(); |
| |
| if (faultOutFlow != null) { |
| Utils.addFlowHandlers(faultOutFlow, moduleClassLoader); |
| } |
| |
| axisConfig.addModule(modulemetadata); |
| log.debug(Messages.getMessage(DeploymentErrorMsgs.ADDING_NEW_MODULE)); |
| } |
| |
| private void addServiceGroup(AxisServiceGroup serviceGroup, |
| ArrayList serviceList, |
| URL serviceLocation, |
| ArchiveFileData currentArchiveFile) |
| throws AxisFault { |
| fillServiceGroup(serviceGroup, serviceList, serviceLocation, axisConfig); |
| axisConfig.addServiceGroup(serviceGroup); |
| if (currentArchiveFile != null) { |
| addAsWebResources(currentArchiveFile.getFile(), |
| serviceGroup.getServiceGroupName(), serviceGroup); |
| } |
| } |
| |
| private static void fillServiceGroup(AxisServiceGroup serviceGroup, |
| ArrayList serviceList, |
| URL serviceLocation, |
| AxisConfiguration axisConfig) throws AxisFault { |
| serviceGroup.setParent(axisConfig); |
| // module from services.xml at serviceGroup level |
| ArrayList groupModules = serviceGroup.getModuleRefs(); |
| |
| for (int i = 0; i < groupModules.size(); i++) { |
| QName moduleName = (QName) groupModules.get(i); |
| AxisModule module = axisConfig.getModule(moduleName); |
| |
| if (module != null) { |
| serviceGroup.engageModule(axisConfig.getModule(moduleName), axisConfig); |
| } else { |
| throw new DeploymentException( |
| Messages.getMessage( |
| DeploymentErrorMsgs.BAD_MODULE_FROM_SERVICE, |
| serviceGroup.getServiceGroupName(), moduleName.getLocalPart())); |
| } |
| } |
| |
| Iterator services = serviceList.iterator(); |
| |
| while (services.hasNext()) { |
| AxisService axisService = (AxisService) services.next(); |
| String scope = axisService.getScope(); |
| if (Constants.SCOPE_TRANSPORT_SESSION.equals(scope)) { |
| if (!axisConfig.isManageTransportSession()) { |
| throw new DeploymentException("You can not deploy the service " + |
| "in transport session , since transport session management" + |
| " disabled in axis2.xml change manageTransportSession parameter value to true"); |
| } |
| } |
| axisService.setUseDefaultChains(false); |
| |
| axisService.setFileName(serviceLocation); |
| serviceGroup.addService(axisService); |
| |
| // modules from <service> |
| ArrayList list = axisService.getModules(); |
| |
| for (int i = 0; i < list.size(); i++) { |
| AxisModule module = axisConfig.getModule((QName) list.get(i)); |
| |
| if (module == null) { |
| throw new DeploymentException( |
| Messages.getMessage( |
| DeploymentErrorMsgs.BAD_MODULE_FROM_SERVICE, axisService.getName(), |
| ((QName) list.get(i)).getLocalPart())); |
| } |
| |
| axisService.engageModule(module, axisConfig); |
| } |
| |
| for (Iterator iterator = axisService.getOperations(); iterator.hasNext();) { |
| AxisOperation opDesc = (AxisOperation) iterator.next(); |
| ArrayList modules = opDesc.getModuleRefs(); |
| |
| for (int i = 0; i < modules.size(); i++) { |
| QName moduleName = (QName) modules.get(i); |
| AxisModule module = axisConfig.getModule(moduleName); |
| |
| if (module != null) { |
| opDesc.engageModule(module, axisConfig); |
| } else { |
| throw new DeploymentException( |
| Messages.getMessage( |
| DeploymentErrorMsgs.BAD_MODULE_FROM_OPERATION, |
| opDesc.getName().getLocalPart(), moduleName.getLocalPart())); |
| } |
| } |
| } |
| } |
| } |
| |
| private void addAsWebResources(File in, String serviceFileName, AxisServiceGroup serviceGroup) { |
| try { |
| if (webLocationString == null) { |
| return; |
| } |
| if (in.isDirectory()) { |
| return; |
| } |
| File webLocation = new File(webLocationString); |
| File out = new File(webLocation, serviceFileName); |
| int BUFFER = 1024; |
| byte data[] = new byte[BUFFER]; |
| FileInputStream fin = new FileInputStream(in); |
| ZipInputStream zin = new ZipInputStream( |
| fin); |
| ZipEntry entry; |
| while ((entry = zin.getNextEntry()) != null) { |
| ZipEntry zip = new ZipEntry(entry); |
| if (zip.getName().toUpperCase().startsWith("WWW")) { |
| String fileName = zip.getName(); |
| fileName = fileName.substring("WWW/".length(), |
| fileName.length()); |
| if (zip.isDirectory()) { |
| new File(out, fileName).mkdirs(); |
| } else { |
| FileOutputStream tempOut = new FileOutputStream(new File(out, fileName)); |
| int count; |
| while ((count = zin.read(data, 0, BUFFER)) != -1) { |
| tempOut.write(data, 0, count); |
| } |
| tempOut.close(); |
| tempOut.flush(); |
| } |
| serviceGroup.setFoundWebResources(true); |
| } |
| } |
| zin.close(); |
| fin.close(); |
| } catch (IOException e) { |
| log.info(e.getMessage()); |
| } |
| } |
| |
| /** |
| * @param file |
| */ |
| public void addWSToDeploy(ArchiveFileData file) { |
| wsToDeploy.add(file); |
| } |
| |
| /** |
| * @param file |
| */ |
| public void addWSToUndeploy(WSInfo file) { |
| wsToUnDeploy.add(file); |
| } |
| |
| public void doDeploy() { |
| if (wsToDeploy.size() > 0) { |
| for (int i = 0; i < wsToDeploy.size(); i++) { |
| ArchiveFileData currentArchiveFile = (ArchiveFileData) wsToDeploy.get(i); |
| boolean explodedDir = currentArchiveFile.getFile().isDirectory(); |
| int type = currentArchiveFile.getType(); |
| try { |
| ArchiveReader archiveReader; |
| StringWriter errorWriter = new StringWriter(); |
| switch (type) { |
| case TYPE_SERVICE : |
| currentArchiveFile.setClassLoader(explodedDir, |
| axisConfig.getServiceClassLoader()); |
| archiveReader = new ArchiveReader(); |
| String serviceStatus = ""; |
| try { |
| HashMap wsdlservice = archiveReader.processWSDLs(currentArchiveFile); |
| if (wsdlservice != null && wsdlservice.size() > 0) { |
| Iterator services = wsdlservice.values().iterator(); |
| while (services.hasNext()) { |
| AxisService service = (AxisService) services.next(); |
| Iterator operations = service.getOperations(); |
| while (operations.hasNext()) { |
| AxisOperation axisOperation = (AxisOperation) operations.next(); |
| axisConfig.getPhasesInfo().setOperationPhases(axisOperation); |
| } |
| } |
| } |
| AxisServiceGroup sericeGroup = new AxisServiceGroup(axisConfig); |
| sericeGroup.setServiceGroupClassLoader( |
| currentArchiveFile.getClassLoader()); |
| ArrayList serviceList = archiveReader.processServiceGroup( |
| currentArchiveFile.getAbsolutePath(), currentArchiveFile, |
| sericeGroup, explodedDir, wsdlservice, |
| configContext); |
| addServiceGroup(sericeGroup, serviceList, currentArchiveFile.getFile().toURL(), currentArchiveFile); |
| log.info(Messages.getMessage(DeploymentErrorMsgs.DEPLOYING_WS, |
| currentArchiveFile.getName())); |
| } catch (DeploymentException de) { |
| de.printStackTrace(); |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_SERVICE, |
| currentArchiveFile.getName(), |
| de.getMessage()), |
| de); |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| de.printStackTrace(error_ptintWriter); |
| serviceStatus = "Error:\n" + errorWriter.toString(); |
| } catch (AxisFault axisFault) { |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_SERVICE, |
| currentArchiveFile.getName(), |
| axisFault.getMessage()), |
| axisFault); |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| axisFault.printStackTrace(error_ptintWriter); |
| serviceStatus = "Error:\n" + errorWriter.toString(); |
| } catch (Exception e) { |
| if (log.isInfoEnabled()) { |
| StringWriter sw = new StringWriter(); |
| PrintWriter pw = new PrintWriter(sw); |
| e.printStackTrace(pw); |
| log.info(Messages.getMessage( |
| DeploymentErrorMsgs.INVALID_SERVICE, |
| currentArchiveFile.getName(), |
| sw.getBuffer().toString())); |
| } |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| e.printStackTrace(error_ptintWriter); |
| serviceStatus = "Error:\n" + errorWriter.toString(); |
| } catch (Throwable t) { |
| if (log.isInfoEnabled()) { |
| StringWriter sw = new StringWriter(); |
| PrintWriter pw = new PrintWriter(sw); |
| t.printStackTrace(pw); |
| log.info(Messages.getMessage( |
| DeploymentErrorMsgs.INVALID_SERVICE, |
| currentArchiveFile.getName(), |
| sw.getBuffer().toString())); |
| } |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| t.printStackTrace(error_ptintWriter); |
| serviceStatus = "Error:\n" + errorWriter.toString(); |
| } finally { |
| if (serviceStatus.startsWith("Error:")) { |
| axisConfig.getFaultyServices().put(currentArchiveFile.getFile().getAbsolutePath(), |
| serviceStatus); |
| } |
| currentArchiveFile = null; |
| } |
| break; |
| case TYPE_MODULE : |
| currentArchiveFile.setClassLoader(explodedDir, |
| axisConfig.getModuleClassLoader()); |
| archiveReader = new ArchiveReader(); |
| String moduleStatus = ""; |
| try { |
| AxisModule metaData = new AxisModule(); |
| metaData.setModuleClassLoader(currentArchiveFile.getClassLoader()); |
| metaData.setParent(axisConfig); |
| archiveReader.readModuleArchive(currentArchiveFile, metaData, explodedDir, |
| axisConfig); |
| metaData.setFileName(currentArchiveFile.getFile().toURL()); |
| addNewModule(metaData); |
| log.info(Messages.getMessage(DeploymentErrorMsgs.DEPLOYING_MODULE, |
| metaData.getName().getLocalPart())); |
| } catch (DeploymentException e) { |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_MODULE, |
| currentArchiveFile.getName(), |
| e.getMessage()), |
| e); |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| e.printStackTrace(error_ptintWriter); |
| moduleStatus = "Error:\n" + errorWriter.toString(); |
| } catch (AxisFault axisFault) { |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_MODULE, |
| currentArchiveFile.getName(), |
| axisFault.getMessage()), |
| axisFault); |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| axisFault.printStackTrace(error_ptintWriter); |
| moduleStatus = "Error:\n" + errorWriter.toString(); |
| } catch (MalformedURLException e) { |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_MODULE, |
| currentArchiveFile.getName(), |
| e.getMessage()), |
| e); |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| e.printStackTrace(error_ptintWriter); |
| moduleStatus = "Error:\n" + errorWriter.toString(); |
| } catch (Throwable t) { |
| if (log.isInfoEnabled()) { |
| StringWriter sw = new StringWriter(); |
| PrintWriter pw = new PrintWriter(sw); |
| t.printStackTrace(pw); |
| log.error(Messages.getMessage(DeploymentErrorMsgs.INVALID_MODULE, |
| currentArchiveFile.getName(), |
| t.getMessage()), |
| t); |
| } |
| PrintWriter error_ptintWriter = new PrintWriter(errorWriter); |
| t.printStackTrace(error_ptintWriter); |
| moduleStatus = "Error:\n" + errorWriter.toString(); |
| } finally { |
| if (moduleStatus.startsWith("Error:")) { |
| axisConfig.getFaultyModules().put( |
| getAxisServiceName(currentArchiveFile.getName()), moduleStatus); |
| } |
| currentArchiveFile = null; |
| } |
| break; |
| } |
| } catch (AxisFault axisFault) { |
| log.info(Messages.getMessage(DeploymentErrorMsgs.ERROR_SETTING_CLIENT_HOME, |
| axisFault.getMessage()), |
| axisFault); |
| } |
| } |
| } |
| |
| wsToDeploy.clear(); |
| } |
| |
| /** |
| * Checks if the modules, referred by server.xml, exist or that they are deployed. |
| */ |
| public void engageModules() throws AxisFault { |
| for (Iterator iterator = axisConfig.getGlobalModules().iterator(); iterator.hasNext();) { |
| QName name = (QName) iterator.next(); |
| axisConfig.engageModule(name); |
| } |
| } |
| |
| /** |
| * To get AxisConfiguration for a given inputStream this method can be used. |
| * The inputstream should be a valid axis2.xml , else you will be getting |
| * DeploymentExceptions. |
| * <p/> |
| * First creat a AxisConfiguration using given inputSream , and then it will |
| * try to find the repository location parameter from AxisConfiguration, so |
| * if user has add a parameter with the name "repository" , then the value |
| * specified by that parameter will be the repository and system will try to |
| * load modules and services from that repository location if it a valid |
| * location. hot deployment and hot update will work as usual in this case. |
| * <p/> |
| * You will be getting AxisConfiguration corresponding to given inputstream |
| * if it is valid , if something goes wrong you will be getting |
| * DeploymentExeption |
| * |
| * @param in |
| * @throws DeploymentException |
| */ |
| public AxisConfiguration populateAxisConfiguration(InputStream in) throws DeploymentException { |
| axisConfig = new AxisConfiguration(); |
| AxisConfigBuilder builder = new AxisConfigBuilder(in, axisConfig); |
| builder.populateConfig(); |
| try { |
| if (in != null) { |
| in.close(); |
| } |
| } catch (IOException e) { |
| log.info("error in closing input stream"); |
| } |
| return axisConfig; |
| } |
| |
| /** |
| * Starts the Deployment engine to perform Hot deployment and so on. |
| */ |
| private void startSearch(RepositoryListener listener) { |
| Scheduler scheduler = new Scheduler(); |
| |
| scheduler.schedule(new SchedulerTask(listener), new DeploymentIterator()); |
| } |
| |
| public void unDeploy() { |
| String fileName; |
| try { |
| if (wsToUnDeploy.size() > 0) { |
| for (int i = 0; i < wsToUnDeploy.size(); i++) { |
| WSInfo wsInfo = (WSInfo) wsToUnDeploy.get(i); |
| if (wsInfo.getType() == TYPE_SERVICE) { |
| if (isHotUpdate()) { |
| try { |
| fileName = getAxisServiceName(wsInfo.getFileName()); |
| axisConfig.removeServiceGroup(fileName); |
| log.info(Messages.getMessage(DeploymentErrorMsgs.SERVICE_REMOVED, |
| wsInfo.getFileName())); |
| } catch (AxisFault axisFault) { |
| //May be a faulty service |
| axisConfig.removeFaultyService(wsInfo.getFileName()); |
| } |
| } else { |
| axisConfig.removeFaultyService(wsInfo.getFileName()); |
| } |
| } |
| } |
| } |
| } catch (Exception e) { |
| log.info(e); |
| } |
| wsToUnDeploy.clear(); |
| } |
| |
| /** |
| * Checks whether some one has changed the system pre-defined phases |
| * for all the flows. If they have been changed,throws a DeploymentException. |
| * |
| * @throws DeploymentException |
| */ |
| private void validateSystemPredefinedPhases() throws DeploymentException { |
| PhasesInfo phasesInfo = axisConfig.getPhasesInfo(); |
| axisConfig.setInPhasesUptoAndIncludingPostDispatch(phasesInfo.getGlobalInflow()); |
| axisConfig.setInFaultPhases(phasesInfo.getGlobalInFaultPhases()); |
| axisConfig.setGlobalOutPhase(phasesInfo.getGlobalOutPhaseList()); |
| axisConfig.setOutFaultPhases(phasesInfo.getOUT_FaultPhases()); |
| } |
| |
| /** |
| * Gets AxisConfiguration. |
| * |
| * @return AxisConfiguration <code>AxisConfiguration</code> |
| */ |
| public AxisConfiguration getAxisConfig() { |
| return axisConfig; |
| } |
| |
| /** |
| * Retrieves service name from the archive file name. |
| * If the archive file name is service1.aar , then axis2 service name would be service1 |
| * |
| * @param fileName |
| * @return Returns String. |
| */ |
| private String getAxisServiceName(String fileName) { |
| char seperator = '.'; |
| String value; |
| int index = fileName.indexOf(seperator); |
| |
| if (index > 0) { |
| value = fileName.substring(0, index); |
| |
| return value; |
| } |
| |
| return fileName; |
| } |
| |
| public AxisModule getModule(QName moduleName) throws AxisFault { |
| return axisConfig.getModule(moduleName); |
| } |
| |
| public boolean isHotUpdate() { |
| return hotUpdate; |
| } |
| |
| public boolean isAntiJARLocking() { |
| return antiJARLocking; |
| } |
| |
| /** |
| * To set the all the classLoader hierarchy this method can be used , the top most parent is |
| * CCL then SCL(system Class Loader) |
| * CCL |
| * : |
| * SCL |
| * : : |
| * MCCL SCCL |
| * : : |
| * MCL SCL |
| * <p/> |
| * <p/> |
| * MCCL : module common class loader |
| * SCCL : Service common class loader |
| * MCL : module class loader |
| * SCL : Service class loader |
| * |
| * @param axis2repoURI : The repository folder of Axis2 |
| * @throws DeploymentException |
| */ |
| private void setClassLoaders(String axis2repoURI) throws DeploymentException { |
| ClassLoader sysClassLoader = |
| Utils.getClassLoader(Thread.currentThread().getContextClassLoader(), axis2repoURI); |
| |
| axisConfig.setSystemClassLoader(sysClassLoader); |
| if (servicesDir.exists()) { |
| axisConfig.setServiceClassLoader( |
| Utils.getClassLoader(axisConfig.getSystemClassLoader(), servicesDir)); |
| } else { |
| axisConfig.setServiceClassLoader(axisConfig.getSystemClassLoader()); |
| } |
| |
| if (modulesDir.exists()) { |
| axisConfig.setModuleClassLoader(Utils.getClassLoader(axisConfig.getSystemClassLoader(), |
| modulesDir)); |
| } else { |
| axisConfig.setModuleClassLoader(axisConfig.getSystemClassLoader()); |
| } |
| } |
| |
| /** |
| * Sets hotDeployment and hot update. |
| */ |
| private void setDeploymentFeatures() { |
| String value; |
| Parameter parahotdeployment = axisConfig.getParameter(TAG_HOT_DEPLOYMENT); |
| Parameter parahotupdate = axisConfig.getParameter(TAG_HOT_UPDATE); |
| // Parameter paraantiJARLocking = axisConfig.getParameter(TAG_ANTI_JAR_LOCKING); |
| |
| if (parahotdeployment != null) { |
| value = (String) parahotdeployment.getValue(); |
| |
| if ("false".equalsIgnoreCase(value)) { |
| hotDeployment = false; |
| } |
| } |
| |
| if (parahotupdate != null) { |
| value = (String) parahotupdate.getValue(); |
| |
| if ("false".equalsIgnoreCase(value)) { |
| hotUpdate = false; |
| } |
| } |
| |
| if (parahotupdate != null) { |
| value = (String) parahotupdate.getValue(); |
| |
| if ("true".equalsIgnoreCase(value)) { |
| antiJARLocking = true; |
| } |
| } |
| String serviceDirPara = (String) |
| axisConfig.getParameterValue(DeploymentConstants.SERVICE_DIR_PATH); |
| if (serviceDirPara != null) { |
| servicesPath = serviceDirPara; |
| } |
| |
| String moduleDirPara = (String) |
| axisConfig.getParameterValue(DeploymentConstants.MODULE_DRI_PATH); |
| if (moduleDirPara != null) { |
| modulesPath = moduleDirPara; |
| } |
| } |
| |
| /** |
| * Creates directories for modules/services, copies configuration xml from class loader if necessary |
| * |
| * @param repositoryName |
| */ |
| |
| private void prepareRepository(String repositoryName) { |
| File repository = new File(repositoryName); |
| if (servicesPath != null) { |
| servicesDir = new File(servicesPath); |
| if (!servicesDir.exists()) { |
| servicesDir = new File(repository, servicesPath); |
| } |
| } else { |
| servicesDir = new File(repository, DeploymentConstants.SERVICE_PATH); |
| } |
| if (!servicesDir.exists()) { |
| log.info(Messages.getMessage("noservicedirfound", getRepositoryPath(repository))); |
| } |
| if (modulesPath != null) { |
| modulesDir = new File(modulesPath); |
| if (!modulesDir.exists()) { |
| modulesDir = new File(repository, modulesPath); |
| } |
| } else { |
| modulesDir = new File(repository, DeploymentConstants.MODULE_PATH); |
| } |
| if (!modulesDir.exists()) { |
| log.info(Messages.getMessage("nomoduledirfound", getRepositoryPath(repository))); |
| } |
| } |
| |
| private String getRepositoryPath(File repository) { |
| try { |
| return repository.getCanonicalPath(); |
| } catch (IOException e) { |
| return repository.getAbsolutePath(); |
| } |
| } |
| |
| private ArrayList getFileList(URL fileListUrl) { |
| ArrayList fileList = new ArrayList(); |
| InputStream in; |
| try { |
| in = fileListUrl.openStream(); |
| } catch (IOException e) { |
| return fileList; |
| } |
| BufferedReader input = null; |
| try { |
| input = new BufferedReader(new InputStreamReader(in)); |
| String line; |
| while ((line = input.readLine()) != null) { |
| line = line.trim(); |
| if (line.length() > 0) { |
| fileList.add(line); |
| } |
| } |
| } catch (IOException ex) { |
| ex.printStackTrace(); |
| } finally { |
| try { |
| if (input != null) { |
| input.close(); |
| } |
| } |
| catch (IOException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| return fileList; |
| } |
| |
| public String getWebLocationString() { |
| return webLocationString; |
| } |
| |
| public void setWebLocationString(String webLocationString) { |
| this.webLocationString = webLocationString; |
| } |
| |
| public void setConfigContext(ConfigurationContext configContext) { |
| this.configContext = configContext; |
| } |
| |
| /** |
| * Builds ModuleDescription for a given module archive file. This does not |
| * called the init method since there is no reference to configuration context |
| * so who ever create module using this has to called module.init if it is |
| * required |
| * |
| * @param modulearchive : Actual module archive file |
| * @param config : AxisConfiguration : for get classloaders etc.. |
| * @throws org.apache.axis2.deployment.DeploymentException |
| * |
| */ |
| public static AxisModule buildModule(File modulearchive, |
| AxisConfiguration config) |
| throws DeploymentException { |
| AxisModule axismodule; |
| try { |
| ArchiveFileData currentArchiveFile = new ArchiveFileData(modulearchive, |
| DeploymentConstants.TYPE_MODULE, false); |
| axismodule = new AxisModule(); |
| ArchiveReader archiveReader = new ArchiveReader(); |
| |
| currentArchiveFile.setClassLoader(false, config.getModuleClassLoader()); |
| axismodule.setModuleClassLoader(currentArchiveFile.getClassLoader()); |
| archiveReader.readModuleArchive(currentArchiveFile, axismodule, |
| false, config); |
| ClassLoader moduleClassLoader = axismodule.getModuleClassLoader(); |
| Flow inflow = axismodule.getInFlow(); |
| |
| if (inflow != null) { |
| Utils.addFlowHandlers(inflow, moduleClassLoader); |
| } |
| |
| Flow outFlow = axismodule.getOutFlow(); |
| |
| if (outFlow != null) { |
| Utils.addFlowHandlers(outFlow, moduleClassLoader); |
| } |
| |
| Flow faultInFlow = axismodule.getFaultInFlow(); |
| |
| if (faultInFlow != null) { |
| Utils.addFlowHandlers(faultInFlow, moduleClassLoader); |
| } |
| |
| Flow faultOutFlow = axismodule.getFaultOutFlow(); |
| |
| if (faultOutFlow != null) { |
| Utils.addFlowHandlers(faultOutFlow, moduleClassLoader); |
| } |
| } catch (AxisFault axisFault) { |
| throw new DeploymentException(axisFault); |
| } |
| return axismodule; |
| } |
| |
| /** |
| * Fills an axisservice object using services.xml. First creates |
| * an axisservice object using WSDL and then fills it using the given services.xml. |
| * Loads all the required class and builds the chains, finally adds the |
| * servicecontext to EngineContext and axisservice into EngineConfiguration. |
| * |
| * @param serviceInputStream |
| * @param classLoader |
| * @return Returns AxisService. |
| * @throws DeploymentException |
| */ |
| public static AxisService buildService(InputStream serviceInputStream, |
| ClassLoader classLoader, |
| ConfigurationContext configCtx) |
| throws DeploymentException { |
| AxisService axisService = new AxisService(); |
| try { |
| |
| AxisConfiguration axisConfig = configCtx.getAxisConfiguration(); |
| Parameter parahotupdate = axisConfig.getParameter(TAG_HOT_UPDATE); |
| boolean antiJARLocking = true; |
| if (parahotupdate != null) { |
| String value = (String) parahotupdate.getValue(); |
| |
| if ("false".equalsIgnoreCase(value)) { |
| antiJARLocking = false; |
| } |
| } |
| ArchiveFileData currentArchiveFile = new ArchiveFileData( |
| DeploymentConstants.TYPE_SERVICE, "", antiJARLocking); |
| currentArchiveFile.setClassLoader(classLoader); |
| |
| ServiceBuilder builder = new ServiceBuilder(serviceInputStream, configCtx, |
| axisService); |
| |
| builder.populateService(builder.buildOM()); |
| } catch (AxisFault axisFault) { |
| throw new DeploymentException(axisFault); |
| } catch (XMLStreamException e) { |
| throw new DeploymentException(e); |
| } |
| |
| return axisService; |
| } |
| |
| /** |
| * To build a AxisServiceGroup for a given services.xml |
| * You have to add the created group into AxisConfig |
| * |
| * @param servicesxml : inpupstream create using services.xml |
| * @param classLoader : corresponding class loader to load the class |
| * @param serviceGroupName : name of the service group |
| * @throws AxisFault |
| */ |
| public static AxisServiceGroup buildServiceGroup(InputStream servicesxml, |
| ClassLoader classLoader, |
| String serviceGroupName, |
| ConfigurationContext configCtx, |
| ArchiveReader archiveReader, |
| HashMap wsdlServices) throws AxisFault { |
| ArchiveFileData currentArchiveFile = new ArchiveFileData( |
| DeploymentConstants.TYPE_SERVICE, "", false); |
| currentArchiveFile.setClassLoader(classLoader); |
| AxisServiceGroup serviceGroup = new AxisServiceGroup(); |
| serviceGroup.setServiceGroupClassLoader(classLoader); |
| serviceGroup.setServiceGroupName(serviceGroupName); |
| AxisConfiguration axisConfig = configCtx.getAxisConfiguration(); |
| try { |
| ArrayList serviceList = archiveReader.buildServiceGroup(servicesxml, |
| currentArchiveFile, serviceGroup, |
| wsdlServices, configCtx); |
| fillServiceGroup(serviceGroup, serviceList, null, axisConfig); |
| return serviceGroup; |
| } catch (XMLStreamException e) { |
| throw new AxisFault(e); |
| } |
| } |
| |
| public File getServicesDir() { |
| return servicesDir; |
| } |
| |
| public File getModulesDir() { |
| return modulesDir; |
| } |
| } |
