Java tutorial
/** * 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.mediation.initializer.configurations; import org.apache.synapse.ServerContextInformation; import org.apache.synapse.task.TaskDescriptionRepository; import org.apache.synapse.task.TaskScheduler; import org.osgi.framework.BundleContext; import org.osgi.framework.ServiceRegistration; import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.mediation.initializer.services.*; import org.wso2.carbon.mediation.initializer.utils.ConfigurationHolder; import org.wso2.carbon.registry.core.session.UserRegistry; import org.wso2.carbon.registry.core.exceptions.RegistryException; 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.registry.WSO2Registry; import org.apache.axis2.context.ConfigurationContext; import org.apache.axis2.description.Parameter; import org.apache.axis2.AxisFault; import org.apache.axis2.engine.AxisConfiguration; import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.Log; import org.apache.synapse.config.*; import org.apache.synapse.config.xml.MultiXMLConfigurationBuilder; import org.apache.synapse.core.SynapseEnvironment; import org.apache.synapse.core.axis2.MessageContextCreatorForAxis2; import org.apache.synapse.core.axis2.Axis2SynapseEnvironment; import org.apache.synapse.core.axis2.ProxyService; import org.apache.synapse.SynapseConstants; import org.apache.synapse.ServerConfigurationInformation; import org.apache.synapse.mediators.base.SequenceMediator; import org.apache.synapse.registry.Registry; import org.apache.synapse.eventing.SynapseEventSource; import org.wso2.carbon.utils.multitenancy.MultitenantConstants; import java.io.File; import java.util.Properties; import java.util.Enumeration; import java.util.List; /** * Responsible for managing the differrence configurations inside a single ConfigurationContext. */ public class ConfigurationManager { private static Log log = LogFactory.getLog(ConfigurationManager.class); public static final String CONFIGURATION_MANAGER = "CONFIGURATION_MANAGER"; /** We are defaulting to this, we need to take this from a configuration */ private String synpaseConfigurationsRoot = ServiceBusConstants.DEFAULT_SYNAPSE_CONFIGS_LOCATION; /** Class to track the multiple configurations */ private ConfigurationTracker tracker; /** Registry */ private UserRegistry registry = null; /** The configuration context of the server */ private ConfigurationContext configurationContext; /** Tenant for this configuration belongs */ private int tenantId = MultitenantConstants.SUPER_TENANT_ID; /** * * @param registry the configuration registry * @param configurationContext servers configuration context */ public ConfigurationManager(UserRegistry registry, ConfigurationContext configurationContext) { if (registry == null) { throw new IllegalArgumentException("Registry is required"); } if (configurationContext == null) { throw new IllegalArgumentException("ConfigurationContext is required"); } this.registry = registry; this.configurationContext = configurationContext; } /** * Initilize the configuration manager * * @throws ConfigurationInitilizerException if an error occurs */ public void init() throws ConfigurationInitilizerException { tracker = new ConfigurationTracker(registry); try { tracker.init(); Parameter parameter = configurationContext.getAxisConfiguration() .getParameter(SynapseConstants.Axis2Param.SYNAPSE_CONFIG_LOCATION); if (parameter != null && parameter.getValue() != null) { synpaseConfigurationsRoot = parameter.getValue().toString(); } tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId(); } catch (RegistryException e) { handleException("Cannot initialize the configuration tracker: ", e); } } /** * Get the configuration tracker * @return configuration tracker used by this manager */ public ConfigurationTracker getTracker() { return tracker; } /** * Activate the given configuration. This will intern deactivate the current * configuration and then activate the new configuration. * * @param name name of the configuration to be activated * @return true if activation is successful * @throws ConfigurationInitilizerException if an error occurs while activating */ public boolean activate(String name) throws ConfigurationInitilizerException { try { if (!tracker.isConfigurationExists(name)) { handleException("Trying to load the configuration: " + name + " that doesn't have a record"); } SynapseConfiguration newSynapseConfiguration = null; SynapseConfiguration oldSynapseConfiguration = getSynapseConfiguration(); SynapseEnvironment oldSynapseEnvironment = getSynapseEnvironment(); TaskDescriptionRepository repository = getSynapseEnvironment().getTaskManager() .getTaskDescriptionRepository(); TaskScheduler taskScheduler = getSynapseEnvironment().getTaskManager().getTaskScheduler(); int loadLocation = 0; // if this configuration is not created before we are going to // create a default configuration if (!tracker.isConfigurationCreated(name)) { ConfigurationInformation information = tracker.getConfigurationInformation(name); newSynapseConfiguration = createDefaultConfiguration(); if (information != null && information.getDescription() != null) { newSynapseConfiguration.setDescription(information.getDescription()); } loadLocation = 1; log.info("A default Synapse Configuration is created " + "for the configuration: " + name); } Properties properties = SynapsePropertiesLoader.loadSynapseProperties(); if (getServerConfigurationInformation().getResolveRoot() != null) { properties.put(SynapseConstants.RESOLVE_ROOT, getServerConfigurationInformation().getResolveRoot()); } if (getServerConfigurationInformation().getSynapseHome() != null) { properties.put(SynapseConstants.SYNAPSE_HOME, getServerConfigurationInformation().getSynapseHome()); } if (loadLocation != 1) { if (isLoadFromRegistry()) { newSynapseConfiguration = ConfigurationUtils.loadFromRegistry(registry, name, synpaseConfigurationsRoot + File.separator + name, properties); if (newSynapseConfiguration != null) { log.info("Successfully loaded the Synapse Configuration: " + name + " from the registry"); loadLocation = 2; } else { log.warn("Failed to load Synapse Configuration: " + name + " from the registry, " + "trying to load from the file system"); } } // we have to try to load the configuration from the file system if (newSynapseConfiguration == null) { newSynapseConfiguration = SynapseConfigurationBuilder .getConfiguration(synpaseConfigurationsRoot + File.separator + name, properties); if (newSynapseConfiguration != null) { log.info( "Successfully loaded the Synapse Configuration: " + name + " from the file system"); loadLocation = 3; } else { log.warn("Failed to load the Synapse Configuration: " + name); return false; } } } // destroy the old configuration synchronized (oldSynapseConfiguration) { // first make sure we have completed all the persistence requests getMediationPersistenceManager().destroy(); try { ConfigurationUtils.destroyConfiguration(oldSynapseConfiguration, configurationContext.getAxisConfiguration(), oldSynapseEnvironment); } catch (Exception e) { // we are going to ignore and continue log.warn("Error while destroying the current configuration.. " + "Continuing to load the new configuration"); } } // we are going to switch to the new configuration location newSynapseConfiguration.setPathToConfigFile(synpaseConfigurationsRoot + File.separator + name); getServerConfigurationInformation() .setSynapseXMLLocation(synpaseConfigurationsRoot + File.separator + name); if (loadLocation == 1) { ConfigurationUtils.saveToRegistry(registry, newSynapseConfiguration, name); ConfigurationUtils.saveToFileSystem(newSynapseConfiguration); } else if (loadLocation == 2) { if ("true".equals(ConfigurationUtils.getParameter(ServiceBusConstants.SAVE_TO_FILE))) { // If the configuration was loaded from the registry and the 'saveConfigToFile' // system property is set we should serialize the current configuration to the // file system ConfigurationUtils.saveToFileSystem(newSynapseConfiguration); } } else { // If the configuration was loaded from the file system we should // save it to the registry ConfigurationUtils.saveToRegistry(registry, newSynapseConfiguration, name); } tracker.activate(name); configurationContext.getAxisConfiguration() .addParameter(new Parameter(ServiceBusConstants.SYNAPSE_CURRENT_CONFIGURATION, name)); tracker.update(name, true); // initilze the configuration initializeConfiguration(synpaseConfigurationsRoot + File.separator + name, oldSynapseConfiguration, newSynapseConfiguration, repository, taskScheduler); // initialize the persistence ConfigurationUtils.initPersistence(newSynapseConfiguration, registry, synpaseConfigurationsRoot + File.separator + name, configurationContext.getAxisConfiguration(), name); // un-register the old configuration unregisterServices(); registerServices(); return true; } catch (RegistryException e) { handleException("Error accessing the registry resources", e); } catch (AxisFault axisFault) { handleException("Error while setting up the new configuration"); } return false; } private void registerServices() { SynapseEnvironment synEnv = getSynapseEnvironment(); SynapseConfiguration synConfig = getSynapseConfiguration(); SynapseConfigurationService synCfgSvc = new SynapseConfigurationServiceImpl(synConfig, tenantId, configurationContext); //Properties props = new Properties(); ServiceRegistration confRegistration = ConfigurationHolder.getInstance().getBundleContext() .registerService(SynapseConfigurationService.class.getName(), synCfgSvc, null); //props = new Properties(); SynapseEnvironmentService synEnvSvc = new SynapseEnvironmentServiceImpl(synEnv, tenantId, configurationContext); ServiceRegistration envRegistration = ConfigurationHolder.getInstance().getBundleContext() .registerService(SynapseEnvironmentService.class.getName(), synEnvSvc, null); //props = new Properties(); SynapseRegistrationsService synRegistrationsSvc = new SynapseRegistrationsServiceImpl(confRegistration, envRegistration, tenantId, configurationContext); ServiceRegistration synapseRegistration = ConfigurationHolder.getInstance().getBundleContext() .registerService(SynapseRegistrationsService.class.getName(), synRegistrationsSvc, null); } private void unregisterServices() { BundleContext bundleContext = ConfigurationHolder.getInstance().getBundleContext(); ServiceRegistration serviceRegistration = ConfigurationHolder.getInstance() .getSynapseRegistration(tenantId); if (serviceRegistration != null) { SynapseRegistrationsService synapseRegistrationsService = (SynapseRegistrationsService) bundleContext .getService(serviceRegistration.getReference()); ServiceRegistration synConfigServiceRegistration = synapseRegistrationsService .getSynapseConfigurationServiceRegistration(); if (synConfigServiceRegistration != null) { bundleContext.ungetService(synConfigServiceRegistration.getReference()); } ServiceRegistration synEnvServiceRegistration = synapseRegistrationsService .getSynapseEnvironmentServiceRegistration(); if (synEnvServiceRegistration != null) { bundleContext.ungetService(synEnvServiceRegistration.getReference()); } bundleContext.ungetService(serviceRegistration.getReference()); } } /** * Create the default configuration * * @return the default configuration */ private SynapseConfiguration createDefaultConfiguration() { SynapseConfiguration newSynapseConfiguration; newSynapseConfiguration = SynapseConfigurationBuilder.getDefaultConfiguration(); SequenceMediator mainSequence = (SequenceMediator) newSynapseConfiguration.getMainSequence(); mainSequence.setFileName(mainSequence.getName()); SequenceMediator faultSequence = (SequenceMediator) newSynapseConfiguration.getFaultSequence(); faultSequence.setFileName(faultSequence.getName()); // set the governance registry Registry registry = new WSO2Registry(); newSynapseConfiguration.setRegistry(registry); newSynapseConfiguration.setProperty(MultiXMLConfigurationBuilder.SEPARATE_REGISTRY_DEFINITION, "true"); return newSynapseConfiguration; } /** * Delete a configuration. This will delete the registry entry, but it won't delete the * actual files and registry persitant information. * * @param name name of the configuration to be deleted * @throws ConfigurationInitilizerException if an error occurs */ public void delete(String name) throws ConfigurationInitilizerException { try { tracker.delete(name); } catch (RegistryException e) { handleException("Failed to delete the configuration: " + name, e); } } /** * Create a new configuration. This won't write anything to the disk until this * configuration is activated. * * @param name name of the configuration * @param description description of the configuration * @throws ConfigurationInitilizerException if an error occurs */ public void create(String name, String description) throws ConfigurationInitilizerException { try { tracker.create(name, description); } catch (RegistryException e) { handleException("Failed to create configuration: " + name, e); } } /** * Return the list of configurations available. * @return list of configuration information * @throws ConfigurationInitilizerException if an error occurs */ public List<ConfigurationInformation> getConfigurationsList() throws ConfigurationInitilizerException { try { return tracker.getConfigurationList(); } catch (RegistryException e) { handleException("Failed to get the configurations list", e); } return null; } public void addExistingConfiguration(String name) throws ConfigurationInitilizerException { // try to see weather file or registry entry exists // if exists delete it // add the information to the tracker try { if (tracker.isConfigurationExists(name)) { String msg = "Configuration already exists in the " + "available configurations list. Cannot add it again."; log.warn(msg); throw new ConfigurationInitilizerException(msg); } else { tracker.create(name, ""); tracker.update(name, true); } } catch (RegistryException e) { handleException("Failed to add the existing configuration: " + name, e); } } /** * Initialize a newly created configuration. This will initialize the Synapse Env as well. * * @param configurationLocation file path which this configuration is based on * @param oldSynapseConfiguration previous synapse configuration * @param newSynapseConfiguration newly created synapse configuration * @param repository task repository * @param taskScheduler @throws ConfigurationInitilizerException if an error occurs * @throws org.apache.axis2.AxisFault if an error occurs * @throws ConfigurationInitilizerException if an error occurs */ private void initializeConfiguration(String configurationLocation, SynapseConfiguration oldSynapseConfiguration, SynapseConfiguration newSynapseConfiguration, TaskDescriptionRepository repository, TaskScheduler taskScheduler) throws ConfigurationInitilizerException, AxisFault { AxisConfiguration axisConfiguration = configurationContext.getAxisConfiguration(); // Set the Axis2 ConfigurationContext to the SynapseConfiguration newSynapseConfiguration.setAxisConfiguration(axisConfiguration); Entry hostEntry = oldSynapseConfiguration.getEntryDefinition(SynapseConstants.SERVER_HOST); Entry ipEntry = oldSynapseConfiguration.getEntryDefinition(SynapseConstants.SERVER_IP); // setup the properties Properties properties = SynapsePropertiesLoader.loadSynapseProperties(); if (properties != null) { Enumeration keys = properties.keys(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); newSynapseConfiguration.setProperty(key, properties.getProperty(key)); } } // Add the old parameters to the new configuration newSynapseConfiguration.setPathToConfigFile(configurationLocation); newSynapseConfiguration.addEntry(SynapseConstants.SERVER_HOST, hostEntry); newSynapseConfiguration.addEntry(SynapseConstants.SERVER_IP, ipEntry); // Check for the main sequence and add a default main sequence if not present if (newSynapseConfiguration.getMainSequence() == null) { SynapseConfigUtils.setDefaultMainSequence(newSynapseConfiguration); } // Check for the fault sequence and add a deafult fault sequence if not present if (newSynapseConfiguration.getFaultSequence() == null) { SynapseConfigUtils.setDefaultFaultSequence(newSynapseConfiguration); } ServerContextInformation contextInformation = getServerContextInformation(); // set the synapse configuration to the axis2 configuration newSynapseConfiguration.setAxisConfiguration(axisConfiguration); Parameter synapseCtxParam = new Parameter(SynapseConstants.SYNAPSE_CONFIG, null); synapseCtxParam.setValue(newSynapseConfiguration); MessageContextCreatorForAxis2.setSynConfig(newSynapseConfiguration); //set up synapse env Parameter synapseEnvParam = new Parameter(SynapseConstants.SYNAPSE_ENV, null); Axis2SynapseEnvironment synEnv = new Axis2SynapseEnvironment(configurationContext, newSynapseConfiguration, contextInformation); synapseEnvParam.setValue(synEnv); MessageContextCreatorForAxis2.setSynEnv(synEnv); if (contextInformation != null) { // set the new information to the server context contextInformation.setSynapseEnvironment(synEnv); contextInformation.setSynapseConfiguration(newSynapseConfiguration); } else { throw new IllegalStateException("ServerContextInformation not found"); } try { axisConfiguration.addParameter(synapseCtxParam); axisConfiguration.addParameter(synapseEnvParam); } catch (AxisFault e) { String msg = "Could not set parameters '" + SynapseConstants.SYNAPSE_CONFIG + "' and/or '" + SynapseConstants.SYNAPSE_ENV + "'to the Axis2 configuration : " + e.getMessage(); throw new ConfigurationInitilizerException(msg, e); } // redeploy proxy services if (log.isTraceEnabled()) { log.trace("Re-deploying Proxy services..."); } for (ProxyService proxyService : newSynapseConfiguration.getProxyServices()) { if (proxyService != null) { proxyService.buildAxisService(newSynapseConfiguration, axisConfiguration); if (log.isDebugEnabled()) { log.debug("Deployed Proxy service : " + proxyService.getName()); } if (!proxyService.isStartOnLoad()) { proxyService.stop(newSynapseConfiguration); } } } if (log.isTraceEnabled()) { log.trace("Re-deploying Event Sources..."); } for (SynapseEventSource eventSource : newSynapseConfiguration.getEventSources()) { if (eventSource != null) { eventSource.buildService(axisConfiguration); if (log.isDebugEnabled()) { log.debug("Deployed Event Source : " + eventSource.getName()); } } } synEnv.getTaskManager().init(repository, taskScheduler, newSynapseConfiguration.getTaskManager()); // init the synapse configuration newSynapseConfiguration.init(synEnv); synEnv.setInitialized(true); } /** * Return true if we have to load the configuration from the registry * @return true if we have to load the configuration from the registry */ private boolean isLoadFromRegistry() { return "true".equals(ConfigurationUtils.getParameter(ServiceBusConstants.LOAD_FROM_REGISTRY)); } private SynapseEnvironment getSynapseEnvironment() { return (SynapseEnvironment) configurationContext.getAxisConfiguration() .getParameter(SynapseConstants.SYNAPSE_ENV).getValue(); } private SynapseConfiguration getSynapseConfiguration() { return (SynapseConfiguration) configurationContext.getAxisConfiguration() .getParameter(SynapseConstants.SYNAPSE_CONFIG).getValue(); } private MediationPersistenceManager getMediationPersistenceManager() { return ServiceBusUtils.getMediationPersistenceManager(configurationContext.getAxisConfiguration()); } private ServerConfigurationInformation getServerConfigurationInformation() { Parameter p = configurationContext.getAxisConfiguration() .getParameter(SynapseConstants.SYNAPSE_SERVER_CONFIG_INFO); if (p != null) { return (ServerConfigurationInformation) p.getValue(); } return null; } private ServerContextInformation getServerContextInformation() { Parameter p = configurationContext.getAxisConfiguration() .getParameter(SynapseConstants.SYNAPSE_SERVER_CTX_INFO); if (p != null) { return (ServerContextInformation) p.getValue(); } return null; } private void handleException(String msg) throws ConfigurationInitilizerException { log.warn(msg); throw new ConfigurationInitilizerException(msg); } private void handleException(String msg, Exception e) throws ConfigurationInitilizerException { log.warn(msg, e); throw new ConfigurationInitilizerException(msg, e); } }