You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by la...@apache.org on 2013/12/26 18:31:40 UTC
svn commit: r1553518 [7/15] - in /airavata/sandbox: orchestrator-service/
orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/
orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/context/
or...
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserResource.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserResource.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserResource.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserResource.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,204 @@
+/*
+ *
+ * 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 java.security.NoSuchAlgorithmException;
+import java.util.List;
+
+import org.apache.airavata.common.utils.SecurityUtil;
+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.Users;
+import org.apache.airavata.registry.api.exception.RegistrySettingsException;
+import org.apache.airavata.registry.api.util.RegistrySettings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.EntityManager;
+
+public class UserResource extends AbstractResource {
+ private final static Logger logger = LoggerFactory.getLogger(UserResource.class);
+ private String userName;
+ private String password;
+ private String gatewayName;
+ private ProjectResource projectResource;
+
+ /**
+ *
+ */
+ public UserResource() {
+ }
+
+ /**
+ *
+ * @param userName user name
+ */
+ public void setUserName(String userName) {
+ this.userName = userName;
+ }
+
+ /**
+ *
+ * @return user name
+ */
+ public String getUserName() {
+ return userName;
+ }
+
+ /**
+ *
+ * @return gateway name
+ */
+ public String getGatewayName() {
+ return gatewayName;
+ }
+
+ /**
+ *
+ * @param gatewayName gateway name
+ */
+ public void setGatewayName(String gatewayName) {
+ this.gatewayName = gatewayName;
+ }
+
+ /**
+ * User is a hypothical data structure.
+ * @param type child resource type
+ * @return child resource
+ */
+ public Resource create(ResourceType type) {
+ logger.error("Unsupported resource type for user resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @param name child resource name
+ */
+ public void remove(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @param name child resource name
+ * @return UnsupportedOperationException
+ */
+ public Resource get(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @return UnsupportedOperationException
+ */
+ public List<Resource> get(ResourceType type) {
+ logger.error("Unsupported resource type for user resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * save user to the database
+ */
+ public void save() {
+ EntityManager em = ResourceUtils.getEntityManager();
+ Users existingUser = em.find(Users.class, userName);
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Users user = new Users();
+ user.setUser_name(userName);
+ try {
+ user.setPassword(SecurityUtil.digestString(password,
+ RegistrySettings.getSetting("default.registry.password.hash.method")));
+ } catch (NoSuchAlgorithmException e) {
+ throw new RuntimeException("Error hashing default admin password. Invalid hash algorithm.", e);
+ } catch (RegistrySettingsException e) {
+ throw new RuntimeException("Error reading hash algorithm from configurations", e);
+ }
+ if(existingUser != null){
+ try {
+ existingUser.setPassword(SecurityUtil.digestString(password,
+ RegistrySettings.getSetting("default.registry.password.hash.method")));
+ } catch (NoSuchAlgorithmException e) {
+ throw new RuntimeException("Error hashing default admin password. Invalid hash algorithm.", e);
+ } catch (RegistrySettingsException e) {
+ throw new RuntimeException("Error reading hash algorithm from configurations", e);
+ }
+
+ user = em.merge(existingUser);
+ }else {
+ em.persist(user);
+ }
+ em.getTransaction().commit();
+ em.close();
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @param name child resource name
+ * @return UnsupportedOperationException
+ */
+ public boolean isExists(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ *
+ * @return project resource
+ */
+ public ProjectResource getProjectResource() {
+ return projectResource;
+ }
+
+ /**
+ *
+ * @param projectResource project resource
+ */
+ public void setProjectResource(ProjectResource projectResource) {
+ this.projectResource = projectResource;
+ }
+
+ /**
+ *
+ * @return password
+ */
+ public String getPassword() {
+ return password;
+ }
+
+ /**
+ *
+ * @param password password
+ */
+ public void setPassword(String password) {
+ this.password = password;
+ }
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserWorkflowResource.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserWorkflowResource.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserWorkflowResource.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/UserWorkflowResource.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,187 @@
+/*
+ *
+ * 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.Gateway;
+import org.apache.airavata.persistance.registry.jpa.model.User_Workflow;
+import org.apache.airavata.persistance.registry.jpa.model.User_Workflow_PK;
+import org.apache.airavata.persistance.registry.jpa.model.Users;
+import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator;
+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 UserWorkflowResource extends AbstractResource {
+ private final static Logger logger = LoggerFactory.getLogger(UserWorkflowResource.class);
+ private GatewayResource gateway;
+ private WorkerResource worker;
+ private String name;
+ private Timestamp lastUpdateDate;
+ private String content;
+ private String path;
+
+ public UserWorkflowResource() {
+ }
+
+ public UserWorkflowResource(GatewayResource gateway, WorkerResource worker, String name) {
+ this.setGateway(gateway);
+ this.setWorker(worker);
+ this.name = name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setLastUpdateDate(Timestamp lastUpdateDate) {
+ this.lastUpdateDate = lastUpdateDate;
+ }
+
+ public void setContent(String content) {
+ this.content = content;
+ }
+
+ public Timestamp getLastUpdateDate() {
+ return lastUpdateDate;
+ }
+
+ public String getContent() {
+ return content;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public void setPath(String path) {
+ this.path = path;
+ }
+
+ public Resource create(ResourceType type) {
+ logger.error("Unsupported resource type for user workflow resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ public void remove(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user workflow resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ public Resource get(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user workflow resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ *
+ * @param keys should be in the order of gateway_name,user_name and user_workflow_name
+ * @return resource list
+ */
+ public List<Resource> populate(Object[] keys) {
+ List<Resource> list = new ArrayList<Resource>();
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator queryGenerator = new QueryGenerator(USER_WORKFLOW);
+ queryGenerator.setParameter(UserWorkflowConstants.GATEWAY_NAME, keys[0]);
+ queryGenerator.setParameter(UserWorkflowConstants.OWNER, keys[1]);
+ queryGenerator.setParameter(UserWorkflowConstants.TEMPLATE_NAME, keys[2]);
+ Query q = queryGenerator.selectQuery(em);
+ User_Workflow userWorkflow = (User_Workflow)q.getSingleResult();
+ UserWorkflowResource userWorkflowResource = (UserWorkflowResource)Utils.getResource(
+ ResourceType.USER_WORKFLOW, userWorkflow);
+ em.getTransaction().commit();
+ em.close();
+ list.add(userWorkflowResource);
+ return list;
+ }
+
+ public List<Resource> get(ResourceType type) {
+ logger.error("Unsupported resource type for user workflow resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ public void save() {
+ EntityManager em = ResourceUtils.getEntityManager();
+ User_Workflow existingWF = em.find(User_Workflow.class, new User_Workflow_PK(name, worker.getUser(), gateway.getGatewayName()));
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ User_Workflow userWorkflow = new User_Workflow();
+ userWorkflow.setTemplate_name(name);
+ if(lastUpdateDate == null){
+ java.util.Date date= new java.util.Date();
+ lastUpdateDate = new Timestamp(date.getTime());
+ }
+ userWorkflow.setLast_updated_date(lastUpdateDate);
+ byte[] bytes = content.getBytes();
+ userWorkflow.setWorkflow_graph(bytes);
+ userWorkflow.setGateway_name(this.gateway.getGatewayName());
+ userWorkflow.setOwner(this.getWorker().getUser());
+ userWorkflow.setPath(path);
+ if(existingWF != null){
+ existingWF.setGateway_name(this.gateway.getGatewayName());
+ existingWF.setOwner(this.getWorker().getUser());
+ existingWF.setTemplate_name(name);
+ existingWF.setLast_updated_date(lastUpdateDate);
+ existingWF.setPath(path);
+ existingWF.setWorkflow_graph(bytes);
+ userWorkflow = em.merge(existingWF);
+ } else {
+ em.persist(userWorkflow);
+ }
+ em.getTransaction().commit();
+ em.close();
+ }
+
+ public boolean isExists(ResourceType type, Object name) {
+ logger.error("Unsupported resource type for user workflow resource.", new UnsupportedOperationException());
+ throw new UnsupportedOperationException();
+ }
+
+ public GatewayResource getGateway() {
+ return gateway;
+ }
+
+ public void setGateway(GatewayResource gateway) {
+ this.gateway = gateway;
+ }
+
+ public WorkerResource getWorker() {
+ return worker;
+ }
+
+ public void setWorker(WorkerResource worker) {
+ this.worker = worker;
+ }
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/Utils.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/Utils.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/Utils.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/Utils.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,652 @@
+/*
+ *
+ * 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 java.net.URI;
+
+import org.apache.airavata.persistance.registry.jpa.JPAConstants;
+import org.apache.airavata.persistance.registry.jpa.Resource;
+import org.apache.airavata.persistance.registry.jpa.ResourceType;
+import org.apache.airavata.persistance.registry.jpa.model.*;
+import org.apache.airavata.registry.api.AiravataRegistryConnectionDataProvider;
+import org.apache.airavata.registry.api.AiravataRegistryFactory;
+import org.apache.airavata.registry.api.exception.RegistrySettingsException;
+import org.apache.airavata.registry.api.util.RegistrySettings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class Utils {
+ private final static Logger logger = LoggerFactory.getLogger(Utils.class);
+
+ public static String getJDBCFullURL(){
+ String jdbcUrl = getJDBCURL();
+ String jdbcUser = getJDBCUser();
+ String jdbcPassword = getJDBCPassword();
+ jdbcUrl = jdbcUrl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword;
+ return jdbcUrl;
+ }
+
+ public static String getJDBCURL(){
+ try {
+ return getProvider().getValue(JPAConstants.KEY_JDBC_URL).toString();
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static String getHost(){
+ try{
+ String jdbcURL = getJDBCURL();
+ String cleanURI = jdbcURL.substring(5);
+ URI uri = URI.create(cleanURI);
+ return uri.getHost();
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static int getPort(){
+ try{
+ String jdbcURL = getJDBCURL();
+ String cleanURI = jdbcURL.substring(5);
+ URI uri = URI.create(cleanURI);
+ return uri.getPort();
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ return -1;
+ }
+ }
+
+ public static String getDBType(){
+ try{
+ String jdbcURL = getJDBCURL();
+ String cleanURI = jdbcURL.substring(5);
+ URI uri = URI.create(cleanURI);
+ return uri.getScheme();
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static boolean isDerbyStartEnabled(){
+ try {
+ String s = getProvider().getValue(JPAConstants.KEY_DERBY_START_ENABLE).toString();
+ if("true".equals(s)){
+ return true;
+ }
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return false;
+ }
+ return false;
+ }
+
+ private static AiravataRegistryConnectionDataProvider getProvider() {
+ return AiravataRegistryFactory.getRegistryConnectionDataProvider();
+ }
+
+ static {
+ if(AiravataRegistryFactory.getRegistryConnectionDataProvider() == null){
+ AiravataRegistryFactory.registerRegistryConnectionDataProvider(new AiravataRegistryConnectionDataProviderImpl());
+ }
+
+ }
+
+ public static String getJDBCUser(){
+ try {
+ if (getProvider()!=null){
+ return getProvider().getValue(JPAConstants.KEY_JDBC_USER).toString();
+ } else {
+ return RegistrySettings.getSetting(JPAConstants.KEY_JDBC_USER);
+ }
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static String getValidationQuery(){
+ try {
+ if (getProvider()!=null){
+ if(getProvider().getValue(JPAConstants.VALIDATION_QUERY) != null){
+ return getProvider().getValue(JPAConstants.VALIDATION_QUERY).toString();
+ }
+ } else {
+ if(getProvider().getValue(JPAConstants.VALIDATION_QUERY) != null){
+ return RegistrySettings.getSetting(JPAConstants.VALIDATION_QUERY);
+ }
+ }
+ return "";
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static String getJPAConnectionProperties(){
+ try {
+ if (getProvider()!=null){
+ if(getProvider().getValue(JPAConstants.CONNECTION_JPA_PROPERTY) != null){
+ return getProvider().getValue(JPAConstants.CONNECTION_JPA_PROPERTY).toString();
+ }
+ } else {
+ if(getProvider().getValue(JPAConstants.CONNECTION_JPA_PROPERTY) != null){
+ return RegistrySettings.getSetting(JPAConstants.CONNECTION_JPA_PROPERTY);
+ }
+ }
+ return "";
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ public static String getJDBCPassword(){
+ try {
+ if (getProvider()!=null){
+ return getProvider().getValue(JPAConstants.KEY_JDBC_PASSWORD).toString();
+ }else {
+ return RegistrySettings.getSetting(JPAConstants.KEY_JDBC_PASSWORD);
+ }
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+
+ }
+
+ public static String getJDBCDriver(){
+ try {
+ if (getProvider()!=null){
+ return getProvider().getValue(JPAConstants.KEY_JDBC_DRIVER).toString();
+ } else {
+ return RegistrySettings.getSetting(JPAConstants.KEY_JDBC_DRIVER);
+ }
+ } catch (RegistrySettingsException e) {
+ logger.error(e.getMessage(), e);
+ return null;
+ }
+ }
+
+ /**
+ *
+ * @param type model type
+ * @param o model type instance
+ * @return corresponding resource object
+ */
+ public static Resource getResource(ResourceType type, Object o) {
+ switch (type){
+ case GATEWAY:
+ if (o instanceof Gateway) {
+ return createGateway((Gateway) o);
+ } else {
+ logger.error("Object should be a Gateway.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Gateway.");
+ }
+ case PROJECT:
+ if (o instanceof Project){
+ return createProject((Project) o);
+ } else {
+ logger.error("Object should be a Project.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Project.");
+ }
+ case CONFIGURATION:
+ if(o instanceof Configuration){
+ return createConfiguration((Configuration) o);
+ }else {
+ logger.error("Object should be a Configuration.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Configuration.");
+ }
+ case APPLICATION_DESCRIPTOR:
+ if (o instanceof Application_Descriptor){
+ return createApplicationDescriptor((Application_Descriptor) o);
+ } else {
+ logger.error("Object should be a Application Descriptor.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Application Descriptor.");
+ }
+ case EXPERIMENT:
+ if (o instanceof Experiment){
+ return createExperiment((Experiment) o);
+ } else {
+ logger.error("Object should be a Experiment.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Experiment.");
+ }
+ case USER:
+ if(o instanceof Users) {
+ return createUser((Users) o);
+ }else {
+ logger.error("Object should be a User.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a User.");
+ }
+ case HOST_DESCRIPTOR:
+ if (o instanceof Host_Descriptor){
+ return createHostDescriptor((Host_Descriptor) o);
+ }else {
+ logger.error("Object should be a Host Descriptor.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Host Descriptor.");
+ }
+ case SERVICE_DESCRIPTOR:
+ if (o instanceof Service_Descriptor){
+ return createServiceDescriptor((Service_Descriptor) o);
+ }else {
+ logger.error("Object should be a Service Descriptor.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Service Descriptor.");
+ }
+ case PUBLISHED_WORKFLOW:
+ if (o instanceof Published_Workflow){
+ return createPublishWorkflow((Published_Workflow) o);
+ }else {
+ logger.error("Object should be a Publish Workflow.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Publish Workflow.");
+ }
+ case USER_WORKFLOW:
+ if (o instanceof User_Workflow){
+ return createUserWorkflow((User_Workflow) o);
+ }else {
+ logger.error("Object should be a User Workflow.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a User Workflow.");
+ }
+ case GATEWAY_WORKER:
+ if (o instanceof Gateway_Worker){
+ return createGatewayWorker((Gateway_Worker)o);
+ } else {
+ logger.error("Object should be a Gateway Worker.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Gateway Worker.");
+ }
+ case EXPERIMENT_DATA:
+ if (o instanceof Experiment_Data){
+ return createExperimentData((Experiment_Data)o);
+ }else {
+ logger.error("Object should be a Experiment Data.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Experiment Data.");
+ }
+ case EXPERIMENT_METADATA:
+ if (o instanceof Experiment_Metadata){
+ return createExperimentMetadata((Experiment_Metadata)o);
+ }else {
+ logger.error("Object should be a Experiment Metadata.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Experiment Metadata.");
+ }
+ case WORKFLOW_DATA:
+ if (o instanceof Workflow_Data){
+ return createWorkflowData((Workflow_Data) o);
+ }else {
+ logger.error("Object should be a Workflow Data.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Workflow Data.");
+ }
+ case NODE_DATA:
+ if (o instanceof Node_Data){
+ return createNodeData((Node_Data) o);
+ }else {
+ logger.error("Object should be a Node Data.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Node Data.");
+ }
+ case GRAM_DATA:
+ if (o instanceof Gram_Data){
+ return createGramData((Gram_Data) o);
+ }else {
+ logger.error("Object should be a Gram Data.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Gram Data.");
+ }
+ case EXECUTION_ERROR:
+ if (o instanceof Execution_Error){
+ return createExecutionError((Execution_Error) o);
+ }else {
+ logger.error("Object should be a Node Error type.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a Node Error.");
+ }
+ case GFAC_JOB_DATA:
+ if (o instanceof GFac_Job_Data){
+ return createGfacJobData((GFac_Job_Data) o);
+ }else {
+ logger.error("Object should be a GFac Job Data type.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a GFac Job Data.");
+ }
+ case GFAC_JOB_STATUS:
+ if (o instanceof GFac_Job_Status){
+ return createGfacJobStatus((GFac_Job_Status) o);
+ }else {
+ logger.error("Object should be a GFac Job Status type.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Object should be a GFac Job Status.");
+ }
+ default:
+ }
+ return null;
+
+ }
+
+ /**
+ *
+ * @param o Gateway model object
+ * @return GatewayResource object
+ */
+ private static Resource createGateway(Gateway o) {
+ GatewayResource gatewayResource = new GatewayResource();
+ gatewayResource.setGatewayName(o.getGateway_name());
+ return gatewayResource;
+ }
+
+ /**
+ *
+ * @param o Project model object
+ * @return ProjectResource object
+ */
+ private static Resource createProject(Project o) {
+ ProjectResource projectResource = new ProjectResource();
+ projectResource.setName(o.getProject_name());
+ GatewayResource gatewayResource = (GatewayResource)createGateway(o.getGateway());
+ projectResource.setGateway(gatewayResource);
+ Gateway_Worker gateway_worker = new Gateway_Worker();
+ gateway_worker.setGateway(o.getGateway());
+ gateway_worker.setUser(o.getUsers());
+ WorkerResource workerResource = (WorkerResource) createGatewayWorker(gateway_worker);
+ projectResource.setWorker(workerResource);
+ return projectResource;
+ }
+
+ /**
+ *
+ * @param o configuration model object
+ * @return configuration resource object
+ */
+ private static Resource createConfiguration (Configuration o){
+ ConfigurationResource configurationResource = new ConfigurationResource();
+ configurationResource.setConfigKey(o.getConfig_key());
+ configurationResource.setConfigVal(o.getConfig_val());
+ configurationResource.setExpireDate(o.getExpire_date());
+ configurationResource.setCategoryID(o.getCategory_id());
+ return configurationResource;
+ }
+
+ /**
+ *
+ * @param o application descriptor model object
+ * @return application descriptor resource object
+ */
+ private static Resource createApplicationDescriptor(Application_Descriptor o) {
+ ApplicationDescriptorResource applicationDescriptorResource = new ApplicationDescriptorResource();
+ applicationDescriptorResource.setName(o.getApplication_descriptor_ID());
+ applicationDescriptorResource.setHostDescName(o.getHost_descriptor_ID());
+ applicationDescriptorResource.setServiceDescName(o.getService_descriptor_ID());
+ applicationDescriptorResource.setContent(new String(o.getApplication_descriptor_xml()));
+ applicationDescriptorResource.setUpdatedUser(o.getUser().getUser_name());
+ applicationDescriptorResource.setGatewayName(o.getGateway().getGateway_name());
+ return applicationDescriptorResource;
+ }
+
+ /**
+ *
+ * @param o Experiment model object
+ * @return Experiment resource object
+ */
+ private static Resource createExperiment(Experiment o) {
+ ExperimentResource experimentResource = new ExperimentResource();
+ GatewayResource gatewayResource = (GatewayResource)createGateway(o.getGateway());
+ experimentResource.setGateway(gatewayResource);
+ Gateway_Worker gateway_worker = new Gateway_Worker();
+ gateway_worker.setGateway(o.getGateway());
+ gateway_worker.setUser(o.getUser());
+ WorkerResource workerResource = (WorkerResource) createGatewayWorker(gateway_worker);
+ experimentResource.setWorker(workerResource);
+ ProjectResource projectResource = (ProjectResource)createProject(o.getProject());
+ experimentResource.setProject(projectResource);
+ experimentResource.setExpID(o.getExperiment_ID());
+ experimentResource.setSubmittedDate(o.getSubmitted_date());
+ return experimentResource;
+ }
+
+ /**
+ *
+ * @param o Gateway_Worker model object
+ * @return Gateway_Worker resource object
+ */
+ private static Resource createGatewayWorker(Gateway_Worker o) {
+ GatewayResource gatewayResource = new GatewayResource(o.getGateway().getGateway_name());
+ gatewayResource.setOwner(o.getGateway().getOwner());
+ WorkerResource workerResource = new WorkerResource(o.getUser().getUser_name(), gatewayResource);
+ return workerResource;
+ }
+
+ /**
+ *
+ * @param o Host_Descriptor model object
+ * @return HostDescriptor resource object
+ */
+ private static Resource createHostDescriptor(Host_Descriptor o) {
+ try {
+ HostDescriptorResource hostDescriptorResource = new HostDescriptorResource();
+ hostDescriptorResource.setGatewayName(o.getGateway().getGateway_name());
+ hostDescriptorResource.setUserName(o.getUser().getUser_name());
+ hostDescriptorResource.setHostDescName(o.getHost_descriptor_ID());
+ byte[] bytes = o.getHost_descriptor_xml();
+ hostDescriptorResource.setContent(new String(bytes));
+ return hostDescriptorResource;
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ /**
+ *
+ * @param o Published_Workflow model object
+ * @return Published Workflow resource object
+ */
+ private static Resource createPublishWorkflow(Published_Workflow o) {
+ PublishWorkflowResource publishWorkflowResource = new PublishWorkflowResource();
+ GatewayResource gatewayResource = (GatewayResource)createGateway(o.getGateway());
+ publishWorkflowResource.setGateway(gatewayResource);
+ publishWorkflowResource.setCreatedUser(o.getUser().getUser_name());
+ publishWorkflowResource.setName(o.getPublish_workflow_name());
+ publishWorkflowResource.setContent(new String(o.getWorkflow_content()));
+ publishWorkflowResource.setPublishedDate(o.getPublished_date());
+ publishWorkflowResource.setVersion(o.getVersion());
+ publishWorkflowResource.setPath(o.getPath());
+ return publishWorkflowResource;
+ }
+
+ /**
+ *
+ * @param o Service_Descriptor model object
+ * @return ServiceDescriptor resource object
+ */
+ private static Resource createServiceDescriptor(Service_Descriptor o) {
+ ServiceDescriptorResource serviceDescriptorResource = new ServiceDescriptorResource();
+ serviceDescriptorResource.setGatewayName(o.getGateway().getGateway_name());
+ serviceDescriptorResource.setUserName(o.getUser().getUser_name());
+ serviceDescriptorResource.setServiceDescName(o.getService_descriptor_ID());
+ serviceDescriptorResource.setContent(new String(o.getService_descriptor_xml()));
+ return serviceDescriptorResource;
+ }
+
+ /**
+ *
+ * @param o User_Workflow model object
+ * @return User_Workflow resource object
+ */
+ private static Resource createUserWorkflow(User_Workflow o) {
+ UserWorkflowResource userWorkflowResource = new UserWorkflowResource();
+ userWorkflowResource.setName(o.getTemplate_name());
+ GatewayResource gatewayResource = (GatewayResource)createGateway(o.getGateway());
+ userWorkflowResource.setGateway(gatewayResource);
+ Gateway_Worker gateway_worker = new Gateway_Worker();
+ gateway_worker.setGateway(o.getGateway());
+ gateway_worker.setUser(o.getUser());
+ WorkerResource workerResource = (WorkerResource) createGatewayWorker(gateway_worker);
+ userWorkflowResource.setWorker(workerResource);
+ userWorkflowResource.setLastUpdateDate(o.getLast_updated_date());
+ userWorkflowResource.setContent(new String(o.getWorkflow_graph()));
+ userWorkflowResource.setPath(o.getPath());
+ return userWorkflowResource;
+ }
+
+ /**
+ *
+ * @param o Users model object
+ * @return UserResource object
+ */
+ private static Resource createUser(Users o) {
+ UserResource userResource = new UserResource();
+ userResource.setUserName(o.getUser_name());
+ userResource.setPassword(o.getPassword());
+ return userResource;
+ }
+
+ /**
+ *
+ * @param o Experiment Data model object
+ * @return Experiment Data resource object
+ */
+ private static Resource createExperimentData(Experiment_Data o){
+ ExperimentDataResource experimentDataResource = new ExperimentDataResource();
+ experimentDataResource.setExperimentID(o.getExperiment_ID());
+ experimentDataResource.setExpName(o.getName());
+ experimentDataResource.setUserName(o.getUsername());
+ return experimentDataResource;
+ }
+
+ /**
+ *
+ * @param o Experiment MetaData model object
+ * @return Experiment MetaData resource object
+ */
+ private static Resource createExperimentMetadata(Experiment_Metadata o) {
+ ExperimentMetadataResource experimentMetadataResource = new ExperimentMetadataResource();
+ experimentMetadataResource.setExpID(o.getExperiment_ID());
+ experimentMetadataResource.setMetadata(new String(o.getMetadata()));
+ return experimentMetadataResource;
+ }
+
+ /**
+ *
+ * @param o Workflow_Data model object
+ * @return WorkflowDataResource object
+ */
+ private static Resource createWorkflowData(Workflow_Data o){
+ WorkflowDataResource workflowDataResource = new WorkflowDataResource();
+ workflowDataResource.setExperimentID(o.getExperiment_data().getExperiment_ID());
+ workflowDataResource.setWorkflowInstanceID(o.getWorkflow_instanceID());
+ workflowDataResource.setTemplateName(o.getTemplate_name());
+ workflowDataResource.setStatus(o.getStatus());
+ workflowDataResource.setStartTime(o.getStart_time());
+ workflowDataResource.setLastUpdatedTime(o.getLast_update_time());
+ return workflowDataResource;
+ }
+
+ /**
+ *
+ * @param o Node_Data model object
+ * @return Node Data resource
+ */
+ private static Resource createNodeData (Node_Data o){
+ NodeDataResource nodeDataResource = new NodeDataResource();
+ WorkflowDataResource workflowDataResource = (WorkflowDataResource)createWorkflowData(o.getWorkflow_Data());
+ nodeDataResource.setWorkflowDataResource(workflowDataResource);
+ nodeDataResource.setNodeID(o.getNode_id());
+ nodeDataResource.setNodeType(o.getNode_type());
+ if (o.getInputs()!=null) {
+ nodeDataResource.setInputs(new String(o.getInputs()));
+ }
+ if (o.getOutputs()!=null) {
+ nodeDataResource.setOutputs(new String(o.getOutputs()));
+ }
+ nodeDataResource.setStatus(o.getStatus());
+ nodeDataResource.setStartTime(o.getStart_time());
+ nodeDataResource.setLastUpdateTime(o.getLast_update_time());
+ nodeDataResource.setExecutionIndex(o.getExecution_index());
+ return nodeDataResource;
+ }
+
+ /**
+ *
+ * @param o GramData model object
+ * @return GramData Resource object
+ */
+ private static Resource createGramData (Gram_Data o){
+ GramDataResource gramDataResource = new GramDataResource();
+ WorkflowDataResource workflowDataResource = (WorkflowDataResource)createWorkflowData(o.getWorkflow_Data());
+ gramDataResource.setWorkflowDataResource(workflowDataResource);
+ gramDataResource.setNodeID(o.getNode_id());
+ gramDataResource.setRsl(new String(o.getRsl()));
+ gramDataResource.setInvokedHost(o.getInvoked_host());
+ gramDataResource.setLocalJobID(o.getLocal_Job_ID());
+ return gramDataResource;
+ }
+
+ private static Resource createExecutionError(Execution_Error o){
+ ExecutionErrorResource executionErrorResource = new ExecutionErrorResource();
+ ExperimentDataResource experimentDataResource = (ExperimentDataResource)createExperimentData(o.getExperiment_Data());
+ executionErrorResource.setExperimentDataResource(experimentDataResource);
+ WorkflowDataResource workflowDataResource = (WorkflowDataResource)createWorkflowData(o.getWorkflow_Data());
+ executionErrorResource.setWorkflowDataResource(workflowDataResource);
+ executionErrorResource.setNodeID(o.getNode_id());
+ executionErrorResource.setErrorID(o.getError_id());
+ executionErrorResource.setGfacJobID(o.getGfacJobID());
+ executionErrorResource.setSourceType(o.getSource_type());
+ executionErrorResource.setErrorTime(o.getError_date());
+ executionErrorResource.setErrorMsg(o.getError_msg());
+ executionErrorResource.setErrorDes(o.getError_des());
+ executionErrorResource.setErrorCode(o.getError_code());
+ executionErrorResource.setErrorReporter(o.getError_reporter());
+ executionErrorResource.setErrorLocation(o.getError_location());
+ executionErrorResource.setActionTaken(o.getAction_taken());
+ executionErrorResource.setErrorReference(o.getError_reference());
+ return executionErrorResource;
+ }
+
+ private static Resource createGfacJobData (GFac_Job_Data o){
+ GFacJobDataResource gFacJobDataResource = new GFacJobDataResource();
+ ExperimentDataResource experimentDataResource = (ExperimentDataResource)createExperimentData(o.getExperiment_data());
+ WorkflowDataResource workflowDataResource = (WorkflowDataResource)createWorkflowData(o.getWorkflow_Data());
+ gFacJobDataResource.setExperimentDataResource(experimentDataResource);
+ gFacJobDataResource.setWorkflowDataResource(workflowDataResource);
+ gFacJobDataResource.setNodeID(o.getNode_id());
+ gFacJobDataResource.setApplicationDescID(o.getApplication_descriptor_ID());
+ gFacJobDataResource.setServiceDescID(o.getService_descriptor_ID());
+ gFacJobDataResource.setHostDescID(o.getHost_descriptor_ID());
+ gFacJobDataResource.setJobData(o.getJob_data());
+ gFacJobDataResource.setLocalJobID(o.getLocal_Job_ID());
+ gFacJobDataResource.setSubmittedTime(o.getSubmitted_time());
+ gFacJobDataResource.setStatusUpdateTime(o.getStatus_update_time());
+ gFacJobDataResource.setStatus(o.getStatus());
+ gFacJobDataResource.setMetadata(o.getMetadata());
+ return gFacJobDataResource;
+ }
+
+ private static Resource createGfacJobStatus(GFac_Job_Status o) {
+ GFacJobStatusResource gFacJobStatusResource = new GFacJobStatusResource();
+ gFacJobStatusResource.setLocalJobID(o.getLocal_Job_ID());
+ gFacJobStatusResource.setStatus(o.getStatus());
+ gFacJobStatusResource.setStatusUpdateTime(o.getStatus_update_time());
+ GFacJobDataResource gFacJobDataResource = (GFacJobDataResource)createGfacJobData(o.getgFac_job_data());
+ gFacJobStatusResource.setgFacJobDataResource(gFacJobDataResource);
+ return gFacJobStatusResource;
+ }
+
+// public static byte[] getByteArray(String content){
+// byte[] contentBytes = content.getBytes();
+// return contentBytes;
+// }
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkerResource.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,521 @@
+/*
+ *
+ * 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 java.util.ArrayList;
+import java.util.List;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+
+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.resources.AbstractResource.GFacJobStatusConstants;
+import org.apache.airavata.persistance.registry.jpa.resources.AbstractResource.WorkflowDataConstants;
+import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+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) {
+ Resource result = null;
+ switch (type) {
+ case PROJECT:
+ ProjectResource projectResource = new ProjectResource();
+ projectResource.setWorker(this);
+ projectResource.setGateway(gateway);
+ result=projectResource;
+ break;
+ case USER_WORKFLOW:
+ UserWorkflowResource userWorkflowResource = new UserWorkflowResource();
+ userWorkflowResource.setWorker(this);
+ userWorkflowResource.setGateway(gateway);
+ result=userWorkflowResource;
+ break;
+ case EXPERIMENT:
+ ExperimentResource experimentResource = new ExperimentResource();
+ experimentResource.setWorker(this);
+ 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) {
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+ QueryGenerator generator;
+ switch (type) {
+ case PROJECT:
+ generator = new QueryGenerator(PROJECT);
+ generator.setParameter(ProjectConstants.PROJECT_NAME, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case USER_WORKFLOW:
+ generator = new QueryGenerator(USER_WORKFLOW);
+ generator.setParameter(UserWorkflowConstants.OWNER, getUser());
+ generator.setParameter(UserWorkflowConstants.TEMPLATE_NAME, name);
+ generator.setParameter(UserWorkflowConstants.GATEWAY_NAME, gateway.getGatewayName());
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case EXPERIMENT:
+ generator = new QueryGenerator(EXPERIMENT);
+ generator.setParameter(ExperimentConstants.USERNAME, getUser());
+ generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case WORKFLOW_DATA:
+ generator = new QueryGenerator(WORKFLOW_DATA);
+ generator.setParameter(WorkflowDataConstants.WORKFLOW_INSTANCE_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();
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @param name child resource name
+ * @return child resource
+ */
+ public Resource get(ResourceType type, Object name) {
+ Resource result = null;
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator;
+ Query q;
+ switch (type) {
+ case PROJECT:
+ generator = new QueryGenerator(PROJECT);
+ generator.setParameter(ProjectConstants.PROJECT_NAME, name);
+ q = generator.selectQuery(em);
+ Project project = (Project) q.getSingleResult();
+ result= Utils.getResource(ResourceType.PROJECT, project);
+ break;
+ case USER_WORKFLOW:
+ generator = new QueryGenerator(USER_WORKFLOW);
+ generator.setParameter(UserWorkflowConstants.OWNER, getUser());
+ generator.setParameter(UserWorkflowConstants.TEMPLATE_NAME, name);
+ generator.setParameter(UserWorkflowConstants.GATEWAY_NAME, gateway.getGatewayName());
+ q = generator.selectQuery(em);
+ User_Workflow userWorkflow = (User_Workflow) q.getSingleResult();
+ result= Utils.getResource(ResourceType.USER_WORKFLOW, userWorkflow);
+ break;
+ case EXPERIMENT:
+ generator = new QueryGenerator(EXPERIMENT);
+ generator.setParameter(ExperimentConstants.USERNAME, getUser());
+ generator.setParameter(ExperimentConstants.EXPERIMENT_ID, name);
+ q = generator.selectQuery(em);
+ Experiment experiment = (Experiment) q.getSingleResult();
+ result= Utils.getResource(ResourceType.EXPERIMENT, experiment);
+ break;
+ case WORKFLOW_DATA:
+ generator = new QueryGenerator(WORKFLOW_DATA);
+ generator.setParameter(WorkflowDataConstants.WORKFLOW_INSTANCE_ID, name);
+ q = generator.selectQuery(em);
+ Workflow_Data eworkflowData = (Workflow_Data)q.getSingleResult();
+ WorkflowDataResource workflowDataResource = (WorkflowDataResource)Utils.getResource(ResourceType.WORKFLOW_DATA, eworkflowData);
+ result= workflowDataResource;
+ break;
+ case GFAC_JOB_DATA:
+ generator = new QueryGenerator(GFAC_JOB_DATA);
+ generator.setParameter(GFacJobDataConstants.LOCAL_JOB_ID, name);
+ q = generator.selectQuery(em);
+ GFac_Job_Data gFacJobData = (GFac_Job_Data)q.getSingleResult();
+ GFacJobDataResource gFacJobDataResource = (GFacJobDataResource)Utils.getResource(ResourceType.GFAC_JOB_DATA, gFacJobData);
+ result= gFacJobDataResource;
+ break;
+ default:
+ logger.error("Unsupported resource type for worker resource.", new IllegalArgumentException());
+ break;
+ }
+ em.getTransaction().commit();
+ 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;
+ }
+
+ /**
+ *
+ * @param type child resource type
+ * @return list of child resources
+ */
+ public List<Resource> get(ResourceType type) {
+ List<Resource> result = new ArrayList<Resource>();
+ EntityManager 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.getGatewayName());
+ generator.setParameter("users", users);
+ generator.setParameter("gateway", gatewayModel);
+// generator.setParameter(ProjectConstants.USERNAME, getUser());
+// generator.setParameter(ProjectConstants.GATEWAY_NAME, gateway.getGatewayName());
+ q = generator.selectQuery(em);
+ for (Object o : q.getResultList()) {
+ Project project = (Project) o;
+ ProjectResource projectResource = (ProjectResource)Utils.getResource(ResourceType.PROJECT, project);
+ result.add(projectResource);
+ }
+ break;
+ case USER_WORKFLOW:
+ generator = new QueryGenerator(USER_WORKFLOW);
+ generator.setParameter(UserWorkflowConstants.OWNER, getUser());
+ q = generator.selectQuery(em);
+// q.setParameter("usr_name", getUser());
+ for (Object o : q.getResultList()) {
+ User_Workflow userWorkflow = (User_Workflow) o;
+ UserWorkflowResource userWorkflowResource = (UserWorkflowResource)Utils.getResource(ResourceType.USER_WORKFLOW, userWorkflow);
+ result.add(userWorkflowResource);
+ }
+ break;
+ case EXPERIMENT:
+ generator = new QueryGenerator(EXPERIMENT);
+ generator.setParameter(ExperimentConstants.USERNAME, getUser());
+ generator.setParameter(ExperimentConstants.GATEWAY_NAME, gateway.getGatewayName());
+ q = generator.selectQuery(em);
+ 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();
+ return result;
+ }
+
+ /**
+ * save gateway worker to database
+ */
+ public void save() {
+ EntityManager em = ResourceUtils.getEntityManager();
+ Gateway_Worker existingWorker = em.find(Gateway_Worker.class, new Gateway_Worker_PK(gateway.getGatewayName(), user));
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Gateway_Worker gatewayWorker = new Gateway_Worker();
+ Users users = new Users();
+ users.setUser_name(user);
+ gatewayWorker.setUser(users);
+ Gateway gatewaymodel = new Gateway();
+ gatewaymodel.setGateway_name(gateway.getGatewayName());
+ gatewaymodel.setOwner(gateway.getOwner());
+ gatewayWorker.setGateway(gatewaymodel);
+ if(existingWorker != null){
+ gatewayWorker = em.merge(existingWorker);
+ }else {
+ em.merge(gatewayWorker);
+ }
+ em.getTransaction().commit();
+ 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 name project name
+ * @return whether the project is available under the user
+ */
+ public boolean isProjectExists(String name){
+ return isExists(ResourceType.PROJECT, name);
+ }
+
+ /**
+ *
+ * @param name project name
+ * @return project resource for the user
+ */
+ public ProjectResource createProject(String name){
+ ProjectResource project=(ProjectResource)create(ResourceType.PROJECT);
+ project.setName(name);
+ return project;
+ }
+
+ /**
+ *
+ * @param name project name
+ * @return project resource
+ */
+ public ProjectResource getProject(String name){
+ return (ProjectResource)get(ResourceType.PROJECT, name);
+ }
+
+ /**
+ *
+ * @param name project name
+ */
+ public void removeProject(String name){
+ remove(ResourceType.PROJECT, name);
+ }
+
+ /**
+ *
+ * @return list of projects for the user
+ */
+ public List<ProjectResource> getProjects(){
+ List<ProjectResource> result=new ArrayList<ProjectResource>();
+ List<Resource> list = get(ResourceType.PROJECT);
+ for (Resource resource : list) {
+ result.add((ProjectResource) resource);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param templateName user workflow template
+ * @return whether the workflow is already exists under the given user
+ */
+ public boolean isWorkflowTemplateExists(String templateName){
+ return isExists(ResourceType.USER_WORKFLOW, templateName);
+ }
+
+ /**
+ *
+ * @param templateName user workflow template
+ * @return user workflow resource
+ */
+ public UserWorkflowResource createWorkflowTemplate(String templateName){
+ UserWorkflowResource workflow=(UserWorkflowResource)create(ResourceType.USER_WORKFLOW);
+ workflow.setName(templateName);
+ return workflow;
+ }
+
+ /**
+ *
+ * @param templateName user workflow template
+ * @return user workflow resource
+ */
+ public UserWorkflowResource getWorkflowTemplate(String templateName){
+ return (UserWorkflowResource)get(ResourceType.USER_WORKFLOW, templateName);
+ }
+
+ /**
+ *
+ * @param templateName user workflow template
+ */
+ public void removeWorkflowTemplate(String templateName){
+ remove(ResourceType.USER_WORKFLOW, templateName);
+ }
+
+ /**
+ *
+ * @return list of user workflows for the given user
+ */
+ public List<UserWorkflowResource> getWorkflowTemplates(){
+ List<UserWorkflowResource> result=new ArrayList<UserWorkflowResource>();
+ List<Resource> list = get(ResourceType.USER_WORKFLOW);
+ for (Resource resource : list) {
+ result.add((UserWorkflowResource) resource);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param name experiment name
+ * @return whether experiment is already exist for the given user
+ */
+ public boolean isExperimentExists(String name){
+ return isExists(ResourceType.EXPERIMENT, name);
+ }
+
+ /**
+ * Returns of the gfac job record is present for the job id
+ * @param jobId
+ * @return
+ */
+ public boolean isGFacJobExists(String jobId){
+ return isExists(ResourceType.GFAC_JOB_DATA, jobId);
+ }
+
+ /**
+ *
+ * @param name experiment name
+ * @return experiment resource
+ */
+ public ExperimentResource getExperiment(String name){
+ return (ExperimentResource)get(ResourceType.EXPERIMENT, name);
+ }
+
+ public GFacJobDataResource getGFacJob(String jobId){
+ return (GFacJobDataResource)get(ResourceType.GFAC_JOB_DATA,jobId);
+ }
+
+ /**
+ *
+ * @return list of experiments for the user
+ */
+ public List<ExperimentResource> getExperiments(){
+ List<ExperimentResource> result=new ArrayList<ExperimentResource>();
+ List<Resource> list = get(ResourceType.EXPERIMENT);
+ for (Resource resource : list) {
+ result.add((ExperimentResource) resource);
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param experimentId experiment name
+ */
+ public void removeExperiment(String experimentId){
+ remove(ResourceType.EXPERIMENT, experimentId);
+ }
+
+ public boolean isWorkflowInstancePresent(String workflowInstanceId){
+ return isExists(ResourceType.WORKFLOW_DATA, workflowInstanceId);
+ }
+
+ public WorkflowDataResource getWorkflowInstance(String workflowInstanceId){
+ return (WorkflowDataResource)get(ResourceType.WORKFLOW_DATA, workflowInstanceId);
+ }
+
+ public void removeWorkflowInstance(String workflowInstanceId){
+ remove(ResourceType.WORKFLOW_DATA, workflowInstanceId);
+ }
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowDataResource.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowDataResource.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowDataResource.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/resources/WorkflowDataResource.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,369 @@
+/*
+ *
+ * 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.resources.AbstractResource.GFacJobDataConstants;
+import org.apache.airavata.persistance.registry.jpa.utils.QueryGenerator;
+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 WorkflowDataResource extends AbstractResource{
+ private final static Logger logger = LoggerFactory.getLogger(WorkflowDataResource.class);
+ public static final String NODE_DATA = "Node_Data";
+ public static final String GRAM_DATA = "Gram_Data";
+ public static final String EXECUTION_ERROR = "Execution_Error";
+ private String experimentID;
+ private String workflowInstanceID;
+ private String templateName;
+ private String status;
+ private Timestamp startTime;
+ private Timestamp lastUpdatedTime;
+
+ public String getExperimentID() {
+ return experimentID;
+ }
+
+ public String getWorkflowInstanceID() {
+ return workflowInstanceID;
+ }
+
+ public String getTemplateName() {
+ return templateName;
+ }
+
+ public String getStatus() {
+ return status;
+ }
+
+ public void setExperimentID(String experimentID) {
+ this.experimentID = experimentID;
+ }
+
+ public void setWorkflowInstanceID(String workflowInstanceID) {
+ this.workflowInstanceID = workflowInstanceID;
+ }
+
+ public void setTemplateName(String templateName) {
+ this.templateName = templateName;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ }
+
+ public Timestamp getStartTime() {
+ return startTime;
+ }
+
+ public Timestamp getLastUpdatedTime() {
+ return lastUpdatedTime;
+ }
+
+ public void setStartTime(Timestamp startTime) {
+ this.startTime = startTime;
+ }
+
+ public void setLastUpdatedTime(Timestamp lastUpdatedTime) {
+ this.lastUpdatedTime = lastUpdatedTime;
+ }
+
+ public Resource create(ResourceType type) {
+ switch (type){
+ case NODE_DATA:
+ NodeDataResource nodeDataResource = new NodeDataResource();
+ nodeDataResource.setWorkflowDataResource(this);
+ return nodeDataResource;
+ case GRAM_DATA:
+ GramDataResource gramDataResource = new GramDataResource();
+ gramDataResource.setWorkflowDataResource(this);
+ return gramDataResource;
+ case EXECUTION_ERROR:
+ ExecutionErrorResource executionErrorResource = new ExecutionErrorResource();
+ executionErrorResource.setWorkflowDataResource(this);
+ return executionErrorResource;
+ case GFAC_JOB_DATA:
+ GFacJobDataResource gFacJobDataResource = new GFacJobDataResource();
+ gFacJobDataResource.setWorkflowDataResource(this);
+ return gFacJobDataResource;
+ default:
+ logger.error("Unsupported resource type for workflow data resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for workflow data resource.");
+ }
+ }
+
+ public void remove(ResourceType type, Object name) {
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+ QueryGenerator generator;
+ switch (type){
+ case NODE_DATA:
+ generator = new QueryGenerator(NODE_DATA);
+ generator.setParameter(NodeDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ generator.setParameter(NodeDataConstants.NODE_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case GRAM_DATA:
+ generator = new QueryGenerator(GRAM_DATA);
+ generator.setParameter(GramDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ generator.setParameter(GramDataConstants.NODE_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case EXECUTION_ERROR:
+ generator = new QueryGenerator(EXECUTION_ERROR);
+ generator.setParameter(ExecutionErrorConstants.ERROR_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ case GFAC_JOB_DATA:
+ generator = new QueryGenerator(GFAC_JOB_DATA);
+ generator.setParameter(GFacJobDataConstants.LOCAL_JOB_ID, name);
+ q = generator.deleteQuery(em);
+ q.executeUpdate();
+ break;
+ default:
+ logger.error("Unsupported resource type for workflow data resource.", new IllegalArgumentException());
+ break;
+ }
+ em.getTransaction().commit();
+ em.close();
+ }
+
+ public Resource get(ResourceType type, Object name) {
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator;
+ Query q;
+ switch (type) {
+ case NODE_DATA:
+ generator = new QueryGenerator(NODE_DATA);
+ generator.setParameter(NodeDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ generator.setParameter(NodeDataConstants.NODE_ID, name);
+ q = generator.selectQuery(em);
+ Node_Data enodeDeata = (Node_Data)q.getSingleResult();
+ NodeDataResource nodeDataResource = (NodeDataResource)Utils.getResource(ResourceType.NODE_DATA, enodeDeata);
+ em.getTransaction().commit();
+ em.close();
+ return nodeDataResource;
+ case GRAM_DATA:
+ generator = new QueryGenerator(GRAM_DATA);
+ generator.setParameter(GramDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ generator.setParameter(GramDataConstants.NODE_ID, name);
+ q = generator.selectQuery(em);
+ Gram_Data egramData = (Gram_Data)q.getSingleResult();
+ GramDataResource gramDataResource = (GramDataResource)Utils.getResource(ResourceType.GRAM_DATA, egramData);
+ em.getTransaction().commit();
+ em.close();
+ return gramDataResource;
+ case EXECUTION_ERROR:
+ generator = new QueryGenerator(EXECUTION_ERROR);
+ generator.setParameter(ExecutionErrorConstants.ERROR_ID, name);
+ q = generator.selectQuery(em);
+ Execution_Error execution_error = (Execution_Error)q.getSingleResult();
+ ExecutionErrorResource executionErrorResource = (ExecutionErrorResource)Utils.getResource(ResourceType.EXECUTION_ERROR, execution_error);
+ em.getTransaction().commit();
+ em.close();
+ return executionErrorResource;
+ case GFAC_JOB_DATA:
+ generator = new QueryGenerator(GFAC_JOB_DATA);
+ generator.setParameter(GFacJobDataConstants.LOCAL_JOB_ID, name);
+ q = generator.selectQuery(em);
+ GFac_Job_Data gFac_job_data = (GFac_Job_Data)q.getSingleResult();
+ GFacJobDataResource gFacJobDataResource = (GFacJobDataResource)Utils.getResource(ResourceType.GFAC_JOB_DATA, gFac_job_data);
+ em.getTransaction().commit();
+ em.close();
+ return gFacJobDataResource;
+ default:
+ em.getTransaction().commit();
+ em.close();
+ logger.error("Unsupported resource type for workflow data resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for workflow data resource.");
+ }
+ }
+
+ public List<Resource> get(ResourceType type) {
+ List<Resource> resourceList = new ArrayList<Resource>();
+ EntityManager em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Query q;
+ QueryGenerator generator;
+ List<?> results;
+ switch (type){
+ case NODE_DATA:
+ generator = new QueryGenerator(NODE_DATA);
+ generator.setParameter(NodeDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ Node_Data nodeData = (Node_Data)result;
+ NodeDataResource nodeDataResource = (NodeDataResource)Utils.getResource(ResourceType.NODE_DATA,nodeData);
+ resourceList.add(nodeDataResource);
+
+ }
+ }
+ break;
+ case GRAM_DATA:
+ generator = new QueryGenerator(GRAM_DATA);
+ generator.setParameter(GramDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ Gram_Data gramData = (Gram_Data)result;
+ GramDataResource gramDataResource = (GramDataResource)Utils.getResource(ResourceType.GRAM_DATA, gramData);
+ resourceList.add(gramDataResource);
+ }
+ }
+ break;
+ case EXECUTION_ERROR:
+ generator = new QueryGenerator(EXECUTION_ERROR);
+ generator.setParameter(ExecutionErrorConstants.WORKFLOW_ID, workflowInstanceID);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ Execution_Error executionError = (Execution_Error)result;
+ ExecutionErrorResource executionErrorResource = (ExecutionErrorResource)Utils.getResource(ResourceType.EXECUTION_ERROR, executionError);
+ resourceList.add(executionErrorResource);
+ }
+ }
+ break;
+ case GFAC_JOB_DATA:
+ generator = new QueryGenerator(GFAC_JOB_DATA);
+ generator.setParameter(GFacJobDataConstants.EXPERIMENT_ID, experimentID);
+ generator.setParameter(GFacJobDataConstants.WORKFLOW_INSTANCE_ID, workflowInstanceID);
+ q = generator.selectQuery(em);
+ results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ GFac_Job_Data gFac_job_data = (GFac_Job_Data)result;
+ GFacJobDataResource gFacJobDataResource = (GFacJobDataResource)Utils.getResource(ResourceType.GFAC_JOB_DATA, gFac_job_data);
+ resourceList.add(gFacJobDataResource);
+ }
+ }
+ break;
+ default:
+ em.getTransaction().commit();
+ em.close();
+ logger.error("Unsupported resource type for workflow data resource.", new IllegalArgumentException());
+ throw new IllegalArgumentException("Unsupported resource type for workflow data resource.");
+ }
+ em.getTransaction().commit();
+ em.close();
+ return resourceList;
+ }
+
+ public List<Resource> getGFacJobs(){
+ return get(ResourceType.GFAC_JOB_DATA);
+ }
+
+ public void save() {
+ if(lastUpdatedTime == null){
+ java.util.Date date= new java.util.Date();
+ lastUpdatedTime = new Timestamp(date.getTime());
+ }
+ EntityManager em = ResourceUtils.getEntityManager();
+ Workflow_Data existingWFData = em.find(Workflow_Data.class, workflowInstanceID);
+ em.close();
+
+ em = ResourceUtils.getEntityManager();
+ em.getTransaction().begin();
+ Workflow_Data workflowData = new Workflow_Data();
+ Experiment_Data expData = em.find(Experiment_Data.class, experimentID);
+ workflowData.setExperiment_data(expData);
+ workflowData.setWorkflow_instanceID(workflowInstanceID);
+ workflowData.setLast_update_time(lastUpdatedTime);
+ workflowData.setStart_time(startTime);
+ workflowData.setTemplate_name(templateName);
+ workflowData.setStatus(status);
+ if(existingWFData != null){
+ existingWFData.setExperiment_data(expData);
+ existingWFData.setLast_update_time(lastUpdatedTime);
+ existingWFData.setStart_time(startTime);
+ existingWFData.setStatus(status);
+ existingWFData.setTemplate_name(templateName);
+ workflowData = em.merge(existingWFData);
+ }else {
+ em.persist(workflowData);
+ }
+ em.getTransaction().commit();
+ em.close();
+ }
+
+ public boolean isNodeExists(String nodeId){
+ return isExists(ResourceType.NODE_DATA, nodeId);
+ }
+
+ public boolean isGramDataExists(String nodeId){
+ return isExists(ResourceType.GRAM_DATA, nodeId);
+ }
+
+ public NodeDataResource getNodeData(String nodeId){
+ return (NodeDataResource) get(ResourceType.NODE_DATA,nodeId);
+ }
+
+ public GramDataResource getGramData(String nodeId){
+ return (GramDataResource) get(ResourceType.GRAM_DATA,nodeId);
+ }
+
+ public List<NodeDataResource> getNodeData(){
+ return getResourceList(get(ResourceType.NODE_DATA),NodeDataResource.class);
+ }
+
+ public List<GramDataResource> getGramData(){
+ return getResourceList(get(ResourceType.GRAM_DATA),GramDataResource.class);
+ }
+
+ public NodeDataResource createNodeData(String nodeId){
+ NodeDataResource data=(NodeDataResource)create(ResourceType.NODE_DATA);
+ data.setNodeID(nodeId);
+ return data;
+ }
+
+ public GramDataResource createGramData(String nodeId){
+ GramDataResource data=(GramDataResource)create(ResourceType.GRAM_DATA);
+ data.setNodeID(nodeId);
+ return data;
+ }
+
+ public void removeNodeData(String nodeId){
+ remove(ResourceType.NODE_DATA, nodeId);
+ }
+
+ public void removeGramData(String nodeId){
+ remove(ResourceType.GRAM_DATA, nodeId);
+ }
+
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/java/org/apache/airavata/persistance/registry/jpa/utils/QueryGenerator.java Thu Dec 26 17:31:35 2013
@@ -0,0 +1,101 @@
+/*
+ *
+ * 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 java.util.HashMap;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+
+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);
+ }
+
+ public Query selectQuery(EntityManager entityManager){
+ String queryString="SELECT "+ SELECT_OBJ + " FROM " +getTableName()+" "+TABLE_OBJ;
+ return generateQueryWithParameters(entityManager, queryString);
+ }
+
+// 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) {
+ 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;
+ }
+ Query query = entityManager.createQuery(queryString);
+ for (String paramName : queryParameters.keySet()) {
+ query.setParameter(paramName, queryParameters.get(paramName));
+ }
+ return query;
+ }
+}
Added: airavata/sandbox/registry/airavata-jpa-registry/src/main/resources/META-INF/persistence.xml
URL: http://svn.apache.org/viewvc/airavata/sandbox/registry/airavata-jpa-registry/src/main/resources/META-INF/persistence.xml?rev=1553518&view=auto
==============================================================================
--- airavata/sandbox/registry/airavata-jpa-registry/src/main/resources/META-INF/persistence.xml (added)
+++ airavata/sandbox/registry/airavata-jpa-registry/src/main/resources/META-INF/persistence.xml Thu Dec 26 17:31:35 2013
@@ -0,0 +1,58 @@
+<?xml version="1.0"?>
+<!--*
+ *
+ * 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.
+ *
+* -->
+<persistence xmlns="http://java.sun.com/xml/ns/persistence"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0">
+ <persistence-unit name="airavata_data">
+ <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Gateway</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Configuration</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Users</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Gateway_Worker</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Project</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Published_Workflow</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.User_Workflow</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Host_Descriptor</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Service_Descriptor</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Application_Descriptor</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Experiment</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Experiment_Data</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Experiment_Metadata</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Workflow_Data</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Node_Data</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Gram_Data</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.Execution_Error</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.GFac_Job_Data</class>
+ <class>org.apache.airavata.persistance.registry.jpa.model.GFac_Job_Status</class>
+ <!--properties>
+ <property name="openjpa.ConnectionURL"
+ value="jdbc:mysql://localhost:3306/persitant_data" />
+ <property name="openjpa.ConnectionDriverName" value="com.mysql.jdbc.Driver" />
+ <property name="openjpa.ConnectionUserName" value="airavata" />
+ <property name="openjpa.ConnectionPassword" value="airavata" />
+ <property name="openjpa.DynamicEnhancementAgent" value="true" />
+ <property name="openjpa.RuntimeUnenhancedClasses" value="supported" />
+ <property name="openjpa.Log" value="SQL=TRACE" />
+ <property name="openjpa.ConnectionFactoryProperties"
+ value="PrettyPrint=true, PrettyPrintLineLength=72, PrintParameters=true, MaxActive=10, MaxIdle=5, MinIdle=2, MaxWait=60000" />
+ </properties-->
+ </persistence-unit>
+</persistence>