You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by sc...@apache.org on 2016/08/08 18:14:22 UTC
[5/7] airavata git commit: adding registry server module
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ConnectionPool.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ConnectionPool.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ConnectionPool.java
new file mode 100644
index 0000000..202a143
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ConnectionPool.java
@@ -0,0 +1,383 @@
+/*
+ *
+ * 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.api.service.util;
+
+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 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);
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/Constants.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/Constants.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/Constants.java
new file mode 100644
index 0000000..90046c3
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/Constants.java
@@ -0,0 +1,29 @@
+/*
+ *
+ * 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.api.service.util;
+
+public class Constants {
+ public static final String REGISTRY_SERVER_PORT = "regserver.port";
+ public static final String REGISTRY_SERVER_HOST = "regserver.host";
+ public static final String REGISTRY_SERVER_NAME = "regserver.name";
+ public static final String REGISTRY_SERVER_MIN_THREADS = "regserver.server.min.threads";
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/DatabaseCreator.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/DatabaseCreator.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/DatabaseCreator.java
new file mode 100644
index 0000000..ba2316f
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/DatabaseCreator.java
@@ -0,0 +1,353 @@
+/*
+ *
+ * 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.api.service.util;
+
+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("experiment-derby.sql");
+ }else if(databaseType.equals(DatabaseType.mysql)){
+ is = DatabaseCreator.class.getClassLoader().getResourceAsStream("experiment-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;
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ExperimentCatalogInitUtil.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ExperimentCatalogInitUtil.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ExperimentCatalogInitUtil.java
new file mode 100644
index 0000000..1ae5448
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ExperimentCatalogInitUtil.java
@@ -0,0 +1,203 @@
+/*
+*
+* 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.api.service.util;
+
+import org.apache.airavata.common.exception.ApplicationSettingsException;
+import org.apache.airavata.common.utils.ServerSettings;
+import org.apache.airavata.registry.core.experiment.catalog.ExpCatResourceUtils;
+import org.apache.airavata.registry.core.experiment.catalog.ResourceType;
+import org.apache.airavata.registry.core.experiment.catalog.resources.GatewayResource;
+import org.apache.airavata.registry.core.experiment.catalog.resources.ProjectResource;
+import org.apache.airavata.registry.core.experiment.catalog.resources.UserResource;
+import org.apache.airavata.registry.core.experiment.catalog.resources.WorkerResource;
+import org.apache.derby.drda.NetworkServerControl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.URI;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class ExperimentCatalogInitUtil {
+ public static final String CONFIGURATION_TABLE = "CONFIGURATION";
+ private static final Logger logger = LoggerFactory.getLogger(ExperimentCatalogInitUtil.class);
+ public static final String REGISTRY_JDBC_DRIVER = "registry.jdbc.driver";
+ public static final String REGISTRY_JDBC_URL = "registry.jdbc.url";
+ public static final String REGISTRY_JDBC_USER = "registry.jdbc.user";
+ public static final String REGISTRY_JDBC_PASSWORD = "registry.jdbc.password";
+ public static final String START_DERBY_ENABLE = "start.derby.server.mode";
+ public static final String DERBY_SERVER_MODE_SYS_PROPERTY = "derby.drda.startNetworkServer";
+ public static final String DEFAULT_PROJECT_NAME = "default";
+ private static NetworkServerControl server;
+ private static JdbcStorage db;
+ private static String jdbcURl;
+ private static String jdbcDriver;
+ private static String jdbcUser;
+ private static String jdbcPassword;
+
+
+ public static void initializeDB() {
+ System.setProperty("registry.initialize.state", "0");
+ try{
+ jdbcDriver = ServerSettings.getSetting(REGISTRY_JDBC_DRIVER);
+ jdbcURl = ServerSettings.getSetting(REGISTRY_JDBC_URL);
+ jdbcUser = ServerSettings.getSetting(REGISTRY_JDBC_USER);
+ jdbcPassword = ServerSettings.getSetting(REGISTRY_JDBC_PASSWORD);
+ jdbcURl = jdbcURl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword;
+ } catch (ApplicationSettingsException e) {
+ logger.error("Unable to read airavata server properties", e.getMessage());
+ }
+
+ 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_TABLE, conn)) {
+ DatabaseCreator.createRegistryDatabase("database_scripts/expcatalog", conn);
+ logger.info("New Database created for Experiment Catalog !!!");
+ } else {
+ logger.info("Database already created for Experiment Catalog !!!");
+ }
+ try{
+ GatewayResource gateway;
+ if (!ExpCatResourceUtils.isGatewayExist(ServerSettings.getDefaultUserGateway())){
+ gateway = (GatewayResource)ExpCatResourceUtils.createGateway(ServerSettings.getDefaultUserGateway());
+ gateway.save();
+ }else {
+ gateway = (GatewayResource)ExpCatResourceUtils.getGateway(ServerSettings.getDefaultUserGateway());
+ }
+
+ UserResource user;
+ if (!ExpCatResourceUtils.isUserExist(ServerSettings.getDefaultUser(), ServerSettings.getDefaultUserGateway())){
+ user = ExpCatResourceUtils.createUser(ServerSettings.getDefaultUser(), ServerSettings.getDefaultUserPassword(), ServerSettings.getDefaultUserGateway());
+ user.save();
+ }else {
+ user = (UserResource)ExpCatResourceUtils.getUser(ServerSettings.getDefaultUser(), ServerSettings.getDefaultUserGateway());
+ }
+
+ WorkerResource workerResource;
+ if (!gateway.isExists(ResourceType.GATEWAY_WORKER, ServerSettings.getDefaultUserGateway())){
+ workerResource = (WorkerResource)gateway.create(ResourceType.GATEWAY_WORKER);
+ workerResource.setUser(user.getUserName());
+ workerResource.save();
+ }else {
+ workerResource = (WorkerResource)gateway.get(ResourceType.GATEWAY_WORKER, ServerSettings.getDefaultUser());
+ }
+ ProjectResource projectResource;
+ if (!workerResource.isExists(ResourceType.PROJECT, DEFAULT_PROJECT_NAME)){
+ projectResource = workerResource.createProject(DEFAULT_PROJECT_NAME);
+ projectResource.setName(DEFAULT_PROJECT_NAME);
+ projectResource.setGatewayId(gateway.getGatewayId());
+ projectResource.save();
+ }
+
+ } catch (ApplicationSettingsException e) {
+ logger.error("Unable to read airavata-server properties...", e.getMessage());
+ }
+ } 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);
+ }
+ }
+ System.setProperty("registry.initialize.state", "1");
+ }
+
+ 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;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/JdbcStorage.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/JdbcStorage.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/JdbcStorage.java
new file mode 100644
index 0000000..7a33fef
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/JdbcStorage.java
@@ -0,0 +1,176 @@
+/*
+ *
+ * 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.api.service.util;
+
+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();
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ReplicaCatalogInitUtil.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ReplicaCatalogInitUtil.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ReplicaCatalogInitUtil.java
new file mode 100644
index 0000000..996afaf
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/ReplicaCatalogInitUtil.java
@@ -0,0 +1,160 @@
+/*
+*
+* 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.api.service.util;
+
+import org.apache.airavata.common.exception.ApplicationSettingsException;
+import org.apache.airavata.common.utils.ServerSettings;
+import org.apache.derby.drda.NetworkServerControl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.URI;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class ReplicaCatalogInitUtil {
+ private static final Logger logger = LoggerFactory.getLogger(ReplicaCatalogInitUtil.class);
+ public static final String REPLICA_CATALOG = "REPLICA_CATALOG";
+ public static final String REPLICA_CATALOG_JDBC_DRIVER = "replicacatalog.jdbc.driver";
+ public static final String REPLICA_CATALOG_JDBC_URL = "replicacatalog.jdbc.url";
+ public static final String REPLICA_CATALOG_JDBC_USER = "replicacatalog.jdbc.user";
+ public static final String REPLICA_CATALOG_JDBC_PASSWORD = "replicacatalog.jdbc.password";
+ 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;
+
+
+ public static void initializeDB() {
+// System.setProperty("appcatalog.initialize.state", "0");
+ try{
+ jdbcDriver = ServerSettings.getSetting(REPLICA_CATALOG_JDBC_DRIVER);
+ jdbcURl = ServerSettings.getSetting(REPLICA_CATALOG_JDBC_URL);
+ jdbcUser = ServerSettings.getSetting(REPLICA_CATALOG_JDBC_USER);
+ jdbcPassword = ServerSettings.getSetting(REPLICA_CATALOG_JDBC_PASSWORD);
+ jdbcURl = jdbcURl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword;
+ } catch (ApplicationSettingsException e) {
+ logger.error("Unable to read airavata server properties", e.getMessage());
+ }
+
+ 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(REPLICA_CATALOG, conn)) {
+ DatabaseCreator.createRegistryDatabase("database_scripts/replicacatalog", conn);
+ logger.info("New Database created for Replica Catalog !!! ");
+ } else {
+ logger.info("Database already created for Replica 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);
+ }
+ }
+// System.setProperty("appcatalog.initialize.state", "1");
+ }
+
+ 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;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/WorkflowCatalogInitUtil.java
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/WorkflowCatalogInitUtil.java b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/WorkflowCatalogInitUtil.java
new file mode 100644
index 0000000..a1ca429
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-service/src/main/java/org/apache/airavata/registry/api/service/util/WorkflowCatalogInitUtil.java
@@ -0,0 +1,160 @@
+/*
+*
+* 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.api.service.util;
+
+import org.apache.airavata.common.exception.ApplicationSettingsException;
+import org.apache.airavata.common.utils.ServerSettings;
+import org.apache.derby.drda.NetworkServerControl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.URI;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class WorkflowCatalogInitUtil {
+ private static final Logger logger = LoggerFactory.getLogger(WorkflowCatalogInitUtil.class);
+ public static final String WORKFLOW = "WORKFLOW";
+ public static final String WORKFLOWCATALOG_JDBC_DRIVER = "workflowcatalog.jdbc.driver";
+ public static final String WORKFLOWCATALOG_JDBC_URL = "workflowcatalog.jdbc.url";
+ public static final String WORKFLOWCATALOG_JDBC_USER = "workflowcatalog.jdbc.user";
+ public static final String WORKFLOWCATALOG_JDBC_PASSWORD = "workflowcatalog.jdbc.password";
+ 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;
+
+
+ public static void initializeDB() {
+// System.setProperty("appcatalog.initialize.state", "0");
+ try{
+ jdbcDriver = ServerSettings.getSetting(WORKFLOWCATALOG_JDBC_DRIVER);
+ jdbcURl = ServerSettings.getSetting(WORKFLOWCATALOG_JDBC_URL);
+ jdbcUser = ServerSettings.getSetting(WORKFLOWCATALOG_JDBC_USER);
+ jdbcPassword = ServerSettings.getSetting(WORKFLOWCATALOG_JDBC_PASSWORD);
+ jdbcURl = jdbcURl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword;
+ } catch (ApplicationSettingsException e) {
+ logger.error("Unable to read airavata server properties", e.getMessage());
+ }
+
+ 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(WORKFLOW, conn)) {
+ DatabaseCreator.createRegistryDatabase("database_scripts/workflowcatalog", conn);
+ logger.info("New Database created for Workflow Catalog !!! ");
+ } else {
+ logger.info("Database already created for Workflow 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);
+ }
+ }
+// System.setProperty("appcatalog.initialize.state", "1");
+ }
+
+ 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;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/airavata/blob/2d9fd253/modules/registry/registry-server/registry-api-stubs/pom.xml
----------------------------------------------------------------------
diff --git a/modules/registry/registry-server/registry-api-stubs/pom.xml b/modules/registry/registry-server/registry-api-stubs/pom.xml
new file mode 100644
index 0000000..818db67
--- /dev/null
+++ b/modules/registry/registry-server/registry-api-stubs/pom.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+ <parent>
+ <artifactId>registry-server</artifactId>
+ <groupId>org.apache.airavata</groupId>
+ <version>0.17-SNAPSHOT</version>
+ </parent>
+ <modelVersion>4.0.0</modelVersion>
+
+ <artifactId>registry-api-stubs</artifactId>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.thrift</groupId>
+ <artifactId>libthrift</artifactId>
+ <version>${thrift.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.airavata</groupId>
+ <artifactId>airavata-data-models</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+</project>
\ No newline at end of file