airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scnakand...@apache.org
Subject [14/44] airavata git commit: Adding mongo-registry WIP
Date Sun, 07 Jun 2015 17:00:55 GMT
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;
+    }
+}
+


Mime
View raw message