/*
* 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.
*/
package org.wso2.carbon.service.mgt;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMNamespace;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.axiom.om.util.StAXUtils;
import org.apache.axiom.om.util.UUIDGenerator;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.deployment.DeploymentErrorMsgs;
import org.apache.axis2.description.AxisBinding;
import org.apache.axis2.description.AxisBindingOperation;
import org.apache.axis2.description.AxisEndpoint;
import org.apache.axis2.description.AxisMessage;
import org.apache.axis2.description.AxisModule;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.AxisServiceGroup;
import org.apache.axis2.description.Parameter;
import org.apache.axis2.description.PolicyInclude;
import org.apache.axis2.description.PolicySubject;
import org.apache.axis2.description.TransportInDescription;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.engine.AxisEvent;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.util.PolicyLocator;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.neethi.Assertion;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyComponent;
import org.apache.neethi.PolicyEngine;
import org.apache.neethi.PolicyReference;
import org.wso2.carbon.CarbonConstants;
import org.wso2.carbon.core.AbstractAdmin;
import org.wso2.carbon.core.RegistryResources;
import org.wso2.carbon.core.persistence.PersistenceUtils;
import org.wso2.carbon.core.persistence.ServicePersistenceManager;
import org.wso2.carbon.core.transports.TransportPersistenceManager;
import org.wso2.carbon.core.util.ParameterUtil;
import org.wso2.carbon.core.util.SystemFilter;
import org.wso2.carbon.registry.core.Association;
import org.wso2.carbon.registry.core.Collection;
import org.wso2.carbon.registry.core.Registry;
import org.wso2.carbon.registry.core.Resource;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.jdbc.utils.Transaction;
import org.wso2.carbon.security.SecurityConfigException;
import org.wso2.carbon.security.config.SecurityConfigAdmin;
import org.wso2.carbon.security.config.service.SecurityScenarioData;
import org.wso2.carbon.service.mgt.util.Utils;
import org.wso2.carbon.utils.CarbonUtils;
import org.wso2.carbon.utils.DataPaginator;
import org.wso2.carbon.utils.FileManipulator;
import org.wso2.carbon.utils.ServerConstants;
import org.wso2.carbon.utils.ServerException;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
@SuppressWarnings("unused")
public class ServiceAdmin extends AbstractAdmin implements ServiceAdminMBean {
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);
}
}
/**
* set the service parameter enableMTOM to manipulate MTOM flag
* true/false/optional
*
* @param flag
* @param serviceName
*/
public void configureMTOM(String flag, String serviceName) throws AxisFault {
AxisService service = getAxisConfig().getServiceForActivation(serviceName);
if (service == null) {
throw new AxisFault("AxisService " + serviceName + " cannot be found.");
}
if (log.isDebugEnabled()) {
log.debug("Setting the MTOM status to " + flag + " for service " + serviceName);
}
Parameter parameter = ParameterUtil.createParameter(Constants.Configuration.ENABLE_MTOM,
flag.trim());
service.addParameter(parameter);
for (Iterator iterator1 = service.getOperations(); iterator1.hasNext();) {
AxisOperation axisOperation = (AxisOperation) iterator1.next();
axisOperation.
addParameter(ParameterUtil.createParameter(Constants.Configuration.ENABLE_MTOM,
(String) parameter.getValue()));
}
try {
spm.updateServiceParameter(service, parameter);
} catch (Exception e) {
String msg = "Cannot persist MTOM service parameter in the registry";
log.error(msg, e);
throw new AxisFault(msg, e);
}
}
public void startService(String serviceName) throws Exception {
if (log.isDebugEnabled()) {
log.debug("Activating service " + serviceName);
}
AxisService axisService = getAxisConfig().getServiceForActivation(serviceName);
if (axisService == null) {
throw new Exception("Invalid service name " + serviceName);
}
try {
getAxisConfig().startService(serviceName);
} catch (AxisFault e) {
String msg = "Cannot start service " + serviceName;
log.error(msg, e);
throw new Exception(msg);
}
}
public void stopService(String serviceName) throws Exception {
if (log.isDebugEnabled()) {
log.debug("Deactivating service " + serviceName);
}
AxisService axisService = getAxisConfig().getServiceForActivation(serviceName);
if (axisService == null) {
throw new Exception("Invalid service name " + serviceName);
}
try {
getAxisConfig().stopService(serviceName);
} catch (AxisFault e) {
String msg = "Cannot stop service " + serviceName;
log.error(msg, e);
throw new Exception(msg);
}
}
public String[] getExposedTransports(String serviceId) throws AxisFault {
AxisService axisService = getAxisConfig().getServiceForActivation(serviceId);
if (!axisService.isEnableAllTransports()) {
List<String> exposedTransports = axisService.getExposedTransports();
return exposedTransports.toArray(new String[exposedTransports.size()]);
} else {
Map transportsIn = getConfigContext().getAxisConfiguration()
.getTransportsIn();
String[] transports = new String[transportsIn.size()];
int i = 0;
for (Object o : transportsIn.values()) {
TransportInDescription tiDesc = (TransportInDescription) o;
transports[i++] = tiDesc.getName();
}
return transports;
}
}
public String addTransportBinding(String serviceId, String transportProtocol) throws Exception {
if (transportProtocol == null || transportProtocol.trim().length() == 0) {
return "Invalid transport " + transportProtocol;
}
AxisService axisService = getAxisConfig().getServiceForActivation(serviceId);
Registry registry = getConfigSystemRegistry();
if (axisService.isExposedTransport(transportProtocol)) {
return "Service [" + serviceId + "] already contains the " + transportProtocol
+ " transport binding!";
}
Resource serviceResource = spm.getService(axisService);
// TODO In the current implementation of Carbon-core this
// serviceResource can be null
// TODO Therefore we need to add it to the registry if it is null
if (serviceResource == null) {
spm.handleNewServiceAddition(axisService);
serviceResource = spm.getService(axisService);
}
// TODO This should be added, but for the moment it is commented
if (serviceResource.getProperty(RegistryResources.ServiceProperties.IS_UT_ENABLED) !=
null) {
if (!transportProtocol
.equalsIgnoreCase(ServerConstants.HTTPS_TRANSPORT)) {
throw new AxisFault(
"Cannot add non-HTTPS transport binding for Service ["
+ serviceId
+ "] since a security scenario which requires the "
+ "service to contain only the HTTPS transport binding"
+ " has been applied to this service.");
}
}
// if (serviceDO.getIsUTAuthEnabled()) {
// if (!transportProtocol
// .equalsIgnoreCase(ServerConstants.HTTPS_TRANSPORT)) {
// throw new AxisFault(
// "Cannot add non-HTTPS transport binding for Service ["
// + serviceId
// + "] since a security scenario which requires the "
// + "service to contain only the HTTPS transport binding"
// + " has been applied to this service.");
// }
// }
if (!axisService.isEnableAllTransports()) {
axisService.addExposedTransport(transportProtocol);
} else {
return "Service [" + serviceId + "] already contains the " + transportProtocol
+ " transport binding!";
}
Resource transportResource =
new TransportPersistenceManager(getAxisConfig()).getTransportResource(transportProtocol);
if (transportResource != null) {
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
serviceResource.setProperty(
RegistryResources.ServiceProperties.EXPOSED_ON_ALL_TANSPORTS, String
.valueOf(false));
registry.addAssociation(serviceResource.getPath(), transportResource.getPath(),
RegistryResources.Associations.EXPOSED_TRANSPORTS);
// registry.addAssociation(transportResource.getPath(),
// serviceResource.getPath(),
// RegistryResources.Associations.EXPOSED_TRANSPORTS);
registry.put(serviceResource.getPath(), serviceResource);
registry.put(transportResource.getPath(), transportResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (RegistryException e) {
String msg = "Service with name " + serviceId + " not found.";
log.error(msg);
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw new AxisFault(msg, e);
}
}
axisConfig.notifyObservers(
new AxisEvent(CarbonConstants.AxisEvent.TRANSPORT_BINDING_ADDED, axisService),
axisService);
return "Successfully added " + transportProtocol + " transport binding to service "
+ serviceId;
}
public String removeTransportBinding(String serviceId, String transportProtocol)
throws Exception {
AxisService axisService = getAxisConfig().getServiceForActivation(serviceId);
Registry registry = getConfigSystemRegistry();
Resource serviceResource = spm.getService(axisService);
// TODO In the current implementation of Carbon-core this
// serviceResource can be null
// TODO Therefore we need to add it to the registry if it is null
if (serviceResource == null) {
spm.handleNewServiceAddition(axisService);
serviceResource = spm.getService(axisService);
}
// TODO This should be added, but for the moment it is commented
if (serviceResource.getProperty(RegistryResources.ServiceProperties.IS_UT_ENABLED) !=
null) {
if (transportProtocol
.equalsIgnoreCase(ServerConstants.HTTPS_TRANSPORT)) {
throw new AxisFault(
"Cannot add non-HTTPS transport binding for Service ["
+ serviceId
+ "] since a security scenario which requires the "
+ "service to contain only the HTTPS transport binding"
+ " has been applied to this service.");
}
}
// if (serviceDO.getIsUTAuthEnabled()) {
// if (transportProtocol
// .equalsIgnoreCase(ServerConstants.HTTPS_TRANSPORT)) {
// throw new AxisFault(
// "HTTPS transport binding for Service ["
// + serviceId
// + "] cannot be removed since a security scenario which requires"
// + " HTTPS has been applied to this service.");
// }
// }
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
Resource transportResource;
if (!axisService.isEnableAllTransports()) {
transportResource =
new TransportPersistenceManager(getAxisConfig()).
getTransportResource(transportProtocol);
if (axisService.getExposedTransports().size() == 1) {
return SERVICE_MUST_CONTAIN_AT_LEAST_ONE_TRANSPORT;
} else {
registry.removeAssociation(serviceResource.getPath(), transportResource.getPath(),
RegistryResources.Associations.EXPOSED_TRANSPORTS);
// registry.removeAssociation(transportResource.getPath(),
// serviceResource.getPath(),
// RegistryResources.Associations.EXPOSED_TRANSPORTS);
axisService.removeExposedTransport(transportProtocol);
registry.put(transportResource.getPath(), transportResource);
}
} else {
//TODO this should come from Transport component UI
/*ServiceTracker transportServiceTracker = new ServiceTracker(bundleContext,
TransportAdmin.class.getName(),
null);
try {
transportServiceTracker.open();
TransportAdmin transportAdmin =
(TransportAdmin) transportServiceTracker.getService();
if (transportAdmin != null) {
TransportSummary[] transports = transportAdmin.listTransports();
if (transports.length == 1) {
return SERVICE_MUST_CONTAIN_AT_LEAST_ONE_TRANSPORT;
} else {
for (TransportSummary transport : transports) {
String protocol = transport.getProtocol();
if (!protocol.equals(transportProtocol)) {
axisService.addExposedTransport(protocol);
transportResource = spm.getTransport(protocol);
registry.addAssociation(serviceResource.getPath(),
transportResource.getPath(),
RegistryResources.Associations.EXPOSED_TRANSPORTS);
// registry.addAssociation(transportResource.getPath(),
// serviceResource.getPath(),
// RegistryResources.Associations.EXPOSED_TRANSPORTS);
registry.put(transportResource.getPath(), transportResource);
}
}
}
} else {
log.error("TransportAdmin OSGi Service is not available");
}
} catch (RegistryException e) {
} catch (Exception e) {
String msg = "Could not get transports list form TransportAdmin service";
log.error(msg, e);
throw new AxisFault(msg, e);
} finally {
transportServiceTracker.close();
}*/
}
serviceResource.setProperty(RegistryResources.ServiceProperties.EXPOSED_ON_ALL_TANSPORTS,
String.valueOf(false));
registry.put(serviceResource.getPath(), serviceResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
axisConfig.notifyObservers(
new AxisEvent(CarbonConstants.AxisEvent.TRANSPORT_BINDING_REMOVED, axisService),
axisService);
return "Removed " + transportProtocol + " transport binding for " + serviceId + " service";
}
/**
* Removes policy given the key
*
* @param serviceName Name of the service
* @param policyKey Key of the policy to be removed
* @param moduleNames Array of module names
* @throws ServerException on error
*/
public void removeBindingPolicy(String serviceName, String policyKey, String[] moduleNames)
throws ServerException {
try {
AxisConfiguration axisConfig = getAxisConfig();
Registry registry = getConfigSystemRegistry();
AxisService service = axisConfig.getServiceForActivation(serviceName);
String servicePath = RegistryResources.SERVICE_GROUPS
+ service.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + serviceName;
String policyPath = servicePath + RegistryResources.POLICIES + policyKey;
registry.delete(policyPath);
for (String moduleName : moduleNames) {
String modPath = RegistryResources.MODULES + moduleName;
registry.removeAssociation(servicePath, modPath,
RegistryResources.Associations.ENGAGED_MODULES);
}
// 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();
PolicySubject subject = binding.getPolicySubject();
subject.detachPolicyComponent(policyKey);
}
} catch (Exception e) {
String msg = "Cannot remove service policy";
log.error(msg, e);
throw new ServerException(msg, e);
}
}
public void setServiceParameters(String serviceName,
String[] parameters) throws AxisFault {
for (String parameter : parameters) {
setServiceParameter(serviceName, parameter);
}
}
private void setServiceParameter(String serviceName,
String parameterStr) throws AxisFault {
AxisService axisService = getAxisConfig().getServiceForActivation(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name service not found : " + serviceName);
}
OMElement paramEle;
try {
XMLStreamReader xmlSR =
StAXUtils.createXMLStreamReader(
new ByteArrayInputStream(parameterStr.getBytes()));
paramEle = new StAXOMBuilder(xmlSR).getDocumentElement();
} catch (XMLStreamException e) {
String msg = "Cannot create OMElement from parameter: " + parameterStr;
log.error(msg, e);
throw new AxisFault(msg, e);
}
Parameter parameter = ParameterUtil.createParameter(paramEle);
if (axisService.getParameter(parameter.getName()) != null) {
if (!axisService.getParameter(parameter.getName()).isLocked()) {
axisService.addParameter(parameter);
}
} else {
axisService.addParameter(parameter);
}
try {
spm.updateServiceParameter(axisService, parameter);
} catch (Exception e) {
String msg = "Cannot persist service parameter change for service " + serviceName;
log.error(msg, e);
throw new AxisFault(msg, e);
}
}
public void removeServiceParameter(String serviceName,
String parameterName) throws AxisFault {
AxisService axisService = getAxisConfig().getServiceForActivation(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name service not found : " +
serviceName);
}
Parameter parameter = ParameterUtil.createParameter(parameterName, null);
axisService.removeParameter(parameter);
try {
spm.removeServiceParameter(axisService, parameter);
} catch (Exception e) {
String msg = "Cannot persist service parameter removal. Service " + serviceName;
log.error(msg, e);
throw new AxisFault(msg, e);
}
}
public String[] getServiceParameters(String serviceName) throws ServerException {
try {
AxisService service = getAxisService(serviceName);
ArrayList<Parameter> parameters = service.getParameters();
List<String> params = new ArrayList<String>();
for (Parameter param : parameters) {
OMElement paramEle = param.getParameterElement();
if (paramEle != null) {
params.add(paramEle.toString());
}
}
return params.toArray(new String[params.size()]);
} catch (Exception e) {
String msg = "Error occured while getting parameters of service : " + serviceName;
log.error(msg, e);
throw new ServerException(msg, e);
}
}
/**
* Returns the Service Policy for a given service.
*
* @param serviceName The name of the service
* @return A string representing the Policy XML
* @throws AxisFault on error
*/
public String getPolicy(String serviceName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
PolicySubject servicePolicySubject = axisService.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(servicePolicySubject.getAttachedPolicyComponents());
Policy servicePolicy = org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList,
axisService);
if (servicePolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(servicePolicy).toString();
}
/**
* Retrieves the merged policy from a given modiule
*
* @param moduleName Name of the module
* @param moduleVersion Version string of the string
* @return A string representaiton of the policy
* @throws AxisFault on error
*/
public String getModulePolicy(String moduleName, String moduleVersion) throws AxisFault {
AxisConfiguration axisConfig = MessageContext.getCurrentMessageContext()
.getConfigurationContext().getAxisConfiguration();
AxisModule axisModule = axisConfig.getModule(moduleName, moduleVersion);
if (axisModule == null) {
throw new AxisFault("invalid service name");
}
PolicySubject modulePolicySubject = axisModule.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(modulePolicySubject.getAttachedPolicyComponents());
// Get the merged module policy
Policy policy = null;
for (Iterator iterator = policyList.iterator(); iterator.hasNext();) {
Object policyElement = iterator.next();
if (policyElement instanceof Policy) {
policy = (policy == null) ? (Policy) policyElement
: policy.merge((Policy) policyElement);
} else {
PolicyReference policyReference = (PolicyReference) policyElement;
String key = policyReference.getURI();
int pos = key.indexOf("#");
if (pos == 0) {
key = key.substring(1);
} else if (pos > 0) {
key = key.substring(0, pos);
}
PolicyComponent attachedPolicyComponent = modulePolicySubject
.getAttachedPolicyComponent(key);
if (attachedPolicyComponent != null
&& attachedPolicyComponent instanceof Policy) {
policy = (Policy) attachedPolicyComponent;
}
}
}
if (policy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(policy).toString();
}
public void setModulePolicy(String moduleName, String moduleVersion, String policyString)
throws Exception {
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
// At axis2
AxisConfiguration axisConfig = MessageContext.getCurrentMessageContext()
.getConfigurationContext().getAxisConfiguration();
AxisModule axisModule = axisConfig.getModule(moduleName, moduleVersion);
axisModule.getPolicySubject().clear();
axisModule.getPolicySubject().attachPolicy(policy);
// At Registry
Resource policyResource = getConfigSystemRegistry().newResource();
policyResource.setProperty(RegistryResources.ModuleProperties.POLICY_UUID, policy.getId());
policyResource.setProperty(RegistryResources.ModuleProperties.VERSION, moduleVersion);
// do a performance improvement
ByteArrayOutputStream baos = new ByteArrayOutputStream();
XMLStreamWriter writer = XMLOutputFactory.newInstance().createXMLStreamWriter(baos);
policy.serialize(writer);
writer.flush();
policyResource.setContent(baos.toString());
policyResource.setProperty(RegistryResources.ModuleProperties.POLICY_TYPE,
"" + PolicyInclude.AXIS_MODULE_POLICY);
String modulePath = PersistenceUtils.getResourcePath(axisModule);
String policyResourcePath = modulePath + RegistryResources.POLICIES + policy.getId();
getConfigSystemRegistry().put(policyResourcePath, policyResource);
}
/**
* Returns the policy for a given service and it's operation
*
* @param serviceName The name of the service
* @param operationName The operation
* @return a String representing the Policy XML
* @throws AxisFault on error
*/
public String getOperationPolicy(String serviceName, String operationName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
AxisOperation axisOperation = axisService.getOperation(new QName(operationName));
PolicySubject operationPolicySubject = axisOperation.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(operationPolicySubject.getAttachedPolicyComponents());
Policy operationPolicy = org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList,
axisService);
if (operationPolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(operationPolicy).toString();
}
/**
* Returns the policy for a given message
*
* @param serviceName The name of the service
* @param operationName The name of the operation
* @param messageType The type of message
* @return A string representation of the Policy XML
* @throws AxisFault on error
*/
public String getOperationMessagePolicy(String serviceName, String operationName,
String messageType)
throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
AxisMessage axisMessage =
axisService.getOperation(new QName(operationName)).getMessage(messageType);
PolicySubject messagePolicySubject = axisMessage.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(messagePolicySubject.getAttachedPolicyComponents());
Policy messagePolicy = org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList,
axisService);
if (messagePolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(messagePolicy).toString();
}
public PolicyMetaData[] getPolicies(String serviceName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
ArrayList<PolicyMetaData> policyDataArray = new ArrayList<PolicyMetaData>();
PolicySubject servicePolicySubject = axisService.getPolicySubject();
List<PolicyComponent> policyList;
// services.xml
policyList = new ArrayList<PolicyComponent>(servicePolicySubject.getAttachedPolicyComponents());
if (!policyList.isEmpty()) {
PolicyMetaData policyData = new PolicyMetaData();
policyData.setWrapper("Policies that are applicable for " + axisService.getName()
+ " service");
policyData.setPolycies(PolicyUtil.processPolicyElements(policyList.iterator(),
new PolicyLocator(
axisService)));
policyDataArray.add(policyData);
}
for (Iterator iterator = axisService.getEndpoints().values().iterator();
iterator.hasNext();) {
AxisEndpoint axisEndpoint = (AxisEndpoint) iterator.next();
policyList = new ArrayList<PolicyComponent>(axisEndpoint.getPolicySubject()
.getAttachedPolicyComponents());
if (!policyList.isEmpty()) {
PolicyMetaData policyData = new PolicyMetaData();
policyData.setWrapper("Policies that are applicable for " + axisEndpoint.getName()
+ " endpoint");
policyData.setPolycies(PolicyUtil.processPolicyElements(policyList.iterator(),
new PolicyLocator(
axisService)));
policyDataArray.add(policyData);
}
}
return (policyDataArray.toArray(new PolicyMetaData[policyDataArray.size()]));
}
/**
* Returns the policy for a given service binding
*
* @param serviceName The name of the service
* @param bindingName The name of the binding in question
* @return A String representing the Policy XML
* @throws AxisFault on error
*/
public String getBindingPolicy(String serviceName, String bindingName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
AxisBinding axisBinding = null;
// at axis2
Map endPointMap = axisService.getEndpoints();
for (Object o : endPointMap.entrySet()) {
Map.Entry entry = (Map.Entry) o;
AxisEndpoint point = (AxisEndpoint) entry.getValue();
if (point.getBinding().getName().getLocalPart().equals(bindingName)) {
axisBinding = point.getBinding();
break;
}
}
if (axisBinding == null) {
throw new AxisFault("invalid binding name");
}
PolicySubject bindingPolicy = axisBinding.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(bindingPolicy.getAttachedPolicyComponents());
Policy servicePolicy = org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList,
axisService);
if (servicePolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(servicePolicy).toString();
}
/**
* Returns a policy for an operation of a given service binding
*
* @param serviceName Name of the service
* @param bindingName Name of the service binding
* @param operationName Name of the service operation
* @return A policy
* @throws AxisFault on error
*/
public String getBindingOperationPolicy(String serviceName, String bindingName,
String operationName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
AxisBinding axisBinding = null;
// at axis2
Map endPointMap = axisService.getEndpoints();
for (Object o : endPointMap.entrySet()) {
Map.Entry entry = (Map.Entry) o;
AxisEndpoint point = (AxisEndpoint) entry.getValue();
if (point.getBinding().getName().getLocalPart().equals(bindingName)) {
axisBinding = point.getBinding();
break;
}
}
if (axisBinding == null) {
throw new AxisFault("invalid binding name");
}
Policy bindingOperationPolicy = null;
Iterator operations = axisBinding.getChildren();
while (operations.hasNext()) {
AxisBindingOperation currentOperation = (AxisBindingOperation) operations.next();
if (currentOperation.getName().toString().equals(operationName)) {
PolicySubject bindingOperationPolicySubject = currentOperation.getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(bindingOperationPolicySubject.getAttachedPolicyComponents());
bindingOperationPolicy =
org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList, axisService);
break;
}
}
if (bindingOperationPolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(bindingOperationPolicy).toString();
}
/**
* Returns the policy of a given message for a given service binding's operation
*
* @param serviceName Service name
* @param bindingName Service binding name
* @param operationName Service operation name
* @param messageType Message type
* @return Policy key
* @throws AxisFault on error
*/
public String getBindingOperationMessagePolicy(String serviceName, String bindingName,
String operationName, String messageType)
throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService == null) {
throw new AxisFault("invalid service name");
}
AxisBinding axisBinding = null;
// at axis2
Map endPointMap = axisService.getEndpoints();
for (Object o : endPointMap.entrySet()) {
Map.Entry entry = (Map.Entry) o;
AxisEndpoint point = (AxisEndpoint) entry.getValue();
if (point.getBinding().getName().getLocalPart().equals(bindingName)) {
axisBinding = point.getBinding();
break;
}
}
if (axisBinding == null) {
throw new AxisFault("invalid binding name");
}
Policy bindingOperationMessagePolicy = null;
Iterator operations = axisBinding.getChildren();
while (operations.hasNext()) {
AxisBindingOperation currentOperation = (AxisBindingOperation) operations.next();
if (currentOperation.getName().toString().equals(operationName)) {
PolicySubject bindingOperationMessagePolicySubject =
currentOperation.getChild(messageType).getPolicySubject();
List<PolicyComponent> policyList =
new ArrayList<PolicyComponent>(
bindingOperationMessagePolicySubject.getAttachedPolicyComponents());
bindingOperationMessagePolicy =
org.apache.axis2.util.PolicyUtil.getMergedPolicy(policyList, axisService);
break;
}
}
if (bindingOperationMessagePolicy == null) {
return PolicyUtil.getEmptyPolicyAsOMElement().toString();
}
return PolicyUtil.getPolicyAsOMElement(bindingOperationMessagePolicy).toString();
}
public void setPolicy(String serviceName, String policyString) throws Exception {
setServicePolicy(serviceName, policyString);
}
public void setServicePolicy(String serviceName, String policyString) throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Registry registry = getConfigSystemRegistry();
// Add the new policy to the registry
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE,
"" + PolicyInclude.AXIS_SERVICE_POLICY);
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
// Update the service resource in registry to point to this merged policy
String serviceResourcePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Resource serviceResource = registry.get(serviceResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
serviceResource.setProperty(RegistryResources.ServiceProperties.POLICY_UUID, policyIdList);
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(serviceResourcePath, serviceResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// at axis2
axisService.getPolicySubject().clear();
axisService.getPolicySubject().attachPolicy(policy);
axisService.getAxisConfiguration().notifyObservers(new AxisEvent(CarbonConstants.POLICY_ADDED
, axisService), axisService);
}
public void setServiceOperationPolicy(String serviceName, String operationName,
String policyString) throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Registry registry = getConfigSystemRegistry();
// Add the new policy to the registry
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE,
"" + PolicyInclude.AXIS_OPERATION_POLICY);
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
// Update the service operation resource in registry to point to this merged policy
String operationResourcePath = servicePath + RegistryResources.ServiceProperties.OPERATIONS
+ operationName;
Resource operationResource = registry.get(operationResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
operationResource
.setProperty(RegistryResources.ServiceProperties.POLICY_UUID, policyIdList);
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(operationResourcePath, operationResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// at axis2
AxisOperation axisOperation = axisService.getOperation(new QName(operationName));
axisOperation.getPolicySubject().clear();
axisOperation.getPolicySubject().attachPolicy(policy);
axisService.getAxisConfiguration().notifyObservers(new AxisEvent(CarbonConstants.POLICY_ADDED
, axisOperation), axisService);
}
public void setServiceOperationMessagePolicy(String serviceName, String operationName,
String messageType, String policyString)
throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
Registry registry = getConfigSystemRegistry();
// at registry
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE,
"" + PolicyInclude.AXIS_MESSAGE_POLICY);
// Update the operation message to point to the new merged policy
String operationResourcePath = servicePath + RegistryResources.ServiceProperties.OPERATIONS
+ operationName;
Resource operationResource = registry.get(operationResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
if (messageType.equals(WSDLConstants.MESSAGE_LABEL_IN_VALUE)) {
operationResource.setProperty(
RegistryResources.ServiceProperties.MESSAGE_IN_POLICY_UUID, policyIdList);
} else if (messageType.equals(WSDLConstants.MESSAGE_LABEL_OUT_VALUE)) {
operationResource.setProperty(
RegistryResources.ServiceProperties.MESSAGE_OUT_POLICY_UUID, policyIdList);
}
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(operationResourcePath, operationResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// at axis2
axisService.getOperation(new QName(operationName)).getMessage(messageType)
.getPolicySubject().clear();
axisService.getOperation(new QName(operationName)).getMessage(messageType)
.getPolicySubject().attachPolicy(policy);
}
public void setBindingPolicy(String serviceName, String bindingName, String policyString)
throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Registry registry = getConfigSystemRegistry();
// Add the new policy to the registry
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE,
"" + PolicyInclude.BINDING_POLICY);
// Update the binding resource in registry to point to this new merged policy
String bindingResourcePath = servicePath + RegistryResources.ServiceProperties.BINDINGS
+ bindingName;
Resource bindingResource = registry.get(bindingResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
bindingResource.setProperty(RegistryResources.ServiceProperties.POLICY_UUID, policyIdList);
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(bindingResourcePath, bindingResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// 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();
if (binding.getName().getLocalPart().equals(bindingName)) {
binding.getPolicySubject().clear();
binding.getPolicySubject().attachPolicy(policy);
}
}
}
public void setBindingOperationPolicy(String serviceName, String bindingName,
String operationName, String policyString)
throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Registry registry = getConfigSystemRegistry();
// Add new policy to registry
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE,
"" + PolicyInclude.BINDING_OPERATION_POLICY);
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
// Make the binding operation resource point to this new merged policy
String bindingOperationResourcePath =
servicePath + RegistryResources.ServiceProperties.BINDINGS
+ bindingName + RegistryResources.ServiceProperties.OPERATIONS +
operationName;
Resource bindingOperationResource = registry.get(bindingOperationResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
bindingOperationResource
.setProperty(RegistryResources.ServiceProperties.POLICY_UUID, policyIdList);
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(bindingOperationResourcePath, bindingOperationResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// 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();
if (binding.getName().getLocalPart().equals(bindingName)) {
Iterator operations = binding.getChildren();
while (operations.hasNext()) {
AxisBindingOperation currentOperation =
(AxisBindingOperation) operations.next();
if (currentOperation.getName().toString().equals(operationName)) {
currentOperation.getPolicySubject().clear();
currentOperation.getPolicySubject().attachPolicy(policy);
break;
}
}
}
}
}
public void setBindingOperationMessagePolicy(String serviceName, String bindingName,
String operationName, String messageType,
String policyString)
throws Exception {
AxisService axisService = getAxisService(serviceName);
ByteArrayInputStream bais = new ByteArrayInputStream(policyString.getBytes());
Policy policy = PolicyEngine.getPolicy(bais);
if (policy.getId() == null) {
// Generate an ID
policy.setId(UUIDGenerator.getUUID());
}
String servicePath = RegistryResources.SERVICE_GROUPS
+ axisService.getAxisServiceGroup().getServiceGroupName()
+ RegistryResources.SERVICES + axisService.getName();
Registry registry = getConfigSystemRegistry();
String policyType;
if (messageType.equalsIgnoreCase(WSDLConstants.MESSAGE_LABEL_IN_VALUE)) {
policyType = "" + PolicyInclude.BINDING_INPUT_POLICY;
} else {
policyType = "" + PolicyInclude.BINDING_OUTPUT_POLICY;
}
// Add the new policy to registry
Resource policyResource = registry.newResource();
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());
policyResource.setProperty(RegistryResources.ServiceProperties.POLICY_TYPE, policyType);
String policyResourcePath = servicePath + RegistryResources.POLICIES + policy.getId();
// Make the binding operation resource's message in the registry point to this policy
String bindingOperationResourcePath =
servicePath + RegistryResources.ServiceProperties.BINDINGS
+ bindingName + RegistryResources.ServiceProperties.OPERATIONS +
operationName;
Resource bindingOperationResource = registry.get(bindingOperationResourcePath);
List<String> policyIdList = new ArrayList<String>();
policyIdList.add(policy.getId());
if (messageType.equals(WSDLConstants.MESSAGE_LABEL_IN_VALUE)) {
bindingOperationResource
.setProperty(RegistryResources.ServiceProperties.MESSAGE_IN_POLICY_UUID,
policyIdList);
} else if (messageType.equals(WSDLConstants.MESSAGE_LABEL_OUT_VALUE)) {
bindingOperationResource
.setProperty(RegistryResources.ServiceProperties.MESSAGE_OUT_POLICY_UUID,
policyIdList);
}
try {
boolean transactionStarted = Transaction.isStarted();
if (!transactionStarted) {
getConfigSystemRegistry().beginTransaction();
}
registry.put(policyResourcePath, policyResource);
registry.put(bindingOperationResourcePath, bindingOperationResource);
if (!transactionStarted) {
getConfigSystemRegistry().commitTransaction();
}
} catch (Exception e) {
try {
getConfigSystemRegistry().rollbackTransaction();
} catch (RegistryException e1) {
throw AxisFault.makeFault(e);
}
throw AxisFault.makeFault(e);
}
// 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();
if (binding.getName().getLocalPart().equals(bindingName)) {
Iterator operations = binding.getChildren();
while (operations.hasNext()) {
AxisBindingOperation currentOperation =
(AxisBindingOperation) operations.next();
if (currentOperation.getName().toString().equals(operationName)) {
currentOperation.getChild(messageType).getPolicySubject().clear();
currentOperation.getChild(messageType).getPolicySubject().attachPolicy(policy);
break;
}
}
}
}
}
public OMElement getWSDL(String serviceName) throws AxisFault {
AxisService axisService = getAxisService(serviceName);
if (axisService != null) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
String url = MessageContext.getCurrentMessageContext().getTo().getAddress();
int ipindex = url.indexOf("//");
String ip = null;
if (ipindex >= 0) {
ip = url.substring(ipindex + 2, url.length());
int seperatorIndex = ip.indexOf(":");
if (seperatorIndex > 0) {
ip = ip.substring(0, seperatorIndex);
}
}
axisService.printWSDL(out, ip);
try {
XMLStreamReader xmlReader = XMLInputFactory.newInstance().createXMLStreamReader(
new ByteArrayInputStream(out.toByteArray()));
OMFactory fac = OMAbstractFactory.getOMFactory();
OMNamespace namespace = fac.createOMNamespace("http://org.apache.axis2/xsd", "ns1");
OMElement wsdlWrapper = fac.createOMElement("getWSDLResponse", namespace);
OMElement retvalue = fac.createOMElement("return", null);
wsdlWrapper.addChild(retvalue);
StAXOMBuilder staxOMBuilder = new StAXOMBuilder(fac, xmlReader);
retvalue.addChild(staxOMBuilder.getDocumentElement());
return wsdlWrapper;
} catch (XMLStreamException e) {
throw AxisFault.makeFault(e);
}
}
return null;
}
public String[] getServiceBindings(String serviceName)
throws Exception {
AxisService axisService = getAxisService(serviceName);
ServiceMetaData serviceMetaData = new ServiceMetaData();
serviceMetaData.setServiceId(serviceName);
// Get all bindings
ArrayList<String> bindingsList = new ArrayList<String>();
Map endPointMap = axisService.getEndpoints();
for (Object o : endPointMap.entrySet()) {
Map.Entry entry = (Map.Entry) o;
AxisEndpoint point = (AxisEndpoint) entry.getValue();
String currentBinding = point.getBinding().getName().getLocalPart().toString();
if ((!currentBinding.contains("HttpBinding")) &&
(!bindingsList.contains(currentBinding))) {
bindingsList.add(currentBinding);
}
}
String[] bindings = new String[bindingsList.size()];
bindingsList.toArray(bindings);
return bindings;
}
private AxisService getAxisService(String serviceName) throws AxisFault {
return getAxisConfig().getServiceForActivation(serviceName);
}
}