/*
*
* 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.persistance.registry.jpa.impl;
import java.net.URI;
import java.net.URISyntaxException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.apache.airavata.common.exception.AiravataConfigurationException;
import org.apache.airavata.common.utils.Version;
import org.apache.airavata.commons.gfac.type.ApplicationDescription;
import org.apache.airavata.commons.gfac.type.HostDescription;
import org.apache.airavata.commons.gfac.type.ServiceDescription;
import org.apache.airavata.persistance.registry.jpa.JPAResourceAccessor;
import org.apache.airavata.persistance.registry.jpa.ResourceUtils;
import org.apache.airavata.persistance.registry.jpa.resources.ApplicationDescriptorResource;
import org.apache.airavata.persistance.registry.jpa.resources.ConfigurationResource;
import org.apache.airavata.persistance.registry.jpa.resources.ExperimentDataResource;
import org.apache.airavata.persistance.registry.jpa.resources.ExperimentDataRetriever;
import org.apache.airavata.persistance.registry.jpa.resources.ExperimentMetadataResource;
import org.apache.airavata.persistance.registry.jpa.resources.ExperimentResource;
import org.apache.airavata.persistance.registry.jpa.resources.GatewayResource;
import org.apache.airavata.persistance.registry.jpa.resources.GramDataResource;
import org.apache.airavata.persistance.registry.jpa.resources.HostDescriptorResource;
import org.apache.airavata.persistance.registry.jpa.resources.NodeDataResource;
import org.apache.airavata.persistance.registry.jpa.resources.ProjectResource;
import org.apache.airavata.persistance.registry.jpa.resources.PublishWorkflowResource;
import org.apache.airavata.persistance.registry.jpa.resources.ServiceDescriptorResource;
import org.apache.airavata.persistance.registry.jpa.resources.UserWorkflowResource;
import org.apache.airavata.persistance.registry.jpa.resources.WorkerResource;
import org.apache.airavata.persistance.registry.jpa.resources.WorkflowDataResource;
import org.apache.airavata.registry.api.*;
import org.apache.airavata.registry.api.exception.*;
import org.apache.airavata.registry.api.exception.gateway.DescriptorAlreadyExistsException;
import org.apache.airavata.registry.api.exception.gateway.DescriptorDoesNotExistsException;
import org.apache.airavata.registry.api.exception.gateway.InsufficientDataException;
import org.apache.airavata.registry.api.exception.gateway.MalformedDescriptorException;
import org.apache.airavata.registry.api.exception.gateway.PublishedWorkflowAlreadyExistsException;
import org.apache.airavata.registry.api.exception.gateway.PublishedWorkflowDoesNotExistsException;
import org.apache.airavata.registry.api.exception.worker.*;
import org.apache.airavata.registry.api.impl.WorkflowExecutionDataImpl;
import org.apache.airavata.registry.api.util.RegistryConstants;
import org.apache.airavata.registry.api.workflow.*;
import org.apache.airavata.registry.api.workflow.WorkflowExecutionStatus.State;
import org.apache.xmlbeans.XmlException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class AiravataJPARegistry extends AiravataRegistry2{
private final static Logger logger = LoggerFactory.getLogger(AiravataJPARegistry.class);
private JPAResourceAccessor jpa;
private boolean active=false;
private static final String DEFAULT_PROJECT_NAME = "default";
private static final Version API_VERSION=new Version("Airavata Registry API",0,7,null,null,null);
private URI registryConnectionURI;
private ConfigurationRegistry configurationRegistry;
private DescriptorRegistry descriptorRegistry;
private ProjectsRegistry projectsRegistry;
private ProvenanceRegistry provenanceRegistry;
private UserWorkflowRegistry userWorkflowRegistry;
private PublishedWorkflowRegistry publishedWorkflowRegistry;
private PasswordCallback callback;
@Override
protected void initialize() throws RegistryException {
jpa = new JPAResourceAccessor(this);
//TODO check if the db connections are proper & accessible & the relevant db/tables are
//present
active=true;
initializeCustomRegistries();
}
/**
* Initialize the custom registries defined in the registry settings
* @throws RegistryException
*/
private void initializeCustomRegistries() throws RegistryException {
// retrieving user defined registry classes from registry settings
try {
configurationRegistry = (ConfigurationRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.CONFIGURATION_REGISTRY_ACCESSOR_CLASS);
descriptorRegistry = (DescriptorRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.DESCRIPTOR_REGISTRY_ACCESSOR_CLASS);
projectsRegistry = (ProjectsRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.PROJECT_REGISTRY_ACCESSOR_CLASS);
provenanceRegistry = (ProvenanceRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.PROVENANCE_REGISTRY_ACCESSOR_CLASS);
userWorkflowRegistry = (UserWorkflowRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.USER_WF_REGISTRY_ACCESSOR_CLASS);
publishedWorkflowRegistry = (PublishedWorkflowRegistry)getClassInstance(ConfigurationRegistry.class,RegistryConstants.PUBLISHED_WF_REGISTRY_ACCESSOR_CLASS);
} catch (AiravataConfigurationException e) {
throw new RegistryException("An error occured when attempting to determine any custom implementations of the registries!!!", e);
}
}
private <T extends AiravataSubRegistry> Object getClassInstance(Class<T> c, String registryAccessorKey) throws AiravataConfigurationException{
try {
T registryClass = c.cast(AiravataRegistryFactory.getRegistryClass(registryAccessorKey));
registryClass.setAiravataRegistry(this);
return registryClass;
} catch (ClassCastException e){
logger.error("The class defined for accessor type "+registryAccessorKey+" MUST be an extention of the interface "+c.getName(),e);
} catch (RegistryAccessorNotFoundException e) {
logger.error("Error in loading class for registry accessor "+registryAccessorKey,e);
} catch (RegistryAccessorUndefinedException e) {
// happens when user has not defined an accessor for the registry accessor key
// thus ignore error
} catch (RegistryAccessorInstantiateException e) {
logger.error("Error in instantiating instance from class for registry accessor "+registryAccessorKey,e);
}
return null;
}
@Override
public boolean isActive() {
return active;
}
/**---------------------------------Configuration Registry----------------------------------**/
public Object getConfiguration(String key) {
ConfigurationResource configuration = ResourceUtils.getConfiguration(key);
return configuration==null? null: configuration.getConfigVal();
}
// Not sure about this.. need some description
public List<Object> getConfigurationList(String key) {
if (configurationRegistry != null){
return configurationRegistry.getConfigurationList(key);
} else {
List<Object> values = new ArrayList<Object>();
List<ConfigurationResource> configurations = ResourceUtils.getConfigurations(key);
for (ConfigurationResource configurationResource : configurations) {
values.add(configurationResource.getConfigVal());
}
return values;
}
}
public void setConfiguration(String key, String value, Date expire) {
if (configurationRegistry != null){
configurationRegistry.setConfiguration(key, value, expire);
}else {
ConfigurationResource config;
if (ResourceUtils.isConfigurationExist(key)) {
config = ResourceUtils.getConfiguration(key);
}else{
config = ResourceUtils.createConfiguration(key);
}
config.setConfigVal(value);
config.setExpireDate(new Timestamp(expire.getTime()));
config.save();
}
}
public void addConfiguration(String key, String value, Date expire) {
if (configurationRegistry != null){
configurationRegistry.addConfiguration(key, value, expire);
} else {
ConfigurationResource config = ResourceUtils.createConfiguration(key);
config.setConfigVal(value);
config.setExpireDate(new Timestamp(expire.getTime()));
config.save();
}
}
public void removeAllConfiguration(String key) {
if (configurationRegistry != null){
configurationRegistry.removeAllConfiguration(key);
} else {
ResourceUtils.removeConfiguration(key);
}
}
public void removeConfiguration(String key, String value) {
if (configurationRegistry != null){
configurationRegistry.removeConfiguration(key, value);
} else {
ResourceUtils.removeConfiguration(key, value);
}
}
private static final String GFAC_URL="gfac.url";
private static final String INTERPRETER_URL="interpreter.url";
private static final String MESSAGE_BOX_URL="messagebox.url";
private static final String EVENTING_URL="eventing.url";
public List<URI> getGFacURIs() {
if (configurationRegistry != null) {
return configurationRegistry.getGFacURIs();
} else {
return retrieveURIsFromConfiguration(GFAC_URL);
}
}
private List<URI> retrieveURIsFromConfiguration(String urlType) {
List<URI> urls=new ArrayList<URI>();
List<Object> configurationList = getConfigurationList(urlType);
for (Object o : configurationList) {
try {
urls.add(new URI(o.toString()));
} catch (URISyntaxException e) {
e.printStackTrace();
}
}
return urls;
}
public List<URI> getWorkflowInterpreterURIs() {
if (configurationRegistry != null) {
return configurationRegistry.getWorkflowInterpreterURIs();
} else {
return retrieveURIsFromConfiguration(INTERPRETER_URL);
}
}
public URI getEventingServiceURI() {
if (configurationRegistry != null) {
return configurationRegistry.getEventingServiceURI();
}else {
List<URI> eventingURLs = retrieveURIsFromConfiguration(EVENTING_URL);
return eventingURLs.size()==0? null: eventingURLs.get(0);
}
}
public URI getMessageBoxURI() {
if (configurationRegistry != null) {
return configurationRegistry.getMessageBoxURI();
}
List<URI> messageboxURLs = retrieveURIsFromConfiguration(MESSAGE_BOX_URL);
return messageboxURLs.size()==0? null: messageboxURLs.get(0);
}
public void addGFacURI(URI uri) {
if (configurationRegistry != null) {
addGFacURI(uri);
} else {
addConfigurationURL(GFAC_URL, uri);
}
}
private void addConfigurationURL(String urlType,URI uri) {
Calendar instance = Calendar.getInstance();
instance.add(Calendar.MINUTE, AiravataRegistry2.SERVICE_TTL);
Date expire = instance.getTime();
addConfigurationURL(urlType, uri, expire);
}
private void addConfigurationURL(String urlType, URI uri, Date expire) {
addConfiguration(urlType, uri.toString(), expire);
}
public void addWorkflowInterpreterURI(URI uri) {
if (configurationRegistry != null) {
configurationRegistry.addWorkflowInterpreterURI(uri);
}else {
addConfigurationURL(INTERPRETER_URL,uri);
}
}
public void setEventingURI(URI uri) {
if (configurationRegistry != null) {
configurationRegistry.setEventingURI(uri);
} else {
addConfigurationURL(EVENTING_URL,uri);
}
}
public void setMessageBoxURI(URI uri) {
if (configurationRegistry != null) {
configurationRegistry.setMessageBoxURI(uri);
} else {
addConfigurationURL(MESSAGE_BOX_URL,uri);
}
}
public void addGFacURI(URI uri, Date expire) {
if (configurationRegistry != null) {
configurationRegistry.addGFacURI(uri, expire);
} else {
addConfigurationURL(GFAC_URL, uri, expire);
}
}
public void addWorkflowInterpreterURI(URI uri, Date expire) {
if (configurationRegistry != null) {
configurationRegistry.addWorkflowInterpreterURI(uri, expire);
} else {
addConfigurationURL(INTERPRETER_URL, uri, expire);
}
}
public void setEventingURI(URI uri, Date expire) {
if (configurationRegistry != null) {
configurationRegistry.setEventingURI(uri, expire);
} else {
addConfigurationURL(EVENTING_URL, uri, expire);
}
}
public void setMessageBoxURI(URI uri, Date expire) {
if (configurationRegistry != null) {
configurationRegistry.setMessageBoxURI(uri, expire);
} else {
addConfigurationURL(MESSAGE_BOX_URL, uri, expire);
}
}
public void removeGFacURI(URI uri) {
if (configurationRegistry != null) {
configurationRegistry.removeGFacURI(uri);
} else {
removeConfiguration(GFAC_URL, uri.toString());
}
}
public void removeWorkflowInterpreterURI(URI uri) {
if (configurationRegistry != null) {
configurationRegistry.removeWorkflowInterpreterURI(uri);
} else {
removeConfiguration(INTERPRETER_URL, uri.toString());
}
}
public void removeAllGFacURI() {
if (configurationRegistry != null) {
configurationRegistry.removeAllGFacURI();
} else {
removeAllConfiguration(GFAC_URL);
}
}
public void removeAllWorkflowInterpreterURI() {
if (configurationRegistry != null) {
configurationRegistry.removeAllWorkflowInterpreterURI();
} else {
removeAllConfiguration(INTERPRETER_URL);
}
}
public void unsetEventingURI() {
if (configurationRegistry != null) {
configurationRegistry.unsetEventingURI();
} else {
removeAllConfiguration(EVENTING_URL);
}
}
public void unsetMessageBoxURI() {
if (configurationRegistry != null) {
configurationRegistry.unsetMessageBoxURI();
} else {
removeAllConfiguration(MESSAGE_BOX_URL);
}
}
/**---------------------------------Descriptor Registry----------------------------------**/
public boolean isHostDescriptorExists(String descriptorName)throws RegistryException{
if (descriptorRegistry != null){
return descriptorRegistry.isHostDescriptorExists(descriptorName);
}
return jpa.getGateway().isHostDescriptorExists(descriptorName);
}
public void addHostDescriptor(HostDescription descriptor) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.addHostDescriptor(descriptor);
} else {
GatewayResource gateway = jpa.getGateway();
WorkerResource workerResource = jpa.getWorker();
String hostName = descriptor.getType().getHostName();
if (isHostDescriptorExists(hostName)){
throw new DescriptorAlreadyExistsException(hostName);
}
HostDescriptorResource hostDescriptorResource = gateway.createHostDescriptorResource(hostName);
hostDescriptorResource.setUserName(workerResource.getUser());
hostDescriptorResource.setContent(descriptor.toXML());
hostDescriptorResource.save();
}
}
public void updateHostDescriptor(HostDescription descriptor) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.updateHostDescriptor(descriptor);
} else {
GatewayResource gateway = jpa.getGateway();
String hostName = descriptor.getType().getHostName();
if (!isHostDescriptorExists(hostName)){
throw new DescriptorDoesNotExistsException(hostName);
}
HostDescriptorResource hostDescriptorResource = gateway.getHostDescriptorResource(hostName);
hostDescriptorResource.setContent(descriptor.toXML());
hostDescriptorResource.save();
}
}
public HostDescription getHostDescriptor(String hostName) throws RegistryException {
if (descriptorRegistry != null){
return descriptorRegistry.getHostDescriptor(hostName);
} else {
GatewayResource gateway = jpa.getGateway();
if (!isHostDescriptorExists(hostName)){
return null;
}
HostDescriptorResource hostDescriptorResource = gateway.getHostDescriptorResource(hostName);
return createHostDescriptor(hostDescriptorResource);
}
}
private HostDescription createHostDescriptor(
HostDescriptorResource hostDescriptorResource)
throws MalformedDescriptorException {
try {
return HostDescription.fromXML(hostDescriptorResource.getContent());
} catch (XmlException e) {
throw new MalformedDescriptorException(hostDescriptorResource.getHostDescName(),e);
}
}
public void removeHostDescriptor(String hostName) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.removeHostDescriptor(hostName);
} else {
GatewayResource gateway = jpa.getGateway();
if (!isHostDescriptorExists(hostName)){
throw new DescriptorDoesNotExistsException(hostName);
}
gateway.removeHostDescriptor(hostName);
try {
//we need to delete the application descriptors bound to this host
Map<String, ApplicationDescription> applicationDescriptors = getApplicationDescriptorsFromHostName(hostName);
for (String serviceName : applicationDescriptors.keySet()) {
removeApplicationDescriptor(serviceName, hostName, applicationDescriptors.get(serviceName).getType().getApplicationName().getStringValue());
}
} catch (Exception e) {
logger.error("Error while removing application descriptors bound to host "+hostName, e);
}
}
}
@Override
public List<HostDescription> getHostDescriptors()
throws MalformedDescriptorException, RegistryException {
if (descriptorRegistry != null){
return descriptorRegistry.getHostDescriptors();
}
GatewayResource gateway = jpa.getGateway();
List<HostDescription> list=new ArrayList<HostDescription>();
List<HostDescriptorResource> hostDescriptorResources = gateway.getHostDescriptorResources();
for (HostDescriptorResource resource : hostDescriptorResources) {
list.add(createHostDescriptor(resource));
}
return list;
}
public ResourceMetadata getHostDescriptorMetadata(String hostName) throws RegistryException {
if (descriptorRegistry != null) {
return descriptorRegistry.getHostDescriptorMetadata(hostName);
}
//TODO
throw new UnimplementedRegistryOperationException();
}
public boolean isServiceDescriptorExists(String descriptorName)throws RegistryException{
if (descriptorRegistry != null) {
return descriptorRegistry.isServiceDescriptorExists(descriptorName);
}
return jpa.getGateway().isServiceDescriptorExists(descriptorName);
}
public void addServiceDescriptor(ServiceDescription descriptor) throws RegistryException {
if (descriptorRegistry != null) {
descriptorRegistry.addServiceDescriptor(descriptor);
}else {
GatewayResource gateway = jpa.getGateway();
WorkerResource workerResource = jpa.getWorker();
String serviceName = descriptor.getType().getName();
if (isServiceDescriptorExists(serviceName)){
throw new DescriptorAlreadyExistsException(serviceName);
}
ServiceDescriptorResource serviceDescriptorResource = gateway.createServiceDescriptorResource(serviceName);
serviceDescriptorResource.setUserName(workerResource.getUser());
serviceDescriptorResource.setContent(descriptor.toXML());
serviceDescriptorResource.save();
}
}
public void updateServiceDescriptor(ServiceDescription descriptor) throws RegistryException {
if (descriptorRegistry != null) {
descriptorRegistry.updateServiceDescriptor(descriptor);
}else {
GatewayResource gateway = jpa.getGateway();
String serviceName = descriptor.getType().getName();
if (!isServiceDescriptorExists(serviceName)){
throw new DescriptorDoesNotExistsException(serviceName);
}
ServiceDescriptorResource serviceDescriptorResource = gateway.getServiceDescriptorResource(serviceName);
serviceDescriptorResource.setContent(descriptor.toXML());
serviceDescriptorResource.save();
}
}
public ServiceDescription getServiceDescriptor(String serviceName) throws RegistryException, MalformedDescriptorException {
if (descriptorRegistry != null) {
return descriptorRegistry.getServiceDescriptor(serviceName);
}else {
GatewayResource gateway = jpa.getGateway();
if (!gateway.isServiceDescriptorExists(serviceName)){
return null;
}
ServiceDescriptorResource serviceDescriptorResource = gateway.getServiceDescriptorResource(serviceName);
return createServiceDescriptor(serviceDescriptorResource);
}
}
private ServiceDescription createServiceDescriptor(
ServiceDescriptorResource serviceDescriptorResource)
throws MalformedDescriptorException {
try {
return ServiceDescription.fromXML(serviceDescriptorResource.getContent());
} catch (XmlException e) {
throw new MalformedDescriptorException(serviceDescriptorResource.getServiceDescName(),e);
}
}
public void removeServiceDescriptor(String serviceName) throws RegistryException {
if (descriptorRegistry != null) {
descriptorRegistry.removeServiceDescriptor(serviceName);
}else {
GatewayResource gateway = jpa.getGateway();
if (!isServiceDescriptorExists(serviceName)){
throw new DescriptorDoesNotExistsException(serviceName);
}
gateway.removeServiceDescriptor(serviceName);
try {
//we need to delete the application descriptors bound to this service
Map<String, ApplicationDescription> applicationDescriptors = getApplicationDescriptors(serviceName);
for (String hostName : applicationDescriptors.keySet()) {
removeApplicationDescriptor(serviceName, hostName, applicationDescriptors.get(hostName).getType().getApplicationName().getStringValue());
}
} catch (Exception e) {
logger.error("Error while removing application descriptors bound to service "+serviceName, e);
}
}
}
@Override
public List<ServiceDescription> getServiceDescriptors()
throws MalformedDescriptorException, RegistryException {
if (descriptorRegistry != null) {
return descriptorRegistry.getServiceDescriptors();
}else {
GatewayResource gateway = jpa.getGateway();
List<ServiceDescription> list=new ArrayList<ServiceDescription>();
List<ServiceDescriptorResource> serviceDescriptorResources = gateway.getServiceDescriptorResources();
for (ServiceDescriptorResource resource : serviceDescriptorResources) {
list.add(createServiceDescriptor(resource));
}
return list;
}
}
public ResourceMetadata getServiceDescriptorMetadata(String serviceName) throws RegistryException {
if (descriptorRegistry != null) {
return descriptorRegistry.getServiceDescriptorMetadata(serviceName);
}else {
//TODO
throw new UnimplementedRegistryOperationException();
}
}
private String createAppName(String serviceName, String hostName, String applicationName){
return serviceName+"/"+hostName+"/"+applicationName;
}
public boolean isApplicationDescriptorExists(String serviceName,
String hostName,
String descriptorName)throws RegistryException{
if (descriptorRegistry != null) {
return descriptorRegistry.isApplicationDescriptorExists(serviceName, hostName, descriptorName);
}else {
return jpa.getGateway().isApplicationDescriptorExists(createAppName(serviceName, hostName, descriptorName));
}
}
public void addApplicationDescriptor(ServiceDescription serviceDescription,
HostDescription hostDescriptor,
ApplicationDescription descriptor) throws RegistryException {
if (descriptorRegistry != null) {
descriptorRegistry.addApplicationDescriptor(serviceDescription, hostDescriptor, descriptor);
}else {
addApplicationDescriptor(serviceDescription.getType().getName(), hostDescriptor.getType().getHostName(), descriptor);
}
}
public void addApplicationDescriptor(String serviceName, String hostName, ApplicationDescription descriptor) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.addApplicationDescriptor(serviceName, hostName, descriptor);
} else {
if (serviceName==null || hostName==null){
throw new InsufficientDataException("Service name or Host name cannot be null");
}
GatewayResource gateway = jpa.getGateway();
WorkerResource workerResource = jpa.getWorker();
String applicationName = descriptor.getType().getApplicationName().getStringValue();
applicationName = createAppName(serviceName, hostName, applicationName);
if (isApplicationDescriptorExists(serviceName,hostName,descriptor.getType().getApplicationName().getStringValue())){
throw new DescriptorAlreadyExistsException(applicationName);
}
ApplicationDescriptorResource applicationDescriptorResource = gateway.createApplicationDescriptorResource(applicationName);
applicationDescriptorResource.setUpdatedUser(workerResource.getUser());
applicationDescriptorResource.setServiceDescName(serviceName);
applicationDescriptorResource.setHostDescName(hostName);
applicationDescriptorResource.setContent(descriptor.toXML());
applicationDescriptorResource.save();
}
}
public void udpateApplicationDescriptor(ServiceDescription serviceDescription,
HostDescription hostDescriptor,
ApplicationDescription descriptor) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.udpateApplicationDescriptor(serviceDescription,hostDescriptor,descriptor);
} else {
updateApplicationDescriptor(serviceDescription.getType().getName(),hostDescriptor.getType().getHostName(),descriptor);
}
}
public void updateApplicationDescriptor(String serviceName, String hostName, ApplicationDescription descriptor) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.updateApplicationDescriptor(serviceName, hostName, descriptor);
} else {
if (serviceName==null || hostName==null){
throw new InsufficientDataException("Service name or Host name cannot be null");
}
GatewayResource gateway = jpa.getGateway();
String applicationName = descriptor.getType().getApplicationName().getStringValue();
applicationName = createAppName(serviceName, hostName, applicationName);
if (!isApplicationDescriptorExists(serviceName,hostName,descriptor.getType().getApplicationName().getStringValue())){
throw new DescriptorDoesNotExistsException(applicationName);
}
ApplicationDescriptorResource serviceDescriptorResource = gateway.getApplicationDescriptorResource(applicationName);
serviceDescriptorResource.setContent(descriptor.toXML());
serviceDescriptorResource.save();
}
}
private ApplicationDescription createApplicationDescriptor(
ApplicationDescriptorResource applicationDescriptorResource)
throws MalformedDescriptorException {
try {
return ApplicationDescription.fromXML(applicationDescriptorResource.getContent());
} catch (XmlException e) {
throw new MalformedDescriptorException(applicationDescriptorResource.getName(),e);
}
}
public ApplicationDescription getApplicationDescriptor(String serviceName, String hostname, String applicationName)throws DescriptorDoesNotExistsException, MalformedDescriptorException, RegistryException{
if (descriptorRegistry != null){
return descriptorRegistry.getApplicationDescriptor(serviceName, hostname, applicationName);
}
if (serviceName==null || hostname==null){
throw new InsufficientDataException("Service name or Host name cannot be null");
}
GatewayResource gateway = jpa.getGateway();
if (!isApplicationDescriptorExists(serviceName,hostname,applicationName)){
throw new DescriptorDoesNotExistsException(createAppName(serviceName, hostname, applicationName));
}
return createApplicationDescriptor(gateway.getApplicationDescriptorResource(createAppName(serviceName, hostname, applicationName)));
}
public ApplicationDescription getApplicationDescriptors(String serviceName, String hostname) throws RegistryException {
if (descriptorRegistry != null){
return descriptorRegistry.getApplicationDescriptors(serviceName, hostname);
}
GatewayResource gateway = jpa.getGateway();
List<ApplicationDescriptorResource> applicationDescriptorResources = gateway.getApplicationDescriptorResources(serviceName, hostname);
if (applicationDescriptorResources.size()>0){
return createApplicationDescriptor(applicationDescriptorResources.get(0));
}
return null;
}
public Map<String, ApplicationDescription> getApplicationDescriptors(String serviceName) throws RegistryException {
if (descriptorRegistry != null){
return descriptorRegistry.getApplicationDescriptors(serviceName);
}
GatewayResource gateway = jpa.getGateway();
Map<String, ApplicationDescription> map=new HashMap<String,ApplicationDescription>();
List<ApplicationDescriptorResource> applicationDescriptorResources = gateway.getApplicationDescriptorResources(serviceName, null);
for (ApplicationDescriptorResource resource : applicationDescriptorResources) {
map.put(resource.getHostDescName(),createApplicationDescriptor(resource));
}
return map;
}
private Map<String,ApplicationDescription> getApplicationDescriptorsFromHostName(String hostName)throws RegistryException {
GatewayResource gateway = jpa.getGateway();
Map<String, ApplicationDescription> map=new HashMap<String,ApplicationDescription>();
List<ApplicationDescriptorResource> applicationDescriptorResources = gateway.getApplicationDescriptorResources(null, hostName);
for (ApplicationDescriptorResource resource : applicationDescriptorResources) {
map.put(resource.getServiceDescName(),createApplicationDescriptor(resource));
}
return map;
}
public Map<String[],ApplicationDescription> getApplicationDescriptors()throws MalformedDescriptorException, RegistryException{
if (descriptorRegistry != null){
return descriptorRegistry.getApplicationDescriptors();
}
GatewayResource gateway = jpa.getGateway();
Map<String[], ApplicationDescription> map=new HashMap<String[],ApplicationDescription>();
List<ApplicationDescriptorResource> applicationDescriptorResources = gateway.getApplicationDescriptorResources();
for (ApplicationDescriptorResource resource : applicationDescriptorResources) {
map.put(new String[]{resource.getServiceDescName(),resource.getHostDescName()},createApplicationDescriptor(resource));
}
return map;
}
public void removeApplicationDescriptor(String serviceName, String hostName, String applicationName) throws RegistryException {
if (descriptorRegistry != null){
descriptorRegistry.removeApplicationDescriptor(serviceName, hostName, applicationName);
} else {
GatewayResource gateway = jpa.getGateway();
String appName = createAppName(serviceName, hostName, applicationName);
if (!isApplicationDescriptorExists(serviceName,hostName,applicationName)){
throw new DescriptorDoesNotExistsException(appName);
}
gateway.removeApplicationDescriptor(appName);
}
}
public ResourceMetadata getApplicationDescriptorMetadata(String serviceName, String hostName, String applicationName) throws RegistryException {
if (descriptorRegistry != null) {
return descriptorRegistry.getApplicationDescriptorMetadata(serviceName, hostName, applicationName);
}
//TODO
throw new UnimplementedRegistryOperationException();
}
/**---------------------------------Project Registry----------------------------------**/
private String createProjName(String projectName){
return createProjName(getGateway().getGatewayName(),getUser().getUserName(),projectName);
}
private String createProjName(String gatewayName, String userName, String projectName){
return gatewayName+"\n"+userName+"\n"+projectName;
}
private String getProjName(String projectLongName){
String[] s = projectLongName.split("\n");
return s[s.length-1];
}
@Override
public boolean isWorkspaceProjectExists(String projectName)
throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.isWorkspaceProjectExists(projectName);
}
return isWorkspaceProjectExists(projectName, false);
}
@Override
public boolean isWorkspaceProjectExists(String projectName,
boolean createIfNotExists) throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.isWorkspaceProjectExists(projectName, createIfNotExists);
}
if (jpa.getWorker().isProjectExists(createProjName(projectName))){
return true;
}else if (createIfNotExists){
addWorkspaceProject(new WorkspaceProject(projectName, this));
return isWorkspaceProjectExists(projectName);
}else{
return false;
}
}
public void addWorkspaceProject(WorkspaceProject project) throws RegistryException {
if (projectsRegistry != null){
projectsRegistry.addWorkspaceProject(project);
} else {
WorkerResource worker = jpa.getWorker();
if (isWorkspaceProjectExists(project.getProjectName())){
throw new WorkspaceProjectAlreadyExistsException(createProjName(project.getProjectName()));
}
ProjectResource projectResource = worker.createProject(createProjName(project.getProjectName()));
projectResource.save();
}
}
public void updateWorkspaceProject(WorkspaceProject project) throws RegistryException {
if (projectsRegistry != null){
projectsRegistry.updateWorkspaceProject(project);
}else {
WorkerResource worker = jpa.getWorker();
if (!isWorkspaceProjectExists(project.getProjectName())){
throw new WorkspaceProjectDoesNotExistsException(createProjName(project.getProjectName()));
}
ProjectResource projectResource = worker.getProject(createProjName(project.getProjectName()));
projectResource.save();
}
}
public void deleteWorkspaceProject(String projectName) throws RegistryException {
if (projectsRegistry != null){
projectsRegistry.deleteWorkspaceProject(projectName);
}else {
WorkerResource worker = jpa.getWorker();
if (!isWorkspaceProjectExists(projectName)){
throw new WorkspaceProjectDoesNotExistsException(createProjName(projectName));
}
worker.removeProject(createProjName(projectName));
}
}
public WorkspaceProject getWorkspaceProject(String projectName) throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.getWorkspaceProject(projectName);
}
WorkerResource worker = jpa.getWorker();
if (!isWorkspaceProjectExists(projectName)){
throw new WorkspaceProjectDoesNotExistsException(createProjName(projectName));
}
ProjectResource projectResource = worker.getProject(createProjName(projectName));
return new WorkspaceProject(getProjName(projectResource.getName()), this);
}
public List<WorkspaceProject> getWorkspaceProjects() throws RegistryException{
if (projectsRegistry != null){
return projectsRegistry.getWorkspaceProjects();
}
WorkerResource worker = jpa.getWorker();
List<WorkspaceProject> projects=new ArrayList<WorkspaceProject>();
List<ProjectResource> projectResouces = worker.getProjects();
for (ProjectResource resource : projectResouces) {
projects.add(new WorkspaceProject(getProjName(resource.getName()), this));
}
return projects;
}
public void addExperiment(String projectName, AiravataExperiment experiment) throws RegistryException {
if (projectsRegistry != null){
projectsRegistry.addExperiment(projectName, experiment);
}else {
WorkspaceProject workspaceProject = getWorkspaceProject(projectName);
ProjectResource project = jpa.getWorker().getProject(createProjName(workspaceProject.getProjectName()));
String experimentId = experiment.getExperimentId();
if (isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experimentResource = project.createExperiment(experimentId);
if (experiment.getSubmittedDate()!=null) {
experimentResource.setSubmittedDate(new Timestamp(experiment.getSubmittedDate().getTime()));
}
experimentResource.save();
}
}
public void removeExperiment(String experimentId) throws ExperimentDoesNotExistsException {
if (projectsRegistry != null){
projectsRegistry.removeExperiment(experimentId);
}else {
WorkerResource worker = jpa.getWorker();
if (!worker.isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
worker.removeExperiment(experimentId);
}
}
public List<AiravataExperiment> getExperiments() throws RegistryException{
if (projectsRegistry != null){
return projectsRegistry.getExperiments();
}
WorkerResource worker = jpa.getWorker();
List<AiravataExperiment> result=new ArrayList<AiravataExperiment>();
List<ExperimentResource> experiments = worker.getExperiments();
for (ExperimentResource resource : experiments) {
AiravataExperiment e = createAiravataExperimentObj(resource);
result.add(e);
}
return result;
}
private AiravataExperiment createAiravataExperimentObj(
ExperimentResource resource) {
AiravataExperiment e = new AiravataExperiment();
e.setExperimentId(resource.getExpID());
e.setUser(new AiravataUser(resource.getWorker().getUser()));
e.setSubmittedDate(new Date(resource.getSubmittedDate().getTime()));
e.setGateway(new Gateway(resource.getGateway().getGatewayName()));
e.setProject(new WorkspaceProject(getProjName(resource.getProject().getName()), this));
return e;
}
public List<AiravataExperiment> getExperiments(String projectName)throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.getExperiments(projectName);
}
ProjectResource project = jpa.getWorker().getProject(createProjName(projectName));
List<ExperimentResource> experiments = project.getExperiments();
List<AiravataExperiment> result=new ArrayList<AiravataExperiment>();
for (ExperimentResource resource : experiments) {
AiravataExperiment e = createAiravataExperimentObj(resource);
result.add(e);
}
return result;
}
public List<AiravataExperiment> getExperiments(Date from, Date to)throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.getExperiments(from, to);
}
List<AiravataExperiment> experiments = getExperiments();
List<AiravataExperiment> newExperiments = new ArrayList<AiravataExperiment>();
for(AiravataExperiment exp:experiments){
Date submittedDate = exp.getSubmittedDate();
if(submittedDate.after(from) && submittedDate.before(to)) {
newExperiments.add(exp);
}
}
return newExperiments;
}
public List<AiravataExperiment> getExperiments(String projectName, Date from, Date to)throws RegistryException {
if (projectsRegistry != null){
return projectsRegistry.getExperiments(projectName, from, to);
}
List<AiravataExperiment> experiments = getExperiments(projectName);
List<AiravataExperiment> newExperiments = new ArrayList<AiravataExperiment>();
for (AiravataExperiment exp : experiments) {
Date submittedDate = exp.getSubmittedDate();
if (submittedDate.after(from) && submittedDate.before(to)) {
newExperiments.add(exp);
}
}
return newExperiments;
}
/**---------------------------------Published Workflow Registry----------------------------------**/
@Override
public boolean isPublishedWorkflowExists(String workflowName)
throws RegistryException {
if (publishedWorkflowRegistry != null){
return publishedWorkflowRegistry.isPublishedWorkflowExists(workflowName);
}
return jpa.getGateway().isPublishedWorkflowExists(workflowName);
}
public void publishWorkflow(String workflowName, String publishWorkflowName) throws RegistryException {
if (publishedWorkflowRegistry != null){
publishedWorkflowRegistry.publishWorkflow(workflowName, publishWorkflowName);
} else {
GatewayResource gateway = jpa.getGateway();
String workflowGraphXML = getWorkflowGraphXML(workflowName);
if (gateway.isPublishedWorkflowExists(publishWorkflowName)){
throw new PublishedWorkflowAlreadyExistsException(publishWorkflowName);
}
PublishWorkflowResource publishedWorkflow = gateway.createPublishedWorkflow(publishWorkflowName);
publishedWorkflow.setCreatedUser(getUser().getUserName());
publishedWorkflow.setContent(workflowGraphXML);
publishedWorkflow.setPublishedDate(new Timestamp(Calendar.getInstance().getTime().getTime()));
publishedWorkflow.save();
}
}
public void publishWorkflow(String workflowName) throws RegistryException {
if (publishedWorkflowRegistry != null){
publishedWorkflowRegistry.publishWorkflow(workflowName);
} else {
publishWorkflow(workflowName, workflowName);
}
}
public String getPublishedWorkflowGraphXML(String workflowName) throws RegistryException {
if (publishedWorkflowRegistry != null){
return publishedWorkflowRegistry.getPublishedWorkflowGraphXML(workflowName);
}
GatewayResource gateway = jpa.getGateway();
if (!isPublishedWorkflowExists(workflowName)){
throw new PublishedWorkflowDoesNotExistsException(workflowName);
}
return gateway.getPublishedWorkflow(workflowName).getContent();
}
public List<String> getPublishedWorkflowNames() throws RegistryException{
if (publishedWorkflowRegistry != null){
return publishedWorkflowRegistry.getPublishedWorkflowNames();
}
GatewayResource gateway = jpa.getGateway();
List<String> result=new ArrayList<String>();
List<PublishWorkflowResource> publishedWorkflows = gateway.getPublishedWorkflows();
for (PublishWorkflowResource resource : publishedWorkflows) {
result.add(resource.getName());
}
return result;
}
public Map<String,String> getPublishedWorkflows() throws RegistryException{
if (publishedWorkflowRegistry != null){
return publishedWorkflowRegistry.getPublishedWorkflows();
}
GatewayResource gateway = jpa.getGateway();
Map<String,String> result=new HashMap<String, String>();
List<PublishWorkflowResource> publishedWorkflows = gateway.getPublishedWorkflows();
for (PublishWorkflowResource resource : publishedWorkflows) {
result.put(resource.getName(), resource.getContent());
}
return result;
}
public void removePublishedWorkflow(String workflowName) throws RegistryException {
if (publishedWorkflowRegistry != null){
publishedWorkflowRegistry.removePublishedWorkflow(workflowName);
} else {
GatewayResource gateway = jpa.getGateway();
if (!isPublishedWorkflowExists(workflowName)){
throw new PublishedWorkflowDoesNotExistsException(workflowName);
}
gateway.removePublishedWorkflow(workflowName);
}
}
public ResourceMetadata getPublishedWorkflowMetadata(String workflowName) throws RegistryException {
if (publishedWorkflowRegistry != null){
return publishedWorkflowRegistry.getPublishedWorkflowMetadata(workflowName);
}
//TODO
throw new UnimplementedRegistryOperationException();
}
/**---------------------------------User Workflow Registry----------------------------------**/
@Override
public boolean isWorkflowExists(String workflowName)
throws RegistryException {
if (userWorkflowRegistry != null){
return userWorkflowRegistry.isWorkflowExists(workflowName);
}
return jpa.getWorker().isWorkflowTemplateExists(workflowName);
}
public void addWorkflow(String workflowName, String workflowGraphXml) throws RegistryException {
if (userWorkflowRegistry != null){
userWorkflowRegistry.addWorkflow(workflowName, workflowGraphXml);
}else {
WorkerResource worker = jpa.getWorker();
if (isWorkflowExists(workflowName)){
throw new UserWorkflowAlreadyExistsException(workflowName);
}
UserWorkflowResource workflowResource = worker.createWorkflowTemplate(workflowName);
workflowResource.setContent(workflowGraphXml);
workflowResource.save();
}
}
public void updateWorkflow(String workflowName, String workflowGraphXml) throws RegistryException {
if (userWorkflowRegistry != null){
userWorkflowRegistry.updateWorkflow(workflowName, workflowGraphXml);
}else {
WorkerResource worker = jpa.getWorker();
if (!isWorkflowExists(workflowName)){
throw new UserWorkflowDoesNotExistsException(workflowName);
}
UserWorkflowResource workflowResource = worker.getWorkflowTemplate(workflowName);
workflowResource.setContent(workflowGraphXml);
workflowResource.save();
}
}
public String getWorkflowGraphXML(String workflowName) throws RegistryException {
if (userWorkflowRegistry != null){
return userWorkflowRegistry.getWorkflowGraphXML(workflowName);
}
WorkerResource worker = jpa.getWorker();
if (!isWorkflowExists(workflowName)){
throw new UserWorkflowDoesNotExistsException(workflowName);
}
return worker.getWorkflowTemplate(workflowName).getContent();
}
@Override
public Map<String, String> getWorkflows() throws RegistryException {
if (userWorkflowRegistry != null){
return userWorkflowRegistry.getWorkflows();
}
WorkerResource worker = jpa.getWorker();
Map<String, String> workflows=new HashMap<String, String>();
List<UserWorkflowResource> workflowTemplates = worker.getWorkflowTemplates();
for (UserWorkflowResource resource : workflowTemplates) {
workflows.put(resource.getName(), resource.getContent());
}
return workflows;
}
public void removeWorkflow(String workflowName) throws RegistryException {
if (userWorkflowRegistry != null){
userWorkflowRegistry.removeWorkflow(workflowName);
}else {
WorkerResource worker = jpa.getWorker();
if (!isWorkflowExists(workflowName)){
throw new UserWorkflowDoesNotExistsException(workflowName);
}
worker.removeWorkflowTemplate(workflowName);
}
}
public ResourceMetadata getWorkflowMetadata(String workflowName) throws RegistryException {
if (userWorkflowRegistry != null){
return userWorkflowRegistry.getWorkflowMetadata(workflowName);
}
//TODO
throw new UnimplementedRegistryOperationException();
}
public void setAiravataRegistry(AiravataRegistry2 registry) {
//redundant
}
public void setAiravataUser(AiravataUser user) {
setUser(user);
}
@Override
public AiravataUser getAiravataUser() {
return getUser();
}
/**---------------------------------Provenance Registry----------------------------------**/
@Override
public boolean isExperimentExists(String experimentId, boolean createIfNotPresent)throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isExperimentExists(experimentId, createIfNotPresent);
}
if (jpa.getWorker().isExperimentExists(experimentId)){
return true;
}else if (createIfNotPresent){
if (!isWorkspaceProjectExists(DEFAULT_PROJECT_NAME, true)){
throw new WorkspaceProjectDoesNotExistsException(createProjName(DEFAULT_PROJECT_NAME));
}
AiravataExperiment experiment = new AiravataExperiment();
experiment.setExperimentId(experimentId);
experiment.setSubmittedDate(Calendar.getInstance().getTime());
experiment.setGateway(getGateway());
experiment.setUser(getUser());
addExperiment(DEFAULT_PROJECT_NAME, experiment);
return jpa.getWorker().isExperimentExists(experimentId);
}else{
return false;
}
}
@Override
public boolean isExperimentExists(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isExperimentExists(experimentId);
}
return isExperimentExists(experimentId, false);
}
@Override
public void updateExperimentExecutionUser(String experimentId,
String user) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateExperimentExecutionUser(experimentId, user);
}else {
if (!isExperimentExists(experimentId, true)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
data.setUserName(user);
data.save();
}
}
@Override
public String getExperimentExecutionUser(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentExecutionUser(experimentId);
}
if (!isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
return experiment.getData().getUserName();
}
@Override
public boolean isExperimentNameExist(String experimentName) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isExperimentNameExist(experimentName);
}
return (new ExperimentDataRetriever()).isExperimentNameExist(experimentName);
}
@Override
public String getExperimentName(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentName(experimentId);
}
if (!isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
return (new ExperimentDataRetriever()).getExperimentName(experimentId);
}
@Override
public void updateExperimentName(String experimentId,
String experimentName) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateExperimentName(experimentId, experimentName);
}else {
if (!isExperimentExists(experimentId, true)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
data.setExpName(experimentName);
data.save();
}
}
@Override
public String getExperimentMetadata(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentMetadata(experimentId);
}
if (!isExperimentExists(experimentId, true)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
if (data.isExperimentMetadataPresent()){
return data.getExperimentMetadata().getMetadata();
}
return null;
}
@Override
public void updateExperimentMetadata(String experimentId, String metadata)
throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateExperimentMetadata(experimentId, metadata);
}else {
if (!isExperimentExists(experimentId, true)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
ExperimentMetadataResource experimentMetadata;
if (data.isExperimentMetadataPresent()){
experimentMetadata = data.getExperimentMetadata();
experimentMetadata.setMetadata(metadata);
}else{
experimentMetadata = data.createExperimentMetadata();
experimentMetadata.setMetadata(metadata);
}
experimentMetadata.save();
}
}
@Override
public String getWorkflowExecutionTemplateName(String workflowInstanceId) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowExecutionTemplateName(workflowInstanceId);
}
if (!isWorkflowInstanceExists(workflowInstanceId, true)){
throw new WorkflowInstanceDoesNotExistsException(workflowInstanceId);
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(workflowInstanceId);
return wi.getTemplateName();
}
@Override
public void setWorkflowInstanceTemplateName(String workflowInstanceId,
String templateName) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.setWorkflowInstanceTemplateName(workflowInstanceId, templateName);
}else {
if (!isWorkflowInstanceExists(workflowInstanceId, true)){
throw new WorkflowInstanceDoesNotExistsException(workflowInstanceId);
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(workflowInstanceId);
wi.setTemplateName(templateName);
wi.save();
}
}
@Override
public List<WorkflowExecution> getExperimentWorkflowInstances(
String experimentId) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentWorkflowInstances(experimentId);
}
if (!isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
List<WorkflowExecution> result=new ArrayList<WorkflowExecution>();
List<WorkflowDataResource> workflowInstances = data.getWorkflowInstances();
for (WorkflowDataResource resource : workflowInstances) {
WorkflowExecution workflowInstance = new WorkflowExecution(resource.getExperimentID(), resource.getWorkflowInstanceID());
workflowInstance.setTemplateName(resource.getTemplateName());
result.add(workflowInstance);
}
return result;
}
@Override
public boolean isWorkflowInstanceExists(String instanceId, boolean createIfNotPresent) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isWorkflowInstanceExists(instanceId, createIfNotPresent);
}
if (jpa.getWorker().isWorkflowInstancePresent(instanceId)){
return true;
}else if (createIfNotPresent){
//we are using the same id for the experiment id for backward compatibility
//for up to airavata 0.5
if (!isExperimentExists(instanceId, true)){
throw new ExperimentDoesNotExistsException(instanceId);
}
addWorkflowInstance(instanceId, instanceId, null);
return isWorkflowInstanceExists(instanceId);
}else{
return false;
}
}
@Override
public boolean isWorkflowInstanceExists(String instanceId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isWorkflowInstanceExists(instanceId);
}
return isWorkflowInstanceExists(instanceId, false);
}
@Override
public void updateWorkflowInstanceStatus(String instanceId,
State status) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowInstanceStatus(instanceId, status);
}else {
if (!isWorkflowInstanceExists(instanceId, true)){
throw new WorkflowInstanceDoesNotExistsException(instanceId);
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(instanceId);
Timestamp currentTime = new Timestamp(Calendar.getInstance().getTime().getTime());
wi.setStatus(status.toString());
if (status==State.STARTED){
wi.setStartTime(currentTime);
}
wi.setLastUpdatedTime(currentTime);
wi.save();
}
}
@Override
public void updateWorkflowInstanceStatus(WorkflowExecutionStatus status)
throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowInstanceStatus(status);
}else {
if (!isWorkflowInstanceExists(status.getWorkflowInstance().getWorkflowExecutionId(), true)){
throw new WorkflowInstanceDoesNotExistsException(status.getWorkflowInstance().getWorkflowExecutionId());
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(status.getWorkflowInstance().getWorkflowExecutionId());
Timestamp currentTime = new Timestamp(status.getStatusUpdateTime().getTime());
if(status.getExecutionStatus() != null){
wi.setStatus(status.getExecutionStatus().toString());
}
if (status.getExecutionStatus()==State.STARTED){
wi.setStartTime(currentTime);
}
wi.setLastUpdatedTime(currentTime);
wi.save();
}
}
@Override
public WorkflowExecutionStatus getWorkflowInstanceStatus(String instanceId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowInstanceStatus(instanceId);
}
if (!isWorkflowInstanceExists(instanceId, true)){
throw new WorkflowInstanceDoesNotExistsException(instanceId);
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(instanceId);
return new WorkflowExecutionStatus(new WorkflowExecution(wi.getExperimentID(),wi.getWorkflowInstanceID()),wi.getStatus()==null?null:State.valueOf(wi.getStatus()),wi.getLastUpdatedTime());
}
@Override
public void updateWorkflowNodeInput(WorkflowInstanceNode node, String data)
throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeInput(node, data);
}else {
if (!isWorkflowInstanceNodePresent(node.getWorkflowInstance().getWorkflowExecutionId(),node.getNodeId(),true)){
throw new WorkflowInstanceNodeDoesNotExistsException(node.getWorkflowInstance().getWorkflowExecutionId(), node.getNodeId());
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(node.getWorkflowInstance().getWorkflowExecutionId());
NodeDataResource nodeData = wi.getNodeData(node.getNodeId());
nodeData.setInputs(data);
nodeData.save();
}
}
@Override
public void updateWorkflowNodeOutput(WorkflowInstanceNode node, String data) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeOutput(node, data);
}else {
try {
if (!isWorkflowInstanceNodePresent(node.getWorkflowInstance().getWorkflowExecutionId(),node.getNodeId(),true)){
throw new WorkflowInstanceNodeDoesNotExistsException(node.getWorkflowInstance().getWorkflowExecutionId(), node.getNodeId());
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(node.getWorkflowInstance().getWorkflowExecutionId());
NodeDataResource nodeData = wi.getNodeData(node.getNodeId());
nodeData.setOutputs(data);
nodeData.save();
} catch (RegistryException e) {
e.printStackTrace();
throw e;
}
}
}
@Override
public List<WorkflowNodeIOData> searchWorkflowInstanceNodeInput(
String experimentIdRegEx, String workflowNameRegEx,
String nodeNameRegEx) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.searchWorkflowInstanceNodeInput(experimentIdRegEx, workflowNameRegEx, nodeNameRegEx);
}
return null;
}
@Override
public List<WorkflowNodeIOData> searchWorkflowInstanceNodeOutput(
String experimentIdRegEx, String workflowNameRegEx,
String nodeNameRegEx) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.searchWorkflowInstanceNodeOutput(experimentIdRegEx, workflowNameRegEx, nodeNameRegEx);
}
return null;
}
@Override
public List<WorkflowNodeIOData> getWorkflowInstanceNodeInput(
String workflowInstanceId, String nodeType)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowInstanceNodeInput(workflowInstanceId, nodeType);
}
return null;
}
@Override
public List<WorkflowNodeIOData> getWorkflowInstanceNodeOutput(
String workflowInstanceId, String nodeType)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowInstanceNodeOutput(workflowInstanceId, nodeType);
}
return null;
}
@Deprecated
@Override
public void saveWorkflowExecutionOutput(String experimentId,
String outputNodeName, String output) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.saveWorkflowExecutionOutput(experimentId, outputNodeName, output);
}
}
@Deprecated
@Override
public void saveWorkflowExecutionOutput(String experimentId,
WorkflowIOData data) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.saveWorkflowExecutionOutput(experimentId, data);
}
}
@Deprecated
@Override
public WorkflowIOData getWorkflowExecutionOutput(String experimentId,
String outputNodeName) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowExecutionOutput(experimentId, outputNodeName);
}
// TODO Auto-generated method stub
return null;
}
@Deprecated
@Override
public List<WorkflowIOData> getWorkflowExecutionOutput(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowExecutionOutput(experimentId);
}
// TODO Auto-generated method stub
return null;
}
@Deprecated
@Override
public String[] getWorkflowExecutionOutputNames(String exeperimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowExecutionOutputNames(exeperimentId);
}
// TODO Auto-generated method stub
return null;
}
@Override
public ExperimentData getExperiment(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperiment(experimentId);
}
if (!isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
return (new ExperimentDataRetriever()).getExperiment(experimentId);
}
@Override
public List<String> getExperimentIdByUser(String user)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentIdByUser(user);
}
if(user == null){
user = jpa.getWorker().getUser();
}
return (new ExperimentDataRetriever()).getExperimentIdByUser(user);
}
@Override
public List<ExperimentData> getExperimentByUser(String user)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentByUser(user);
}
if(user == null){
user = jpa.getWorker().getUser();
}
return (new ExperimentDataRetriever()).getExperiments(user);
}
@Override
public List<ExperimentData> getExperimentByUser(String user,
int pageSize, int pageNo) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentByUser(user, pageSize, pageNo);
}
// TODO Auto-generated method stub
return null;
}
@Override
public void updateWorkflowNodeStatus(NodeExecutionStatus workflowStatusNode) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeStatus(workflowStatusNode);
}else {
WorkflowExecution workflowInstance = workflowStatusNode.getWorkflowInstanceNode().getWorkflowInstance();
String nodeId = workflowStatusNode.getWorkflowInstanceNode().getNodeId();
if (!isWorkflowInstanceNodePresent(workflowInstance.getWorkflowExecutionId(), nodeId, true)){
throw new WorkflowInstanceNodeDoesNotExistsException(workflowInstance.getWorkflowExecutionId(), nodeId);
}
NodeDataResource nodeData = jpa.getWorker().getWorkflowInstance(workflowInstance.getWorkflowExecutionId()).getNodeData(nodeId);
nodeData.setStatus(workflowStatusNode.getExecutionStatus().toString());
Timestamp t = new Timestamp(workflowStatusNode.getStatusUpdateTime().getTime());
if (workflowStatusNode.getExecutionStatus()==State.STARTED){
nodeData.setStartTime(t);
}
nodeData.setLastUpdateTime(t);
nodeData.save();
//Each time node status is updated the the time of update for the workflow status is going to be the same
WorkflowExecutionStatus currentWorkflowInstanceStatus = getWorkflowInstanceStatus(workflowInstance.getWorkflowExecutionId());
updateWorkflowInstanceStatus(new WorkflowExecutionStatus(workflowInstance, currentWorkflowInstanceStatus.getExecutionStatus(), t));
}
}
@Override
public void updateWorkflowNodeStatus(String workflowInstanceId,
String nodeId, State status) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeStatus(workflowInstanceId, nodeId, status);
}else {
updateWorkflowNodeStatus(new WorkflowInstanceNode(new WorkflowExecution(workflowInstanceId, workflowInstanceId), nodeId), status);
}
}
@Override
public void updateWorkflowNodeStatus(WorkflowInstanceNode workflowNode,
State status) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeStatus(workflowNode, status);
}else {
updateWorkflowNodeStatus(new NodeExecutionStatus(workflowNode, status, Calendar.getInstance().getTime()));
}
}
@Override
public NodeExecutionStatus getWorkflowNodeStatus(
WorkflowInstanceNode workflowNode) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowNodeStatus(workflowNode);
}
String id = workflowNode.getWorkflowInstance().getWorkflowExecutionId();
String nodeId = workflowNode.getNodeId();
if (!isWorkflowInstanceNodePresent(id, nodeId)){
throw new WorkflowInstanceNodeDoesNotExistsException(id, nodeId);
}
WorkflowDataResource workflowInstance = jpa.getWorker().getWorkflowInstance(id);
NodeDataResource nodeData = workflowInstance.getNodeData(nodeId);
return new NodeExecutionStatus(new WorkflowInstanceNode(new WorkflowExecution(workflowInstance.getExperimentID(), workflowInstance.getWorkflowInstanceID()), nodeData.getNodeID()), nodeData.getStatus()==null?null:State.valueOf(nodeData.getStatus()),nodeData.getLastUpdateTime());
}
@Override
public Date getWorkflowNodeStartTime(WorkflowInstanceNode workflowNode)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowNodeStartTime(workflowNode);
}
String id = workflowNode.getWorkflowInstance().getWorkflowExecutionId();
String nodeId = workflowNode.getNodeId();
if (!isWorkflowInstanceNodePresent(id, nodeId)){
throw new WorkflowInstanceNodeDoesNotExistsException(id, nodeId);
}
WorkflowDataResource workflowInstance = jpa.getWorker().getWorkflowInstance(id);
NodeDataResource nodeData = workflowInstance.getNodeData(nodeId);
return nodeData.getStartTime();
}
@Override
public Date getWorkflowStartTime(WorkflowExecution workflowInstance)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowStartTime(workflowInstance);
}
if (!isWorkflowInstanceExists(workflowInstance.getWorkflowExecutionId(),true)){
throw new WorkflowInstanceDoesNotExistsException(workflowInstance.getWorkflowExecutionId());
}
WorkflowDataResource wi = jpa.getWorker().getWorkflowInstance(workflowInstance.getWorkflowExecutionId());
return wi.getStartTime();
}
@Override
public void updateWorkflowNodeGramData(
WorkflowNodeGramData workflowNodeGramData) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeGramData(workflowNodeGramData);
}else {
if (!isWorkflowInstanceNodePresent(workflowNodeGramData.getWorkflowInstanceId(),workflowNodeGramData.getNodeID(), true)){
throw new WorkflowInstanceNodeDoesNotExistsException(workflowNodeGramData.getWorkflowInstanceId(),workflowNodeGramData.getNodeID());
}
WorkflowDataResource workflowInstance = jpa.getWorker().getWorkflowInstance(workflowNodeGramData.getWorkflowInstanceId());
GramDataResource gramData;
if (workflowInstance.isGramDataExists(workflowNodeGramData.getNodeID())){
gramData = workflowInstance.getGramData(workflowNodeGramData.getNodeID());
}else{
gramData = workflowInstance.createGramData(workflowNodeGramData.getNodeID());
}
gramData.setInvokedHost(workflowNodeGramData.getInvokedHost());
gramData.setLocalJobID(workflowNodeGramData.getGramJobID());
gramData.setRsl(workflowNodeGramData.getRsl());
gramData.save();
}
}
@Override
public WorkflowExecutionData getWorkflowInstanceData(
String workflowInstanceId) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowInstanceData(workflowInstanceId);
}
if (!isWorkflowInstanceExists(workflowInstanceId,true)){
throw new WorkflowInstanceDoesNotExistsException(workflowInstanceId);
}
try{
WorkflowDataResource resource = jpa.getWorker().getWorkflowInstance(workflowInstanceId);
WorkflowExecution workflowInstance = new WorkflowExecution(resource.getExperimentID(), resource.getWorkflowInstanceID());
workflowInstance.setTemplateName(resource.getTemplateName());
WorkflowExecutionData workflowInstanceData = new WorkflowExecutionDataImpl(null, workflowInstance, new WorkflowExecutionStatus(workflowInstance, resource.getStatus()==null? null:State.valueOf(resource.getStatus()),resource.getLastUpdatedTime()), null);
List<NodeDataResource> nodeData = resource.getNodeData();
for (NodeDataResource nodeDataResource : nodeData) {
workflowInstanceData.getNodeDataList().add(getWorkflowInstanceNodeData(workflowInstanceId, nodeDataResource.getNodeID()));
}
return workflowInstanceData;
} catch (ExperimentLazyLoadedException e) {
throw new RegistryException(e);
}
}
@Override
public NodeExecutionData getWorkflowInstanceNodeData(
String workflowInstanceId, String nodeId) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getWorkflowInstanceNodeData(workflowInstanceId, nodeId);
}
if (!isWorkflowInstanceNodePresent(workflowInstanceId, nodeId)){
throw new WorkflowInstanceNodeDoesNotExistsException(workflowInstanceId,nodeId);
}
NodeDataResource nodeData = jpa.getWorker().getWorkflowInstance(workflowInstanceId).getNodeData(nodeId);
NodeExecutionData data = new NodeExecutionData(new WorkflowInstanceNode(new WorkflowExecution(nodeData.getWorkflowDataResource().getExperimentID(),nodeData.getWorkflowDataResource().getWorkflowInstanceID()),nodeData.getNodeID()));
data.setInput(nodeData.getInputs());
data.setOutput(nodeData.getOutputs());
data.setType(WorkflowNodeType.getType(nodeData.getNodeType()).getNodeType());
//TODO setup status
return data;
}
@Override
public boolean isWorkflowInstanceNodePresent(String workflowInstanceId,
String nodeId) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isWorkflowInstanceNodePresent(workflowInstanceId, nodeId);
}
return isWorkflowInstanceNodePresent(workflowInstanceId, nodeId, false);
}
@Override
public boolean isWorkflowInstanceNodePresent(String workflowInstanceId,
String nodeId, boolean createIfNotPresent) throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.isWorkflowInstanceNodePresent(workflowInstanceId, nodeId, createIfNotPresent);
}
if (!isWorkflowInstanceExists(workflowInstanceId, true)){
throw new WorkflowInstanceDoesNotExistsException(workflowInstanceId);
}
if (jpa.getWorker().getWorkflowInstance(workflowInstanceId).isNodeExists(nodeId)){
return true;
}else if (createIfNotPresent){
addWorkflowInstanceNode(workflowInstanceId, nodeId);
return isWorkflowInstanceNodePresent(workflowInstanceId, nodeId);
}else{
return false;
}
}
@Override
public void addWorkflowInstance(String experimentId,
String workflowInstanceId, String templateName) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.addWorkflowInstance(experimentId,workflowInstanceId, templateName);
}else {
if (!isExperimentExists(experimentId, true)){
throw new ExperimentDoesNotExistsException(experimentId);
}
if (isWorkflowInstanceExists(workflowInstanceId)){
throw new WorkflowInstanceAlreadyExistsException(workflowInstanceId);
}
ExperimentResource experiment = jpa.getWorker().getExperiment(experimentId);
ExperimentDataResource data = experiment.getData();
WorkflowDataResource workflowInstanceResource = data.createWorkflowInstanceResource(workflowInstanceId);
workflowInstanceResource.setTemplateName(templateName);
workflowInstanceResource.save();
}
}
@Override
public void updateWorkflowNodeType(WorkflowInstanceNode node, WorkflowNodeType type)
throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.updateWorkflowNodeType(node, type);
}else {
try {
if (!isWorkflowInstanceNodePresent(node.getWorkflowInstance().getWorkflowExecutionId(),node.getNodeId(), true)){
throw new WorkflowInstanceNodeDoesNotExistsException(node.getWorkflowInstance().getWorkflowExecutionId(),node.getNodeId());
}
NodeDataResource nodeData = jpa.getWorker().getWorkflowInstance(node.getWorkflowInstance().getWorkflowExecutionId()).getNodeData(node.getNodeId());
nodeData.setNodeType(type.getNodeType().toString());
nodeData.save();
} catch (RegistryException e) {
e.printStackTrace();
throw e;
}
}
}
@Override
public void addWorkflowInstanceNode(String workflowInstanceId,
String nodeId) throws RegistryException {
if (provenanceRegistry != null){
provenanceRegistry.addWorkflowInstanceNode(workflowInstanceId, nodeId);
}else {
if (isWorkflowInstanceNodePresent(workflowInstanceId, nodeId)){
throw new WorkflowInstanceNodeAlreadyExistsException(workflowInstanceId, nodeId);
}
NodeDataResource nodeData = jpa.getWorker().getWorkflowInstance(workflowInstanceId).createNodeData(nodeId);
nodeData.save();
}
}
@Override
public ExperimentData getExperimentMetaInformation(String experimentId)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getExperimentMetaInformation(experimentId);
}
if (!isExperimentExists(experimentId)){
throw new ExperimentDoesNotExistsException(experimentId);
}
ExperimentDataRetriever experimentDataRetriever = new ExperimentDataRetriever();
return experimentDataRetriever.getExperimentMetaInformation(experimentId);
}
@Override
public List<ExperimentData> getAllExperimentMetaInformation(String user)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.getAllExperimentMetaInformation(user);
}
ExperimentDataRetriever experimentDataRetriever = new ExperimentDataRetriever();
return experimentDataRetriever.getAllExperimentMetaInformation(user);
}
@Override
public List<ExperimentData> searchExperiments(String user, String experimentNameRegex)
throws RegistryException {
if (provenanceRegistry != null){
return provenanceRegistry.searchExperiments(user, experimentNameRegex);
}
Pattern pattern = Pattern.compile(experimentNameRegex);
List<ExperimentData> filteredExperiments=new ArrayList<ExperimentData>();
List<ExperimentData> allExperimentMetaInformation = getAllExperimentMetaInformation(user);
for (ExperimentData experimentData : allExperimentMetaInformation) {
if (experimentData.getExperimentName()!=null && pattern.matcher(experimentData.getExperimentName()).find()){
filteredExperiments.add(experimentData);
}
}
return filteredExperiments;
}
@Override
public Version getVersion() {
return API_VERSION;
}
@Override
public void setConnectionURI(URI connectionURI) {
registryConnectionURI=connectionURI;
}
@Override
public URI getConnectionURI() {
return registryConnectionURI;
}
@Override
public void setCallback(PasswordCallback callback) {
this.callback=callback;
}
@Override
public PasswordCallback getCallback() {
return callback;
}
}