You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by ch...@apache.org on 2012/11/19 23:31:05 UTC
svn commit: r1411462 [2/2] - in /airavata/trunk/modules:
airavata-client/src/main/java/org/apache/airavata/client/
airavata-client/src/main/java/org/apache/airavata/client/impl/
rest/client/src/main/java/org/apache/airavata/rest/client/
Added: airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/RegistryClient.java
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/RegistryClient.java?rev=1411462&view=auto
==============================================================================
--- airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/RegistryClient.java (added)
+++ airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/RegistryClient.java Mon Nov 19 22:31:01 2012
@@ -0,0 +1,784 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.apache.airavata.rest.client;
+
+import org.apache.airavata.common.utils.Version;
+import org.apache.airavata.commons.gfac.type.ApplicationDeploymentDescription;
+import org.apache.airavata.commons.gfac.type.HostDescription;
+import org.apache.airavata.commons.gfac.type.ServiceDescription;
+import org.apache.airavata.registry.api.*;
+import org.apache.airavata.registry.api.exception.RegistryException;
+import org.apache.airavata.registry.api.exception.gateway.*;
+import org.apache.airavata.registry.api.exception.worker.*;
+import org.apache.airavata.registry.api.workflow.*;
+import org.apache.airavata.rest.utils.Callback;
+
+import java.net.URI;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+public class RegistryClient extends AiravataRegistry2 {
+ private BasicRegistryResourceClient basicRegistryResourceClient;
+ private ConfigurationResourceClient configurationResourceClient;
+ private DescriptorResourceClient descriptorResourceClient;
+ private ExperimentResourceClient experimentResourceClient;
+ private ProjectResourceClient projectResourceClient;
+ private ProvenanceResourceClient provenanceResourceClient;
+ private PublishedWorkflowResourceClient publishedWorkflowResourceClient;
+ private UserWorkflowResourceClient userWorkflowResourceClient;
+
+ public RegistryClient(String userName, Callback callback) {
+ basicRegistryResourceClient = new BasicRegistryResourceClient(userName, callback);
+ configurationResourceClient = new ConfigurationResourceClient(userName, callback);
+ descriptorResourceClient = new DescriptorResourceClient(userName, callback);
+ experimentResourceClient = new ExperimentResourceClient(userName, callback);
+ projectResourceClient = new ProjectResourceClient(userName, callback);
+ provenanceResourceClient = new ProvenanceResourceClient(userName, callback);
+ publishedWorkflowResourceClient = new PublishedWorkflowResourceClient(userName, callback);
+ userWorkflowResourceClient = new UserWorkflowResourceClient(userName, callback);
+ }
+
+ public BasicRegistryResourceClient getBasicRegistryResourceClient() {
+ return basicRegistryResourceClient;
+ }
+
+ public ConfigurationResourceClient getConfigurationResourceClient() {
+ return configurationResourceClient;
+ }
+
+ public DescriptorResourceClient getDescriptorResourceClient() {
+ return descriptorResourceClient;
+ }
+
+ public ExperimentResourceClient getExperimentResourceClient() {
+ return experimentResourceClient;
+ }
+
+ public ProjectResourceClient getProjectResourceClient() {
+ return projectResourceClient;
+ }
+
+ public ProvenanceResourceClient getProvenanceResourceClient() {
+ return provenanceResourceClient;
+ }
+
+ public PublishedWorkflowResourceClient getPublishedWorkflowResourceClient() {
+ return publishedWorkflowResourceClient;
+ }
+
+ public UserWorkflowResourceClient getUserWorkflowResourceClient() {
+ return userWorkflowResourceClient;
+ }
+
+ public void setBasicRegistryResourceClient(BasicRegistryResourceClient basicRegistryResourceClient) {
+ this.basicRegistryResourceClient = basicRegistryResourceClient;
+ }
+
+ public void setConfigurationResourceClient(ConfigurationResourceClient configurationResourceClient) {
+ this.configurationResourceClient = configurationResourceClient;
+ }
+
+ public void setDescriptorResourceClient(DescriptorResourceClient descriptorResourceClient) {
+ this.descriptorResourceClient = descriptorResourceClient;
+ }
+
+ public void setExperimentResourceClient(ExperimentResourceClient experimentResourceClient) {
+ this.experimentResourceClient = experimentResourceClient;
+ }
+
+ public void setProjectResourceClient(ProjectResourceClient projectResourceClient) {
+ this.projectResourceClient = projectResourceClient;
+ }
+
+ public void setProvenanceResourceClient(ProvenanceResourceClient provenanceResourceClient) {
+ this.provenanceResourceClient = provenanceResourceClient;
+ }
+
+ public void setPublishedWorkflowResourceClient(PublishedWorkflowResourceClient publishedWorkflowResourceClient) {
+ this.publishedWorkflowResourceClient = publishedWorkflowResourceClient;
+ }
+
+ public void setUserWorkflowResourceClient(UserWorkflowResourceClient userWorkflowResourceClient) {
+ this.userWorkflowResourceClient = userWorkflowResourceClient;
+ }
+
+ @Override
+ protected void initialize() {
+ //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ @Override
+ public Object getConfiguration(String key) {
+ return getConfigurationResourceClient().getConfiguration(key);
+ }
+
+ @Override
+ public List<Object> getConfigurationList(String key) {
+ return getConfigurationResourceClient().getConfigurationList(key);
+ }
+
+ @Override
+ public void setConfiguration(String key, String value, Date expire) {
+ getConfigurationResourceClient().setConfiguration(key, value, expire);
+ }
+
+ @Override
+ public void addConfiguration(String key, String value, Date expire) {
+ getConfigurationResourceClient().addConfiguration(key, value, expire);
+ }
+
+ @Override
+ public void removeAllConfiguration(String key) {
+ getConfigurationResourceClient().removeAllConfiguration(key);
+ }
+
+ @Override
+ public void removeConfiguration(String key, String value) {
+ getConfigurationResourceClient().removeConfiguration(key, value);
+ }
+
+ @Override
+ public List<URI> getGFacURIs() {
+ return getConfigurationResourceClient().getGFacURIs();
+ }
+
+ @Override
+ public List<URI> getWorkflowInterpreterURIs() {
+ return getConfigurationResourceClient().getWorkflowInterpreterURIs();
+ }
+
+ @Override
+ public URI getEventingServiceURI() {
+ return getConfigurationResourceClient().getEventingURI();
+ }
+
+ @Override
+ public URI getMessageBoxURI() {
+ return getConfigurationResourceClient().getMsgBoxURI();
+ }
+
+ @Override
+ public void addGFacURI(URI uri) {
+ getConfigurationResourceClient().addGFacURI(uri);
+ }
+
+ @Override
+ public void addWorkflowInterpreterURI(URI uri) {
+ getConfigurationResourceClient().addWFInterpreterURI(uri);
+ }
+
+ @Override
+ public void setEventingURI(URI uri) {
+ getConfigurationResourceClient().setEventingURI(uri);
+ }
+
+ @Override
+ public void setMessageBoxURI(URI uri) {
+ getConfigurationResourceClient().setMessageBoxURI(uri);
+ }
+
+ @Override
+ public void addGFacURI(URI uri, Date expire) {
+ getConfigurationResourceClient().addGFacURIByDate(uri, expire);
+ }
+
+ @Override
+ public void addWorkflowInterpreterURI(URI uri, Date expire) {
+ getConfigurationResourceClient().addWorkflowInterpreterURI(uri, expire);
+ }
+
+ @Override
+ public void setEventingURI(URI uri, Date expire) {
+ getConfigurationResourceClient().setEventingURIByDate(uri, expire);
+ }
+
+ @Override
+ public void setMessageBoxURI(URI uri, Date expire) {
+ getConfigurationResourceClient().setMessageBoxURIByDate(uri, expire);
+ }
+
+ @Override
+ public void removeGFacURI(URI uri) {
+ getConfigurationResourceClient().removeGFacURI(uri);
+ }
+
+ @Override
+ public void removeAllGFacURI() {
+ getConfigurationResourceClient().removeAllGFacURI();
+ }
+
+ @Override
+ public void removeWorkflowInterpreterURI(URI uri) {
+ getConfigurationResourceClient().removeWorkflowInterpreterURI(uri);
+ }
+
+ @Override
+ public void removeAllWorkflowInterpreterURI() {
+ getConfigurationResourceClient().removeAllWorkflowInterpreterURI();
+ }
+
+ @Override
+ public void unsetEventingURI() {
+ getConfigurationResourceClient().unsetEventingURI();
+ }
+
+ @Override
+ public void unsetMessageBoxURI() {
+ getConfigurationResourceClient().unsetMessageBoxURI();
+ }
+
+ @Override
+ public boolean isHostDescriptorExists(String descriptorName) throws RegistryException {
+ return getDescriptorResourceClient().isHostDescriptorExists(descriptorName);
+ }
+
+ @Override
+ public void addHostDescriptor(HostDescription descriptor) throws DescriptorAlreadyExistsException, RegistryException {
+ getDescriptorResourceClient().addHostDescriptor(descriptor);
+ }
+
+ @Override
+ public void updateHostDescriptor(HostDescription descriptor) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().updateHostDescriptor(descriptor);
+ }
+
+ @Override
+ public HostDescription getHostDescriptor(String hostName) throws DescriptorDoesNotExistsException, MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getHostDescriptor(hostName);
+ }
+
+ @Override
+ public void removeHostDescriptor(String hostName) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().removeHostDescriptor(hostName);
+ }
+
+ @Override
+ public List<HostDescription> getHostDescriptors() throws MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getHostDescriptors();
+ }
+
+ @Override
+ public ResourceMetadata getHostDescriptorMetadata(String hostName) throws DescriptorDoesNotExistsException, RegistryException {
+ return null;
+ }
+
+ @Override
+ public boolean isServiceDescriptorExists(String descriptorName) throws RegistryException {
+ return getDescriptorResourceClient().isServiceDescriptorExists(descriptorName);
+ }
+
+ @Override
+ public void addServiceDescriptor(ServiceDescription descriptor) throws DescriptorAlreadyExistsException, RegistryException {
+ getDescriptorResourceClient().addServiceDescriptor(descriptor);
+ }
+
+ @Override
+ public void updateServiceDescriptor(ServiceDescription descriptor) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().updateServiceDescriptor(descriptor);
+ }
+
+ @Override
+ public ServiceDescription getServiceDescriptor(String serviceName) throws DescriptorDoesNotExistsException, MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getServiceDescriptor(serviceName);
+ }
+
+ @Override
+ public void removeServiceDescriptor(String serviceName) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().removeServiceDescriptor(serviceName);
+ }
+
+ @Override
+ public List<ServiceDescription> getServiceDescriptors() throws MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getServiceDescriptors();
+ }
+
+ @Override
+ public ResourceMetadata getServiceDescriptorMetadata(String serviceName) throws DescriptorDoesNotExistsException, RegistryException {
+ return null;
+ }
+
+ @Override
+ public boolean isApplicationDescriptorExists(String serviceName, String hostName, String descriptorName) throws RegistryException {
+ return getDescriptorResourceClient().isApplicationDescriptorExists(serviceName, hostName, descriptorName);
+ }
+
+ @Override
+ public void addApplicationDescriptor(ServiceDescription serviceDescription, HostDescription hostDescriptor, ApplicationDeploymentDescription descriptor) throws DescriptorAlreadyExistsException, RegistryException {
+ getDescriptorResourceClient().addApplicationDescriptor(serviceDescription, hostDescriptor, descriptor);
+ }
+
+ @Override
+ public void addApplicationDescriptor(String serviceName, String hostName, ApplicationDeploymentDescription descriptor) throws DescriptorAlreadyExistsException, RegistryException {
+ getDescriptorResourceClient().addApplicationDescriptor(serviceName, hostName, descriptor);
+ }
+
+ @Override
+ public void udpateApplicationDescriptor(ServiceDescription serviceDescription, HostDescription hostDescriptor, ApplicationDeploymentDescription descriptor) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().udpateApplicationDescriptor(serviceDescription, hostDescriptor, descriptor);
+ }
+
+ @Override
+ public void updateApplicationDescriptor(String serviceName, String hostName, ApplicationDeploymentDescription descriptor) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().updateApplicationDescriptor(serviceName, hostName, descriptor);
+ }
+
+ @Override
+ public ApplicationDeploymentDescription getApplicationDescriptor(String serviceName, String hostname, String applicationName) throws DescriptorDoesNotExistsException, MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getApplicationDescriptor(serviceName, hostname, applicationName);
+ }
+
+ @Override
+ public ApplicationDeploymentDescription getApplicationDescriptors(String serviceName, String hostname) throws MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getApplicationDescriptors(serviceName, hostname);
+ }
+
+ @Override
+ public Map<String, ApplicationDeploymentDescription> getApplicationDescriptors(String serviceName) throws MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getApplicationDescriptors(serviceName);
+ }
+
+ @Override
+ public Map<String[], ApplicationDeploymentDescription> getApplicationDescriptors() throws MalformedDescriptorException, RegistryException {
+ return getDescriptorResourceClient().getApplicationDescriptors();
+ }
+
+ @Override
+ public void removeApplicationDescriptor(String serviceName, String hostName, String applicationName) throws DescriptorDoesNotExistsException, RegistryException {
+ getDescriptorResourceClient().removeApplicationDescriptor(serviceName, hostName, applicationName);
+ }
+
+ @Override
+ public ResourceMetadata getApplicationDescriptorMetadata(String serviceName, String hostName, String applicationName) throws DescriptorDoesNotExistsException, RegistryException {
+ return null;
+ }
+
+ @Override
+ public boolean isWorkspaceProjectExists(String projectName) throws RegistryException {
+ return getProjectResourceClient().isWorkspaceProjectExists(projectName);
+ }
+
+ @Override
+ public boolean isWorkspaceProjectExists(String projectName, boolean createIfNotExists) throws RegistryException {
+ return getProjectResourceClient().isWorkspaceProjectExists(projectName, createIfNotExists);
+ }
+
+ @Override
+ public void addWorkspaceProject(WorkspaceProject project) throws WorkspaceProjectAlreadyExistsException, RegistryException {
+ getProjectResourceClient().addWorkspaceProject(project);
+ }
+
+ @Override
+ public void updateWorkspaceProject(WorkspaceProject project) throws WorkspaceProjectDoesNotExistsException, RegistryException {
+ getProjectResourceClient().updateWorkspaceProject(project);
+ }
+
+ @Override
+ public void deleteWorkspaceProject(String projectName) throws WorkspaceProjectDoesNotExistsException, RegistryException {
+ getProjectResourceClient().deleteWorkspaceProject(projectName);
+ }
+
+ @Override
+ public WorkspaceProject getWorkspaceProject(String projectName) throws WorkspaceProjectDoesNotExistsException, RegistryException {
+ return getProjectResourceClient().getWorkspaceProject(projectName);
+ }
+
+ @Override
+ public List<WorkspaceProject> getWorkspaceProjects() throws RegistryException {
+ return getProjectResourceClient().getWorkspaceProjects();
+ }
+
+ @Override
+ public void addExperiment(String projectName, AiravataExperiment experiment) throws WorkspaceProjectDoesNotExistsException, ExperimentDoesNotExistsException, RegistryException {
+ getExperimentResourceClient().addExperiment(projectName, experiment);
+ }
+
+ @Override
+ public void removeExperiment(String experimentId) throws ExperimentDoesNotExistsException {
+ getExperimentResourceClient().removeExperiment(experimentId);
+ }
+
+ @Override
+ public List<AiravataExperiment> getExperiments() throws RegistryException {
+ return getExperimentResourceClient().getExperiments();
+ }
+
+ @Override
+ public List<AiravataExperiment> getExperiments(String projectName) throws RegistryException {
+ return getExperimentResourceClient().getExperiments(projectName);
+ }
+
+ @Override
+ public List<AiravataExperiment> getExperiments(Date from, Date to) throws RegistryException {
+ return getExperimentResourceClient().getExperiments(from, to);
+ }
+
+ @Override
+ public List<AiravataExperiment> getExperiments(String projectName, Date from, Date to) throws RegistryException {
+ return getExperimentResourceClient().getExperiments(projectName, from, to);
+ }
+
+ @Override
+ public boolean isExperimentExists(String experimentId) throws RegistryException {
+ return getExperimentResourceClient().isExperimentExists(experimentId);
+ }
+
+ @Override
+ public boolean isExperimentExists(String experimentId, boolean createIfNotPresent) throws RegistryException {
+ return getExperimentResourceClient().isExperimentExists(experimentId, createIfNotPresent);
+ }
+
+ @Override
+ public void updateExperimentExecutionUser(String experimentId, String user) throws RegistryException {
+ getProvenanceResourceClient().updateExperimentExecutionUser(experimentId, user);
+ }
+
+ @Override
+ public String getExperimentExecutionUser(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentExecutionUser(experimentId);
+ }
+
+ @Override
+ public boolean isExperimentNameExist(String experimentName) throws RegistryException {
+ return getProvenanceResourceClient().isExperimentNameExist(experimentName);
+ }
+
+ @Override
+ public String getExperimentName(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentName(experimentId);
+ }
+
+ @Override
+ public void updateExperimentName(String experimentId, String experimentName) throws RegistryException {
+ getProvenanceResourceClient().updateExperimentName(experimentId, experimentName);
+ }
+
+ @Override
+ public String getExperimentMetadata(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentMetadata(experimentId);
+ }
+
+ @Override
+ public void updateExperimentMetadata(String experimentId, String metadata) throws RegistryException {
+ getProvenanceResourceClient().updateExperimentMetadata(experimentId, metadata);
+ }
+
+ @Override
+ public String getWorkflowExecutionTemplateName(String workflowInstanceId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowExecutionTemplateName(workflowInstanceId);
+ }
+
+ @Override
+ public void setWorkflowInstanceTemplateName(String workflowInstanceId, String templateName) throws RegistryException {
+ getProvenanceResourceClient().setWorkflowInstanceTemplateName(workflowInstanceId, templateName);
+ }
+
+ @Override
+ public List<WorkflowInstance> getExperimentWorkflowInstances(String experimentId) throws RegistryException {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ @Override
+ public boolean isWorkflowInstanceExists(String instanceId) throws RegistryException {
+ return getProvenanceResourceClient().isWorkflowInstanceExists(instanceId);
+ }
+
+ @Override
+ public boolean isWorkflowInstanceExists(String instanceId, boolean createIfNotPresent) throws RegistryException {
+ return getProvenanceResourceClient().isWorkflowInstanceExists(instanceId, createIfNotPresent);
+ }
+
+ @Override
+ public void updateWorkflowInstanceStatus(String instanceId, WorkflowInstanceStatus.ExecutionStatus status) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowInstanceStatus(instanceId, status);
+ }
+
+ @Override
+ public void updateWorkflowInstanceStatus(WorkflowInstanceStatus status) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowInstanceStatus(status);
+ }
+
+ @Override
+ public WorkflowInstanceStatus getWorkflowInstanceStatus(String instanceId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowInstanceStatus(instanceId);
+ }
+
+ @Override
+ public void updateWorkflowNodeInput(WorkflowInstanceNode node, String data) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeInput(node, data);
+ }
+
+ @Override
+ public void updateWorkflowNodeOutput(WorkflowInstanceNode node, String data) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeOutput(node, data);
+ }
+
+ @Override
+ public List<WorkflowNodeIOData> searchWorkflowInstanceNodeInput(String experimentIdRegEx, String workflowNameRegEx, String nodeNameRegEx) throws RegistryException {
+ return getProvenanceResourceClient().searchWorkflowInstanceNodeInput(experimentIdRegEx, workflowNameRegEx, nodeNameRegEx);
+ }
+
+ @Override
+ public List<WorkflowNodeIOData> searchWorkflowInstanceNodeOutput(String experimentIdRegEx, String workflowNameRegEx, String nodeNameRegEx) throws RegistryException {
+ return getProvenanceResourceClient().searchWorkflowInstanceNodeOutput(experimentIdRegEx, workflowNameRegEx, nodeNameRegEx);
+ }
+
+ @Override
+ public List<WorkflowNodeIOData> getWorkflowInstanceNodeInput(String workflowInstanceId, String nodeType) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowInstanceNodeInput(workflowInstanceId, nodeType);
+ }
+
+ @Override
+ public List<WorkflowNodeIOData> getWorkflowInstanceNodeOutput(String workflowInstanceId, String nodeType) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowInstanceNodeOutput(workflowInstanceId, nodeType);
+ }
+
+ @Override
+ public void saveWorkflowExecutionOutput(String experimentId, String outputNodeName, String output) throws RegistryException {
+ getProvenanceResourceClient().saveWorkflowExecutionOutput(experimentId, outputNodeName, output);
+ }
+
+ @Override
+ public void saveWorkflowExecutionOutput(String experimentId, WorkflowIOData data) throws RegistryException {
+ getProvenanceResourceClient().saveWorkflowExecutionOutput(experimentId, data);
+ }
+
+ @Override
+ public WorkflowIOData getWorkflowExecutionOutput(String experimentId, String outputNodeName) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowExecutionOutput(experimentId, outputNodeName);
+ }
+
+ @Override
+ public List<WorkflowIOData> getWorkflowExecutionOutput(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowExecutionOutput(experimentId);
+ }
+
+ @Override
+ public String[] getWorkflowExecutionOutputNames(String exeperimentId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowExecutionOutputNames(exeperimentId);
+ }
+
+ @Override
+ public ExperimentData getExperiment(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getExperiment(experimentId);
+ }
+
+ @Override
+ public ExperimentData getExperimentMetaInformation(String experimentId) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentMetaInformation(experimentId);
+ }
+
+ @Override
+ public List<ExperimentData> getAllExperimentMetaInformation(String user) throws RegistryException {
+ return getProvenanceResourceClient().getAllExperimentMetaInformation(user);
+ }
+
+ @Override
+ public List<ExperimentData> searchExperiments(String user, String experimentNameRegex) throws RegistryException {
+ return getProvenanceResourceClient().searchExperiments(user, experimentNameRegex);
+ }
+
+ @Override
+ public List<String> getExperimentIdByUser(String user) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentIdByUser(user);
+ }
+
+ @Override
+ public List<ExperimentData> getExperimentByUser(String user) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentByUser(user);
+ }
+
+ @Override
+ public List<ExperimentData> getExperimentByUser(String user, int pageSize, int pageNo) throws RegistryException {
+ return getProvenanceResourceClient().getExperimentByUser(user, pageSize, pageNo);
+ }
+
+ @Override
+ public void updateWorkflowNodeStatus(WorkflowInstanceNodeStatus workflowStatusNode) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeStatus(workflowStatusNode);
+ }
+
+ @Override
+ public void updateWorkflowNodeStatus(String workflowInstanceId, String nodeId, WorkflowInstanceStatus.ExecutionStatus status) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeStatus(workflowInstanceId, nodeId, status);
+ }
+
+ @Override
+ public void updateWorkflowNodeStatus(WorkflowInstanceNode workflowNode, WorkflowInstanceStatus.ExecutionStatus status) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeStatus(workflowNode, status);
+ }
+
+ @Override
+ public WorkflowInstanceNodeStatus getWorkflowNodeStatus(WorkflowInstanceNode workflowNode) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowNodeStatus(workflowNode);
+ }
+
+ @Override
+ public Date getWorkflowNodeStartTime(WorkflowInstanceNode workflowNode) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowNodeStartTime(workflowNode);
+ }
+
+ @Override
+ public Date getWorkflowStartTime(WorkflowInstance workflowInstance) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowStartTime(workflowInstance);
+ }
+
+ @Override
+ public void updateWorkflowNodeGramData(WorkflowNodeGramData workflowNodeGramData) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeGramData(workflowNodeGramData);
+ }
+
+ @Override
+ public WorkflowInstanceData getWorkflowInstanceData(String workflowInstanceId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowInstanceData(workflowInstanceId);
+ }
+
+ @Override
+ public boolean isWorkflowInstanceNodePresent(String workflowInstanceId, String nodeId) throws RegistryException {
+ return getProvenanceResourceClient().isWorkflowInstanceNodePresent(workflowInstanceId, nodeId);
+ }
+
+ @Override
+ public boolean isWorkflowInstanceNodePresent(String workflowInstanceId, String nodeId, boolean createIfNotPresent) throws RegistryException {
+ return getProvenanceResourceClient().isWorkflowInstanceNodePresent(workflowInstanceId, nodeId, createIfNotPresent);
+ }
+
+ @Override
+ public WorkflowInstanceNodeData getWorkflowInstanceNodeData(String workflowInstanceId, String nodeId) throws RegistryException {
+ return getProvenanceResourceClient().getWorkflowInstanceNodeData(workflowInstanceId, nodeId);
+ }
+
+ @Override
+ public void addWorkflowInstance(String experimentId, String workflowInstanceId, String templateName) throws RegistryException {
+ getProvenanceResourceClient().addWorkflowInstance(experimentId, workflowInstanceId, templateName);
+ }
+
+ @Override
+ public void updateWorkflowNodeType(WorkflowInstanceNode node, WorkflowNodeType type) throws RegistryException {
+ getProvenanceResourceClient().updateWorkflowNodeType(node, type);
+ }
+
+ @Override
+ public void addWorkflowInstanceNode(String workflowInstance, String nodeId) throws RegistryException {
+ getProvenanceResourceClient().addWorkflowInstanceNode(workflowInstance, nodeId);
+ }
+
+ @Override
+ public boolean isPublishedWorkflowExists(String workflowName) throws RegistryException {
+ return getPublishedWorkflowResourceClient().isPublishedWorkflowExists(workflowName);
+ }
+
+ @Override
+ public void publishWorkflow(String workflowName, String publishWorkflowName) throws PublishedWorkflowAlreadyExistsException, UserWorkflowDoesNotExistsException, RegistryException {
+ getPublishedWorkflowResourceClient().publishWorkflow(workflowName, publishWorkflowName);
+ }
+
+ @Override
+ public void publishWorkflow(String workflowName) throws PublishedWorkflowAlreadyExistsException, UserWorkflowDoesNotExistsException, RegistryException {
+ getPublishedWorkflowResourceClient().publishWorkflow(workflowName);
+ }
+
+ @Override
+ public String getPublishedWorkflowGraphXML(String workflowName) throws PublishedWorkflowDoesNotExistsException, RegistryException {
+ return getPublishedWorkflowResourceClient().getPublishedWorkflowGraphXML(workflowName);
+ }
+
+ @Override
+ public List<String> getPublishedWorkflowNames() throws RegistryException {
+ return getPublishedWorkflowResourceClient().getPublishedWorkflowNames();
+ }
+
+ @Override
+ public Map<String, String> getPublishedWorkflows() throws RegistryException {
+ return getPublishedWorkflowResourceClient().getPublishedWorkflows();
+ }
+
+ @Override
+ public ResourceMetadata getPublishedWorkflowMetadata(String workflowName) throws RegistryException {
+ return getPublishedWorkflowResourceClient().getPublishedWorkflowMetadata(workflowName);
+ }
+
+ @Override
+ public void removePublishedWorkflow(String workflowName) throws PublishedWorkflowDoesNotExistsException, RegistryException {
+ getUserWorkflowResourceClient().removeWorkflow(workflowName);
+ }
+
+ @Override
+ public boolean isWorkflowExists(String workflowName) throws RegistryException {
+ return getUserWorkflowResourceClient().isWorkflowExists(workflowName);
+ }
+
+ @Override
+ public void addWorkflow(String workflowName, String workflowGraphXml) throws UserWorkflowAlreadyExistsException, RegistryException {
+ getUserWorkflowResourceClient().addWorkflow(workflowName, workflowGraphXml);
+ }
+
+ @Override
+ public void updateWorkflow(String workflowName, String workflowGraphXml) throws UserWorkflowDoesNotExistsException, RegistryException {
+ getUserWorkflowResourceClient().updateWorkflow(workflowName, workflowGraphXml);
+ }
+
+ @Override
+ public String getWorkflowGraphXML(String workflowName) throws UserWorkflowDoesNotExistsException, RegistryException {
+ return getUserWorkflowResourceClient().getWorkflowGraphXML(workflowName);
+ }
+
+ @Override
+ public Map<String, String> getWorkflows() throws RegistryException {
+ return getUserWorkflowResourceClient().getWorkflows();
+ }
+
+ @Override
+ public ResourceMetadata getWorkflowMetadata(String workflowName) throws RegistryException {
+ return getUserWorkflowResourceClient().getWorkflowMetadata(workflowName);
+ }
+
+ @Override
+ public void removeWorkflow(String workflowName) throws UserWorkflowDoesNotExistsException, RegistryException {
+ getUserWorkflowResourceClient().removeWorkflow(workflowName);
+ }
+
+ @Override
+ public void setAiravataRegistry(AiravataRegistry2 registry) {
+ //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ @Override
+ public void setAiravataUser(AiravataUser user) {
+ getBasicRegistryResourceClient().setUser(user);
+ }
+
+ @Override
+ public AiravataUser getAiravataUser() {
+ return getBasicRegistryResourceClient().getUser();
+ }
+
+ @Override
+ public boolean isActive() {
+ return false; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ @Override
+ public Version getVersion() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+}
Modified: airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/UserWorkflowResourceClient.java
URL: http://svn.apache.org/viewvc/airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/UserWorkflowResourceClient.java?rev=1411462&r1=1411461&r2=1411462&view=diff
==============================================================================
--- airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/UserWorkflowResourceClient.java (original)
+++ airavata/trunk/modules/rest/client/src/main/java/org/apache/airavata/rest/client/UserWorkflowResourceClient.java Mon Nov 19 22:31:01 2012
@@ -28,6 +28,7 @@ import com.sun.jersey.api.client.config.
import com.sun.jersey.api.client.config.DefaultClientConfig;
import com.sun.jersey.api.json.JSONConfiguration;
import com.sun.jersey.core.util.MultivaluedMapImpl;
+import org.apache.airavata.registry.api.ResourceMetadata;
import org.apache.airavata.rest.mappings.resourcemappings.Workflow;
import org.apache.airavata.rest.mappings.resourcemappings.WorkflowList;
import org.apache.airavata.rest.mappings.utils.ResourcePathConstants;
@@ -227,4 +228,9 @@ public class UserWorkflowResourceClient
}
}
+ public ResourceMetadata getWorkflowMetadata(String workflowName) {
+ //not implemented in the registry API
+ return null;
+ }
+
}