/*
* 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.governance.api.endpoints;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.governance.api.common.dataobjects.GovernanceArtifact;
import org.wso2.carbon.governance.api.endpoints.dataobjects.Endpoint;
import org.wso2.carbon.governance.api.endpoints.dataobjects.EndpointImpl;
import org.wso2.carbon.governance.api.exception.GovernanceException;
import org.wso2.carbon.governance.api.util.GovernanceConstants;
import org.wso2.carbon.governance.api.util.GovernanceUtils;
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.utils.RegistryUtils;
import org.wso2.carbon.registry.extensions.handlers.utils.EndpointUtils;
import org.wso2.carbon.registry.extensions.utils.CommonConstants;
import org.wso2.carbon.registry.extensions.utils.CommonUtil;
import java.util.*;
/**
* This provides the management functionality for endpoint artifacts stored on
* the registry.
*/
public class EndpointManager {
private static final Log log = LogFactory.getLog(EndpointManager.class);
private Registry registry;
/**
* Constructor accepting an instance of the registry to use.
*
* @param registry the instance of the registry.
*/
public EndpointManager(Registry registry) {
this.registry = registry;
}
/**
* Creates a new endpoint artifact from the given URL.
*
* @param url the given URL.
*
* @return the artifact added.
* @throws GovernanceException if the operation failed.
*/
public Endpoint newEndpoint(String url) throws GovernanceException {
String endpointId = UUID.randomUUID().toString();
EndpointImpl endpoint = new EndpointImpl(url, endpointId);
endpoint.associateRegistry(registry);
return endpoint;
}
/**
* Adds the given endpoint artifact to the registry. Please do not use this method to update an
* existing artifact use the update method instead. If this method is used to update an existing
* artifact, all existing properties (such as lifecycle details) will be removed from the
* existing artifact.
*
* @param endpoint the endpoint artifact.
*
* @throws GovernanceException if the operation failed.
*/
public void addEndpoint(Endpoint endpoint) throws GovernanceException {
boolean succeeded = false;
try {
registry.beginTransaction();
Resource endpointResource = registry.newResource();
endpointResource.setMediaType(GovernanceConstants.ENDPOINT_MEDIA_TYPE);
setContent(endpoint, endpointResource);
String tmpPath = "/" + GovernanceUtils.getNameFromUrl(((EndpointImpl)endpoint).getUrl());
endpointResource.setUUID(endpoint.getId());
// Resource resource = registry.get(registry.put(tmpPath, endpointResource));
registry.put(tmpPath, endpointResource);
// endpoint.setId(endpointResource.getUUID());
((EndpointImpl)endpoint).updatePath();
succeeded = true;
} catch (RegistryException e) {
String msg =
"Add endpoint failed: endpoint id: " + endpoint.getId() + ", path: " +
endpoint.getPath() + ".";
log.error(msg, e);
throw new GovernanceException(msg, e);
} finally {
if (succeeded) {
try {
registry.commitTransaction();
} catch (RegistryException e) {
String msg =
"Error in committing transactions. Add endpoint failed: " +
"endpoint id: " + endpoint.getId() + ", path: " +
endpoint.getPath() + ".";
log.error(msg, e);
}
} else {
try {
registry.rollbackTransaction();
} catch (RegistryException e) {
String msg =
"Error in rolling back transactions. Add endpoint failed: " +
"endpoint id: " + endpoint.getId() + ", path: " +
endpoint.getPath() + ".";
log.error(msg, e);
}
}
}
}
/**
* Updates the given endpoint artifact on the registry.
*
* @param endpoint the endpoint artifact.
*
* @throws GovernanceException if the operation failed.
*/
@SuppressWarnings("unused")
public void updateEndpoint(Endpoint endpoint) throws GovernanceException {
if (((EndpointImpl)endpoint).getUrl() == null) {
// there won't be any updates
String msg =
"Updates are only accepted if the url is available. " +
"So no updates will be done. " + "endpoint id: " + endpoint.getId() +
", endpoint path: " + endpoint.getPath() + ".";
log.error(msg);
throw new GovernanceException(msg);
}
boolean succeeded = false;
try {
registry.beginTransaction();
// getting the old endpoint.
// Endpoint oldEndpoint = getEndpoint(endpoint.getId());
// if (oldEndpoint != null) {
// // we are expecting only the OMElement to be different.
// String oldPath = oldEndpoint.getPath();
// registry.delete(oldPath);
// }
addEndpoint(endpoint);
succeeded = true;
} catch (RegistryException e) {
String msg =
"Error in updating the endpoint, endpoint id: " + endpoint.getId() +
", endpoint path: " + endpoint.getPath() + ".";
log.error(msg, e);
throw new GovernanceException(msg, e);
} finally {
if (succeeded) {
try {
registry.commitTransaction();
} catch (RegistryException e) {
String msg =
"Error in committing transactions. Update endpoint failed: " +
"endpoint id: " + endpoint.getId() + ", path: " +
endpoint.getPath() + ".";
log.error(msg, e);
}
} else {
try {
registry.rollbackTransaction();
} catch (RegistryException e) {
String msg =
"Error in rolling back transactions. Update endpoint failed: " +
"endpoint id: " + endpoint.getId() + ", path: " +
endpoint.getPath() + ".";
log.error(msg, e);
}
}
}
}
/**
* Fetches the given endpoint artifact on the registry.
*
* @param endpointId the identifier of the endpoint artifact.
*
* @return the endpoint artifact.
* @throws GovernanceException if the operation failed.
*/
public Endpoint getEndpoint(String endpointId) throws GovernanceException {
GovernanceArtifact artifact =
GovernanceUtils.retrieveGovernanceArtifactById(registry, endpointId);
if (artifact != null && !(artifact instanceof Endpoint)) {
String msg = "The artifact request is not an endpoint. id: " + endpointId + ".";
log.error(msg);
throw new GovernanceException(msg);
}
return (Endpoint) artifact;
}
/**
* Removes the given endpoint artifact from the registry.
*
* @param endpointId the identifier of the endpoint artifact.
*
* @throws GovernanceException if the operation failed.
*/
public void removeEndpoint(String endpointId) throws GovernanceException {
GovernanceUtils.removeArtifact(registry, endpointId);
}
/**
* Sets content of the given endpoint artifact to the given resource on the
* registry.
*
* @param endpoint the endpoint artifact.
* @param endpointResource the content resource.
*
* @throws GovernanceException if the operation failed.
*/
public void setContent(Endpoint endpoint, Resource endpointResource) throws GovernanceException {
// set the endpoint url
String url = ((EndpointImpl)endpoint).getUrl();
try {
String content = EndpointUtils.getEndpointContentWithOverview(url, EndpointUtils.deriveEndpointFromUrl(url),
EndpointUtils.deriveEndpointNameFromUrl(url), CommonConstants.ENDPOINT_VERSION_DEFAULT_VALUE);
endpointResource.setContent(content);
} catch (RegistryException e) {
String msg =
"Error in setting the resource content for endpoint. path: " +
endpoint.getPath() + ", " + "id: " + endpoint.getId() + ".";
log.error(msg);
throw new GovernanceException(msg, e);
}
// and set all the attributes as properties.
String[] attributeKeys = endpoint.getAttributeKeys();
if (attributeKeys != null) {
Properties properties = new Properties();
for (String attributeKey : attributeKeys) {
String[] attributeValues = endpoint.getAttributes(attributeKey);
if (attributeValues != null) {
// The list obtained from the Arrays#asList method is
// immutable. Therefore,
// we create a mutable object out of it before adding it as
// a property.
properties.put(attributeKey,
new ArrayList<String>(Arrays.asList(attributeValues)));
}
}
endpointResource.setProperties(properties);
}
endpointResource.setUUID(endpoint.getId());
}
/**
* Finds the endpoint artifact that matches the given URL.
*
* @param url the URL.
*
* @return the endpoint artifact that corresponds.
* @throws GovernanceException if the operation failed.
*/
public Endpoint getEndpointByUrl(String url) throws GovernanceException {
String path = CommonUtil.getEndpointPathFromUrl(url);
Resource r;
try {
if (registry.resourceExists(path)) {
r = registry.get(path);
} else {
return null;
}
} catch (RegistryException e) {
String msg =
"Error in retrieving the endpoint resource. url:" + url + ", path:" + path +
".";
log.error(msg, e);
throw new GovernanceException(msg, e);
}
String artifactId = r.getUUID();
if (artifactId != null) {
return getEndpoint(artifactId);
}
return null;
}
/**
* Finds all Endpoint artifacts on the registry.
*
* @return all Endpoint artifacts on the registry.
* @throws GovernanceException if the operation failed.
*/
public Endpoint[] getAllEndpoints() throws GovernanceException {
List<String> endpointPaths =
Arrays.asList(GovernanceUtils.getResultPaths(registry,
GovernanceConstants.ENDPOINT_MEDIA_TYPE));
Collections.sort(endpointPaths, new Comparator<String>() {
public int compare(String o1, String o2) {
// First order by name
int result = RegistryUtils.getResourceName(o1).compareToIgnoreCase(
RegistryUtils.getResourceName(o2));
if (result != 0) {
return result;
}
// Then order by namespace
return o1.compareToIgnoreCase(o2);
}
});
List<Endpoint> endpoints = new ArrayList<Endpoint>();
for (String endpointPath : endpointPaths) {
GovernanceArtifact artifact =
GovernanceUtils.retrieveGovernanceArtifactByPath(registry, endpointPath);
endpoints.add((Endpoint) artifact);
}
return endpoints.toArray(new Endpoint[endpoints.size()]);
}
}