/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.synapse.config.xml;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.commons.io.FileUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.Mediator;
import org.apache.synapse.Startup;
import org.apache.synapse.SynapseConstants;
import org.apache.synapse.endpoints.Template;
import org.apache.synapse.inbound.InboundEndpoint;
import org.apache.synapse.libraries.imports.SynapseImport;
import org.apache.synapse.mediators.template.TemplateMediator;
import org.apache.synapse.SynapseException;
import org.apache.synapse.message.processor.MessageProcessor;
import org.apache.synapse.message.store.MessageStore;
import org.apache.synapse.commons.executors.PriorityExecutor;
import org.apache.synapse.config.Entry;
import org.apache.synapse.config.SynapseConfigUtils;
import org.apache.synapse.config.SynapseConfiguration;
import org.apache.synapse.core.axis2.ProxyService;
import org.apache.synapse.endpoints.Endpoint;
import org.apache.synapse.eventing.SynapseEventSource;
import org.apache.synapse.mediators.base.SequenceMediator;
import org.apache.synapse.rest.API;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import java.io.*;
import java.util.Iterator;
import java.util.Properties;
/**
* <p>
* This optional configuration builder creates the Synapse configuration by processing
* a specified file hierarchy. If the root of the specified file hierarchy is CONFIG_HOME,
* then the following directories are expected to be in CONFIG_HOME.
* <ul>
* <li>CONFIG_HOME/proxy-services</li>
* <li>CONFIG_HOME/sequences</li>
* <li>CONFIG_HOME/endpoints</li>
* <li>CONFIG_HOME/local-entries</li>
* <li>CONFIG_HOME/tasks</li>
* <li>CONFIG_HOME/event-sources</li>
* <li>CONFIG_HOME/priority-executors</li>
* </ul>
*
* Each of these directories will house a set of XML files. Each file will define exactly
* one configuration item (eg: a proxy service, an endpoint, a sequence).
* </p>
* <p>
* In addition to the directories mentioned above one can have the following file in
* CONFIG_HOME
* <ul>
* <li>CONFIG_HOME/registry.xml</li>
* </ul>
* </p>
*
*/
public class MultiXMLConfigurationBuilder {
public static final String PROXY_SERVICES_DIR = "proxy-services";
public static final String SEQUENCES_DIR = "sequences";
public static final String TEMPLATES_DIR = "templates";
public static final String ENDPOINTS_DIR = "endpoints";
public static final String LOCAL_ENTRY_DIR = "local-entries";
public static final String TASKS_DIR = "tasks";
public static final String EVENTS_DIR = "event-sources";
public static final String EXECUTORS_DIR = "priority-executors";
public static final String MESSAGE_STORE_DIR = "message-stores";
public static final String MESSAGE_PROCESSOR_DIR = "message-processors";
public static final String REST_API_DIR = "api";
public static final String INBOUND_ENDPOINT_DIR = "inbound-endpoints";
public static final String SYNAPSE_IMPORTS_DIR = "imports";
public static final String REGISTRY_FILE = "registry.xml";
public static final String TASK_MANAGER_FILE = "task-manager.xml";
public static final String SEPARATE_REGISTRY_DEFINITION = "__separateRegDef";
public static final String SEPARATE_TASK_MANAGER_DEFINITION = "__separateTaskManagerDef";
private static final String[] extensions = { "xml" };
private static Log log = LogFactory.getLog(MultiXMLConfigurationBuilder.class);
public static SynapseConfiguration getConfiguration(String root, Properties properties) {
log.info("Building synapse configuration from the synapse artifact repository at : " + root);
// First try to load the configuration from synapse.xml
SynapseConfiguration synapseConfig = createConfigurationFromSynapseXML(root, properties);
if (synapseConfig == null) {
synapseConfig = SynapseConfigUtils.newConfiguration();
synapseConfig.setDefaultQName(XMLConfigConstants.DEFINITIONS_ELT);
} else if (log.isDebugEnabled()) {
log.debug("Found a synapse configuration in the " + SynapseConstants.SYNAPSE_XML
+ " file at the artifact repository root, which gets precedence "
+ "over other definitions");
}
if (synapseConfig.getRegistry() == null) {
// If the synapse.xml does not define a registry look for a registry.xml
createRegistry(synapseConfig, root, properties);
} else if (log.isDebugEnabled()) {
log.debug("Using the registry defined in the " + SynapseConstants.SYNAPSE_XML
+ " as the registry, any definitions in the "+ REGISTRY_FILE +
" will be neglected");
}
if (synapseConfig.getTaskManager() == null) {
// If the synapse.xml does not define a taskManager look for a task-manager.xml
createTaskManager(synapseConfig, root, properties);
} else if (log.isDebugEnabled()) {
log.debug("Using the task manager defined in the " + SynapseConstants.SYNAPSE_XML
+ " as the task manager, any definitions in the "+ TASK_MANAGER_FILE +
" will be neglected");
}
createSynapseImports(synapseConfig, root, properties);
createLocalEntries(synapseConfig, root, properties);
createEndpoints(synapseConfig, root, properties);
createSequences(synapseConfig, root, properties);
createTemplates(synapseConfig, root, properties);
createProxyServices(synapseConfig, root, properties);
createTasks(synapseConfig, root, properties);
createEventSources(synapseConfig, root, properties);
createExecutors(synapseConfig, root, properties);
createMessageStores(synapseConfig, root, properties);
createMessageProcessors(synapseConfig, root, properties);
createAPIs(synapseConfig, root, properties);
createInboundEndpoint(synapseConfig, root, properties);
return synapseConfig;
}
private static SynapseConfiguration createConfigurationFromSynapseXML(
String rootDirPath, Properties properties) {
File synapseXML = new File(rootDirPath, SynapseConstants.SYNAPSE_XML);
if (!synapseXML.exists() || !synapseXML.isFile()) {
return null;
}
FileInputStream is;
SynapseConfiguration config = null;
try {
is = FileUtils.openInputStream(synapseXML);
} catch (IOException e) {
handleException("Error while opening the file: " + synapseXML.getName(), e);
return null;
}
try {
config = XMLConfigurationBuilder.getConfiguration(is, properties);
is.close();
} catch (XMLStreamException e) {
handleException("Error while loading the Synapse configuration from the " +
synapseXML.getName() + " file", e);
} catch (IOException e) {
log.warn("Error while closing the input stream from file: " + synapseXML.getName(), e);
}
return config;
}
private static void createRegistry(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File registryDef = new File(rootDirPath, REGISTRY_FILE);
try {
if (registryDef.exists() && registryDef.isFile()) {
if (log.isDebugEnabled()) {
log.debug("Initializing Synapse registry from the configuration at : " +
registryDef.getPath());
}
OMElement document = getOMElement(registryDef);
SynapseXMLConfigurationFactory.defineRegistry(synapseConfig, document, properties);
synapseConfig.setProperty(SEPARATE_REGISTRY_DEFINITION,
String.valueOf(Boolean.TRUE));
}
} catch (Exception e) {
String msg = "Registry configuration cannot be built from : " + registryDef.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_REGISTRY, msg, e);
}
}
private static void createTaskManager(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File taskManagerDef = new File(rootDirPath, TASK_MANAGER_FILE);
try {
if (taskManagerDef.exists() && taskManagerDef.isFile()) {
if (log.isDebugEnabled()) {
log.debug("Initializing Synapse taskManager from the configuration at : " +
taskManagerDef.getPath());
}
OMElement document = getOMElement(taskManagerDef);
SynapseXMLConfigurationFactory.defineTaskManager(synapseConfig, document, properties);
synapseConfig.setProperty(SEPARATE_TASK_MANAGER_DEFINITION,
String.valueOf(Boolean.TRUE));
}
} catch (Exception e) {
String msg = "Task Manager configuration cannot be built from : " + taskManagerDef.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_TASK_MANAGER, msg, e);
}
}
private static void createLocalEntries(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File localEntriesDir = new File(rootDirPath, LOCAL_ENTRY_DIR);
if (localEntriesDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading local entry definitions from : " + localEntriesDir.getPath());
}
Iterator entryDefinitions = FileUtils.iterateFiles(localEntriesDir, extensions, false);
while (entryDefinitions.hasNext()) {
File file = (File) entryDefinitions.next();
try {
OMElement document = getOMElement(file);
Entry entry = SynapseXMLConfigurationFactory.defineEntry(synapseConfig, document,
properties);
if (entry != null) {
entry.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
entry.getKey());
}
} catch (Exception e) {
String msg = "Local Entry configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_LOCALENTRIES, msg, e);
}
}
}
}
private static void createProxyServices(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File proxyServicesDir = new File(rootDirPath, PROXY_SERVICES_DIR);
if (proxyServicesDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading proxy services from : " + proxyServicesDir.getPath());
}
Iterator proxyDefinitions = FileUtils.iterateFiles(proxyServicesDir, extensions, false);
while (proxyDefinitions.hasNext()) {
File file = (File) proxyDefinitions.next();
try {
OMElement document = getOMElement(file);
ProxyService proxy = SynapseXMLConfigurationFactory.defineProxy(synapseConfig,
document, properties);
if (proxy != null) {
proxy.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), proxy.getName());
}
} catch (Exception e) {
String msg = "Proxy configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_PROXY_SERVICES, msg, e);
}
}
}
}
private static void createTasks(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File tasksDir = new File(rootDirPath, TASKS_DIR);
if (tasksDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading tasks from : " + tasksDir.getPath());
}
Iterator taskDefinitions = FileUtils.iterateFiles(tasksDir, extensions, false);
while (taskDefinitions.hasNext()) {
File file = (File) taskDefinitions.next();
try {
OMElement document = getOMElement(file);
Startup startup = SynapseXMLConfigurationFactory.defineStartup(synapseConfig,
document, properties);
startup.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), startup.getName());
} catch (Exception e) {
String msg = "Task configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_TASKS, msg, e);
}
}
}
}
private static void createSequences(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File sequencesDir = new File(rootDirPath, SEQUENCES_DIR);
if (sequencesDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading sequences from : " + sequencesDir.getPath());
}
Iterator sequences = FileUtils.iterateFiles(sequencesDir, extensions, false);
while (sequences.hasNext()) {
File file = (File) sequences.next();
try{
OMElement document = getOMElement(file);
Mediator seq = SynapseXMLConfigurationFactory.defineSequence(synapseConfig,
document, properties);
if (seq != null && seq instanceof SequenceMediator) {
SequenceMediator sequence = (SequenceMediator) seq;
sequence.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), sequence.getName());
}
} catch (Exception e) {
String msg = "Sequence configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_SEQUENCES, msg, e);
}
}
}
}
private static void createTemplates(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File templatesDir = new File(rootDirPath, TEMPLATES_DIR);
if (templatesDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading template from : " + templatesDir.getPath());
}
Iterator templates = FileUtils.iterateFiles(templatesDir, extensions, false);
while (templates.hasNext()) {
File file = (File) templates.next();
try {
OMElement document = getOMElement(file);
OMElement element = document.getFirstChildWithName(
new QName(SynapseConstants.SYNAPSE_NAMESPACE, "sequence"));
if (element != null) {
TemplateMediator mediator =
(TemplateMediator) SynapseXMLConfigurationFactory.defineMediatorTemplate(
synapseConfig, document, properties);
if (mediator != null) {
mediator.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), mediator.getName());
}
} else {
element = document.getFirstChildWithName(
new QName(SynapseConstants.SYNAPSE_NAMESPACE, "endpoint"));
if (element != null) {
Template endpointTemplate =
SynapseXMLConfigurationFactory.defineEndpointTemplate(
synapseConfig, document, properties);
if (endpointTemplate != null) {
endpointTemplate.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), endpointTemplate.getName());
}
}
}
} catch (Exception e) {
String msg = "Template configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_TEMPLATES, msg, e);
}
}
}
}
private static void createEndpoints(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File endpointsDir = new File(rootDirPath, ENDPOINTS_DIR);
if (endpointsDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading endpoints from : " + endpointsDir.getPath());
}
Iterator endpoints = FileUtils.iterateFiles(endpointsDir, extensions, false);
while (endpoints.hasNext()) {
File file = (File) endpoints.next();
try {
OMElement document = getOMElement(file);
Endpoint endpoint = SynapseXMLConfigurationFactory.defineEndpoint(
synapseConfig, document, properties);
if (endpoint != null) {
endpoint.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), endpoint.getName());
}
} catch (Exception e) {
String msg = "Endpoint configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_EP, msg, e);
}
}
}
}
private static void createEventSources(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File eventsDir = new File(rootDirPath, EVENTS_DIR);
if (eventsDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading event sources from : " + eventsDir.getPath());
}
Iterator events = FileUtils.iterateFiles(eventsDir, extensions, false);
while (events.hasNext()) {
File file = (File) events.next();
try {
OMElement document = getOMElement(file);
SynapseEventSource eventSource = SynapseXMLConfigurationFactory.
defineEventSource(synapseConfig, document, properties);
if (eventSource != null) {
eventSource.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), eventSource.getName());
}
} catch (Exception e) {
String msg = "Event source configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_EVENT_SOURCE, msg, e);
}
}
}
}
private static void createExecutors(SynapseConfiguration synapseConfig, String rootDirPath,
Properties properties) {
File executorsDir = new File(rootDirPath, EXECUTORS_DIR);
if (executorsDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading event sources from : " + executorsDir.getPath());
}
Iterator executors = FileUtils.iterateFiles(executorsDir, extensions, false);
while (executors.hasNext()) {
File file = (File) executors.next();
try {
OMElement document = getOMElement(file);
PriorityExecutor executor = SynapseXMLConfigurationFactory.
defineExecutor(synapseConfig, document, properties);
if (executor != null) {
executor.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(
file.getAbsolutePath(), executor.getName());
}
} catch (Exception e) {
String msg = "Executor configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_EXECUTORS, msg, e);
}
}
}
}
private static void createMessageStores(SynapseConfiguration synapseConfig ,
String rootDirPath, Properties properties) {
File messageStoresDir = new File(rootDirPath, MESSAGE_STORE_DIR);
if (messageStoresDir.exists() ) {
if (log.isDebugEnabled()) {
log.debug("Loading Message Stores from :" + messageStoresDir.getPath());
}
Iterator messageStores = FileUtils.iterateFiles(messageStoresDir, extensions, false);
while (messageStores.hasNext()) {
File file = (File) messageStores.next();
try {
OMElement document = getOMElement(file);
MessageStore messageStore = SynapseXMLConfigurationFactory.defineMessageStore(
synapseConfig, document, properties);
if (messageStore != null) {
messageStore.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
messageStore.getName());
}
} catch (Exception e) {
String msg = "Message store configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_MESSAGE_STORES, msg, e);
}
}
}
}
private static void createMessageProcessors(SynapseConfiguration synapseConfig,
String rootDirPath, Properties properties) {
File messageProcessorDir = new File(rootDirPath, MESSAGE_PROCESSOR_DIR);
if (messageProcessorDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading Message Processors from :" + messageProcessorDir.getPath());
}
Iterator messageProcessors = FileUtils.iterateFiles(messageProcessorDir, extensions, false);
while (messageProcessors.hasNext()) {
File file = (File) messageProcessors.next();
try {
OMElement document = getOMElement(file);
MessageProcessor messageProcessor = SynapseXMLConfigurationFactory.defineMessageProcessor(
synapseConfig, document, properties);
if (messageProcessor != null) {
messageProcessor.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
messageProcessor.getName());
}
} catch (Exception e) {
String msg = "Message processor configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_MESSAGE_PROCESSORS, msg, e);
}
}
}
}
private static void createSynapseImports(SynapseConfiguration synapseConfig, String root, Properties properties) {
File synImportsDir = new File(root, SYNAPSE_IMPORTS_DIR);
if (synImportsDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading Synapse Imports from :" + synImportsDir.getPath());
}
Iterator synImports = FileUtils.iterateFiles(synImportsDir, extensions, false);
while (synImports.hasNext()) {
File file = (File) synImports.next();
try {
OMElement document = getOMElement(file);
SynapseImport synImp = SynapseXMLConfigurationFactory.defineImport(
synapseConfig, document, properties);
if (synImp != null) {
synImp.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
synImp.getName());
}
} catch (Exception e) {
String msg = "Import configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_IMPORTS, msg, e);
}
}
}
}
private static void createAPIs(SynapseConfiguration synapseConfig,
String rootDirPath, Properties properties) {
File apiDir = new File(rootDirPath, REST_API_DIR);
if (apiDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading APIs from :" + apiDir.getPath());
}
Iterator apiIterator = FileUtils.iterateFiles(apiDir, extensions, false);
while (apiIterator.hasNext()) {
File file = (File) apiIterator.next();
try {
OMElement document = getOMElement(file);
API api = SynapseXMLConfigurationFactory.defineAPI(synapseConfig, document, properties);
if (api != null) {
api.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
api.getName());
}
} catch (Exception e) {
String msg = "API configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_API, msg, e);
}
}
}
}
private static void createInboundEndpoint(SynapseConfiguration synapseConfig,
String rootDirPath, Properties properties) {
File inboundEndpointDir = new File(rootDirPath, INBOUND_ENDPOINT_DIR);
if (inboundEndpointDir.exists()) {
if (log.isDebugEnabled()) {
log.debug("Loading APIs from :" + inboundEndpointDir.getPath());
}
Iterator inboundEndpointIterator = FileUtils.iterateFiles(inboundEndpointDir, extensions, false);
while (inboundEndpointIterator.hasNext()) {
File file = (File) inboundEndpointIterator.next();
try {
OMElement document = getOMElement(file);
InboundEndpoint inboundEndpoint = SynapseXMLConfigurationFactory.defineInboundEndpoint(synapseConfig, document, properties);
if (inboundEndpoint != null) {
inboundEndpoint.setFileName(file.getName());
synapseConfig.getArtifactDeploymentStore().addArtifact(file.getAbsolutePath(),
inboundEndpoint.getName());
}
} catch (Exception e) {
String msg = "Inbound Endpoint configuration cannot be built from : " + file.getName();
handleConfigurationError(SynapseConstants.FAIL_SAFE_MODE_INBOUND_ENDPOINT, msg, e);
}
}
}
}
private static OMElement getOMElement(File file) {
FileInputStream is;
OMElement document = null;
try {
is = FileUtils.openInputStream(file);
} catch (IOException e) {
handleException("Error while opening the file: " + file.getName() + " for reading", e);
return null;
}
try {
document = new StAXOMBuilder(is).getDocumentElement();
document.build();
is.close();
} catch (XMLStreamException e) {
handleException("Error while parsing the content of the file: " + file.getName(), e);
} catch (IOException e) {
log.warn("Error while closing the input stream from the file: " + file.getName(), e);
}
return document;
}
private static void handleConfigurationError(String componentType, String msg, Exception e) {
if (SynapseConfigUtils.isFailSafeEnabled(componentType)) {
log.warn(msg + " - Continue in fail-safe mode", e);
} else {
log.error(msg, e);
throw new SynapseException(msg, e);
}
}
private static void handleException(String msg, Exception e) {
log.error(msg, e);
throw new SynapseException(msg, e);
}
}