/** * Copyright (c) 2009, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * * 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.wso2.carbon.sequences.services; import org.apache.axiom.om.OMElement; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.synapse.Mediator; 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.MediatorFactoryFinder; import org.apache.synapse.config.xml.MediatorSerializerFinder; import org.apache.synapse.config.xml.SynapseXMLConfigurationFactory; import org.apache.synapse.config.xml.XMLConfigConstants; import org.apache.synapse.endpoints.Endpoint; import org.apache.synapse.mediators.base.SequenceMediator; import org.apache.synapse.registry.Registry; import org.apache.axis2.context.ConfigurationContext; import org.apache.axis2.context.MessageContext; import org.apache.axis2.engine.AxisConfiguration; import org.apache.axis2.util.XMLPrettyPrinter; import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.core.CarbonConfigurationContextFactory; import org.wso2.carbon.core.multitenancy.utils.TenantAxisUtils; import org.wso2.carbon.mediation.dependency.mgt.services.DependencyManagementService; import org.wso2.carbon.mediation.initializer.AbstractServiceBusAdmin; 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.registry.core.Resource; import org.wso2.carbon.registry.core.exceptions.RegistryException; import org.wso2.carbon.sequences.common.SequenceEditorException; import org.wso2.carbon.sequences.common.factory.SequenceInfoFactory; import org.wso2.carbon.sequences.common.to.ConfigurationObject; import org.wso2.carbon.sequences.common.to.SequenceInfo; import org.wso2.carbon.sequences.internal.ConfigHolder; import org.wso2.carbon.utils.multitenancy.MultitenantConstants; import javax.xml.namespace.QName; import java.io.ByteArrayOutputStream; import java.util.*; import java.util.concurrent.locks.Lock; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Takes care of all the administration activities related to <code>Sequences</code> * in the initialized synapse environment</p> * * <p>The administration activities include;</p> * <ul> * <li>Adding sequences</li> * <li>Editing sequences</li> * <li>Saving sequence</li> * <li>Deleting sequences</li> * <li>Enabling/disabling statistics/tracing of sequences</li> * <li>Editing of dynamic sequences</li> * <li>and so on...</li> * </ul> */ @SuppressWarnings({"UnusedDeclaration"}) public class SequenceAdmin extends AbstractServiceBusAdmin { private static final Log log = LogFactory.getLog(SequenceAdmin.class); //TODO: Move WSO2_SEQUENCE_MEDIA_TYPE to registry public static final String WSO2_SEQUENCE_MEDIA_TYPE ="application/vnd.wso2.sequence"; public SequenceInfo[] getSequences(int pageNumber,int sequencePerPage) throws SequenceEditorException { final Lock lock = getLock(); Collection<SequenceMediator> sequences = null; try { lock.lock(); sequences = getSynapseConfiguration().getDefinedSequences().values(); SequenceInfo[] info = SequenceInfoFactory.getSortedSequenceInfoArray(sequences); SequenceInfo[] ret; if (info != null && info.length > 0) { for (SequenceInfo seqInfo : info) { SequenceMediator seq = getSynapseConfiguration().getDefinedSequences().get(seqInfo.getName()); if (seq.getArtifactContainerName() != null) { seqInfo.setArtifactContainerName(seq.getArtifactContainerName()); } if (seq.isEdited()) { seqInfo.setIsEdited(true); } } } if (info.length >= (sequencePerPage * pageNumber + sequencePerPage)) { ret = new SequenceInfo[sequencePerPage]; } else { ret = new SequenceInfo[info.length - (sequencePerPage * pageNumber)]; } for (int i = 0; i < sequencePerPage; ++i) { if (ret.length > i) ret[i] = info[sequencePerPage * pageNumber + i]; } return ret; } catch (Exception fault) { handleException("Couldn't get the Synapse Configuration to " + "get the available sequences", fault); } finally { lock.unlock(); } return null; } public int getSequencesCount() throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); return getSynapseConfiguration().getDefinedSequences().values().size(); } catch (Exception e) { handleException("Couldn't get the Synapse Configuration to get Sequence count", e); } finally { lock.unlock(); } return 0; } @SuppressWarnings({"unchecked"}) public SequenceInfo[] getDynamicSequences(int pageNumber, int sequencePerPage) throws SequenceEditorException { org.wso2.carbon.registry.core.Registry registry; SequenceInfo[] ret; final Lock lock = getLock(); try { lock.lock(); String[] configInfo = getConfigSystemRegistry() !=null?getMimeTypeResult(getConfigSystemRegistry()):new String[0]; String[] govInfo = getGovernanceRegistry() != null ?getMimeTypeResult(getGovernanceRegistry()):new String[0]; String[] info = new String[(configInfo != null?configInfo.length:0) + (govInfo !=null?govInfo.length:0)]; int ptr = 0; for (String aConfigInfo : configInfo) { info[ptr] = "conf:" + aConfigInfo; ++ptr; } for (String aGovInfo : govInfo) { info[ptr] = "gov:" + aGovInfo; ++ptr; } Arrays.sort(info); if (info.length >= (sequencePerPage * pageNumber + sequencePerPage)) { ret = new SequenceInfo[sequencePerPage]; } else { ret = new SequenceInfo[info.length - (sequencePerPage * pageNumber)]; } for (int i = 0; i < sequencePerPage; ++i) { if (ret.length > i) { SequenceInfo seq = new SequenceInfo(); seq.setName(info[sequencePerPage * pageNumber + i]); ret[i] = seq; } } } catch (Exception e) { handleException("Unable to get Dynamic Sequence Info",e); return null; } finally { lock.unlock(); } return ret; } public int getDynamicSequenceCount() throws SequenceEditorException { try { String[] govList = getGovernanceRegistry() !=null ?getMimeTypeResult(getGovernanceRegistry()) : new String[0]; String[] confList = getConfigSystemRegistry() !=null ? getMimeTypeResult(getConfigSystemRegistry()) : new String[0]; return (confList != null ?confList.length:0) + (govList != null ?govList.length:0); } catch (Exception e) { return 0; } } @SuppressWarnings({"unchecked"}) private String[] getMimeTypeResult(org.wso2.carbon.registry.core.Registry targetRegistry) throws Exception { String sql = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE WHERE REG_MEDIA_TYPE = ?"; Map parameters = new HashMap(); parameters.put("query", sql); parameters.put("1", WSO2_SEQUENCE_MEDIA_TYPE); Resource result = targetRegistry.executeQuery(null, parameters); return (String[]) result.getContent(); } /** * Deletes the sequence with the given name from SynapseConfiguration * * @param sequenceName - Name of the sequence to delete * @throws SequenceEditorException if the Sequence described by the given name doesn't * exist in the Synapse Configuration */ public void deleteSequence(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synCfg = getSynapseConfiguration(); SequenceMediator sequence = synCfg.getDefinedSequences().get(sequenceName); if (sequence != null && sequence.getArtifactContainerName() == null) { synCfg.removeSequence(sequenceName); MediationPersistenceManager pm = getMediationPersistenceManager(); pm.deleteItem(sequenceName, sequence.getFileName(), ServiceBusConstants.ITEM_TYPE_SEQUENCE); } else { handleException("No defined sequence with name " + sequenceName + " found to delete in the Synapse configuration"); } } catch (Exception fault) { handleException("Couldn't get the Synapse Configuration to delete the sequence", fault); } finally { lock.unlock(); } } /** * Set the tenant domain when a publisher deletes custom sequences in MT mode. When publisher * deletes the sequence, we login the gateway as supertenant. But we need to delete in the particular * tenant domain. * * @param sequenceName * @param tenantDomain * @throws SequenceEditorException */ public void deleteSequenceForTenant(String sequenceName, String tenantDomain) throws SequenceEditorException{ try { PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true); deleteSequence(sequenceName); } catch (Exception e) { handleException("Issue is in deleting the sequence definition"); } finally { PrivilegedCarbonContext.endTenantFlow(); } } /** * Delete Selected Sequence in the synapse configuration * * @param sequenceNames * @throws SequenceEditorException */ public void deleteSelectedSequence(String[] sequenceNames) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synCfg = getSynapseConfiguration(); List<String> list = new ArrayList<String>(); Collections.addAll(list, sequenceNames); list.remove("main"); list.remove("fault"); sequenceNames = list.toArray(new String[list.size()]); for (String sequenceName : sequenceNames) { SequenceMediator sequence = synCfg.getDefinedSequences().get(sequenceName); if (sequence != null && sequence.getArtifactContainerName() == null) { synCfg.removeSequence(sequenceName); MediationPersistenceManager pm = getMediationPersistenceManager(); pm.deleteItem(sequenceName, sequence.getFileName(), ServiceBusConstants.ITEM_TYPE_SEQUENCE); } } } catch (Exception fault) { handleException("Couldn't get the Synapse Configuration to delete the sequence", fault); } finally { lock.unlock(); } } /** * Delete all the sequences in the synapse configuration * * @throws SequenceEditorException */ public void deleteAllSequence() throws SequenceEditorException { final Lock lock = getLock(); Collection<SequenceMediator> sequences = null; try { lock.lock(); sequences = getSynapseConfiguration().getDefinedSequences().values(); SynapseConfiguration synCfg = getSynapseConfiguration(); for (SequenceMediator sequence : sequences) { if (sequence != null) { if ((!sequence.getName().equals("main")) && (!sequence.getName().equals("fault")) && sequence.getArtifactContainerName() == null) { synCfg.removeSequence(sequence.getName()); MediationPersistenceManager pm = getMediationPersistenceManager(); pm.deleteItem(sequence.getName(), sequence.getFileName(), ServiceBusConstants.ITEM_TYPE_SEQUENCE); } } } } catch (Exception fault) { handleException("Unable to delete entire sequences in the synapse configuration", fault); } finally { lock.unlock(); } } /** * Returns the OMelement representation of the sequence given by sequence * name * * @param sequenceName - name of the sequence to get * @return OMElement representing the SequenceMediator of the given sequence * name * @throws SequenceEditorException if any error occured while getting the data from the * SynapseConfiguration */ public OMElement getSequence(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); if (synapseConfiguration.getSequence(sequenceName) != null) { return MediatorSerializerFinder.getInstance().getSerializer( synapseConfiguration.getSequence(sequenceName)) .serializeMediator(null, synapseConfiguration .getSequence(sequenceName)); } else { handleException("Sequence with the name " + sequenceName + " does not exist"); } } catch (SynapseException syne) { handleException("Unable to get the sequence : " + sequenceName, syne); } catch (Exception fault) { handleException("Couldn't get the Synapse Configuration to get the sequence", fault); } finally { lock.unlock(); } return null; } /** * Set the tenant domain when a publisher tries to get custom sequences in MT mode. When publisher * tries to get the sequence, we login the gateway as supertenant. But we need to get in the particular * tenant domain. * * @param sequenceName * @param tenantDomain * @throws SequenceEditorException * */ public OMElement getSequenceForTenant(String sequenceName, String tenantDomain) throws SequenceEditorException{ try { PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true); OMElement seq = getSequence(sequenceName); return seq; } catch (Exception e) { handleException("Issue is in getting the sequence definition"); } finally { PrivilegedCarbonContext.endTenantFlow(); } return null; } /** * Add a sequence into the synapseConfiguration * * @param sequenceElement - Sequence object to be added as an OMElement * @throws SequenceEditorException if a sequence exists with the same name or if the * element provided is not a Sequence element */ public void addSequence(OMElement sequenceElement) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); if (sequenceElement.getLocalName().equals( XMLConfigConstants.SEQUENCE_ELT.getLocalPart())) { String sequenceName = sequenceElement.getAttributeValue(new QName("name")); if("".equals(sequenceName) || null == sequenceName) { handleException("sequence name is required."); } SynapseConfiguration config = getSynapseConfiguration(); if(log.isDebugEnabled()) { log.debug("Adding sequence : " + sequenceName + " to the configuration"); } if (config.getLocalRegistry().get(sequenceName) != null) { handleException("The name '" + sequenceName + "' is already used within the configuration - a sequence or local entry with this name already exists"); } else { SynapseXMLConfigurationFactory.defineSequence(config, sequenceElement, getSynapseConfiguration().getProperties()); if(log.isDebugEnabled()) { log.debug("Added sequence : " + sequenceName + " to the configuration"); } SequenceMediator seq = config.getDefinedSequences().get(sequenceName); seq.setFileName(ServiceBusUtils.generateFileName(sequenceName)); seq.init(getSynapseEnvironment()); //noinspection ConstantConditions persistSequence(seq); } } else { handleException("Invalid sequence definition"); } } catch (Exception fault) { throw new SequenceEditorException("Error adding sequence : " + fault.getMessage(), fault); } catch (Error error) { throw new SequenceEditorException("Unexpected error occured while " + "adding the sequence : " + error.getMessage(), error); } finally { lock.unlock(); } } /** * Set the tenant domain when a publisher deploys custom sequences in MT mode. When publisher * deploys the sequence, we login the gateway as supertenant. But we need to deploy in the particular * tenant domain. * * @param sequenceElement * @param tenantDomain * @throws SequenceEditorException */ public void addSequenceForTenant(OMElement sequenceElement, String tenantDomain) throws SequenceEditorException{ try { PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true); addSequence(sequenceElement); } catch (Exception e) { handleException("Issue in deploying the sequence definition"); } finally { PrivilegedCarbonContext.endTenantFlow(); } } public boolean isExistingSequence(String sequenceName){ SynapseConfiguration config = getSynapseConfiguration(); if (config.getLocalRegistry().get(sequenceName) != null){ return true; } return false; } public boolean isExistingSequenceForTenant(String sequenceName, String tenantDomain){ PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true); return isExistingSequence(sequenceName); } /** * Saves the sequence described with the sequence string * * @param sequenceElement - String representing the XML describing the * Sequence * @throws SequenceEditorException if the sequence name already exists or if the string * doesn't represent a Sequence element */ public void saveSequence(OMElement sequenceElement) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); /**The SynapseXPathFactory adds all namespaces defined in the upper levels of the xpath element to the xpath. *Remove the sequence element from its parent to avoid inheritance of unwanted namespaces (ex: namespace of *the admin service operation)*/ sequenceElement.detach(); if (sequenceElement != null && sequenceElement.getLocalName().equals( XMLConfigConstants.SEQUENCE_ELT.getLocalPart())) { String sequenceName = sequenceElement.getAttributeValue(new QName("name")); SynapseConfiguration config = getSynapseConfiguration(); log.debug("Saving sequence : " + sequenceName); SequenceMediator preSeq = config.getDefinedSequences().get(sequenceName); if (preSeq == null) { handleException("Unable to save sequence " + sequenceName + ". Does not exist"); } else { // we should first try to build the new sequence. if exception we return Mediator mediator = MediatorFactoryFinder.getInstance().getMediator( sequenceElement, getSynapseConfiguration().getProperties()); boolean statisticsEnable = preSeq.isStatisticsEnable(); // if everything went successfully we remove the sequence config.removeSequence(sequenceName); if (mediator instanceof SequenceMediator) { if (statisticsEnable) { ((SequenceMediator) mediator).enableStatistics(); } ((SequenceMediator)mediator).setFileName(preSeq.getFileName()); } config.addSequence(sequenceName, mediator); log.debug("Saved sequence : " + sequenceName + " to the configuration"); SequenceMediator seq = config.getDefinedSequences().get(sequenceName); if (seq != null) { seq.init(getSynapseEnvironment()); if (preSeq.getArtifactContainerName() != null) { seq.setArtifactContainerName(preSeq.getArtifactContainerName()); seq.setIsEdited(true); Collection<SequenceMediator> sequenceMediators = new ArrayList<>(); sequenceMediators.add(seq); SequenceInfo[] sequenceInfoTemp = SequenceInfoFactory.getSortedSequenceInfoArray(sequenceMediators); sequenceInfoTemp[0].setIsEdited(true); sequenceInfoTemp[0].setArtifactContainerName(preSeq.getArtifactContainerName()); } else { persistSequence(seq); } } } } else { handleException("Unable to save sequence. Invalid definition"); } } catch (Exception fault) { handleException("Unable to save the Sequence : " + fault.getMessage(), fault); } finally { lock.unlock(); } } public String enableStatistics(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SequenceMediator sequence = (SequenceMediator) getSynapseConfiguration().getSequence(sequenceName); if (sequence != null) { sequence.enableStatistics(); if (sequence.getArtifactContainerName() == null) { persistSequence(sequence); } return sequenceName; } else { handleException("No defined sequence with name " + sequenceName + " found to enable statistics in the Synapse configuration"); } } catch (Exception fault) { handleException("Couldn't enable statistics of the sequence " + sequenceName + " : " + fault.getMessage(), fault); } finally { lock.unlock(); } return null; } public String disableStatistics(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SequenceMediator sequence = (SequenceMediator) getSynapseConfiguration().getSequence(sequenceName); if (sequence != null) { sequence.disableStatistics(); if (sequence.getArtifactContainerName() == null) { persistSequence(sequence); } return sequenceName; } else { handleException("No defined sequence with name " + sequenceName + " found to disable statistics in the Synapse configuration"); } } catch (Exception fault) { handleException("Couldn't disable statistics of the sequence " + sequenceName + " : " + fault.getMessage(), fault); } finally { lock.unlock(); } return null; } public String enableTracing(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SequenceMediator sequence = (SequenceMediator) getSynapseConfiguration().getSequence(sequenceName); if (sequence != null) { sequence.enableTracing(); sequence.enableStatistics(); // Tracing needs statistics to be enabled if (sequence.getArtifactContainerName() == null) { persistSequence(sequence); } return sequenceName; } else { handleException("No defined sequence with name " + sequenceName + " found to enable tracing in the Synapse configuration"); } } catch (Exception fault) { handleException("Couldn't enable tracing of the sequence " + sequenceName + " : " + fault.getMessage(), fault); } finally { lock.unlock(); } return null; } public String disableTracing(String sequenceName) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SequenceMediator sequence = (SequenceMediator) getSynapseConfiguration().getSequence(sequenceName); if (sequence != null) { sequence.disableTracing(); if (sequence.getArtifactContainerName() == null) { persistSequence(sequence); } return sequenceName; } else { handleException("No defined sequence with name " + sequenceName + " found to disable tracing in the Synapse configuration"); } } catch (Exception fault) { handleException("Couldn't disable tracing of the sequence " + sequenceName + " : " + fault.getMessage(), fault); } finally { lock.unlock(); } return null; } private void handleException(String message, Throwable cause) throws SequenceEditorException { log.error(message, cause); throw new SequenceEditorException(message, cause); } private void handleException(String message) throws SequenceEditorException { log.error(message); throw new SequenceEditorException(message); } public String getEntryNamesString() throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Map globalEntriesMap = synapseConfiguration.getLocalRegistry(); List<String> sequenceList = new ArrayList<String>(); List<String> endpointList = new ArrayList<String>(); List<String> entryList = new ArrayList<String>(); StringBuffer entrySb = new StringBuffer(); StringBuffer endpointSb = new StringBuffer(); StringBuffer sequenceSb = new StringBuffer(); for (Object entryValue : globalEntriesMap.values()) { if (entryValue instanceof Endpoint) { Endpoint endpoint = (Endpoint) entryValue; String name = endpoint.getName(); if (name != null) { endpointList.add(name); } } else if (entryValue instanceof SequenceMediator) { SequenceMediator sequenceMediator = (SequenceMediator) entryValue; String name = sequenceMediator.getName(); if (name != null) { sequenceList.add(name); } } else if (entryValue instanceof Entry) { Entry entry = (Entry) entryValue; if (!entry.isDynamic() && !entry.isRemote()) { // only care pre-defined local entries String key = entry.getKey(); if (SynapseConstants.SERVER_IP.equals(key) || SynapseConstants.SERVER_HOST.equals(key)) { continue; } entryList.add(key); } } } if (!sequenceList.isEmpty()) { Collections.sort(sequenceList, new Comparator<String>() { public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }); for (String name : sequenceList) { if (name != null) { sequenceSb.append("[Sequence]-").append(name).append(" "); } } } if (!entryList.isEmpty()) { Collections.sort(entryList, new Comparator<String>() { public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }); for (String name : entryList) { if (name != null) { entrySb.append("[Entry]-").append(name).append(" "); } } } if (!endpointList.isEmpty()) { Collections.sort(endpointList, new Comparator<String>() { public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }); for (String name : endpointList) { if (name != null) { endpointSb.append("[Endpoint]-").append(name).append(" "); } } } return endpointSb.toString() + entrySb.toString() + sequenceSb.toString(); } catch (Exception axisFault) { handleException("Error during retrieving local registry", axisFault); } finally { lock.unlock(); } return ""; } public void updateDynamicSequence(String key, OMElement omElement) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); deleteDynamicSequence(key); addDynamicSequence(key, omElement); } finally { lock.unlock(); } } public void deleteDynamicSequence(String key) throws SequenceEditorException { SynapseConfiguration synConfig = getSynapseConfiguration(); Registry registry = synConfig.getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleException("The key '" + key + "' cannot be found within the configuration"); } else { registry.delete(key); } } else { handleException("Unable to access the registry instance for the ESB"); } } public void addDynamicSequence(String key, OMElement sequence) throws SequenceEditorException { ByteArrayOutputStream stream = new ByteArrayOutputStream(); stream.reset(); try { XMLPrettyPrinter.prettify(sequence, stream); } catch (Exception e) { handleException("Unable to pretty print configuration",e); } try { org.wso2.carbon.registry.core.Registry registry; if(key.startsWith("conf:")) { registry = getConfigSystemRegistry(); key = key.replace("conf:",""); } else { registry = getGovernanceRegistry(); key = key.replace("gov:",""); } if(registry.resourceExists(key)){ handleException("Resource is already exists"); } Resource resource = registry.newResource(); resource.setMediaType(WSO2_SEQUENCE_MEDIA_TYPE); resource.setContent(new String(stream.toByteArray()).trim()); registry.put(key, resource); } catch (RegistryException e) { handleException("WSO2 Registry Exception", e); } } public OMElement getDynamicSequence(String key) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synConfig = getSynapseConfiguration(); Registry registry = synConfig.getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleException("No resource is available by the key '" + key + "'"); } return (OMElement) registry.getResource(new Entry(key), getSynapseConfiguration().getProperties()); } else { handleException("Unable to access the registry instance for the ESB"); } } finally { lock.unlock(); } return null; } public void saveDynamicSequence(String key, OMElement sequence) throws SequenceEditorException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synConfig = getSynapseConfiguration(); Registry registry = synConfig.getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleException("Unable to save the sequence. No resource is available " + "by the key '" + key + "'"); } registry.updateResource(key, sequence); } else { handleException("Unable to access the registry instance for the ESB"); } } finally { lock.unlock(); } } public ConfigurationObject[] getDependents(String sequence) { DependencyManagementService dependencyMgr = ConfigHolder.getInstance(). getDependencyManager(); if (dependencyMgr != null) { org.wso2.carbon.mediation.dependency.mgt.ConfigurationObject[] tempDependents = dependencyMgr.getDependents(org.wso2.carbon.mediation.dependency.mgt .ConfigurationObject.TYPE_SEQUENCE, sequence); if (tempDependents != null && tempDependents.length > 0) { List<ConfigurationObject> dependents = new ArrayList<ConfigurationObject>(); for (int i = 0; i < tempDependents.length; i++) { if (tempDependents[i].getType() != org.wso2.carbon.mediation.dependency.mgt.ConfigurationObject.TYPE_UNKNOWN) { dependents.add(new ConfigurationObject(tempDependents[i].getType(), tempDependents[i].getId())); } } if (dependents.size() > 0) { return dependents.toArray(new ConfigurationObject[dependents.size()]); } } } return null; } private void persistSequence(SequenceMediator sequence) throws SequenceEditorException { MediationPersistenceManager pm = getMediationPersistenceManager(); if (pm == null){ handleException("Cannot Persist sequence because persistence manager is null, " + "probably persistence is disabled"); } pm.saveItem(sequence.getName(), ServiceBusConstants.ITEM_TYPE_SEQUENCE); } /** * Override the AbstarctAdmin.java's getAxisConfig() to create the CarbonContext from ThreadLoaclContext. * We do this to support, publishing APIs as a supertenant but want to deploy that in tenant space. * (This model is needed for APIManager) */ protected AxisConfiguration getAxisConfig() { return (axisConfig != null) ? axisConfig : getConfigContext().getAxisConfiguration(); } protected ConfigurationContext getConfigContext() { if (configurationContext != null) { return configurationContext; } MessageContext msgContext = MessageContext.getCurrentMessageContext(); if (msgContext != null) { ConfigurationContext mainConfigContext = msgContext.getConfigurationContext(); // If a tenant has been set, then try to get the // ConfigurationContext of that tenant PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getThreadLocalCarbonContext(); String domain = carbonContext.getTenantDomain(); if (domain != null && !MultitenantConstants.SUPER_TENANT_DOMAIN_NAME.equals(domain)) { return TenantAxisUtils.getTenantConfigurationContext(domain, mainConfigContext); } else if (carbonContext.getTenantId() == MultitenantConstants.SUPER_TENANT_ID) { return mainConfigContext; } else { throw new UnsupportedOperationException( "Tenant domain unidentified. " + "Upstream code needs to identify & set the tenant domain & tenant ID. " + " The TenantDomain SOAP header could be set by the clients or " + "tenant authentication should be carried out."); } } else { return CarbonConfigurationContextFactory.getConfigurationContext(); } } private boolean isServiceSatisfySearchString(String searchString, String sequenceName) { if (searchString != null) { String regex = searchString.toLowerCase(). replace("..?", ".?").replace("..*", ".*"). replaceAll("\\?", ".?").replaceAll("\\*", ".*?"); Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(sequenceName.toLowerCase()); return regex.trim().length() == 0 || matcher.find(); } return false; } public SequenceInfo[] getSequencesSearch(String searchText) throws SequenceEditorException { final Lock lock = getLock(); Collection<SequenceMediator> sequences = null; List<SequenceInfo> searchedSequenceInfo = null; try { lock.lock(); sequences = getSynapseConfiguration().getDefinedSequences().values(); SequenceInfo[] info = SequenceInfoFactory.getSortedSequenceInfoArray(sequences); if (info != null && info.length > 0) { searchedSequenceInfo = new ArrayList<SequenceInfo>(); for (SequenceInfo infoTemp : info) { SequenceInfo seqInfo = new SequenceInfo(); seqInfo.setEnableStatistics(infoTemp.isEnableTracing()); seqInfo.setEnableTracing(infoTemp.isEnableTracing()); seqInfo.setName(infoTemp.getName()); seqInfo.setDescription(infoTemp.getDescription()); if (this.isServiceSatisfySearchString(searchText, seqInfo.getName())) { searchedSequenceInfo.add(seqInfo); } } } if (searchedSequenceInfo != null && searchedSequenceInfo.size() > 0) { return searchedSequenceInfo.toArray(new SequenceInfo[searchedSequenceInfo.size()]); } } catch (Exception fault) { handleException("Couldn't get the Synapse Configuration to " + "search sequences", fault); } finally { lock.unlock(); } return null; } }