Merge branch 'master' of https://git-wip-us.apache.org/repos/asf/airavata
Project: http://git-wip-us.apache.org/repos/asf/airavata/repo Commit: http://git-wip-us.apache.org/repos/asf/airavata/commit/22a76f8a Tree: http://git-wip-us.apache.org/repos/asf/airavata/tree/22a76f8a Diff: http://git-wip-us.apache.org/repos/asf/airavata/diff/22a76f8a Branch: refs/heads/master Commit: 22a76f8af745ccceedc371ac91dc354673c77b31 Parents: 7ab87e5 22bcbb4 Author: Supun Nakandala <[email protected]> Authored: Wed Jun 3 02:18:43 2015 +0530 Committer: Supun Nakandala <[email protected]> Committed: Wed Jun 3 02:18:43 2015 +0530 ---------------------------------------------------------------------- airavata-api/airavata-api-server/pom.xml | 2 +- .../server/handler/AiravataServerHandler.java | 4 +- .../api/server/util/AppCatalogInitUtil.java | 6 - .../api/server/util/RegistryInitUtil.java | 12 +- .../client/samples/CreateLaunchExperiment.java | 4 +- .../main/resources/airavata-client.properties | 14 +- modules/distribution/server/pom.xml | 2 +- modules/gfac/airavata-gfac-service/pom.xml | 2 +- .../airavata/gfac/server/GfacServerHandler.java | 2 +- .../gfac/client/GfacClientFactoryTest.java | 11 - .../airavata/gfac/client/util/Initialize.java | 5 +- .../gfac/bes/provider/impl/BESProvider.java | 24 +- modules/gfac/gfac-core/pom.xml | 2 +- .../gfac/core/handler/AbstractHandler.java | 3 +- .../gfac/core/provider/AbstractProvider.java | 4 +- .../airavata/gfac/core/utils/GFacUtils.java | 2 +- .../impl/GSISSHProviderTestWithMyProxyAuth.java | 2 +- .../gfac/services/impl/LocalProviderTest.java | 2 +- .../gfac/gfac-monitor/gfac-hpc-monitor/pom.xml | 2 +- .../services/impl/BigRed2TestWithSSHAuth.java | 2 +- modules/integration-tests/pom.xml | 2 +- .../server/OrchestratorServerHandler.java | 2 +- .../client/OrchestratorClientFactoryTest.java | 13 - .../orchestrator/client/util/Initialize.java | 5 +- modules/orchestrator/orchestrator-core/pom.xml | 2 +- .../validator/impl/BatchQueueValidator.java | 2 +- .../cpi/impl/AbstractOrchestrator.java | 2 +- .../core/OrchestratorTestWithGRAM.java | 15 - .../core/OrchestratorTestWithMyProxyAuth.java | 16 - .../orchestrator/core/ValidatorTest.java | 2 +- .../orchestrator/core/util/Initialize.java | 5 +- modules/registry/airavata-jpa-registry/pom.xml | 151 - .../persistance/registry/jpa/JPAConstants.java | 33 - .../persistance/registry/jpa/Resource.java | 71 - .../persistance/registry/jpa/ResourceType.java | 50 - .../persistance/registry/jpa/ResourceUtils.java | 525 --- .../registry/jpa/impl/ExperimentRegistry.java | 2983 ------------------ .../registry/jpa/impl/GatewayRegistry.java | 115 - .../registry/jpa/impl/LoggingRegistryImpl.java | 97 - .../registry/jpa/impl/ProjectRegistry.java | 303 -- .../registry/jpa/impl/RegistryFactory.java | 80 - .../registry/jpa/impl/RegistryImpl.java | 735 ----- .../persistance/registry/jpa/impl/UserReg.java | 42 - .../jpa/model/AdvancedInputDataHandling.java | 113 - .../jpa/model/AdvancedOutputDataHandling.java | 104 - .../registry/jpa/model/ApplicationInput.java | 165 - .../registry/jpa/model/ApplicationInput_PK.java | 65 - .../registry/jpa/model/ApplicationOutput.java | 142 - .../jpa/model/ApplicationOutput_PK.java | 64 - .../Computational_Resource_Scheduling.java | 174 - .../registry/jpa/model/Configuration.java | 80 - .../registry/jpa/model/Configuration_PK.java | 74 - .../registry/jpa/model/DataTransferDetail.java | 92 - .../registry/jpa/model/ErrorDetail.java | 176 -- .../registry/jpa/model/Experiment.java | 300 -- .../jpa/model/ExperimentConfigData.java | 143 - .../registry/jpa/model/Experiment_Input.java | 170 - .../registry/jpa/model/Experiment_Input_PK.java | 64 - .../registry/jpa/model/Experiment_Output.java | 143 - .../jpa/model/Experiment_Output_PK.java | 64 - .../persistance/registry/jpa/model/Gateway.java | 76 - .../registry/jpa/model/Gateway_Worker.java | 82 - .../registry/jpa/model/Gateway_Worker_PK.java | 64 - .../registry/jpa/model/JobDetail.java | 136 - .../registry/jpa/model/JobDetails_PK.java | 64 - .../registry/jpa/model/NodeInput.java | 163 - .../registry/jpa/model/NodeInput_PK.java | 64 - .../registry/jpa/model/NodeOutput.java | 140 - .../registry/jpa/model/NodeOutput_PK.java | 64 - .../registry/jpa/model/Notification_Email.java | 81 - .../persistance/registry/jpa/model/Project.java | 125 - .../registry/jpa/model/ProjectUser.java | 81 - .../registry/jpa/model/ProjectUser_PK.java | 64 - .../registry/jpa/model/QosParam.java | 103 - .../persistance/registry/jpa/model/Status.java | 146 - .../registry/jpa/model/TaskDetail.java | 223 -- .../persistance/registry/jpa/model/Users.java | 55 - .../registry/jpa/model/WorkflowNodeDetail.java | 157 - .../jpa/resources/AbstractResource.java | 317 -- .../AdvanceInputDataHandlingResource.java | 162 - .../AdvancedOutputDataHandlingResource.java | 152 - .../jpa/resources/ApplicationInputResource.java | 231 -- .../resources/ApplicationOutputResource.java | 209 -- .../ComputationSchedulingResource.java | 223 -- .../jpa/resources/ConfigDataResource.java | 195 -- .../jpa/resources/ConfigurationResource.java | 208 -- .../resources/DataTransferDetailResource.java | 276 -- .../jpa/resources/ErrorDetailResource.java | 218 -- .../jpa/resources/ExperimentInputResource.java | 226 -- .../jpa/resources/ExperimentOutputResource.java | 205 -- .../jpa/resources/ExperimentResource.java | 831 ----- .../resources/ExperimentSummaryResource.java | 134 - .../registry/jpa/resources/GatewayResource.java | 437 --- .../jpa/resources/JobDetailResource.java | 376 --- .../jpa/resources/NodeInputResource.java | 228 -- .../jpa/resources/NodeOutputResource.java | 208 -- .../resources/NotificationEmailResource.java | 119 - .../registry/jpa/resources/ProjectResource.java | 508 --- .../jpa/resources/ProjectUserResource.java | 123 - .../jpa/resources/QosParamResource.java | 146 - .../registry/jpa/resources/StatusResource.java | 181 -- .../jpa/resources/TaskDetailResource.java | 748 ----- .../registry/jpa/resources/UserResource.java | 186 -- .../registry/jpa/resources/Utils.java | 1014 ------ .../registry/jpa/resources/WorkerResource.java | 725 ----- .../resources/WorkflowNodeDetailResource.java | 515 --- .../registry/jpa/utils/QueryGenerator.java | 128 - .../jpa/utils/ThriftDataModelConversion.java | 686 ---- .../src/main/resources/META-INF/persistence.xml | 65 - .../src/main/resources/registry-derby.sql | 391 --- .../src/main/resources/registry-mysql.sql | 392 --- .../registry/jpa/AbstractResourceTest.java | 91 - .../jpa/ComputationalSchedulingTest.java | 84 - .../registry/jpa/ConfigurationResourceTest.java | 58 - .../jpa/ExecutionErrorResourceTest.java | 95 - .../jpa/ExperimentDataResourceTest.java | 107 - .../jpa/ExperimentInputResourceTest.java | 75 - .../jpa/ExperimentMetadataResourceTest.java | 87 - .../jpa/ExperimentOutputResourceTest.java | 76 - .../registry/jpa/ExperimentResourceTest.java | 78 - .../registry/jpa/GFacJobDataResourceTest.java | 77 - .../registry/jpa/GFacJobStatusResourceTest.java | 87 - .../registry/jpa/GatewayResourceTest.java | 120 - .../registry/jpa/GramDataResourceTest.java | 72 - .../registry/jpa/NodeDataResourceTest.java | 72 - .../jpa/OrchestratorDataResourceTest.java | 69 - .../registry/jpa/RegistryUseCaseTest.java | 296 -- .../registry/jpa/TaskDetailResourceTest.java | 93 - .../registry/jpa/UserResourceTest.java | 54 - .../registry/jpa/WorkerResourceTest.java | 122 - .../registry/jpa/WorkflowDataResourceTest.java | 106 - .../jpa/WorkflowNodeDetailResourceTest.java | 85 - .../registry/jpa/util/Initialize.java | 334 -- .../airavata/provenance/test/JpaTest.java | 151 - .../src/test/resources/registry-derby.sql | 391 --- modules/registry/experiment-catalog/pom.xml | 151 + .../experiment/catalog/JPAConstants.java | 33 + .../airavata/experiment/catalog/Resource.java | 71 + .../experiment/catalog/ResourceType.java | 50 + .../experiment/catalog/ResourceUtils.java | 525 +++ .../catalog/impl/ExperimentRegistry.java | 2983 ++++++++++++++++++ .../catalog/impl/GatewayRegistry.java | 115 + .../catalog/impl/LoggingRegistryImpl.java | 97 + .../catalog/impl/ProjectRegistry.java | 303 ++ .../catalog/impl/RegistryFactory.java | 80 + .../experiment/catalog/impl/RegistryImpl.java | 735 +++++ .../experiment/catalog/impl/UserReg.java | 41 + .../model/AdvancedInputDataHandling.java | 113 + .../model/AdvancedOutputDataHandling.java | 104 + .../catalog/model/ApplicationInput.java | 165 + .../catalog/model/ApplicationInput_PK.java | 65 + .../catalog/model/ApplicationOutput.java | 142 + .../catalog/model/ApplicationOutput_PK.java | 64 + .../Computational_Resource_Scheduling.java | 174 + .../experiment/catalog/model/Configuration.java | 80 + .../catalog/model/Configuration_PK.java | 74 + .../catalog/model/DataTransferDetail.java | 91 + .../experiment/catalog/model/ErrorDetail.java | 176 ++ .../experiment/catalog/model/Experiment.java | 299 ++ .../catalog/model/ExperimentConfigData.java | 142 + .../catalog/model/Experiment_Input.java | 170 + .../catalog/model/Experiment_Input_PK.java | 64 + .../catalog/model/Experiment_Output.java | 143 + .../catalog/model/Experiment_Output_PK.java | 64 + .../experiment/catalog/model/Gateway.java | 76 + .../catalog/model/Gateway_Worker.java | 82 + .../catalog/model/Gateway_Worker_PK.java | 64 + .../experiment/catalog/model/JobDetail.java | 135 + .../experiment/catalog/model/JobDetails_PK.java | 64 + .../experiment/catalog/model/NodeInput.java | 163 + .../experiment/catalog/model/NodeInput_PK.java | 64 + .../experiment/catalog/model/NodeOutput.java | 140 + .../experiment/catalog/model/NodeOutput_PK.java | 64 + .../catalog/model/Notification_Email.java | 81 + .../experiment/catalog/model/Project.java | 125 + .../experiment/catalog/model/ProjectUser.java | 81 + .../catalog/model/ProjectUser_PK.java | 64 + .../experiment/catalog/model/QosParam.java | 103 + .../experiment/catalog/model/Status.java | 146 + .../experiment/catalog/model/TaskDetail.java | 221 ++ .../experiment/catalog/model/Users.java | 55 + .../catalog/model/WorkflowNodeDetail.java | 155 + .../catalog/resources/AbstractResource.java | 317 ++ .../AdvanceInputDataHandlingResource.java | 160 + .../AdvancedOutputDataHandlingResource.java | 150 + .../resources/ApplicationInputResource.java | 230 ++ .../resources/ApplicationOutputResource.java | 208 ++ .../ComputationSchedulingResource.java | 221 ++ .../catalog/resources/ConfigDataResource.java | 194 ++ .../resources/ConfigurationResource.java | 204 ++ .../resources/DataTransferDetailResource.java | 276 ++ .../catalog/resources/ErrorDetailResource.java | 215 ++ .../resources/ExperimentInputResource.java | 225 ++ .../resources/ExperimentOutputResource.java | 204 ++ .../catalog/resources/ExperimentResource.java | 831 +++++ .../resources/ExperimentSummaryResource.java | 134 + .../catalog/resources/GatewayResource.java | 437 +++ .../catalog/resources/JobDetailResource.java | 376 +++ .../catalog/resources/NodeInputResource.java | 227 ++ .../catalog/resources/NodeOutputResource.java | 207 ++ .../resources/NotificationEmailResource.java | 119 + .../catalog/resources/ProjectResource.java | 508 +++ .../catalog/resources/ProjectUserResource.java | 123 + .../catalog/resources/QosParamResource.java | 144 + .../catalog/resources/StatusResource.java | 181 ++ .../catalog/resources/TaskDetailResource.java | 748 +++++ .../catalog/resources/UserResource.java | 186 ++ .../experiment/catalog/resources/Utils.java | 1011 ++++++ .../catalog/resources/WorkerResource.java | 725 +++++ .../resources/WorkflowNodeDetailResource.java | 515 +++ .../catalog/utils/QueryGenerator.java | 128 + .../utils/ThriftDataModelConversion.java | 686 ++++ .../src/main/resources/META-INF/persistence.xml | 65 + .../src/main/resources/registry-derby.sql | 391 +++ .../src/main/resources/registry-mysql.sql | 392 +++ .../catalog/AbstractResourceTest.java | 91 + .../catalog/ComputationalSchedulingTest.java | 84 + .../catalog/ConfigurationResourceTest.java | 58 + .../catalog/ExecutionErrorResourceTest.java | 95 + .../catalog/ExperimentDataResourceTest.java | 107 + .../catalog/ExperimentInputResourceTest.java | 75 + .../catalog/ExperimentMetadataResourceTest.java | 87 + .../catalog/ExperimentOutputResourceTest.java | 76 + .../catalog/ExperimentResourceTest.java | 77 + .../catalog/GFacJobDataResourceTest.java | 77 + .../catalog/GFacJobStatusResourceTest.java | 87 + .../experiment/catalog/GatewayResourceTest.java | 120 + .../catalog/GramDataResourceTest.java | 72 + .../catalog/NodeDataResourceTest.java | 72 + .../catalog/OrchestratorDataResourceTest.java | 69 + .../experiment/catalog/RegistryUseCaseTest.java | 296 ++ .../catalog/TaskDetailResourceTest.java | 93 + .../experiment/catalog/UserResourceTest.java | 54 + .../experiment/catalog/WorkerResourceTest.java | 122 + .../catalog/WorkflowDataResourceTest.java | 106 + .../catalog/WorkflowNodeDetailResourceTest.java | 85 + .../experiment/catalog/util/Initialize.java | 333 ++ .../src/test/resources/registry-derby.sql | 391 +++ modules/registry/pom.xml | 2 +- modules/workflow-model/workflow-engine/pom.xml | 2 +- .../workflow/engine/WorkflowEngineImpl.java | 2 +- .../engine/interpretor/WorkflowInterpreter.java | 3 +- modules/workflow/workflow-core/pom.xml | 2 +- .../core/SimpleWorkflowInterpreter.java | 2 +- .../core/parser/AiravataWorkflowParser.java | 2 +- modules/xbaya-gui/pom.xml | 2 +- .../dialogs/registry/NewRegistryUserDialog.java | 10 +- pom.xml | 2 +- 248 files changed, 22727 insertions(+), 22986 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/airavata/blob/22a76f8a/modules/registry/experiment-catalog/src/main/java/org/apache/airavata/experiment/catalog/resources/WorkerResource.java ---------------------------------------------------------------------- diff --cc modules/registry/experiment-catalog/src/main/java/org/apache/airavata/experiment/catalog/resources/WorkerResource.java index 0000000,51ba04f..6b4a6a5 mode 000000,100644..100644 --- a/modules/registry/experiment-catalog/src/main/java/org/apache/airavata/experiment/catalog/resources/WorkerResource.java +++ b/modules/registry/experiment-catalog/src/main/java/org/apache/airavata/experiment/catalog/resources/WorkerResource.java @@@ -1,0 -1,727 +1,725 @@@ + /* + * + * 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.experiment.catalog.resources; + + import org.apache.airavata.model.workspace.experiment.ExperimentState; + import org.apache.airavata.experiment.catalog.Resource; + import org.apache.airavata.experiment.catalog.ResourceType; + import org.apache.airavata.experiment.catalog.ResourceUtils; + import org.apache.airavata.experiment.catalog.model.*; + import org.apache.airavata.experiment.catalog.utils.QueryGenerator; + import org.apache.airavata.registry.cpi.RegistryException; + 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.apache.openjpa.persistence.OpenJPAPersistence; + import org.apache.openjpa.persistence.OpenJPAQuery; + import org.apache.openjpa.persistence.jdbc.FetchMode; + import org.apache.openjpa.persistence.jdbc.JDBCFetchPlan; + 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; + 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 String gatewayId; + + public WorkerResource() { + } + + public WorkerResource(String user, String gatewayId) { + this.user = user; + this.gatewayId = gatewayId; + } + + public String getGatewayId() { + return gatewayId; + } + + public void setGatewayId(String gatewayId) { + this.gatewayId = gatewayId; + } + + /** + * 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.setGatewayId(gatewayId); + result=projectResource; + break; + case EXPERIMENT: + ExperimentResource experimentResource = new ExperimentResource(); + experimentResource.setExecutionUser(user); + experimentResource.setGatewayId(gatewayId); + 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 get 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 get 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, gatewayId); + generator.setParameter("users", users); + if (gatewayModel != null){ + 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; + } + + /** + * save 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(gatewayId, 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()); + gatewayWorker.setGateway_id(gatewayId); + if (existingWorker != null) { + existingWorker.setUser_name(existingUser.getUser_name()); + existingWorker.setUser(existingUser); + existingWorker.setGateway_id(gatewayId); + 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; + } + + /** + * + * @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)get(ResourceType.GFAC_JOB_DATA,jobId); + // } + + /** + * Method to get 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 get 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 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 the experiments of user with the given time period and 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. Also if + * time period values i.e fromTime and toTime are null they will be ignored. + * + * @param fromTime + * @param toTime + * @param filters + * @param limit + * @param offset + * @param orderByIdentifier + * @param resultOrderType + * @return + * @throws RegistryException + */ + public List<ExperimentSummaryResource> searchExperiments(Timestamp fromTime, Timestamp toTime, Map<String, String> filters, int limit, + int offset, Object orderByIdentifier, ResultOrderType resultOrderType) throws RegistryException { + List<ExperimentSummaryResource> result = new ArrayList(); + EntityManager em = null; + try { - String query; ++ String query = "SELECT e, s FROM Experiment e " + ++ ",Status s WHERE e.expId=s.expId AND " + ++ "s.statusType='" + StatusType.EXPERIMENT + "' AND "; + if(filters.get(StatusConstants.STATE) != null) { - query = "SELECT DISTINCT (e) FROM Experiment e " + - "JOIN e.statuses s LEFT JOIN FETCH e.statuses WHERE " + - "s.statusType='" + StatusType.EXPERIMENT + "' AND "; + String experimentState = ExperimentState.valueOf(filters.get(StatusConstants.STATE)).toString(); + query += "s.state='" + experimentState + "' AND "; - }else{ - query = "SELECT e FROM Experiment e " + - "LEFT JOIN FETCH e.statuses WHERE "; + } + + if(toTime != null && fromTime != null && toTime.after(fromTime)){ + query += "e.creationTime > '" + fromTime + "' " + "AND e.creationTime <'" + toTime + "' AND "; + } + + filters.remove(StatusConstants.STATE); + 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); + } + OpenJPAQuery kq = OpenJPAPersistence.cast(q); + JDBCFetchPlan fetch = (JDBCFetchPlan) kq.getFetchPlan(); + fetch.setEagerFetchMode(FetchMode.JOIN); + + List resultList = q.getResultList(); + for (Object o : resultList) { - Experiment experiment = (Experiment) o; ++ Experiment experiment = (Experiment) ((Object[])o)[0]; ++ Status experimentStatus = (Status) ((Object[])o)[1]; ++ experiment.setExperimentStatus(experimentStatus); + ExperimentSummaryResource experimentSummaryResource = + (ExperimentSummaryResource) Utils.getResource(ResourceType.EXPERIMENT_SUMMARY, experiment); + result.add(experimentSummaryResource); + } + 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; + } + }
