You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sh...@apache.org on 2015/06/04 22:36:48 UTC
[02/52] [abbrv] [partial] airavata git commit: registry refactoring
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogThriftConversion.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogThriftConversion.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogThriftConversion.java
new file mode 100644
index 0000000..cc0abc8
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogThriftConversion.java
@@ -0,0 +1,800 @@
+/*
+ *
+ * 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.registry.core.app.catalog.util;
+
+import org.apache.airavata.model.Workflow;
+import org.apache.airavata.model.appcatalog.appdeployment.ApplicationDeploymentDescription;
+import org.apache.airavata.model.appcatalog.appdeployment.ApplicationModule;
+import org.apache.airavata.model.appcatalog.appdeployment.ApplicationParallelismType;
+import org.apache.airavata.model.appcatalog.appdeployment.SetEnvPaths;
+import org.apache.airavata.model.appcatalog.appinterface.*;
+import org.apache.airavata.model.appcatalog.computeresource.*;
+import org.apache.airavata.model.appcatalog.computeresource.BatchQueue;
+import org.apache.airavata.model.appcatalog.computeresource.CloudJobSubmission;
+import org.apache.airavata.model.appcatalog.computeresource.DataMovementInterface;
+import org.apache.airavata.model.appcatalog.computeresource.JobManagerCommand;
+import org.apache.airavata.model.appcatalog.computeresource.JobSubmissionInterface;
+import org.apache.airavata.model.appcatalog.computeresource.ResourceJobManager;
+import org.apache.airavata.model.appcatalog.computeresource.UnicoreDataMovement;
+import org.apache.airavata.model.appcatalog.computeresource.UnicoreJobSubmission;
+import org.apache.airavata.model.appcatalog.gatewayprofile.ComputeResourcePreference;
+import org.apache.airavata.model.appcatalog.gatewayprofile.GatewayResourceProfile;
+import org.apache.airavata.registry.core.app.catalog.resources.*;
+import org.apache.airavata.registry.cpi.AppCatalogException;
+
+import java.util.*;
+
+public class AppCatalogThriftConversion {
+ public static ComputeResourceAppCatalogResourceAppCat getComputeHostResource (ComputeResourceDescription description){
+ ComputeResourceAppCatalogResourceAppCat resource = new ComputeResourceAppCatalogResourceAppCat();
+ resource.setHostName(description.getHostName());
+ resource.setResourceDescription(description.getResourceDescription());
+ resource.setResourceId(description.getComputeResourceId());
+ resource.setMaxMemoryPerNode(description.getMaxMemoryPerNode());
+ return resource;
+ }
+
+ public static ComputeResourceDescription getComputeHostDescription (ComputeResourceAppCatalogResourceAppCat resource) throws AppCatalogException {
+ ComputeResourceDescription description = new ComputeResourceDescription();
+ description.setComputeResourceId(resource.getResourceId());
+ description.setHostName(resource.getHostName());
+ description.setResourceDescription(resource.getResourceDescription());
+ description.setMaxMemoryPerNode(resource.getMaxMemoryPerNode());
+ HostAliasAppCatalogResourceAppCat aliasResource = new HostAliasAppCatalogResourceAppCat();
+ List<AppCatalogResource> resources = aliasResource.get(AppCatAbstractResource.HostAliasConstants.RESOURCE_ID, resource.getResourceId());
+ if (resources != null && !resources.isEmpty()){
+ description.setHostAliases(getHostAliases(resources));
+ }
+ HostIPAddressAppCatalogResourceAppCat ipAddressResource = new HostIPAddressAppCatalogResourceAppCat();
+ List<AppCatalogResource> ipAddresses = ipAddressResource.get(AppCatAbstractResource.HostIPAddressConstants.RESOURCE_ID, resource.getResourceId());
+ if (ipAddresses != null && !ipAddresses.isEmpty()){
+ description.setIpAddresses(getIpAddresses(ipAddresses));
+ }
+
+ BatchQueueAppCatalogResourceAppCat bqResource = new BatchQueueAppCatalogResourceAppCat();
+ List<AppCatalogResource> batchQueues = bqResource.get(AppCatAbstractResource.BatchQueueConstants.COMPUTE_RESOURCE_ID, resource.getResourceId());
+ if (batchQueues != null && !batchQueues.isEmpty()){
+ description.setBatchQueues(getBatchQueues(batchQueues));
+ }
+
+ ComputeResourceFileSystemAppCatalogResourceAppCat fsResource = new ComputeResourceFileSystemAppCatalogResourceAppCat();
+ List<AppCatalogResource> fsList = fsResource.get(AppCatAbstractResource.ComputeResourceFileSystemConstants.COMPUTE_RESOURCE_ID, resource.getResourceId());
+ description.setFileSystems(new HashMap<FileSystems,String>());
+ if (fsList != null && !fsList.isEmpty()){
+ for (AppCatalogResource r : fsList) {
+ ComputeResourceFileSystemAppCatalogResourceAppCat rr=(ComputeResourceFileSystemAppCatalogResourceAppCat)r;
+ description.getFileSystems().put(FileSystems.valueOf(rr.getFileSystem()), rr.getPath());
+ }
+ }
+
+ JobSubmissionInterfaceAppCatalogResourceAppCat jsiResource = new JobSubmissionInterfaceAppCatalogResourceAppCat();
+ List<AppCatalogResource> hsiList = jsiResource.get(AppCatAbstractResource.JobSubmissionInterfaceConstants.COMPUTE_RESOURCE_ID, resource.getResourceId());
+ if (hsiList != null && !hsiList.isEmpty()){
+ description.setJobSubmissionInterfaces(getJobSubmissionInterfaces(hsiList));
+ }
+
+ DataMovementInterfaceAppCatalogResourceAppCat dmiResource = new DataMovementInterfaceAppCatalogResourceAppCat();
+ List<AppCatalogResource> dmiList = dmiResource.get(AppCatAbstractResource.DataMovementInterfaceConstants.COMPUTE_RESOURCE_ID, resource.getResourceId());
+ if (dmiList != null && !dmiList.isEmpty()){
+ description.setDataMovementInterfaces(getDataMovementInterfaces(dmiList));
+ }
+ return description;
+ }
+
+ public static List<ComputeResourceDescription> getComputeDescriptionList (List<AppCatalogResource> resources) throws AppCatalogException {
+ List<ComputeResourceDescription> list = new ArrayList<ComputeResourceDescription>();
+ for (AppCatalogResource resource : resources){
+ list.add(getComputeHostDescription((ComputeResourceAppCatalogResourceAppCat)resource));
+ }
+ return list;
+ }
+
+ public static List<String> getHostAliases (List<AppCatalogResource> resources){
+ List<String> hostAliases = new ArrayList<String>();
+ for (AppCatalogResource alias : resources){
+ hostAliases.add(((HostAliasAppCatalogResourceAppCat)alias).getAlias());
+ }
+ return hostAliases;
+ }
+
+ public static List<String> getIpAddresses (List<AppCatalogResource> resources){
+ List<String> hostIpAddresses = new ArrayList<String>();
+ for (AppCatalogResource resource : resources){
+ hostIpAddresses.add(((HostIPAddressAppCatalogResourceAppCat)resource).getIpaddress());
+ }
+ return hostIpAddresses;
+ }
+
+ public static List<BatchQueue> getBatchQueues (List<AppCatalogResource> resources){
+ List<BatchQueue> batchQueues = new ArrayList<BatchQueue>();
+ for (AppCatalogResource resource : resources){
+ batchQueues.add(getBatchQueue((BatchQueueAppCatalogResourceAppCat)resource));
+ }
+ return batchQueues;
+ }
+
+ public static List<DataMovementInterface> getDataMovementInterfaces(List<AppCatalogResource> resources){
+ List<DataMovementInterface> dataMovementInterfaces = new ArrayList<DataMovementInterface>();
+ for (AppCatalogResource resource : resources){
+ dataMovementInterfaces.add(getDataMovementInterface((DataMovementInterfaceAppCatalogResourceAppCat)resource));
+ }
+ return dataMovementInterfaces;
+ }
+
+ public static DataMovementInterface getDataMovementInterface(DataMovementInterfaceAppCatalogResourceAppCat resource){
+ DataMovementInterface dmi = new DataMovementInterface();
+ dmi.setDataMovementInterfaceId(resource.getDataMovementInterfaceId());
+ dmi.setDataMovementProtocol(DataMovementProtocol.valueOf(resource.getDataMovementProtocol()));
+ dmi.setPriorityOrder(resource.getPriorityOrder());
+ return dmi;
+ }
+
+ public static DataMovementInterfaceAppCatalogResourceAppCat getDataMovementInterface(DataMovementInterface resource){
+ DataMovementInterfaceAppCatalogResourceAppCat dmi = new DataMovementInterfaceAppCatalogResourceAppCat();
+ dmi.setDataMovementInterfaceId(resource.getDataMovementInterfaceId());
+ dmi.setDataMovementProtocol(resource.getDataMovementProtocol().toString());
+ dmi.setPriorityOrder(resource.getPriorityOrder());
+ return dmi;
+ }
+
+ public static List<JobSubmissionInterface> getJobSubmissionInterfaces(List<AppCatalogResource> resources){
+ List<JobSubmissionInterface> jobSubmissionInterfaces = new ArrayList<JobSubmissionInterface>();
+ for (AppCatalogResource resource : resources){
+ jobSubmissionInterfaces.add(getJobSubmissionInterface((JobSubmissionInterfaceAppCatalogResourceAppCat)resource));
+ }
+ return jobSubmissionInterfaces;
+ }
+
+ public static JobSubmissionInterface getJobSubmissionInterface(JobSubmissionInterfaceAppCatalogResourceAppCat resource){
+ JobSubmissionInterface jsi = new JobSubmissionInterface();
+ jsi.setJobSubmissionInterfaceId(resource.getJobSubmissionInterfaceId());
+ jsi.setJobSubmissionProtocol(JobSubmissionProtocol.valueOf(resource.getJobSubmissionProtocol()));
+ jsi.setPriorityOrder(resource.getPriorityOrder());
+ return jsi;
+ }
+
+ public static JobSubmissionInterfaceAppCatalogResourceAppCat getJobSubmissionInterface(JobSubmissionInterface resource){
+ JobSubmissionInterfaceAppCatalogResourceAppCat jsi = new JobSubmissionInterfaceAppCatalogResourceAppCat();
+ jsi.setJobSubmissionInterfaceId(resource.getJobSubmissionInterfaceId());
+ jsi.setJobSubmissionProtocol(resource.getJobSubmissionProtocol().toString());
+ jsi.setPriorityOrder(resource.getPriorityOrder());
+ return jsi;
+ }
+
+ public static BatchQueue getBatchQueue(BatchQueueAppCatalogResourceAppCat resource){
+ BatchQueue batchQueue = new BatchQueue();
+ batchQueue.setMaxJobsInQueue(resource.getMaxJobInQueue());
+ batchQueue.setMaxNodes(resource.getMaxNodes());
+ batchQueue.setMaxProcessors(resource.getMaxProcessors());
+ batchQueue.setMaxRunTime(resource.getMaxRuntime());
+ batchQueue.setMaxMemory(resource.getMaxMemory());
+ batchQueue.setQueueDescription(resource.getQueueDescription());
+ batchQueue.setQueueName(resource.getQueueName());
+ return batchQueue;
+ }
+
+ public static BatchQueueAppCatalogResourceAppCat getBatchQueue(BatchQueue resource){
+ BatchQueueAppCatalogResourceAppCat batchQueue = new BatchQueueAppCatalogResourceAppCat();
+ batchQueue.setMaxJobInQueue(resource.getMaxJobsInQueue());
+ batchQueue.setMaxNodes(resource.getMaxNodes());
+ batchQueue.setMaxProcessors(resource.getMaxProcessors());
+ batchQueue.setMaxRuntime(resource.getMaxRunTime());
+ batchQueue.setQueueDescription(resource.getQueueDescription());
+ batchQueue.setQueueName(resource.getQueueName());
+ batchQueue.setMaxMemory(resource.getMaxMemory());
+ return batchQueue;
+ }
+
+// public static Map<String, JobSubmissionProtocol> getJobSubmissionProtocolList(List<Resource> resources){
+// Map<String, JobSubmissionProtocol> protocols = new HashMap<String, JobSubmissionProtocol>();
+// for (Resource resource : resources){
+// JobSubmissionProtocolResource submission = (JobSubmissionProtocolResource) resource;
+// protocols.put(submission.getSubmissionID(), JobSubmissionProtocol.valueOf(submission.getJobType()));
+// }
+// return protocols;
+// }
+
+// public static Map<String, DataMovementProtocol> getDataMoveProtocolList(List<Resource> resources){
+// Map<String, DataMovementProtocol> protocols = new HashMap<String, DataMovementProtocol>();
+// for (Resource resource : resources){
+// DataMovementProtocolResource protocolResource = (DataMovementProtocolResource) resource;
+// protocols.put(protocolResource.getDataMoveID(), DataMovementProtocol.valueOf(protocolResource.getDataMoveType()));
+// }
+// return protocols;
+// }
+
+ public static SshJobSubmissionAppCatalogResourceAppCat getSSHJobSubmission (SSHJobSubmission submission){
+ SshJobSubmissionAppCatalogResourceAppCat resource = new SshJobSubmissionAppCatalogResourceAppCat();
+ resource.setAlternativeSshHostname(submission.getAlternativeSSHHostName());
+ resource.setJobSubmissionInterfaceId(submission.getJobSubmissionInterfaceId());
+ ResourceJobManagerAppCatalogResourceAppCat resourceJobManager = getResourceJobManager(submission.getResourceJobManager());
+// resourceJobManager.setResourceJobManagerId(submission.getJobSubmissionInterfaceId());
+ resource.setResourceJobManagerId(resourceJobManager.getResourceJobManagerId());
+ if (submission.getMonitorMode() != null){
+ resource.setMonitorMode(submission.getMonitorMode().toString());
+ }
+ resource.setResourceJobManagerResource(resourceJobManager);
+ if (submission.getSecurityProtocol() != null){
+ resource.setSecurityProtocol(submission.getSecurityProtocol().toString());
+ }
+ resource.setSshPort(submission.getSshPort());
+ return resource;
+ }
+
+
+ public static UnicoreJobSubmissionAppCatalogResourceAppCat getUnicoreJobSubmission (UnicoreJobSubmission submission){
+ UnicoreJobSubmissionAppCatalogResourceAppCat resource = new UnicoreJobSubmissionAppCatalogResourceAppCat();
+ resource.setjobSubmissionInterfaceId(submission.getJobSubmissionInterfaceId());
+ if (submission.getSecurityProtocol() != null){
+ resource.setSecurityProtocol(submission.getSecurityProtocol().toString());
+ }
+ resource.setUnicoreEndpointUrl(submission.getUnicoreEndPointURL());
+ return resource;
+ }
+
+ public static UnicoreDataMovementAppCatalogResourceAppCat getUnicoreDMResource (UnicoreDataMovement dataMovement){
+ UnicoreDataMovementAppCatalogResourceAppCat resource = new UnicoreDataMovementAppCatalogResourceAppCat();
+ resource.setDataMovementId(dataMovement.getDataMovementInterfaceId());
+ if (dataMovement.getSecurityProtocol() != null){
+ resource.setSecurityProtocol(dataMovement.getSecurityProtocol().toString());
+ }
+ resource.setUnicoreEndpointUrl(dataMovement.getUnicoreEndPointURL());
+ return resource;
+ }
+
+
+ public static CloudSubmissionAppCatalogResourceAppCat getCloudJobSubmission (CloudJobSubmission submission){
+ CloudSubmissionAppCatalogResourceAppCat resource = new CloudSubmissionAppCatalogResourceAppCat();
+ resource.setJobSubmissionInterfaceId(submission.getJobSubmissionInterfaceId());
+ if (submission.getSecurityProtocol() != null){
+ resource.setSecurityProtocol(submission.getSecurityProtocol().toString());
+ }
+ if(submission.getProviderName() != null){
+ resource.setProviderName(submission.getProviderName().toString());
+ }
+ resource.setUserAccountName(submission.getUserAccountName());
+ resource.setNodeId(submission.getNodeId());
+ resource.setExecutableType(submission.getExecutableType());
+ return resource;
+ }
+
+ public static LocalDataMovementAppCatalogResourceAppCat getLocalDataMovement(LOCALDataMovement localSubmission)throws AppCatalogException {
+ LocalDataMovementAppCatalogResourceAppCat submission = new LocalDataMovementAppCatalogResourceAppCat();
+ submission.setDataMovementInterfaceId(localSubmission.getDataMovementInterfaceId());
+ return submission;
+ }
+
+ public static LOCALDataMovement getLocalDataMovement(LocalDataMovementAppCatalogResourceAppCat localSubmission)throws AppCatalogException {
+ LOCALDataMovement submission = new LOCALDataMovement();
+ submission.setDataMovementInterfaceId(localSubmission.getDataMovementInterfaceId());
+ return submission;
+ }
+
+
+ public static LocalSubmissionAppCatalogResourceAppCat getLocalJobSubmission(LOCALSubmission localSubmission)throws AppCatalogException {
+ LocalSubmissionAppCatalogResourceAppCat submission = new LocalSubmissionAppCatalogResourceAppCat();
+ submission.setJobSubmissionInterfaceId(localSubmission.getJobSubmissionInterfaceId());
+ ResourceJobManagerAppCatalogResourceAppCat resourceJobManager = getResourceJobManager(localSubmission.getResourceJobManager());
+ submission.setResourceJobManagerId(resourceJobManager.getResourceJobManagerId());
+ submission.setResourceJobManagerResource(resourceJobManager);
+ return submission;
+ }
+
+ public static LOCALSubmission getLocalJobSubmission(LocalSubmissionAppCatalogResourceAppCat localSubmission)throws AppCatalogException {
+ LOCALSubmission submission = new LOCALSubmission();
+ submission.setJobSubmissionInterfaceId(localSubmission.getJobSubmissionInterfaceId());
+ submission.setResourceJobManager(getResourceJobManager(localSubmission.getResourceJobManagerResource()));
+ return submission;
+ }
+
+ public static ResourceJobManagerAppCatalogResourceAppCat getResourceJobManager(ResourceJobManager manager){
+ ResourceJobManagerAppCatalogResourceAppCat r = new ResourceJobManagerAppCatalogResourceAppCat();
+ r.setResourceJobManagerId(manager.getResourceJobManagerId());
+ r.setJobManagerBinPath(manager.getJobManagerBinPath());
+ r.setPushMonitoringEndpoint(manager.getPushMonitoringEndpoint());
+ r.setResourceJobManagerType(manager.getResourceJobManagerType().toString());
+ return r;
+ }
+
+ public static ResourceJobManager getResourceJobManager(ResourceJobManagerAppCatalogResourceAppCat manager) throws AppCatalogException {
+ ResourceJobManager r = new ResourceJobManager();
+ r.setResourceJobManagerId(manager.getResourceJobManagerId());
+ r.setJobManagerBinPath(manager.getJobManagerBinPath());
+ r.setPushMonitoringEndpoint(manager.getPushMonitoringEndpoint());
+ r.setResourceJobManagerType(ResourceJobManagerType.valueOf(manager.getResourceJobManagerType()));
+ r.setJobManagerCommands(new HashMap<JobManagerCommand, String>());
+ JobManagerCommandAppCatalogResourceAppCat jmcr=new JobManagerCommandAppCatalogResourceAppCat();
+ List<AppCatalogResource> jmcrList = jmcr.get(AppCatAbstractResource.JobManagerCommandConstants.RESOURCE_JOB_MANAGER_ID, manager.getResourceJobManagerId());
+ if (jmcrList != null && !jmcrList.isEmpty()){
+ for (AppCatalogResource rrr : jmcrList) {
+ JobManagerCommandAppCatalogResourceAppCat rr=(JobManagerCommandAppCatalogResourceAppCat)rrr;
+ r.getJobManagerCommands().put(JobManagerCommand.valueOf(rr.getCommandType()), rr.getCommand());
+ }
+ }
+ return r;
+ }
+
+
+ public static SSHJobSubmission getSSHJobSubmissionDescription (SshJobSubmissionAppCatalogResourceAppCat submission) throws AppCatalogException {
+ SSHJobSubmission sshJobSubmission = new SSHJobSubmission();
+ sshJobSubmission.setAlternativeSSHHostName(submission.getAlternativeSshHostname());
+ sshJobSubmission.setJobSubmissionInterfaceId(submission.getJobSubmissionInterfaceId());
+ sshJobSubmission.setResourceJobManager(getResourceJobManager(submission.getResourceJobManagerResource()));
+ sshJobSubmission.setSecurityProtocol(SecurityProtocol.valueOf(submission.getSecurityProtocol()));
+ sshJobSubmission.setSshPort(submission.getSshPort());
+ if (submission.getMonitorMode() != null){
+ sshJobSubmission.setMonitorMode(MonitorMode.valueOf(submission.getMonitorMode()));
+ }
+ return sshJobSubmission;
+ }
+
+ public static UnicoreJobSubmission getUnicoreJobSubmissionDescription (UnicoreJobSubmissionAppCatalogResourceAppCat submission) throws AppCatalogException {
+ UnicoreJobSubmission unicoreJobSubmission = new UnicoreJobSubmission();
+ unicoreJobSubmission.setUnicoreEndPointURL(submission.getUnicoreEndpointUrl());
+ unicoreJobSubmission.setJobSubmissionInterfaceId(submission.getjobSubmissionInterfaceId());
+ if (submission.getSecurityProtocol() != null){
+ unicoreJobSubmission.setSecurityProtocol(SecurityProtocol.valueOf(submission.getSecurityProtocol()));
+ }
+ return unicoreJobSubmission;
+ }
+
+ public static UnicoreDataMovement getUnicoreDMDescription (UnicoreDataMovementAppCatalogResourceAppCat resource) throws AppCatalogException {
+ UnicoreDataMovement dataMovement = new UnicoreDataMovement();
+ dataMovement.setUnicoreEndPointURL(resource.getUnicoreEndpointUrl());
+ dataMovement.setDataMovementInterfaceId(resource.getDataMovementId());
+ if (resource.getSecurityProtocol() != null){
+ dataMovement.setSecurityProtocol(SecurityProtocol.valueOf(resource.getSecurityProtocol()));
+ }
+ return dataMovement;
+ }
+
+
+ public static CloudJobSubmission getCloudJobSubmissionDescription (CloudSubmissionAppCatalogResourceAppCat submission) throws AppCatalogException {
+ CloudJobSubmission cloudJobSubmission = new CloudJobSubmission();
+ cloudJobSubmission.setJobSubmissionInterfaceId(submission.getJobSubmissionInterfaceId());
+ cloudJobSubmission.setExecutableType(submission.getExecutableType());
+ cloudJobSubmission.setSecurityProtocol(SecurityProtocol.valueOf(submission.getSecurityProtocol()));
+ cloudJobSubmission.setNodeId(submission.getNodeId());
+ cloudJobSubmission.setUserAccountName(submission.getUserAccountName());
+ cloudJobSubmission.setProviderName(ProviderName.valueOf(submission.getProviderName()));
+ return cloudJobSubmission;
+ }
+
+// public static GlobusJobSubmission getGlobusJobSubmissionDescription (GlobusJobSubmissionResource submission) throws AppCatalogException {
+// GlobusJobSubmission globusJobSubmission = new GlobusJobSubmission();
+// globusJobSubmission.setJobSubmissionInterfaceId(submission.getSubmissionID());
+// globusJobSubmission.setResourceJobManager(ResourceJobManager.valueOf(submission.getResourceJobManager()));
+// globusJobSubmission.setSecurityProtocol(SecurityProtocol.valueOf(submission.getSecurityProtocol()));
+//
+// GlobusGKEndpointResource endpointResource = new GlobusGKEndpointResource();
+// List<Resource> endpoints = endpointResource.get(AbstractResource.GlobusEPConstants.SUBMISSION_ID, submission.getSubmissionID());
+// if (endpoints != null && !endpoints.isEmpty()){
+// globusJobSubmission.setGlobusGateKeeperEndPoint(getGlobusGateKeeperEndPointList(endpoints));
+// }
+//
+// return globusJobSubmission;
+// }
+
+ public static SCPDataMovement getSCPDataMovementDescription (ScpDataMovementAppCatalogResourceAppCat dataMovementResource) throws AppCatalogException {
+ SCPDataMovement dataMovement = new SCPDataMovement();
+ dataMovement.setDataMovementInterfaceId(dataMovementResource.getDataMovementInterfaceId());
+ dataMovement.setAlternativeSCPHostName(dataMovementResource.getAlternativeScpHostname());
+ dataMovement.setSecurityProtocol(SecurityProtocol.valueOf(dataMovementResource.getSecurityProtocol()));
+ dataMovement.setSshPort(dataMovementResource.getSshPort());
+ return dataMovement;
+ }
+
+ public static ScpDataMovementAppCatalogResourceAppCat getSCPDataMovementDescription (SCPDataMovement dataMovementResource) throws AppCatalogException {
+ ScpDataMovementAppCatalogResourceAppCat dataMovement = new ScpDataMovementAppCatalogResourceAppCat();
+ dataMovement.setDataMovementInterfaceId(dataMovementResource.getDataMovementInterfaceId());
+ dataMovement.setAlternativeScpHostname(dataMovementResource.getAlternativeSCPHostName());
+ dataMovement.setSecurityProtocol(dataMovementResource.getSecurityProtocol().toString());
+ dataMovement.setSshPort(dataMovementResource.getSshPort());
+ return dataMovement;
+ }
+
+ public static GridFTPDataMovement getGridFTPDataMovementDescription (GridftpDataMovementAppCatalogResourceAppCat dataMovementResource) throws AppCatalogException {
+ GridFTPDataMovement dataMovement = new GridFTPDataMovement();
+ dataMovement.setDataMovementInterfaceId(dataMovementResource.getDataMovementInterfaceId());
+ dataMovement.setSecurityProtocol(SecurityProtocol.valueOf(dataMovementResource.getSecurityProtocol()));
+ GridftpEndpointAppCatalogResourceAppCat endpointResource = new GridftpEndpointAppCatalogResourceAppCat();
+ List<AppCatalogResource> endpoints = endpointResource.get(AppCatAbstractResource.GridftpEndpointConstants.DATA_MOVEMENT_INTERFACE_ID, dataMovementResource.getDataMovementInterfaceId());
+ if (endpoints != null && !endpoints.isEmpty()){
+ dataMovement.setGridFTPEndPoints(getGridFTPDMEPList(endpoints));
+ }
+ return dataMovement;
+ }
+
+ public static GridftpDataMovementAppCatalogResourceAppCat getGridFTPDataMovementDescription (GridFTPDataMovement dataMovementResource) throws AppCatalogException {
+ GridftpDataMovementAppCatalogResourceAppCat dataMovement = new GridftpDataMovementAppCatalogResourceAppCat();
+ dataMovement.setDataMovementInterfaceId(dataMovementResource.getDataMovementInterfaceId());
+ dataMovement.setSecurityProtocol(dataMovementResource.getSecurityProtocol().toString());
+ return dataMovement;
+ }
+
+ public static List<String> getGridFTPDMEPList (List<AppCatalogResource> endpoints){
+ List<String> list = new ArrayList<String>();
+ for (AppCatalogResource resource : endpoints){
+ list.add(((GridftpEndpointAppCatalogResourceAppCat) resource).getEndpoint());
+ }
+ return list;
+ }
+
+ public static List<String> getGlobusGateKeeperEndPointList (List<AppCatalogResource> resources) throws AppCatalogException {
+ List<String> list = new ArrayList<String>();
+ for (AppCatalogResource resource : resources){
+ list.add(((GlobusGKEndpointAppCatalogResourceAppCat) resource).getEndpoint());
+ }
+ return list;
+ }
+//
+// public static List<GSISSHJobSubmission> getGSISSHSubmissionList (List<Resource> resources) throws AppCatalogException {
+// List<GSISSHJobSubmission> list = new ArrayList<GSISSHJobSubmission>();
+// for (Resource resource : resources){
+// list.add(getGSISSHSubmissionDescription((GSISSHSubmissionResource) resource));
+// }
+// return list;
+// }
+//
+// public static List<GlobusJobSubmission> getGlobusSubmissionList (List<Resource> resources) throws AppCatalogException {
+// List<GlobusJobSubmission> list = new ArrayList<GlobusJobSubmission>();
+// for (Resource resource : resources){
+// list.add(getGlobusJobSubmissionDescription((GlobusJobSubmissionResource) resource));
+// }
+// return list;
+// }
+//
+// public static List<SSHJobSubmission> getSSHSubmissionList (List<Resource> resources) throws AppCatalogException {
+// List<SSHJobSubmission> list = new ArrayList<SSHJobSubmission>();
+// for (Resource resource : resources){
+// list.add(getSSHJobSubmissionDescription((SshJobSubmissionResource) resource));
+// }
+// return list;
+// }
+//
+// public static List<GridFTPDataMovement> getGridFTPDataMovementList (List<Resource> resources) throws AppCatalogException {
+// List<GridFTPDataMovement> list = new ArrayList<GridFTPDataMovement>();
+// for (Resource resource : resources){
+// list.add(getGridFTPDataMovementDescription((GridftpDataMovementResource) resource));
+// }
+// return list;
+// }
+//
+// public static List<SCPDataMovement> getSCPDataMovementList (List<Resource> resources) throws AppCatalogException {
+// List<SCPDataMovement> list = new ArrayList<SCPDataMovement>();
+// for (Resource resource : resources){
+// list.add(getSCPDataMovementDescription((ScpDataMovementResource) resource));
+// }
+// return list;
+// }
+//
+// public static Set<String> getGSISSHExports (List<Resource> gsisshExportResources){
+// Set<String> exports = new HashSet<String>();
+// for (Resource resource : gsisshExportResources){
+// exports.add(((GSISSHExportResource) resource).getExport());
+// }
+// return exports;
+// }
+//
+// public static List<String> getGSISSHPreJobCommands (List<Resource> gsisshPreJobCommandResources){
+// List<String> list = new ArrayList<String>();
+// for (Resource resource : gsisshPreJobCommandResources){
+// list.add(((GSISSHPreJobCommandResource) resource).getCommand());
+// }
+// return list;
+// }
+//
+// public static List<String> getGSISSHPostJobCommands (List<Resource> gsisshPostJobCommandResources){
+// List<String> list = new ArrayList<String>();
+// for (Resource resource : gsisshPostJobCommandResources){
+// list.add(((GSISSHPostJobCommandResource) resource).getCommand());
+// }
+// return list;
+// }
+//
+// public static GlobusJobSubmissionResource getGlobusJobSubmission (GlobusJobSubmission submission){
+// GlobusJobSubmissionResource resource = new GlobusJobSubmissionResource();
+// resource.setSubmissionID(submission.getJobSubmissionDataID());
+// resource.setSecurityProtocol(submission.getSecurityProtocol().toString());
+// resource.setResourceJobManager(submission.getResourceJobManager().toString());
+// return resource;
+// }
+
+ public static ApplicationModule getApplicationModuleDesc (AppModuleAppCatalogResourceAppCat resource){
+ ApplicationModule module = new ApplicationModule();
+ module.setAppModuleId(resource.getModuleId());
+ module.setAppModuleDescription(resource.getModuleDesc());
+ module.setAppModuleName(resource.getModuleName());
+ module.setAppModuleVersion(resource.getModuleVersion());
+ return module;
+ }
+
+ public static ApplicationInterfaceDescription getApplicationInterfaceDescription (AppInterfaceAppCatalogResourceAppCat resource) throws AppCatalogException {
+ ApplicationInterfaceDescription description = new ApplicationInterfaceDescription();
+ description.setApplicationInterfaceId(resource.getInterfaceId());
+ description.setApplicationName(resource.getAppName());
+ description.setApplicationDescription(resource.getAppDescription());
+
+ AppModuleMappingAppCatalogResourceAppCat appModuleMappingResource = new AppModuleMappingAppCatalogResourceAppCat();
+ List<AppCatalogResource> appModules = appModuleMappingResource.get(AppCatAbstractResource.AppModuleMappingConstants.INTERFACE_ID, resource.getInterfaceId());
+ if (appModules != null && !appModules.isEmpty()){
+ description.setApplicationModules(getAppModuleIds(appModules));
+ }
+
+ ApplicationInputAppCatalogResourceAppCat inputResource = new ApplicationInputAppCatalogResourceAppCat();
+ List<AppCatalogResource> appInputs = inputResource.get(AppCatAbstractResource.AppInputConstants.INTERFACE_ID, resource.getInterfaceId());
+ if (appInputs != null && !appInputs.isEmpty()){
+ description.setApplicationInputs(getAppInputs(appInputs));
+ }
+
+ ApplicationOutputAppCatalogResourceAppCat outputResource = new ApplicationOutputAppCatalogResourceAppCat();
+ List<AppCatalogResource> appOutputs = outputResource.get(AppCatAbstractResource.AppOutputConstants.INTERFACE_ID, resource.getInterfaceId());
+ if (appOutputs != null && !appOutputs.isEmpty()){
+ description.setApplicationOutputs(getAppOutputs(appOutputs));
+ }
+ return description;
+ }
+
+ public static List<String> getAppModuleIds (List<AppCatalogResource> appModuleMappings){
+ List<String> modules = new ArrayList<String>();
+ for (AppCatalogResource resource : appModuleMappings){
+ modules.add(((AppModuleMappingAppCatalogResourceAppCat)resource).getModuleId());
+ }
+ return modules;
+ }
+
+ public static List<ApplicationModule> getAppModules (List<AppCatalogResource> appModules){
+ List<ApplicationModule> modules = new ArrayList<ApplicationModule>();
+ for (AppCatalogResource resource : appModules){
+ modules.add(getApplicationModuleDesc((AppModuleAppCatalogResourceAppCat) resource));
+ }
+ return modules;
+ }
+
+ public static List<ApplicationInterfaceDescription> getAppInterfaceDescList (List<AppCatalogResource> appInterfaces) throws AppCatalogException {
+ List<ApplicationInterfaceDescription> interfaceDescriptions = new ArrayList<ApplicationInterfaceDescription>();
+ for (AppCatalogResource resource : appInterfaces){
+ interfaceDescriptions.add(getApplicationInterfaceDescription((AppInterfaceAppCatalogResourceAppCat) resource));
+ }
+ return interfaceDescriptions;
+ }
+
+ public static List<InputDataObjectType> getAppInputs (List<AppCatalogResource> resources){
+ List<InputDataObjectType> inputs = new ArrayList<InputDataObjectType>();
+ for (AppCatalogResource resource : resources){
+ inputs.add(getInputDataObjType((ApplicationInputAppCatalogResourceAppCat) resource));
+ }
+ return inputs;
+ }
+
+ public static InputDataObjectType getInputDataObjType (ApplicationInputAppCatalogResourceAppCat input){
+ InputDataObjectType inputDataObjectType = new InputDataObjectType();
+ inputDataObjectType.setName(input.getInputKey());
+ inputDataObjectType.setValue(input.getInputVal());
+ inputDataObjectType.setApplicationArgument(input.getAppArgument());
+ inputDataObjectType.setInputOrder(input.getInputOrder());
+ inputDataObjectType.setMetaData(input.getMetadata());
+ inputDataObjectType.setType(DataType.valueOf(input.getDataType()));
+ inputDataObjectType.setStandardInput(input.isStandardInput());
+ inputDataObjectType.setUserFriendlyDescription(input.getUserFriendlyDesc());
+ inputDataObjectType.setIsRequired(input.getRequired());
+ inputDataObjectType.setRequiredToAddedToCommandLine(input.getRequiredToCMD());
+ inputDataObjectType.setDataStaged(input.isDataStaged());
+ return inputDataObjectType;
+ }
+
+ public static List<OutputDataObjectType> getAppOutputs (List<AppCatalogResource> resources){
+ List<OutputDataObjectType> outputs = new ArrayList<OutputDataObjectType>();
+ for (AppCatalogResource resource : resources){
+ outputs.add(getOutputDataObjType((ApplicationOutputAppCatalogResourceAppCat) resource));
+ }
+ return outputs;
+ }
+ public static OutputDataObjectType getOutputDataObjType (ApplicationOutputAppCatalogResourceAppCat output){
+ OutputDataObjectType outputDataObjectType = new OutputDataObjectType();
+ outputDataObjectType.setName(output.getOutputKey());
+ outputDataObjectType.setValue(output.getOutputVal());
+ outputDataObjectType.setType(DataType.valueOf(output.getDataType()));
+ outputDataObjectType.setIsRequired(output.getRequired());
+ outputDataObjectType.setRequiredToAddedToCommandLine(output.getRequiredToCMD());
+ outputDataObjectType.setDataMovement(output.isDataMovement());
+ outputDataObjectType.setLocation(output.getDataNameLocation());
+ outputDataObjectType.setSearchQuery(output.getSearchQuery());
+ outputDataObjectType.setApplicationArgument(output.getAppArgument());
+ return outputDataObjectType;
+ }
+
+ public static ApplicationDeploymentDescription getApplicationDeploymentDescription (AppDeploymentAppCatalogResourceAppCat resource) throws AppCatalogException {
+ ApplicationDeploymentDescription description = new ApplicationDeploymentDescription();
+ description.setAppDeploymentId(resource.getDeploymentId());
+ description.setAppModuleId(resource.getAppModuleId());
+ description.setComputeHostId(resource.getHostId());
+ description.setExecutablePath(resource.getExecutablePath());
+ if (resource.getParallelism() != null){
+ description.setParallelism(ApplicationParallelismType.valueOf(resource.getParallelism()));
+ }
+ description.setAppDeploymentDescription(resource.getAppDes());
+ ModuleLoadCmdAppCatalogResourceAppCat cmdResource = new ModuleLoadCmdAppCatalogResourceAppCat();
+ List<AppCatalogResource> moduleLoadCmds = cmdResource.get(AppCatAbstractResource.ModuleLoadCmdConstants.APP_DEPLOYMENT_ID, resource.getDeploymentId());
+ if (moduleLoadCmds != null && !moduleLoadCmds.isEmpty()){
+ for (AppCatalogResource moduleLoadCmd : moduleLoadCmds){
+ description.addToModuleLoadCmds(((ModuleLoadCmdAppCatalogResourceAppCat) moduleLoadCmd).getCmd());
+ }
+ }
+ LibraryPrepandPathAppCatalogResourceAppCat prepandPathResource = new LibraryPrepandPathAppCatalogResourceAppCat();
+ List<AppCatalogResource> libPrepandPaths = prepandPathResource.get(AppCatAbstractResource.LibraryPrepandPathConstants.DEPLOYMENT_ID, resource.getDeploymentId());
+ if (libPrepandPaths != null && !libPrepandPaths.isEmpty()){
+ description.setLibPrependPaths(getLibPrepandPaths(libPrepandPaths));
+ }
+
+ LibraryApendPathAppCatalogResourceAppCat apendPathResource = new LibraryApendPathAppCatalogResourceAppCat();
+ List<AppCatalogResource> libApendPaths = apendPathResource.get(AppCatAbstractResource.LibraryPrepandPathConstants.DEPLOYMENT_ID, resource.getDeploymentId());
+ if (libApendPaths != null && !libApendPaths.isEmpty()){
+ description.setLibAppendPaths(getLibApendPaths(libApendPaths));
+ }
+
+ AppEnvironmentAppCatalogResourceAppCat appEnvironmentResource = new AppEnvironmentAppCatalogResourceAppCat();
+ List<AppCatalogResource> appEnvList = appEnvironmentResource.get(AppCatAbstractResource.LibraryPrepandPathConstants.DEPLOYMENT_ID, resource.getDeploymentId());
+ if (appEnvList != null && !appEnvList.isEmpty()){
+ description.setSetEnvironment(getAppEnvPaths(appEnvList));
+ }
+ PreJobCommandAppCatalogResourceAppCat preJobCommandResource = new PreJobCommandAppCatalogResourceAppCat();
+ List<AppCatalogResource> preJobCommands = preJobCommandResource.get(AppCatAbstractResource.PreJobCommandConstants.DEPLOYMENT_ID, resource.getDeploymentId());
+ if (preJobCommands != null && !preJobCommands.isEmpty()){
+ for (AppCatalogResource prejobCommand : preJobCommands){
+ description.addToPreJobCommands(((PreJobCommandAppCatalogResourceAppCat) prejobCommand).getCommand());
+ }
+ }
+ PostJobCommandAppCatalogResourceAppCat postJobCommandResource = new PostJobCommandAppCatalogResourceAppCat();
+ List<AppCatalogResource> postJobCommands = postJobCommandResource.get(AppCatAbstractResource.PostJobCommandConstants.DEPLOYMENT_ID, resource.getDeploymentId());
+ if (postJobCommands != null && !postJobCommands.isEmpty()){
+ for (AppCatalogResource postjobCommand : postJobCommands){
+ description.addToPostJobCommands(((PostJobCommandAppCatalogResourceAppCat) postjobCommand).getCommand());
+ }
+ }
+ return description;
+ }
+
+ public static List<ApplicationDeploymentDescription> getAppDepDescList (List<AppCatalogResource> resources) throws AppCatalogException {
+ List<ApplicationDeploymentDescription> appList = new ArrayList<ApplicationDeploymentDescription>();
+ for (AppCatalogResource resource : resources){
+ appList.add(getApplicationDeploymentDescription((AppDeploymentAppCatalogResourceAppCat)resource));
+ }
+ return appList;
+ }
+
+ public static SetEnvPaths getSetEnvPath(AppCatalogResource resource){
+ SetEnvPaths envPaths = new SetEnvPaths();
+ if (resource instanceof LibraryPrepandPathAppCatalogResourceAppCat){
+ envPaths.setName(((LibraryPrepandPathAppCatalogResourceAppCat) resource).getName());
+ envPaths.setValue(((LibraryPrepandPathAppCatalogResourceAppCat) resource).getValue());
+ return envPaths;
+ }else if (resource instanceof LibraryApendPathAppCatalogResourceAppCat){
+ envPaths.setName(((LibraryApendPathAppCatalogResourceAppCat) resource).getName());
+ envPaths.setValue(((LibraryApendPathAppCatalogResourceAppCat) resource).getValue());
+ return envPaths;
+ }else if (resource instanceof AppEnvironmentAppCatalogResourceAppCat){
+ envPaths.setName(((AppEnvironmentAppCatalogResourceAppCat) resource).getName());
+ envPaths.setValue(((AppEnvironmentAppCatalogResourceAppCat) resource).getValue());
+ return envPaths;
+ }else {
+ return null;
+ }
+ }
+
+ public static List<SetEnvPaths> getLibPrepandPaths (List<AppCatalogResource> prepandPaths){
+ List<SetEnvPaths> pathList = new ArrayList<SetEnvPaths>();
+ for (AppCatalogResource resource : prepandPaths){
+ pathList.add(getSetEnvPath(resource));
+ }
+ return pathList;
+ }
+
+ public static List<SetEnvPaths> getLibApendPaths (List<AppCatalogResource> appendPaths){
+ List<SetEnvPaths> pathList = new ArrayList<SetEnvPaths>();
+ for (AppCatalogResource resource : appendPaths){
+ pathList.add(getSetEnvPath(resource));
+ }
+ return pathList;
+ }
+
+ public static List<SetEnvPaths> getAppEnvPaths (List<AppCatalogResource> appEnvPaths){
+ List<SetEnvPaths> pathList = new ArrayList<SetEnvPaths>();
+ for (AppCatalogResource resource : appEnvPaths){
+ pathList.add(getSetEnvPath(resource));
+ }
+ return pathList;
+ }
+
+ public static ComputeResourcePreference getComputeResourcePreference (ComputeHostPreferenceAppCatalogResourceAppCat resource){
+ ComputeResourcePreference preference = new ComputeResourcePreference();
+ preference.setComputeResourceId(resource.getResourceId());
+ preference.setOverridebyAiravata(resource.getOverrideByAiravata());
+ if (resource.getPreferredJobProtocol() != null){
+ preference.setPreferredJobSubmissionProtocol(JobSubmissionProtocol.valueOf(resource.getPreferredJobProtocol()));
+ }
+ if (resource.getPreferedDMProtocol() != null){
+ preference.setPreferredDataMovementProtocol(DataMovementProtocol.valueOf(resource.getPreferedDMProtocol()));
+ }
+ preference.setPreferredBatchQueue(resource.getBatchQueue());
+ preference.setScratchLocation(resource.getScratchLocation());
+ preference.setAllocationProjectNumber(resource.getProjectNumber());
+ preference.setLoginUserName(resource.getLoginUserName());
+ return preference;
+ }
+
+ public static List<ComputeResourcePreference> getComputeResourcePreferences (List<AppCatalogResource> resources){
+ List<ComputeResourcePreference> preferences = new ArrayList<ComputeResourcePreference>();
+ if (resources != null && !resources.isEmpty()){
+ for (AppCatalogResource resource : resources){
+ preferences.add(getComputeResourcePreference((ComputeHostPreferenceAppCatalogResourceAppCat)resource));
+ }
+ }
+ return preferences;
+ }
+
+ public static InputDataObjectType getWorkflowInput (WorkflowInputAppCatalogResourceAppCat resource){
+ InputDataObjectType input = new InputDataObjectType();
+ input.setName(resource.getInputKey());
+ input.setApplicationArgument(resource.getAppArgument());
+ input.setInputOrder(resource.getInputOrder());
+ input.setType(DataType.valueOf(resource.getDataType()));
+ input.setMetaData(resource.getMetadata());
+ input.setUserFriendlyDescription(resource.getUserFriendlyDesc());
+ input.setIsRequired(resource.getRequired());
+ input.setRequiredToAddedToCommandLine(resource.getRequiredToCMD());
+ input.setDataStaged(resource.isDataStaged());
+ return input;
+ }
+
+ public static List<InputDataObjectType> getWFInputs(List<AppCatalogResource> resources){
+ List<InputDataObjectType> inputResources = new ArrayList<InputDataObjectType>();
+ if (resources != null && !resources.isEmpty()){
+ for (AppCatalogResource resource : resources){
+ inputResources.add(getWorkflowInput((WorkflowInputAppCatalogResourceAppCat) resource));
+ }
+ }
+ return inputResources;
+ }
+
+ public static GatewayResourceProfile getGatewayResourceProfile(GatewayProfileAppCatalogResourceAppCat gw, List<ComputeResourcePreference> preferences){
+ GatewayResourceProfile gatewayProfile = new GatewayResourceProfile();
+ gatewayProfile.setGatewayID(gw.getGatewayID());
+ gatewayProfile.setComputeResourcePreferences(preferences);
+ return gatewayProfile;
+ }
+
+ public static Workflow getWorkflow (WorkflowAppCatalogResourceAppCat resource) throws AppCatalogException {
+ Workflow workflow = new Workflow();
+ workflow.setTemplateId(resource.getWfTemplateId());
+ workflow.setGraph(resource.getGraph());
+ workflow.setName(resource.getWfName());
+ if (resource.getImage() != null){
+ workflow.setImage(resource.getImage().getBytes());
+ }
+ WorkflowInputAppCatalogResourceAppCat inputResource = new WorkflowInputAppCatalogResourceAppCat();
+ List<AppCatalogResource> resources = inputResource.get(AppCatAbstractResource.WFInputConstants.WF_TEMPLATE_ID, resource.getWfTemplateId());
+ workflow.setWorkflowInputs(getWFInputs(resources));
+
+ return workflow;
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogUtils.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogUtils.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogUtils.java
new file mode 100644
index 0000000..d4bb3b1
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/app/catalog/util/AppCatalogUtils.java
@@ -0,0 +1,31 @@
+/*
+ *
+ * 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.registry.core.app.catalog.util;
+
+import java.util.UUID;
+
+public class AppCatalogUtils {
+ public static String getID (String name){
+ String pro = name.replaceAll("\\s", "");
+ return pro + "_" + UUID.randomUUID();
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExpCatResourceUtils.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExpCatResourceUtils.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExpCatResourceUtils.java
new file mode 100644
index 0000000..ad96e67
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExpCatResourceUtils.java
@@ -0,0 +1,526 @@
+/*
+ *
+ * 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.registry.core.experiment.catalog;
+
+import org.apache.airavata.registry.core.experiment.catalog.model.*;
+import org.apache.airavata.registry.core.experiment.catalog.resources.*;
+import org.apache.airavata.registry.core.experiment.catalog.utils.QueryGenerator;
+import org.apache.airavata.registry.cpi.RegistryException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Persistence;
+import javax.persistence.Query;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ExpCatResourceUtils {
+ private final static Logger logger = LoggerFactory.getLogger(ExpCatResourceUtils.class);
+ private static final String PERSISTENCE_UNIT_NAME = "experiment_data";
+ protected static EntityManagerFactory factory;
+
+ public static void reset(){
+ factory=null;
+ }
+
+ public static EntityManager getEntityManager(){
+ if (factory == null) {
+ String connectionProperties = "DriverClassName=" + Utils.getJDBCDriver() + "," + "Url=" + Utils.getJDBCURL() + "?autoReconnect=true,," +
+ "Username=" + Utils.getJDBCUser() + "," + "Password=" + Utils.getJDBCPassword() + ",validationQuery=" +
+ Utils.getValidationQuery();
+ System.out.println(connectionProperties);
+ Map<String, String> properties = new HashMap<String, String>();
+ properties.put("persistenceXmlLocation", "META-INF/experiment-catalog.xml");
+ properties.put("openjpa.ConnectionDriverName", "org.apache.commons.dbcp.BasicDataSource");
+ properties.put("openjpa.ConnectionProperties", connectionProperties);
+ properties.put("openjpa.DynamicEnhancementAgent", "true");
+ properties.put("openjpa.RuntimeUnenhancedClasses", "unsupported");
+ properties.put("openjpa.DataCache","" + Utils.isCachingEnabled() + "(CacheSize=" + Utils.getJPACacheSize() + ", SoftReferenceSize=0)");
+ properties.put("openjpa.QueryCache","" + Utils.isCachingEnabled() + "(CacheSize=" + Utils.getJPACacheSize() + ", SoftReferenceSize=0)");
+ properties.put("openjpa.RemoteCommitProvider","sjvm");
+ properties.put("openjpa.Log","DefaultLevel=INFO, Runtime=INFO, Tool=INFO, SQL=INFO");
+ properties.put("openjpa.jdbc.DBDictionary","SupportsMultipleNontransactionalResultSets=false");
+// properties.put("openjpa.ReadLockLevel", "none");
+// properties.put("openjpa.WriteLockLevel", "none");
+// properties.put("openjpa.LockTimeout", "30000");
+// properties.put("openjpa.LockManager", "none");
+ properties.put("openjpa.jdbc.SynchronizeMappings", "buildSchema(ForeignKeys=true)");
+ properties.put("openjpa.ConnectionFactoryProperties", "PrettyPrint=true, PrettyPrintLineLength=72, PrintParameters=true, MaxActive=10, MaxIdle=5, MinIdle=2, MaxWait=31536000, autoReconnect=true");
+ properties.put("openjpa.jdbc.QuerySQLCache", "false");
+ factory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME, properties);
+ }
+ return factory.createEntityManager();
+ }
+
+ /**
+ * @param gatewayId
+ * @return
+ */
+ public static ExperimentCatResource createGateway(String gatewayId) throws RegistryException {
+ if (!isGatewayExist(gatewayId)) {
+ GatewayExperimentCatResource gatewayResource = new GatewayExperimentCatResource();
+ gatewayResource.setGatewayId(gatewayId);
+ return gatewayResource;
+ }else {
+ return getGateway(gatewayId);
+ }
+ }
+
+ public static UserExperimentCatResource createUser(String username, String password) throws RegistryException {
+ if (!isUserExist(username)) {
+ UserExperimentCatResource userResource = new UserExperimentCatResource();
+ userResource.setUserName(username);
+ userResource.setPassword(password);
+ return userResource;
+ }else {
+ return (UserExperimentCatResource)getUser(username);
+ }
+
+ }
+
+ public static ExperimentCatResource getGateway(String gatewayId) throws RegistryException{
+ EntityManager em = null;
+ try {
+ if (isGatewayExist(gatewayId)) {
+ em = getEntityManager();
+ Gateway gateway = em.find(Gateway.class, gatewayId);
+ GatewayExperimentCatResource gatewayResource = (GatewayExperimentCatResource)Utils.getResource(ResourceType.GATEWAY, gateway);
+ em.close();
+ return gatewayResource;
+ }
+ }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 null;
+ }
+
+ public static void addUser (String userName, String password) throws RegistryException{
+ UserExperimentCatResource resource = new UserExperimentCatResource();
+ resource.setUserName(userName);
+ resource.setPassword(password);
+ resource.save();
+ }
+
+ public static boolean isUserExist (String username) throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.USERS);
+ generator.setParameter(AbstractExperimentCatResource.UserConstants.USERNAME, username);
+ Query q = generator.selectQuery(em);
+ int size = q.getResultList().size();
+ em.getTransaction().commit();
+ em.close();
+ return size>0;
+ } catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+
+ public static ExperimentCatResource getUser(String userName) throws RegistryException{
+ EntityManager em = null;
+ try {
+ if (isUserExist(userName)) {
+ em = getEntityManager();
+ Users user = em.find(Users.class, userName);
+ UserExperimentCatResource userResource = (UserExperimentCatResource)Utils.getResource(ResourceType.USER, user);
+ em.close();
+ return userResource;
+ }
+ }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 null;
+
+ }
+
+ public static ExperimentCatResource getWorker(String gatewayId, String userName) throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ Gateway_Worker gatewayWorker = em.find(Gateway_Worker.class, new Gateway_Worker_PK(gatewayId, userName));
+ WorkerExperimentCatResource workerResource = (WorkerExperimentCatResource) Utils.getResource(ResourceType.GATEWAY_WORKER, gatewayWorker);
+ em.close();
+ return workerResource;
+ }catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+
+
+ }
+
+
+ /**
+ * @param gatewayId
+ * @return
+ */
+ public static boolean isGatewayExist(String gatewayId) throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.GATEWAY);
+ generator.setParameter(AbstractExperimentCatResource.GatewayConstants.GATEWAY_ID, gatewayId);
+ Query q = generator.selectQuery(em);
+ int size = q.getResultList().size();
+ em.getTransaction().commit();
+ em.close();
+ return size>0;
+ }catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+
+ }
+
+ public static List<ExperimentCatResource> getAllGateways() throws RegistryException{
+ List<ExperimentCatResource> resourceList = new ArrayList<ExperimentCatResource>();
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.GATEWAY);
+ Query q = generator.selectQuery(em);
+ List results = q.getResultList();
+ if (results.size() != 0) {
+ for (Object result : results) {
+ Gateway gateway = (Gateway) result;
+ GatewayExperimentCatResource gatewayResource =
+ (GatewayExperimentCatResource) Utils.getResource(ResourceType.GATEWAY, gateway);
+ resourceList.add(gatewayResource);
+ }
+ }
+ em.getTransaction().commit();
+ em.close();
+ }catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ return resourceList;
+ }
+
+ /**
+ * @param gatewayId
+ * @return
+ */
+ public static boolean removeGateway(String gatewayId) {
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.GATEWAY);
+ generator.setParameter(AbstractExperimentCatResource.GatewayConstants.GATEWAY_ID, gatewayId);
+ Query q = generator.deleteQuery(em);
+ q.executeUpdate();
+ em.getTransaction().commit();
+ em.close();
+ return true;
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ return false;
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ /**
+ * @param gatewayResource
+ * @param userResource
+ */
+ public static WorkerExperimentCatResource addGatewayWorker(GatewayExperimentCatResource gatewayResource, UserExperimentCatResource userResource) throws RegistryException{
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ if (!isGatewayExist(gatewayResource.getGatewayName())){
+ gatewayResource.save();
+ }
+ if (!isUserExist(userResource.getUserName())){
+ userResource.save();
+ }
+ Gateway gateway = em.find(Gateway.class, gatewayResource.getGatewayId());
+ Users user = em.find(Users.class, userResource.getUserName());
+ Gateway_Worker gatewayWorker = new Gateway_Worker();
+ gatewayWorker.setGateway(gateway);
+ gatewayWorker.setUser(user);
+ em.persist(gatewayWorker);
+ em.getTransaction().commit();
+ em.close();
+ return (WorkerExperimentCatResource)Utils.getResource(ResourceType.GATEWAY_WORKER, gatewayWorker);
+ } catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ /**
+ * @param gatewayResource
+ * @param userResource
+ * @return
+ */
+ public static boolean removeGatewayWorker(GatewayExperimentCatResource gatewayResource, UserExperimentCatResource userResource) {
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.GATEWAY_WORKER);
+ generator.setParameter(AbstractExperimentCatResource.GatewayWorkerConstants.GATEWAY_ID,
+ gatewayResource.getGatewayName());
+ generator.setParameter(AbstractExperimentCatResource.UserConstants.USERNAME, userResource.getUserName());
+ Query q = generator.deleteQuery(em);
+ q.executeUpdate();
+ em.getTransaction().commit();
+ em.close();
+ return true;
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ return false;
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+
+ }
+
+ /**
+ * @param configKey
+ * @return
+ */
+ public static List<ConfigurationExperimentCatResource> getConfigurations(String configKey){
+ List<ConfigurationExperimentCatResource> list = new ArrayList<ConfigurationExperimentCatResource>();
+ EntityManager em = null;
+ try {
+ em = getEntityManager();
+ em.getTransaction().begin();
+ QueryGenerator generator = new QueryGenerator(AbstractExperimentCatResource.CONFIGURATION);
+ generator.setParameter(AbstractExperimentCatResource.ConfigurationConstants.CONFIG_KEY, configKey);
+ Query q = generator.selectQuery(em);
+ List<?> resultList = q.getResultList();
+ if (resultList.size() != 0) {
+ for (Object result : resultList) {
+ ConfigurationExperimentCatResource configurationResource = createConfigurationResourceObject(result);
+ list.add(configurationResource);
+ }
+ }
+ em.getTransaction().commit();
+ em.close();
+ }catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ return list;
+ }
+
+ /**
+ * @param configKey
+ * @return
+ */
+ public static ConfigurationExperimentCatResource getConfiguration(String configKey){
+ List<ConfigurationExperimentCatResource> configurations = getConfigurations(configKey);
+ return (configurations != null && configurations.size() > 0) ? configurations.get(0) : null;
+ }
+
+ /**
+ * @param configKey
+ * @return
+ */
+ public static boolean isConfigurationExist(String configKey){
+ List<ConfigurationExperimentCatResource> configurations = getConfigurations(configKey);
+ return (configurations != null && configurations.size() > 0);
+ }
+
+ /**
+ * @param configKey
+ * @return
+ */
+ public static ConfigurationExperimentCatResource createConfiguration(String configKey) {
+ ConfigurationExperimentCatResource config = new ConfigurationExperimentCatResource();
+ config.setConfigKey(configKey);
+ return config;
+ }
+
+ /**
+ * @param result
+ * @return
+ */
+ private static ConfigurationExperimentCatResource createConfigurationResourceObject(
+ Object result) {
+ Configuration configuration = (Configuration) result;
+ ConfigurationExperimentCatResource configurationResource = new ConfigurationExperimentCatResource(configuration.getConfig_key(), configuration.getConfig_val());
+ configurationResource.setExpireDate(configuration.getExpire_date());
+ return configurationResource;
+ }
+
+ /**
+ * @param configkey
+ * @param configValue
+ */
+ public static void removeConfiguration(String configkey, String configValue) throws RegistryException{
+ QueryGenerator queryGenerator = new QueryGenerator(AbstractExperimentCatResource.CONFIGURATION);
+ queryGenerator.setParameter(AbstractExperimentCatResource.ConfigurationConstants.CONFIG_KEY, configkey);
+ queryGenerator.setParameter(AbstractExperimentCatResource.ConfigurationConstants.CONFIG_VAL, configValue);
+ EntityManager em = null;
+ try {
+ if(isConfigurationExists(configkey, configValue)){
+ em = getEntityManager();
+ em.getTransaction().begin();
+ Query q = queryGenerator.deleteQuery(em);
+ q.executeUpdate();
+ em.getTransaction().commit();
+ em.close();
+ }
+ }catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ /**
+ * @param configkey
+ */
+ public static void removeConfiguration(String configkey) throws RegistryException{
+ QueryGenerator queryGenerator = new QueryGenerator(AbstractExperimentCatResource.CONFIGURATION);
+ queryGenerator.setParameter(AbstractExperimentCatResource.ConfigurationConstants.CONFIG_KEY, configkey);
+ EntityManager em = null;
+ try {
+ if(isConfigurationExist(configkey)){
+ em = getEntityManager();
+ em.getTransaction().begin();
+ Query q = queryGenerator.deleteQuery(em);
+ q.executeUpdate();
+ em.getTransaction().commit();
+ em.close();
+ }
+ }catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+
+ public static boolean isConfigurationExists(String configKey, String configVal) throws RegistryException{
+ EntityManager em = null;
+ try{
+ //Currently categoryID is hardcoded value
+ em = ExpCatResourceUtils.getEntityManager();
+ Configuration existing = em.find(Configuration.class, new Configuration_PK(configKey, configVal, AbstractExperimentCatResource.ConfigurationConstants.CATEGORY_ID_DEFAULT_VALUE));
+ em.close();
+ return existing!= null;
+ } catch (Exception e){
+ logger.error(e.getMessage(), e);
+ throw new RegistryException(e);
+ }finally {
+ if (em != null && em.isOpen()){
+ if (em.getTransaction().isActive()){
+ em.getTransaction().rollback();
+ }
+ em.close();
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExperimentCatResource.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExperimentCatResource.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExperimentCatResource.java
new file mode 100644
index 0000000..ead6d13
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ExperimentCatResource.java
@@ -0,0 +1,71 @@
+/*
+ *
+ * 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.registry.core.experiment.catalog;
+
+import org.apache.airavata.registry.cpi.RegistryException;
+
+import java.util.List;
+
+public interface ExperimentCatResource {
+ /**
+ * This method will create associate resource objects for the given resource type.
+ * @param type child resource type
+ * @return associate child resource
+ */
+ ExperimentCatResource create(ResourceType type) throws RegistryException, RegistryException;
+
+ /**
+ * This method will remove the given child resource from the database
+ * @param type child resource type
+ * @param name child resource name
+ */
+ void remove(ResourceType type, Object name) throws RegistryException;
+
+ /**
+ * This method will return the given child resource from the database
+ * @param type child resource type
+ * @param name child resource name
+ * @return associate child resource
+ */
+ ExperimentCatResource get(ResourceType type, Object name) throws RegistryException;
+
+ /**
+ * This method will list all the child resources for the given resource type
+ * @param type child resource type
+ * @return list of child resources of the given child resource type
+ */
+ List<ExperimentCatResource> get(ResourceType type) throws RegistryException;
+
+ /**
+ * This method will save the resource to the database.
+ */
+ void save() throws RegistryException;
+
+ /**
+ * This method will check whether an entry from the given resource type and resource name
+ * exists in the database
+ * @param type child resource type
+ * @param name child resource name
+ * @return whether the entry exists in the database or not
+ */
+ boolean isExists(ResourceType type, Object name) throws RegistryException;
+
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/JPAConstants.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/JPAConstants.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/JPAConstants.java
new file mode 100644
index 0000000..359c02c
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/JPAConstants.java
@@ -0,0 +1,32 @@
+/*
+ *
+ * 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.registry.core.experiment.catalog;
+public class JPAConstants {
+ public static final String KEY_JDBC_URL = "registry.jdbc.url";
+ public static final String KEY_JDBC_USER = "registry.jdbc.user";
+ public static final String KEY_JDBC_PASSWORD = "registry.jdbc.password";
+ public static final String KEY_JDBC_DRIVER = "registry.jdbc.driver";
+ public static final String KEY_DERBY_START_ENABLE = "start.derby.server.mode";
+ public static final String VALIDATION_QUERY = "validationQuery";
+ public static final String JPA_CACHE_SIZE = "jpa.cache.size";
+ public static final String ENABLE_CACHING = "cache.enable";
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/ec8c6202/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ResourceType.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ResourceType.java b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ResourceType.java
new file mode 100644
index 0000000..8224cf3
--- /dev/null
+++ b/modules/registry/registry-core/src/main/java/org/apache/airavata/registry/core/experiment/catalog/ResourceType.java
@@ -0,0 +1,49 @@
+/*
+ *
+ * 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.registry.core.experiment.catalog;
+public enum ResourceType {
+ GATEWAY,
+ PROJECT,
+ USER,
+ PROJECT_USER,
+ CONFIGURATION,
+ GATEWAY_WORKER,
+ EXPERIMENT,
+ EXPERIMENT_SUMMARY,
+ NOTIFICATION_EMAIL,
+ EXPERIMENT_INPUT,
+ EXPERIMENT_OUTPUT,
+ WORKFLOW_NODE_DETAIL,
+ TASK_DETAIL,
+ ERROR_DETAIL,
+ APPLICATION_INPUT,
+ APPLICATION_OUTPUT,
+ NODE_INPUT,
+ NODE_OUTPUT,
+ JOB_DETAIL,
+ DATA_TRANSFER_DETAIL,
+ STATUS,
+ CONFIG_DATA,
+ COMPUTATIONAL_RESOURCE_SCHEDULING,
+ ADVANCE_INPUT_DATA_HANDLING,
+ ADVANCE_OUTPUT_DATA_HANDLING,
+ QOS_PARAM
+}