You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sc...@apache.org on 2015/06/07 19:00:52 UTC
[11/44] airavata git commit: Adding mongo-registry WIP
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/WorkerResource.java
----------------------------------------------------------------------
diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java
new file mode 100644
index 0000000..fbf7855
--- /dev/null
+++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java
@@ -0,0 +1,908 @@
+/*
+ *
+ * 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.model.workspace.experiment.ExperimentState;
+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.ResultOrderType;
+import org.apache.airavata.registry.cpi.utils.Constants;
+import org.apache.airavata.registry.cpi.utils.StatusType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.airavata.registry.cpi.RegistryException;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class WorkerResource extends AbstractResource {
+ private final static Logger logger = LoggerFactory.getLogger(WorkerResource.class);
+ private String user;
+ private GatewayResource gateway;
+
+ /**
+ *
+ */
+ public WorkerResource() {
+ }
+
+ /**
+ *
+ * @param user username
+ * @param gateway gatewayResource
+ */
+ public WorkerResource(String user, GatewayResource gateway) {
+ this.setUser(user);
+ this.gateway=gateway;
+ }
+
+ /**
+ * Gateway worker can create child data structures such as projects and user workflows
+ * @param type child resource type
+ * @return child resource
+ */
+ public Resource create(ResourceType type) throws RegistryException{
+ Resource result = null;
+ switch (type) {
+ case PROJECT:
+ ProjectResource projectResource = new ProjectResource();
+ projectResource.setWorker(this);
+ projectResource.setGateway(gateway);
+ result=projectResource;
+ break;
+ case EXPERIMENT:
+ ExperimentResource experimentResource = new ExperimentResource();
+ experimentResource.setExecutionUser(user);
+ experimentResource.setGateway(gateway);
+ result = experimentResource;
+ break;
+ default:
+ logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for worker resource.");
+
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @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 PROJECT:
+ generator = new QueryGenerator(PROJECT);
+ generator.setParameter(ProjectConstants.PROJECT_ID, 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 worker resource.", new IllegalArgumentException());
+ break;
+ }
+ em.getTransaction().commit();
+ em.close();
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e.getMessage());
+ } finally {
+ if (em != null && em.isOpen()) {
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @param name child resource name
+ * @return child resource
+ */
+ public Resource get(ResourceType type, Object name) throws RegistryException{
+ Resource result = null;
+ EntityManager em = null;
+ try {
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator;
+ Query q;
+ switch (type) {
+ case PROJECT:
+ generator = new QueryGenerator(PROJECT);
+ generator.setParameter(ProjectConstants.PROJECT_ID, name);
+ q = generator.selectQuery(em);
+ Project project = (Project) q.getSingleResult();
+ result = Utils.getResource(ResourceType.PROJECT, project);
+ break;
+ case EXPERIMENT:
+ generator = new QueryGenerator(EXPERIMENT);
+ generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name);
+ q = generator.selectQuery(em);
+ Experiment experiment = (Experiment) q.getSingleResult();
+ result = Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ break;
+ default:
+ logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException());
+ break;
+ }
+ em.getTransaction().commit();
+ em.close();
+ } catch (Exception e) {
+ throw new RegistryException(e);
+ } finally {
+ if (em != null && em.isOpen()) {
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ return result;
+ }
+
+// public List<GFacJobDataResource> getGFacJobs(String serviceDescriptionId, String hostDescriptionId, String applicationDescriptionId){
+// List<GFacJobDataResource> result = new ArrayList<GFacJobDataResource>();
+// EntityManager em = ResourceUtils.getEntityManager();
+// em.getTransaction().begin();
+// QueryGenerator generator;
+// Query q;
+// generator = new QueryGenerator(GFAC_JOB_DATA);
+// generator.setParameter(GFacJobDataConstants.SERVICE_DESC_ID, serviceDescriptionId);
+// generator.setParameter(GFacJobDataConstants.HOST_DESC_ID, hostDescriptionId);
+// generator.setParameter(GFacJobDataConstants.APP_DESC_ID, applicationDescriptionId);
+// q = generator.selectQuery(em);
+// for (Object o : q.getResultList()) {
+// GFac_Job_Data gFacJobData = (GFac_Job_Data)o;
+// result.add((GFacJobDataResource)Utils.getResource(ResourceType.GFAC_JOB_DATA, gFacJobData));
+// }
+// em.getTransaction().commit();
+// em.close();
+// return result;
+// }
+//
+// public List<GFacJobStatusResource> getGFacJobStatuses(String jobId){
+// List<GFacJobStatusResource> resourceList = new ArrayList<GFacJobStatusResource>();
+// EntityManager em = ResourceUtils.getEntityManager();
+// em.getTransaction().begin();
+// QueryGenerator generator;
+// Query q;
+// generator = new QueryGenerator(GFAC_JOB_STATUS);
+// generator.setParameter(GFacJobStatusConstants.LOCAL_JOB_ID, jobId);
+// q = generator.selectQuery(em);
+// for (Object result : q.getResultList()) {
+// GFac_Job_Status gFacJobStatus = (GFac_Job_Status) result;
+// GFacJobStatusResource gFacJobStatusResource =
+// (GFacJobStatusResource)Utils.getResource(ResourceType.GFAC_JOB_STATUS, gFacJobStatus);
+// resourceList.add(gFacJobStatusResource);
+// }
+// return resourceList;
+// }
+
+ /**
+ * Method getExperiment all results of the given child resource type
+ *
+ * @param type child resource type
+ * @return list of child resources
+ */
+ public List<Resource> get(ResourceType type) throws RegistryException{
+ return get(type, -1, -1, null, null);
+ }
+
+ /**
+ * Method getExperiment all results of the given child resource type with paginaltion and ordering
+ *
+ * @param type child resource type
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return list of child resources
+ * @throws RegistryException
+ */
+ public List<Resource> get(ResourceType type, int limit, int offset, Object orderByIdentifier,
+ ResultOrderType resultOrderType) throws RegistryException{
+ List<Resource> result = new ArrayList<Resource>();
+ EntityManager em = null;
+ try {
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator;
+ Query q;
+ switch (type) {
+ case PROJECT:
+ generator = new QueryGenerator(PROJECT);
+ Users users = em.find(Users.class, getUser());
+ Gateway gatewayModel = em.find(Gateway.class, gateway.getGatewayId());
+ generator.setParameter("users", users);
+ generator.setParameter("gateway", gatewayModel);
+
+ //ordering - only supported only by CREATION_TIME
+ if(orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)) {
+ q = generator.selectQuery(em, ProjectConstants.CREATION_TIME, resultOrderType);
+ }else{
+ q = generator.selectQuery(em);
+ }
+
+ //pagination
+ if(limit>0 && offset>=0){
+ q.setFirstResult(offset);
+ q.setMaxResults(limit);
+ }
+
+ for (Object o : q.getResultList()) {
+ Project project = (Project) o;
+ ProjectResource projectResource = (ProjectResource) Utils.getResource(ResourceType.PROJECT, project);
+ result.add(projectResource);
+ }
+ break;
+ case EXPERIMENT:
+ generator = new QueryGenerator(EXPERIMENT);
+ generator.setParameter(ExperimentConstants.EXECUTION_USER, getUser());
+
+ //ordering - only supported only by CREATION_TIME
+ if(orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)) {
+ q = generator.selectQuery(em, ExperimentConstants.CREATION_TIME, resultOrderType);
+ }else{
+ q = generator.selectQuery(em);
+ }
+
+ //pagination
+ if(limit>0 && offset>=0){
+ q.setFirstResult(offset);
+ q.setMaxResults(limit);
+ }
+ for (Object o : q.getResultList()) {
+ Experiment experiment = (Experiment) o;
+ ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ result.add(experimentResource);
+ }
+
+ break;
+ default:
+ logger.error("Unsupported resource type for worker 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();
+ }
+ }
+ return result;
+ }
+
+ /**
+ * saveExperiment gateway worker to database
+ */
+ public void save() throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = ResourceUtils.getEntityManager();
+ Gateway_Worker existingWorker = em.find(Gateway_Worker.class, new Gateway_Worker_PK(gateway.getGatewayId(), user));
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Gateway_Worker gatewayWorker = new Gateway_Worker();
+ Users existingUser = em.find(Users.class, this.user);
+ gatewayWorker.setUser(existingUser);
+ gatewayWorker.setUser_name(existingUser.getUser_name());
+ Gateway gatewaymodel = em.find(Gateway.class, gateway.getGatewayId());
+ gatewayWorker.setGateway(gatewaymodel);
+ gatewayWorker.setGateway_id(gatewaymodel.getGateway_id());
+ if (existingWorker != null) {
+ existingWorker.setUser_name(existingUser.getUser_name());
+ existingWorker.setUser(existingUser);
+ existingWorker.setGateway(gatewaymodel);
+ existingWorker.setGateway_id(gatewaymodel.getGateway_id());
+ gatewayWorker = em.merge(existingWorker);
+ } else {
+ em.persist(gatewayWorker);
+ }
+ 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 user name
+ */
+ public String getUser() {
+ return user;
+ }
+
+ /**
+ *
+ * @param user user name
+ */
+ public void setUser(String user) {
+ this.user = user;
+ }
+
+ /**
+ *
+ * @return gateway resource
+ */
+ public GatewayResource getGateway() {
+ return gateway;
+ }
+
+ /**
+ *
+ * @param gateway gateway resource
+ */
+ public void setGateway(GatewayResource gateway) {
+ this.gateway = gateway;
+ }
+
+ /**
+ *
+ * @param id project id
+ * @return whether the project is available under the user
+ */
+ public boolean isProjectExists(String id) throws RegistryException{
+ return isExists(ResourceType.PROJECT, id);
+ }
+
+ /**
+ *
+ * @param projectId project id
+ * @return project resource for the user
+ */
+ public ProjectResource createProject(String projectId) throws RegistryException{
+ ProjectResource project=(ProjectResource)create(ResourceType.PROJECT);
+ project.setId(projectId);
+ return project;
+ }
+
+ public String getProjectId(String projectName) {
+ String pro = projectName.replaceAll("\\s", "");
+ return pro + "_" + UUID.randomUUID();
+ }
+
+ /**
+ *
+ * @param id project id
+ * @return project resource
+ */
+ public ProjectResource getProject(String id) throws RegistryException{
+ return (ProjectResource)get(ResourceType.PROJECT, id);
+ }
+
+ /**
+ *
+ * @param id project id
+ */
+ public void removeProject(String id) throws RegistryException{
+ remove(ResourceType.PROJECT, id);
+ }
+
+ /**
+ * Get projects list of user
+ * @return list of projects for the user
+ */
+ public List<ProjectResource> getProjects() throws RegistryException{
+ return getProjects(-1, -1, null, null);
+ }
+
+
+ /**
+ * Get projects list of user with pagination and ordering
+ *
+ * @return list of projects for the user
+ */
+ public List<ProjectResource> getProjects(int limit, int offset, Object orderByIdentifier,
+ ResultOrderType resultOrderType) throws RegistryException{
+ List<ProjectResource> result=new ArrayList<ProjectResource>();
+ List<Resource> list = get(ResourceType.PROJECT, limit, offset, orderByIdentifier, resultOrderType);
+ for (Resource resource : list) {
+ result.add((ProjectResource) resource);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param name experiment name
+ * @return whether experiment is already exist for the given user
+ */
+ public boolean isExperimentExists(String name) throws RegistryException{
+ return isExists(ResourceType.EXPERIMENT, name);
+ }
+
+
+ /**
+ *
+ * @param name experiment name
+ * @return experiment resource
+ */
+ public ExperimentResource getExperiment(String name) throws RegistryException{
+ return (ExperimentResource)get(ResourceType.EXPERIMENT, name);
+ }
+//
+// public GFacJobDataResource getGFacJob(String jobId){
+// return (GFacJobDataResource)getExperiment(ResourceType.GFAC_JOB_DATA,jobId);
+// }
+
+ /**
+ * Method to getExperiment list of expeirments of user
+ * @return list of experiments for the user
+ */
+ public List<ExperimentResource> getExperiments() throws RegistryException{
+ return getExperiments(-1, -1, null, null);
+ }
+
+ /**
+ * Method to getExperiment list of experiments of user with pagination and ordering
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> getExperiments(int limit, int offset, Object orderByIdentifier,
+ ResultOrderType resultOrderType) throws RegistryException{
+ List<ExperimentResource> result=new ArrayList<ExperimentResource>();
+ List<Resource> list = get(ResourceType.EXPERIMENT, limit, offset, orderByIdentifier, resultOrderType);
+ for (Resource resource : list) {
+ result.add((ExperimentResource) resource);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param experimentId experiment name
+ */
+ public void removeExperiment(String experimentId) throws RegistryException{
+ remove(ResourceType.EXPERIMENT, experimentId);
+ }
+
+ /**
+ * To search projects of user with the given filter criteria. All the matching results will be sent.
+ * Results are not ordered in any order
+ * @param filters
+ * @return
+ * @throws RegistryException
+ */
+ public List<ProjectResource> searchProjects (Map<String, String> filters) throws RegistryException{
+ return searchProjects(filters, -1, -1, null, null);
+ }
+
+ /**
+ * To search the projects of user with the given filter criteria and retrieve the results with
+ * pagination support. Results can be ordered based on an identifier (i.e column) either ASC or
+ * DESC. But in the current implementation ordering is only supported based on the project
+ * creation time
+ *
+ * @param filters
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return
+ * @throws RegistryException
+ */
+ public List<ProjectResource> searchProjects(Map<String, String> filters, int limit,
+ int offset, Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException {
+ List<ProjectResource> result = new ArrayList<ProjectResource>();
+ EntityManager em = null;
+ try {
+ String query = "SELECT p from Project p WHERE ";
+ if (filters != null && filters.size() != 0) {
+ for (String field : filters.keySet()) {
+ String filterVal = filters.get(field);
+ if (field.equals(ProjectConstants.USERNAME)) {
+ query += "p." + field + "= '" + filterVal + "' AND ";
+ }else if (field.equals(ProjectConstants.GATEWAY_ID)) {
+ query += "p." + field + "= '" + filterVal + "' AND ";
+ }else {
+ if (filterVal.contains("*")){
+ filterVal = filterVal.replaceAll("\\*", "");
+ }
+ query += "p." + field + " LIKE '%" + filterVal + "%' AND ";
+ }
+ }
+ }
+ query = query.substring(0, query.length() - 5);
+
+ //ordering
+ if( orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ProjectConstants.CREATION_TIME)){
+ String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC";
+ query += " ORDER BY p." + ProjectConstants.CREATION_TIME + " " + order;
+ }
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+
+ //pagination
+ if(offset>=0 && limit >=0){
+ q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit);
+ }else{
+ q = em.createQuery(query);
+ }
+
+ List resultList = q.getResultList();
+ for (Object o : resultList) {
+ Project project = (Project) o;
+ ProjectResource projectResource =
+ (ProjectResource) Utils.getResource(ResourceType.PROJECT, project);
+ result.add(projectResource);
+ }
+ 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 result;
+ }
+
+ /**
+ * To search experiments of user with the given filter criteria. All the matching results will be sent.
+ * Results are not ordered in any order
+ * @param filters
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperiments (Map<String, String> filters) throws RegistryException{
+ return searchExperiments(filters, -1, -1, null, null);
+ }
+
+ /**
+ * To search the experiments of user with the given filter criteria and retrieve the results with
+ * pagination support. Results can be ordered based on an identifier (i.e column) either ASC or
+ * DESC. But in the current implementation ordering is only supported based on creationTime
+ *
+ * @param filters
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperiments(Map<String, String> filters, int limit,
+ int offset, Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException {
+
+ List<ExperimentResource> result = new ArrayList<ExperimentResource>();
+ EntityManager em = null;
+ try {
+ String query = "SELECT e from Experiment e WHERE ";
+ if (filters != null && filters.size() != 0) {
+ for (String field : filters.keySet()) {
+ String filterVal = filters.get(field);
+ if (field.equals(ExperimentConstants.EXECUTION_USER)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ }else if (field.equals(ExperimentConstants.GATEWAY_ID)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ } else if (field.equals(ExperimentConstants.PROJECT_ID)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ } else {
+ if (filterVal.contains("*")){
+ filterVal = filterVal.replaceAll("\\*", "");
+ }
+ query += "e." + field + " LIKE '%" + filterVal + "%' AND ";
+ }
+ }
+ }
+ query = query.substring(0, query.length() - 5);
+
+ //ordering
+ if( orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){
+ String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC";
+ query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order;
+ }
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+
+ //pagination
+ if(offset>=0 && limit >=0){
+ q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit);
+ }else{
+ q = em.createQuery(query);
+ }
+
+ List resultList = q.getResultList();
+ for (Object o : resultList) {
+ Experiment experiment = (Experiment) o;
+ ExperimentResource experimentResource =
+ (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ result.add(experimentResource);
+ }
+ 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 result;
+ }
+
+ /**
+ * Method to getExperiment experiments by state
+ * @param filters
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperimentsByState (Map<String, String> filters) throws RegistryException{
+ return searchExperimentsByState(filters, -1, -1, null, null);
+ }
+
+ /**
+ * Method to getExperiment experiments of the given state with pagination and ordering
+ * @param filters
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperimentsByState (Map<String, String> filters, int limit, int offset,
+ Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException{
+ List<ExperimentResource> result = new ArrayList<ExperimentResource>();
+ EntityManager em = null;
+ try {
+ String experimentState = ExperimentState.valueOf(filters.get(StatusConstants.STATE)).toString();
+ String query = "SELECT e FROM Status s " +
+ "JOIN s.experiment e " +
+ "WHERE s.state='" + experimentState + "' " +
+ "AND s.statusType='" + StatusType.EXPERIMENT + "' AND ";
+
+ filters.remove(StatusConstants.STATE);
+ if (filters.size() != 0) {
+ for (String field : filters.keySet()) {
+ String filterVal = filters.get(field);
+ if (field.equals(ExperimentConstants.EXECUTION_USER)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ }else if (field.equals(ExperimentConstants.GATEWAY_ID)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ } else if (field.equals(ExperimentConstants.PROJECT_ID)) {
+ query += "e." + field + "= '" + filterVal + "' AND ";
+ } else {
+ if (filterVal.contains("*")){
+ filterVal = filterVal.replaceAll("\\*", "");
+ }
+ query += "e." + field + " LIKE '%" + filterVal + "%' AND ";
+ }
+ }
+ }
+ query = query.substring(0, query.length() - 5);
+
+ //ordering
+ if( orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){
+ String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC";
+ query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order;
+ }
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+
+ //pagination
+ if(offset>=0 && limit >=0){
+ q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit);
+ }else{
+ q = em.createQuery(query);
+ }
+
+ List resultList = q.getResultList();
+ for (Object o : resultList) {
+ Experiment experiment = (Experiment) o;
+ ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ result.add(experimentResource);
+ }
+ 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 result;
+ }
+
+ /**
+ * Search experiments from creation time between interval. Returns all results
+ * @param fromTime
+ * @param toTime
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperimentsByCreationTime (Timestamp fromTime, Timestamp toTime) throws RegistryException{
+ return searchExperimentsByCreationTime(fromTime, toTime, -1, -1, null, null);
+ }
+
+
+ /**
+ * Search experiments from creation time between interval. Results are ordered creation time DESC.
+ * Supports pagination
+ *
+ * @param fromTime
+ * @param toTime
+ * @param limit
+ * @param offset
+ * @param orderByIdentifier
+ * @param resultOrderType
+ * @return
+ * @throws RegistryException
+ */
+ public List<ExperimentResource> searchExperimentsByCreationTime(
+ Timestamp fromTime, Timestamp toTime, int limit, int offset, Object orderByIdentifier,
+ ResultOrderType resultOrderType) throws RegistryException{
+
+ List<ExperimentResource> result = new ArrayList<ExperimentResource>();
+ EntityManager em = null;
+ try {
+ String query = "SELECT e FROM Experiment e " +
+ "WHERE e.creationTime > '" + fromTime + "' " +
+ "AND e.creationTime <'" + toTime + "'";
+
+ //ordering
+ if( orderByIdentifier != null && resultOrderType != null
+ && orderByIdentifier.equals(Constants.FieldConstants.ExperimentConstants.CREATION_TIME)){
+ String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC";
+ query += " ORDER BY e." + ExperimentConstants.CREATION_TIME + " " + order;
+ }
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+
+ //pagination
+ if(offset>=0 && limit >=0){
+ q = em.createQuery(query).setFirstResult(offset).setMaxResults(limit);
+ }else{
+ q = em.createQuery(query);
+ }
+
+ List resultList = q.getResultList();
+ for (Object o : resultList) {
+ Experiment experiment = (Experiment) o;
+ ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ result.add(experimentResource);
+ }
+ 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 result;
+ }
+
+ /**
+ *
+ * @return list of experiments for the user
+ */
+ public List<ExperimentResource> getExperimentsByCaching(String user) throws RegistryException{
+ List<ExperimentResource> result = new ArrayList<ExperimentResource>();
+ EntityManager em = null;
+ try {
+ String query = "SELECT e from Experiment e WHERE e.executionUser = '" + user + "'";
+ em = ResourceUtils.getEntityManager();
+// OpenJPAEntityManagerFactory oemf = OpenJPAPersistence.cast(em.getEntityManagerFactory());
+// QueryResultCache qcache = oemf.getQueryResultCache();
+ // qcache.evictAll(Experiment.class);
+ em.getTransaction().begin();
+ Query q = em.createQuery(query);
+ List resultList = q.getResultList();
+ for (Object o : resultList) {
+ Experiment experiment = (Experiment) o;
+ ExperimentResource experimentResource = (ExperimentResource) Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ result.add(experimentResource);
+ }
+ 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 result;
+ }
+}
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/WorkflowNodeDetailResource.java
----------------------------------------------------------------------
diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java
new file mode 100644
index 0000000..9d2869d
--- /dev/null
+++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowNodeDetailResource.java
@@ -0,0 +1,473 @@
+/*
+ *
+ * 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.utils.StatusType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.airavata.registry.cpi.RegistryException;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+public class WorkflowNodeDetailResource extends AbstractResource {
+ private static final Logger logger = LoggerFactory.getLogger(WorkflowNodeDetailResource.class);
+ private ExperimentResource experimentResource;
+ private String nodeInstanceId;
+ private Timestamp creationTime;
+ private String nodeName;
+ private String executionUnit;
+ private String executionUnitData;
+
+ public ExperimentResource getExperimentResource() {
+ return experimentResource;
+ }
+
+ public void setExperimentResource(ExperimentResource experimentResource) {
+ this.experimentResource = experimentResource;
+ }
+
+ public String getNodeInstanceId() {
+ return nodeInstanceId;
+ }
+
+ public void setNodeInstanceId(String nodeInstanceId) {
+ this.nodeInstanceId = nodeInstanceId;
+ }
+
+ public Timestamp getCreationTime() {
+ return creationTime;
+ }
+
+ public void setCreationTime(Timestamp creationTime) {
+ this.creationTime = creationTime;
+ }
+
+ public String getNodeName() {
+ return nodeName;
+ }
+
+ public void setNodeName(String nodeName) {
+ this.nodeName = nodeName;
+ }
+
+ public Resource create(ResourceType type) throws RegistryException{
+ switch (type){
+ case TASK_DETAIL:
+ TaskDetailResource taskDetailResource = new TaskDetailResource();
+ taskDetailResource.setWorkflowNodeDetailResource(this);
+ return taskDetailResource;
+ case ERROR_DETAIL:
+ ErrorDetailResource errorDetailResource = new ErrorDetailResource();
+ errorDetailResource.setNodeDetail(this);
+ return errorDetailResource;
+ case NODE_INPUT:
+ NodeInputResource nodeInputResource = new NodeInputResource();
+ nodeInputResource.setNodeDetailResource(this);
+ return nodeInputResource;
+ case NODE_OUTPUT:
+ NodeOutputResource nodeOutputResource = new NodeOutputResource();
+ nodeOutputResource.setNodeDetailResource(this);
+ return nodeOutputResource;
+ case STATUS:
+ StatusResource statusResource = new StatusResource();
+ statusResource.setWorkflowNodeDetail(this);
+ return statusResource;
+ default:
+ logger.error("Unsupported resource type for workflow node detail resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for workflow node detail resource.");
+ }
+ }
+
+ 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 TASK_DETAIL:
+ generator = new QueryGenerator(TASK_DETAIL);
+ generator.setParameter(TaskDetailConstants.TASK_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case ERROR_DETAIL:
+ generator = new QueryGenerator(ERROR_DETAIL);
+ generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case NODE_INPUT:
+ generator = new QueryGenerator(NODE_INPUT);
+ generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case NODE_OUTPUT:
+ generator = new QueryGenerator(NODE_OUTPUT);
+ generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case STATUS:
+ generator = new QueryGenerator(STATUS);
+ generator.setParameter(StatusConstants.NODE_INSTANCE_ID, name);
+ generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.WORKFLOW_NODE.toString());
+ 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();
+ }
+ }
+ }
+
+ 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 TASK_DETAIL:
+ generator = new QueryGenerator(TASK_DETAIL);
+ generator.setParameter(TaskDetailConstants.TASK_ID, name);
+ q = generator.selectQuery(em);
+ TaskDetail taskDetail = (TaskDetail) q.getSingleResult();
+ TaskDetailResource taskDetailResource = (TaskDetailResource) Utils.getResource(ResourceType.TASK_DETAIL, taskDetail);
+ em.getTransaction().commit();
+ em.close();
+ return taskDetailResource;
+ case ERROR_DETAIL:
+ generator = new QueryGenerator(ERROR_DETAIL);
+ generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_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 NODE_INPUT:
+ generator = new QueryGenerator(NODE_INPUT);
+ generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, name);
+ q = generator.selectQuery(em);
+ NodeInput nodeInput = (NodeInput) q.getSingleResult();
+ NodeInputResource nodeInputResource = (NodeInputResource) Utils.getResource(ResourceType.NODE_INPUT, nodeInput);
+ em.getTransaction().commit();
+ em.close();
+ return nodeInputResource;
+ case NODE_OUTPUT:
+ generator = new QueryGenerator(NODE_OUTPUT);
+ generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, name);
+ q = generator.selectQuery(em);
+ NodeOutput nodeOutput = (NodeOutput) q.getSingleResult();
+ NodeOutputResource nodeOutputResource = (NodeOutputResource) Utils.getResource(ResourceType.NODE_OUTPUT, nodeOutput);
+ em.getTransaction().commit();
+ em.close();
+ return nodeOutputResource;
+ case STATUS:
+ generator = new QueryGenerator(STATUS);
+ generator.setParameter(StatusConstants.NODE_INSTANCE_ID, name);
+ generator.setParameter(StatusConstants.STATUS_TYPE, StatusType.WORKFLOW_NODE.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;
+ default:
+ em.getTransaction().commit();
+ em.close();
+ logger.error("Unsupported resource type for workflow node resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for workflow node resource.");
+ }
+ } catch (Exception e) {
+ throw new RegistryException(e);
+ } finally {
+ if (em != null && em.isOpen()) {
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ 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 TASK_DETAIL:
+ generator = new QueryGenerator(TASK_DETAIL);
+ generator.setParameter(TaskDetailConstants.NODE_INSTANCE_ID, nodeInstanceId);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ TaskDetail taskDetail = (TaskDetail) result;
+ TaskDetailResource taskDetailResource =
+ (TaskDetailResource) Utils.getResource(ResourceType.TASK_DETAIL, taskDetail);
+ resourceList.add(taskDetailResource);
+ }
+ }
+ break;
+ case ERROR_DETAIL:
+ generator = new QueryGenerator(ERROR_DETAIL);
+ generator.setParameter(ErrorDetailConstants.NODE_INSTANCE_ID, nodeInstanceId);
+ 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 NODE_INPUT:
+ generator = new QueryGenerator(NODE_INPUT);
+ generator.setParameter(NodeInputConstants.NODE_INSTANCE_ID, nodeInstanceId);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ NodeInput nodeInput = (NodeInput) result;
+ NodeInputResource nodeInputResource =
+ (NodeInputResource) Utils.getResource(ResourceType.NODE_INPUT, nodeInput);
+ resourceList.add(nodeInputResource);
+ }
+ }
+ break;
+ case NODE_OUTPUT:
+ generator = new QueryGenerator(NODE_OUTPUT);
+ generator.setParameter(NodeOutputConstants.NODE_INSTANCE_ID, nodeInstanceId);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ NodeOutput nodeOutput = (NodeOutput) result;
+ NodeOutputResource nodeOutputResource =
+ (NodeOutputResource) Utils.getResource(ResourceType.NODE_OUTPUT, nodeOutput);
+ resourceList.add(nodeOutputResource);
+ }
+ }
+ break;
+ case STATUS:
+ generator = new QueryGenerator(STATUS);
+ generator.setParameter(StatusConstants.NODE_INSTANCE_ID, nodeInstanceId);
+ 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 workflow node details 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;
+ }
+
+ public void save() throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = ResourceUtils.getEntityManager();
+ WorkflowNodeDetail existingNode = em.find(WorkflowNodeDetail.class, nodeInstanceId);
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ WorkflowNodeDetail workflowNodeDetail = new WorkflowNodeDetail();
+ workflowNodeDetail.setNodeId(nodeInstanceId);
+ Experiment experiment = em.find(Experiment.class, experimentResource.getExpID());
+ workflowNodeDetail.setExperiment(experiment);
+ workflowNodeDetail.setExpId(experimentResource.getExpID());
+ workflowNodeDetail.setCreationTime(creationTime);
+ workflowNodeDetail.setNodeName(nodeName);
+ workflowNodeDetail.setExecutionUnit(getExecutionUnit());
+ workflowNodeDetail.setExecutionUnitData(getExecutionUnitData());
+
+ if (existingNode != null) {
+ existingNode.setExperiment(experiment);
+ existingNode.setExpId(experimentResource.getExpID());
+ existingNode.setCreationTime(creationTime);
+ existingNode.setNodeName(nodeName);
+ existingNode.setExecutionUnit(getExecutionUnit());
+ existingNode.setExecutionUnitData(getExecutionUnitData());
+ workflowNodeDetail = em.merge(existingNode);
+ } else {
+ em.persist(workflowNodeDetail);
+ }
+ 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();
+ }
+ }
+ }
+
+ public List<NodeInputResource> getNodeInputs() throws RegistryException{
+ List<NodeInputResource> nodeInputResourceList = new ArrayList<NodeInputResource>();
+ List<Resource> resources = get(ResourceType.NODE_INPUT);
+ for (Resource resource : resources) {
+ NodeInputResource nodeInputResource = (NodeInputResource) resource;
+ nodeInputResourceList.add(nodeInputResource);
+ }
+ return nodeInputResourceList;
+ }
+
+ public List<NodeOutputResource> getNodeOutputs() throws RegistryException{
+ List<NodeOutputResource> outputResources = new ArrayList<NodeOutputResource>();
+ List<Resource> resources = get(ResourceType.NODE_OUTPUT);
+ for (Resource resource : resources) {
+ NodeOutputResource nodeOutputResource = (NodeOutputResource) resource;
+ outputResources.add(nodeOutputResource);
+ }
+ return outputResources;
+ }
+
+ public StatusResource getWorkflowNodeStatus() throws RegistryException{
+ List<Resource> resources = get(ResourceType.STATUS);
+ for (Resource resource : resources) {
+ StatusResource nodeStatus = (StatusResource) resource;
+ if(nodeStatus.getStatusType().equals(StatusType.WORKFLOW_NODE.toString())){
+ if (nodeStatus.getState() == null || nodeStatus.getState().equals("") ){
+ nodeStatus.setState("UNKNOWN");
+ }
+ return nodeStatus;
+ }
+ }
+ return null;
+ }
+
+ public StatusResource getTaskStatus(String taskId) throws RegistryException{
+ List<Resource> resources = get(ResourceType.STATUS);
+ for (Resource resource : resources) {
+ StatusResource taskStatus = (StatusResource) resource;
+ if(taskStatus.getStatusType().equals(StatusType.TASK.toString()) && taskStatus.getTaskDetailResource().getTaskId().equals(taskId)){
+ if (taskStatus.getState() == null || taskStatus.getState().equals("") ){
+ taskStatus.setState("UNKNOWN");
+ }
+ return taskStatus;
+ }
+ }
+ return null;
+ }
+
+ public List<TaskDetailResource> getTaskDetails() throws RegistryException{
+ List<TaskDetailResource> taskDetailResources = new ArrayList<TaskDetailResource>();
+ List<Resource> resources = get(ResourceType.TASK_DETAIL);
+ for (Resource resource : resources) {
+ TaskDetailResource taskDetailResource = (TaskDetailResource) resource;
+ taskDetailResources.add(taskDetailResource);
+ }
+ return taskDetailResources;
+ }
+
+ public List<ErrorDetailResource> getErrorDetails() throws RegistryException{
+ List<ErrorDetailResource> errorDetails = new ArrayList<ErrorDetailResource>();
+ List<Resource> resources = get(ResourceType.ERROR_DETAIL);
+ for (Resource resource : resources) {
+ ErrorDetailResource errorDetailResource = (ErrorDetailResource) resource;
+ errorDetails.add(errorDetailResource);
+ }
+ return errorDetails;
+ }
+
+ public TaskDetailResource getTaskDetail(String taskId) throws RegistryException{
+ return (TaskDetailResource)get(ResourceType.TASK_DETAIL, taskId);
+ }
+
+ public String getExecutionUnit() {
+ return executionUnit;
+ }
+
+ public void setExecutionUnit(String executionUnit) {
+ this.executionUnit = executionUnit;
+ }
+
+ public String getExecutionUnitData() {
+ return executionUnitData;
+ }
+
+ public void setExecutionUnitData(String executionUnitData) {
+ this.executionUnitData = executionUnitData;
+ }
+}
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/utils/QueryGenerator.java
----------------------------------------------------------------------
diff --git a/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java
new file mode 100644
index 0000000..b0ebe45
--- /dev/null
+++ b/modules/registry/airavata-mongo-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java
@@ -0,0 +1,128 @@
+/*
+ *
+ * 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.utils;
+
+import org.apache.airavata.registry.cpi.ResultOrderType;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+import java.util.HashMap;
+import java.util.Map;
+
+public class QueryGenerator {
+ private String tableName;
+ private Map<String,Object> matches=new HashMap<String, Object>();
+ private static final String SELECT_OBJ="p";
+ private static final String DELETE_OBJ="p";
+ private static final String TABLE_OBJ="p";
+//
+// public QueryGenerator(String tableName) {
+// setTableName(tableName);
+// }
+
+ public QueryGenerator(String tableName, Object[]...params) {
+ setTableName(tableName);
+ for (Object[] param : params) {
+ addMatch(param[0].toString(), param[1]);
+ }
+ }
+
+ public String getTableName() {
+ return tableName;
+ }
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ }
+ public void addMatch(String colName, Object matchValue){
+ matches.put(colName, matchValue);
+ }
+
+ public void setParameter(String colName, Object matchValue){
+ addMatch(colName, matchValue);
+ }
+
+ /**
+ * Select query
+ * @param entityManager
+ * @return
+ */
+ public Query selectQuery(EntityManager entityManager){
+ String queryString="SELECT "+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ;
+ return generateQueryWithParameters(entityManager, queryString);
+ }
+
+ /**
+ * Select query with pagination
+ * @param entityManager
+ * @param orderByColumn
+ * @param resultOrderType
+ * @return
+ */
+ public Query selectQuery(EntityManager entityManager, String orderByColumn,
+ ResultOrderType resultOrderType){
+ String order = (resultOrderType == ResultOrderType.ASC) ? "ASC" : "DESC";
+ String orderByClause = " ORDER BY " + SELECT_OBJ + "." + orderByColumn + " " + order;
+ String queryString="SELECT "+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ;
+ return generateQueryWithParameters(entityManager, queryString, orderByClause);
+ }
+
+// public Query countQuery(EntityManager entityManager){
+// SELECT COUNT(p.host_descriptor_ID) FROM Host_Descriptor p WHERE p.gateway_name =:gate_ID and p.host_descriptor_ID =:host_desc_name")
+// String queryString="SELECT COUNT("+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ;
+// return generateQueryWithParameters(entityManager, queryString);
+// }
+
+ public Query deleteQuery(EntityManager entityManager){
+ String queryString="Delete FROM "+getTableName()+" "+TABLE_OBJ;
+ return generateQueryWithParameters(entityManager, queryString);
+ }
+
+ private Query generateQueryWithParameters(EntityManager entityManager,
+ String queryString) {
+ return generateQueryWithParameters(entityManager, queryString, "");
+ }
+
+ private Query generateQueryWithParameters(EntityManager entityManager,
+ String queryString, String orderByClause) {
+ Map<String,Object> queryParameters=new HashMap<String, Object>();
+ if (matches.size()>0){
+ String matchString = "";
+ int paramCount=0;
+ for (String colName : matches.keySet()) {
+ String paramName="param"+paramCount;
+ queryParameters.put(paramName, matches.get(colName));
+ if (!matchString.equals("")){
+ matchString+=" AND ";
+ }
+ matchString+=TABLE_OBJ+"."+colName+" =:"+paramName;
+ paramCount++;
+ }
+ queryString+=" WHERE "+matchString;
+ }
+ queryString += orderByClause;
+ Query query = entityManager.createQuery(queryString);
+ for (String paramName : queryParameters.keySet()) {
+ query.setParameter(paramName, queryParameters.get(paramName));
+ }
+ return query;
+ }
+}