/*
* Copyright (c) 2005-2008, 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.mediation.initializer.persistence;
import org.apache.axis2.AxisFault;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.Startup;
import org.apache.synapse.SynapseConstants;
import org.apache.synapse.config.Entry;
import org.apache.synapse.config.SynapseConfiguration;
import org.apache.synapse.config.xml.MultiXMLConfigurationSerializer;
import org.apache.synapse.config.xml.XMLConfigurationSerializer;
import org.apache.synapse.core.SynapseEnvironment;
import org.apache.synapse.core.axis2.ProxyService;
import org.apache.synapse.endpoints.Endpoint;
import org.apache.synapse.endpoints.Template;
import org.apache.synapse.inbound.InboundEndpoint;
import org.apache.synapse.mediators.base.SequenceMediator;
import org.apache.synapse.mediators.template.TemplateMediator;
import org.apache.synapse.message.processor.MessageProcessor;
import org.apache.synapse.message.store.MessageStore;
import org.apache.synapse.rest.API;
import org.wso2.carbon.mediation.initializer.RegistryBasedSynapseConfigSerializer;
import org.wso2.carbon.mediation.initializer.ServiceBusConstants;
import org.wso2.carbon.registry.core.session.UserRegistry;
import org.wso2.carbon.utils.CarbonUtils;
import javax.xml.stream.XMLStreamException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Manages all persistence activities related to mediation configuration. Takes care
* of saving configurations to the file system, registry and updating such configurations
* as and when necessary. All the mediation components (proxy services, sequences etc)
* should use this implementation to handle their persistence requirements. This class
* does not immediately carry out persistence requests. Requests are first queued up and
* then executed as batch jobs. Therefore admin services which initiate persistence
* requests does not have to 'wait' for disk and network I/O often associated with
* persistence activities. This improves the UI response times and system usability
* in a great deal.
*/
@SuppressWarnings({"UnusedDeclaration"})
public class MediationPersistenceManager {
private static final Log log = LogFactory.getLog(MediationPersistenceManager.class);
private UserRegistry registry;
private boolean initialized = false;
private String configPath;
private boolean flatFileMode;
private SynapseConfiguration synapseConfiguration;
private String configName;
/** Queue to hold persistence requests - Make sure all accesses are synchronized */
private final LinkedList<PersistenceRequest> requestQueue = new LinkedList<PersistenceRequest>();
private MediationPersistenceWorker worker;
private boolean acceptRequests;
private long interval = 5000L;
private Map<Integer, AbstractStore> dataStores;
/**
* Initialize the mediation persistence manager instance and start accepting
* and processing persistence requests. Persistence requests are carried out
* on the local file system and if required on the registry as well.
*
* @param registry The UserRegistry instance to be used for persistence or null
* @param configPath Path to the file/directory where configuration should be saved in
* @param synapseConfiguration synapse configuration to be used
* @param interval The wait time for the mediation persistence worker thread
* @param configName Name of the configuration to be used
*/
public MediationPersistenceManager(UserRegistry registry, String configPath,
SynapseConfiguration synapseConfiguration,
long interval, String configName) {
if (initialized) {
log.warn("Mediation persistence manager is already initialized");
return;
}
if (configPath == null) {
log.warn("Synapse configuration location is not provided - Unable to initialize " +
"the mediation persistence manager.");
return;
}
if (log.isDebugEnabled()) {
log.debug("Initializing the mediation persistence manager");
}
this.registry = registry;
this.configPath = configPath;
this.synapseConfiguration = synapseConfiguration;
this.configName = configName;
if (interval > 0) {
this.interval = interval;
} else {
log.warn("Invalid interval value " + interval + " for the mediation persistence " +
"worker, Using defaults");
}
File file = new File(configPath);
flatFileMode = file.exists() && file.isFile();
initDataStores();
worker = new MediationPersistenceWorker();
worker.start();
// and we are ready to launch....
acceptRequests = true;
initialized = true;
}
private void initDataStores() {
dataStores = new HashMap<Integer, AbstractStore>();
dataStores.put(ServiceBusConstants.ITEM_TYPE_PROXY_SERVICE,
new ProxyServiceStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_SEQUENCE,
new SequenceStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_ENDPOINT,
new EndpointStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_TASK,
new StartupStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_EVENT_SRC,
new EventSourceStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_ENTRY,
new LocalEntryStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_REGISTRY,
new SynapseRegistryStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_EXECUTOR,
new ExecutorStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_TEMPLATE,
new TemplateStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_TEMPLATE_ENDPOINTS,
new EndpointTemplateStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_MESSAGE_STORE,
new MessageStoreStore(configPath,registry,configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_MESSAGE_PROCESSOR,
new MessageProcessorStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_REST_API,
new APIStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_IMPORT,
new ImportStore(configPath, registry, configName));
dataStores.put(ServiceBusConstants.ITEM_TYPE_INBOUND,
new InboundStore(configPath, registry, configName));
}
public void destroy() {
if (!initialized) {
return;
}
// Stop accepting any more persistence requests
acceptRequests = false;
if (log.isDebugEnabled()) {
log.debug("Shutting down mediation persistence manager");
}
// Wait till the jobs already in the queue are done
while (!requestQueue.isEmpty()) {
try {
Thread.sleep(1000);
} catch (InterruptedException ignore) { }
}
// Halt the persistence worker thread
worker.proceed = false;
if (worker.isAlive()) {
// If the worker is asleep, wake him up
worker.interrupt();
}
initialized = false;
}
public boolean isInitialized() {
return initialized;
}
/**
* Save changes made to a particular item of the mediation configuration. Changes are
* saved to the local file system and if required to the registry as well. Types of
* supported mediation configuration items are defined in ServiceBusConstants. If the
* item to be saved should be written to its own configuration file, the file name
* attribute must be set on the item (in the SynapseConfiguration). Leaving the file
* name as null will cause the item to be persisted into the top level synapse.xml
* file.
*
* @param name Name/ID of the configuration item
* @param itemType type of the configuration item
*/
public void saveItem(String name, int itemType) {
if (!initialized || !acceptRequests) {
log.warn("Mediation persistence manager is either not initialized or not in the " +
"'accepting' mode. Ignoring the save request.");
return;
}
if (itemType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
saveFullConfiguration(false);
return;
}
PersistenceRequest request = new PersistenceRequest(name, itemType, true);
synchronized (requestQueue) {
addToQueue(request);
}
}
/**
* Delete a particular item in the saved mediation configuration. Item is removed from the
* local file system and if required to the registry as well. Types of
* supported mediation configuration items are defined in ServiceBusConstants.
*
* @param name Name/ID of the configuration item
* @param fileName Name of the file where the item is currently saved in
* @param itemType Type of the configuration item
*/
public void deleteItem(String name, String fileName, int itemType) {
if (!initialized || !acceptRequests) {
log.warn("Mediation persistence manager is either not initialized or not in the " +
"'accepting' mode. Ignoring the delete request.");
return;
}
if (itemType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
return;
}
PersistenceRequest request = new PersistenceRequest(name, fileName, itemType, false);
synchronized (requestQueue) {
addToQueue(request);
}
}
/**
* Save the specified item to the registry only. This method accepts request if and only
* if registry persistence is enabled for mediation configuration items. It is not
* recommended to use this method unless it is required to save something to the registry
* only. To save an item properly one must use the saveItem method.
*
* @param name Name/ID of the configuration item
* @param itemType Type of the configuration item
*/
public void saveItemToRegistry(String name, int itemType) {
if (registry == null) {
if (log.isDebugEnabled()) {
log.debug("Registry persistence is disabled for mediation configuration. " +
"Ignoring the persistence request for " + name);
}
return;
}
if (!initialized || !acceptRequests) {
log.warn("Mediation persistence manager is either not initialized or not in the " +
"'accepting' mode. Ignoring the save request.");
return;
}
if (itemType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
saveFullConfiguration(true);
return;
}
PersistenceRequest request = new PersistenceRequest(name, itemType, true);
request.registryOnly = true;
synchronized (requestQueue) {
addToQueue(request);
}
}
/**
* Delete the specified item from the registry only. This method accepts request if and only
* if registry persistence is enabled for mediation configuration items. It is not
* recommended to use this method unless it is required to delete something from the registry
* only. To delete an item properly one must use the deleteItem method.
*
* @param name Name/ID of the configuration item
* @param itemType Type of the configuration item
*/
public void deleteItemFromRegistry(String name, int itemType) {
if (registry == null) {
if (log.isDebugEnabled()) {
log.debug("Registry persistence is disabled for mediation configuration. " +
"Ignoring the persistence request for " + name);
}
return;
}
if (!initialized || !acceptRequests) {
log.warn("Mediation persistence manager is either not initialized or not in the " +
"'accepting' mode. Ignoring the delete request.");
return;
}
if (itemType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
return;
}
PersistenceRequest request = new PersistenceRequest(name, null, itemType, false);
request.registryOnly = true;
synchronized (requestQueue) {
addToQueue(request);
}
}
/**
* This method ensures that only the latest persistence request for a particular object
* will remain in the request queue. This helps reduce I/O overhead during persistence
* operations by merging multiple save requests to one and giving delete requests priority
* over save requests.
*
* @param request The latest request to be added to queue
*/
private void addToQueue(PersistenceRequest request) {
int i = 0;
boolean matchFound = false;
for (; i < requestQueue.size(); i++) {
PersistenceRequest oldRequest = requestQueue.get(i);
if (oldRequest.subjectType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
// if a request to save the full configuration is already in the queue
// we can ignore the current request - Configuration will get saved
// to the disk anyway
return;
}
if (oldRequest.subjectType == request.subjectType &&
oldRequest.subjectId.equals(request.subjectId)) {
matchFound = true;
break;
}
}
if (matchFound) {
// If an older request was found for the same item overwrite it
requestQueue.remove(i);
requestQueue.add(i, request);
} else {
// Otherwise add the current request to the tail of the queue
requestQueue.offer(request);
}
}
/**
* Make a request to save the complete mediation configuration (the entire
* SynapseConfiguration) to be saved to the file system and the registry.
* This will remove all the existing requests already in the job queue and add
* a single new entry.
*
* @param registryOnly Whether or not to save the configuration to the registry only
*/
public void saveFullConfiguration(boolean registryOnly) {
if (log.isDebugEnabled()) {
log.debug("Received request to save full mediation configuration");
}
PersistenceRequest request = new PersistenceRequest(null,
ServiceBusConstants.ITEM_TYPE_FULL_CONFIG, true);
request.registryOnly = registryOnly;
synchronized (requestQueue) {
requestQueue.clear();
requestQueue.offer(request);
}
}
private void handleException(String msg, Throwable t) {
log.error(msg, t);
throw new ServiceBusPersistenceException(msg, t);
}
private class MediationPersistenceWorker extends Thread {
boolean proceed = true;
public void run() {
if (log.isDebugEnabled()) {
log.debug("Starting the mediation persistence worker thread");
}
if(CarbonUtils.isWorkerNode()){
log.info("This is a worker node, Mediation persistance manager will be disabled.");
}
while (proceed) {
PersistenceRequest request;
synchronized (requestQueue) {
request = requestQueue.poll();
}
if (request == null) {
try {
sleep(interval);
} catch (InterruptedException ignore) {
// This condition could occur only during system shutdown.
// We can safely ignore this.
}
// Simply go to the next iteration
continue;
}
if(CarbonUtils.isWorkerNode()){
log.debug("Ignoring persist request because this is a worker node");
continue;
}
try {
//SynapseConfiguration config = synapseConfiguration;
if (request.registryOnly && registry != null) {
if (request.save) {
persistElementToRegistry(synapseConfiguration, request);
} else {
deleteElementFromRegistry(request);
}
} else {
if (flatFileMode) {
saveToFlatFile(synapseConfiguration);
} else if (request.save) {
persistElement(synapseConfiguration, request);
} else {
deleteElement(synapseConfiguration, request);
}
}
} catch (Throwable t) {
// Just log the error and continue
// DO NOT throw the error since that will kill the worker thread
log.error("Error while saving mediation configuration changes", t);
}
}
if (log.isDebugEnabled()) {
log.debug("Stopping the mediation persistence worker thread");
}
}
}
private void persistElement(SynapseConfiguration config, PersistenceRequest request) {
if (request.subjectType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
saveFullConfiguration(config);
} else {
AbstractStore dataStore = dataStores.get(request.subjectType);
dataStore.save(request.subjectId, config);
}
}
private void deleteElement(SynapseConfiguration config, PersistenceRequest request) {
AbstractStore dataStore = dataStores.get(request.subjectType);
dataStore.delete(request.subjectId, request.fileName, config);
}
private void persistElementToRegistry(SynapseConfiguration config, PersistenceRequest request) {
if (request.subjectType == ServiceBusConstants.ITEM_TYPE_FULL_CONFIG) {
if (log.isDebugEnabled()) {
log.debug("Serializing full mediation configuration to the registry");
}
RegistryBasedSynapseConfigSerializer registrySerializer =
new RegistryBasedSynapseConfigSerializer(registry, configName);
registrySerializer.serializeConfiguration(config);
} else {
AbstractStore dataStore = dataStores.get(request.subjectType);
dataStore.saveItemToRegistry(request.subjectId, config);
}
}
private void deleteElementFromRegistry(PersistenceRequest request) {
AbstractStore dataStore = dataStores.get(request.subjectType);
dataStore.deleteItemFromRegistry(request.subjectId);
}
@SuppressWarnings({"ResultOfMethodCallIgnored"})
private void saveToFlatFile(SynapseConfiguration config) throws IOException,
XMLStreamException {
File outputFile = new File(configPath);
if (!outputFile.exists()) {
outputFile.createNewFile();
}
FileOutputStream fos = new FileOutputStream(outputFile);
XMLConfigurationSerializer.serializeConfiguration(config, fos);
fos.flush();
fos.close();
}
private void saveFullConfiguration(SynapseConfiguration config) {
if (log.isDebugEnabled()) {
log.debug("Serializing full mediation configuration to the file system");
}
SynapseConfiguration deployedArtifacts = removeCAppArtifactsBeforePersist(config);
MultiXMLConfigurationSerializer serializer = new MultiXMLConfigurationSerializer(configPath);
serializer.serialize(config);
if (registry != null) {
if (log.isDebugEnabled()) {
log.debug("Serializing full mediation configuration to the registry");
}
RegistryBasedSynapseConfigSerializer registrySerializer =
new RegistryBasedSynapseConfigSerializer(registry, configName);
registrySerializer.serializeConfiguration(config);
}
addCAppArtifactsAfterPersist(config, deployedArtifacts);
}
/**
* Add the CApp artifact configuration to the current configuration, after persist the other artifacts into the default location
*
* @param synapseConfiguration Current Configuration
* @param cAppConfig CApp artifact configuration
*/
public void addCAppArtifactsAfterPersist(SynapseConfiguration synapseConfiguration,
SynapseConfiguration cAppConfig) {
final Lock lock = getLock(synapseConfiguration.getAxisConfiguration());
try {
lock.lock();
Map<String, Endpoint> endpoints = cAppConfig.getDefinedEndpoints();
for (String name : endpoints.keySet()) {
Endpoint newEndpoint = endpoints.get(name);
synapseConfiguration.addEndpoint(name, newEndpoint);
}
Map<String, SequenceMediator> sequences = cAppConfig.getDefinedSequences();
for (String name : sequences.keySet()) {
SequenceMediator newSequences = sequences.get(name);
synapseConfiguration.addSequence(name, newSequences);
}
Collection<ProxyService> proxyServices = cAppConfig.getProxyServices();
for (ProxyService proxy : proxyServices) {
// Delete the persisted proxy service
deleteItem(proxy.getName(), proxy.getFileName(), ServiceBusConstants.ITEM_TYPE_PROXY_SERVICE);
}
Map<String, Entry> localEntries = cAppConfig.getDefinedEntries();
for (String name : localEntries.keySet()) {
Entry newEntry = localEntries.get(name);
synapseConfiguration.addEntry(name, newEntry);
}
Collection<MessageStore> messageStores = cAppConfig.getMessageStores().values();
for (MessageStore store : messageStores) {
synapseConfiguration.addMessageStore(store.getName(), store);
}
Collection<MessageProcessor> messageProcessors = cAppConfig.getMessageProcessors().values();
for (MessageProcessor processor : messageProcessors) {
synapseConfiguration.addMessageProcessor(processor.getName(), processor);
}
Map<String, TemplateMediator> sequenceTemplates = cAppConfig.getSequenceTemplates();
for (String name : sequenceTemplates.keySet()) {
TemplateMediator newTemplate = sequenceTemplates.get(name);
synapseConfiguration.addSequenceTemplate(name, newTemplate);
}
Map<String, Template> endpointTemplates = cAppConfig.getEndpointTemplates();
for (String name : endpointTemplates.keySet()) {
Template newEndpointTemplate = endpointTemplates.get(name);
synapseConfiguration.addEndpointTemplate(name, newEndpointTemplate);
}
Collection<API> apiCollection = cAppConfig.getAPIs();
for (API api : apiCollection) {
synapseConfiguration.addAPI(api.getName(), api);
api.init((SynapseEnvironment) synapseConfiguration.getAxisConfiguration()
.getParameter(SynapseConstants.SYNAPSE_ENV).getValue());
}
Collection<Startup> tasks = cAppConfig.getStartups();
for (Startup task : tasks) {
synapseConfiguration.addStartup(task);
}
Collection<InboundEndpoint> inboundEndpoints = cAppConfig.getInboundEndpoints();
for (InboundEndpoint inboundEndpoint : inboundEndpoints) {
InboundEndpoint newInbound = inboundEndpoint;
synapseConfiguration.addInboundEndpoint(newInbound.getName(), newInbound);
}
} finally {
lock.unlock();
}
}
/**
* Bean to store details of a persistence request
*/
private class PersistenceRequest {
private boolean save;
private int subjectType;
private String subjectId;
private String fileName;
private boolean registryOnly;
public PersistenceRequest(String subjectId, int subjectType, boolean save) {
this.save = save;
this.subjectId = subjectId;
this.subjectType = subjectType;
}
public PersistenceRequest(String subjectId, String fileName, int subjectType, boolean save) {
this.save = save;
this.subjectId = subjectId;
this.subjectType = subjectType;
this.fileName = fileName;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
PersistenceRequest pr = (PersistenceRequest) o;
return pr.subjectType == this.subjectType &&
pr.save == this.save &&
pr.subjectId.equals(this.subjectId);
}
@Override
public int hashCode() {
int result = (save ? 1 : 0);
result = 31 * result + subjectType;
result = 31 * result + (subjectId != null ? subjectId.hashCode() : 0);
return result;
}
}
/**
* @param synapseConfiguration Contains all the configuration includes CApp artifact configs
* @return new Configuration which removes all the CApp related configs
*/
public SynapseConfiguration removeCAppArtifactsBeforePersist(
SynapseConfiguration synapseConfiguration) {
HashMap<String, SynapseConfiguration> returnMap = new HashMap<>();
final Lock lock = getLock(synapseConfiguration.getAxisConfiguration());
SynapseConfiguration cAppArtifactConfig = new SynapseConfiguration();
try {
lock.lock();
Map<String, Endpoint> endpoints = synapseConfiguration.getDefinedEndpoints();
for (String name : endpoints.keySet()) {
Endpoint ep = endpoints.get(name);
if (ep != null && ep.getArtifactContainerName() != null) {
ep.setIsEdited(true);
cAppArtifactConfig.addEndpoint(name, ep);
synapseConfiguration.removeEndpoint(name);
}
}
Map<String, SequenceMediator> sequences = synapseConfiguration.getDefinedSequences();
for (String name : sequences.keySet()) {
SequenceMediator seq = sequences.get(name);
if (seq != null && seq.getArtifactContainerName() != null) {
seq.setIsEdited(true);
cAppArtifactConfig.addSequence(name, seq);
synapseConfiguration.removeSequence(name);
}
}
Collection<ProxyService> proxyServices = synapseConfiguration.getProxyServices();
for (ProxyService proxy : proxyServices) {
if (proxy != null && proxy.getArtifactContainerName() != null) {
proxy.setIsEdited(true);
cAppArtifactConfig.addProxyService(proxy.getName(), proxy);
// Do not remove proxy service from the synapseConfiguration since the CGAgentAdminService will
// Throw an error while it try to find the service
// Therefore remove the persisted config xml after persisting
}
}
Map<String, Entry> localEntries = synapseConfiguration.getDefinedEntries();
for (String name : localEntries.keySet()) {
Entry localEntry = localEntries.get(name);
if (localEntry != null && localEntry.getArtifactContainerName() != null) {
localEntry.setIsEdited(true);
cAppArtifactConfig.addEntry(name, localEntry);
synapseConfiguration.removeEntry(name);
}
}
Collection<MessageStore> messageStores = synapseConfiguration.getMessageStores().values();
for (MessageStore store : messageStores) {
if (store != null && store.getArtifactContainerName() != null) {
store.setIsEdited(true);
cAppArtifactConfig.addMessageStore(store.getName(), store);
synapseConfiguration.removeMessageStore(store.getName());
}
}
Collection<MessageProcessor> messageProcessors = synapseConfiguration.getMessageProcessors().values();
for (MessageProcessor processor : messageProcessors) {
if (processor != null && processor.getArtifactContainerName() != null) {
processor.setIsEdited(true);
cAppArtifactConfig.addMessageProcessor(processor.getName(), processor);
synapseConfiguration.removeMessageProcessor(processor.getName());
}
}
Map<String, TemplateMediator> sequenceTemplates = synapseConfiguration.getSequenceTemplates();
for (String name : sequenceTemplates.keySet()) {
TemplateMediator seqTemplate = sequenceTemplates.get(name);
if (seqTemplate != null && seqTemplate.getArtifactContainerName() != null) {
seqTemplate.setIsEdited(true);
cAppArtifactConfig.addSequenceTemplate(name, seqTemplate);
synapseConfiguration.removeSequenceTemplate(name);
}
}
Map<String, Template> endpointTemplates = synapseConfiguration.getEndpointTemplates();
for (String name : endpointTemplates.keySet()) {
Template template = endpointTemplates.get(name);
if (template != null && template.getArtifactContainerName() != null) {
template.setIsEdited(true);
cAppArtifactConfig.addEndpointTemplate(name, template);
synapseConfiguration.removeEndpointTemplate(name);
}
}
Collection<API> apiCollection = synapseConfiguration.getAPIs();
for (API api : apiCollection) {
if (api != null && api.getArtifactContainerName() != null) {
api.setIsEdited(true);
cAppArtifactConfig.addAPI(api.getName(), api);
synapseConfiguration.removeAPI(api.getName());
}
}
Collection<Startup> tasks = synapseConfiguration.getStartups();
for (Startup task : tasks) {
if (task != null && task.getArtifactContainerName() != null) {
task.setIsEdited(true);
cAppArtifactConfig.addStartup(task);
synapseConfiguration.removeStartup(task.getName());
}
}
Collection<InboundEndpoint> inboundEndpoints = synapseConfiguration.getInboundEndpoints();
for (InboundEndpoint inboundEndpoint : inboundEndpoints) {
if (inboundEndpoint != null && inboundEndpoint.getArtifactContainerName() != null) {
inboundEndpoint.setIsEdited(true);
cAppArtifactConfig.addInboundEndpoint(inboundEndpoint.getName(), inboundEndpoint);
synapseConfiguration.removeInboundEndpoint(inboundEndpoint.getName());
}
}
return cAppArtifactConfig;
} finally {
lock.unlock();
}
}
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;
}
}