| /* |
| * 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.axis2.engine; |
| |
| import java.io.File; |
| import java.net.URL; |
| import java.security.PrivilegedAction; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.CopyOnWriteArraySet; |
| |
| import javax.xml.namespace.QName; |
| |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.Constants; |
| import org.apache.axis2.transaction.TransactionConfiguration; |
| import org.apache.axis2.builder.Builder; |
| import org.apache.axis2.builder.unknowncontent.UnknownContentBuilder; |
| import org.apache.axis2.clustering.ClusteringAgent; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.dataretrieval.AxisDataLocator; |
| import org.apache.axis2.deployment.DeploymentException; |
| import org.apache.axis2.deployment.ModuleDeployer; |
| import org.apache.axis2.deployment.repository.util.DeploymentFileData; |
| import org.apache.axis2.deployment.util.PhasesInfo; |
| import org.apache.axis2.description.AxisDescription; |
| import org.apache.axis2.description.AxisEndpoint; |
| import org.apache.axis2.description.AxisModule; |
| import org.apache.axis2.description.AxisOperation; |
| import org.apache.axis2.description.AxisService; |
| import org.apache.axis2.description.AxisServiceGroup; |
| import org.apache.axis2.description.ModuleConfiguration; |
| import org.apache.axis2.description.Parameter; |
| import org.apache.axis2.description.TransportInDescription; |
| import org.apache.axis2.description.TransportOutDescription; |
| import org.apache.axis2.description.Version; |
| import org.apache.axis2.description.java2wsdl.Java2WSDLConstants; |
| import org.apache.axis2.i18n.Messages; |
| import org.apache.axis2.phaseresolver.PhaseMetadata; |
| import org.apache.axis2.phaseresolver.PhaseResolver; |
| import org.apache.axis2.transport.MessageFormatter; |
| import org.apache.axis2.util.TargetResolver; |
| import org.apache.axis2.util.Utils; |
| import org.apache.axis2.util.FaultyServiceData; |
| import org.apache.axis2.util.JavaUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| /** |
| * Class AxisConfiguration |
| */ |
| public class AxisConfiguration extends AxisDescription { |
| |
| private static final Log log = LogFactory.getLog(AxisConfiguration.class); |
| /* |
| * To store configured data locators |
| */ |
| private HashMap<String, AxisDataLocator> dataLocators = new HashMap<String, AxisDataLocator>(); |
| private HashMap<String, String> dataLocatorClassNames = new HashMap<String, String>(); |
| |
| /** |
| * Map of all available modules. The key is the archive name as defined by |
| * {@link AxisModule#getArchiveName()}. |
| */ |
| private final HashMap<String, AxisModule> allModules = new HashMap<String, AxisModule>(); |
| |
| // To store mapping between default version and module name |
| private final HashMap<String, String> nameToversionMap = new HashMap<String, String>(); |
| |
| // private final HashMap serviceGroups = new HashMap(); |
| private final HashMap<String, TransportInDescription> transportsIn = new HashMap<String, TransportInDescription>(); |
| |
| private final HashMap<String, TransportOutDescription> transportsOut = new HashMap<String, TransportOutDescription>(); |
| |
| private final HashMap<String, List<AxisModule>> policySupportedModules = new HashMap<String, List<AxisModule>>(); |
| |
| /** |
| * Stores the QNames of local policy assertions |
| */ |
| private final ArrayList<QName> localPolicyAssertions = new ArrayList<QName>(); |
| |
| // to store AxisObserver Objects |
| private Set<AxisObserver> observerSet = null; |
| |
| private URL axis2Repository = null; |
| |
| private Map<String, AxisService> allServices = new ConcurrentHashMap<String, AxisService>(); |
| private Map<String, AxisService> allEndpoints = new ConcurrentHashMap<String, AxisService>(); |
| |
| /** |
| * Stores the module specified in the server.xml at the document parsing time. |
| */ |
| private List<String> globalModuleList; |
| |
| private Hashtable<String, String> faultyModules; |
| |
| /** |
| * To store faulty services |
| */ |
| private Hashtable<String, String> faultyServices; |
| |
| /** |
| * To store services which have become faulty due to modules. Here key is the module name and |
| * the corresponding value is an another map which holds the a Map of faulty services due a |
| * single module (keyed by service name). |
| */ |
| private final Map<String, Map<String, FaultyServiceData>> faultyServicesDueToModules = |
| new HashMap<String, Map<String, FaultyServiceData>>(); |
| |
| |
| private List<Phase> inFaultPhases; |
| |
| private List<Phase> inPhasesUptoAndIncludingPostDispatch; |
| |
| private HashMap<String, MessageReceiver> messageReceivers; |
| |
| private HashMap<String, Builder> messageBuilders; |
| |
| private HashMap<String, MessageFormatter> messageFormatters; |
| |
| private ClassLoader moduleClassLoader; |
| |
| private HashMap<String, ModuleConfiguration> moduleConfigmap; |
| |
| private List<Phase> outFaultPhases; |
| |
| private List<Phase> outPhases; |
| |
| protected PhasesInfo phasesinfo; |
| |
| private ClassLoader serviceClassLoader; |
| |
| private ClassLoader systemClassLoader; |
| |
| //To keep track of whether the system has started or not |
| private boolean start; |
| |
| private ArrayList<TargetResolver> targetResolvers; |
| |
| private ClusteringAgent clusteringAgent; |
| |
| private AxisConfigurator configurator; |
| |
| private TransactionConfiguration transactionConfiguration; |
| |
| /** |
| * Constructor AxisConfiguration. |
| */ |
| public AxisConfiguration() { |
| moduleConfigmap = new HashMap<String, ModuleConfiguration>(); |
| globalModuleList = new ArrayList<String>(); |
| messageReceivers = new HashMap<String, MessageReceiver>(); |
| messageBuilders = new HashMap<String, Builder>(); |
| messageFormatters = new HashMap<String, MessageFormatter>(); |
| outPhases = new ArrayList<Phase>(); |
| inFaultPhases = new ArrayList<Phase>(); |
| outFaultPhases = new ArrayList<Phase>(); |
| faultyServices = new Hashtable<String, String>(); |
| faultyModules = new Hashtable<String, String>(); |
| observerSet = new CopyOnWriteArraySet<AxisObserver>(); |
| inPhasesUptoAndIncludingPostDispatch = new ArrayList<Phase>(); |
| systemClassLoader = org.apache.axis2.java.security.AccessController |
| .doPrivileged(new PrivilegedAction<ClassLoader>() { |
| public ClassLoader run() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| }); |
| serviceClassLoader = systemClassLoader; |
| moduleClassLoader = systemClassLoader; |
| |
| this.phasesinfo = new PhasesInfo(); |
| targetResolvers = new ArrayList<TargetResolver>(); |
| } |
| |
| public void addMessageReceiver(String mepURL, |
| MessageReceiver messageReceiver) { |
| messageReceivers.put(mepURL, messageReceiver); |
| } |
| |
| /** |
| * Register a messageBuilder implementation against a content type. |
| * This is used by Axis2 to support different message formats. |
| * |
| * @param contentType the relevant content-type (i.e. "text/xml") |
| * @param messageBuilder a Builder implementation |
| */ |
| public void addMessageBuilder(String contentType, |
| Builder messageBuilder) { |
| messageBuilders.put(contentType, messageBuilder); |
| } |
| |
| /** |
| * Register a messageFormatter implementation against a content type. |
| * This is used by Axis2 to support serialization of messages to different |
| * message formats. (Eg: JSON) |
| * |
| * @param contentType the relevant content-type (i.e. "text/xml") |
| * @param messageFormatter a MessageFormatter implementation |
| */ |
| public void addMessageFormatter(String contentType, |
| MessageFormatter messageFormatter) { |
| messageFormatters.put(contentType, messageFormatter); |
| } |
| |
| /** |
| * Add an available Module to this configuration |
| * |
| * @param module an AxisModule |
| * @throws AxisFault in case of error |
| */ |
| public void addModule(AxisModule module) throws AxisFault { |
| module.setParent(this); |
| |
| // check whether the module version paramter is there , if so set the module version as that |
| Parameter versionParameter = module.getParameter(org.apache.axis2.Constants.MODULE_VERSION); |
| if (versionParameter !=null ) { |
| String version = (String) versionParameter.getValue(); |
| try { |
| module.setVersion(new Version(version)); |
| } catch (ParseException ex) { |
| throw new AxisFault("The version number '" + version + "' specified by the " |
| + org.apache.axis2.Constants.MODULE_VERSION + " parameter is invalid"); |
| } |
| } |
| |
| allModules.put(module.getArchiveName(), module); |
| notifyObservers(new AxisEvent(AxisEvent.MODULE_DEPLOY,null), module); |
| |
| // Registering the policy namespaces that the module understand |
| registerModulePolicySupport(module); |
| // Registering the policy assertions that are local to the system |
| registerLocalPolicyAssertions(module); |
| |
| } |
| |
| public void deployModule(String moduleFileName) throws DeploymentException { |
| File moduleFile = new File(moduleFileName); |
| if (!moduleFile.exists()) { |
| throw new DeploymentException("Module archive '" + moduleFileName + "' doesn't exist"); |
| } |
| DeploymentFileData dfd = new DeploymentFileData(moduleFile, new ModuleDeployer(this)); |
| dfd.deploy(); |
| } |
| |
| /** |
| * Remove a module with moduleName & moduleVersion |
| * |
| * @param moduleName the name of the module to remove |
| * @param moduleVersion the version of the module to remove |
| */ |
| public void removeModule(String moduleName, String moduleVersion) { |
| allModules.remove(Utils.getModuleName(moduleName, moduleVersion)); |
| // TODO disengage has to be done here |
| } |
| |
| /** |
| * Remove a module with moduleName & moduleVersion |
| * |
| * @param moduleName the name of the module to remove |
| * @param moduleVersion the version of the module to remove |
| */ |
| public void removeModule(String moduleName, Version moduleVersion) { |
| String version = null; |
| if (moduleVersion != null) { |
| version = moduleVersion.toString(); |
| } |
| removeModule(moduleName, version); |
| } |
| |
| /** |
| * Adds module configuration, if there is a moduleConfig tag in service. |
| * |
| * @param moduleConfiguration a ModuleConfiguration to remember |
| */ |
| public void addModuleConfig(ModuleConfiguration moduleConfiguration) { |
| moduleConfigmap.put(moduleConfiguration.getModuleName(), |
| moduleConfiguration); |
| } |
| |
| /** |
| * Register given AxisObserver object to the {@link AxisConfiguration}. |
| * |
| * @param axisObserver the axis observer |
| */ |
| public void addObservers(AxisObserver axisObserver) { |
| observerSet.add(axisObserver); |
| } |
| |
| /** |
| * Unregister the given AxisObserver object if it is registered with |
| * the {@link AxisConfiguration}. |
| * |
| * @param axisObserver the axis observer |
| */ |
| public void removeObserver(AxisObserver axisObserver) { |
| observerSet.remove(axisObserver); |
| } |
| |
| /** |
| * Add an AxisService to our global configuration. Since services must |
| * be in ServiceGroups, we construct an anonymous AxisServiceGroup around |
| * the passed AxisService and then call addServiceGroup(). |
| * |
| * @param service an AxisService to deploy. |
| * @throws AxisFault if something goes wrong (invalid service, service is |
| * already deployed, etc...) |
| */ |
| public synchronized void addService(AxisService service) throws AxisFault { |
| AxisServiceGroup axisServiceGroup = new AxisServiceGroup(); |
| axisServiceGroup.setServiceGroupName(service.getName()); |
| axisServiceGroup.setParent(this); |
| axisServiceGroup.addService(service); |
| addServiceGroup(axisServiceGroup); |
| // processEndpoints(service, service.getAxisConfiguration()); |
| } |
| |
| public synchronized void addServiceGroup(AxisServiceGroup axisServiceGroup) |
| throws AxisFault { |
| axisServiceGroup.setParent(this); |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_DEPLOY, axisServiceGroup), axisServiceGroup); |
| AxisService axisService; |
| |
| Iterator<AxisService> services = axisServiceGroup.getServices(); |
| while (services.hasNext()) { |
| axisService = services.next(); |
| if (axisService.getSchemaTargetNamespace() == null) { |
| axisService.setSchemaTargetNamespace(Java2WSDLConstants.AXIS2_XSD); |
| } |
| } |
| services = axisServiceGroup.getServices(); |
| while (services.hasNext()) { |
| axisService = services.next(); |
| if (axisService.isUseDefaultChains()) { |
| Iterator<AxisOperation> operations = axisService.getOperations(); |
| while (operations.hasNext()) { |
| AxisOperation operation = operations.next(); |
| phasesinfo.setOperationPhases(operation); |
| } |
| } |
| } |
| Iterator<AxisModule> enModule = getEngagedModules().iterator(); |
| while (enModule.hasNext()) { |
| axisServiceGroup.engageModule(enModule.next()); |
| } |
| services = axisServiceGroup.getServices(); |
| ArrayList<AxisService> servicesIAdded = new ArrayList<AxisService>(); |
| while (services.hasNext()) { |
| axisService = services.next(); |
| processEndpoints(axisService, axisService.getAxisConfiguration()); |
| |
| Map<String, AxisEndpoint> endpoints = axisService.getEndpoints(); |
| String serviceName = axisService.getName(); |
| try { |
| addToAllServicesMap(axisService); |
| } catch (AxisFault axisFault) { |
| // Whoops, must have been a duplicate! If we had a problem here, we have to |
| // remove all the ones we added... |
| for (AxisService service : servicesIAdded) { |
| allServices.remove(service.getName()); |
| } |
| // And toss this in case anyone wants it? |
| throw axisFault; |
| } |
| servicesIAdded.add(axisService); |
| if (endpoints != null) { |
| Iterator<String> endpointNameIter = endpoints.keySet().iterator(); |
| while (endpointNameIter.hasNext()) { |
| String endpointName = endpointNameIter.next(); |
| if (log.isDebugEnabled()) { |
| log.debug("Adding service to allEndpoints map: (" |
| + serviceName + "," + endpointName + ") "); |
| } |
| |
| allEndpoints.put(serviceName + "." + endpointName, axisService); |
| } |
| if (log.isDebugEnabled()) { |
| log.debug("After adding to allEndpoints map, size is " |
| + allEndpoints.size()); |
| } |
| } |
| |
| if (!axisService.isClientSide()) { |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_DEPLOY ,axisService ), axisService); |
| } |
| } |
| // serviceGroups.put(axisServiceGroup.getServiceGroupName(), |
| // axisServiceGroup); |
| addChild(axisServiceGroup); |
| } |
| |
| /** |
| * This method is used to add a service to an existing active service group in the axis configuration |
| * |
| * @param axisService service to be added to the existing service group provided |
| * @param serviceGroupName name of the service group which should be existing in the axis configuration |
| * @throws AxisFault in case of an error in adding the service to the group specified or if the group is not existing |
| */ |
| public void addServiceToExistingServiceGroup(AxisService axisService, |
| String serviceGroupName) throws AxisFault { |
| |
| AxisServiceGroup serviceGroup = getServiceGroup(serviceGroupName); |
| if (serviceGroup == null) { |
| String message = "A ServiceGroup with the provided name " |
| + serviceGroupName + " is not existing"; |
| log.error(message); |
| throw new AxisFault(message); |
| } |
| |
| if (axisService.getSchemaTargetNamespace() == null) { |
| axisService.setSchemaTargetNamespace(Java2WSDLConstants.AXIS2_XSD); |
| } |
| |
| if (axisService.isUseDefaultChains()) { |
| Iterator<AxisOperation> operations = axisService.getOperations(); |
| while (operations.hasNext()) { |
| AxisOperation operation = operations.next(); |
| phasesinfo.setOperationPhases(operation); |
| } |
| } |
| |
| Map<String, AxisEndpoint> endpoints = axisService.getEndpoints(); |
| if (endpoints == null || endpoints.size() == 0) { |
| org.apache.axis2.deployment.util.Utils.addEndpointsToService( |
| axisService, axisService.getAxisConfiguration()); |
| endpoints = axisService.getEndpoints(); |
| } |
| |
| String serviceName = axisService.getName(); |
| addToAllServicesMap(axisService); |
| |
| if (endpoints != null) { |
| Iterator<String> endpointNameIter = endpoints.keySet().iterator(); |
| while (endpointNameIter.hasNext()) { |
| String endpointName = endpointNameIter.next(); |
| if (log.isDebugEnabled()) { |
| log.debug("Adding service to allEndpoints map: (" |
| + serviceName + "," + endpointName + ") "); |
| } |
| |
| allEndpoints.put(serviceName + "." + endpointName, axisService); |
| } |
| if (log.isDebugEnabled()) { |
| log.debug("After adding to allEndpoints map, size is " |
| + allEndpoints.size()); |
| } |
| } |
| |
| serviceGroup.addService(axisService); |
| |
| if (!axisService.isClientSide()) { |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_DEPLOY, axisService), axisService); |
| } |
| } |
| |
| public void addToAllServicesMap(AxisService axisService) throws AxisFault { |
| String serviceName = axisService.getName(); |
| AxisService oldService = allServices.get(serviceName); |
| if (oldService == null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Adding service to allServices map: [" + serviceName + "] "); |
| } |
| allServices.put(serviceName, axisService); |
| if (log.isTraceEnabled()) { |
| //noinspection ThrowableInstanceNeverThrown |
| log.trace("After adding to allServices map, size is " |
| + allServices.size() + " call stack is " + |
| JavaUtils.stackToString(new Exception())); |
| } |
| |
| } else { |
| // If we were already there, that's fine. If not, fault! |
| if (oldService != axisService) { |
| throw new AxisFault(Messages.getMessage("twoservicecannothavesamename", |
| axisService.getName() + |
| " [" + axisService.getFileName() + "]")); |
| } |
| } |
| } |
| |
| public AxisServiceGroup removeServiceGroup(String serviceGroupName) throws AxisFault { |
| AxisServiceGroup axisServiceGroup = (AxisServiceGroup) getChild(serviceGroupName); |
| if (axisServiceGroup == null) { |
| throw new AxisFault(Messages.getMessage("invalidservicegroupname", |
| serviceGroupName)); |
| } |
| |
| Iterator<AxisService> services = axisServiceGroup.getServices(); |
| boolean isClientSide = false; |
| while (services.hasNext()) { |
| AxisService axisService = services.next(); |
| isClientSide = axisService.isClientSide()? true : false; |
| |
| //removes the endpoints to this service |
| removeServiceReferences(axisService.getName()); |
| |
| } |
| removeChild(serviceGroupName); |
| if (!isClientSide) { |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_REMOVE, axisServiceGroup), axisServiceGroup); |
| } |
| |
| return axisServiceGroup; |
| } |
| |
| /** |
| * Add an incoming transport description (i.e. receiver) to our configuration. |
| * |
| * @param transport TransportInDescription to add. |
| * @throws AxisFault |
| */ |
| public void addTransportIn(TransportInDescription transport) throws AxisFault { |
| if (transport.getReceiver() == null) { |
| throw new AxisFault( |
| "Transport Receiver can not be null for the transport " |
| + transport.getName()); |
| } |
| transportsIn.put(transport.getName(), transport); |
| } |
| |
| /** |
| * Add an outgoing transport description (i.e. sender) to our configuration. |
| * |
| * @param transport TransportOutDescription to add. |
| * @throws AxisFault |
| */ |
| public void addTransportOut(TransportOutDescription transport) |
| throws AxisFault { |
| if (transport.getSender() == null) { |
| throw new AxisFault( |
| "Transport sender can not be null for the transport " |
| + transport.getName()); |
| } |
| transportsOut.put(transport.getName(), transport); |
| } |
| |
| /** |
| * Engages the default module version corresponding to given module name , |
| * or if the module name contains version number in it then it will engage |
| * the correct module. Both of the below two cases are valid 1. |
| * engageModule("addressing"); 2. engageModule("addressing-1.23"); |
| * |
| * @param moduleref name of module to engage |
| * @throws AxisFault |
| */ |
| public void engageModule(String moduleref) throws AxisFault { |
| AxisModule module = getModule(moduleref); |
| if (module != null) { |
| engageModule(module); |
| } else { |
| throw new AxisFault(Messages.getMessage("modulenotavailble", moduleref)); |
| } |
| } |
| |
| /** |
| * Engages a module using given name and its version ID. |
| * |
| * @param moduleName name of module to engage |
| * @param versionID version of module to engage |
| * @throws AxisFault |
| */ |
| public void engageModule(String moduleName, String versionID) |
| throws AxisFault { |
| String actualName = Utils.getModuleName(moduleName, versionID); |
| AxisModule module = getModule(actualName); |
| if (module != null) { |
| engageModule(module); |
| } else { |
| // TODO : Should this be an NPE or InvalidArgumentException? |
| throw new AxisFault(Messages.getMessage("refertoinvalidmodule")); |
| } |
| } |
| |
| public void onEngage(AxisModule module, AxisDescription engager) throws AxisFault { |
| Iterator<AxisServiceGroup> servicegroups = getServiceGroups(); |
| while (servicegroups.hasNext()) { |
| AxisServiceGroup serviceGroup = servicegroups.next(); |
| serviceGroup.engageModule(module, engager); |
| } |
| } |
| |
| /** |
| * To dis-engage a module from the system. This will remove all the handlers |
| * belonging to this module from all the handler chains. |
| * |
| * @param module module to disengage |
| */ |
| public void onDisengage(AxisModule module) throws AxisFault { |
| PhaseResolver phaseResolver = new PhaseResolver(this); |
| phaseResolver.disengageModuleFromGlobalChains(module); |
| |
| Iterator<AxisServiceGroup> serviceGroups = getServiceGroups(); |
| while (serviceGroups.hasNext()) { |
| AxisServiceGroup axisServiceGroup = serviceGroups.next(); |
| axisServiceGroup.disengageModule(module); |
| } |
| } |
| |
| public void notifyObservers(AxisEvent event, AxisService service) { |
| if (service.isClientSide()) |
| return; |
| |
| for (AxisObserver observer : observerSet) { |
| try { |
| observer.serviceUpdate(event, service); |
| } catch (Throwable e) { |
| // No need to stop the system due to this, so log an error and ignore |
| log.error("Error occured while notifying observer", e); |
| } |
| } |
| } |
| |
| public void notifyObservers(AxisEvent event, AxisModule moule) { |
| |
| for (AxisObserver anObserversList : observerSet) { |
| |
| try { |
| anObserversList.moduleUpdate(event, moule); |
| } catch (Throwable e) { |
| // No need to stop the system due to this, so log an error and ignore |
| log.error("Error occured while notifying observer", e); |
| } |
| } |
| } |
| |
| public void notifyObservers(AxisEvent event, AxisServiceGroup serviceGroup) { |
| |
| for (AxisObserver anObserversList : observerSet) { |
| |
| try { |
| anObserversList.serviceGroupUpdate(event, serviceGroup); |
| } catch (Throwable e) { |
| // No need to stop the system due to this, so log an error and ignore |
| log.error("Error occured while notifying observer", e); |
| } |
| } |
| } |
| |
| /** |
| * Remove a service. |
| * |
| * @param name name of service to remove |
| * @throws AxisFault |
| */ |
| public synchronized void removeService(String name) throws AxisFault { |
| AxisService service = removeServiceReferences(name); |
| if (service != null) { |
| AxisServiceGroup serviceGroup = service.getAxisServiceGroup(); |
| serviceGroup.removeService(name); |
| log.debug(Messages.getMessage("serviceremoved", name)); |
| } |
| } |
| |
| /** |
| * Add an AxisModule to the list of globally deployed modules. |
| * <p/> |
| * TODO: should this check for duplicate names? |
| * |
| * @param moduleName name of AxisModule to add to list. |
| */ |
| public void addGlobalModuleRef(String moduleName) { |
| globalModuleList.add(moduleName); |
| } |
| |
| /** |
| * Engage all the previously added global modules. |
| * |
| * @throws AxisFault if an individual engageModule() fails |
| */ |
| public void engageGlobalModules() throws AxisFault { |
| for (String aGlobalModuleList : globalModuleList) { |
| engageModule(aGlobalModuleList); |
| } |
| } |
| |
| public Hashtable<String, String> getFaultyModules() { |
| return faultyModules; |
| } |
| |
| public Hashtable<String, String> getFaultyServices() { |
| return faultyServices; |
| } |
| |
| /** |
| * Updates the map that keeps track of faulty services due to modules |
| * @param moduleName This service has become faulty due this module. |
| * @param faultyServiceData Data that are required when recovering the faulty service. |
| */ |
| public void addFaultyServiceDuetoModule(String moduleName, FaultyServiceData faultyServiceData) { |
| Map<String, FaultyServiceData> faultyServicesMap; |
| |
| synchronized (faultyServicesDueToModules) { |
| |
| if (faultyServicesDueToModules.containsKey(moduleName)) { |
| faultyServicesMap = faultyServicesDueToModules.get(moduleName); |
| faultyServicesMap.put(faultyServiceData.getServiceGroupName(), faultyServiceData); |
| |
| } else { |
| faultyServicesMap = new HashMap<String, FaultyServiceData>(); |
| faultyServicesMap.put(faultyServiceData.getServiceGroupName(), faultyServiceData); |
| faultyServicesDueToModules.put(moduleName, faultyServicesMap); |
| } |
| |
| //Adding the faulty service to default service map |
| String serviceStatus = "Error:\n" + "Engaged module not found :" + moduleName; |
| |
| String serviceLocation = null; |
| if(faultyServiceData.getCurrentDeploymentFile() != null){ |
| serviceLocation = faultyServiceData.getCurrentDeploymentFile().getFile().getAbsolutePath(); |
| } |
| |
| if(serviceLocation == null){ |
| serviceLocation = faultyServiceData.getServiceGroupName(); |
| } |
| faultyServices.put(serviceLocation, serviceStatus); |
| } |
| } |
| |
| /** |
| * Returns a map which contains the faulty services due a particular module. |
| * |
| * @param moduleName name of the module about which to inquire |
| * @return a Map<String, FaultyServiceData> mapping service name to data |
| */ |
| public Map<String, FaultyServiceData> getFaultyServicesDuetoModule(String moduleName) { |
| if (faultyServicesDueToModules.containsKey(moduleName)) { |
| return faultyServicesDueToModules.get(moduleName); |
| |
| } |
| return new HashMap<String, FaultyServiceData>(1); |
| } |
| |
| /** |
| * Returns the map which keeps track of faulty services due to modules. |
| * @return a Map keyed by module name, containing Maps keyed by service name containing |
| * FaultyServiceData for each faulty service. |
| */ |
| public Map<String, Map<String, FaultyServiceData>> getFaultyServicesDuetoModules(){ |
| return faultyServicesDueToModules; |
| } |
| |
| /** |
| * Removes a faulty service for a given module from the internal map. |
| * |
| * TODO: Doesn't this actually remove a faulty service *group*? And should this even be public? |
| * |
| * @param moduleName name of the module to look up |
| * @param serviceGroupName name of the service group to remove |
| */ |
| public void removeFaultyServiceDuetoModule(String moduleName, String serviceGroupName) { |
| synchronized (faultyServicesDueToModules) { |
| Map<String, FaultyServiceData> faultyServicesDueToModule = faultyServicesDueToModules.get(moduleName); |
| FaultyServiceData faultyServiceData = faultyServicesDueToModule.get(serviceGroupName); |
| |
| if (faultyServicesDueToModule != null) { |
| faultyServicesDueToModule.remove(serviceGroupName); |
| |
| //Removing from the default faulty services map. |
| String serviceLocation = null; |
| if (faultyServiceData.getCurrentDeploymentFile() != null) { |
| serviceLocation = faultyServiceData.getCurrentDeploymentFile().getFile().getAbsolutePath(); |
| } |
| |
| if (serviceLocation == null) { |
| serviceLocation = faultyServiceData.getServiceGroupName(); |
| } |
| faultyServices.remove(serviceLocation); |
| |
| if (faultyServicesDueToModule.isEmpty()) { |
| faultyServicesDueToModules.remove(moduleName); |
| } |
| } |
| } |
| } |
| |
| public void removeFaultyService(String key) { |
| Iterator<String> itr = faultyServices.keySet().iterator(); |
| while (itr.hasNext()) { |
| String fullFileName = itr.next(); |
| if (fullFileName.indexOf(key) >= 0) { |
| faultyServices.remove(fullFileName); |
| return; |
| } |
| } |
| } |
| |
| // to get the out flow correpodning to the global out flow; |
| public List<Phase> getOutFlowPhases() { |
| return this.outPhases; |
| } |
| |
| /** |
| * @return Returns ArrayList. |
| */ |
| public List<Phase> getInFaultFlowPhases() { |
| return inFaultPhases; |
| } |
| |
| public List<Phase> getInFlowPhases() { |
| return inPhasesUptoAndIncludingPostDispatch; |
| } |
| |
| public MessageReceiver getMessageReceiver(String mepURL) { |
| return messageReceivers.get(mepURL); |
| } |
| |
| /** |
| * Get a Builder for a particular content type. |
| * |
| * @param contentType the desired content type |
| * @return the configured message builder implementation class name against |
| * the given content type. |
| */ |
| public Builder getMessageBuilder(String contentType) { |
| Builder builder = null; |
| if (messageBuilders.isEmpty()) { |
| return null; |
| } |
| if (contentType != null) { |
| builder = messageBuilders.get(contentType); |
| if (builder == null) { |
| builder = messageBuilders.get(contentType.toLowerCase()); |
| } |
| if (builder == null) { |
| Iterator<Entry<String, Builder>> iterator = messageBuilders.entrySet().iterator(); |
| while (iterator.hasNext() && builder == null) { |
| Entry<String, Builder> entry = iterator.next(); |
| String key = entry.getKey(); |
| if (contentType.matches(key)) { |
| builder = entry.getValue(); |
| } |
| } |
| } |
| } |
| return builder; |
| } |
| |
| public Builder getMessageBuilder(String contentType, boolean defaultBuilder) { |
| Builder builder = getMessageBuilder(contentType); |
| if (builder == null && defaultBuilder){ |
| builder = new UnknownContentBuilder(); |
| } |
| return builder; |
| } |
| |
| /** |
| * Get a MessageFormatter for the specified content type. |
| * |
| * @param contentType content type to look up |
| * @return a MessageFormatter corresponding to the given content type, or null. |
| */ |
| public MessageFormatter getMessageFormatter(String contentType) { |
| return messageFormatters.get(contentType); |
| } |
| |
| // /** |
| // * |
| // * @deprecate Please use String version instead |
| // * @param qname |
| // * @return |
| // */ |
| // public AxisModule getModule(QName qname) { |
| // return getModule(qname.getLocalPart()); |
| // } |
| |
| /** |
| * Get an AxisModule by name. |
| * |
| * If the exact name passed (which might contain a version) is present, we'll return that, |
| * otherwise we'll look for the default version *if* there is no version in the passed |
| * name. |
| * |
| * @param name module name to look up |
| * @return an AxisModule if found, or null |
| */ |
| public AxisModule getModule(String name) { |
| AxisModule module = allModules.get(name); |
| if (module != null) { |
| return module; |
| } |
| // checks whether the version string seperator is not there in the |
| // module name |
| String defaultModuleVersion = getDefaultModuleVersion(name); |
| if (defaultModuleVersion != null) { |
| module = allModules.get(Utils.getModuleName(name, defaultModuleVersion)); |
| if (module != null) { |
| return module; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Return the module having name=moduleName & version=moduleVersion |
| * |
| * @param moduleName The module name |
| * @param moduleVersion The version of the module |
| * @return The AxisModule having name=moduleName & version=moduleVersion |
| */ |
| public AxisModule getModule(String moduleName, String moduleVersion) { |
| if (moduleVersion == null || moduleVersion.trim().length() == 0) { |
| moduleVersion = getDefaultModuleVersion(moduleName); |
| } |
| return allModules.get(Utils.getModuleName(moduleName, moduleVersion)); |
| } |
| |
| /** |
| * Get the class loader that becomes the parent of all the modules |
| * |
| * @return a ClassLoader |
| */ |
| public ClassLoader getModuleClassLoader() { |
| return this.moduleClassLoader; |
| } |
| |
| public ModuleConfiguration getModuleConfig(String moduleName) { |
| return moduleConfigmap.get(moduleName); |
| } |
| |
| /** |
| * @return Returns HashMap. |
| */ |
| public HashMap<String, AxisModule> getModules() { |
| return allModules; |
| } |
| |
| /** |
| * @return Returns ArrayList. |
| */ |
| public List<Phase> getOutFaultFlowPhases() { |
| return outFaultPhases; |
| } |
| |
| public PhasesInfo getPhasesInfo() { |
| return phasesinfo; |
| } |
| |
| public URL getRepository() { |
| return axis2Repository; |
| } |
| |
| /** |
| * Method getService. |
| * |
| * @param name the name of the service to look up |
| * @return an AxisService if found, or null |
| */ |
| public AxisService getService(String name) throws AxisFault { |
| AxisService axisService = allServices.get(name); |
| if (axisService != null) { |
| if (axisService.isActive()) { |
| return axisService; |
| } else { |
| throw new AxisFault(Messages |
| .getMessage("serviceinactive", name)); |
| } |
| } else { |
| axisService = allEndpoints.get(name); |
| if (axisService != null) { |
| if (axisService.isActive()) { |
| return axisService; |
| } else { |
| throw new AxisFault(Messages |
| .getMessage("serviceinactive", name)); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Service can start and stop, once stopped it cannot be accessed, so we |
| * need a way to get the service even if service is not active. |
| * |
| * @param serviceName name to look up |
| * @return AxisService |
| */ |
| public AxisService getServiceForActivation(String serviceName) { |
| AxisService axisService; |
| axisService = allServices.get(serviceName); |
| if (axisService != null) { |
| return axisService; |
| } else { |
| axisService = allEndpoints.get(serviceName); |
| return axisService; |
| } |
| } |
| |
| // The class loader that becomes the parent of all the services |
| public ClassLoader getServiceClassLoader() { |
| return this.serviceClassLoader; |
| } |
| |
| public AxisServiceGroup getServiceGroup(String serviceNameAndGroupString) { |
| // return (AxisServiceGroup) |
| // serviceGroups.get(serviceNameAndGroupString); |
| return (AxisServiceGroup) getChild(serviceNameAndGroupString); |
| } |
| |
| public Iterator<AxisServiceGroup> getServiceGroups() { |
| // return serviceGroups.values().iterator(); |
| return (Iterator<AxisServiceGroup>) getChildren(); |
| } |
| |
| // To get all the services in the system |
| public HashMap<String, AxisService> getServices() { |
| HashMap<String, AxisService> hashMap = new HashMap<String, AxisService>(this.allServices.size()); |
| String key; |
| for (String s : this.allServices.keySet()) { |
| key = s; |
| hashMap.put(key, this.allServices.get(key)); |
| } |
| return hashMap; |
| } |
| |
| // The class loader which become the top most parent of all the modules and |
| // services |
| public ClassLoader getSystemClassLoader() { |
| return this.systemClassLoader; |
| } |
| |
| public TransportInDescription getTransportIn(String name) { |
| return transportsIn.get(name); |
| } |
| |
| public TransportOutDescription getTransportOut(String name) { |
| return transportsOut.get(name); |
| } |
| |
| public HashMap<String, TransportInDescription> getTransportsIn() { |
| return transportsIn; |
| } |
| |
| public HashMap<String, TransportOutDescription> getTransportsOut() { |
| return transportsOut; |
| } |
| |
| public boolean isEngaged(String moduleId) { |
| AxisModule module = getModule(moduleId); |
| if (module == null) { |
| return false; |
| } |
| boolean isEngaged = super.isEngaged(module); |
| if (!isEngaged) { |
| AxisModule defaultModule = getDefaultModule(moduleId); |
| isEngaged = engagedModules != null && engagedModules.values().contains(defaultModule); |
| } |
| return isEngaged; |
| } |
| |
| public boolean isEngaged(AxisModule axisModule) { |
| boolean isEngaged = super.isEngaged(axisModule); |
| if (!isEngaged) { |
| isEngaged = engagedModules != null && |
| engagedModules.values().contains(axisModule); |
| } |
| return isEngaged; |
| } |
| |
| public void setGlobalOutPhase(List<Phase> outPhases) { |
| this.outPhases = outPhases; |
| } |
| |
| /** |
| * Set the inbound fault phases |
| * |
| * TODO: Passing mutable lists like this and using them directly is bad practice. |
| * |
| * @param list a List of Phases which will become our inbound fault flow |
| */ |
| public void setInFaultPhases(List<Phase> list) { |
| inFaultPhases = list; |
| } |
| |
| public void setInPhasesUptoAndIncludingPostDispatch( |
| List<Phase> inPhasesUptoAndIncludingPostDispatch) { |
| this.inPhasesUptoAndIncludingPostDispatch = inPhasesUptoAndIncludingPostDispatch; |
| } |
| |
| public void setModuleClassLoader(ClassLoader classLoader) { |
| this.moduleClassLoader = classLoader; |
| } |
| |
| /** |
| * Set the outbound fault phases |
| * |
| * TODO: Passing mutable lists like this and using them directly is bad practice. |
| * |
| * @param list a List of Phases which will become our outbound fault flow |
| */ |
| public void setOutFaultPhases(List<Phase> list) { |
| outFaultPhases = list; |
| } |
| |
| public void setPhasesInfo(PhasesInfo phasesInfo) { |
| this.phasesinfo = phasesInfo; |
| } |
| |
| public void setRepository(URL axis2Repository) { |
| this.axis2Repository = axis2Repository; |
| } |
| |
| public void setServiceClassLoader(ClassLoader classLoader) { |
| this.serviceClassLoader = classLoader; |
| } |
| |
| public void setSystemClassLoader(ClassLoader classLoader) { |
| this.systemClassLoader = classLoader; |
| } |
| |
| /** |
| * Adds a default module version, which can be done either programmatically |
| * or by using axis2.xml. The default module version is important if user |
| * asks to engage a module without given version ID, in which case, |
| * the default version is engaged. |
| * |
| * TODO: This currently does NOTHING if a default has already been set. Should either overwrite or throw. |
| * |
| * @param moduleName the name of the module for which we're setting the default version |
| * @param moduleVersion the default version |
| */ |
| public void addDefaultModuleVersion(String moduleName, String moduleVersion) { |
| if (nameToversionMap.get(moduleName) == null) { |
| nameToversionMap.put(moduleName, moduleVersion); |
| } |
| } |
| |
| public String getDefaultModuleVersion(String moduleName) { |
| return nameToversionMap.get(moduleName); |
| } |
| |
| public AxisModule getDefaultModule(String moduleName) { |
| String defaultModuleVersion = getDefaultModuleVersion(moduleName); |
| if (defaultModuleVersion == null) { |
| return allModules.get(moduleName); |
| } else { |
| return allModules.get(moduleName + "-" + defaultModuleVersion); |
| } |
| } |
| |
| public ClusteringAgent getClusteringAgent() { |
| return clusteringAgent; |
| } |
| |
| public void setClusteringAgent(ClusteringAgent clusteringAgent) { |
| this.clusteringAgent = clusteringAgent; |
| } |
| |
| public TransactionConfiguration getTransactionConfiguration() { |
| return transactionConfiguration; |
| } |
| |
| public void setTransactionConfig(TransactionConfiguration transactionConfiguration) { |
| this.transactionConfiguration = transactionConfiguration; |
| } |
| |
| public Object getKey() { |
| return toString(); |
| } |
| |
| public void stopService(String serviceName) throws AxisFault { |
| AxisService service = allServices.get(serviceName); |
| if (service == null) { |
| throw new AxisFault(Messages.getMessage("servicenamenotvalid", |
| serviceName)); |
| } |
| service.setActive(false); |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_STOP , service), service); |
| } |
| |
| public void startService(String serviceName) throws AxisFault { |
| AxisService service = allServices.get(serviceName); |
| if (service == null) { |
| throw new AxisFault(Messages.getMessage("servicenamenotvalid", |
| serviceName)); |
| } |
| service.setActive(true); |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_START , service), service); |
| } |
| |
| public List<AxisModule> getModulesForPolicyNamesapce(String namesapce) { |
| return policySupportedModules.get(namesapce); |
| } |
| |
| public void registerModulePolicySupport(AxisModule axisModule) { |
| String[] namespaces = axisModule.getSupportedPolicyNamespaces(); |
| |
| if (namespaces == null) { |
| return; |
| } |
| |
| List<AxisModule> modulesList; |
| |
| for (String namespace : namespaces) { |
| modulesList = policySupportedModules.get(namespace); |
| |
| if (modulesList != null) { |
| modulesList.add(axisModule); |
| } else { |
| modulesList = new ArrayList<AxisModule>(); |
| modulesList.add(axisModule); |
| policySupportedModules.put(namespace, modulesList); |
| } |
| } |
| } |
| |
| public void registerLocalPolicyAssertions(AxisModule axisModule) { |
| QName[] localPolicyAssertions = axisModule.getLocalPolicyAssertions(); |
| |
| if (localPolicyAssertions == null) { |
| return; |
| } |
| |
| for (QName localPolicyAssertion : localPolicyAssertions) { |
| addLocalPolicyAssertion(localPolicyAssertion); |
| } |
| } |
| |
| /** |
| * This method returns read-only list of AxisObservers registered with this |
| * {@link AxisConfiguration}. |
| * |
| * @return ArrayList<AxisObserver> |
| */ |
| public ArrayList<AxisObserver> getObserversList() { |
| AxisObserver[] array = observerSet.toArray(new AxisObserver[observerSet.size()]); |
| ArrayList<AxisObserver> observers = new ArrayList<AxisObserver>(array.length); |
| observers.addAll(Arrays.asList(array)); |
| return observers; |
| } |
| |
| public boolean isStart() { |
| return start; |
| } |
| |
| public void setStart(boolean start) { |
| this.start = start; |
| } |
| |
| /** |
| * getTargetResolverChain returns an instance of |
| * TargetResolver which iterates over the registered |
| * TargetResolvers, calling each one in turn when |
| * resolveTarget is called. |
| * |
| * @return a TargetResolver which iterates over all registered TargetResolvers. |
| */ |
| public TargetResolver getTargetResolverChain() { |
| if (targetResolvers.isEmpty()) { |
| return null; |
| } |
| return new TargetResolver() { |
| public void resolveTarget(MessageContext messageContext) { |
| Iterator<TargetResolver> iter = targetResolvers.iterator(); |
| while (iter.hasNext()) { |
| TargetResolver tr = iter.next(); |
| tr.resolveTarget(messageContext); |
| } |
| } |
| }; |
| } |
| |
| public void addTargetResolver(TargetResolver tr) { |
| targetResolvers.add(tr); |
| } |
| |
| public void addLocalPolicyAssertion(QName name) { |
| this.localPolicyAssertions.add(name); |
| } |
| |
| public List<QName> getLocalPolicyAssertions() { |
| return this.localPolicyAssertions; |
| } |
| |
| public void removeLocalPolicyAssertion(QName name) { |
| this.localPolicyAssertions.remove(name); |
| } |
| |
| public boolean isAssertionLocal(QName name) { |
| return this.localPolicyAssertions.contains(name); |
| } |
| |
| /** |
| * Allows to define/configure Data Locator for specified dialect at Axis 2 Configuration. |
| * |
| * @param dialect- an absolute URI represents the format and version of data |
| * @param classname - class name of the Data Locator configured to support retrieval |
| * for the specified dialect. |
| */ |
| public void addDataLocatorClassNames(String dialect, String classname) { |
| dataLocatorClassNames.put(dialect, classname); |
| } |
| |
| /** |
| * For internal used only! To store instance of DataLocator when it is first loaded. This allows to |
| * reuse of the DataLocator after it is initially loaded. |
| * |
| * @param dialect- an absolute URI represents the format and version of data |
| * @param dataLocator - specified an DataLocator instance to support retrieval |
| * of the specified dialect. |
| */ |
| public void addDataLocator(String dialect, AxisDataLocator dataLocator) { |
| dataLocators.put(dialect, dataLocator); |
| } |
| |
| /** |
| * Return DataLocator instance for specified dialect. |
| * @param dialect the dialect to look up |
| * @return an AxisDataLocator, or null |
| */ |
| public AxisDataLocator getDataLocator(String dialect) { |
| return dataLocators.get(dialect); |
| } |
| |
| |
| /** |
| * Return classname of DataLocator configured for specified dialect. |
| * @param dialect the dialect to look up |
| * @return a String containing a class name, or null |
| */ |
| public String getDataLocatorClassName(String dialect) { |
| return dataLocatorClassNames.get(dialect); |
| } |
| |
| |
| /** |
| * Checks whether the system pre-defined phases |
| * for all the flows, have been changed. If they have been changed, throws a DeploymentException. |
| * |
| * @throws org.apache.axis2.deployment.DeploymentException |
| * |
| */ |
| public void validateSystemPredefinedPhases() throws DeploymentException { |
| PhasesInfo phasesInfo = getPhasesInfo(); |
| setInPhasesUptoAndIncludingPostDispatch(phasesInfo.getGlobalInflow()); |
| setInFaultPhases(phasesInfo.getGlobalInFaultPhases()); |
| setGlobalOutPhase(phasesInfo.getGlobalOutPhaseList()); |
| setOutFaultPhases(phasesInfo.getOUT_FaultPhases()); |
| } |
| |
| public AxisConfigurator getConfigurator() { |
| return configurator; |
| } |
| |
| public void setConfigurator(AxisConfigurator configurator) { |
| this.configurator = configurator; |
| } |
| |
| public void cleanup() { |
| if (configurator != null) { |
| configurator.cleanup(); |
| } |
| if (clusteringAgent != null) { |
| clusteringAgent.finalize(); |
| } |
| this.policySupportedModules.clear(); |
| this.moduleConfigmap.clear(); |
| this.allEndpoints.clear(); |
| this.allModules.clear(); |
| this.allServices.clear(); |
| this.outPhases.clear(); |
| this.messageReceivers.clear(); |
| this.targetResolvers.clear(); |
| if (this.engagedModules != null) { |
| this.engagedModules.clear(); |
| } |
| this.configurator = null; |
| } |
| |
| /** |
| * This method can be used to insert a phase at the runtime for a given location |
| * And the relative location can be specified by beforePhase and afterPhase. Parameters |
| * Either or both of them can be null , if both the parameters are null then the phase |
| * will be added some where in the global phase. If one of them are null then the phase |
| * will be added |
| * - If the beforePhase is null then the phase will be added after the afterPhase |
| * - If the after phase is null then the phase will be added before the beforePhase |
| * Type of the flow will be specified by the parameter flow. |
| * 1 - Inflow |
| * 2 - out flow |
| * 3 - fault in flow |
| * 4 - fault out flow |
| * |
| * @param d the Deployable representing the Phase to deploy |
| * @param flow the type of the flow |
| * @throws org.apache.axis2.AxisFault : If something went wrong |
| */ |
| public void insertPhase(Deployable d, int flow) throws AxisFault { |
| |
| switch (flow) { |
| case PhaseMetadata.IN_FLOW : { |
| List<Phase> phaseList = phasesinfo.getINPhases(); |
| phaseList = findAndInsertPhase(d, phaseList); |
| if (phaseList != null) { |
| phasesinfo.setINPhases(phaseList); |
| } |
| break; |
| } |
| case PhaseMetadata.OUT_FLOW : { |
| List<Phase> phaseList = phasesinfo.getOUTPhases(); |
| phaseList = findAndInsertPhase(d, phaseList); |
| if (phaseList != null) { |
| phasesinfo.setOUTPhases(phaseList); |
| } |
| break; |
| } |
| case PhaseMetadata.FAULT_OUT_FLOW : { |
| List<Phase> phaseList = phasesinfo.getOutFaultPhaseList(); |
| phaseList = findAndInsertPhase(d, phaseList); |
| if (phaseList != null) { |
| phasesinfo.setOUT_FaultPhases(phaseList); |
| } |
| break; |
| } |
| case PhaseMetadata.FAULT_IN_FLOW : { |
| List<Phase> phaseList = phasesinfo.getIN_FaultPhases(); |
| phaseList = findAndInsertPhase(d, phaseList); |
| if (phaseList != null) { |
| phasesinfo.setIN_FaultPhases(phaseList); |
| } |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Insert a Phase into a list of Phases |
| * |
| * @param d a Deployable containing the Phase to insert |
| * @param phaseList a list of Phases |
| * @return a new List of Phases with the new one correctly deployed. |
| * @throws AxisFault |
| */ |
| private List<Phase> findAndInsertPhase(Deployable d, List<Phase> phaseList) throws AxisFault { |
| DeployableChain<Phase> ec = new DeployableChain<Phase>(); |
| String last = null; |
| for (Phase phase : phaseList) { |
| String name = phase.getName(); |
| Deployable existing = new Deployable(name); |
| existing.setTarget(phase); |
| if (last != null) { |
| // Set up explicit chain relationship for preexisting phases, for now. |
| ec.addRelationship(last, name); |
| } |
| last = name; |
| try { |
| ec.deploy(existing); |
| } catch (Exception e) { |
| // This should never happen when building a simple list like the above |
| throw AxisFault.makeFault(e); |
| } |
| } |
| |
| try { |
| ec.deploy(d); |
| |
| if (d.getTarget() == null) { |
| Phase phase = new Phase(); |
| phase.setName(d.getName()); |
| d.setTarget(phase); |
| } |
| |
| ec.rebuild(); |
| } catch (Exception e) { |
| throw AxisFault.makeFault(e); |
| } |
| |
| phaseList = ec.getChain(); |
| |
| return phaseList; |
| } |
| |
| private void processEndpoints(AxisService axisService, |
| AxisConfiguration axisConfiguration) throws AxisFault { |
| Map<String, AxisEndpoint> enspoints = axisService.getEndpoints(); |
| if (enspoints == null || enspoints.size() == 0) { |
| org.apache.axis2.deployment.util.Utils.addEndpointsToService( |
| axisService, axisConfiguration); |
| } |
| } |
| |
| public boolean isChildFirstClassLoading(){ |
| boolean childFirstClassLoading = false; |
| Parameter isChildFirstClassLoading = this.getParameter(Constants.Configuration.ENABLE_CHILD_FIRST_CLASS_LOADING); |
| if (isChildFirstClassLoading != null){ |
| childFirstClassLoading = JavaUtils.isTrueExplicitly(isChildFirstClassLoading.getValue()); |
| } |
| return childFirstClassLoading; |
| } |
| |
| private AxisService removeServiceReferences(String serviceName) { |
| |
| AxisService axisService = allServices.remove(serviceName); |
| if (axisService != null) { |
| if (!axisService.isClientSide()) { |
| notifyObservers(new AxisEvent(AxisEvent.SERVICE_REMOVE, |
| axisService), axisService); |
| } |
| |
| // removes the endpoints to this service |
| for (Iterator<String> iter = axisService.getEndpoints().keySet() |
| .iterator(); iter.hasNext();) { |
| String key = serviceName + "." + iter.next(); |
| this.allEndpoints.remove(key); |
| } |
| } |
| return axisService; |
| } |
| |
| public boolean isGlobalModulesRegistered(String moduleName) { |
| if (globalModuleList.contains(moduleName)) { |
| return true; |
| } |
| return false; |
| } |
| } |
