/* * Copyright (c) 2005-2010, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * * WSO2 Inc. 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.wso2.carbon.application.deployer.synapse; import org.apache.axiom.om.OMElement; import org.apache.axiom.om.OMException; import org.apache.axiom.om.impl.builder.StAXOMBuilder; import org.apache.axis2.AxisFault; import org.apache.axis2.deployment.Deployer; import org.apache.axis2.deployment.DeploymentEngine; import org.apache.axis2.deployment.DeploymentException; import org.apache.axis2.deployment.repository.util.DeploymentFileData; import org.apache.axis2.description.Parameter; import org.apache.axis2.engine.AxisConfiguration; import org.apache.commons.io.FileUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.synapse.deployers.AbstractSynapseArtifactDeployer; import org.apache.synapse.SynapseConstants; import org.apache.synapse.SynapseException; import org.apache.synapse.config.Entry; import org.apache.synapse.config.SynapseConfiguration; import org.apache.synapse.config.xml.EntryFactory; import org.apache.synapse.config.xml.SynapseImportFactory; import org.apache.synapse.config.xml.SynapseImportSerializer; import org.apache.synapse.config.xml.XMLConfigConstants; import org.apache.synapse.deployers.LibraryArtifactDeployer; import org.apache.synapse.deployers.SynapseArtifactDeploymentStore; import org.apache.synapse.libraries.imports.SynapseImport; import org.apache.synapse.libraries.model.Library; import org.apache.synapse.libraries.util.LibDeployerUtils; import org.apache.synapse.transport.customlogsetter.CustomLogSetter; import org.wso2.carbon.application.deployer.AppDeployerConstants; import org.wso2.carbon.application.deployer.AppDeployerUtils; import org.wso2.carbon.application.deployer.CarbonApplication; import org.wso2.carbon.application.deployer.config.Artifact; import org.wso2.carbon.application.deployer.config.CappFile; import org.wso2.carbon.application.deployer.handler.AppDeploymentHandler; import org.wso2.carbon.application.deployer.synapse.internal.DataHolder; import org.wso2.carbon.application.deployer.synapse.internal.SynapseAppDeployerDSComponent; import org.wso2.carbon.mediation.initializer.ServiceBusConstants; import org.wso2.carbon.mediation.initializer.ServiceBusUtils; import org.wso2.carbon.mediation.initializer.persistence.MediationPersistenceManager; import org.wso2.carbon.mediation.initializer.services.SynapseEnvironmentService; import org.wso2.carbon.mediation.library.service.LibraryInfo; import org.wso2.carbon.mediation.library.service.MediationLibraryAdminService; import org.wso2.carbon.mediation.library.util.LocalEntryUtil; import javax.xml.namespace.QName; import javax.xml.stream.XMLStreamException; import java.io.ByteArrayInputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Method; import java.util.List; import java.util.Map; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SynapseAppDeployer implements AppDeploymentHandler { private static final Log log = LogFactory.getLog(SynapseAppDeployer.class); private Map<String, Boolean> acceptanceList = null; private static String MAIN_XML="<sequence xmlns=\"http://ws.apache.org/ns/synapse\" name=\"main\"/>"; private static String FAULT_XML="<sequence xmlns=\"http://ws.apache.org/ns/synapse\" name=\"fault\"/>"; private static String MAIN_SEQ_REGEX = "main-\\d+\\.\\d+\\.\\d+\\.xml"; private static String FAULT_SEQ_REGEX = "fault-\\d+\\.\\d+\\.\\d+\\.xml"; /** * Deploy the artifacts which can be deployed through this deployer (endpoints, sequences, * proxy service etc.). * * @param carbonApp - CarbonApplication instance to check for artifacts * @param axisConfig - AxisConfiguration of the current tenant */ public void deployArtifacts(CarbonApplication carbonApp, AxisConfiguration axisConfig) throws DeploymentException{ List<Artifact.Dependency> artifacts = carbonApp.getAppConfig().getApplicationArtifact() .getDependencies(); deployClassMediators(artifacts, axisConfig); deploySynapseLibrary(artifacts, axisConfig); for (Artifact.Dependency dep : artifacts) { Artifact artifact = dep.getArtifact(); if (!validateArtifact(artifact)) { continue; } String artifactDirName = getArtifactDirName(artifact); if (artifactDirName == null) { continue; } Deployer deployer = getDeployer(axisConfig, artifactDirName); String artifactDir = getArtifactDirPath(axisConfig, artifactDirName); artifact.setRuntimeObjectName(artifact.getName()); if (deployer != null) { String fileName = artifact.getFiles().get(0).getName(); String artifactPath = artifact.getExtractedPath() + File.separator + fileName; File artifactInRepo = new File(artifactDir + File.separator + fileName); if (SynapseAppDeployerConstants.SEQUENCE_TYPE.equals(artifact.getType()) && handleMainFaultSeqDeployment(artifact, axisConfig)) { } else if (artifactInRepo.exists()) { log.warn("Artifact " + fileName + " already found in " + artifactInRepo.getAbsolutePath() + ". Ignoring CAPP's artifact"); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } else { try { setCustomLogContent(deployer, carbonApp); deployer.deploy(new DeploymentFileData(new File(artifactPath), deployer)); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } catch (DeploymentException e) { artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_FAILED); throw e; } finally { //clear the log appender once deployment is finished to avoid appending the //same log to other classes. setCustomLogContent(deployer, null); CustomLogSetter.getInstance().clearThreadLocalContent(); } } } } } /** * Un-deploys Synapse artifacts found in this application. Just delete the files from the * hot folders. Synapse hot deployer will do the rest.. * * @param carbonApplication - CarbonApplication instance * @param axisConfig - AxisConfiguration of the current tenant */ public void undeployArtifacts(CarbonApplication carbonApplication, AxisConfiguration axisConfig) throws DeploymentException{ List<Artifact.Dependency> artifacts = carbonApplication.getAppConfig() .getApplicationArtifact().getDependencies(); for (Artifact.Dependency dep : artifacts) { Artifact artifact = dep.getArtifact(); if (!validateArtifact(artifact)) { continue; } Deployer deployer; String artifactDir = null; if (SynapseAppDeployerConstants.MEDIATOR_TYPE.endsWith(artifact.getType())) { deployer = getClassMediatorDeployer(axisConfig); } else if(SynapseAppDeployerConstants.SYNAPSE_LIBRARY_TYPE.equals(artifact.getType())) { deployer = getSynapseLibraryDeployer(axisConfig); } else { String artifactDirName = getArtifactDirName(artifact); if (artifactDirName == null) { continue; } deployer = getDeployer(axisConfig, artifactDirName); artifactDir = getArtifactDirPath(axisConfig, artifactDirName); } if (deployer != null && AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED. equals(artifact.getDeploymentStatus())) { String fileName = artifact.getFiles().get(0).getName(); String artifactName = artifact.getName(); String artifactPath = artifact.getExtractedPath() + File.separator + fileName; File artifactInRepo = new File(artifactDir + File.separator + fileName); try { if (SynapseAppDeployerConstants.MEDIATOR_TYPE.endsWith(artifact.getType())) { if (deployer instanceof AbstractSynapseArtifactDeployer) { ((AbstractSynapseArtifactDeployer) deployer).setCustomLog(carbonApplication.getAppName(), AppDeployerUtils.getTenantIdLogString(AppDeployerUtils.getTenantId())); } deployer.undeploy(artifactPath); } else if (SynapseAppDeployerConstants.SYNAPSE_LIBRARY_TYPE.equals(artifact.getType())){ String libQName = getArtifactName(artifactPath, axisConfig); deleteImport(libQName, axisConfig); deployer.undeploy(artifactPath); } else if (SynapseAppDeployerConstants.SEQUENCE_TYPE.equals(artifact.getType()) && handleMainFaultSeqUndeployment(artifact, axisConfig)) { } else if (artifactInRepo.exists()) { log.info("Deleting artifact at " + artifactInRepo.getAbsolutePath()); if (!artifactInRepo.delete()) { log.error("Unable to delete " + artifactInRepo.getAbsolutePath()); } } else { // use reflection to avoid having synapse as a dependency Class[] paramString = new Class[1]; paramString[0] = String.class; Method method = deployer.getClass().getDeclaredMethod("undeploySynapseArtifact", paramString); method.invoke(deployer, artifactName); } artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_PENDING); File artifactFile = new File(artifactPath); if (artifactFile.exists() && !artifactFile.delete()) { log.warn("Couldn't delete App artifact file : " + artifactPath); } } catch (Exception e) { artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_FAILED); log.error("Error occured while trying to un deploy : "+ artifactName); } } } } /** * Deploy class mediators contains in the CApp * * @param artifacts List of Artifacts contains in the capp * @param axisConfig AxisConfiguration of the current tenant * @throws DeploymentException if something goes wrong while deployment */ private void deployClassMediators(List<Artifact.Dependency> artifacts, AxisConfiguration axisConfig) throws DeploymentException { for (Artifact.Dependency dependency : artifacts) { Artifact artifact = dependency.getArtifact(); if (!validateArtifact(artifact)) { continue; } if (SynapseAppDeployerConstants.MEDIATOR_TYPE.endsWith(artifact.getType())) { Deployer deployer = getClassMediatorDeployer(axisConfig); if (deployer != null) { artifact.setRuntimeObjectName(artifact.getName()); String fileName = artifact.getFiles().get(0).getName(); String artifactPath = artifact.getExtractedPath() + File.separator + fileName; try { deployer.deploy(new DeploymentFileData(new File(artifactPath), deployer)); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } catch (DeploymentException e) { artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_FAILED); throw e; } } } } } /** * Deploy synapse libraries contains in the CApp * * @param artifacts List of Artifacts contains in the capp * @param axisConfig AxisConfiguration of the current tenant * @throws DeploymentException if something goes wrong while deployment */ private void deploySynapseLibrary(List<Artifact.Dependency> artifacts, AxisConfiguration axisConfig) throws DeploymentException { for (Artifact.Dependency dependency : artifacts) { Artifact artifact = dependency.getArtifact(); if (!validateArtifact(artifact)) { continue; } if (SynapseAppDeployerConstants.SYNAPSE_LIBRARY_TYPE.equals(artifact.getType())) { Deployer deployer = getSynapseLibraryDeployer(axisConfig); if (deployer != null) { artifact.setRuntimeObjectName(artifact.getName()); String fileName = artifact.getFiles().get(0).getName(); String artifactPath = artifact.getExtractedPath() + File.separator + fileName; String artifactDir = getArtifactDirPath(axisConfig, SynapseAppDeployerConstants.SYNAPSE_LIBS); File artifactInRepo = new File(artifactDir + File.separator + fileName); if (artifactInRepo.exists()) { log.warn("Synapse Library " + fileName + " already found in " + artifactInRepo.getAbsolutePath() + ". Ignoring CAPP's artifact"); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } else { try { deployer.deploy(new DeploymentFileData(new File(artifactPath), deployer)); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); try { String artifactName = getArtifactName(artifactPath, axisConfig); SynapseConfiguration configuration = getSynapseConfiguration(axisConfig); if (artifactName != null) { if (configuration.getSynapseImports().get(artifactName) == null) { String libName = artifactName.substring(artifactName.lastIndexOf("}") + 1); String libraryPackage = artifactName.substring(1, artifactName.lastIndexOf("}")); updateStatus(artifactName, libName, libraryPackage, ServiceBusConstants.ENABLED, axisConfig); } } } catch (AxisFault axisFault) { log.error("Unable to update status for the synapse library : " + axisFault.getMessage()); } catch (NullPointerException nullException) { log.error("Error while getting qualified name of the synapse library : " + nullException.getMessage()); } } catch (DeploymentException e) { artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_FAILED); log.error("Error while deploying the synapse library : " + e.getMessage()); throw e; } } } } } } /** * * Get the library artifact name * @param axisConfig AxisConfiguration of the current tenant * @throws DeploymentException if something goes wrong while deployment * */ public String getArtifactName(String filePath, AxisConfiguration axisConfig) throws DeploymentException { SynapseArtifactDeploymentStore deploymentStore; deploymentStore = getSynapseConfiguration(axisConfig).getArtifactDeploymentStore(); return deploymentStore.getArtifactNameForFile(filePath); } /** * Helper method to retrieve the Synapse configuration from the relevant axis configuration * * @param axisConfig AxisConfiguration of the current tenant * @return extracted SynapseConfiguration from the relevant AxisConfiguration */ protected SynapseConfiguration getSynapseConfiguration(AxisConfiguration axisConfig) { return (SynapseConfiguration) axisConfig.getParameter( SynapseConstants.SYNAPSE_CONFIG).getValue(); } /** * Performing the action of enabling/disabling the given meidation library * * @param libName * @param packageName * @param status * @param axisConfig AxisConfiguration of the current tenant * @throws AxisFault */ public boolean updateStatus(String libQName, String libName, String packageName, String status, AxisConfiguration axisConfig) throws AxisFault { try { SynapseConfiguration synapseConfiguration = getSynapseConfiguration(axisConfig); SynapseImport synapseImport = synapseConfiguration.getSynapseImports().get(libQName); if (synapseImport == null && libName != null && packageName != null) { addImport(libName, packageName, axisConfig); synapseImport = synapseConfiguration.getSynapseImports().get(libQName); } Library synLib = synapseConfiguration.getSynapseLibraries().get(libQName); if (libQName != null && synLib != null) { if (ServiceBusConstants.ENABLED.equals(status)) { synapseImport.setStatus(true); synLib.setLibStatus(true); synLib.loadLibrary(); deployingLocalEntries(synLib, synapseConfiguration, axisConfig); } else { synapseImport.setStatus(false); synLib.setLibStatus(false); synLib.unLoadLibrary(); undeployingLocalEntries(synLib, synapseConfiguration, axisConfig); } } } catch (Exception e) { String message = "Unable to update status for : " + libQName; handleException(log, message, e); } return true; } /** * Performing the action of importing the given meidation library * * @param libName * @param packageName * @param axisConfig AxisConfiguration of the current tenant * @throws AxisFault */ public void addImport(String libName, String packageName, AxisConfiguration axisConfig) throws AxisFault { SynapseImport synImport = new SynapseImport(); synImport.setLibName(libName); synImport.setLibPackage(packageName); OMElement impEl = SynapseImportSerializer.serializeImport(synImport); if (impEl != null) { try { addImport(impEl.toString(), axisConfig); } catch (AxisFault axisFault) { handleException(log, "Could not add Synapse Import", axisFault); } } else { handleException(log, "Could not add Synapse Import. Invalid import params for libName : " + libName + " packageName : " + packageName, null); } } /** * * Undeploy the local entries deployed from the lib * * @param axisConfig AxisConfiguration of the current tenant * */ private void undeployingLocalEntries(Library library, SynapseConfiguration config, AxisConfiguration axisConfig) { if (log.isDebugEnabled()) { log.debug("Start : Removing Local registry entries from the configuration"); } for (Map.Entry<String, Object> libararyEntryMap : library.getLocalEntryArtifacts() .entrySet()) { File localEntryFileObj = (File) libararyEntryMap.getValue(); OMElement document = LocalEntryUtil.getOMElement(localEntryFileObj); deleteEntry(document.toString(), axisConfig); } if (log.isDebugEnabled()) { log.debug("End : Removing Local registry entries from the configuration"); } } /** * Get an XML configuration element for a message processor from the FE and * creates and add the MessageStore to the synapse configuration. * * @param xml * string that contain the message processor configuration. * @param axisConfig AxisConfiguration of the current tenant * @throws AxisFault * if some thing goes wrong when creating a MessageProcessor * with the given xml. */ private void addImport(String xml, AxisConfiguration axisConfig) throws AxisFault { try { OMElement imprtElem = createElement(xml); SynapseImport synapseImport = SynapseImportFactory.createImport(imprtElem, null); if (synapseImport != null && synapseImport.getName() != null) { SynapseConfiguration synapseConfiguration = getSynapseConfiguration(axisConfig); String fileName = ServiceBusUtils.generateFileName(synapseImport.getName()); synapseImport.setFileName(fileName); synapseConfiguration.addSynapseImport(synapseImport.getName(), synapseImport); String synImportQualfiedName = LibDeployerUtils.getQualifiedName(synapseImport); Library synLib = synapseConfiguration.getSynapseLibraries() .get(synImportQualfiedName); if (synLib != null) { LibDeployerUtils.loadLibArtifacts(synapseImport, synLib); } } else { String message = "Unable to create a Synapse Import for : " + xml; handleException(log, message, null); } } catch (XMLStreamException e) { String message = "Unable to create a Synapse Import for : " + xml; handleException(log, message, e); } } /** * Creates an <code>OMElement</code> from the given string * * @param str * the XML string * @return the <code>OMElement</code> representation of the given string * @throws javax.xml.stream.XMLStreamException * if building the <code>OmElement</code> is unsuccessful */ private OMElement createElement(String str) throws XMLStreamException { InputStream in = new ByteArrayInputStream(str.getBytes()); return new StAXOMBuilder(in).getDocumentElement(); } private void handleException(Log log, String message, Exception e) throws AxisFault { if (e == null) { AxisFault exception = new AxisFault(message); log.error(message, exception); throw exception; } else { message = message + " :: " + e.getMessage(); log.error(message, e); throw new AxisFault(message, e); } } /** * Helper method to get the persistence manger * @param axisConfig AxisConfiguration of the current tenant * @return persistence manager for this configuration context */ protected MediationPersistenceManager getMediationPersistenceManager(AxisConfiguration axisConfig) { return ServiceBusUtils.getMediationPersistenceManager(axisConfig); } /** * Deploy the local entries from lib * * @param axisConfig AxisConfiguration of the current tenant * */ private void deployingLocalEntries(Library library, SynapseConfiguration config, AxisConfiguration axisConfig) { if (log.isDebugEnabled()) { log.debug("Start : Adding Local registry entries to the configuration"); } for (Map.Entry<String, Object> libararyEntryMap : library.getLocalEntryArtifacts() .entrySet()) { File localEntryFileObj = (File) libararyEntryMap.getValue(); OMElement document = LocalEntryUtil.getOMElement(localEntryFileObj); addEntry(document.toString(), axisConfig); } if (log.isDebugEnabled()) { log.debug("End : Adding Local registry entries to the configuration"); } } /** * Add the local entry * * @param ele * @param axisConfig AxisConfiguration of the current tenant * */ private boolean addEntry(String ele, AxisConfiguration axisConfig) { final Lock lock = getLock(axisConfig); try { lock.lock(); OMElement elem; try { elem = LocalEntryUtil.nonCoalescingStringToOm(ele); } catch (XMLStreamException e) { log.error("Error while converting the file content : " + e.getMessage()); return false; } if (elem.getQName().getLocalPart().equals(XMLConfigConstants.ENTRY_ELT.getLocalPart())) { String entryKey = elem.getAttributeValue(new QName("key")); entryKey = entryKey.trim(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(axisConfig); if (log.isDebugEnabled()) { log.debug("Adding local entry with key : " + entryKey); } if (synapseConfiguration.getLocalRegistry().containsKey(entryKey)) { log.error("An Entry with key " + entryKey + " is already used within the configuration"); } else { Entry entry = EntryFactory.createEntry(elem, synapseConfiguration.getProperties()); entry.setFileName(ServiceBusUtils.generateFileName(entry.getKey())); synapseConfiguration.addEntry(entryKey, entry); MediationPersistenceManager pm = ServiceBusUtils.getMediationPersistenceManager(axisConfig); pm.saveItem(entry.getKey(), ServiceBusConstants.ITEM_TYPE_ENTRY); } if (log.isDebugEnabled()) { log.debug("Local registry entry : " + entryKey + " added to the configuration"); } return true; } else { log.warn("Error adding local entry. Invalid definition"); } } catch (SynapseException syne) { log.error("Unable to add local entry ", syne); } catch (OMException e) { log.error("Unable to add local entry. Invalid XML ", e); } catch (Exception e) { log.error("Unable to add local entry. Invalid XML ", e); } finally { lock.unlock(); } return false; } /** * Remove the local entry * * @param ele * @param axisConfig AxisConfiguration of the current tenant * */ public boolean deleteEntry(String ele, AxisConfiguration axisConfig) { final Lock lock = getLock(axisConfig); String entryKey = null; try { lock.lock(); OMElement elem; try { elem = LocalEntryUtil.nonCoalescingStringToOm(ele); } catch (XMLStreamException e) { log.error("Error while converting the file content : " + e.getMessage()); return false; } if (elem.getQName().getLocalPart().equals(XMLConfigConstants.ENTRY_ELT.getLocalPart())) { entryKey = elem.getAttributeValue(new QName("key")); entryKey = entryKey.trim(); log.debug("Adding local entry with key : " + entryKey); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(axisConfig); Entry entry = synapseConfiguration.getDefinedEntries().get(entryKey); if (entry != null) { synapseConfiguration.removeEntry(entryKey); MediationPersistenceManager pm = ServiceBusUtils.getMediationPersistenceManager(axisConfig); pm.deleteItem(entryKey, entry.getFileName(), ServiceBusConstants.ITEM_TYPE_ENTRY); if (log.isDebugEnabled()) { log.debug("Deleted local entry with key : " + entryKey); } return true; } else { log.warn("No entry exists by the key : " + entryKey); return false; } } } catch (SynapseException syne) { log.error("Unable to delete the local entry : " + entryKey, syne); } catch (Exception e) { log.error("Unable to delete the local entry : " + entryKey, e); } finally { lock.unlock(); } return false; } /** * Acquires the lock * * @param axisConfig AxisConfiguration instance * @return Lock instance */ protected Lock getLock(AxisConfiguration axisConfig) { Parameter p = axisConfig.getParameter(ServiceBusConstants.SYNAPSE_CONFIG_LOCK); if (p != null) { return (Lock) p.getValue(); } else { log.warn(ServiceBusConstants.SYNAPSE_CONFIG_LOCK + " is null, Recreating a new lock"); Lock lock = new ReentrantLock(); try { axisConfig.addParameter(ServiceBusConstants.SYNAPSE_CONFIG_LOCK, lock); return lock; } catch (AxisFault axisFault) { log.error("Error while setting " + ServiceBusConstants.SYNAPSE_CONFIG_LOCK); } } return null; } /** * Delete the SynapseImport instance with given importQualifiedName in the * synapse configuration * * @param importQualifiedName * of the MessageProcessor to be deleted * @param axisConfig AxisConfiguration of the current tenant * @throws AxisFault * if Message processor does not exist */ public void deleteImport(String importQualifiedName, AxisConfiguration axisConfig) throws AxisFault { try { SynapseConfiguration configuration = getSynapseConfiguration(axisConfig); assert configuration != null; if (configuration.getSynapseImports().containsKey(importQualifiedName)) { SynapseImport synapseImport = configuration.removeSynapseImport(importQualifiedName); String fileName = synapseImport.getFileName(); // get corresponding library for un-loading this import Library synLib = configuration.getSynapseLibraries() .get(importQualifiedName); if (synLib != null) { // this is a important step -> we need to unload what ever the // components loaded thru this import synLib.unLoadLibrary(); undeployingLocalEntries(synLib, configuration, axisConfig); } } } catch (Exception e) { log.error("Error occured while deleting the synapse library import"); } } /** * Handle main and fault sequence deployment. * Since main.xml and fault.xml is already in filesystem, we only can update those. * NO direct deployer call and sync deployment * * @param artifact Sequence Artifact * @param axisConfig AxisConfiguration of the current tenant * @return whether main or fault sequence is handled */ private boolean handleMainFaultSeqDeployment(Artifact artifact, AxisConfiguration axisConfig) { String fileName = artifact.getFiles().get(0).getName(); String artifactPath = artifact.getExtractedPath() + File.separator + fileName; boolean isMainOrFault = false; if (fileName.matches(MAIN_SEQ_REGEX) || fileName.matches(SynapseAppDeployerConstants.MAIN_SEQ_FILE)) { isMainOrFault = true; try { String mainXMLPath = getMainXmlPath(axisConfig); log.info("Copying main sequence to " + mainXMLPath); FileUtils.copyFile(new File(artifactPath), new File(mainXMLPath)); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } catch (IOException e) { log.error("Error copying main.xml to sequence directory", e); } } else if (fileName.matches(FAULT_SEQ_REGEX) || fileName.matches(SynapseAppDeployerConstants.FAULT_SEQ_FILE)) { isMainOrFault = true; try { String faultXMLPath = getFaultXmlPath(axisConfig); log.info("Copying fault sequence to " + faultXMLPath); FileUtils.copyFile(new File(artifactPath), new File(faultXMLPath)); artifact.setDeploymentStatus(AppDeployerConstants.DEPLOYMENT_STATUS_DEPLOYED); } catch (IOException e) { log.error("Error copying main.xml to sequence directory", e); } } return isMainOrFault; } /** * Handle main and fault sequence un-deployment. * Since main.xml and fault.xml is already in filesystem, we only can update those. * NO direct deployer call * * @param artifact Sequence Artifact * @param axisConfig AxisConfiguration of the current tenant * @return whether main or fault sequence is handled * @throws java.io.IOException */ private boolean handleMainFaultSeqUndeployment(Artifact artifact, AxisConfiguration axisConfig) throws IOException { boolean isMainOrFault = false; String fileName = artifact.getFiles().get(0).getName(); if (fileName.matches(MAIN_SEQ_REGEX) || fileName.matches(SynapseAppDeployerConstants.MAIN_SEQ_FILE)) { isMainOrFault = true; String mainXMLPath = getMainXmlPath(axisConfig); FileUtils.deleteQuietly(new File(mainXMLPath)); FileUtils.writeStringToFile(new File(mainXMLPath), MAIN_XML); } else if (fileName.matches(FAULT_SEQ_REGEX) || fileName.matches(SynapseAppDeployerConstants.FAULT_SEQ_FILE)) { isMainOrFault = true; String faultXMLPath = getFaultXmlPath(axisConfig); FileUtils.deleteQuietly(new File(faultXMLPath)); FileUtils.writeStringToFile(new File(faultXMLPath), FAULT_XML); } return isMainOrFault; } /** * Check whether a particular artifact type can be accepted for deployment. If the type doesn't * exist in the acceptance list, we assume that it doesn't require any special features to be * installed in the system. Therefore, that type is accepted. * If the type exists in the acceptance list, the acceptance value is returned. * * @param serviceType - service type to be checked * @return true if all features are there or entry is null. else false */ private boolean isAccepted(String serviceType) { if (acceptanceList == null) { acceptanceList = AppDeployerUtils.buildAcceptanceList(SynapseAppDeployerDSComponent .getRequiredFeatures()); } Boolean acceptance = acceptanceList.get(serviceType); return (acceptance == null || acceptance); } /** * Validate artifact * * @param artifact artifact to be validated * @return validation passed or not */ private boolean validateArtifact(Artifact artifact) { if (artifact == null) { return false; } if (!isAccepted(artifact.getType())) { log.warn("Can't deploy artifact : " + artifact.getName() + " of type : " + artifact.getType() + ". Required features are not installed in the system"); return false; } List<CappFile> files = artifact.getFiles(); if (files.size() != 1) { log.error("Synapse artifact types must have a single file to " + "be deployed. But " + files.size() + " files found."); return false; } return true; } /** * Finds the correct deployer for the given artifact type * * @param axisConfig - AxisConfiguration instance * @return Deployer instance */ private Deployer getDeployer(AxisConfiguration axisConfig, String directory) { Deployer deployer = null; // access the deployment engine through axis config DeploymentEngine deploymentEngine = (DeploymentEngine) axisConfig.getConfigurator(); String tenantId = AppDeployerUtils.getTenantIdString(axisConfig); SynapseEnvironmentService environmentService = DataHolder.getInstance(). getSynapseEnvironmentService(Integer.parseInt(tenantId)); if (environmentService != null) { String synapseConfigPath = ServiceBusUtils.getSynapseConfigAbsPath( environmentService.getSynapseEnvironment().getServerContextInformation()); String endpointDirPath = synapseConfigPath + File.separator + directory; deployer = deploymentEngine.getDeployer(endpointDirPath, ServiceBusConstants.ARTIFACT_EXTENSION); } return deployer; } /** * Get the deployer for the Class Mediators * * @param axisConfig AxisConfiguration instance * @return Deployer instance */ private Deployer getClassMediatorDeployer(AxisConfiguration axisConfig) { DeploymentEngine deploymentEngine = (DeploymentEngine) axisConfig.getConfigurator(); String classMediatorPath = axisConfig.getRepository().getPath() + File.separator + SynapseAppDeployerConstants.MEDIATORS_FOLDER; return deploymentEngine. getDeployer(classMediatorPath, ServiceBusConstants.CLASS_MEDIATOR_EXTENSION); } /** * Get the deployer for the Synapse Library * * @param axisConfig AxisConfiguration instance * @return Deployer instance */ private Deployer getSynapseLibraryDeployer(AxisConfiguration axisConfig) { try { String synapseLibraryPath = axisConfig.getRepository().getPath() + SynapseAppDeployerConstants.SYNAPSE_LIBS; DeploymentEngine deploymentEngine = (DeploymentEngine) axisConfig.getConfigurator(); deploymentEngine.addDeployer(new LibraryArtifactDeployer(), synapseLibraryPath, ServiceBusConstants.SYNAPSE_LIBRARY_EXTENSION); return deploymentEngine. getDeployer(synapseLibraryPath, ServiceBusConstants.SYNAPSE_LIBRARY_EXTENSION); } catch (Exception e) { log.error("Error occured while getting the deployer"); return null; } } /** * Get the artifact directory name for the artifact type * * @param artifact synapse artifact * @return artifact directory */ private String getArtifactDirName(Artifact artifact) { String artifactType = artifact.getType(); if (SynapseAppDeployerConstants.SEQUENCE_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.SEQUENCES_FOLDER; } else if (SynapseAppDeployerConstants.ENDPOINT_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.ENDPOINTS_FOLDER; } else if (SynapseAppDeployerConstants.PROXY_SERVICE_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.PROXY_SERVICES_FOLDER; } else if (SynapseAppDeployerConstants.LOCAL_ENTRY_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.LOCAL_ENTRIES_FOLDER; } else if (SynapseAppDeployerConstants.EVENT_SOURCE_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.EVENTS_FOLDER; } else if (SynapseAppDeployerConstants.TASK_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.TASKS_FOLDER; } else if (SynapseAppDeployerConstants.MESSAGE_STORE_TYPE.endsWith(artifactType)) { return SynapseAppDeployerConstants.MESSAGE_STORE_FOLDER; } else if (SynapseAppDeployerConstants.MESSAGE_PROCESSOR_TYPE.endsWith(artifactType)) { return SynapseAppDeployerConstants.MESSAGE_PROCESSOR_FOLDER; } else if (SynapseAppDeployerConstants.API_TYPE.endsWith(artifactType)) { return SynapseAppDeployerConstants.APIS_FOLDER; } else if (SynapseAppDeployerConstants.TEMPLATE_TYPE.endsWith(artifactType)) { return SynapseAppDeployerConstants.TEMPLATES_FOLDER; } else if (SynapseAppDeployerConstants.INBOUND_ENDPOINT_TYPE.endsWith(artifactType)) { return SynapseAppDeployerConstants.INBOUND_ENDPOINT_FOLDER; } else if (SynapseAppDeployerConstants.SYNAPSE_LIBRARY_TYPE.equals(artifactType)) { return SynapseAppDeployerConstants.SYNAPSE_LIBS; } return null; } /** * Get the absolute path of the artifact directory * * @param axisConfiguration axis configuration * @param artifactDirName synapse artifact directory name * @return absolute path of artifact directory */ private String getArtifactDirPath(AxisConfiguration axisConfiguration, String artifactDirName) { if (artifactDirName.equals(SynapseAppDeployerConstants.SYNAPSE_LIBS)) { return axisConfiguration.getRepository().getPath() + SynapseAppDeployerConstants.SYNAPSE_LIBS; } else { return axisConfiguration.getRepository().getPath() + SynapseAppDeployerConstants.SYNAPSE_CONFIGS + File.separator + SynapseAppDeployerConstants.DEFAULT_DIR + File.separator + artifactDirName; } } private String getMainXmlPath(AxisConfiguration axisConfig) { return axisConfig.getRepository().getPath() + SynapseAppDeployerConstants.SYNAPSE_CONFIGS + File.separator + SynapseAppDeployerConstants.DEFAULT_DIR + File.separator + SynapseAppDeployerConstants.SEQUENCES_FOLDER + File.separator + SynapseAppDeployerConstants.MAIN_SEQ_FILE; } private String getFaultXmlPath(AxisConfiguration axisConfig) { return axisConfig.getRepository().getPath() + SynapseAppDeployerConstants.SYNAPSE_CONFIGS + File.separator + SynapseAppDeployerConstants.DEFAULT_DIR + File.separator + SynapseAppDeployerConstants.SEQUENCES_FOLDER + File.separator + SynapseAppDeployerConstants.FAULT_SEQ_FILE; } /** * Set the custom log content if the per Artifact container logging is enabled * * @param deployer Application Deployer * @param carbonApp carbon application */ public void setCustomLogContent (Deployer deployer, CarbonApplication carbonApp) { if ((deployer instanceof AbstractSynapseArtifactDeployer)) { if (carbonApp != null) { ((AbstractSynapseArtifactDeployer) deployer).setCustomLog(carbonApp.getAppName(), AppDeployerUtils.getTenantIdLogString(AppDeployerUtils.getTenantId())); } else { ((AbstractSynapseArtifactDeployer) deployer).setCustomLog(null, null); } } } }