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
