*  Copyright (c) 2008, 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.

*/

    private static final Log log = LogFactory.getLog(ServiceAdmin.class);

    private static final String SERVICE_MUST_CONTAIN_AT_LEAST_ONE_TRANSPORT =

            "Cannot remove transport binding. "

            + "<br/>A service must contain at least one transport binding!";

    private static final int DEFAULT_ITEMS_PER_PAGE = 10;

    public static final String DISABLE_TRY_IT_PARAM = "disableTryIt";

    public static final String DISABLE_DELETION_PARAM = "disableDeletion";

    private ServicePersistenceManager spm;

    public ServiceAdmin() {

        try {

            spm = new ServicePersistenceManager(getAxisConfig());

        } catch (AxisFault axisFault) {

            log.error("Error while initializing ServicePersistenceManager", axisFault);

        }

    }

    public ServiceAdmin(AxisConfiguration axisConfig) throws Exception {

        super(axisConfig);

        spm = new ServicePersistenceManager(axisConfig);

    }

    public void setConfigurationContext(ConfigurationContext configurationContext) {

        super.setConfigurationContext(configurationContext);

    }

    /**

     * This method add Policy to service at the Registry. Does not add the

     * policy to Axis2. To all Bindings available

     *

     * @param serviceName

     * @param policy

     * @param policyType

     * @throws Exception

     */

    public void addPoliciesToService(String serviceName, Policy policy, int policyType,

                                     String[] modulePaths) throws Exception {

        AxisService axisService = this.getAxisService(serviceName);

        // at registry

        Resource policyResource = getConfigSystemRegistry().newResource();

        policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE, String

                .valueOf(policyType));

        policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_UUID, policy.getId());

        // do a performance improvement

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        XMLStreamWriter writer = XMLOutputFactory.newInstance().createXMLStreamWriter(baos);

        policy.serialize(writer);

        writer.flush();

        policyResource.setContent(baos.toString());

        String servicePath = RegistryResources.SERVICE_GROUPS

                             + axisService.getAxisServiceGroup().getServiceGroupName()

                             + RegistryResources.SERVICES + axisService.getName();

        String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();

        getConfigSystemRegistry().put(policyResourcePath, policyResource);

        // at axis2

        Map endPointMap = axisService.getEndpoints();

        for (Object o : endPointMap.entrySet()) {

            Map.Entry entry = (Map.Entry) o;

            AxisEndpoint point = (AxisEndpoint) entry.getValue();

            AxisBinding binding = point.getBinding();

            binding.applyPolicy(policy);

        }

        // handle each module required

        try {

            boolean transactionStarted = Transaction.isStarted();

            if (!transactionStarted) {

                getConfigSystemRegistry().beginTransaction();

            }

            for (String path : modulePaths) {

                getConfigSystemRegistry().addAssociation(RegistryResources.Associations.REQUIRED_MODULES,

                                                         policyResourcePath, path);

                String[] values = path.split("/");

                String moduleName = values[values.length - 2];

                String moduleVersion = values[values.length - 1];

                this.engageModuleToService(serviceName, moduleName, moduleVersion);

            }

            if (!transactionStarted) {

                getConfigSystemRegistry().commitTransaction();

            }

        } catch (Exception e) {

            try {

                getConfigSystemRegistry().rollbackTransaction();

            } catch (RegistryException e1) {

                throw AxisFault.makeFault(e);

            }

            throw AxisFault.makeFault(e);

        }

    }

    public void removeServicePoliciesByNamespace(String serviceName, String namesapce)

            throws Exception {

        try {

            AxisService service = getAxisConfig().getServiceForActivation(serviceName);

            // at registry

            String servicePath = RegistryResources.SERVICE_GROUPS

                                 + service.getAxisServiceGroup().getServiceGroupName()

                                 + RegistryResources.SERVICES + serviceName;

            String policyResourcePath = servicePath + RegistryResources.POLICIES;

            Collection policies = (Collection) getConfigSystemRegistry().get(policyResourcePath);

            String[] children = policies.getChildren();

            List<String> removedModuleAssociations = new ArrayList<String>();

            for (String path : children) {

                Resource resource = getConfigSystemRegistry().get(path);

                String value = (String) resource.getContent();

                XMLStreamReader parser = XMLInputFactory.newInstance().createXMLStreamReader(

                        new ByteArrayInputStream(value.getBytes()));

                StAXOMBuilder builder = new StAXOMBuilder(parser);

                OMElement element = builder.getDocumentElement();

                Policy policy = PolicyEngine.getPolicy(element);

                removeAssertionsByNamespace(policy, namesapce);

                int iValue = policy.getAssertions().size();

                if (iValue == 1) { // TODO :: Check here

                    Association[] values = getConfigSystemRegistry().getAssociations(path,

                                                                                     RegistryResources.Associations.REQUIRED_MODULES);

                    for (Association association : values) {

                        removedModuleAssociations.add(association.getDestinationPath());

                    }

                    getConfigSystemRegistry().delete(path);

                }

            }

            // at axis2

            Map endPointMap = service.getEndpoints();

            for (Object o : endPointMap.entrySet()) {

                Map.Entry entry = (Map.Entry) o;

                AxisEndpoint point = (AxisEndpoint) entry.getValue();

                AxisBinding binding = point.getBinding();

                Policy policy = binding.getEffectivePolicy();

                removeAssertionsByNamespace(policy, namesapce);

            }

            // handle module removals

            disengageUnusedModuleFromAxisService(serviceName, removedModuleAssociations);

        } catch (Exception e) {

            throw new Exception("errorRemovingServicePolicies");

        }

    }

    private void disengageUnusedModuleFromAxisService(String serviceName,

                                                      List<String> checkList) throws Exception {

        AxisService axisService = this.getAxisService(serviceName);

        String serviceResourcePath = RegistryResources.SERVICE_GROUPS

                                     + axisService.getAxisServiceGroup().getServiceGroupName()

                                     + RegistryResources.SERVICES + axisService.getName();

        String policyResourcePath = serviceResourcePath + RegistryResources.POLICIES;

        boolean doDisengage = true;

        for (String moduleResourcePath : checkList) {

            // chec required by other policyes

            Collection policies = (Collection) getConfigSystemRegistry().get(policyResourcePath);

            String[] children = policies.getChildren();

            for (String policyPath : children) {

                Association[] policyAss = getConfigSystemRegistry().getAssociations(policyPath,

                                                                                    RegistryResources.Associations.REQUIRED_MODULES);

                for (Association moduleAss : policyAss) {

                    if (moduleAss.getDestinationPath().equals(moduleResourcePath)) {

                        doDisengage = false;

                        break;

                    }

                }

                if (!doDisengage) {

                    break;

                }

            }

            // check required by service level engaged modules

            if (doDisengage) {

                Association[] serviceAss = getConfigSystemRegistry().getAssociations(serviceResourcePath,

                                                                                     RegistryResources.Associations.ENGAGED_MODULES);

                for (Association moduleAss : serviceAss) {

                    if (moduleAss.getDestinationPath().equals(moduleResourcePath)) {

                        doDisengage = false;

                        break;

                    }

                }

            }

            if (doDisengage) {

                String[] values = moduleResourcePath.split("/");

                String moduleName = values[values.length - 2];

                String moduleVersion = values[values.length - 1];

                // disengage at Axis

                axisService.disengageModule(axisService.getAxisConfiguration().getModule(

                        moduleName, moduleVersion));

            }

        }

    }

    public void engageModuleToService(String serviceName, String moduleName, String version)

            throws Exception {

        AxisService axisService = this.getAxisService(serviceName);

        String serviceResourcePath = RegistryResources.SERVICE_GROUPS

                                     + axisService.getAxisServiceGroup().getServiceGroupName()

                                     + RegistryResources.SERVICES + axisService.getName();

        // engage at registry

        String moduleResourcePath = RegistryResources.MODULES + moduleName + "/" + version;

        getConfigSystemRegistry().addAssociation(RegistryResources.Associations.ENGAGED_MODULES,

                                                 serviceResourcePath, moduleResourcePath);

        // engage at axis2

        AxisModule module = axisService.getAxisConfiguration().getModule(moduleName);

        axisService.disengageModule(module);

        axisService.engageModule(module);

    }

    private void removeAssertionsByNamespace(Policy policy, String namespace) {

        List lst = policy.getAssertions();

        Iterator itePolices = lst.iterator();

        while (itePolices.hasNext()) {

            PolicyComponent comp = (PolicyComponent) itePolices.next();

            if (comp instanceof Assertion) {

                Assertion assertion = (Assertion) comp;

                if (assertion.getName().getNamespaceURI().equals(namespace)) {

                    itePolices.remove();

                }

            }

        }

    }

    /**

     * Return service group details for a given service group

     *

     * @param serviceGroupName

     * @return ServiceGroupMetaData

     * @throws org.apache.axis2.AxisFault

     * TODO: Do we need this in ServiceAdmin?

     */

    public ServiceGroupMetaData listServiceGroup(String serviceGroupName) throws AxisFault {

        ServiceGroupMetaData sgmd = new ServiceGroupMetaData();

        AxisServiceGroup serviceGroup = getAxisConfig().getServiceGroup(serviceGroupName);

        sgmd.setServiceGroupName(serviceGroup.getServiceGroupName());

        Parameter parameter = serviceGroup.getParameter(Constants.Configuration.ENABLE_MTOM);

        if (parameter != null) {

            sgmd.setMtomStatus((String) parameter.getValue());

        }

        return sgmd;

    }

    /**

     * List all the available services

     *

     * @param serviceTypeFilter Service type of services to be returned

     * @param serviceSearchString Service name or part of a service name

     * @param pageNumber The number of the page to be retrieved

     * @return The service metadata

     * @throws org.apache.axis2.AxisFault If an error occurs while retrieving services

     */

    public ServiceMetaDataWrapper listServices(String serviceTypeFilter,

                                               String serviceSearchString,

                                               int pageNumber) throws AxisFault {

        if (serviceTypeFilter == null) {

            serviceTypeFilter = "ALL";

        }

        if (pageNumber < 0 || pageNumber == Integer.MAX_VALUE) {

            pageNumber = 0;

        }

        List<ServiceMetaData> serviceList = new ArrayList<ServiceMetaData>();

        TreeSet<String> serviceTypes = new TreeSet<String>();

        serviceTypes.add("axis2");

        HashMap<String,AxisService> axisServices = getAxisConfig().getServices();

        for (AxisService axisService: axisServices.values()) {

            // Filtering the admin services

            if (SystemFilter.isAdminService(axisService) || SystemFilter.isHiddenService(axisService)) {

                continue;  // No advancement of currentIndex

            }

            String serviceType = "axis2";

            Parameter serviceTypeParam;

            serviceTypeParam = axisService.getParameter(ServerConstants.SERVICE_TYPE);

            if (serviceTypeParam != null) {

                serviceType = (String) serviceTypeParam.getValue();

                serviceTypes.add(serviceType);

            }

            // Filter out client side services

            if (axisService.isClientSide()) {

                continue;

            }

            // Filter out services based on service type

            if (!serviceTypeFilter.equals("ALL") && !serviceTypeFilter.equals(serviceType)) {

                continue;

            }

            // Filter out services based on serviceSearchString

            if (serviceSearchString != null &&

                serviceSearchString.trim().length() > 0 &&

                axisService.getName().toLowerCase().

                        indexOf(serviceSearchString.toLowerCase()) == -1) {

                continue;

            }

            ServiceMetaData service = new ServiceMetaData();

            String serviceName = axisService.getName();

            service.setName(serviceName);

            // extract service type

            serviceTypeParam = axisService.getParameter(ServerConstants.SERVICE_TYPE);

            if (serviceTypeParam != null) {

                serviceType = (String) serviceTypeParam.getValue();

            }

            service.setServiceType(serviceType);

            AxisConfiguration axisConfiguration = getAxisConfig();

            service.setWsdlURLs(Utils.getWsdlInformation(serviceName, axisConfiguration));

            service.setTryitURL(Utils.getTryitURL(serviceName, getConfigContext()));

            service.setActive(axisService.isActive());

            Parameter parameter = axisService.getParameter(ServiceAdmin.DISABLE_TRY_IT_PARAM);

            if (parameter != null && Boolean.TRUE.toString().equalsIgnoreCase((String) parameter.getValue())) {

                service.setDisableTryit(true);

            }

            parameter = axisService.getParameter(ServiceAdmin.DISABLE_DELETION_PARAM);

            if (parameter != null && Boolean.TRUE.toString().equalsIgnoreCase((String) parameter.getValue())) {

                service.setDisableDeletion(true);

            }

            service.setServiceGroupName(axisService.getAxisServiceGroup().getServiceGroupName());

            SecurityScenarioData securityScenario = getSecurityScenario(serviceName);

            if (securityScenario != null) {

                service.setSecurityScenarioId(securityScenario.getScenarioId());

            }

            serviceList.add(service);

        }

        ServiceMetaDataWrapper wrapper;

        if (serviceList.size() > 0) {

            Collections.sort(serviceList, new Comparator<ServiceMetaData>() {

                public int compare(ServiceMetaData arg0, ServiceMetaData arg1) {

                    return arg0.getName().compareToIgnoreCase(arg1.getName());

                }

            });

        }

        wrapper = new ServiceMetaDataWrapper();

        wrapper.setNumberOfCorrectServiceGroups(getNumberOfServiceGroups());

        wrapper.setNumberOfFaultyServiceGroups(getNumberOfFaultyServices());

        wrapper.setServiceTypes(serviceTypes.toArray(new String[serviceTypes.size()]));

        wrapper.setNumberOfActiveServices(getNumberOfActiveServices());

        DataPaginator.doPaging(pageNumber, serviceList, wrapper);

        return wrapper;

    }

   public int getNumberOfServiceGroups(){

       int numOfserviceGroups = 0;

       for(Iterator<AxisServiceGroup> serviceGroups = getAxisConfig().getServiceGroups();

           serviceGroups.hasNext();){

           AxisServiceGroup serviceGroup = serviceGroups.next();

           if (!SystemFilter.isFilteredOutService(serviceGroup)) {

               if (!serviceGroup.getServices().hasNext() ||

                   serviceGroup.getServices().next().isClientSide()) {

                   continue; // No advancement of currentIndex

               }

               numOfserviceGroups++;

           }

       }

       return numOfserviceGroups;

   }

   public int getNumberOfActiveServices() {

       int activeServices = 0;

       Map<String, AxisService> services = getAxisConfig().getServices();

       for (AxisService service : services.values()) {

           if (!SystemFilter.isFilteredOutService((AxisServiceGroup) service.getParent()) &&

               service.isActive()) {

               activeServices++;

           }

       }

       return activeServices;

    }

    public int getNumberOfInactiveServices() throws Exception {

        int inactiveServices = 0;

        Map<String, AxisService> services = getAxisConfig().getServices();

        for (AxisService service : services.values()) {

            if (!SystemFilter.isFilteredOutService((AxisServiceGroup) service.getParent()) &&

                !service.isActive()) {

                inactiveServices++;

            }

        }

        return inactiveServices;

    }

    public int getNumberOfFaultyServices() {

        return getAxisConfig().getFaultyServices().size();

    }

    public FaultyServicesWrapper getFaultyServiceArchives(int pageNumber) throws AxisFault {

        AxisConfiguration ac = getAxisConfig();

        String repository = ac.getRepository().getPath();

        Hashtable<String, String> faultyServices = ac.getFaultyServices();

        List<FaultyService> fsList = new ArrayList<FaultyService>();

        for (Map.Entry<String, String> entry : faultyServices.entrySet()) {

            String artifactPath = entry.getKey();

            String serviceName = artifactPath;

            String fault = entry.getValue();

            FaultyService fs = new FaultyService();

            if (File.separatorChar == '\\') {

                serviceName = serviceName.replace('\\', '/');

                repository = repository.replace('\\', '/');

                if (repository.startsWith("/")) {

                    repository = repository.substring(1);

                }

            }

            if (serviceName.endsWith("/")) {

                serviceName = serviceName.substring(0, serviceName.length() - 1);

            }

            if (repository.endsWith("/")) {

                repository = repository.substring(0, repository.length() - 1);

            }

            if (serviceName.startsWith(repository)) {

                serviceName = serviceName.substring(repository.length() + 1);

                serviceName = serviceName.substring(serviceName.indexOf('/') + 1);

            }

            int slashIndex = serviceName.lastIndexOf('/');

            int dotIndex = serviceName.lastIndexOf('.');

            if (dotIndex != -1 && (dotIndex > slashIndex)) {

                serviceName = serviceName.substring(0, dotIndex);

            }

            //Retrieving faulty services registered via CarbonConfigurationContext

            AxisService axisService = CarbonUtils.getFaultyService(artifactPath,

                    this.getConfigContext());

            fs.setServiceName(serviceName);

            fs.setFault(fault);

            if (File.separatorChar == '\\') {

                artifactPath = artifactPath.replace('\\', '/');

            }

            if (axisService != null) {

                fs.setArtifact(artifactPath.replace(repository, ""));

                fs.setServiceType(getServiceType(axisService));

                fsList.add(fs);

                continue;

            }

            // sometimes we get the real serviceName. Ex: proxy services. In that case, there

            // might be an AxisService object..

            axisService = ac.getService(serviceName);

            if (artifactPath.startsWith(repository)) {

                artifactPath = artifactPath.replace(repository, "");

                fs.setArtifact(artifactPath);

            }

            fs.setServiceName(serviceName);

            fs.setFault(fault);

            if (axisService != null) {

                fs.setServiceType(getServiceType(axisService));

            }

            fsList.add(fs);

        }

        FaultyServicesWrapper wrapper = null;

        if (fsList.size() > 0) {

            Collections.sort(fsList, new Comparator<FaultyService>() {

                public int compare(FaultyService arg0, FaultyService arg1) {

                    return arg0.getServiceName().compareToIgnoreCase(arg1.getServiceName());

                }

            });

            // Pagination

            wrapper = new FaultyServicesWrapper();

            wrapper.setNumberOfFaultyServiceGroups(getNumberOfFaultyServices());

            DataPaginator.doPaging(pageNumber, fsList, wrapper);

        }

        return wrapper;

    }

    public boolean deleteFaultyServiceGroup(String archiveName) throws AxisFault {

        String repository = getAxisConfig().getRepository().getPath();

        if (repository.endsWith("/")) {

            repository = repository.substring(0, repository.length() - 1);

        }

        if (File.separatorChar == '\\') {

            archiveName = archiveName.replace('/', '\\');

            if(repository.startsWith("/")){

                repository = repository.substring(1);

            }

            repository = repository.replace('/', '\\');

        }

        if (archiveName.indexOf(repository) != 0) {

            archiveName = repository + archiveName;

        }

        if (log.isDebugEnabled()) {

            log.debug("Deleting faulty service archive " + archiveName);

        }

        boolean isDeleted = false;

        if (archiveName != null && archiveName.trim().length() != 0) {

            File file = new File(archiveName);

            if (file.exists()) {

                if (!((file.isDirectory() && FileManipulator.deleteDir(file)) || file

                        .delete())) {

                    throw new AxisFault("Faulty service archive deletion failed. "

                                        + "Due to a JVM issue on MS-Windows, "

                                        + "service archive files cannot be deleted. "

                                        + "Please stop the server and manually delete this file.");

                } else {

                    isDeleted = true;

                    getAxisConfig().getFaultyServices().remove(archiveName);

                }

            }

        }

        return isDeleted;

    }

    public void deleteAllNonAdminServiceGroups() throws AxisFault {

        for (Iterator iter = getAxisConfig().getServiceGroups(); iter.hasNext();) {

            AxisServiceGroup asGroup = (AxisServiceGroup) iter.next();

            if (!SystemFilter.isFilteredOutService(asGroup)) {

                deleteServiceGroup(asGroup.getServiceGroupName());

            }

        }

    }

    public void deleteAllFaultyServiceGroups() throws AxisFault {

        for (Iterator iter = getAxisConfig().getFaultyServices().values().iterator();

             iter.hasNext();) {

            String fileName = (String) iter.next();

            deleteFaultyServiceGroup(fileName);

        }

    }

    public void deleteServiceGroups(String[] serviceGroups) throws AxisFault {

        for (String serviceGroup : serviceGroups) {

            deleteServiceGroup(serviceGroup);

        }

    }

    public void deleteFaultyServiceGroups(String[] fileNames) throws AxisFault {

        for (String fileName : fileNames) {

            deleteFaultyServiceGroup(fileName);

        }

    }

    private void deleteServiceGroup(String serviceGroupName) throws AxisFault {

        AxisConfiguration axisConfig = getAxisConfig();

        AxisServiceGroup asGroup = axisConfig.getServiceGroup(serviceGroupName);

        if (asGroup == null) {

            throw new AxisFault("Invalid service group name " + serviceGroupName);

        }

        if (SystemFilter.isFilteredOutService(asGroup)) {

            String msg = "Cannot delete admin service group " + serviceGroupName;

            log.error(msg);

            throw new AxisFault(msg);

        }

        String fileName = null;

        for (Iterator serviceIter = asGroup.getServices(); serviceIter.hasNext();) {

            AxisService axisService = (AxisService) serviceIter.next();

            URL fn = axisService.getFileName();

            if (fn != null) {

                fileName = fn.getPath();

            }

            // removing the service from axis configuration

            axisConfig.removeService(axisService.getName());

        }

        // remove the service group from axis config and config context

        AxisServiceGroup serviceGroup = axisConfig.removeServiceGroup(asGroup.getServiceGroupName());

        if (serviceGroup != null) {

            getConfigContext().removeServiceGroupContext(serviceGroup);

      log.info(Messages.getMessage(DeploymentErrorMsgs.SERVICE_REMOVED,

                    fileName != null ? fileName : serviceGroupName));

        } else {

            axisConfig.removeFaultyService(fileName);

        }

        /*

        TODO This code does not work

        Object bundleIdObject = asGroup.getParameterValue(BUNDLE_ID);

        if (bundleIdObject != null) {

            Bundle bundle = (Bundle) bundleIdObject;

            try {

                bundle.stop();

                bundle.uninstall();

                return true;

            } catch (BundleException e) {

                throw new AxisFault("Bundle cannot be stoped and uninstall", e);

            }

        }*/

        // We cannot delete items from a URL repo

        // TODO: Do we need to throw an exception if we try to remove a service in a URL repo

        /*String axis2Repo = ServerConfiguration.getInstance().getFirstProperty(

                ServerConfiguration.AXIS2_CONFIG_REPO_LOCATION);

        if (CarbonUtils.isURL(axis2Repo)) {

            throw new AxisFault("You are not permitted to remove the " + serviceGroupName

                    + " service group from the URL repository " + axis2Repo);

        }*/

        if ((fileName != null) && (fileName.trim().length() != 0)) {

            if (log.isDebugEnabled()) {

                log.debug("Deleting service file " + fileName);

            }

            File file = new File(fileName);

            if (file.exists()) {

                if (!((file.isDirectory() && FileManipulator.deleteDir(file)) || file

                        .delete())) {

                    log.error("Service file/directory deletion failed : " + fileName);

                }

            }

            // now check whether this is a hierarchical service. if so, there should be a "/"

            // in service group name

            if (serviceGroupName.lastIndexOf(File.separator) != -1) {

                // if this is a hierarchical service, we have to remove the empty dirs on path

                String firstHierarchicalDir = serviceGroupName.substring(0,

                        serviceGroupName.indexOf(File.separator));

                Utils.deleteEmptyDirsOnPath(fileName, firstHierarchicalDir);

            }

        }

    }

    public ServiceMetaData getServiceData(String serviceName) throws AxisFault {

        AxisService service = getAxisConfig().getServiceForActivation(serviceName);

        String serviceType = getServiceType(service);

        List<String> ops = new ArrayList<String>();

        for (Iterator opIter = service.getOperations(); opIter.hasNext();) {

            AxisOperation axisOperation = (AxisOperation) opIter.next();

            if (axisOperation.getName() != null) {

                ops.add(axisOperation.getName().getLocalPart());

            }

        }

        ServiceMetaData serviceMetaData = new ServiceMetaData();

        serviceMetaData.setOperations(ops.toArray(new String[ops.size()]));

        serviceMetaData.setName(serviceName);

        serviceMetaData.setServiceId(serviceName);

        serviceMetaData.setServiceVersion("");

        serviceMetaData.setActive(service.isActive());

        String[] eprs = getServiceEPRs(serviceName);

        serviceMetaData.setEprs(eprs);

        serviceMetaData.setServiceType(serviceType);

        AxisConfiguration axisConfiguration = getAxisConfig();

        serviceMetaData.setWsdlURLs(Utils.getWsdlInformation(serviceName, axisConfiguration));

        serviceMetaData.setTryitURL(Utils.getTryitURL(serviceName, getConfigContext()));

        AxisServiceGroup serviceGroup = (AxisServiceGroup) service.getParent();

        serviceMetaData.setFoundWebResources(serviceGroup.isFoundWebResources());

        serviceMetaData.setScope(service.getScope());

        serviceMetaData.setServiceGroupName(serviceGroup.getServiceGroupName());

        SecurityScenarioData securityScenario = getSecurityScenario(serviceName);

        if (securityScenario != null) {

            serviceMetaData.setSecurityScenarioId(securityScenario.getScenarioId());

        }

        if (service.getDocumentation() != null) {

            serviceMetaData.setDescription(service.getDocumentation());

        } else {

            serviceMetaData.setDescription("No service description found");

        }

        Parameter parameter = service.getParameter(Constants.Configuration.ENABLE_MTOM);

        if (parameter != null) {

            serviceMetaData.setMtomStatus((String) parameter.getValue());

        } else {

            serviceMetaData.setMtomStatus("false");

        }

        parameter = service.getParameter(DISABLE_TRY_IT_PARAM);

        if (parameter != null && Boolean.TRUE.toString().equalsIgnoreCase((String) parameter.getValue())) {

            serviceMetaData.setDisableTryit(true);

        }

        return serviceMetaData;

    }

    private SecurityScenarioData getSecurityScenario(String serviceName) throws AxisFault {

        try {

            return new SecurityConfigAdmin(getUserRealm(),

                                           getConfigSystemRegistry(),

                                           getAxisConfig()).getCurrentScenario(serviceName);

        } catch (SecurityConfigException e) {

            throw new AxisFault("Cannot retrieve security scenario for service", e);

        }

    }

    private String getServiceType(AxisService service) {

        Parameter serviceTypeParam = service.getParameter(ServerConstants.SERVICE_TYPE);

        String serviceType;

        if (serviceTypeParam != null) {

            serviceType = (String) serviceTypeParam.getValue();

        } else {

            serviceType = "axis2";

        }

        return serviceType;

    }

    private String[] getServiceEPRs(String serviceName) throws AxisFault {

        getAxisService(serviceName).setEPRs(null);

        return getAxisService(serviceName).getEPRs();

    }

    public void changeServiceState(String serviceName, boolean isActive) throws AxisFault {

        if (log.isDebugEnabled()) {

            log.debug("Changing service Active state to " + isActive + " for service " + serviceName);

        }

        AxisService service = getAxisService(serviceName);

        if (service == null) {

            String msg = "Service " + serviceName + " is not available";

            log.error(msg);

            throw new AxisFault(msg);

        }

        if (isActive) {

            getAxisConfig().startService(serviceName);

        } else {

            getAxisConfig().stopService(serviceName);

        }

        // Persist the service state

        try {

            spm.setServiceProperty(service,

                                   RegistryResources.ServiceProperties.ACTIVE, String.valueOf(isActive));

        } catch (Exception e) {

            String msg = "Cannot persist ACTIVE service parameter";

            log.error(msg, e);

            throw new AxisFault(msg, e);