This is an automated email from the ASF dual-hosted git repository. smarru pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/airavata-sandbox.git
commit 50534be30e135e5c8b73cbb62051a92c1ddabf48 Author: Harsha Phulwani <[email protected]> AuthorDate: Fri Nov 17 18:44:12 2017 -0500 Added entities,repositories,utils and updated pom file --- .gitignore | 34 +- .../airavata-allocation-manager-server/pom.xml | 64 +++- .../manager/db/entities/DomainEntity.java | 116 +++++++ .../manager/db/entities/RequestStatusEntity.java | 78 +++++ .../db/entities/UserAllocationDetailEntity.java | 205 +++++++++++ .../db/entities/UserAllocationDetailEntityPK.java | 57 +++ .../manager/db/entities/UserDetailEntity.java | 78 +++++ .../db/repositories/AbstractRepository.java | 163 +++++++++ .../manager/db/repositories/DomainRepository.java | 33 ++ .../db/repositories/RequestStatusRepository.java | 14 + .../UserAllocationDetailPKRepository.java | 14 + .../UserAllocationDetailRepository.java | 14 + .../db/repositories/UserDetailRepository.java | 19 + .../allocation/manager/db/utils/Committer.java | 26 ++ .../manager/db/utils/ConnectionPool.java | 381 +++++++++++++++++++++ .../allocation/manager/db/utils/DBConstants.java | 106 ++++++ .../manager/db/utils/DatabaseCreator.java | 352 +++++++++++++++++++ .../allocation/manager/db/utils/JPAUtils.java | 215 ++++++++++++ .../allocation/manager/db/utils/JdbcStorage.java | 174 ++++++++++ .../manager/db/utils/ObjectMapperSingleton.java | 38 ++ .../airavata/allocation/manager/models/Domain.java | 5 + 21 files changed, 2159 insertions(+), 27 deletions(-) diff --git a/.gitignore b/.gitignore index d6e588b..2d2d74f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,11 @@ +# Compiled class file *.class -*id_rsa* + +# Log file +*.log + +# BlueJ files +*.ctxt # Mobile Tools for Java (J2ME) .mtj.tmp/ @@ -8,18 +14,22 @@ *.jar *.war *.ear - - -target/ -.idea/ -tmp/ -logs/ -gaussian_sample/ -*.ser -*.iml -*.gen +*.zip +*.tar.gz +*.rar # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* -solr-server/logs/solr.log +# Ignore files ending with target +*target/ + +# Ignore files starting with bin +bin/* + +# Ignore files starting with dot +.* +!.gitignore + + +/bin/ diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/pom.xml b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/pom.xml index 86dd4fc..8cb41b4 100644 --- a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/pom.xml +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/pom.xml @@ -1,21 +1,55 @@ -<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> - <modelVersion>4.0.0</modelVersion> - <parent> - <groupId>org.apache.airavata</groupId> - <artifactId>airavata-allocation-manager</artifactId> - <version>0.0.1-SNAPSHOT</version> - </parent> - <artifactId>airavata-allocation-manager-server</artifactId> - <dependencies> - <dependency> - <groupId>org.apache.thrift</groupId> - <artifactId>libthrift</artifactId> - <version>0.10.0</version> - </dependency> +<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> + <modelVersion>4.0.0</modelVersion> + <parent> + <groupId>org.apache.airavata</groupId> + <artifactId>airavata-allocation-manager</artifactId> + <version>0.0.1-SNAPSHOT</version> + </parent> + <artifactId>airavata-allocation-manager-server</artifactId> + <dependencies> <dependency> <groupId>org.apache.airavata</groupId> <artifactId>airavata-allocation-manager-stubs</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency> + <dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-api</artifactId> + <version>1.7.10</version> + </dependency> + <dependency> + <groupId>net.sf.dozer</groupId> + <artifactId>dozer</artifactId> + <version>5.4.0</version> + <exclusions> + <exclusion> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-log4j12</artifactId> + </exclusion> + </exclusions> + </dependency> + <dependency> + <groupId>org.apache.openjpa</groupId> + <artifactId>openjpa-all</artifactId> + <version>2.2.0</version> + </dependency> + <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> + <dependency> + <groupId>mysql</groupId> + <artifactId>mysql-connector-java</artifactId> + <version>5.1.34</version> + </dependency> + <!-- https://mvnrepository.com/artifact/org.apache.thrift/libthrift --> + <dependency> + <groupId>org.apache.thrift</groupId> + <artifactId>libthrift</artifactId> + <version>0.10.0</version> + <type>pom</type> + </dependency> </dependencies> -</project> \ No newline at end of file + <properties> + <maven.compiler.source>1.8</maven.compiler.source> + <maven.compiler.target>1.8</maven.compiler.target> + </properties> +</project> \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/DomainEntity.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/DomainEntity.java new file mode 100644 index 0000000..2aed6f9 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/DomainEntity.java @@ -0,0 +1,116 @@ +/** + * + * 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.allocation.manager.db.entities; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.*; + +@Entity +@Table(name = "DOMAIN", schema = "" ) +public class DomainEntity { + private final static Logger logger = LoggerFactory.getLogger(DomainEntity.class); + private String domainId; + private String name; + private String description; + private Long createdTime; + private Long updatedTime; + + @Id + @Column(name = "DOMAIN_ID") + public String getDomainId() { + return domainId; + } + + public void setDomainId(String domainId) { + this.domainId = domainId; + } + + @Basic + @Column(name = "NAME") + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + @Basic + @Column(name = "DESCRIPTION") + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + @Basic + @Column(name = "CREATED_TIME") + public Long getCreatedTime() { + return createdTime; + } + + public void setCreatedTime(Long createdTime) { + this.createdTime = createdTime; + } + + @Basic + @Column(name = "UPDATED_TIME") + public Long getUpdatedTime() { + return updatedTime; + } + + public void setUpdatedTime(Long updatedTime) { + this.updatedTime = updatedTime; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + DomainEntity that = (DomainEntity) o; + + if (getDomainId() != null ? !getDomainId().equals(that.getDomainId()) : that.getDomainId() != null) + return false; + if (getName() != null ? !getName().equals(that.getName()) : that.getName() != null) return false; + if (getDescription() != null ? !getDescription().equals(that.getDescription()) : that.getDescription() != null) + return false; + if (getCreatedTime() != null ? !getCreatedTime().equals(that.getCreatedTime()) : that.getCreatedTime() != null) + return false; + if (getUpdatedTime() != null ? !getUpdatedTime().equals(that.getUpdatedTime()) : that.getUpdatedTime() != null) + return false; + + return true; + } + + @Override + public int hashCode() { + int result = getDomainId() != null ? getDomainId().hashCode() : 0; + result = 31 * result + (getName() != null ? getName().hashCode() : 0); + result = 31 * result + (getDescription() != null ? getDescription().hashCode() : 0); + result = 31 * result + (getCreatedTime() != null ? getCreatedTime().hashCode() : 0); + result = 31 * result + (getUpdatedTime() != null ? getUpdatedTime().hashCode() : 0); + return result; + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/RequestStatusEntity.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/RequestStatusEntity.java new file mode 100644 index 0000000..42ccc4a --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/RequestStatusEntity.java @@ -0,0 +1,78 @@ +package org.apache.airavata.allocation.manager.db.entities; + +import java.io.Serializable; +import javax.persistence.*; +import java.math.BigInteger; + + +/** + * The persistent class for the REQUEST_STATUS database table. + * + */ +@Entity +@Table(name="REQUEST_STATUS") +@NamedQuery(name="RequestStatusEntity.findAll", query="SELECT r FROM RequestStatusEntity r") +public class RequestStatusEntity implements Serializable { + private static final long serialVersionUID = 1L; + + @Id + @Column(name="PROJECT_ID") + private String projectId; + + @Column(name="END_DATE") + private BigInteger endDate; + + @Lob + @Column(name="REVIEWERS") + private String reviewers; + + @Column(name="START_DATE") + private BigInteger startDate; + + @Column(name="STATUS") + private String status; + + public RequestStatusEntity() { + } + + public String getProjectId() { + return this.projectId; + } + + public void setProjectId(String projectId) { + this.projectId = projectId; + } + + public BigInteger getEndDate() { + return this.endDate; + } + + public void setEndDate(BigInteger endDate) { + this.endDate = endDate; + } + + public String getReviewers() { + return this.reviewers; + } + + public void setReviewers(String reviewers) { + this.reviewers = reviewers; + } + + public BigInteger getStartDate() { + return this.startDate; + } + + public void setStartDate(BigInteger startDate) { + this.startDate = startDate; + } + + public String getStatus() { + return this.status; + } + + public void setStatus(String status) { + this.status = status; + } + +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntity.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntity.java new file mode 100644 index 0000000..35ab18d --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntity.java @@ -0,0 +1,205 @@ +package org.apache.airavata.allocation.manager.db.entities; + +import java.io.Serializable; +import javax.persistence.*; +import java.math.BigInteger; + + +/** + * The persistent class for the USER_ALLOCATION_DETAILS database table. + * + */ +@Entity +@Table(name="USER_ALLOCATION_DETAILS") +@NamedQuery(name="UserAllocationDetailEntity.findAll", query="SELECT u FROM UserAllocationDetailEntity u") +public class UserAllocationDetailEntity implements Serializable { + private static final long serialVersionUID = 1L; + + @EmbeddedId + private UserAllocationDetailEntityPK id; + + @Lob + @Column(name="APPLICATIONS_TO_BE_USED") + private String applicationsToBeUsed; + + @Column(name="DISK_USAGE_RANGE_PER_JOB") + private BigInteger diskUsageRangePerJob; + + @Lob + @Column(name="DOCUMENTS") + private byte[] documents; + + @Lob + @Column(name="FIELD_OF_SCIENCE") + private String fieldOfScience; + + @Lob + @Column(name="KEYWORDS") + private String keywords; + + @Column(name="MAX_MEMORY_PER_CPU") + private BigInteger maxMemoryPerCpu; + + @Column(name="NUMBER_OF_CPU_PER_JOB") + private BigInteger numberOfCpuPerJob; + + @Lob + @Column(name="PROJECT_DESCRIPTION") + private String projectDescription; + + @Lob + @Column(name="PROJECT_REVIEWED_AND_FUNDED_BY") + private String projectReviewedAndFundedBy; + + @Column(name="REQ_DATE") + private BigInteger reqDate; + + @Column(name="SERVICE_UNITS") + private BigInteger serviceUnits; + + @Lob + @Column(name="SPECIFIC_RESOURCE_SELECTION") + private String specificResourceSelection; + + @Lob + @Column(name="TITLE") + private String title; + + @Column(name="TYPE_OF_ALLOCATION") + private String typeOfAllocation; + + @Column(name="TYPICAL_SU_PER_JOB") + private BigInteger typicalSuPerJob; + + public UserAllocationDetailEntity() { + } + + public UserAllocationDetailEntityPK getId() { + return this.id; + } + + public void setId(UserAllocationDetailEntityPK id) { + this.id = id; + } + + public String getApplicationsToBeUsed() { + return this.applicationsToBeUsed; + } + + public void setApplicationsToBeUsed(String applicationsToBeUsed) { + this.applicationsToBeUsed = applicationsToBeUsed; + } + + public BigInteger getDiskUsageRangePerJob() { + return this.diskUsageRangePerJob; + } + + public void setDiskUsageRangePerJob(BigInteger diskUsageRangePerJob) { + this.diskUsageRangePerJob = diskUsageRangePerJob; + } + + public byte[] getDocuments() { + return this.documents; + } + + public void setDocuments(byte[] documents) { + this.documents = documents; + } + + public String getFieldOfScience() { + return this.fieldOfScience; + } + + public void setFieldOfScience(String fieldOfScience) { + this.fieldOfScience = fieldOfScience; + } + + public String getKeywords() { + return this.keywords; + } + + public void setKeywords(String keywords) { + this.keywords = keywords; + } + + public BigInteger getMaxMemoryPerCpu() { + return this.maxMemoryPerCpu; + } + + public void setMaxMemoryPerCpu(BigInteger maxMemoryPerCpu) { + this.maxMemoryPerCpu = maxMemoryPerCpu; + } + + public BigInteger getNumberOfCpuPerJob() { + return this.numberOfCpuPerJob; + } + + public void setNumberOfCpuPerJob(BigInteger numberOfCpuPerJob) { + this.numberOfCpuPerJob = numberOfCpuPerJob; + } + + public String getProjectDescription() { + return this.projectDescription; + } + + public void setProjectDescription(String projectDescription) { + this.projectDescription = projectDescription; + } + + public String getProjectReviewedAndFundedBy() { + return this.projectReviewedAndFundedBy; + } + + public void setProjectReviewedAndFundedBy(String projectReviewedAndFundedBy) { + this.projectReviewedAndFundedBy = projectReviewedAndFundedBy; + } + + public BigInteger getReqDate() { + return this.reqDate; + } + + public void setReqDate(BigInteger reqDate) { + this.reqDate = reqDate; + } + + public BigInteger getServiceUnits() { + return this.serviceUnits; + } + + public void setServiceUnits(BigInteger serviceUnits) { + this.serviceUnits = serviceUnits; + } + + public String getSpecificResourceSelection() { + return this.specificResourceSelection; + } + + public void setSpecificResourceSelection(String specificResourceSelection) { + this.specificResourceSelection = specificResourceSelection; + } + + public String getTitle() { + return this.title; + } + + public void setTitle(String title) { + this.title = title; + } + + public String getTypeOfAllocation() { + return this.typeOfAllocation; + } + + public void setTypeOfAllocation(String typeOfAllocation) { + this.typeOfAllocation = typeOfAllocation; + } + + public BigInteger getTypicalSuPerJob() { + return this.typicalSuPerJob; + } + + public void setTypicalSuPerJob(BigInteger typicalSuPerJob) { + this.typicalSuPerJob = typicalSuPerJob; + } + +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntityPK.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntityPK.java new file mode 100644 index 0000000..e768883 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserAllocationDetailEntityPK.java @@ -0,0 +1,57 @@ +package org.apache.airavata.allocation.manager.db.entities; + +import java.io.Serializable; +import javax.persistence.*; + +/** + * The primary key class for the USER_ALLOCATION_DETAILS database table. + * + */ +@Embeddable +public class UserAllocationDetailEntityPK implements Serializable { + //default serial version id, required for serializable classes. + private static final long serialVersionUID = 1L; + + @Column(name="PROJECT_ID") + private String projectId; + + @Column(name="USERNAME") + private String username; + + public UserAllocationDetailEntityPK() { + } + public String getProjectId() { + return this.projectId; + } + public void setProjectId(String projectId) { + this.projectId = projectId; + } + public String getUsername() { + return this.username; + } + public void setUsername(String username) { + this.username = username; + } + + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (!(other instanceof UserAllocationDetailEntityPK)) { + return false; + } + UserAllocationDetailEntityPK castOther = (UserAllocationDetailEntityPK)other; + return + this.projectId.equals(castOther.projectId) + && this.username.equals(castOther.username); + } + + public int hashCode() { + final int prime = 31; + int hash = 17; + hash = hash * prime + this.projectId.hashCode(); + hash = hash * prime + this.username.hashCode(); + + return hash; + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserDetailEntity.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserDetailEntity.java new file mode 100644 index 0000000..9eb04fc --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/entities/UserDetailEntity.java @@ -0,0 +1,78 @@ +package org.apache.airavata.allocation.manager.db.entities; + +import java.io.Serializable; +import javax.persistence.*; + + +/** + * The persistent class for the USER_DETAILS database table. + * + */ +@Entity +@Table(name="USER_DETAILS") +@NamedQuery(name="UserDetailEntity.findAll", query="SELECT u FROM UserDetailEntity u") +public class UserDetailEntity implements Serializable { + private static final long serialVersionUID = 1L; + + @Id + @Column(name="USERNAME") + private String username; + + @Lob + @Column(name="EMAIL") + private String email; + + @Lob + @Column(name="FULL_NAME") + private String fullName; + + @Column(name="PASSWORD") + private String password; + + @Column(name="USER_TYPE") + private String userType; + + public UserDetailEntity() { + } + + public String getUsername() { + return this.username; + } + + public void setUsername(String username) { + this.username = username; + } + + public String getEmail() { + return this.email; + } + + public void setEmail(String email) { + this.email = email; + } + + public String getFullName() { + return this.fullName; + } + + public void setFullName(String fullName) { + this.fullName = fullName; + } + + public String getPassword() { + return this.password; + } + + public void setPassword(String password) { + this.password = password; + } + + public String getUserType() { + return this.userType; + } + + public void setUserType(String userType) { + this.userType = userType; + } + +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/AbstractRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/AbstractRepository.java new file mode 100644 index 0000000..6449b4a --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/AbstractRepository.java @@ -0,0 +1,163 @@ +/** + * + * 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.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.utils.Committer; +import org.apache.airavata.allocation.manager.db.utils.DBConstants; +import org.apache.airavata.allocation.manager.db.utils.JPAUtils; +import org.apache.airavata.allocation.manager.db.utils.ObjectMapperSingleton; +import org.apache.airavata.allocation.manager.models.AllocationManagerException; +import org.dozer.Mapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public abstract class AbstractRepository<T, E, Id> { + private final static Logger logger = LoggerFactory.getLogger(AbstractRepository.class); + + private Class<T> thriftGenericClass; + private Class<E> dbEntityGenericClass; + + public AbstractRepository(Class<T> thriftGenericClass, Class<E> dbEntityGenericClass){ + this.thriftGenericClass = thriftGenericClass; + this.dbEntityGenericClass = dbEntityGenericClass; + } + + public T create(T t) throws Exception { + return update(t); + } + + //FIXME do a bulk insert + public List<T> create(List<T> tList) throws Exception { + return update(tList); + } + + public T update(T t) throws Exception { + Mapper mapper = ObjectMapperSingleton.getInstance(); + E entity = mapper.map(t, dbEntityGenericClass); + E persistedCopy = execute(entityManager -> entityManager.merge(entity)); + return mapper.map(persistedCopy, thriftGenericClass); + } + + //FIXME do a bulk update + public List<T> update(List<T> tList) throws Exception { + List<T> returnList = new ArrayList<T>(); + for(T temp : tList) + returnList.add(update(temp)); + return returnList; + } + + public boolean delete(Id id) throws Exception { + execute(entityManager -> { + E entity = entityManager.find(dbEntityGenericClass, id); + entityManager.remove(entity); + return entity; + }); + return true; + } + + public boolean delete(List<Id> idList) throws Exception { + for(Id id : idList) + delete(id); + return true; + } + + public T get(Id id) throws Exception { + E entity = execute(entityManager -> entityManager + .find(dbEntityGenericClass, id)); + Mapper mapper = ObjectMapperSingleton.getInstance(); + if(entity == null) + return null; + return mapper.map(entity, thriftGenericClass); + } + + public boolean isExists(Id id) throws Exception { + return get(id) != null; + } + + public List<T> get(List<Id> idList) throws Exception { + List<T> returnList = new ArrayList<>(); + for(Id id : idList) + returnList.add(get(id)); + return returnList; + } + + public List<T> select(Map<String, String> filters, int offset, int limit) throws Exception { + String query = "SELECT DISTINCT p from " + dbEntityGenericClass.getSimpleName() + " as p"; + ArrayList<String> parameters = new ArrayList<>(); + int parameterCount = 1; + if (filters != null && filters.size() != 0) { + query += " WHERE "; + for (String k : filters.keySet()) { + query += "p." + k + " = ?" + parameterCount + " AND "; + parameters.add(filters.get(k)); + parameterCount++; + } + query = query.substring(0, query.length() - 5); + } + + query += " ORDER BY p.createdTime DESC"; + String queryString = query; + int newLimit = limit < 0 ? DBConstants.SELECT_MAX_ROWS: limit; + List resultSet = execute(entityManager -> { + javax.persistence.Query q = entityManager.createQuery(queryString); + for (int i = 0; i < parameters.size(); i++) { + q.setParameter(i + 1, parameters.get(i)); + } + return q.setFirstResult(offset).setMaxResults(newLimit).getResultList(); + }); + Mapper mapper = ObjectMapperSingleton.getInstance(); + List<T> gatewayList = new ArrayList<>(); + resultSet.stream().forEach(rs -> gatewayList.add(mapper.map(rs, thriftGenericClass))); + return gatewayList; + } + + public List<T> select(String queryString, Map<String,Object> queryParameters, int offset, int limit) throws Exception { + int newLimit = limit < 0 ? DBConstants.SELECT_MAX_ROWS: limit; + List resultSet = execute(entityManager -> { + Query q = entityManager.createQuery(queryString); + for(Map.Entry<String, Object> queryParam : queryParameters.entrySet()){ + q.setParameter(queryParam.getKey(), queryParam.getValue()); + } + return q.setFirstResult(offset).setMaxResults(newLimit).getResultList(); + }); + Mapper mapper = ObjectMapperSingleton.getInstance(); + List<T> gatewayList = new ArrayList<>(); + resultSet.stream().forEach(rs -> gatewayList.add(mapper.map(rs, thriftGenericClass))); + return gatewayList; + } + + public <R> R execute(Committer<EntityManager, R> committer) throws Exception { + EntityManager entityManager = JPAUtils.getEntityManager(); + try { + entityManager.getTransaction().begin(); + R r = committer.commit(entityManager); + entityManager.getTransaction().commit(); + return r; + } finally { + entityManager.close(); + } + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/DomainRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/DomainRepository.java new file mode 100644 index 0000000..c86d85b --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/DomainRepository.java @@ -0,0 +1,33 @@ +/** + * + * 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.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.entities.DomainEntity; +import org.apache.airavata.allocation.manager.models.Domain; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class DomainRepository extends AbstractRepository<Domain, DomainEntity, String> { + private final static Logger logger = LoggerFactory.getLogger(DomainRepository.class); + + public DomainRepository(){ + super(Domain.class, DomainEntity.class); + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/RequestStatusRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/RequestStatusRepository.java new file mode 100644 index 0000000..71cbba8 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/RequestStatusRepository.java @@ -0,0 +1,14 @@ +package org.apache.airavata.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.entities.RequestStatusEntity; +import org.apache.airavata.allocation.manager.models.RequestStatus; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class RequestStatusRepository extends AbstractRepository<RequestStatus, RequestStatusEntity,String> { + private final static Logger logger = LoggerFactory.getLogger(DomainRepository.class); + + public RequestStatusRepository(){ + super(RequestStatus.class, RequestStatusEntity.class); + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailPKRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailPKRepository.java new file mode 100644 index 0000000..265e063 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailPKRepository.java @@ -0,0 +1,14 @@ +package org.apache.airavata.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.entities.UserAllocationDetailEntityPK; +import org.apache.airavata.allocation.manager.models.UserAllocationDetailPK; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class UserAllocationDetailPKRepository extends AbstractRepository<UserAllocationDetailPK, UserAllocationDetailPK, String> { + private final static Logger logger = LoggerFactory.getLogger(DomainRepository.class); + + public UserAllocationDetailPKRepository(){ + super(UserAllocationDetailPK.class, UserAllocationDetailPK.class); + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailRepository.java new file mode 100644 index 0000000..adfd6d2 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserAllocationDetailRepository.java @@ -0,0 +1,14 @@ +package org.apache.airavata.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.entities.UserAllocationDetailEntity; +import org.apache.airavata.allocation.manager.models.UserAllocationDetail; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class UserAllocationDetailRepository extends AbstractRepository<UserAllocationDetail, UserAllocationDetailEntity, String> { + private final static Logger logger = LoggerFactory.getLogger(DomainRepository.class); + + public UserAllocationDetailRepository(){ + super(UserAllocationDetail.class, UserAllocationDetailEntity.class); + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserDetailRepository.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserDetailRepository.java new file mode 100644 index 0000000..c05ff5c --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/repositories/UserDetailRepository.java @@ -0,0 +1,19 @@ +package org.apache.airavata.allocation.manager.db.repositories; + +import org.apache.airavata.allocation.manager.db.entities.UserDetailEntity; +import org.apache.airavata.allocation.manager.models.UserDetail; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class UserDetailRepository extends AbstractRepository<UserDetail, UserDetailEntity, String> { + private final static Logger logger = LoggerFactory.getLogger(DomainRepository.class); + + public UserDetailRepository(){ + super(UserDetail.class, UserDetailEntity.class); + } + + public static void main(String args[]) + { + + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/Committer.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/Committer.java new file mode 100644 index 0000000..64e9abc --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/Committer.java @@ -0,0 +1,26 @@ +/** + * + * 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.allocation.manager.db.utils; + +@FunctionalInterface +public interface Committer<T, R> { + + R commit(T t); +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ConnectionPool.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ConnectionPool.java new file mode 100644 index 0000000..2d3a64e --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ConnectionPool.java @@ -0,0 +1,381 @@ +/** + * + * 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.allocation.manager.db.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.sql.DataSource; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Stack; +import java.util.concurrent.Semaphore; + + +/** + * A class for preallocating, recycling, and managing JDBC connections. + */ +public class ConnectionPool { + private static final Logger logger = LoggerFactory.getLogger(ConnectionPool.class); + + private long MAX_IDLE_TIME = 5 * 60 * 1000; // 5 minutes + + private String driver; + private String url; + private String username; + private String password; + private String jdbcUrl; + + private int maxConnections; + + private boolean autoCommit = true; + private boolean waitIfBusy; + + private Semaphore needConnection = new Semaphore(0); + private boolean stop; + + private Stack<Connection> availableConnections; + private Stack<Connection> busyConnections; + + private HashMap<Connection, Long> lastAccessTimeRecord = new HashMap<Connection, Long>(); + + private String urlType = ""; + + private DataSource datasource; + + private int transactionIsolation = Connection.TRANSACTION_NONE; + + private Thread clenupThread; + private Thread producerThread; + + public ConnectionPool(String driver, String url, String username, String password, int initialConnections, + int maxConnections, boolean waitIfBusy) throws SQLException { + this.driver = driver; + this.url = url; + this.username = username; + this.password = password; + this.urlType = "speratedURL"; + initialize(initialConnections, maxConnections, waitIfBusy); + } + + public ConnectionPool(String driver, String jdbcUrl, int initialConnections, int maxConnections, + boolean waitIfBusy, boolean autoCommit, int transactionIsolation) throws SQLException { + this.driver = driver; + this.jdbcUrl = jdbcUrl; + this.urlType = "simpleURL"; + this.autoCommit = autoCommit; + this.transactionIsolation = transactionIsolation; + initialize(initialConnections, maxConnections, waitIfBusy); + } + + public ConnectionPool(String driver, String jdbcUrl, int initialConnections, int maxConnections, boolean waitIfBusy) + throws SQLException { + this.driver = driver; + this.jdbcUrl = jdbcUrl; + this.urlType = "simpleURL"; + initialize(initialConnections, maxConnections, waitIfBusy); + } + + public ConnectionPool(DataSource dataSource, int initialConnections, int maxConnections, boolean waitIfBusy) + throws SQLException { + this.urlType = "dataSource"; + this.datasource = dataSource; + initialize(initialConnections, maxConnections, waitIfBusy); + } + + /** + * Check if this connection pool is auto commit or not + * + * @return + */ + public boolean isAutoCommit() { + return this.autoCommit; + } + + private void initialize(int initialConnections, int maxConnections, boolean waitIfBusy) throws SQLException { + this.maxConnections = maxConnections; + this.waitIfBusy = waitIfBusy; + + int sizeOfConnections = (initialConnections > maxConnections) ? maxConnections : initialConnections; + + availableConnections = new Stack<Connection>(); + busyConnections = new Stack<Connection>(); + + for (int i = 0; i < sizeOfConnections; i++) { + Connection con = makeNewConnection(); + setTimeStamp(con); + availableConnections.push(con); + + } + + producerThread = new Thread(new FillUpThread()); + producerThread.start(); + + clenupThread = new Thread(new CleanUpThread()); + clenupThread.start(); + } + + public synchronized Connection getConnection() throws SQLException { + if (!availableConnections.isEmpty()) { + Connection existingConnection = availableConnections.pop(); + + // If connection on available list is closed (e.g., + // it timed out), then remove it from available list + // and race for a connection again. + if (existingConnection.isClosed()) { + lastAccessTimeRecord.remove(existingConnection); + // notifyAll for fairness + notifyAll(); + } else { + busyConnections.push(existingConnection); + setTimeStamp(existingConnection); + return existingConnection; + } + } else if (!waitIfBusy && busyConnections.size() >= maxConnections) { + // You reached maxConnections limit and waitIfBusy flag is false. + // Throw SQLException in such a case. + throw new SQLException("Connection limit reached"); + } else { + + if (busyConnections.size() < maxConnections) { + // available connection is empty, but total number of connection + // doesn't reach maxConnection. Request for more connection + needConnection.release(); + } + + try { + // wait for free connection + wait(); + } catch (InterruptedException ie) { + } + } + // always race for connection forever + return getConnection(); + } + + // This explicitly makes a new connection. Called in + // the foreground when initializing the ConnectionPool, + // and called in the background when running. + private Connection makeNewConnection() throws SQLException { + try { + // Load database driver if not already loaded + Class.forName(driver); + Connection connection; + // Establish network connection to database + if (urlType.equals("speratedURL")) { + connection = DriverManager.getConnection(url, username, password); + } else if (urlType.equals("simpleURL")) { + connection = DriverManager.getConnection(jdbcUrl); + } else { // if(urlType.equals("dataSource")){ + connection = datasource.getConnection(); + } + connection.setTransactionIsolation(this.transactionIsolation); + connection.setAutoCommit(this.autoCommit); + return connection; + } catch (ClassNotFoundException cnfe) { + // Simplify try/catch blocks of people using this by + // throwing only one exception type. + throw new SQLException("Can't find class for driver: " + driver); + } + } + + private synchronized void fillUpConnection(Connection conn) { + setTimeStamp(conn); + availableConnections.push(conn); + + // notify all since new connection is created + notifyAll(); + } + + private void setTimeStamp(Connection connection) { + lastAccessTimeRecord.put(connection, System.currentTimeMillis()); + } + + // The database connection cannot be left idle for too long, otherwise TCP + // connection will be broken. + /** + * From http://forums.mysql.com/read.php?39,28450,57460#msg-57460 Okay, then it looks like wait_timeout on the + * server is killing your connection (it is set to 8 hours of idle time by default). Either set that value higher on + * your server, or configure your connection pool to not hold connections idle that long (I prefer the latter). Most + * folks I know that run MySQL with a connection pool in high-load production environments only let connections sit + * idle for a matter of minutes, since it only takes a few milliseconds to open a connection, and the longer one + * sits idle the more chance it will go "bad" because of a network hiccup or the MySQL server being restarted. + * + * @throws java.sql.SQLException + */ + private boolean isConnectionStale(Connection connection) { + long currentTime = System.currentTimeMillis(); + long lastAccess = lastAccessTimeRecord.get(connection); + if (currentTime - lastAccess > MAX_IDLE_TIME) { + return true; + } else + return false; + } + + private synchronized void closeStaleConnections() { + // close idle connections + Iterator<Connection> iter = availableConnections.iterator(); + while (iter.hasNext()) { + Connection existingConnection = iter.next(); + if (isConnectionStale(existingConnection)) { + try { + existingConnection.close(); + iter.remove(); + } catch (SQLException sql) { + logger.error(sql.getMessage(), sql); + } + } + } + // close busy connections that have been checked out for too long. + // This should not happen since this means program has bug for not + // releasing connections . + iter = busyConnections.iterator(); + while (iter.hasNext()) { + Connection busyConnection = iter.next(); + if (isConnectionStale(busyConnection)) { + try { + busyConnection.close(); + iter.remove(); + logger.warn("****Connection has checked out too long. Forced release. Check the program for calling release connection [free(Connection) method]"); + } catch (SQLException sql) { + logger.error(sql.getMessage(), sql); + } + } + } + } + + public synchronized void free(Connection connection) { + busyConnections.removeElement(connection); + availableConnections.addElement(connection); + // Wake up threads that are waiting for a connection + notifyAll(); + } + + /** + * Close all the connections. Use with caution: be sure no connections are in use before calling. Note that you are + * not <I>required</I> to call this when done with a ConnectionPool, since connections are guaranteed to be closed + * when garbage collected. But this method gives more control regarding when the connections are closed. + */ + public synchronized void dispose() { + logger.info("Connection Pool Shutting down"); + + // stop clean up thread + this.stop = true; + this.clenupThread.interrupt(); + + // stop producer up thread + this.producerThread.interrupt(); + + // close all connection + closeConnections(availableConnections); + availableConnections = new Stack<Connection>(); + closeConnections(busyConnections); + busyConnections = new Stack<Connection>(); + lastAccessTimeRecord.clear(); + + logger.info("All connection is closed"); + + try { + this.clenupThread.join(); + this.producerThread.join(); + } catch (Exception e) { + logger.error("Cannot shutdown cleanup thread", e); + } + + logger.info("Connection Pool Shutdown"); + } + + private void closeConnections(Stack<Connection> connections) { + while (!connections.isEmpty()) { + Connection connection = connections.pop(); + try { + if (!connection.isClosed()) { + connection.close(); + } + } catch (SQLException sqle) { + // Ignore errors; garbage collect anyhow + logger.warn(sqle.getMessage()); + } + } + } + + public synchronized String toString() { + String info = "ConnectionPool(" + url + "," + username + ")" + ", available=" + availableConnections.size() + + ", busy=" + busyConnections.size() + ", max=" + maxConnections; + return (info); + } + + class CleanUpThread implements Runnable { + public void run() { + while (!stop) { + try { + Thread.sleep(MAX_IDLE_TIME); + closeStaleConnections(); + } catch (InterruptedException e) { + logger.info("Clean up thread is interrupted to close"); + } + } + } + } + + class FillUpThread implements Runnable { + public void run() { + while (!stop) { + try { + // block until get + needConnection.acquire(); + + Connection conn = makeNewConnection(); + fillUpConnection(conn); + } catch (SQLException e) { + // cannot create connection (increase semaphore value back) + needConnection.release(); + logger.error(e.getMessage(), e); + } catch (InterruptedException e) { + logger.info("Fill up thread is interrupted to close"); + break; + } + } + } + } + + public void shutdown() throws SQLException{ + for (Connection c : availableConnections) { + try { + c.close(); + } catch (SQLException e) { + logger.error("Error while closing the connection", e); + throw new SQLException("Error while closing the connection", e); + } + } + + for (Connection c : busyConnections) { + try { + c.close(); + } catch (SQLException e) { + logger.error("Error while closing the connection", e); + throw new SQLException("Error while closing the connection", e); + } + } + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DBConstants.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DBConstants.java new file mode 100644 index 0000000..1de1363 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DBConstants.java @@ -0,0 +1,106 @@ +/** + * + * 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.allocation.manager.db.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class DBConstants { + private final static Logger logger = LoggerFactory.getLogger(DBConstants.class); + + public static int SELECT_MAX_ROWS = 1000; + + public static class DomainTable { + public static final String DOMAIN_ID = "domainId"; + public static final String NAME = "name"; + public static final String DESCRIPTION = "description"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class UserTable { + public static final String USER_ID = "userId"; + public static final String DOMAIN_ID = "domainId"; + public static final String USER_NAME = "userName"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class UserGroupTable { + public static final String GROUP_ID = "groupId"; + public static final String DOMAIN_ID = "domainId"; + public static final String NAME = "name"; + public static final String DESCRIPTION = "description"; + public static final String OWNER_ID = "ownerId"; + public static final String GROUP_TYPE = "groupType"; + public static final String GROUP_CARDINALITY = "groupCardinality"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class GroupMembershipTable { + public static final String PARENT_ID = "parentId"; + public static final String CHILD_ID = "childId"; + public static final String CHILD_TYPE = "childType"; + public static final String DOMAIN_ID = "domainId"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class EntityTypeTable { + public static final String ENTITY_TYPE_ID = "entityTypeId"; + public static final String DOMAIN_ID = "domainId"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class PermissionTypeTable { + public static final String ENTITY_TYPE_ID = "permissionTypeId"; + public static final String DOMAIN_ID = "domainId"; + public static final String NAME = "name"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } + + public static class EntityTable { + public static final String ENTITY_ID = "entityId"; + public static final String PARENT_ENTITY_ID = "parentEntityId"; + public static final String ENTITY_TYPE_ID = "entityTypeId"; + public static final String NAME = "name"; + public static final String DESCRIPTION = "description"; + public static final String FULL_TEXT = "fullText"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + public static final String DOMAIN_ID = "domainId"; + public static final String ORIGINAL_ENTITY_CREATION_TIME = "originalEntityCreationTime"; + public static final String SHARED = "shared"; + } + + public static class SharingTable { + public static final String DOMAIN_ID = "domainId"; + public static final String PERMISSION_TYPE_ID = "permissionTypeId"; + public static final String ENTITY_ID = "entityId"; + public static final String GROUP_ID = "groupId"; + public static final String INHERITED_PARENT_ID = "inheritedParentId"; + public static final String SHARING_TYPE = "sharingType"; + public static final String CREATED_TIME = "createdTime"; + public static final String UPDATED_TIME = "updatedTime"; + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DatabaseCreator.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DatabaseCreator.java new file mode 100644 index 0000000..d8368f5 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/DatabaseCreator.java @@ -0,0 +1,352 @@ +/** + * + * 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.allocation.manager.db.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.sql.*; +import java.util.StringTokenizer; + +/** + * This class creates the database tables required for airavata with default configuration this + * class creates derby database in server mode. User can specify required database in appropriate + * properties files. + */ +public class DatabaseCreator { + private final static Logger logger = LoggerFactory.getLogger(DatabaseCreator.class); + + public enum DatabaseType { + derby("(?i).*derby.*"), mysql("(?i).*mysql.*"), other(""); + + private String pattern; + + private DatabaseType(String matchingPattern) { + this.pattern = matchingPattern; + } + + public String getMatchingPattern() { + return this.pattern; + } + } + + private static DatabaseType[] supportedDatabase = new DatabaseType[] { DatabaseType.derby, DatabaseType.mysql }; + + private static Logger log = LoggerFactory.getLogger(DatabaseCreator.class); + private static final String delimiter = ";"; + + /** + * Creates database + * + * @throws Exception + */ + public static void createRegistryDatabase(String prefix, Connection conn) throws Exception { + createDatabase(prefix, conn); + } + + + + /** + * Checks whether database tables are created by using select * on given table name + * + * @param tableName + * Table which should be existed + * @return <code>true</core> if checkSQL is success, else <code>false</code> . + */ + public static boolean isDatabaseStructureCreated(String tableName, Connection conn) { + try { + + log.debug("Running a query to test the database tables existence."); + + // check whether the tables are already created with a query + Statement statement = null; + try { + statement = conn.createStatement(); + ResultSet rs = statement.executeQuery("select * from " + tableName); + if (rs != null) { + rs.close(); + } + } finally { + try { + if (statement != null) { + statement.close(); + } + } catch (SQLException e) { + return false; + } + } + } catch (SQLException e) { + return false; + } + + return true; + } + + /** + * executes given sql + * + * @param sql + * @throws Exception + */ + private static void executeSQL(String sql, Connection conn) throws Exception { + // Check and ignore empty statements + if ("".equals(sql.trim())) { + return; + } + + Statement statement = null; + try { + log.debug("SQL : " + sql); + + boolean ret; + int updateCount = 0, updateCountTotal = 0; + statement = conn.createStatement(); + ret = statement.execute(sql); + updateCount = statement.getUpdateCount(); + do { + if (!ret) { + if (updateCount != -1) { + updateCountTotal += updateCount; + } + } + ret = statement.getMoreResults(); + if (ret) { + updateCount = statement.getUpdateCount(); + } + } while (ret); + + log.debug(sql + " : " + updateCountTotal + " rows affected"); + + SQLWarning warning = conn.getWarnings(); + while (warning != null) { + log.info(warning + " sql warning"); + warning = warning.getNextWarning(); + } + conn.clearWarnings(); + } catch (SQLException e) { + if (e.getSQLState().equals("X0Y32")) { + // eliminating the table already exception for the derby + // database + log.info("Table Already Exists", e); + } else { + throw new Exception("Error occurred while executing : " + sql, e); + } + } finally { + if (statement != null) { + try { + statement.close(); + } catch (SQLException e) { + log.error("Error occurred while closing result set.", e); + } + } + } + } + + /** + * computes relatational database type using database name + * + * @return DatabaseType + * @throws Exception + * + */ + public static DatabaseType getDatabaseType(Connection conn) throws Exception { + try { + if (conn != null && (!conn.isClosed())) { + DatabaseMetaData metaData = conn.getMetaData(); + String databaseProductName = metaData.getDatabaseProductName(); + return checkType(databaseProductName); + } + } catch (SQLException e) { + String msg = "Failed to create Airavata database." + e.getMessage(); + log.error(msg, e); + throw new Exception(msg, e); + } + return DatabaseType.other; + } + + /** + * Overloaded method with String input + * + * @return DatabaseType + * @throws Exception + * + */ + public static DatabaseType getDatabaseType(String dbUrl) throws Exception { + return checkType(dbUrl); + } + + private static DatabaseType checkType(String text) throws Exception { + try { + if (text != null) { + for (DatabaseType type : supportedDatabase) { + if (text.matches(type.getMatchingPattern())) + return type; + } + } + String msg = "Unsupported database: " + text + + ". Database will not be created automatically by the Airavata. " + + "Please create the database using appropriate database scripts for " + "the database."; + throw new Exception(msg); + + } catch (SQLException e) { + String msg = "Failed to create Airavatadatabase." + e.getMessage(); + log.error(msg, e); + throw new Exception(msg, e); + } + } + + /** + * Get scripts location which is prefix + "-" + databaseType + ".sql" + * + * @param prefix + * @param databaseType + * @return script location + */ + private static String getScriptLocation(String prefix, DatabaseType databaseType) { + String scriptName = prefix + "-" + databaseType + ".sql"; + log.debug("Loading database script from :" + scriptName); + return scriptName; + } + + private static void createDatabase(String prefix, Connection conn) throws Exception { + Statement statement = null; + try { + conn.setAutoCommit(false); + statement = conn.createStatement(); + executeSQLScript(getScriptLocation(prefix, DatabaseCreator.getDatabaseType(conn)), conn); + conn.commit(); + log.debug("Tables are created successfully."); + } catch (SQLException e) { + String msg = "Failed to create database tables for Airavata resource store. " + e.getMessage(); + log.error(msg, e); + conn.rollback(); + throw new Exception(msg, e); + } finally { + conn.setAutoCommit(true); + try { + if (statement != null) { + statement.close(); + } + } catch (SQLException e) { + log.error("Failed to close statement.", e); + } + } + } + + private static void executeSQLScript(String dbscriptName, Connection conn) throws Exception { + StringBuffer sql = new StringBuffer(); + BufferedReader reader = null; + + try { + InputStream is = DatabaseCreator.class.getClassLoader().getResourceAsStream(dbscriptName); + if(is == null) { + logger.info("Script file not found at " + dbscriptName + ". Uses default database script file"); + DatabaseType databaseType = DatabaseCreator.getDatabaseType(conn); + if(databaseType.equals(DatabaseType.derby)){ + is = DatabaseCreator.class.getClassLoader().getResourceAsStream("sharing-registry-derby.sql"); + }else if(databaseType.equals(DatabaseType.mysql)){ + is = DatabaseCreator.class.getClassLoader().getResourceAsStream("sharing-registry-mysql.sql"); + } + } + reader = new BufferedReader(new InputStreamReader(is)); + String line; + while ((line = reader.readLine()) != null) { + line = line.trim(); + if (line.startsWith("//")) { + continue; + } + if (line.startsWith("--")) { + continue; + } + StringTokenizer st = new StringTokenizer(line); + if (st.hasMoreTokens()) { + String token = st.nextToken(); + if ("REM".equalsIgnoreCase(token)) { + continue; + } + } + sql.append(" ").append(line); + + // SQL defines "--" as a comment to EOL + // and in Oracle it may contain a hint + // so we cannot just remove it, instead we must end it + if (line.indexOf("--") >= 0) { + sql.append("\n"); + } + if ((checkStringBufferEndsWith(sql, delimiter))) { + executeSQL(sql.substring(0, sql.length() - delimiter.length()), conn); + sql.replace(0, sql.length(), ""); + } + } + // Catch any statements not followed by ; + if (sql.length() > 0) { + executeSQL(sql.toString(), conn); + } + } catch (IOException e) { + log.error("Error occurred while executing SQL script for creating Airavata database", e); + throw new Exception("Error occurred while executing SQL script for creating Airavata database", e); + + } finally { + if (reader != null) { + reader.close(); + } + } + } + + /** + * Checks that a string buffer ends up with a given string. It may sound trivial with the existing JDK API but the + * various implementation among JDKs can make those methods extremely resource intensive and perform poorly due to + * massive memory allocation and copying. See + * + * @param buffer + * the buffer to perform the check on + * @param suffix + * the suffix + * @return <code>true</code> if the character sequence represented by the argument is a suffix of the character + * sequence represented by the StringBuffer object; <code>false</code> otherwise. Note that the result will + * be <code>true</code> if the argument is the empty string. + */ + public static boolean checkStringBufferEndsWith(StringBuffer buffer, String suffix) { + if (suffix.length() > buffer.length()) { + return false; + } + // this loop is done on purpose to avoid memory allocation performance + // problems on various JDKs + // StringBuffer.lastIndexOf() was introduced in jdk 1.4 and + // implementation is ok though does allocation/copying + // StringBuffer.toString().endsWith() does massive memory + // allocation/copying on JDK 1.5 + // See http://issues.apache.org/bugzilla/show_bug.cgi?id=37169 + int endIndex = suffix.length() - 1; + int bufferIndex = buffer.length() - 1; + while (endIndex >= 0) { + if (buffer.charAt(bufferIndex) != suffix.charAt(endIndex)) { + return false; + } + bufferIndex--; + endIndex--; + } + return true; + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JPAUtils.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JPAUtils.java new file mode 100644 index 0000000..3781c4b --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JPAUtils.java @@ -0,0 +1,215 @@ +/** + * + * 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.allocation.manager.db.utils; + +import org.apache.airavata.common.exception.ApplicationSettingsException; +import org.apache.airavata.common.utils.ServerSettings; +import org.apache.airavata.allocation.manager.models.AllocationManagerException; +import org.apache.derby.drda.NetworkServerControl; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.*; +import java.io.IOException; +import java.net.InetAddress; +import java.net.URI; +import java.sql.Connection; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.Map; + +public class JPAUtils { + private final static Logger logger = LoggerFactory.getLogger(JPAUtils.class); + + public static final String PERSISTENCE_UNIT_NAME = "airavata-sharing-registry"; + public static final String SHARING_REG_JDBC_DRIVER = "sharingcatalog.jdbc.driver"; + public static final String SHARING_REG_JDBC_URL = "sharingcatalog.jdbc.url"; + public static final String SHARING_REG_JDBC_USER = "sharingcatalog.jdbc.user"; + public static final String SHARING_REG_JDBC_PWD = "sharingcatalog.jdbc.password"; + public static final String SHARING_REG_VALIDATION_QUERY = "sharingcatalog.validationQuery"; + public static final String JPA_CACHE_SIZE = "jpa.cache.size"; + public static final String JPA_CACHE_ENABLED = "cache.enable"; + + public static final String CONFIGURATION = "CONFIGURATION"; + public static final String START_DERBY_ENABLE = "start.derby.server.mode"; + public static final String DERBY_SERVER_MODE_SYS_PROPERTY = "derby.drda.startNetworkServer"; + private static NetworkServerControl server; + private static JdbcStorage db; + private static String jdbcURl; + private static String jdbcDriver; + private static String jdbcUser; + private static String jdbcPassword; + + @PersistenceUnit(unitName = PERSISTENCE_UNIT_NAME) + protected static EntityManagerFactory factory; + @PersistenceContext(unitName = PERSISTENCE_UNIT_NAME) + private static EntityManager entityManager; + + public synchronized static EntityManager getEntityManager() throws Exception { + if (factory == null) { + String connectionProperties = "DriverClassName=" + readServerProperties(SHARING_REG_JDBC_DRIVER) + "," + + "Url=" + readServerProperties(SHARING_REG_JDBC_URL) + "?autoReconnect=true," + + "Username=" + readServerProperties(SHARING_REG_JDBC_USER) + "," + + "Password=" + readServerProperties(SHARING_REG_JDBC_PWD) + + ",validationQuery=" + readServerProperties(SHARING_REG_VALIDATION_QUERY); + +// String connectionProperties = "DriverClassName=com.mysql.jdbc.Driver," + +// "Url=jdbc:mysql://localhost:3306/airavata_sharing_catalog?autoReconnect=true," + +// "Username=root," + +// "Password=," + +// ",validationQuery=SELECT 1 FROM CONFIGURATION"; + + Map<String, String> properties = new HashMap<String, String>(); + 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", "" + readServerProperties(JPA_CACHE_ENABLED) +// + "(CacheSize=" + Integer.valueOf(readServerProperties(JPA_CACHE_SIZE)) + ", SoftReferenceSize=0)"); +// properties.put("openjpa.QueryCache", "" + readServerProperties(JPA_CACHE_ENABLED) +// + "(CacheSize=" + Integer.valueOf(readServerProperties(JPA_CACHE_SIZE)) + ", SoftReferenceSize=0)"); + + properties.put("openjpa.RemoteCommitProvider", "sjvm"); + properties.put("openjpa.Log", "DefaultLevel=INFO, Runtime=INFO, Tool=INFO, SQL=INFO"); + properties.put("openjpa.jdbc.SynchronizeMappings", "buildSchema(ForeignKeys=true)"); + properties.put("openjpa.jdbc.QuerySQLCache", "false"); +// properties.put("openjpa.Multithreaded", "true"); + properties.put("openjpa.ConnectionFactoryProperties", "PrettyPrint=true, PrettyPrintLineLength=72," + + " PrintParameters=true, MaxActive=10, MaxIdle=5, MinIdle=2, MaxWait=31536000, autoReconnect=true"); + properties.put("openjpa.RuntimeUnenhancedClasses", "warn"); + factory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME, properties); + } + + entityManager = factory.createEntityManager(); + return entityManager; + } + + public static void initializeDB() throws Exception { + jdbcDriver = readServerProperties(SHARING_REG_JDBC_DRIVER); + jdbcURl = readServerProperties(SHARING_REG_JDBC_URL); + jdbcUser = readServerProperties(SHARING_REG_JDBC_USER); + jdbcPassword = readServerProperties(SHARING_REG_JDBC_PWD); + jdbcURl = jdbcURl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword; + + if (getDBType(jdbcURl).equals("derby") && isDerbyStartEnabled()) { + startDerbyInServerMode(); + } + db = new JdbcStorage(10, 50, jdbcURl, jdbcDriver, true); + + Connection conn = null; + try { + conn = db.connect(); + if (!DatabaseCreator.isDatabaseStructureCreated(CONFIGURATION, conn)) { + DatabaseCreator.createRegistryDatabase("database_scripts/sharing-registry", conn); + logger.info("New Database created for Sharing Catalog !!! "); + } else { + logger.info("Database already created for Sharing Catalog !!!"); + } + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RuntimeException("Database failure", e); + } finally { + db.closeConnection(conn); + try { + if(conn != null){ + if (!conn.getAutoCommit()) { + conn.commit(); + } + conn.close(); + } + } catch (SQLException e) { + logger.error("Error while closing database connection...", e.getMessage(), e); + } + } + } + + public static String getDBType(String jdbcUrl){ + try{ + String cleanURI = jdbcUrl.substring(5); + URI uri = URI.create(cleanURI); + return uri.getScheme(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + return null; + } + } + + public static boolean isDerbyStartEnabled(){ + try { + String s = ServerSettings.getSetting(START_DERBY_ENABLE); + if("true".equals(s)){ + return true; + } + } catch (ApplicationSettingsException e) { + logger.error("Unable to read airavata server properties", e.getMessage(), e); + return false; + } + return false; + } + + public static void startDerbyInServerMode() { + try { + System.setProperty(DERBY_SERVER_MODE_SYS_PROPERTY, "true"); + server = new NetworkServerControl(InetAddress.getByName("0.0.0.0"), + getPort(jdbcURl), + jdbcUser, jdbcPassword); + java.io.PrintWriter consoleWriter = new java.io.PrintWriter(System.out, true); + server.start(consoleWriter); + } catch (IOException e) { + logger.error("Unable to start Apache derby in the server mode! Check whether " + + "specified port is available"); + } catch (Exception e) { + logger.error("Unable to start Apache derby in the server mode! Check whether " + + "specified port is available"); + } + } + + public static void stopDerbyInServerMode() { + System.setProperty(DERBY_SERVER_MODE_SYS_PROPERTY, "false"); + if (server!=null){ + try { + server.shutdown(); + } catch (Exception e) { + logger.error("Error when stopping the derby server : "+e.getLocalizedMessage()); + } + } + } + + public static int getPort(String jdbcURL){ + try{ + String cleanURI = jdbcURL.substring(5); + URI uri = URI.create(cleanURI); + return uri.getPort(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + return -1; + } + } + + public static String readServerProperties(String propertyName) throws Exception { + try { + return ServerSettings.getSetting(propertyName); + } catch (ApplicationSettingsException e) { + logger.error("Unable to read airavata-server.properties...", e); + throw new Exception("Unable to read airavata-server.properties..."); + } + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JdbcStorage.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JdbcStorage.java new file mode 100644 index 0000000..ea3a360 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/JdbcStorage.java @@ -0,0 +1,174 @@ +/** + * + * 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.allocation.manager.db.utils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.*; + +public class JdbcStorage { + private static Logger log = LoggerFactory.getLogger(JdbcStorage.class); + + private ConnectionPool connectionPool; + + public JdbcStorage(String jdbcUrl, String jdbcDriver) { + // default init connection and max connection + this(3, 50, jdbcUrl, jdbcDriver, true); + } + + public JdbcStorage(int initCon, int maxCon, String url, String driver, boolean enableTransactions) { + try { + if (enableTransactions) { + connectionPool = new ConnectionPool(driver, url, initCon, maxCon, true, false, + Connection.TRANSACTION_SERIALIZABLE); + } else { + connectionPool = new ConnectionPool(driver, url, initCon, maxCon, true); + } + } catch (Exception e) { + throw new RuntimeException("Failed to create database connection pool.", e); + } + } + + /** + * Check if this connection pool is auto commit or not + * + * @return + */ + public boolean isAutoCommit() { + return connectionPool.isAutoCommit(); + } + + public void commit(Connection conn) { + try { + if (conn != null && !conn.getAutoCommit()) { + conn.commit(); + } + } catch (SQLException sqle) { + log.error("Cannot commit data", sqle); + } + } + + public void commitAndFree(Connection conn) { + commit(conn); + closeConnection(conn); + } + + public void rollback(Connection conn) { + try { + if (conn != null && !conn.getAutoCommit()) { + conn.rollback(); + } + } catch (SQLException sqle) { + log.error("Cannot Rollback data", sqle); + } + } + + public void rollbackAndFree(Connection conn) { + rollback(conn); + closeConnection(conn); + } + + public Connection connect() { + + Connection conn = null; + try { + conn = connectionPool.getConnection(); + } catch (SQLException e) { + log.error(e.getMessage(), e); + } + return conn; + } + + /** + * This method is provided so that you can have better control over the statement. For example: You can use + * stmt.setString to convert quotation mark automatically in an UPDATE statement + * + * NOTE: Statement is closed after execution + */ + public int executeUpdateAndClose(PreparedStatement stmt) throws SQLException { + int rows = 0; + try { + rows = stmt.executeUpdate(); + if (rows == 0) { + log.info("Problem: 0 rows affected by insert/update/delete statement."); + } + } finally { + stmt.close(); + } + return rows; + } + + public int countRow(String tableName, String columnName) throws SQLException { + String query = new String("SELECT COUNT(" + columnName + ") FROM " + tableName); + int count = -1; + Connection conn = null; + PreparedStatement stmt = null; + try { + conn = connectionPool.getConnection(); + stmt = conn.prepareStatement(query); + ResultSet rs = stmt.executeQuery(); + rs.next(); + count = rs.getInt(1); + commit(conn); + } catch (SQLException sql) { + rollback(conn); + throw sql; + } finally { + try { + if (stmt != null && !stmt.isClosed()) { + stmt.close(); + } + } finally { + closeConnection(conn); + } + } + return count; + } + + public void quietlyClose(Connection conn, Statement... stmts) { + if (stmts != null) { + for (Statement stmt : stmts) { + try { + if (stmt != null && !stmt.isClosed()) { + stmt.close(); + } + } catch (SQLException sql) { + log.error(sql.getMessage(), sql); + } + } + } + closeConnection(conn); + } + + public void closeConnection(Connection conn) { + if (conn != null) { + connectionPool.free(conn); + } + } + + public void closeAllConnections() { + if (connectionPool != null) + connectionPool.dispose(); + } + + public void shutdown() throws SQLException { + connectionPool.shutdown(); + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ObjectMapperSingleton.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ObjectMapperSingleton.java new file mode 100644 index 0000000..b5f6c00 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-server/src/main/java/org/apache/airavata/allocation/manager/db/utils/ObjectMapperSingleton.java @@ -0,0 +1,38 @@ +/** + * + * 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.allocation.manager.db.utils; + +import org.dozer.DozerBeanMapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class ObjectMapperSingleton extends DozerBeanMapper{ + private final static Logger logger = LoggerFactory.getLogger(ObjectMapperSingleton.class); + + private static ObjectMapperSingleton instance; + + private ObjectMapperSingleton(){} + + public static ObjectMapperSingleton getInstance(){ + if(instance == null) + instance = new ObjectMapperSingleton(); + return instance; + } +} \ No newline at end of file diff --git a/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-stubs/src/main/java/org/apache/airavata/allocation/manager/models/Domain.java b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-stubs/src/main/java/org/apache/airavata/allocation/manager/models/Domain.java new file mode 100644 index 0000000..2eccf05 --- /dev/null +++ b/allocation-manager/airavata-allocation-manager/airavata-allocation-manager-stubs/src/main/java/org/apache/airavata/allocation/manager/models/Domain.java @@ -0,0 +1,5 @@ +package org.apache.airavata.allocation.manager.models; + +public class Domain { +// Placeholder file for Madrina to create +} -- To stop receiving notification emails like this one, please contact "[email protected]" <[email protected]>.
