http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ErrorDetailResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ErrorDetailResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ErrorDetailResource.java new file mode 100644 index 0000000..56a4e57 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ErrorDetailResource.java @@ -0,0 +1,229 @@ +/* + * + * 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.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.ErrorDetail; +import org.apache.airavata.persistance.registry.jpa.model.Experiment; +import org.apache.airavata.persistance.registry.jpa.model.TaskDetail; +import org.apache.airavata.persistance.registry.jpa.model.WorkflowNodeDetail; +import org.apache.airavata.registry.cpi.RegistryException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import java.sql.Timestamp; +import java.util.List; + +public class ErrorDetailResource extends AbstractResource { + private static final Logger logger = LoggerFactory.getLogger(ErrorDetailResource.class); + private int errorId; + private ExperimentResource experimentResource; + private TaskDetailResource taskDetailResource; + private WorkflowNodeDetailResource nodeDetail; + private Timestamp creationTime; + private String actualErrorMsg; + private String userFriendlyErrorMsg; + private boolean transientPersistent; + private String errorCategory; + private String correctiveAction; + private String actionableGroup; + private String jobId; + + public int getErrorId() { + return errorId; + } + + public void setErrorId(int errorId) { + this.errorId = errorId; + } + + public Timestamp getCreationTime() { + return creationTime; + } + + public void setCreationTime(Timestamp creationTime) { + this.creationTime = creationTime; + } + + public String getActualErrorMsg() { + return actualErrorMsg; + } + + public void setActualErrorMsg(String actualErrorMsg) { + this.actualErrorMsg = actualErrorMsg; + } + + public String getUserFriendlyErrorMsg() { + return userFriendlyErrorMsg; + } + + public void setUserFriendlyErrorMsg(String userFriendlyErrorMsg) { + this.userFriendlyErrorMsg = userFriendlyErrorMsg; + } + + public boolean isTransientPersistent() { + return transientPersistent; + } + + public void setTransientPersistent(boolean transientPersistent) { + this.transientPersistent = transientPersistent; + } + + public String getErrorCategory() { + return errorCategory; + } + + public void setErrorCategory(String errorCategory) { + this.errorCategory = errorCategory; + } + + public String getCorrectiveAction() { + return correctiveAction; + } + + public void setCorrectiveAction(String correctiveAction) { + this.correctiveAction = correctiveAction; + } + + public String getActionableGroup() { + return actionableGroup; + } + + public void setActionableGroup(String actionableGroup) { + this.actionableGroup = actionableGroup; + } + + public ExperimentResource getExperimentResource() { + return experimentResource; + } + + public void setExperimentResource(ExperimentResource experimentResource) { + this.experimentResource = experimentResource; + } + + public TaskDetailResource getTaskDetailResource() { + return taskDetailResource; + } + + public void setTaskDetailResource(TaskDetailResource taskDetailResource) { + this.taskDetailResource = taskDetailResource; + } + + public WorkflowNodeDetailResource getNodeDetail() { + return nodeDetail; + } + + public void setNodeDetail(WorkflowNodeDetailResource nodeDetail) { + this.nodeDetail = nodeDetail; + } + + public String getJobId() { + return jobId; + } + + public void setJobId(String jobId) { + this.jobId = jobId; + } + + + public Resource create(ResourceType type) throws RegistryException { + logger.error("Unsupported resource type for error details data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + + public void remove(ResourceType type, Object name) throws RegistryException { + logger.error("Unsupported resource type for error details data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + + public Resource get(ResourceType type, Object name) throws RegistryException{ + logger.error("Unsupported resource type for error details data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + + public List<Resource> get(ResourceType type) throws RegistryException{ + logger.error("Unsupported resource type for error details data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + + public void save() throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + ErrorDetail errorDetail; + if (errorId != 0) { + errorDetail = em.find(ErrorDetail.class, errorId); + errorDetail.setErrorId(errorId); + } else { + errorDetail = new ErrorDetail(); + } + errorDetail.setErrorId(errorId); + Experiment experiment = em.find(Experiment.class, experimentResource.getExpID()); + errorDetail.setExperiment(experiment); + errorDetail.setExpId(experimentResource.getExpID()); + if (taskDetailResource != null) { + TaskDetail taskDetail = em.find(TaskDetail.class, taskDetailResource.getTaskId()); + errorDetail.setTask(taskDetail); + errorDetail.setTaskId(taskDetail.getTaskId()); + } + + if (nodeDetail != null) { + WorkflowNodeDetail workflowNodeDetail = em.find(WorkflowNodeDetail.class, nodeDetail.getNodeInstanceId()); + errorDetail.setNodeDetails(workflowNodeDetail); + errorDetail.setNodeId(workflowNodeDetail.getNodeId()); + } + errorDetail.setCreationTime(creationTime); + if (actualErrorMsg != null){ + errorDetail.setActualErrorMsg(actualErrorMsg.toCharArray()); + } + + errorDetail.setUserFriendlyErrorMsg(userFriendlyErrorMsg); + errorDetail.setTransientPersistent(transientPersistent); + errorDetail.setErrorCategory(errorCategory); + errorDetail.setCorrectiveAction(correctiveAction); + errorDetail.setActionableGroup(actionableGroup); + errorDetail.setJobId(jobId); + em.persist(errorDetail); + errorId = errorDetail.getErrorId(); + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } +}
http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentInputResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentInputResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentInputResource.java new file mode 100644 index 0000000..1466522 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentInputResource.java @@ -0,0 +1,229 @@ +/* +* +* 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.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.Experiment; +import org.apache.airavata.persistance.registry.jpa.model.Experiment_Input; +import org.apache.airavata.persistance.registry.jpa.model.Experiment_Input_PK; +import org.apache.airavata.registry.cpi.RegistryException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import java.util.List; + +public class ExperimentInputResource extends AbstractResource { + private static final Logger logger = LoggerFactory.getLogger(ExperimentInputResource.class); + + private ExperimentResource experimentResource; + private String experimentKey; + private String value; + private String metadata; + private String dataType; + private String appArgument; + private boolean standardInput; + private String userFriendlyDesc; + private int inputOrder; + private boolean isRequired; + private boolean requiredToCMD; + private boolean dataStaged; + + public boolean getRequired() { + return isRequired; + } + + public void setRequired(boolean required) { + this.isRequired = required; + } + + public boolean getRequiredToCMD() { + return requiredToCMD; + } + + public void setRequiredToCMD(boolean requiredToCMD) { + this.requiredToCMD = requiredToCMD; + } + + public boolean isDataStaged() { + return dataStaged; + } + + public void setDataStaged(boolean dataStaged) { + this.dataStaged = dataStaged; + } + + public int getInputOrder() { + return inputOrder; + } + + public void setInputOrder(int inputOrder) { + this.inputOrder = inputOrder; + } + + public String getAppArgument() { + return appArgument; + } + + public void setAppArgument(String appArgument) { + this.appArgument = appArgument; + } + + public boolean isStandardInput() { + return standardInput; + } + + public void setStandardInput(boolean standardInput) { + this.standardInput = standardInput; + } + + public String getUserFriendlyDesc() { + return userFriendlyDesc; + } + + public void setUserFriendlyDesc(String userFriendlyDesc) { + this.userFriendlyDesc = userFriendlyDesc; + } + + public String getExperimentKey() { + return experimentKey; + } + + public void setExperimentKey(String experimentKey) { + this.experimentKey = experimentKey; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public ExperimentResource getExperimentResource() { + return experimentResource; + } + + public void setExperimentResource(ExperimentResource experimentResource) { + this.experimentResource = experimentResource; + } + + public String getDataType() { + return dataType; + } + + public void setDataType(String dataType) { + this.dataType = dataType; + } + + public String getMetadata() { + return metadata; + } + + public void setMetadata(String metadata) { + this.metadata = metadata; + } + + public Resource create(ResourceType type) throws RegistryException { + logger.error("Unsupported resource type for experiment input data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public void remove(ResourceType type, Object name) throws RegistryException{ + logger.error("Unsupported resource type for experiment input data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public Resource get(ResourceType type, Object name) throws RegistryException { + logger.error("Unsupported resource type for experiment input data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public List<Resource> get(ResourceType type) throws RegistryException { + logger.error("Unsupported resource type for experiment input data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public void save() throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + Experiment_Input existingInput = em.find(Experiment_Input.class, new Experiment_Input_PK(experimentResource.getExpID(), experimentKey)); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Experiment_Input exInput = new Experiment_Input(); + exInput.setEx_key(experimentKey); + Experiment experiment = em.find(Experiment.class, experimentResource.getExpID()); + exInput.setExperiment(experiment); + exInput.setExperiment_id(experiment.getExpId()); + if (value != null){ + exInput.setValue(value.toCharArray()); + } + exInput.setDataType(dataType); + exInput.setMetadata(metadata); + exInput.setAppArgument(appArgument); + exInput.setStandardInput(standardInput); + exInput.setUserFriendlyDesc(userFriendlyDesc); + exInput.setInputOrder(inputOrder); + exInput.setRequiredToCMD(requiredToCMD); + exInput.setRequired(isRequired); + exInput.setDataStaged(dataStaged); + if (existingInput != null) { + existingInput.setEx_key(experimentKey); + existingInput.setExperiment(experiment); + existingInput.setExperiment_id(experiment.getExpId()); + if (value != null){ + existingInput.setValue(value.toCharArray()); + } + existingInput.setDataType(dataType); + existingInput.setMetadata(metadata); + existingInput.setAppArgument(appArgument); + existingInput.setStandardInput(standardInput); + existingInput.setUserFriendlyDesc(userFriendlyDesc); + existingInput.setInputOrder(inputOrder); + existingInput.setRequiredToCMD(requiredToCMD); + existingInput.setRequired(isRequired); + existingInput.setDataStaged(dataStaged); + exInput = em.merge(existingInput); + } else { + em.persist(exInput); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } +} http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentOutputResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentOutputResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentOutputResource.java new file mode 100644 index 0000000..17bd23a --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentOutputResource.java @@ -0,0 +1,209 @@ +/* +* +* 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.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.Experiment; +import org.apache.airavata.persistance.registry.jpa.model.Experiment_Output; +import org.apache.airavata.persistance.registry.jpa.model.Experiment_Output_PK; +import org.apache.airavata.registry.cpi.RegistryException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import java.util.List; + +public class ExperimentOutputResource extends AbstractResource { + private static final Logger logger = LoggerFactory.getLogger(ExperimentOutputResource.class); + + private ExperimentResource experimentResource; + private String experimentKey; + private String value; + private String dataType; + private boolean isRequired; + private boolean dataMovement; + private String dataNameLocation; + private boolean requiredToCMD; + private String searchQuery; + private String appArgument; + + public String getSearchQuery() { + return searchQuery; + } + + public void setSearchQuery(String searchQuery) { + this.searchQuery = searchQuery; + } + + public String getAppArgument() { + return appArgument; + } + + public void setAppArgument(String appArgument) { + this.appArgument = appArgument; + } + + + public boolean getRequiredToCMD() { + return requiredToCMD; + } + + public void setRequiredToCMD(boolean requiredToCMD) { + this.requiredToCMD = requiredToCMD; + } + + public boolean getRequired() { + return isRequired; + } + + public void setRequired(boolean required) { + this.isRequired = required; + } + + public boolean isDataMovement() { + return dataMovement; + } + + public void setDataMovement(boolean dataMovement) { + this.dataMovement = dataMovement; + } + + public String getDataNameLocation() { + return dataNameLocation; + } + + public void setDataNameLocation(String dataNameLocation) { + this.dataNameLocation = dataNameLocation; + } + + public String getExperimentKey() { + return experimentKey; + } + + public void setExperimentKey(String experimentKey) { + this.experimentKey = experimentKey; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public ExperimentResource getExperimentResource() { + return experimentResource; + } + + public void setExperimentResource(ExperimentResource experimentResource) { + this.experimentResource = experimentResource; + } + + public String getDataType() { + return dataType; + } + + public void setDataType(String dataType) { + this.dataType = dataType; + } + + public Resource create(ResourceType type) throws RegistryException { + logger.error("Unsupported resource type for experiment output data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public void remove(ResourceType type, Object name) throws RegistryException{ + logger.error("Unsupported resource type for experiment output data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public Resource get(ResourceType type, Object name) throws RegistryException{ + logger.error("Unsupported resource type for experiment output data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public List<Resource> get(ResourceType type) throws RegistryException { + logger.error("Unsupported resource type for experiment output data resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + + public void save() throws RegistryException { + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + Experiment_Output existingOutput = em.find(Experiment_Output.class, new Experiment_Output_PK(experimentResource.getExpID(), experimentKey)); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Experiment_Output exOutput = new Experiment_Output(); + exOutput.setEx_key(experimentKey); + Experiment experiment = em.find(Experiment.class, experimentResource.getExpID()); + exOutput.setExperiment(experiment); + exOutput.setExperiment_id(experiment.getExpId()); + if (value != null){ + exOutput.setValue(value.toCharArray()); + } + exOutput.setDataType(dataType); + exOutput.setRequired(isRequired); + exOutput.setRequiredToCMD(requiredToCMD); + exOutput.setDataMovement(dataMovement); + exOutput.setDataNameLocation(dataNameLocation); + exOutput.setApplicationArgument(appArgument); + exOutput.setSearchQuery(searchQuery); + + if (existingOutput != null) { + existingOutput.setEx_key(experimentKey); + existingOutput.setExperiment(experiment); + if (value != null){ + existingOutput.setValue(value.toCharArray()); + } + existingOutput.setExperiment_id(experiment.getExpId()); + existingOutput.setDataType(dataType); + existingOutput.setRequired(isRequired); + existingOutput.setRequiredToCMD(requiredToCMD); + existingOutput.setDataMovement(dataMovement); + existingOutput.setDataNameLocation(dataNameLocation); + existingOutput.setApplicationArgument(appArgument); + existingOutput.setSearchQuery(searchQuery); + exOutput = em.merge(existingOutput); + } else { + em.persist(exOutput); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } +} http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentResource.java new file mode 100644 index 0000000..ab9d924 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/ExperimentResource.java @@ -0,0 +1,777 @@ +/* +* +* 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.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.*; +import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator; +import org.apache.airavata.registry.cpi.RegistryException; +import org.apache.airavata.registry.cpi.utils.StatusType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.List; + +public class ExperimentResource extends AbstractResource { + private static final Logger logger = LoggerFactory.getLogger(ExperimentResource.class); +// private WorkerResource worker; + private String executionUser; + private String expID; + private Timestamp creationTime; + private GatewayResource gateway; + private ProjectResource project; + private String expName; + private String description; + private String applicationId; + private String applicationVersion; + private String workflowTemplateId; + private String workflowTemplateVersion; + private String workflowExecutionId; + private boolean enableEmailNotifications; + private String gatewayExecutionId; + + /** + * + * @return experiment ID + */ + public String getExpID() { + return expID; + } + + public Timestamp getCreationTime() { + return creationTime; + } + + public void setCreationTime(Timestamp creationTime) { + this.creationTime = creationTime; + } + + public String getExpName() { + return expName; + } + + public void setExpName(String expName) { + this.expName = expName; + } + + public String getApplicationId() { + return applicationId; + } + + public void setApplicationId(String applicationId) { + this.applicationId = applicationId; + } + + public String getApplicationVersion() { + return applicationVersion; + } + + public void setApplicationVersion(String applicationVersion) { + this.applicationVersion = applicationVersion; + } + + public String getWorkflowTemplateId() { + return workflowTemplateId; + } + + public void setWorkflowTemplateId(String workflowTemplateId) { + this.workflowTemplateId = workflowTemplateId; + } + + public String getWorkflowTemplateVersion() { + return workflowTemplateVersion; + } + + public void setWorkflowTemplateVersion(String workflowTemplateVersion) { + this.workflowTemplateVersion = workflowTemplateVersion; + } + + public String getWorkflowExecutionId() { + return workflowExecutionId; + } + + public void setWorkflowExecutionId(String workflowExecutionId) { + this.workflowExecutionId = workflowExecutionId; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public boolean isEnableEmailNotifications() { + return enableEmailNotifications; + } + + public void setEnableEmailNotifications(boolean enableEmailNotifications) { + this.enableEmailNotifications = enableEmailNotifications; + } + + public String getGatewayExecutionId() { + return gatewayExecutionId; + } + + public void setGatewayExecutionId(String gatewayExecutionId) { + this.gatewayExecutionId = gatewayExecutionId; + } + + /** + * Since experiments are at the leaf level, this method is not + * valid for an experiment + * @param type child resource types + * @return UnsupportedOperationException + */ + public Resource create(ResourceType type) throws RegistryException { + switch (type){ + case EXPERIMENT_INPUT: + ExperimentInputResource inputResource = new ExperimentInputResource(); + inputResource.setExperimentResource(this); + return inputResource; + case EXPERIMENT_OUTPUT: + ExperimentOutputResource experimentOutputResource = new ExperimentOutputResource(); + experimentOutputResource.setExperimentResource(this); + return experimentOutputResource; + case NOTIFICATION_EMAIL: + NotificationEmailResource emailResource = new NotificationEmailResource(); + emailResource.setExperimentResource(this); + return emailResource; + case WORKFLOW_NODE_DETAIL: + WorkflowNodeDetailResource nodeDetailResource = new WorkflowNodeDetailResource(); + nodeDetailResource.setExperimentResource(this); + return nodeDetailResource; + case ERROR_DETAIL: + ErrorDetailResource errorDetailResource = new ErrorDetailResource(); + errorDetailResource.setExperimentResource(this); + return errorDetailResource; + case STATUS: + StatusResource statusResource = new StatusResource(); + statusResource.setExperimentResource(this); + return statusResource; + case CONFIG_DATA: + ConfigDataResource configDataResource = new ConfigDataResource(); + configDataResource.setExperimentResource(this); + return configDataResource; + case COMPUTATIONAL_RESOURCE_SCHEDULING: + ComputationSchedulingResource schedulingResource = new ComputationSchedulingResource(); + schedulingResource.setExperimentResource(this); + return schedulingResource; + case ADVANCE_INPUT_DATA_HANDLING: + AdvanceInputDataHandlingResource dataHandlingResource = new AdvanceInputDataHandlingResource(); + dataHandlingResource.setExperimentResource(this); + return dataHandlingResource; + case ADVANCE_OUTPUT_DATA_HANDLING: + AdvancedOutputDataHandlingResource outputDataHandlingResource = new AdvancedOutputDataHandlingResource(); + outputDataHandlingResource.setExperimentResource(this); + return outputDataHandlingResource; + case QOS_PARAM: + QosParamResource qosParamResource = new QosParamResource(); + qosParamResource.setExperimentResource(this); + return qosParamResource; + default: + logger.error("Unsupported resource type for experiment resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for experiment resource."); + } + } + + /** + * + * @param type child resource types + * @param name name of the child resource + * @return UnsupportedOperationException + */ + public void remove(ResourceType type, Object name) throws RegistryException { + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + switch (type) { + case EXPERIMENT_INPUT: + generator = new QueryGenerator(EXPERIMENT_INPUT); + generator.setParameter(ExperimentInputConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case EXPERIMENT_OUTPUT: + generator = new QueryGenerator(EXPERIMENT_OUTPUT); + generator.setParameter(ExperimentOutputConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case NOTIFICATION_EMAIL: + generator = new QueryGenerator(NOTIFICATION_EMAIL); + generator.setParameter(NotificationEmailConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case WORKFLOW_NODE_DETAIL: + generator = new QueryGenerator(WORKFLOW_NODE_DETAIL); + generator.setParameter(WorkflowNodeDetailsConstants.NODE_INSTANCE_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.EXPERIMENT_ID, name); + generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.EXPERIMENT.toString()); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case CONFIG_DATA: + generator = new QueryGenerator(CONFIG_DATA); + generator.setParameter(ExperimentConfigurationDataConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case COMPUTATIONAL_RESOURCE_SCHEDULING: + generator = new QueryGenerator(COMPUTATIONAL_RESOURCE_SCHEDULING); + generator.setParameter(ComputationalResourceSchedulingConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case ADVANCE_INPUT_DATA_HANDLING: + generator = new QueryGenerator(ADVANCE_INPUT_DATA_HANDLING); + generator.setParameter(AdvancedInputDataHandlingConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case ADVANCE_OUTPUT_DATA_HANDLING: + generator = new QueryGenerator(ADVANCE_OUTPUT_DATA_HANDLING); + generator.setParameter(AdvancedOutputDataHandlingConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case QOS_PARAM: + generator = new QueryGenerator(QOS_PARAMS); + generator.setParameter(QosParamsConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + default: + logger.error("Unsupported resource type for experiment resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * + * @param type child resource types + * @param name name of the child resource + * @return UnsupportedOperationException + */ + public Resource get(ResourceType type, Object name) throws RegistryException { + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + QueryGenerator generator; + Query q; + switch (type) { + case EXPERIMENT_INPUT: + generator = new QueryGenerator(EXPERIMENT_INPUT); + generator.setParameter(ExperimentInputConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + Experiment_Input experimentInput = (Experiment_Input) q.getSingleResult(); + ExperimentInputResource inputResource = (ExperimentInputResource) Utils.getResource(ResourceType.EXPERIMENT_INPUT, experimentInput); + em.getTransaction().commit(); + em.close(); + return inputResource; + case EXPERIMENT_OUTPUT: + generator = new QueryGenerator(EXPERIMENT_OUTPUT); + generator.setParameter(ExperimentOutputConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + Experiment_Output experimentOutput = (Experiment_Output) q.getSingleResult(); + ExperimentOutputResource outputResource = (ExperimentOutputResource) Utils.getResource(ResourceType.EXPERIMENT_OUTPUT, experimentOutput); + em.getTransaction().commit(); + em.close(); + return outputResource; + case NOTIFICATION_EMAIL: + generator = new QueryGenerator(NOTIFICATION_EMAIL); + generator.setParameter(NotificationEmailConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + Notification_Email notificationEmail = (Notification_Email) q.getSingleResult(); + NotificationEmailResource notificationEmailResource = (NotificationEmailResource) Utils.getResource(ResourceType.NOTIFICATION_EMAIL, notificationEmail); + em.getTransaction().commit(); + em.close(); + return notificationEmailResource; + case WORKFLOW_NODE_DETAIL: + generator = new QueryGenerator(WORKFLOW_NODE_DETAIL); + generator.setParameter(WorkflowNodeDetailsConstants.NODE_INSTANCE_ID, name); + q = generator.selectQuery(em); + WorkflowNodeDetail workflowNodeDetail = (WorkflowNodeDetail) q.getSingleResult(); + WorkflowNodeDetailResource nodeDetailResource = (WorkflowNodeDetailResource) Utils.getResource(ResourceType.WORKFLOW_NODE_DETAIL, workflowNodeDetail); + em.getTransaction().commit(); + em.close(); + return nodeDetailResource; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + ErrorDetail errorDetail = (ErrorDetail) q.getSingleResult(); + ErrorDetailResource errorDetailResource = (ErrorDetailResource) Utils.getResource(ResourceType.ERROR_DETAIL, errorDetail); + em.getTransaction().commit(); + em.close(); + return errorDetailResource; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.EXPERIMENT_ID, name); + generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.EXPERIMENT.toString()); + q = generator.selectQuery(em); + Status status = (Status) q.getSingleResult(); + StatusResource statusResource = (StatusResource) Utils.getResource(ResourceType.STATUS, status); + em.getTransaction().commit(); + em.close(); + return statusResource; + case CONFIG_DATA: + generator = new QueryGenerator(CONFIG_DATA); + generator.setParameter(ExperimentConfigurationDataConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + ExperimentConfigData configData = (ExperimentConfigData) q.getSingleResult(); + ConfigDataResource configDataResource = (ConfigDataResource) Utils.getResource(ResourceType.CONFIG_DATA, configData); + em.getTransaction().commit(); + em.close(); + return configDataResource; + case COMPUTATIONAL_RESOURCE_SCHEDULING: + generator = new QueryGenerator(COMPUTATIONAL_RESOURCE_SCHEDULING); + generator.setParameter(ComputationalResourceSchedulingConstants.EXPERIMENT_ID, name); + generator.setParameter(ComputationalResourceSchedulingConstants.TASK_ID, null); + q = generator.selectQuery(em); + Computational_Resource_Scheduling scheduling = (Computational_Resource_Scheduling) q.getSingleResult(); + ComputationSchedulingResource schedulingResource = (ComputationSchedulingResource) Utils.getResource(ResourceType.COMPUTATIONAL_RESOURCE_SCHEDULING, scheduling); + em.getTransaction().commit(); + em.close(); + return schedulingResource; + case ADVANCE_INPUT_DATA_HANDLING: + generator = new QueryGenerator(ADVANCE_INPUT_DATA_HANDLING); + generator.setParameter(AdvancedInputDataHandlingConstants.EXPERIMENT_ID, name); + generator.setParameter(AdvancedInputDataHandlingConstants.TASK_ID, null); + q = generator.selectQuery(em); + AdvancedInputDataHandling inputDataHandling = (AdvancedInputDataHandling) q.getSingleResult(); + AdvanceInputDataHandlingResource dataHandlingResource = (AdvanceInputDataHandlingResource) Utils.getResource(ResourceType.ADVANCE_INPUT_DATA_HANDLING, inputDataHandling); + em.getTransaction().commit(); + em.close(); + return dataHandlingResource; + case ADVANCE_OUTPUT_DATA_HANDLING: + generator = new QueryGenerator(ADVANCE_OUTPUT_DATA_HANDLING); + generator.setParameter(AdvancedOutputDataHandlingConstants.EXPERIMENT_ID, name); + generator.setParameter(AdvancedOutputDataHandlingConstants.TASK_ID, null); + q = generator.selectQuery(em); + AdvancedOutputDataHandling outputDataHandling = (AdvancedOutputDataHandling) q.getSingleResult(); + AdvancedOutputDataHandlingResource outputDataHandlingResource = (AdvancedOutputDataHandlingResource) Utils.getResource(ResourceType.ADVANCE_OUTPUT_DATA_HANDLING, outputDataHandling); + em.getTransaction().commit(); + em.close(); + return outputDataHandlingResource; + case QOS_PARAM: + generator = new QueryGenerator(QOS_PARAMS); + generator.setParameter(QosParamsConstants.EXPERIMENT_ID, name); + generator.setParameter(QosParamsConstants.TASK_ID, null); + q = generator.selectQuery(em); + QosParam qosParam = (QosParam) q.getSingleResult(); + QosParamResource qosParamResource = (QosParamResource) Utils.getResource(ResourceType.QOS_PARAM, qosParam); + em.getTransaction().commit(); + em.close(); + return qosParamResource; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for experiment resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for experiment data resource."); + } + } catch (Exception e) { + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + + } + + /** + * + * @param type child resource types + * @return UnsupportedOperationException + */ + public List<Resource> get(ResourceType type) throws RegistryException{ + List<Resource> resourceList = new ArrayList<Resource>(); + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + List results; + switch (type) { + case EXPERIMENT_INPUT: + generator = new QueryGenerator(EXPERIMENT_INPUT); + generator.setParameter(ExperimentInputConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Experiment_Input exInput = (Experiment_Input) result; + ExperimentInputResource inputResource = + (ExperimentInputResource) Utils.getResource(ResourceType.EXPERIMENT_INPUT, exInput); + resourceList.add(inputResource); + } + } + break; + case EXPERIMENT_OUTPUT: + generator = new QueryGenerator(EXPERIMENT_OUTPUT); + generator.setParameter(ExperimentOutputConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Experiment_Output output = (Experiment_Output) result; + ExperimentOutputResource outputResource = + (ExperimentOutputResource) Utils.getResource(ResourceType.EXPERIMENT_OUTPUT, output); + resourceList.add(outputResource); + } + } + break; + case NOTIFICATION_EMAIL: + generator = new QueryGenerator(NOTIFICATION_EMAIL); + generator.setParameter(NotificationEmailConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Notification_Email notificationEmail = (Notification_Email) result; + NotificationEmailResource emailResource = + (NotificationEmailResource) Utils.getResource(ResourceType.NOTIFICATION_EMAIL, notificationEmail); + resourceList.add(emailResource); + } + } + break; + case WORKFLOW_NODE_DETAIL: + generator = new QueryGenerator(WORKFLOW_NODE_DETAIL); + generator.setParameter(WorkflowNodeDetailsConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + WorkflowNodeDetail nodeDetail = (WorkflowNodeDetail) result; + WorkflowNodeDetailResource nodeDetailResource = + (WorkflowNodeDetailResource) Utils.getResource(ResourceType.WORKFLOW_NODE_DETAIL, nodeDetail); + resourceList.add(nodeDetailResource); + } + } + break; + case ERROR_DETAIL: + generator = new QueryGenerator(ERROR_DETAIL); + generator.setParameter(ErrorDetailConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + ErrorDetail errorDetail = (ErrorDetail) result; + ErrorDetailResource errorDetailResource = + (ErrorDetailResource) Utils.getResource(ResourceType.ERROR_DETAIL, errorDetail); + resourceList.add(errorDetailResource); + } + } + break; + case STATUS: + generator = new QueryGenerator(STATUS); + generator.setParameter(StatusConstants.EXPERIMENT_ID, expID); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Status status = (Status) result; + StatusResource statusResource = + (StatusResource) Utils.getResource(ResourceType.STATUS, status); + resourceList.add(statusResource); + } + } + break; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for experiment resource.", new UnsupportedOperationException()); + throw new UnsupportedOperationException(); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return resourceList; + } + + /** + * saveExperiment experiment + */ + public void save() throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + Experiment existingExp = em.find(Experiment.class, expID); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Experiment experiment = new Experiment(); + Project projectmodel = em.find(Project.class, project.getId()); + experiment.setProject(projectmodel); + experiment.setProjectId(projectmodel.getProject_id()); + Gateway gateway = em.find(Gateway.class, getGateway().getGatewayId()); + experiment.setExpId(expID); + experiment.setExecutionUser(executionUser); + Users userModel = em.find(Users.class, executionUser); + experiment.setUser(userModel); + experiment.setExecutionUser(userModel.getUser_name()); + experiment.setGateway(gateway); + experiment.setGatewayId(gateway.getGateway_id()); + experiment.setCreationTime(creationTime); + experiment.setExpName(expName); + experiment.setExpDesc(description); + experiment.setApplicationId(applicationId); + experiment.setAppVersion(applicationVersion); + experiment.setWorkflowExecutionId(workflowExecutionId); + experiment.setWorkflowTemplateVersion(workflowTemplateVersion); + experiment.setWorkflowExecutionId(workflowExecutionId); + experiment.setAllowNotification(enableEmailNotifications); + experiment.setGatewayExecutionId(gatewayExecutionId); + if (existingExp != null) { + existingExp.setGateway(gateway); + existingExp.setGatewayId(gateway.getGateway_id()); + existingExp.setProject(projectmodel); + existingExp.setExecutionUser(executionUser); + existingExp.setUser(userModel); + existingExp.setProjectId(projectmodel.getProject_id()); + existingExp.setCreationTime(creationTime); + existingExp.setExpName(expName); + existingExp.setExpDesc(description); + existingExp.setApplicationId(applicationId); + existingExp.setAppVersion(applicationVersion); + existingExp.setWorkflowExecutionId(workflowExecutionId); + existingExp.setWorkflowTemplateVersion(workflowTemplateVersion); + existingExp.setWorkflowExecutionId(workflowExecutionId); + existingExp.setAllowNotification(enableEmailNotifications); + existingExp.setGatewayExecutionId(gatewayExecutionId); + experiment = em.merge(existingExp); + } else { + em.persist(experiment); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * + * @param expID experiment ID + */ + public void setExpID(String expID) { + this.expID = expID; + } + + /** + * + * @return gatewayResource + */ + public GatewayResource getGateway() { + return gateway; + } + + /** + * + * @param gateway gateway + */ + public void setGateway(GatewayResource gateway) { + this.gateway = gateway; + } + + public String getExecutionUser() { + return executionUser; + } + + public void setExecutionUser(String executionUser) { + this.executionUser = executionUser; + } + + /** + * + * @return project + */ + public ProjectResource getProject() { + return project; + } + + /** + * + * @param project project + */ + public void setProject(ProjectResource project) { + this.project = project; + } + + public List<NotificationEmailResource> getNotificationEmails () throws RegistryException{ + List<NotificationEmailResource> emailResources = new ArrayList<NotificationEmailResource>(); + List<Resource> resources = get(ResourceType.NOTIFICATION_EMAIL); + for (Resource resource : resources) { + emailResources.add((NotificationEmailResource) resource); + } + return emailResources; + } + + public List<ExperimentInputResource> getExperimentInputs () throws RegistryException{ + List<ExperimentInputResource> expInputs = new ArrayList<ExperimentInputResource>(); + List<Resource> resources = get(ResourceType.EXPERIMENT_INPUT); + for (Resource resource : resources) { + expInputs.add((ExperimentInputResource) resource); + } + return expInputs; + } + + public List<ExperimentOutputResource> getExperimentOutputs () throws RegistryException{ + List<ExperimentOutputResource> expOutputs = new ArrayList<ExperimentOutputResource>(); + List<Resource> resources = get(ResourceType.EXPERIMENT_OUTPUT); + for (Resource resource : resources) { + expOutputs.add((ExperimentOutputResource) resource); + } + return expOutputs; + } + + public StatusResource getExperimentStatus() throws RegistryException{ + List<Resource> resources = get(ResourceType.STATUS); + for (Resource resource : resources) { + StatusResource expStatus = (StatusResource) resource; + if(expStatus.getStatusType().equals(StatusType.EXPERIMENT.toString())){ + if (expStatus.getState() == null || expStatus.getState().equals("") ){ + expStatus.setState("UNKNOWN"); + } + return expStatus; + } + } + return null; + } + + public List<StatusResource> getWorkflowNodeStatuses() throws RegistryException{ + List<StatusResource> statuses = new ArrayList<StatusResource>(); + List<Resource> resources = get(ResourceType.STATUS); + for (Resource resource : resources) { + StatusResource workflowNodeStatus = (StatusResource) resource; + if(workflowNodeStatus.getStatusType().equals(StatusType.WORKFLOW_NODE.toString())){ + if (workflowNodeStatus.getState() == null || workflowNodeStatus.getState().equals("")){ + workflowNodeStatus.setState("UNKNOWN"); + } + statuses.add(workflowNodeStatus); + } + } + return statuses; + } + + public List<WorkflowNodeDetailResource> getWorkflowNodeDetails () throws RegistryException{ + List<WorkflowNodeDetailResource> workflowNodeDetailResourceList = new ArrayList<WorkflowNodeDetailResource>(); + List<Resource> resources = get(ResourceType.WORKFLOW_NODE_DETAIL); + for (Resource resource : resources) { + WorkflowNodeDetailResource nodeDetailResource = (WorkflowNodeDetailResource) resource; + workflowNodeDetailResourceList.add(nodeDetailResource); + } + return workflowNodeDetailResourceList; + } + + public List<ErrorDetailResource> getErrorDetails () throws RegistryException{ + List<ErrorDetailResource> errorDetailResources = new ArrayList<ErrorDetailResource>(); + List<Resource> resources = get(ResourceType.ERROR_DETAIL); + for (Resource resource : resources) { + ErrorDetailResource errorDetailResource = (ErrorDetailResource) resource; + errorDetailResources.add(errorDetailResource); + } + return errorDetailResources; + } + + public ComputationSchedulingResource getComputationScheduling (String expId) throws RegistryException{ + return (ComputationSchedulingResource)get(ResourceType.COMPUTATIONAL_RESOURCE_SCHEDULING, expId); + } + + public AdvanceInputDataHandlingResource getInputDataHandling (String expId) throws RegistryException{ + return (AdvanceInputDataHandlingResource)get(ResourceType.ADVANCE_INPUT_DATA_HANDLING, expId); + } + + public AdvancedOutputDataHandlingResource getOutputDataHandling (String expId) throws RegistryException{ + return (AdvancedOutputDataHandlingResource)get(ResourceType.ADVANCE_OUTPUT_DATA_HANDLING, expId); + } + + public QosParamResource getQOSparams (String expId) throws RegistryException{ + return (QosParamResource)get(ResourceType.QOS_PARAM, expId); + } + + public ConfigDataResource getUserConfigData(String expID) throws RegistryException{ + return (ConfigDataResource)get(ResourceType.CONFIG_DATA, expID); + } + public WorkflowNodeDetailResource getWorkflowNode (String nodeId) throws RegistryException{ + return (WorkflowNodeDetailResource)get(ResourceType.WORKFLOW_NODE_DETAIL, nodeId); + } +} http://git-wip-us.apache.org/repos/asf/airavata/blob/e13d90da/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/GatewayResource.java ---------------------------------------------------------------------- diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/GatewayResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/GatewayResource.java new file mode 100644 index 0000000..d33fb05 --- /dev/null +++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/GatewayResource.java @@ -0,0 +1,436 @@ +/* + * + * 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.resources; + +import org.apache.airavata.persistance.registry.jpa.Resource; +import org.apache.airavata.persistance.registry.jpa.ResourceType; +import org.apache.airavata.persistance.registry.jpa.ResourceUtils; +import org.apache.airavata.persistance.registry.jpa.model.*; +import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator; +import org.apache.airavata.registry.cpi.RegistryException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.util.ArrayList; +import java.util.List; + +public class GatewayResource extends AbstractResource { + private final static Logger logger = LoggerFactory.getLogger(GatewayResource.class); + + private String gatewayId; + private String gatewayName; + private String domain; + private String emailAddress; + + public String getGatewayId() { + return gatewayId; + } + + public void setGatewayId(String gatewayId) { + this.gatewayId = gatewayId; + } + + public String getEmailAddress() { + return emailAddress; + } + + public void setEmailAddress(String emailAddress) { + this.emailAddress = emailAddress; + } + + /** + * + * @param gatewayId gateway name + */ + public GatewayResource(String gatewayId) { + setGatewayId(gatewayId); + } + + /** + * + */ + public GatewayResource() { + } + + /** + * + * @return gateway name + */ + public String getGatewayName() { + return gatewayName; + } + + /** + * + * @param gatewayName + */ + public void setGatewayName(String gatewayName) { + this.gatewayName = gatewayName; + } + + /** + * + * @return domain of the gateway + */ + public String getDomain() { + return domain; + } + + /** + * + * @param domain domain of the gateway + */ + public void setDomain(String domain) { + this.domain = domain; + } + + + /** + * Gateway is at the root level. So it can populate his child resources. + * Project, User, Published Workflows, User workflows, Host descriptors, + * Service Descriptors, Application descriptors and Experiments are all + * its children + * @param type resource type of the children + * @return specific child resource type + */ + public Resource create(ResourceType type) throws RegistryException { + switch (type) { + case PROJECT: + ProjectResource projectResource = new ProjectResource(); + projectResource.setGateway(this); + return projectResource; + case EXPERIMENT: + ExperimentResource experimentResource =new ExperimentResource(); + experimentResource.setGateway(this); + return experimentResource; + case GATEWAY_WORKER: + WorkerResource workerResource = new WorkerResource(); + workerResource.setGateway(this); + return workerResource; + default: + logger.error("Unsupported resource type for gateway resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for gateway resource."); + } + } + + /** + * Child resources can be removed from a gateway + * @param type child resource type + * @param name child resource name + */ + public void remove(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + switch (type) { + case USER: + generator = new QueryGenerator(USERS); + generator.setParameter(UserConstants.USERNAME, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name); + q = generator.deleteQuery(em); + q.executeUpdate(); + break; + default: + logger.error("Unsupported resource type for gateway resource.", new IllegalArgumentException()); + break; + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * Gateway can getExperiment information of his children + * @param type child resource type + * @param name child resource name + * @return specific child resource type + */ + public Resource get(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + QueryGenerator generator; + Query q; + switch (type) { + case GATEWAY_WORKER: + generator = new QueryGenerator(GATEWAY_WORKER); + generator.setParameter(GatewayWorkerConstants.USERNAME, name); + generator.setParameter(GatewayWorkerConstants.GATEWAY_ID, gatewayId); + q = generator.selectQuery(em); + Gateway_Worker worker = (Gateway_Worker) q.getSingleResult(); + WorkerResource workerResource = + (WorkerResource) Utils.getResource(ResourceType.GATEWAY_WORKER, worker); + em.getTransaction().commit(); + em.close(); + return workerResource; + case USER: + generator = new QueryGenerator(USERS); + generator.setParameter(UserConstants.USERNAME, name); + q = generator.selectQuery(em); + Users user = (Users) q.getSingleResult(); + UserResource userResource = + (UserResource) Utils.getResource(ResourceType.USER, user); + em.getTransaction().commit(); + em.close(); + return userResource; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name); + q = generator.selectQuery(em); + Experiment experiment = (Experiment) q.getSingleResult(); + ExperimentResource experimentResource = + (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + em.getTransaction().commit(); + em.close(); + return experimentResource; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for gateway resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for gateway resource."); + } + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + /** + * + * @param type child resource type + * @return list of child resources + */ + public List<Resource> get(ResourceType type) throws RegistryException{ + List<Resource> resourceList = new ArrayList<Resource>(); + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Query q; + QueryGenerator generator; + List results; + switch (type) { + case PROJECT: + generator = new QueryGenerator(PROJECT); + Gateway gatewayModel = em.find(Gateway.class, gatewayId); + generator.setParameter("gateway", gatewayModel); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Project project = (Project) result; + ProjectResource projectResource = + (ProjectResource) Utils.getResource(ResourceType.PROJECT, project); + resourceList.add(projectResource); + } + } + break; + case GATEWAY_WORKER: + generator = new QueryGenerator(GATEWAY_WORKER); + generator.setParameter(GatewayWorkerConstants.GATEWAY_ID, gatewayId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Gateway_Worker gatewayWorker = (Gateway_Worker) result; + WorkerResource workerResource = + (WorkerResource) Utils.getResource(ResourceType.GATEWAY_WORKER, gatewayWorker); + resourceList.add(workerResource); + } + } + break; + case EXPERIMENT: + generator = new QueryGenerator(EXPERIMENT); + generator.setParameter(ExperimentConstants.GATEWAY_ID, gatewayId); + q = generator.selectQuery(em); + results = q.getResultList(); + if (results.size() != 0) { + for (Object result : results) { + Experiment experiment = (Experiment) result; + ExperimentResource experimentResource = + (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment); + resourceList.add(experimentResource); + } + } + break; + case USER: + generator = new QueryGenerator(USERS); + q = generator.selectQuery(em); + for (Object o : q.getResultList()) { + Users user = (Users) o; + UserResource userResource = + (UserResource) Utils.getResource(ResourceType.USER, user); + resourceList.add(userResource); + } + break; + default: + em.getTransaction().commit(); + em.close(); + logger.error("Unsupported resource type for gateway resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for gateway resource."); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + return resourceList; + } + + /** + * saveExperiment the gateway to the database + */ + public void save() throws RegistryException { + EntityManager em = null; + try { + em = ResourceUtils.getEntityManager(); + Gateway existingGateway = em.find(Gateway.class, gatewayId); + em.close(); + + em = ResourceUtils.getEntityManager(); + em.getTransaction().begin(); + Gateway gateway = new Gateway(); + gateway.setGateway_name(gatewayName); + gateway.setGateway_id(gatewayId); + gateway.setDomain(domain); + gateway.setEmailAddress(emailAddress); + if (existingGateway != null) { + existingGateway.setDomain(domain); + existingGateway.setGateway_name(gatewayName); + existingGateway.setEmailAddress(emailAddress); + gateway = em.merge(existingGateway); + } else { + em.persist(gateway); + } + em.getTransaction().commit(); + em.close(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + + } + + /** + * check whether child resource already exist in the database + * @param type child resource type + * @param name name of the child resource + * @return true or false + */ + public boolean isExists(ResourceType type, Object name) throws RegistryException{ + EntityManager em = null; + try { + switch (type) { + case GATEWAY_WORKER: + em = ResourceUtils.getEntityManager(); + Gateway_Worker existingWorker = em.find(Gateway_Worker.class, new Gateway_Worker_PK(gatewayId, name.toString())); + em.close(); + return existingWorker != null; + case USER: + em = ResourceUtils.getEntityManager(); + Users existingUser = em.find(Users.class, name); + em.close(); + return existingUser != null; + case EXPERIMENT: + em = ResourceUtils.getEntityManager(); + Experiment existingExp = em.find(Experiment.class, name.toString()); + em.close(); + return existingExp != null; + default: + logger.error("Unsupported resource type for gateway resource.", new IllegalArgumentException()); + throw new IllegalArgumentException("Unsupported resource type for gateway resource."); + } + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RegistryException(e); + } finally { + if (em != null && em.isOpen()) { + if (em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + } + } + + public ExperimentResource createExperiment (String experimentID) throws RegistryException{ + ExperimentResource metadataResource = (ExperimentResource)create(ResourceType.EXPERIMENT); + metadataResource.setExpID(experimentID); + return metadataResource; + } + + public ExperimentResource getExperiment (String expId) throws RegistryException{ + return (ExperimentResource)get(ResourceType.EXPERIMENT, expId); + } + + public List<ExperimentResource> getExperiments () throws RegistryException{ + List<ExperimentResource> experiments = new ArrayList<ExperimentResource>(); + List<Resource> resources = get(ResourceType.EXPERIMENT); + for (Resource resource : resources){ + experiments.add((ExperimentResource)resource); + } + return experiments; + } +} +
