Refactor dblib

Changed openecomp references in dblib, filters and sli to onap.  Note: these
must be committed together to get a clean compile.

Issue: CCSDK-11
Change-Id: Ibe0f64fb20f3ae9cdda2f7ea969ca722bbde0d15
Signed-off-by: Dan Timoney <dtimoney@att.com>

1 files changed, 390 insertions, 0 deletions

diff --git a/dblib/provider/src/main/java/org/onap/ccsdk/sli/core/dblib/DBLibConnection.java b/dblib/provider/src/main/java/org/onap/ccsdk/sli/core/dblib/DBLibConnection.java
new file mode 100644
index 00000000..8181b130
--- /dev/null
+++ b/dblib/provider/src/main/java/org/onap/ccsdk/sli/core/dblib/DBLibConnection.java
@@ -0,0 +1,390 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * onap
+ * ================================================================================
+ * Copyright (C) 2016 - 2017 ONAP
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.ccsdk.sli.core.dblib;
+
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.CallableStatement;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.NClob;
+import java.sql.PreparedStatement;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Struct;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.Executor;
+
+import javax.sql.rowset.CachedRowSet;
+
+import org.apache.tomcat.jdbc.pool.PooledConnection;
+import org.apache.tomcat.jdbc.pool.ProxyConnection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DBLibConnection implements Connection {
+
+	private static Logger LOGGER = LoggerFactory.getLogger(DBLibConnection.class);
+
+	private final Connection connection;
+	private final CachedDataSource dataSource;
+	private boolean locked = false;
+	private String tableName = null;
+
+	public DBLibConnection(Connection con, CachedDataSource dataSource){
+		this.connection = con;
+		this.dataSource = dataSource;
+		locked = false;
+		dataSource.getPoolInfo(true);
+	}
+
+	public boolean lockTable(String tablename) {
+		this.tableName = tablename;
+		return locked = dataSource.lockTable(connection, tableName);
+	}
+
+	public void resetInactivityTimer() {
+		Class<org.apache.tomcat.jdbc.pool.PooledConnection> iface = PooledConnection.class;
+		try {
+			PooledConnection pc = connection.unwrap(iface);
+			pc.setTimestamp(System.currentTimeMillis());
+		} catch (SQLException e) {
+			LOGGER.warn("Failed resetting timeout timer", e);
+		}
+	}
+
+	public boolean unlock() {
+		dataSource.unlockTable(connection);
+		return locked = false;
+	}
+
+	public boolean writeData(String statement, ArrayList<String> arguments) throws SQLException, Throwable
+	{
+		ArrayList<Object> newList=new ArrayList<Object>();
+		if(arguments != null && !arguments.isEmpty()) {
+			newList.addAll(arguments);
+		}
+		resetInactivityTimer();
+		return dataSource.executeUpdatePreparedStatement(connection, statement, newList, false);
+	}
+
+	public CachedRowSet getData(String statement, ArrayList<String> arguments) throws SQLException, Throwable
+	{
+		ArrayList<Object> newList=new ArrayList<Object>();
+		if(arguments != null && !arguments.isEmpty()) {
+			newList.addAll(arguments);
+		}
+		resetInactivityTimer();
+		return dataSource.executePreparedStatement(connection, statement, newList, false);
+	}
+
+	@Override
+	public <T> T unwrap(Class<T> iface) throws SQLException {
+		return connection.unwrap(iface);
+	}
+
+	@Override
+	public boolean isWrapperFor(Class<?> iface) throws SQLException {
+		return connection.isWrapperFor(iface);
+	}
+
+	@Override
+	public Statement createStatement() throws SQLException {
+		return connection.createStatement();
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql) throws SQLException {
+		return connection.prepareStatement(sql);
+	}
+
+	@Override
+	public CallableStatement prepareCall(String sql) throws SQLException {
+		return connection.prepareCall(sql);
+	}
+
+	@Override
+	public String nativeSQL(String sql) throws SQLException {
+		return connection.nativeSQL(sql);
+	}
+
+	@Override
+	public void setAutoCommit(boolean autoCommit) throws SQLException {
+		connection.setAutoCommit(autoCommit);
+	}
+
+	@Override
+	public boolean getAutoCommit() throws SQLException {
+		return connection.getAutoCommit();
+	}
+
+	@Override
+	public void commit() throws SQLException {
+		connection.commit();
+	}
+
+	@Override
+	public void rollback() throws SQLException {
+		connection.rollback();
+	}
+
+	@Override
+	public void close() throws SQLException {
+		if(this.locked) {
+			try {
+				this.unlock();
+			} catch(Throwable th) {
+				LOGGER.error("Failed unlocking",th);
+			}
+		}
+		if(connection != null && !connection.isClosed()) {
+			connection.close();
+		}
+		dataSource.getPoolInfo(false);
+	}
+
+	@Override
+	public boolean isClosed() throws SQLException {
+		return connection.isClosed();
+	}
+
+	@Override
+	public DatabaseMetaData getMetaData() throws SQLException {
+		return connection.getMetaData();
+	}
+
+	@Override
+	public void setReadOnly(boolean readOnly) throws SQLException {
+		connection.setReadOnly(readOnly);
+	}
+
+	@Override
+	public boolean isReadOnly() throws SQLException {
+		return connection.isReadOnly();
+	}
+
+	@Override
+	public void setCatalog(String catalog) throws SQLException {
+		connection.setCatalog(catalog);
+	}
+
+	@Override
+	public String getCatalog() throws SQLException {
+		return connection.getCatalog();
+	}
+
+	@Override
+	public void setTransactionIsolation(int level) throws SQLException {
+		connection.setTransactionIsolation(level);
+	}
+
+	@Override
+	public int getTransactionIsolation() throws SQLException {
+		return connection.getTransactionIsolation();
+	}
+
+	@Override
+	public SQLWarning getWarnings() throws SQLException {
+		return connection.getWarnings();
+	}
+
+	@Override
+	public void clearWarnings() throws SQLException {
+		connection.clearWarnings();
+	}
+
+	@Override
+	public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+		return connection.createStatement(resultSetType, resultSetConcurrency);
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
+			throws SQLException {
+		return connection.prepareStatement(sql, resultSetType, resultSetConcurrency);
+	}
+
+	@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+		return connection.prepareCall(sql, resultSetType, resultSetConcurrency);
+	}
+
+	@Override
+	public Map<String, Class<?>> getTypeMap() throws SQLException {
+		return connection.getTypeMap();
+	}
+
+	@Override
+	public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+		connection.setTypeMap(map);
+	}
+
+	@Override
+	public void setHoldability(int holdability) throws SQLException {
+		connection.setHoldability(holdability);
+	}
+
+	@Override
+	public int getHoldability() throws SQLException {
+		return connection.getHoldability();
+	}
+
+	@Override
+	public Savepoint setSavepoint() throws SQLException {
+		return connection.setSavepoint();
+	}
+
+	@Override
+	public Savepoint setSavepoint(String name) throws SQLException {
+		return connection.setSavepoint(name);
+	}
+
+	@Override
+	public void rollback(Savepoint savepoint) throws SQLException {
+		connection.rollback(savepoint);
+	}
+
+	@Override
+	public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+		connection.releaseSavepoint(savepoint);
+	}
+
+	@Override
+	public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		return connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability) throws SQLException {
+		return connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	@Override
+	public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability) throws SQLException {
+		return connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+		return connection.prepareStatement(sql, autoGeneratedKeys);
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+		return connection.prepareStatement(sql, columnIndexes);
+	}
+
+	@Override
+	public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+		return connection.prepareStatement(sql, columnNames);
+	}
+
+	@Override
+	public Clob createClob() throws SQLException {
+		return connection.createClob();
+	}
+
+	@Override
+	public Blob createBlob() throws SQLException {
+		return connection.createBlob();
+	}
+
+	@Override
+	public NClob createNClob() throws SQLException {
+		return connection.createNClob();
+	}
+
+	@Override
+	public SQLXML createSQLXML() throws SQLException {
+		return connection.createSQLXML();
+	}
+
+	@Override
+	public boolean isValid(int timeout) throws SQLException {
+		return connection.isValid(timeout);
+	}
+
+	@Override
+	public void setClientInfo(String name, String value) throws SQLClientInfoException {
+		connection.setClientInfo(name, value);
+	}
+
+	@Override
+	public void setClientInfo(Properties properties) throws SQLClientInfoException {
+		connection.setClientInfo(properties);
+	}
+
+	@Override
+	public String getClientInfo(String name) throws SQLException {
+		return connection.getClientInfo(name);
+	}
+
+	@Override
+	public Properties getClientInfo() throws SQLException {
+		return connection.getClientInfo();
+	}
+
+	@Override
+	public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
+		return connection.createArrayOf(typeName, elements);
+	}
+
+	@Override
+	public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
+		return connection.createStruct(typeName, attributes);
+	}
+
+	@Override
+	public void setSchema(String schema) throws SQLException {
+		connection.setSchema(schema);
+	}
+
+	@Override
+	public String getSchema() throws SQLException {
+		return connection.getSchema();
+	}
+
+	@Override
+	public void abort(Executor executor) throws SQLException {
+		connection.abort(executor);
+	}
+
+	@Override
+	public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
+		connection.setNetworkTimeout(executor, milliseconds);
+	}
+
+	@Override
+	public int getNetworkTimeout() throws SQLException {
+		return connection.getNetworkTimeout();
+	}
+
+}