package org.wso2.carbon.endpoint.service; import org.apache.axiom.om.OMAbstractFactory; import org.apache.axiom.om.OMElement; import org.apache.axiom.om.OMFactory; import org.apache.axiom.om.util.AXIOMUtil; import org.apache.axis2.util.XMLPrettyPrinter; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.synapse.SynapseException; import org.apache.synapse.config.Entry; import org.apache.synapse.config.SynapseConfiguration; import org.apache.synapse.config.xml.SynapseXMLConfigurationFactory; import org.apache.synapse.config.xml.XMLConfigConstants; import org.apache.synapse.config.xml.endpoints.EndpointFactory; import org.apache.synapse.config.xml.endpoints.EndpointSerializer; import org.apache.synapse.endpoints.AbstractEndpoint; import org.apache.synapse.endpoints.Endpoint; import org.apache.synapse.endpoints.EndpointContext; import org.apache.synapse.endpoints.EndpointDefinition; import org.apache.synapse.registry.Registry; import org.wso2.carbon.endpoint.EndpointAdminException; import org.wso2.carbon.endpoint.util.ConfigHolder; import org.wso2.carbon.mediation.dependency.mgt.ConfigurationObject; import org.wso2.carbon.mediation.dependency.mgt.services.DependencyManagementService; import org.wso2.carbon.mediation.initializer.AbstractServiceBusAdmin; import org.wso2.carbon.mediation.initializer.ServiceBusConstants; import org.wso2.carbon.mediation.initializer.ServiceBusUtils; import org.wso2.carbon.mediation.initializer.persistence.MediationPersistenceManager; import org.wso2.carbon.registry.core.Resource; import org.wso2.carbon.registry.core.exceptions.RegistryException; import javax.xml.namespace.QName; import javax.xml.stream.XMLStreamException; import java.io.ByteArrayOutputStream; import java.lang.String; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.locks.Lock; /** * Copyright (c) 2012, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * <p/> * 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 * <p/> * http://www.apache.org/licenses/LICENSE-2.0 * <p/> * 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. */ public class EndpointAdmin extends AbstractServiceBusAdmin { private static final Log log = LogFactory.getLog(EndpointAdmin.class); public static final String WSO2_ENDPOINT_MEDIA_TYPE = "application/vnd.wso2.esb.endpoint"; /** * Set Endpoint status to Active * * @param endpointName name of the endpoint * @throws EndpointAdminException in case of an error */ public void switchOn(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); Endpoint ep = getSynapseConfiguration().getEndpoint(endpointName); ep.getContext().switchOn(); /** * Persist endpoint if it is not deployed via an artifact container */ if (ep.getArtifactContainerName() == null) { persistEndpoint(ep); if (log.isDebugEnabled()) { log.debug("Endpoint " + ep.getName() + " switched on"); } } } catch (SynapseException ex) { handleFault("Error switch on endpoint : " + endpointName, ex); } finally { lock.unlock(); } } /** * Switch off Endpoint * * @param endpointName name of the endpoint * @throws EndpointAdminException in case of an error */ public void switchOff(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); Endpoint ep = getSynapseConfiguration().getEndpoint(endpointName); ep.getContext().switchOff(); /** * Persist endpoint if it is not deployed via an artifact container */ if (ep.getArtifactContainerName() == null) { persistEndpoint(ep); if (log.isDebugEnabled()) { log.debug("Endpoint " + ep.getName() + " switched off"); } } } catch (SynapseException ex) { handleFault("Error switch off endpoint : " + endpointName, ex); } finally { lock.unlock(); } } /** * Add an Endpoint described by the given configuration * * @param epString - configuration representing the endpoint that needs * to be added * @return true if the endpoint was successfully added and false otherwise * @throws EndpointAdminException if the element is not an endpoint or if an endpoint * with the same name exists */ public boolean addEndpoint(String epString) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); OMElement endpointElement; try { endpointElement = AXIOMUtil.stringToOM(epString); } catch (XMLStreamException e) { return false; } if (endpointElement.getQName().getLocalPart() .equals(XMLConfigConstants.ENDPOINT_ELT.getLocalPart())) { String endpointName = endpointElement.getAttributeValue(new QName("name")); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); log.debug("Adding endpoint : " + endpointName + " to the configuration"); if (getSynapseConfiguration().getLocalRegistry() .get(endpointName) != null) { handleFault("The name " + endpointName + " is already used within the configuration", null); } else { SynapseConfiguration config = getSynapseConfiguration(); if (config.getEndpoint(endpointName) != null) { handleFault("A endpoint with name " + endpointName + " is already there.", null); } SynapseXMLConfigurationFactory.defineEndpoint( config, endpointElement, config.getProperties()); Endpoint endpoint = config.getEndpoint(endpointName); if (endpoint == null) { handleFault("Unable to create endpoint", null); } if (endpoint instanceof AbstractEndpoint) { endpoint.setFileName( ServiceBusUtils.generateFileName(endpoint.getName())); } endpoint.init(getSynapseEnvironment()); persistEndpoint(endpoint); } if (log.isDebugEnabled()) { log.debug("Added endpoint : " + endpointName + " to the configuration"); } return true; } else { handleFault("Unable to create endpoint. Invalid XML definition", null); } } catch (SynapseException syne) { handleFault("Unable to add Endpoint ", syne); } finally { lock.unlock(); } return false; } /** * Deletes the endpoint from the SynapseConfiguration * * @param endpointName - name of the endpoint to be deleted * @return true if the endpoint was successfully deleted and false otherwise * @throws EndpointAdminException if the proxy service name given is not existent in the * synapse configuration */ public boolean deleteEndpoint(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); if (log.isDebugEnabled()) { log.debug("Deleting endpoint : " + endpointName + " from the configuration"); } SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Endpoint endpoint = synapseConfiguration.getDefinedEndpoints().get(endpointName); synapseConfiguration.removeEndpoint(endpointName); MediationPersistenceManager pm = getMediationPersistenceManager(); String fileName = null; if (endpoint instanceof AbstractEndpoint) { fileName = endpoint.getFileName(); } pm.deleteItem(endpointName, fileName, ServiceBusConstants.ITEM_TYPE_ENDPOINT); if (log.isDebugEnabled()) { log.debug("Endpoint : " + endpointName + " removed from the configuration"); } } finally { lock.unlock(); } return true; } /** * Delete selected endpoints * @param endpointNames * @throws EndpointAdminException */ public void deleteSelectedEndpoint(String [] endpointNames) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); for(String endpointName : endpointNames){ assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Endpoint endpoint = synapseConfiguration.getDefinedEndpoints().get(endpointName); /** * Check whether the endpoint deployed via an artifact container, before * deleting the endpoint */ if (endpoint.getArtifactContainerName() == null) { if (log.isDebugEnabled()) { log.debug("Deleting endpoint : " + endpointName + " from the configuration"); } synapseConfiguration.removeEndpoint(endpointName); MediationPersistenceManager pm = getMediationPersistenceManager(); String fileName = null; if (endpoint instanceof AbstractEndpoint) { fileName = endpoint.getFileName(); } pm.deleteItem(endpointName, fileName, ServiceBusConstants.ITEM_TYPE_ENDPOINT); if (log.isDebugEnabled()) { log.debug("Endpoint : " + endpointName + " removed from the configuration"); } } } } finally { lock.unlock(); } } /** * Delete * @throws EndpointAdminException */ public void deleteAllEndpointGroups() throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Map<String, Endpoint> namedEndpointMap = synapseConfiguration.getDefinedEndpoints(); Collection<String> namedEndpointCollection = namedEndpointMap.keySet(); if (namedEndpointCollection.size()>0) { for (String endpointName : namedEndpointCollection) { assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); Endpoint endpoint = synapseConfiguration.getDefinedEndpoints().get(endpointName); /** * Check whether the endpoint deployed via an artifact container, before * deleting the endpoint */ if (endpoint.getArtifactContainerName() == null) { if (log.isDebugEnabled()) { log.debug("Deleting endpoint : " + endpointName + " from the configuration"); } synapseConfiguration.removeEndpoint(endpointName); MediationPersistenceManager pm = getMediationPersistenceManager(); String fileName = null; if (endpoint instanceof AbstractEndpoint) { fileName = endpoint.getFileName(); } pm.deleteItem(endpointName, fileName, ServiceBusConstants.ITEM_TYPE_ENDPOINT); if (log.isDebugEnabled()) { log.debug("Endpoint : " + endpointName + " removed from the configuration"); } } } } } finally { lock.unlock(); } } /** * Gets the endpoint element as a string * * @param endpointName - name of the endpoint * @return String representing the endpoint with the given endpoint name * @throws Exception in case of an error */ public String getEndpointConfiguration(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); if (synapseConfiguration.getEndpoint(endpointName) != null) { OMElement ele = EndpointSerializer.getElementFromEndpoint( synapseConfiguration.getEndpoint(endpointName)); return ele.toString(); } else { handleFault("The endpoint named " + endpointName + " does not exist", null); } } finally { lock.unlock(); } return null; } /** * Get all endpoint configurations from the synapse configuration * * @return a list of all the endpoints * @throws EndpointAdminException in case of an error */ public String[] getEndpoints() throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Map<String, Endpoint> namedEndpointMap = synapseConfiguration.getDefinedEndpoints(); Collection<Endpoint> namedEndpointCollection = namedEndpointMap.values(); List<String> epList = new ArrayList<String>(); for (Endpoint ep : namedEndpointCollection) { OMElement ele = EndpointSerializer.getElementFromEndpoint(ep); epList.add(ele.toString()); } return epList.toArray(new String[epList.size()]); } finally { lock.unlock(); } } /** * Get Metadata of all Endpoints of Synapse configuration * * @return EndpointMetaData */ public EndpointMetaData[] getEndpointsData() { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Map<String, Endpoint> namedEndpointMap = synapseConfiguration.getDefinedEndpoints(); Collection<Endpoint> namedEndpointCollection = namedEndpointMap.values(); List<Endpoint> epList = new ArrayList<Endpoint>(); for (Endpoint ep : namedEndpointCollection) { epList.add(ep); } Collections.sort(epList, new Comparator<Endpoint>() { public int compare(Endpoint o1, Endpoint o2) { return (o1).getName().compareToIgnoreCase((o2).getName()); } }); List<EndpointMetaData> metaDatas = new ArrayList<EndpointMetaData>(); for (Endpoint ep : epList) { EndpointMetaData data = new EndpointMetaData(); data.setName(ep.getName()); data.setDescription(ep.getDescription()); if (ep.getArtifactContainerName() != null) { data.setArtifactContainerName(ep.getArtifactContainerName()); } if (ep.getIsEdited()) { data.setIsEdited(true); } // Statistics EndpointDefinition def = ((AbstractEndpoint) ep).getDefinition(); if (null != def) { if (def.isStatisticsEnable()) { data.setEnableStatistics(true); } else { data.setEnableStatistics(false); } } if (ep.getContext().isState(EndpointContext.ST_ACTIVE)) { data.setSwitchOn(true); } else { data.setSwitchOn(false); } data.setEndpointString(EndpointSerializer.getElementFromEndpoint(ep).toString()); metaDatas.add(data); } return metaDatas.toArray(new EndpointMetaData[metaDatas.size()]); } finally { lock.unlock(); } } /** * Enable statistics collection for the specified endpoint * * @param endpointName name of the endpoint * @throws EndpointAdminException in case of an error */ public void enableStatistics(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); Endpoint ep = getSynapseConfiguration().getEndpoint(endpointName); ((AbstractEndpoint) ep).getDefinition().enableStatistics(); /** * Persist endpoint only if it is not deployed via an artifact container */ if (ep.getArtifactContainerName() == null) { persistEndpoint(ep); } if (log.isDebugEnabled()) { log.debug("Statistics enabled on endpoint : " + endpointName); } } catch (SynapseException syne) { handleFault("Error enabling statistics for the endpoint : " + endpointName, syne); } finally { lock.unlock(); } } /** * Stop collecting statistics for a specified endpoint * * @param endpointName name of the endpoint * @throws EndpointAdminException on error */ public void disableStatistics(String endpointName) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); Endpoint ep = getSynapseConfiguration().getEndpoint(endpointName); ((AbstractEndpoint) ep).getDefinition().disableStatistics(); /** * Persist endpoint only if it is not deployed via an artifact container */ if (ep.getArtifactContainerName() == null) { persistEndpoint(ep); } if (log.isDebugEnabled()) { log.debug("Statistics disabled on endpoint : " + endpointName); } } catch (SynapseException syne) { handleFault("Error disabling statistics for the endpoint : " + endpointName, syne); } finally { lock.unlock(); } } private void persistEndpoint(Endpoint ep) throws EndpointAdminException { MediationPersistenceManager pm = getMediationPersistenceManager(); pm.saveItem(ep.getName(), ServiceBusConstants.ITEM_TYPE_ENDPOINT); } private void assertNameNotEmpty(String endpointName) throws EndpointAdminException { if (endpointName == null || "".equals(endpointName.trim())) { handleFault("Invalid name : Name is empty.", null); } } private void handleFault(String message, Exception e) throws EndpointAdminException { if (e != null) { log.error(message, e); throw new EndpointAdminException(e.getMessage(), e); } else { log.error(message); throw new EndpointAdminException(message); } } /** * Update an existing endpoint from the given String representation of the XML * * @param epString - String representing the XML which describes the * Endpoint element * @return true if the endpoint was saved successfully and false otherwise * @throws EndpointAdminException if the endpoint does not exists in the * SynapseConfiguration */ public boolean saveEndpoint(String epString) throws EndpointAdminException { OMElement endpointElement; final Lock lock = getLock(); try { lock.lock(); try { endpointElement = AXIOMUtil.stringToOM(epString); } catch (XMLStreamException e) { return false; } if (endpointElement.getQName().getLocalPart() .equals(XMLConfigConstants.ENDPOINT_ELT.getLocalPart())) { String endpointName = endpointElement.getAttributeValue(new QName("name")); assertNameNotEmpty(endpointName); endpointName = endpointName.trim(); if (log.isDebugEnabled()) { log.debug("Updating the definition of the endpoint : " + endpointName); } Endpoint previousEndpoint = getSynapseConfiguration().getEndpoint( endpointName.trim()); if (previousEndpoint == null) { addEndpoint(epString); } boolean statisticsState = false; EndpointDefinition def = null; if (null != previousEndpoint) { def = ((AbstractEndpoint) previousEndpoint).getDefinition(); } if (null != def && def.isStatisticsEnable()) { statisticsState = true; } String fileName = null; if (null != previousEndpoint && previousEndpoint instanceof AbstractEndpoint) { fileName = previousEndpoint.getFileName(); } Endpoint endpoint = EndpointFactory.getEndpointFromElement( endpointElement, false, getSynapseConfiguration().getProperties()); if (endpoint == null) { handleFault("Newly created endpoint is null ", null); } if (null != def) { if (statisticsState) { ((AbstractEndpoint) endpoint).getDefinition() .enableStatistics(); } } if (fileName != null && endpoint instanceof AbstractEndpoint) { endpoint.setFileName(fileName); } endpoint.init(getSynapseEnvironment()); endpointName = endpointName.trim(); getSynapseConfiguration().removeEndpoint(endpointName); getSynapseConfiguration().addEndpoint(endpointName, endpoint); if (previousEndpoint.getArtifactContainerName() != null) { endpoint.setArtifactContainerName(previousEndpoint.getArtifactContainerName()); endpoint.setIsEdited(true); } else { persistEndpoint(endpoint); } if (log.isDebugEnabled()) { log.debug("Updated the definition of the endpoint : " + endpointName); } return true; } else { handleFault("Unable to update endpoint. Invalid XML definition", null); } } catch (SynapseException syne) { handleFault("Unable to edit Endpoint ", syne); } finally { lock.unlock(); } return false; } /** * Update an existing Endpoint endpoint in the registry * * @param key dynamic endpoint key * @param epName endpoint name * @return whether operation is successful * @throws EndpointAdminException on Error */ public boolean saveDynamicEndpoint(String key, String epName) throws EndpointAdminException { OMElement endpointElement; final Lock lock = getLock(); try { lock.lock(); endpointElement = AXIOMUtil.stringToOM(epName); if (endpointElement.getQName().getLocalPart() .equals(XMLConfigConstants.ENDPOINT_ELT.getLocalPart())) { String endpointName = "dynamicEndpoint"; if (log.isDebugEnabled()) { log.debug("Updating endpoint : " + endpointName + " in the Synapse registry"); } Registry registry = getSynapseConfiguration().getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleFault("No resource exists by the key '" + key + "'", null); } registry.updateResource(key, endpointElement); if (log.isDebugEnabled()) { log.debug("Updated endpoint : " + endpointName + " in the Synapse registry"); } return true; } } else { handleFault("Unable to create endpoint. Invalid XML definition", null); } } catch (XMLStreamException e) { return false; } finally { lock.unlock(); } return false; } /** * Add an endpoint to the Synapse registry * * @param key of the dynamic endpoint * @param epConfiguration endpoint configuration * @throws EndpointAdminException in case of an error */ public boolean addDynamicEndpoint(String key, String epConfiguration) throws EndpointAdminException { ByteArrayOutputStream stream = new ByteArrayOutputStream(); stream.reset(); String originalKey = key; try { org.wso2.carbon.registry.core.Registry registry; if (key.startsWith("conf:")) { registry = getConfigSystemRegistry(); key = key.replace("conf:", ""); } else { registry = getGovernanceRegistry(); key = key.replace("gov:", ""); } if (!registry.resourceExists(key)) { try { OMElement endpointElement = AXIOMUtil.stringToOM(epConfiguration); OMFactory fac = OMAbstractFactory.getOMFactory(); String name = originalKey.replace(":", "/"); endpointElement.addAttribute(fac.createOMAttribute("name", fac.createOMNamespace(XMLConfigConstants.NULL_NAMESPACE, ""), name)); XMLPrettyPrinter.prettify(endpointElement, stream); } catch (Exception e) { handleFault("Unable to pretty print configuration", e); } epConfiguration = new String(stream.toByteArray()).trim(); Resource resource = registry.newResource(); resource.setMediaType(WSO2_ENDPOINT_MEDIA_TYPE); resource.setContent(epConfiguration); registry.put(key, resource); } else { log.warn("Resource is already exists"); return false; } } catch (RegistryException e) { handleFault("WSO2 Registry Exception", e); return false; } return true; } /** * Get a dynamic endpoint from the registry * * @param key dynamic endpoint key * @return dynamic endpoint configuration * @throws EndpointAdminException on an error */ public String getDynamicEndpoint(String key) throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synConfig = getSynapseConfiguration(); Registry registry = synConfig.getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleFault("No resource is available by the key '" + key + "'", null); } } else { handleFault("Unable to access the registry instance for the ESB", null); } OMElement e = null; if (registry != null) { Object obj = null; try { obj = registry.getResource(new Entry(key), synConfig.getProperties()); } catch (Exception e1) { log.error("Invalid endpoint configuration", e1); return null; } if (obj instanceof OMElement) { e = (OMElement) obj; } else { log.error("Invalid endpoint configuration"); } // e = (OMElement) registry.getResource(new Entry(key), // synConfig.getProperties()); } if (e != null) { if (log.isDebugEnabled()) { log.debug("Found dynamic endpoint " + key); } return e.toString(); } } finally { lock.unlock(); } return null; } /** * Check registry is available or not * @return boolean * @throws EndpointAdminException */ public boolean isRegisterNull() throws EndpointAdminException{ final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synConfig = getSynapseConfiguration(); Registry registry = synConfig.getRegistry(); if (registry == null) { return true; } } finally { lock.unlock(); } return false; } /** * Get all endpoints stored in the registry * * @return endpoints in the registry * @throws EndpointAdminException in case of an error */ public String[] getDynamicEndpoints() throws EndpointAdminException { org.wso2.carbon.registry.core.Registry registry; final Lock lock = getLock(); try { lock.lock(); String[] configInfo = getConfigSystemRegistry() != null ? getMimeTypeResult(getConfigSystemRegistry()):new String[0]; String[] govInfo = getGovernanceRegistry() !=null ?getMimeTypeResult(getGovernanceRegistry()):new String[0]; String[] info = new String[configInfo.length + govInfo.length]; int ptr = 0; for (String aConfigInfo : configInfo) { info[ptr] = "conf:" + aConfigInfo; ++ptr; } for (String aGovInfo : govInfo) { info[ptr] = "gov:" + aGovInfo; ++ptr; } Arrays.sort(info); if (log.isDebugEnabled()) { log.debug("Found " + info.length + " dynamic endpoints"); } return info; } catch (RegistryException e) { return null; } finally { lock.unlock(); } } /** * Remove a endpoint form the registry * * @param key dynamic endpoint key * @return whether operation is successful * @throws EndpointAdminException in case of an error */ public boolean deleteDynamicEndpoint(String key) throws EndpointAdminException { Lock lock = getLock(); try { lock.lock(); Registry registry = getSynapseConfiguration().getRegistry(); if (registry != null) { if (registry.getRegistryEntry(key).getType() == null) { handleFault("The key '" + key + "' cannot be found within the configuration", null); } registry.delete(key); if (log.isDebugEnabled()) { log.debug("Deleted endpoint with key: " + key + " from the Synapse registry"); } return true; } } finally { lock.unlock(); } return false; } private String[] getMimeTypeResult(org.wso2.carbon.registry.core.Registry targetRegistry) throws EndpointAdminException, RegistryException { String sql = "SELECT REG_PATH_ID, REG_NAME FROM REG_RESOURCE WHERE REG_MEDIA_TYPE = ?"; Map parameters = new HashMap(); parameters.put("query", sql); parameters.put("1", WSO2_ENDPOINT_MEDIA_TYPE); Resource result = targetRegistry.executeQuery(null, parameters); return (String[]) result.getContent(); } /** * Get dependents of a particular endpoint. * * @param endpointName endpoint name * @return dependants of a endpoints */ public ConfigurationObject[] getDependents(String endpointName) { DependencyManagementService dependencyMgr = ConfigHolder.getInstance(). getDependencyManager(); if (dependencyMgr != null) { ConfigurationObject[] dependents = dependencyMgr.getDependents( ConfigurationObject.TYPE_ENDPOINT, endpointName); if (dependents != null && dependents.length > 0) { List<ConfigurationObject> deps = new ArrayList<ConfigurationObject>(); for (ConfigurationObject o : dependents) { if (o.getType() != ConfigurationObject.TYPE_UNKNOWN) { deps.add(o); } } if (deps.size() > 0) { return deps.toArray(new ConfigurationObject[deps.size()]); } } } return null; } public String[] getEndPointsNames() throws EndpointAdminException { final Lock lock = getLock(); try { lock.lock(); SynapseConfiguration synapseConfiguration = getSynapseConfiguration(); Map<String, Endpoint> namedEndpointMap = synapseConfiguration.getDefinedEndpoints(); Collection<Endpoint> namedEndpointCollection = namedEndpointMap.values(); return listToNames(namedEndpointCollection.toArray( new Endpoint[namedEndpointCollection.size()])); } finally { lock.unlock(); } } private String[] listToNames(Endpoint[] eps) { if (eps == null) { return null; } else { String[] datas = new String[eps.length]; for (int i = 0; i < eps.length; i++) { Endpoint ep = eps[i]; datas[i] = ep.getName(); } return datas; } } public int getEndpointCount() throws EndpointAdminException { final Lock lock = getLock(); try{ lock.lock(); return getSynapseConfiguration().getDefinedEndpoints().size(); } catch (Exception e) { handleFault("Error while retrieving Endpoint count", e); } finally { lock.unlock(); } return 0; } public int getDynamicEndpointCount() throws EndpointAdminException { org.wso2.carbon.registry.core.Registry registry; try { String[] govList = getGovernanceRegistry() != null? getMimeTypeResult(getGovernanceRegistry()) :new String[0]; String[] confList = getConfigSystemRegistry() != null ? getMimeTypeResult(getConfigSystemRegistry()):new String [0]; return confList.length + govList.length; } catch (Exception e) { handleFault("Error while retrieving dynamic endpoint count", e); } return 0; } }