/*
* 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.registry.ws.api;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.CarbonConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.registry.common.services.RegistryAbstractAdmin;
import org.wso2.carbon.registry.core.*;
import org.wso2.carbon.registry.core.config.RegistryContext;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.registry.core.session.UserRegistry;
import org.wso2.carbon.registry.ws.api.utils.CommonUtil;
import org.wso2.carbon.registry.ws.api.internal.WSDataHolder;
import org.wso2.carbon.utils.ServerConstants;
import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.*;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings({"unused", "deprecation"})
public class WSRegistry extends RegistryAbstractAdmin implements Registry {
private Log log = LogFactory.getLog(WSRegistry.class);
private static final String REGISTRY_WS_API_TENANT = "registry.ws.api.tenant";
private String workingDir = System.getProperty(ServerConstants.WORK_DIR);
private File tempFile;
/**
* Constructs a new Registry WS API instance. Only to be used by a web service client. This is used by
* the Registry Web Service client.
* @throws RegistryException
*/
public WSRegistry() throws RegistryException {
try {
tempFile = File.createTempFile("wsresource", ".tmp");
tempFile.deleteOnExit();
} catch (IOException e) {
throw new RegistryException("Not able to create temp files. Check permissions", e);
}
}
private Registry getRegistryForTenant() {
Registry registry = getRootRegistry();
HttpSession httpSession = ((HttpServletRequest) MessageContext.getCurrentMessageContext().getProperty(
HTTPConstants.MC_HTTP_SERVLETREQUEST)).getSession();
RegistryService registryService = WSDataHolder.getInstance().getRegistryService();
if (httpSession != null && registryService != null) {
if (PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId() ==
MultitenantConstants.SUPER_TENANT_ID) {
try {
Object tenantId = httpSession.getAttribute(REGISTRY_WS_API_TENANT);
if (tenantId != null) {
return registryService.getRegistry(
CarbonConstants.REGISTRY_SYSTEM_USERNAME, (Integer) tenantId);
}
} catch (Exception ignored) {
// We are not bothered about any errors in here.
}
}
}
return registry;
}
public Resource newResource() throws RegistryException{
return getRegistryForTenant().newResource();
}
public Collection newCollection() throws RegistryException{
return getRegistryForTenant().newCollection();
}
/**
* Returns a new WSResource instance. This method is not used by the Registry Web Service client to avoid an unnecessary network call. It
* is only there for completeness of the Registry interface. A new Resource instance can be created directly from the client side.
* @return WSResource instance
* @throws RegistryException
*/
public WSResource WSnewResource()throws RegistryException{
Resource resource = getRegistryForTenant().newResource();
return CommonUtil.newResourcetoWSResource(resource);
}
/**
* Returns a new WSCollection instance. This method is not used by the Registry Web Service client to avoid an unnecessary network call. It
* is only there for completeness of the Registry interface. A new Collection instance can be created directly from the client side.
*
* @return WSResource instance
* @throws RegistryException
*/
public WSCollection WSnewCollection()throws RegistryException{
Collection collection = getRegistryForTenant().newCollection();
return CommonUtil.newCollectiontoWSCollection(collection);
}
public Resource get(String path) throws RegistryException{
return getRegistryForTenant().get(path);
}
/**
* Returns the resource at the given path.
*
* @param path Path of the resource. e.g. /project1/server/deployment.xml
* @return WSResource instance
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
* is thrown if the resource is not in the registry
*/
public WSResource WSget(String path) throws RegistryException {
Resource resource = getRegistryForTenant().get(path);
DataHandler dataHandler = null;
if (resource instanceof Collection) {
return CommonUtil.transformCollectiontoWSCollection((Collection) resource, dataHandler);
}
return CommonUtil.transformResourceToWSResource(resource, dataHandler);
}
public Resource getMetaData(String path) throws RegistryException{
return getRegistryForTenant().getMetaData(path);
}
public String importResource(String s, String s1,
org.wso2.carbon.registry.api.Resource resource)
throws org.wso2.carbon.registry.api.RegistryException {
return importResource(s, s1, (Resource) resource);
}
/**
* Returns the meta data of the resource at the given path.
*
* @param path Path of the resource. e.g. /project1/server/deployment.xml
* @return WSResource instance
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
* is thrown if the resource is not in the registry
*/
public WSResource WSgetMetaData(String path) throws RegistryException{
Resource resource = getRegistryForTenant().getMetaData(path);
DataHandler dataHandler = null;
try {
dataHandler = CommonUtil.makeDataHandler(resource, tempFile);
} catch (IOException e) {
log.error("WSGet failed - Unable to generate temp file", e);
}
return CommonUtil.transformResourceToWSResource(resource, dataHandler);
}
public Collection get(String path, int start, int pageSize) throws RegistryException{
return getRegistryForTenant().get(path,start,pageSize);
}
public Collection getChildCollection(String path, int start, int pageSize) throws RegistryException{
return getRegistryForTenant().get(path,start,pageSize);
}
/**
* Returns the WSCollection according to the Collection at the given path, with the content paginated according to
* the arguments.
*
* @param path the path of the collection. MUST point to a collection!
* @param start the initial index of the child to return. If there are fewer children than
* the specified value, a RegistryException will be thrown.
* @param pageSize the maximum number of results to return
* @return a Collection containing the specified results in the content
* @throws RegistryException if the resource is not found, or if the path does not
* reference a Collection, or if the start index is greater than
* the number of children.
*/
public WSCollection WSgetWithPageSize(String path, int start, int pageSize) throws RegistryException{
Collection collection = getRegistryForTenant().get(path,start,pageSize);
DataHandler dataHandler = null;
// try {
// dataHandler = CommonUtil.makeDataHandler(collection, tempFile);
// } catch (IOException e) {
// log.error("WSGet failed - Unable to generate temp file", e);
// }
return CommonUtil.transformCollectiontoWSCollection(collection, dataHandler);
}
public WSCollection WSgetChildCollection(String path, int start, int pageSize) throws RegistryException{
Collection collection = getRegistryForTenant().get(path,start,pageSize);
DataHandler dataHandler = null;
// try {
// dataHandler = CommonUtil.makeDataHandler(collection, tempFile);
// } catch (IOException e) {
// log.error("WSGet failed - Unable to generate temp file", e);
// }
return CommonUtil.transformCollectiontoWSCollection(collection, dataHandler);
}
/**
* Check whether a resource exists at the given path
*
* @param path Path of the resource to be checked
* @return true if a resource exists at the given path, false otherwise.
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
* if an error occurs
*/
public boolean resourceExists(String path) throws RegistryException{
return getRegistryForTenant().resourceExists(path);
}
public String put(String s, org.wso2.carbon.registry.api.Resource resource)
throws org.wso2.carbon.registry.api.RegistryException {
return put(s, (Resource) resource);
}
public String put(String suggestedPath, Resource resource) throws RegistryException{
return getRegistryForTenant().put(suggestedPath,resource);
}
/**
* Adds or updates resources in the registry. If there is no resource at the given path,
* resource is added. If a resource already exist at the given path, it will be replaced with
* the new resource.
*
* @param suggestedPath the path which we'd like to use for the new resource.
* @param wsResource WSResource instance for the new resource. This will be converted to a Resource instance internally.
* @return the actual path that the server chose to use for our Resource
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
* @throws java.io.IOException
*/
public String WSput(String suggestedPath, WSResource wsResource) throws RegistryException, IOException{
Object content = CommonUtil.makeBytesFromDataHandler(wsResource);
Resource resource;
if (wsResource.isCollection()) {
resource = CommonUtil.transformWSCollectiontoCollection( wsResource, content);
}
else {
resource = CommonUtil.transformWSResourcetoResource(wsResource, content);
}
return getRegistryForTenant().put(suggestedPath,resource);
}
/**
* Deletes the resource at the given path. If the path refers to a directory, all child
* resources of the directory will also be deleted.
*
* @param path Path of the resource to be deleted.
* @throws RegistryException is thrown depending on the implementation.
*/
public void delete(String path) throws RegistryException{
getRegistryForTenant().delete(path);
}
public String importResource(String suggestedPath,
String sourceURL,
Resource metadata) throws RegistryException {
return getRegistryForTenant().importResource(suggestedPath,sourceURL,metadata);
}
/**
* Creates a resource by fetching the resource content from the given URL.
*
* @param suggestedPath path where we'd like to add the new resource. Although this path is
* specified by the caller of the method, resource may not be actually
* added at this path.
* @param sourceURL where to fetch the resource content
* @param metadata a WSResource instance containing meta data parameters
* @return actual path to the new resource
* @throws RegistryException if we couldn't get or store the new resource
*/
public String WSimportResource(String suggestedPath,
String sourceURL,
WSResource metadata) throws RegistryException {
return getRegistryForTenant().importResource(suggestedPath, sourceURL, CommonUtil.transformWSResourcetoResource(metadata, null));
}
/**
* Move or rename a resource in the registry. This is equivalent to 1) delete the resource,
* then 2) add the resource to the new location. The operation is atomic, so if it fails the
* old resource will still be there.
*
* @param currentPath current path of the resource
* @param newName where we'd like to move the reosurce
* @return the actual path for the new resource
* @throws RegistryException if something went wrong
*/
public String rename(String currentPath, String newName) throws RegistryException{
return getRegistryForTenant().rename(currentPath, newName);
}
/**
* Move or rename a resource in the registry. This is equivalent to 1) delete the resource,
* then 2) add the resource to the new location. The operation is atomic, so if it fails the
* old resource will still be there.
*
* @param currentPath current path of the resource
* @param newPath where we'd like to move the reosurce
* @return the actual path for the new resource
* @throws RegistryException if something went wrong
*/
public String move(String currentPath, String newPath) throws RegistryException{
return getRegistryForTenant().move(currentPath,newPath);
}
/**
* Copy a resource in the registry. The operation is atomic, so if the resource was a
* collection, all children and the collection would be copied in a single-go.
*
* @param sourcePath current path of the resource
* @param targetPath where we'd like to copy the resource
*
* @return the actual path for the new resource
* @throws RegistryException if something went wrong
*/
public String copy(String sourcePath, String targetPath) throws RegistryException{
return getRegistryForTenant().copy(sourcePath,targetPath);
}
/**
* Creates a new version of the resource.
*
* @param path the resource path.
*
* @throws RegistryException if something went wrong.
*/
public void createVersion(String path) throws RegistryException{
getRegistryForTenant().createVersion(path);
}
/**
* Get a list of all versions of the resource located at the given path. Version paths are
* returned in the form /projects/myresource?v=12
*
* @param path path of a current version of a resource
* @return a String array containing the individual paths of versions
* @throws RegistryException if there is an error
*/
public String[] getVersions(String path) throws RegistryException{
return getRegistryForTenant().getVersions(path);
}
/**
* Reverts a resource to a given version.
*
* @param versionPath path of the version to be reverted. It is not necessary to provide the
* path of the resource as it can be derived from the version path.
* @throws RegistryException if there is an error
*/
public void restoreVersion(String versionPath) throws RegistryException{
getRegistryForTenant().restoreVersion(versionPath);
}
////////////////////////////////////////////////////////
// Associations
////////////////////////////////////////////////////////
/**
* Adds an association stating that the resource at "associationPath" associate on the resource at
* "associationPath". Paths may be the resource paths of the current versions or paths of the old
* versions. If a path refers to the current version, it should contain the path in the form
* /c1/c2/r1. If it refers to an old version, it should be in the form /c1/c2/r1?v=2.
*
* @param sourcePath Path of the source resource
* @param targetPath Path of the target resource
* @param associationType Type of the association
* @throws RegistryException Depends on the implementation
*/
public void addAssociation(String sourcePath,
String targetPath,
String associationType) throws RegistryException{
getRegistryForTenant().addAssociation(sourcePath,targetPath,associationType);
}
/**
* To remove an association for a given resource
*
* @param sourcePath Path of the source resource
* @param targetPath Path of the target resource
* @param associationType Type of the association
* @throws RegistryException Depends on the implementation
*/
public void removeAssociation(String sourcePath,
String targetPath,
String associationType) throws RegistryException{
getRegistryForTenant().removeAssociation(sourcePath,targetPath,associationType);
}
/**
* Get all associations of the given resource. This is a chain of association starting from the
* given resource both upwards (source to destination) and downwards (destination to source). T
* his is useful to analyse how changes to other resources would affect the
* given resource.
*
* @param resourcePath Path of the resource to analyse associations.
* @return List of Association
* @throws RegistryException : If something went wrong
*/
public Association[] getAllAssociations(String resourcePath) throws RegistryException{
return getRegistryForTenant().getAllAssociations(resourcePath);
}
/**
* This is the web service friendly version of getAllAssociations(String resourcePath) method
* @param resoucePath path of resource
* @return WSAssociation
* @throws RegistryException
*/
public WSAssociation[] WSgetAllAssociations(String resoucePath) throws RegistryException {
Association[] associations = getRegistryForTenant().getAllAssociations(resoucePath);
WSAssociation[] wsAssociations = new WSAssociation[associations.length];
for (int i = 0; i < wsAssociations.length; i++) {
wsAssociations[i] = CommonUtil.transformAssociationToWSAssociation(associations[i]);
}
return wsAssociations;
}
/**
* Get all associations of the given resource for a give association type.
* This is a chain of association starting from the
* given resource both upwards (source to destination) and downwards (destination to source). T
* his is useful to analyse how changes to other resources would affect the
* given resource.
*
* @param resourcePath Path of the resource to analyse associations.
* @param associationType : Type of the association , that could be dependecy , or some other type
* @return List of Association
* @throws RegistryException : If something went wrong
*/
public Association[] getAssociations(String resourcePath, String associationType)
throws RegistryException {
return getRegistryForTenant().getAssociations(resourcePath, associationType);
}
/**
* Get all associations of the given resource for a give association type.
* This is a chain of association starting from the
* given resource both upwards (source to destination) and downwards (destination to source). T
* his is useful to analyse how changes to other resources would affect the
* given resource.
*
* @param resourcePath Path of the resource to analyse associations.
* @param associationType : Type of the association , that could be dependecy , or some other type
* @return List of Association
* @throws RegistryException : If something went wrong
*/
public WSAssociation[] WSgetAssociations(String resourcePath, String associationType)
throws RegistryException {
Association[] associations = getRegistryForTenant().getAssociations(resourcePath, associationType);
WSAssociation[] wsAssociations = new WSAssociation[associations.length];
for (int i = 0; i < wsAssociations.length; i++) {
wsAssociations[i] = CommonUtil.transformAssociationToWSAssociation(associations[i]);
}
return wsAssociations;
}
////////////////////////////////////////////////////////
// Tagging
////////////////////////////////////////////////////////
/**
* Applies the given tag to the resource in the given path. If the given tag is not defined in
* the registry, it will be defined.
*
* @param resourcePath Path of the resource to be tagged.
* @param tag Tag. Any string can be used for the tag.
* @throws RegistryException is thrown if a resource does not exist in the given path.
*/
public void applyTag(String resourcePath, String tag) throws RegistryException{
getRegistryForTenant().applyTag(resourcePath,tag);
}
public TaggedResourcePath[] getResourcePathsWithTag(String tag) throws RegistryException{
return getRegistryForTenant().getResourcePathsWithTag(tag);
}
/**
* Returns the paths of all Resources that are tagged with the given tag.
*
* @param tag the tag to search for
* @return an array of WSTaggedResourcePaths
* @throws RegistryException if an error occurs
*/
public WSTaggedResourcePath[] WSgetResourcePathsWithTag(String tag)throws RegistryException{
return CommonUtil.exchangeTaggedResourcepath(getRegistryForTenant().getResourcePathsWithTag(tag));
}
/**
* Returns all tags used for tagging the given resource.
*
* @param resourcePath Path of the resource
* @return Tags tag names
* @throws RegistryException is thrown if a resource does not exist in the given path.
*/
public Tag[] getTags(String resourcePath) throws RegistryException{
return getRegistryForTenant().getTags(resourcePath);
}
/**
* Returns all tags used for tagging the given resource.
*
* @param resourcePath Path of the resource
* @return Tags tag names
* @throws RegistryException is thrown if a resource does not exist in the given path.
*/
public WSTag[] WSgetTags(String resourcePath) throws RegistryException {
Tag[] tags = getRegistryForTenant().getTags(resourcePath);
WSTag[] wsTags = new WSTag[tags.length];
for (int i = 0; i < wsTags.length; i++) {
wsTags[i] = CommonUtil.transformTagToWSTag(tags[i]);
}
return wsTags;
}
/**
* Removes a tag on a resource. If the resource at the path is owned by the current user, all
* taggings done using the given tag will be removed. If the resource is not owned by the
* current user, only the tagging done by the current user will be removed.
*
* @param path Resource path tagged with the given tag.
* @param tag Name of the tag to be removed.
* @throws RegistryException if there's a problem
*/
public void removeTag(String path, String tag) throws RegistryException{
getRegistryForTenant().removeTag(path,tag);
}
public String addComment(String s, org.wso2.carbon.registry.api.Comment comment)
throws org.wso2.carbon.registry.api.RegistryException {
return addComment(s, (Comment) comment);
}
////////////////////////////////////////////////////////
// Comments
////////////////////////////////////////////////////////
public String addComment(String resourcePath, Comment comment) throws RegistryException{
return getRegistryForTenant().addComment(resourcePath,comment);
}
/**
* Adds a comment to a resource.
*
* @param resourcePath Path of the resource to add the comment.
* @param comment WSComment instance for the new comment. This will be converted to a Comment instance internally.
* @return the path of the new comment.
* @throws RegistryException is thrown if a resource does not exist in the given path.
*/
public String WSaddComment(String resourcePath, WSComment comment) throws RegistryException{
return getRegistryForTenant().addComment(resourcePath,CommonUtil.WSCommenttoRegistryComment(comment));
}
/**
* Change the text of an existing comment.
*
* @param commentPath path to comment resource ("..foo/r1;comment:1")
* @param text new text for the comment.
* @throws RegistryException Registry implementations may handle exceptions and throw
* RegistryException if the exception has to be propagated to the
* client.
*/
public void editComment(String commentPath, String text) throws RegistryException{
getRegistryForTenant().editComment(commentPath,text);
}
public Comment[] getComments(String resourcePath) throws RegistryException{
return getRegistryForTenant().getComments(resourcePath);
}
/**
* Get all comments for the given resource.
*
* @param resourcePath path of the resource.
* @return an array of WSComment objects.
* @throws RegistryException Registry implementations may handle exceptions and throw
* RegistryException if the exception has to be propagated to the
* client.
*/
public WSComment[] WSgetComments(String resourcePath) throws RegistryException{
Comment[] rcomment = getRegistryForTenant().getComments(resourcePath);
WSComment[] wscomment = new WSComment[rcomment.length];
for(int i=0;i<rcomment.length;i++){
wscomment[i] = new WSComment();
wscomment[i] = CommonUtil.RegistryCommenttoWSComment(rcomment[i]);
}
return wscomment;
}
/**
* Get the comment for the given comment path.
*
* @param commentPath path of the resource.
* @return a WSComment.
* @throws RegistryException Registry implementations may handle exceptions and throw
* RegistryException if the exception has to be propagated to the
* client.
*/
public WSComment WSgetSingleComment(String commentPath) throws RegistryException {
Comment comment = (Comment) getRegistryForTenant().get(commentPath);
return CommonUtil.RegistryCommenttoWSComment(comment);
}
////////////////////////////////////////////////////////
// Ratings
////////////////////////////////////////////////////////
/**
* Rate the given resource.
*
* @param resourcePath Path of the resource.
* @param rating Rating value between 1 and 5.
* @throws RegistryException Registry implementations may handle exceptions and throw
* RegistryException if the exception has to be propagated to the
* client.
*/
public void rateResource(String resourcePath, int rating) throws RegistryException{
getRegistryForTenant().rateResource(resourcePath,rating);
}
/**
* Returns the average rating for the given resource. This is the average of all ratings done by
* all users for the given resource.
*
* @param resourcePath Path of the resource.
* @return Average rating between 1 and 5.
* @throws RegistryException if an error occurs
*/
public float getAverageRating(String resourcePath) throws RegistryException{
return getRegistryForTenant().getAverageRating(resourcePath);
}
/**
* Returns the rating given to the specified resource by the given user
*
* @param path Path of the resource
* @param userName username of the user
* @return rating given by the given user
* @throws RegistryException if there is a problem
*/
public int getRating(String path, String userName) throws RegistryException{
return getRegistryForTenant().getRating(path,userName);
}
public Collection executeQuery(String path, Map parameters) throws RegistryException{
return getRegistryForTenant().executeQuery(path,parameters);
}
/**
* Executes a custom query which lives at the given path in the Registry.
*
* @param path Path of the query to execute.
* @param key an array of String containing key parameters. These should correspond with the value parameters (key -> value)
* @param value an array of String containing value parameters to the corresponding key parameters (key -> value)
* @return a Collection containing any resource paths which match the query
* @throws RegistryException depends on the implementation.
*/
public WSCollection WSexecuteQuery(String path, String[] key,String[] value) throws RegistryException{
Collection collection = getRegistryForTenant().executeQuery(path, CommonUtil.createMap(key,value));
DataHandler dataHandler = null;
// try {
// dataHandler = CommonUtil.makeDataHandler(collection, tempFile);
// } catch (IOException e) {
// log.error("WSGet failed - Unable to generate temp file", e);
// }
WSCollection wsCollection =
CommonUtil.transformCollectiontoWSCollection(collection, dataHandler);
wsCollection.setChildCount(collection.getChildCount());
wsCollection.setChildren(collection.getChildren());
return wsCollection;
}
/**
* Returns the logs of the activities occurred in the Registry.
*
* @see LogEntry Accepted values for action parameter
*
* @param resourcePath If given, only the logs related to the resource path will be returned. If
* null, logs for all resources will be returned.
* @param action Only the logs pertaining to this action will be returned. For
* acceptable values, see LogEntry.
* @param userName If given, only the logs for activities done by the given user will be
* returned. If null, logs for all users will be returned.
* @param from If given, logs for activities occurred after the given date will be
* returned. If null, there will not be a bound for the starting date.
* @param to If given, logs for activities occurred before the given date will be
* returned. If null, there will not be a bound for the ending date.
* @param recentFirst If true, returned activities will be most-recent first. If false,
* returned activities will be oldest first.
* @return Array of LogEntry objects representing the logs
* @throws RegistryException if there is a problem
*/
public LogEntry[] getLogs(String resourcePath,
int action,
String userName,
Date from,
Date to,
boolean recentFirst) throws RegistryException{
return getRegistryForTenant().getLogs(resourcePath,action,userName,from,to,recentFirst);
}
/**
* Returns the logs of the activities occurred in the Registry.
*
* @see LogEntry Accepted values for action parameter
*
* @param resourcePath If given, only the logs related to the resource path will be returned. If
* null, logs for all resources will be returned.
* @param action Only the logs pertaining to this action will be returned. For
* acceptable values, see LogEntry.
* @param userName If given, only the logs for activities done by the given user will be
* returned. If null, logs for all users will be returned.
* @param from If given, logs for activities occurred after the given date will be
* returned. If null, there will not be a bound for the starting date.
* @param to If given, logs for activities occurred before the given date will be
* returned. If null, there will not be a bound for the ending date.
* @param recentFirst If true, returned activities will be most-recent first. If false,
* returned activities will be oldest first.
* @return Array of LogEntry objects representing the logs
* @throws RegistryException if there is a problem
*/
public WSLogEntry[] WSgetLogs(String resourcePath,
int action,
String userName,
Date from,
Date to,
boolean recentFirst) throws RegistryException{
LogEntry[] entries =
getRegistryForTenant().getLogs(resourcePath,action,userName,from,to,recentFirst);
WSLogEntry[] wsEntries = new WSLogEntry[entries.length];
for (int i = 0; i < wsEntries.length; i++) {
wsEntries[i] = CommonUtil.transformLogEntryToWSLogEntry(entries[i]);
}
return wsEntries;
}
/**
* This method is not supported in WS-API
*/
public LogEntryCollection getLogCollection(String resourcePath,
int action,
String userName,
Date from,
Date to,
boolean recentFirst) throws RegistryException{
return getRegistryForTenant().getLogCollection(resourcePath,action,userName,from,to,recentFirst);
}
/**
* Get a list of the available Aspects for this Registry
* @return a String array containing available Aspect names
*/
public String [] getAvailableAspects(){
return getRegistryForTenant().getAvailableAspects();
}
/**
* Associate an Aspect with a resource.
*
* @param resourcePath Path of the resource
* @param aspect Name of the aspect
* @throws RegistryException : If some thing went wrong while doing associating the phase
*/
public void associateAspect(String resourcePath, String aspect) throws RegistryException{
getRegistryForTenant().associateAspect(resourcePath,aspect);
}
/**
* This invokes an action on a specified Aspect, which must be associated with the Resource
* at the given path.
*
* @param resourcePath Path of the resource
* @param aspectName Name of the aspect
* @param action Which action was selected - actions are aspect-specific
* @throws RegistryException if the Aspect isn't associated with the Resource, or the action
* isn't valid, or an Aspect-specific problem occurs.
*/
public void invokeAspectNoParam(String resourcePath, String aspectName, String action)
throws RegistryException{
invokeAspect(resourcePath,aspectName,action);
}
/**
* This invokes an action on a specified Aspect, which must be associated with the Resource
* at the given path.
*
* @param resourcePath Path of the resource
* @param aspectName Name of the aspect
* @param action Which action was selected - actions are aspect-specific
* @throws RegistryException if the Aspect isn't associated with the Resource, or the action
* isn't valid, or an Aspect-specific problem occurs.
*/
public void invokeAspect(String resourcePath, String aspectName, String action)
throws RegistryException{
getRegistryForTenant().invokeAspect(resourcePath,aspectName,action);
}
/**
* This invokes an action on a specified Aspect, which must be associated with the Resource
* at the given path.
*
* @param resourcePath Path of the resource
* @param aspectName Name of the aspect
* @param action Which action was selected - actions are aspect-specific
* @param keys Parameters keys to be used for the operation
* @param values Parameters values to be used for the operation
* @throws RegistryException if the Aspect isn't associated with the Resource, or the action
* isn't valid, or an Aspect-specific problem occurs.
*/
public void invokeAspectWithParam(String resourcePath, String aspectName, String action,
String[] keys, String[] values)
throws RegistryException{
Map<String, String> parameters = new HashMap<String, String>();
for (int i = 0; i < keys.length; i++) {
parameters.put(keys[i], values[i]);
}
invokeAspect(resourcePath, aspectName, action, parameters);
}
/**
* This invokes an action on a specified Aspect, which must be associated with the Resource
* at the given path.
*
* @param resourcePath Path of the resource
* @param aspectName Name of the aspect
* @param action Which action was selected - actions are aspect-specific
* @param parameters Parameters to be used for the operation
* @throws RegistryException if the Aspect isn't associated with the Resource, or the action
* isn't valid, or an Aspect-specific problem occurs.
*/
public void invokeAspect(String resourcePath, String aspectName, String action,
Map<String, String> parameters)
throws RegistryException{
getRegistryForTenant().invokeAspect(resourcePath,aspectName,action, parameters);
}
/**
* Obtain a list of the available actions on a given resource for a given Aspect. The
* Aspect must be associated with the Resource (@see associateAspect). The actions are
* determined by asking the Aspect itself, so they may change depending on the state of the
* Resource, the user who's asking, etc)
*
* @param resourcePath path of the Resource
* @param aspectName name of the Aspect to query for available actions
* @return a String[] of action names
* @throws RegistryException if the Aspect isn't associated or an Aspect-specific problem occurs
*/
public String[] getAspectActions(String resourcePath, String aspectName)
throws RegistryException{
return getRegistryForTenant().getAspectActions(resourcePath,aspectName);
}
public void beginTransaction() throws RegistryException{
getRegistryForTenant().beginTransaction();
}
public void commitTransaction() throws RegistryException{
getRegistryForTenant().commitTransaction();
}
public void rollbackTransaction() throws RegistryException{
getRegistryForTenant().rollbackTransaction();
}
public RegistryContext getRegistryContext(){
return getRegistryForTenant().getRegistryContext();
}
public Collection searchContent(String keywords) throws RegistryException{
throw new UnsupportedOperationException("Content search operation not supported");
}
/**
* Search the content of resources
*
* @param keywords keywords to look for
* @return the result set as a WSCollection
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
*/
public WSCollection WSsearchContent(String keywords) throws RegistryException{
Collection collection = getRegistryForTenant().searchContent(keywords);
DataHandler dataHandler = null;
// try {
// dataHandler = CommonUtil.makeDataHandler(collection, tempFile);
// } catch (IOException e) {
// log.error("WSGet failed - Unable to generate temp file", e);
// }
WSCollection wsCollection =
CommonUtil.transformCollectiontoWSCollection(collection, dataHandler);
wsCollection.setChildCount(collection.getChildCount());
wsCollection.setChildren(collection.getChildren());
return wsCollection;
}
/**
* Create a symbolic link or mount a registry
*
* @param path the mount path
* @param target the point to be mounted
*/
public void createLink(String path, String target) throws RegistryException{
getRegistryForTenant().createLink(path, target);
}
public void createLink(String path, String target, String subTargetPath)
throws RegistryException{
getRegistryForTenant().createLink(path, target, subTargetPath);
}
/**
* Create a symbolic link or mount a registy
*
* @param path the mount path
* @param target the point to be mounted
* @param subTargetPath sub path in the remote instance to be mounted
* @throws org.wso2.carbon.registry.core.exceptions.RegistryException
*/
public void createLinkWithSubTarget(String path, String target, String subTargetPath)
throws RegistryException{
if (subTargetPath == null) {
getRegistryForTenant().createLink(path, target);
}
getRegistryForTenant().createLink(path, target, subTargetPath);
}
/**
* Remove a symbolic link or mount point created
*
* @param path the mount path
*/
public void removeLink(String path) throws RegistryException{
getRegistryForTenant().removeLink(path);
}
public void restore(String path, Reader reader) throws RegistryException {
getRegistryForTenant().restore(path, reader);
}
public void wsRestore(String path, DataHandler dataHandler) throws RegistryException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
try {
dataHandler.writeTo(output);
} catch (IOException e) {
String msg = "Failed to read the input";
log.error(msg, e);
throw new RegistryException(msg, e);
}
ByteArrayInputStream inputStream = new ByteArrayInputStream(output.toByteArray());
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
restore(path, reader);
}
public void dump(String path, Writer writer) throws RegistryException {
getRegistryForTenant().dump(path, writer);
}
public DataHandler wsDump(String path) throws RegistryException {
DataHandler dataHandler = null;
try {
FileOutputStream fileOutputStream = new FileOutputStream(tempFile);
Writer writer = new OutputStreamWriter(fileOutputStream);
dump(path, writer);
writer.flush();
fileOutputStream.close();
return new DataHandler(new FileDataSource(tempFile));
} catch (IOException e) {
String msg = "get Content failed - Unable to generate temp file";
log.error(msg, e);
throw new RegistryException(msg, e);
}
}
/**
* Gets the URL of the WS-Eventing Service.
*
* @param path the path to which the WS-Eventing Service URL is required
*
* @return the URL of the WS-Eventing Service
* @throws RegistryException throws if the operation fail
*/
public String getEventingServiceURL(String path) throws RegistryException {
return getRegistryForTenant().getEventingServiceURL(path);
}
/**
* Sets the URL of the WS-Eventing Service.
*
* @param path the path to which the WS-Eventing Service URL is associated
* @param eventingServiceURL the URL of the WS-Eventing Service
*
* @throws RegistryException throws if the operation fail
*/
public void setEventingServiceURL(String path, String eventingServiceURL) throws RegistryException {
getRegistryForTenant().setEventingServiceURL(path, eventingServiceURL);
}
/**
* Remove the given aspect from registry context.
*
* @param name the name of the aspect to be removed
*
* @return return true if the operation finished successful, false otherwise.
* @throws RegistryException throws if the operation fail
*/
public boolean removeAspect(String name)throws RegistryException{
return getRegistryForTenant().removeAspect(name);
}
public boolean addAspect(String name, Aspect aspect)throws RegistryException{
return getRegistryForTenant().removeAspect(name);
}
/**
* Delete an existing comment.
*
* @param commentPath path to comment resource ("..foo/r1;comment:1")
*
* @throws RegistryException Registry implementations may handle exceptions and throw
* RegistryException if the exception has to be propagated to the
* client.
*/
public void removeComment(String commentPath) throws RegistryException {
getRegistryForTenant().removeComment(commentPath);
}
/**
* Returns content of a Resource at the specified path. Used by the Registry Web Service client to fetch resource content only when requested.
* @param path Path of the resource
* @return data handler that is compatible with web services
* @throws RegistryException
*/
// Used to provide content on demand - for resources
public DataHandler getContent(String path) throws RegistryException {
try {
String[] parts = path.split("[;]start[=]");
if (parts.length == 2) {
String[] subParts = parts[1].split("[;]pageSize[=]");
if (subParts.length == 2) {
return CommonUtil.makeDataHandler(getRegistryForTenant().get(parts[0],
Integer.parseInt(subParts[0]), Integer.parseInt(subParts[1])),
tempFile);
}
}
return CommonUtil.makeDataHandler(getRegistryForTenant().get(path), tempFile);
} catch (IOException e) {
log.error("get Content failed - Unable to generate temp file", e);
}
return null;
}
/**
* Returns content of a specific Collection. Used by the Registry Web Service client to fetch collection content only when requested.
* @param path Path of the resource
* @return String array with the content
* @throws RegistryException
*/
// Used to provide content on demand - for Collection
public String[] getCollectionContent(String path) throws RegistryException {
Object collectionContent = getRegistryForTenant().get(path).getContent();
if (!(collectionContent instanceof String[])) {
throw new RegistryException("This method only provides content for a Collection. It has been accessed by a Resource");
}
return (String[])collectionContent;
}
/**
* @param path resource path
* @return child count inside the resource
* @throws RegistryException
*/
public int getChildCount(String path) throws RegistryException {
int count = 0;
Collection collection = (Collection) getRegistryForTenant().get(path);
if (collection != null) {
count = collection.getChildCount();
}
return count;
}
public WSResourceData getAll(String path) throws RegistryException {
WSResourceData resourceData = new WSResourceData();
resourceData.setResource(WSget(path));
UserRegistry configUserRegistry = (UserRegistry)getConfigUserRegistry();
if (configUserRegistry != null) {
resourceData.setRating(getRating(path, configUserRegistry.getUserName()));
} else {
resourceData.setRating(-1);
}
resourceData.setAverageRating(getAverageRating(path));
resourceData.setTags(WSgetTags(path));
resourceData.setComments(WSgetComments(path));
resourceData.setAssociations(WSgetAllAssociations(path));
return resourceData;
}
/**
*
* @param path Path of the resource
* @param snapshotId Version ID
* @return Succeed or not
* @throws RegistryException If operation fails
*/
public boolean removeVersionHistory(String path, long snapshotId)
throws RegistryException {
return getRegistryForTenant().removeVersionHistory(path, snapshotId);
}
public void dumpLite(String s, Writer writer) throws RegistryException {
// Implementation needs to be added
}
}