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 >();
        observersList = new ArrayList< AxisObserver >();
        inPhasesUptoAndIncludingPostDispatch = new ArrayList< Phase >();
        systemClassLoader = (ClassLoader) 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 >();
}

Constructor AxisConfiguration.

 public  void addDataLocator(String dialect,
    AxisDataLocator dataLocator) 
{
        dataLocators.put(dialect, dataLocator);
}

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.

 public  void addDataLocatorClassNames(String dialect,
    String classname) 
{
        dataLocatorClassNames.put(dialect, classname);
}

Allows to define/configure Data Locator for specified dialect at Axis 2 Configuration.

 public  void addDefaultModuleVersion(String moduleName,
    String moduleVersion) 
{
        if (nameToversionMap.get(moduleName) == null) {
            nameToversionMap.put(moduleName, moduleVersion);
        }
}

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.

 public  void addGlobalModuleRef(String moduleName) 
{
        globalModuleList.add(moduleName);
}

Add an AxisModule to the list of globally deployed modules.

TODO: should this check for duplicate names?

 public  void addLocalPolicyAssertion(QName name) 
{
        this.localPolicyAssertions.add(name);
}

 public  void addMessageBuilder(String contentType,
    Builder messageBuilder) 
{
        messageBuilders.put(contentType, messageBuilder);
}

Register a messageBuilder implementation against a content type. This is used by Axis2 to support different message formats.

 public  void addMessageFormatter(String contentType,
    MessageFormatter messageFormatter) 
{
        messageFormatters.put(contentType, messageFormatter);
}

Register a messageFormatter implementation against a content type. This is used by Axis2 to support serialization of messages to different message formats. (Eg: JSON)

 public  void addMessageReceiver(String mepURL,
    MessageReceiver messageReceiver) 
{
        messageReceivers.put(mepURL, messageReceiver);
}

 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 verisonParamter = module.getParameter(org.apache.axis2.Constants.MODULE_VERSION);
        if (verisonParamter !=null ) {
            String version = (String) verisonParamter.getValue();
            module.setVersion(version);
        }
        if (module.getVersion() == null) {
            if (module.getName().endsWith(AxisModule.VERSION_SNAPSHOT)) {
                allModules.put(module.getName(), module);
                String moduleName =
                        module.getName().substring(0,
                                                   module.getName().indexOf(AxisModule.VERSION_SNAPSHOT) - 1);
                module.setName(moduleName);
                module.setVersion(AxisModule.VERSION_SNAPSHOT);
            } else {
                allModules.put(module.getName(), module);
            }
        } else { // Calculate the module version from the name
            allModules.put(Utils.getModuleName(module.getName(), module.getVersion()), module);
        }
        notifyObservers(AxisEvent.MODULE_DEPLOY, module);
        // Registering the policy namespaces that the module understand
        registerModulePolicySupport(module);
        // Registering the policy assertions that are local to the system
        registerLocalPolicyAssertions(module);
}

Add an available Module to this configuration

 public  void addModuleConfig(ModuleConfiguration moduleConfiguration) 
{
        moduleConfigmap.put(moduleConfiguration.getModuleName(),
                            moduleConfiguration);
}

Adds module configuration, if there is a moduleConfig tag in service.

 public  void addObservers(AxisObserver axisObserver) 
{
        observersList.add(axisObserver);
}

 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());
}

Method addService.

 public synchronized  void addServiceGroup(AxisServiceGroup axisServiceGroup) throws AxisFault 
{
        axisServiceGroup.setParent(this);
        notifyObservers(AxisEvent.SERVICE_DEPLOY, axisServiceGroup);
        AxisService axisService;
        Iterator< AxisService > services = axisServiceGroup.getServices();
        while (services.hasNext()) {
            axisService = (AxisService) services.next();
            if (axisService.getSchemaTargetNamespace() == null) {
                axisService.setSchemaTargetNamespace(Java2WSDLConstants.AXIS2_XSD);
            }
        }
        services = axisServiceGroup.getServices();
        while (services.hasNext()) {
            axisService = (AxisService) services.next();
            if (axisService.isUseDefaultChains()) {
                Iterator< AxisOperation > operations = axisService.getOperations();
                while (operations.hasNext()) {
                    AxisOperation operation = (AxisOperation) operations.next();
                    phasesinfo.setOperationPhases(operation);
                }
            }
        }
        Iterator< AxisModule > enModule = getEngagedModules().iterator();
        while (enModule.hasNext()) {
            axisServiceGroup.engageModule((AxisModule) enModule.next());
        }
        services = axisServiceGroup.getServices();
        ArrayList< AxisService > servicesIAdded = new ArrayList< AxisService >();
        while (services.hasNext()) {
            axisService = (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 (Iterator< AxisService > i = servicesIAdded.iterator(); i.hasNext();) {
                    AxisService service = (AxisService) i.next();
                    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 = (String) 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(AxisEvent.SERVICE_DEPLOY, axisService);
            }
        }
        // serviceGroups.put(axisServiceGroup.getServiceGroupName(),
        // axisServiceGroup);
        addChild(axisServiceGroup);
}

 public  void addTargetResolver(TargetResolver tr) 
{
        targetResolvers.add(tr);
}

 public  void addToAllServicesMap(AxisService axisService) throws AxisFault 
{
        String serviceName = axisService.getName();
        AxisService oldService = (AxisService) allServices.get(serviceName);
        if (oldService == null) {
            if (log.isDebugEnabled()) {
                log.debug("Adding service to allServices map: [" + serviceName + "] ");
            }
            allServices.put(serviceName, axisService);
            if (log.isTraceEnabled()) {
                log.trace("After adding to allServices map, size is "
                          + allServices.size(), 
                          new Exception("AxisConfiguration.addToAllServicesMap called from"));
            }
        } else {
            // If we were already there, that's fine.  If not, fault!
            if (oldService != axisService) {
                throw new AxisFault(Messages.getMessage("twoservicecannothavesamename",
                                                        axisService.getName()));
            }
        }
}

 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);
}

Method addTransportIn.

 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);
}

Method addTransportOut.

 public  void cleanup() 
{
        if (configurator != null) {
            configurator.cleanup();
        }
}

 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();
}

 public  void engageGlobalModules() throws AxisFault 
{
        for (Iterator< String > i = globalModuleList.iterator(); i.hasNext();) {
            engageModule((String) i.next());
        }
}

Engage all the previously added global modules.

 public  void engageModule(QName moduleref) throws AxisFault 
{
        engageModule(moduleref.getLocalPart());
}

Engages the default module version corresponding to the given module name, or if the module name contains version number in it then it will engage the correct module. Both the below cases are valid : - 1. engageModule("addressing"); 2. engageModule("addressing-1.23");

 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 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");

 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 {
            throw new AxisFault(Messages.getMessage("refertoinvalidmodule"));
        }
}

Engages a module using given name and its version ID.

 public ClusterManager getClusterManager() 
{
        return clusterManager;
}

 public AxisConfigurator getConfigurator() 
{
        return configurator;
}

 public AxisDataLocator getDataLocator(String dialect) 
{
        return (AxisDataLocator) dataLocators.get(dialect);
}

Return DataLocator instance for specified dialect.

 public String getDataLocatorClassName(String dialect) 
{
        return (String) dataLocatorClassNames.get(dialect);
}

Return classname of DataLocator configured for specified dialect.

 public AxisModule getDefaultModule(String moduleName) 
{
        String defaultModuleVersion = getDefaultModuleVersion(moduleName);
        if (defaultModuleVersion == null) {
            return (AxisModule) allModules.get(moduleName);
        } else {
            return (AxisModule) allModules.get(moduleName + "-" + defaultModuleVersion);
        }
}

 public String getDefaultModuleVersion(String moduleName) 
{
        return (String) nameToversionMap.get(moduleName);
}

 public Hashtable getFaultyModules() 
{
        return faultyModules;
}

 public Hashtable getFaultyServices() 
{
        return faultyServices;
}

 public List getGlobalModules() 
{
        return globalModuleList;
}

Get a list of the global modules

 public List getInFaultFlowPhases() 
{
        return inFaultPhases;
}

 public List getInFlowPhases() 
{
        return inPhasesUptoAndIncludingPostDispatch;
}

 public Object getKey() 
{
        return toString();
}

 public List getLocalPolicyAssertions() 
{
        return this.localPolicyAssertions;
}

 public Builder getMessageBuilder(String contentType) 
{
        Builder builder = null;
        if (messageBuilders.isEmpty()) {
            return null;
        }
        if (contentType != null) {
            builder = (Builder) messageBuilders.get(contentType);
            if (builder == null) {
                builder = (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;
}

 public MessageFormatter getMessageFormatter(String contentType) 
{
        return (MessageFormatter) messageFormatters.get(contentType);
}

 public MessageReceiver getMessageReceiver(String mepURL) 
{
        return (MessageReceiver) messageReceivers.get(mepURL);
}

 public AxisModule getModule(String name) 
{
        AxisModule module = (AxisModule) allModules.get(name);
        if (module != null) {
            return module;
        }
        // checks whether the version string seperator is not there in the
        // module name
        String moduleName = name;
        String defaultModuleVersion = getDefaultModuleVersion(moduleName);
        if (defaultModuleVersion != null) {
            module =
                    (AxisModule) allModules.get(Utils.getModuleName(moduleName,
                                                                    defaultModuleVersion));
            if (module != null) {
                return module;
            }
        }
        return null;
}

Method getModule. First it will check whether the given module is there in the hashMap, if so returns that and the name, which can be either with version string or without version string.

If its not found and the name does not contain the version string in it then checks whether the default version of the module is available in the sytem for the given name, then returns that.

 public AxisModule getModule(String moduleName,
    String moduleVersion) 
{
        if (moduleVersion == null || moduleVersion.trim().length() == 0) {
            moduleVersion = getDefaultModuleVersion(moduleName);
        }
        return (AxisModule) allModules.get(Utils.getModuleName(moduleName, moduleVersion));
}

Return the module having name=moduleName & version=moduleVersion

 public ClassLoader getModuleClassLoader() 
{
        return this.moduleClassLoader;
}

The class loader that becomes the parent of all the modules

 public ModuleConfiguration getModuleConfig(String moduleName) 
{
        return (ModuleConfiguration) moduleConfigmap.get(moduleName);
}

 public HashMap getModules() 
{
        return allModules;
}

 public List getModulesForPolicyNamesapce(String namesapce) 
{
        return policySupportedModules.get(namesapce);
}

 public ArrayList getObserversList() 
{
        return observersList;
}

 public List getOutFaultFlowPhases() 
{
        return outFaultPhases;
}

 public List getOutFlowPhases() 
{
        return this.outPhases;
}

 public PhasesInfo getPhasesInfo() 
{
        return phasesinfo;
}

 public URL getRepository() 
{
        return axis2Repository;
}

 public AxisService getService(String name) throws AxisFault 
{
        AxisService axisService = (AxisService) allServices.get(name);
        if (axisService != null) {
            if (axisService.isActive()) {
                return axisService;
            } else {
                throw new AxisFault(Messages
                        .getMessage("serviceinactive", name));
            }
        } else {
            axisService = (AxisService) allEndpoints.get(name);
            if (axisService != null) {
                if (axisService.isActive()) {
                    return axisService;
                } else {
                    throw new AxisFault(Messages
                            .getMessage("serviceinactive", name));
                }
            }
        }
        return null;
}

Method getService.

 public ClassLoader getServiceClassLoader() 
{
        return this.serviceClassLoader;
}

 public AxisService getServiceForActivation(String serviceName) 
{
        AxisService axisService = null;
        axisService = (AxisService) allServices.get(serviceName);
        if (axisService != null) {
            return axisService;
        } else {
            axisService = (AxisService) allEndpoints.get(serviceName);
            return axisService;
        }
}

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.

 public AxisServiceGroup getServiceGroup(String serviceNameAndGroupString) 
{
        // return (AxisServiceGroup)
        // serviceGroups.get(serviceNameAndGroupString);
        return (AxisServiceGroup) getChild(serviceNameAndGroupString);
}

 public Iterator getServiceGroups() 
{
        // return serviceGroups.values().iterator();
        return (Iterator< AxisServiceGroup >) getChildren();
}

 public HashMap getServices() 
{
        HashMap< String, AxisService > hashMap = new HashMap< String, AxisService >(this.allServices.size());
        String key;
        for (Iterator< String > iter = this.allServices.keySet().iterator(); iter.hasNext();){
            key = iter.next();
            hashMap.put(key, this.allServices.get(key));
        }
        return hashMap;
}

 public ClassLoader getSystemClassLoader() 
{
        return this.systemClassLoader;
}

 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 = (TargetResolver) iter.next();
                    tr.resolveTarget(messageContext);
                }
            }
        };
}

getTargetResolverChain returns an instance of TargetResolver which iterates over the registered TargetResolvers, calling each one in turn when resolveTarget is called.

 public TransactionConfiguration getTransactionConfiguration() 
{
        return transactionConfiguration;
}

 public TransportInDescription getTransportIn(String name) 
{
        return (TransportInDescription) transportsIn.get(name);
}

 public TransportOutDescription getTransportOut(String name) 
{
        return (TransportOutDescription) transportsOut.get(name);
}

 public HashMap getTransportsIn() 
{
        return transportsIn;
}

 public HashMap getTransportsOut() 
{
        return transportsOut;
}

 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;
            }
        }
}

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

 public boolean isAssertionLocal(QName name) 
{
        return this.localPolicyAssertions.contains(name);
}

 public boolean isEngaged(QName qname) 
{
        return isEngaged(qname.getLocalPart());
}

This method needs to remain for a few Axis2 releases to support legacy apps still using it.

 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 boolean isStart() 
{
        return start;
}

 public  void notifyObservers(int event_type,
    AxisService service) 
{
        AxisEvent event = new AxisEvent(event_type);
        for (int i = 0; i <  observersList.size(); i++) {
            AxisObserver axisObserver = (AxisObserver) observersList.get(i);
            try {
                if (!service.isClientSide()) {
                    axisObserver.serviceUpdate(event, service);
                }
            } catch (Throwable e) {
                // No need to stop the system due to this, so log and ignore
                log.debug(e);
            }
        }
}

 public  void notifyObservers(int event_type,
    AxisModule moule) 
{
        AxisEvent event = new AxisEvent(event_type);
        for (int i = 0; i <  observersList.size(); i++) {
            AxisObserver axisObserver = (AxisObserver) observersList.get(i);
            try {
                axisObserver.moduleUpdate(event, moule);
            } catch (Throwable e) {
                // No need to stop the system due to this, so log and ignore
                log.debug(e);
            }
        }
}

 public  void notifyObservers(int event_type,
    AxisServiceGroup serviceGroup) 
{
        AxisEvent event = new AxisEvent(event_type);
        for (int i = 0; i <  observersList.size(); i++) {
            AxisObserver axisObserver = (AxisObserver) observersList.get(i);
            try {
                axisObserver.serviceGroupUpdate(event, serviceGroup);
            } catch (Throwable e) {
                // No need to stop the system due to this, so log and ignore
                log.debug(e);
            }
        }
}

 public  void onDisengage(AxisModule module) throws AxisFault 
{
        PhaseResolver phaseResolver = new PhaseResolver(this);
        phaseResolver.disengageModuleFromGlobalChains(module);
        Iterator< AxisServiceGroup > serviceGroups = getServiceGroups();
        while (serviceGroups.hasNext()) {
            AxisServiceGroup axisServiceGroup = (AxisServiceGroup) serviceGroups.next();
            axisServiceGroup.disengageModule(module);
        }
}

To dis-engage a module from the system. This will remove all the handlers belonging to this module from all the handler chains.

 public  void onEngage(AxisModule module,
    AxisDescription engager) throws AxisFault 
{
        Iterator< AxisServiceGroup > servicegroups = getServiceGroups();
        while (servicegroups.hasNext()) {
            AxisServiceGroup serviceGroup = (AxisServiceGroup) servicegroups.next();
            serviceGroup.engageModule(module, engager);
        }
}

 public  void registerLocalPolicyAssertions(AxisModule axisModule) 
{
        QName[] localPolicyAssertions = axisModule.getLocalPolicyAssertions();
        if (localPolicyAssertions == null) {
            return;
        }
        for (int i = 0; i <  localPolicyAssertions.length; i++) {
            addLocalPolicyAssertion(localPolicyAssertions[i]);
        }
}

 public  void registerModulePolicySupport(AxisModule axisModule) 
{
        String[] namespaces = axisModule.getSupportedPolicyNamespaces();
        if (namespaces == null) {
            return;
        }
        List< AxisModule > modulesList;
        for (int i = 0; i <  namespaces.length; i++) {
            modulesList = policySupportedModules.get(namespaces[i]);
            if (modulesList != null) {
                modulesList.add(axisModule);
            } else {
                modulesList = new ArrayList< AxisModule >();
                modulesList.add(axisModule);
                policySupportedModules.put(namespaces[i], modulesList);
            }
        }
}

 public  void removeFaultyService(String key) 
{
        Iterator< String > itr = faultyServices.keySet().iterator();
        while (itr.hasNext()) {
            String fullFileName = (String) itr.next();
            if (fullFileName.indexOf(key)  > 0) {
                faultyServices.remove(fullFileName);
                return;
            }
        }
}

 public  void removeLocalPolicyAssertion(QName name) 
{
        this.localPolicyAssertions.remove(name);
}

 public  void removeModule(String module) 
{
        allModules.remove(module);
        // TODO disengage has to be done here
}

To remove a given module from the system

 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

 public synchronized  void removeService(String name) throws AxisFault 
{
        AxisService service = (AxisService) allServices.remove(name);
        if (service != null) {
            AxisServiceGroup serviceGroup = service.getAxisServiceGroup();
            serviceGroup.removeService(name);
            log.debug(Messages.getMessage("serviceremoved", name));
        }
}

Method removeService.

 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 = (AxisService) services.next();
            allServices.remove(axisService.getName());
            if (!axisService.isClientSide()) {
                notifyObservers(AxisEvent.SERVICE_REMOVE, axisService);
            } else {
                isClientSide = true;
            }
            //removes the endpoints to this service
            String serviceName = axisService.getName();
            String key = null;
            for (Iterator< String > iter = axisService.getEndpoints().keySet().iterator(); iter.hasNext();){
                key = serviceName + "." + (String)iter.next();
                this.allEndpoints.remove(key);
            }
        }
        removeChild(serviceGroupName);
        if (!isClientSide) {
            notifyObservers(AxisEvent.SERVICE_REMOVE, axisServiceGroup);
        }
        return axisServiceGroup;
}

 public  void setClusterManager(ClusterManager clusterManager) 
{
        this.clusterManager = clusterManager;
}

 public  void setConfigurator(AxisConfigurator configurator) 
{
        this.configurator = configurator;
}

 public  void setGlobalOutPhase(List outPhases) 
{
        this.outPhases = outPhases;
}

 public  void setInFaultPhases(List list) 
{
        inFaultPhases = list;
}

 public  void setInPhasesUptoAndIncludingPostDispatch(List inPhasesUptoAndIncludingPostDispatch) 
{
        this.inPhasesUptoAndIncludingPostDispatch = inPhasesUptoAndIncludingPostDispatch;
}

 public  void setModuleClassLoader(ClassLoader classLoader) 
{
        this.moduleClassLoader = classLoader;
}

 public  void setOutFaultPhases(List 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 setStart(boolean start) 
{
        this.start = start;
}

 public  void setSystemClassLoader(ClassLoader classLoader) 
{
        this.systemClassLoader = classLoader;
}

 public  void setTransactionConfig(TransactionConfiguration transactionConfiguration) 
{
        this.transactionConfiguration = transactionConfiguration;
}

 public  void startService(String serviceName) throws AxisFault 
{
        AxisService service = (AxisService) allServices.get(serviceName);
        if (service == null) {
            throw new AxisFault(Messages.getMessage("servicenamenotvalid",
                                                    serviceName));
        }
        service.setActive(true);
        notifyObservers(AxisEvent.SERVICE_START, service);
}

 public  void stopService(String serviceName) throws AxisFault 
{
        AxisService service = (AxisService) allServices.get(serviceName);
        if (service == null) {
            throw new AxisFault(Messages.getMessage("servicenamenotvalid",
                                                    serviceName));
        }
        service.setActive(false);
        notifyObservers(AxisEvent.SERVICE_STOP, service);
}

 public  void validateSystemPredefinedPhases() throws DeploymentException 
{
        PhasesInfo phasesInfo = getPhasesInfo();
        setInPhasesUptoAndIncludingPostDispatch(phasesInfo.getGlobalInflow());
        setInFaultPhases(phasesInfo.getGlobalInFaultPhases());
        setGlobalOutPhase(phasesInfo.getGlobalOutPhaseList());
        setOutFaultPhases(phasesInfo.getOUT_FaultPhases());
}

Checks whether the system pre-defined phases for all the flows, have been changed. If they have been changed, throws a DeploymentException.