Include impacted changes for APPC-346,APPC-348

Issue-ID: APPC-347
Change-Id: I399bc2a1e0dfd481e103032a373bb80fce5baf41
Signed-off-by: Anand <ac204h@att.com>

10 files changed, 607 insertions, 536 deletions

diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/inmemory/LockManagerInMemoryImpl.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/inmemory/LockManagerInMemoryImpl.java
index b141d9607..140d9ebbc 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/inmemory/LockManagerInMemoryImpl.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/inmemory/LockManagerInMemoryImpl.java
@@ -38,7 +38,7 @@ public class LockManagerInMemoryImpl implements LockManager {
     private static LockManagerInMemoryImpl instance = null;
     private Map<String, LockValue> lockedVNFs;
 
-    private static final EELFLogger debugLogger = EELFManager.getInstance().getDebugLogger();
+    private final EELFLogger debugLogger = EELFManager.getInstance().getDebugLogger();
 
     private LockManagerInMemoryImpl() {
         lockedVNFs = new ConcurrentHashMap<>();
@@ -110,7 +110,12 @@ public class LockManagerInMemoryImpl implements LockManager {
 
     @Override
     public boolean isLocked(String resource) {
-        return lockedVNFs.get(resource)!=null?true:false;
+        return lockedVNFs.get(resource) != null;
+    }
+
+    @Override
+    public String getLockOwner(String resource) {
+        return lockedVNFs.get(resource).getOwner();
     }
 
     private boolean lockIsMine(LockValue lockValue, String owner, long now) {
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/JdbcLockManager.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/JdbcLockManager.java
index 9b2083101..b8cf0f741 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/JdbcLockManager.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/JdbcLockManager.java
@@ -26,7 +26,8 @@ package org.onap.appc.lockmanager.impl.sql;
 
 import java.sql.Connection;
 
-import org.onap.appc.dao.util.JdbcConnectionFactory;
+
+import org.onap.appc.dao.util.api.JdbcConnectionFactory;
 import org.onap.appc.lockmanager.api.LockManager;
 
 public abstract class JdbcLockManager implements LockManager {
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/Messages.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/Messages.java
index 769d94257..4f2831157 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/Messages.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/Messages.java
@@ -27,7 +27,7 @@ package org.onap.appc.lockmanager.impl.sql;
 public enum Messages {
 
     ERR_NULL_LOCK_OWNER("Cannot acquire lock for resource [%s]: lock owner must be specified"),
-    ERR_LOCK_LOCKED_BY_OTHER("Cannot lock resource [%s] for [%s]: already locked by [%s]"),
+    ERR_LOCK_LOCKED_BY_OTHER("VNF : [%s] is locked by request id : [%s]"),
     ERR_UNLOCK_NOT_LOCKED("Error unlocking resource [%s]: resource is not locked"),
     ERR_UNLOCK_LOCKED_BY_OTHER("Error unlocking resource [%s] by [%s]: resource is locked by [%s]"),
     EXP_LOCK("Error locking resource [%s]."),
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/MySqlConnectionFactory.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/MySqlConnectionFactory.java
index 4df89541d..7f91d21cd 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/MySqlConnectionFactory.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/MySqlConnectionFactory.java
@@ -32,6 +32,8 @@ import org.onap.appc.dao.util.DefaultJdbcConnectionFactory;
 public class MySqlConnectionFactory extends DefaultJdbcConnectionFactory {
 
     protected void registedDriver() throws SQLException {
-        DriverManager.registerDriver(new org.mariadb.jdbc.Driver());
+    DriverManager.registerDriver(new org.mariadb.jdbc.Driver());
+    
     }
+
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/LockRecord.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/LockRecord.java
index ff0e63b8d..94e656d2d 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/LockRecord.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/LockRecord.java
@@ -26,49 +26,49 @@ package org.onap.appc.lockmanager.impl.sql.optimistic;
 
 class LockRecord {
 
-	private String resource;
-	private String owner;
-	private long updated;
-	private long timeout;
-	private long ver;
+    private String resource;
+    private String owner;
+    private long updated;
+    private long timeout;
+    private long ver;
 
-	LockRecord(String resource) {
-		this.resource = resource;
-	}
+    LockRecord(String resource) {
+        this.resource = resource;
+    }
 
-	public String getResource() {
-		return resource;
-	}
+    public String getResource() {
+        return resource;
+    }
 
-	public String getOwner() {
-		return owner;
-	}
+    public String getOwner() {
+        return owner;
+    }
 
-	public void setOwner(String owner) {
-		this.owner = owner;
-	}
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
 
-	public long getUpdated() {
-		return updated;
-	}
+    public long getUpdated() {
+        return updated;
+    }
 
-	public void setUpdated(long updated) {
-		this.updated = updated;
-	}
+    public void setUpdated(long updated) {
+        this.updated = updated;
+    }
 
-	public long getTimeout() {
-		return timeout;
-	}
+    public long getTimeout() {
+        return timeout;
+    }
 
-	public void setTimeout(long timeout) {
-		this.timeout = timeout;
-	}
+    public void setTimeout(long timeout) {
+        this.timeout = timeout;
+    }
 
-	public long getVer() {
-		return ver;
-	}
+    public long getVer() {
+        return ver;
+    }
 
-	public void setVer(long ver) {
-		this.ver = ver;
-	}
+    public void setVer(long ver) {
+        this.ver = ver;
+    }
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/MySqlLockManager.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/MySqlLockManager.java
index d1dd2c5a3..1cbc1fb04 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/MySqlLockManager.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/MySqlLockManager.java
@@ -28,8 +28,10 @@ import java.sql.SQLException;
 
 public class MySqlLockManager extends SqlLockManager {
 
-	@Override
-	protected boolean isDuplicatePkError(SQLException e) {
-		return (e.getErrorCode() == 1062);
-	}
+    @Override
+    protected boolean isDuplicatePkError(SQLException e) {
+        return (e.getErrorCode() == 1062);
+    }
+
+
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/SqlLockManager.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/SqlLockManager.java
index 26ec6a274..481350199 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/SqlLockManager.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/optimistic/SqlLockManager.java
@@ -36,231 +36,271 @@ import org.onap.appc.lockmanager.impl.sql.Messages;
 
 abstract class SqlLockManager extends JdbcLockManager {
 
-	private static final String SQL_LOAD_LOCK_RECORD = "SELECT * FROM %s WHERE RESOURCE_ID=?";
-	private static final String SQL_INSERT_LOCK_RECORD = "INSERT INTO %s (RESOURCE_ID, OWNER_ID, UPDATED, TIMEOUT, VER) VALUES (?, ?, ?, ?, ?)";
-	private static final String SQL_UPDATE_LOCK_RECORD = "UPDATE %s SET OWNER_ID=?, UPDATED=?, TIMEOUT=?, VER=? WHERE RESOURCE_ID=? AND VER=?";
-//	private static final String SQL_DELETE_LOCK_RECORD = "DELETE FROM %s WHERE RESOURCE_ID=? AND VER=?";
-	private static final String SQL_CURRENT_TIMESTAMP = "SELECT CURRENT_TIMESTAMP()";
+    private static final String SQL_LOAD_LOCK_RECORD = "SELECT * FROM %s WHERE RESOURCE_ID=?";
+    private static final String SQL_INSERT_LOCK_RECORD = "INSERT INTO %s (RESOURCE_ID, OWNER_ID, UPDATED, TIMEOUT, VER) VALUES (?, ?, ?, ?, ?)";
+    private static final String SQL_UPDATE_LOCK_RECORD = "UPDATE %s SET OWNER_ID=?, UPDATED=?, TIMEOUT=?, VER=? WHERE RESOURCE_ID=? AND VER=?";
+//    private static final String SQL_DELETE_LOCK_RECORD = "DELETE FROM %s WHERE RESOURCE_ID=? AND VER=?";
+    private static final String SQL_CURRENT_TIMESTAMP = "SELECT CURRENT_TIMESTAMP()";
+    private static final String SQL_LOAD_LOCK_RECORD_WITH_OWNER = "SELECT * FROM LOCK_MANAGEMENT WHERE RESOURCE_ID = ? AND OWNER = ? ";
 
-	private String sqlLoadLockRecord;
-	private String sqlInsertLockRecord;
-	private String sqlUpdateLockRecord;
-//	private String sqlDeleteLockRecord;
+    private String sqlLoadLockRecord;
+    private String sqlInsertLockRecord;
+    private String sqlUpdateLockRecord;
+//    private String sqlDeleteLockRecord;
 
-	@Override
-	public boolean acquireLock(String resource, String owner) throws LockException {
-		return acquireLock(resource, owner, 0);
-	}
+    @Override
+    public boolean acquireLock(String resource, String owner) throws LockException {
+        return acquireLock(resource, owner, 0);
+    }
 
-	@Override
-	public boolean acquireLock(String resource, String owner, long timeout) throws LockException {
-		if(owner == null) {
-			throw new LockRuntimeException(Messages.ERR_NULL_LOCK_OWNER.format(resource));
-		}
-		boolean res = false;
-		Connection connection = openDbConnection();
-		try {
-			res = lockResource(connection, resource, owner, timeout);
-		} finally {
-			closeDbConnection(connection);
-		}
-		return res;
-	}
+    @Override
+    public boolean acquireLock(String resource, String owner, long timeout) throws LockException {
+        if(owner == null) {
+            throw new LockRuntimeException(Messages.ERR_NULL_LOCK_OWNER.format(resource));
+        }
+        boolean res = false;
+        Connection connection = openDbConnection();
+        try {
+            res = lockResource(connection, resource, owner, timeout);
+        } finally {
+            closeDbConnection(connection);
+        }
+        return res;
+    }
 
-	@Override
-	public void releaseLock(String resource, String owner) throws LockException {
-		Connection connection = openDbConnection();
-		try {
-			unlockResource(connection, resource, owner);
-		} finally {
-			closeDbConnection(connection);
-		}
-	}
+    @Override
+    public void releaseLock(String resource, String owner) throws LockException {
+        Connection connection = openDbConnection();
+        try {
+            unlockResource(connection, resource, owner);
+        } finally {
+            closeDbConnection(connection);
+        }
+    }
 
-	@Override
-	public boolean isLocked(String resource) {
+    @Override
+    public boolean isLocked(String resource) {
         Connection connection=openDbConnection();
-		try {
-			LockRecord lockRecord=loadLockRecord(connection,resource);
-			if(lockRecord==null){
-				return false;
-			}else{
-				if(lockRecord.getOwner()==null){
-					return false;
-				}else if(isLockExpired(lockRecord, connection)){
-					return false;
-				}else{
+        try {
+            LockRecord lockRecord=loadLockRecord(connection,resource);
+            if(lockRecord==null){
+                return false;
+            }else{
+                if(lockRecord.getOwner()==null){
+                    return false;
+                }else if(isLockExpired(lockRecord, connection)){
+                    return false;
+                }else{
                     return true;
                 }
-			}
-		} catch (SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
-		}finally {
+            }
+        } catch (SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
+        }finally {
             closeDbConnection(connection);
         }
     }
 
-	private boolean lockResource(Connection connection, String resource, String owner, long timeout) throws LockException {
-		try {
-			boolean res = false;
-			LockRecord lockRecord = loadLockRecord(connection, resource);
-			if(lockRecord != null) {
-				// lock record already exists
-				String currentOwner = lockRecord.getOwner();
-				if(currentOwner != null) {
-					if(isLockExpired(lockRecord, connection)) {
-						currentOwner = null;
-					} else if(!owner.equals(currentOwner)) {
-						throw new LockException(Messages.ERR_LOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
-					}
-				}
-				// set new owner on the resource lock record
-				if(!updateLockRecord(connection, resource, owner, timeout, lockRecord.getVer())) {
-					// try again - maybe same owner updated the record
-					lockResource(connection, resource, owner, timeout);
-				}
-				if(currentOwner == null) {
-					// no one locked the resource before
-					res = true;
-				}
-			} else {
-				// resource record does not exist in lock table => create new record
-				try {
-					addLockRecord(connection, resource, owner, timeout);
-					res = true;
-				} catch(SQLException e) {
-					if(isDuplicatePkError(e)) {
-						// try again - maybe same owner inserted the record
-						lockResource(connection, resource, owner, timeout);
-					} else {
-						throw e;
-					}
-				}
-			}
-			return res;
-		} catch(SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_LOCK.format(resource), e);
-		}
-	}
+    @Override
+    public String getLockOwner(String resource) {
+        Connection connection=openDbConnection();
+        try {
+            LockRecord lockRecord=loadLockRecord(connection,resource);
+            if(lockRecord==null || lockRecord.getOwner() ==null ){
+                return null;
+            }else{
+                if(isLockExpired(lockRecord, connection)){
+                    return null;
+                }else{
+                    return lockRecord.getOwner();
+                }
+            }
+        } catch (SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
+        }finally {
+            closeDbConnection(connection);
+        }
+    }
 
-	protected boolean isDuplicatePkError(SQLException e) {
-		return e.getSQLState().startsWith("23");
-	}
+    private boolean lockResource(Connection connection, String resource, String owner, long timeout) throws LockException {
+        try {
+            boolean res = false;
+            LockRecord lockRecord = loadLockRecord(connection, resource);
+            if(lockRecord != null) {
+                // lock record already exists
+                String currentOwner = lockRecord.getOwner();
+                if(currentOwner != null) {
+                    if(isLockExpired(lockRecord, connection)) {
+                        currentOwner = null;
+                    } else if(!owner.equals(currentOwner)) {
+                        throw new LockException(Messages.ERR_LOCK_LOCKED_BY_OTHER.format(resource, currentOwner));
+                    }
+                }
+                // set new owner on the resource lock record
+                if(!updateLockRecord(connection, resource, owner, timeout, lockRecord.getVer())) {
+                    // try again - maybe same owner updated the record
+                    lockResource(connection, resource, owner, timeout);
+                }
+                if(currentOwner == null) {
+                    // no one locked the resource before
+                    res = true;
+                }
+            } else {
+                // resource record does not exist in lock table => create new record
+                try {
+                    addLockRecord(connection, resource, owner, timeout);
+                    res = true;
+                } catch(SQLException e) {
+                    if(isDuplicatePkError(e)) {
+                        // try again - maybe same owner inserted the record
+                        lockResource(connection, resource, owner, timeout);
+                    } else {
+                        throw e;
+                    }
+                }
+            }
+            return res;
+        } catch(SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_LOCK.format(resource), e);
+        }
+    }
+
+    protected boolean isDuplicatePkError(SQLException e) {
+        return e.getSQLState().startsWith("23");
+    }
 
-	private void unlockResource(Connection connection, String resource, String owner) throws LockException {
-		try {
-			LockRecord lockRecord = loadLockRecord(connection, resource);
-			if(lockRecord != null) {
-				// check if expired
-				if(isLockExpired(lockRecord, connection)) {
-					// lock is expired => no lock
-					lockRecord = null;
-				}
-			}
-			if((lockRecord == null) || (lockRecord.getOwner() == null)) {
-				// resource is not locked
-				throw new LockException(Messages.ERR_UNLOCK_NOT_LOCKED.format(resource));
-			}
-			String currentOwner = lockRecord.getOwner();
-			if(!owner.equals(currentOwner)) {
-				throw new LockException(Messages.ERR_UNLOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
+    private void unlockResource(Connection connection, String resource, String owner) throws LockException {
+        try {
+            LockRecord lockRecord = loadLockRecord(connection, resource);
+            if(lockRecord != null) {
+                // check if expired
+                if(isLockExpired(lockRecord, connection)) {
+                    // lock is expired => no lock
+                    lockRecord = null;
+                }
+            }
+            if((lockRecord == null) || (lockRecord.getOwner() == null)) {
+                // resource is not locked
+                throw new LockException(Messages.ERR_UNLOCK_NOT_LOCKED.format(resource));
+            }
+            String currentOwner = lockRecord.getOwner();
+            if(!owner.equals(currentOwner)) {
+                throw new LockException(Messages.ERR_UNLOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
             }
             if (!updateLockRecord(connection, resource, null, 0, lockRecord.getVer())) {
-				unlockResource(connection, resource, owner);
-			}
-			// TODO delete record from table on lock release?
-//			deleteLockRecord(connection, resource, lockRecord.getVer());
-		} catch(SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_UNLOCK.format(resource), e);
-		}
-	}
+                unlockResource(connection, resource, owner);
+            }
+            // TODO delete record from table on lock release?
+//            deleteLockRecord(connection, resource, lockRecord.getVer());
+        } catch(SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_UNLOCK.format(resource), e);
+        }
+    }
 
-	protected LockRecord loadLockRecord(Connection connection, String resource) throws SQLException {
-		LockRecord res = null;
-		if(sqlLoadLockRecord == null) {
-			sqlLoadLockRecord = String.format(SQL_LOAD_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlLoadLockRecord)) {
-			statement.setString(1, resource);
-			try(ResultSet resultSet = statement.executeQuery()) {
-				if(resultSet.next()) {
-					res = new LockRecord(resource);
-					res.setOwner(resultSet.getString(2));
-					res.setUpdated(resultSet.getLong(3));
-					res.setTimeout(resultSet.getLong(4));
-					res.setVer(resultSet.getLong(5));
-				}
-			}
-		}
-		return res;
-	}
+    protected LockRecord loadLockRecord(Connection connection, String resource) throws SQLException {
+        LockRecord res = null;
+        if(sqlLoadLockRecord == null) {
+            sqlLoadLockRecord = String.format(SQL_LOAD_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlLoadLockRecord)) {
+            statement.setString(1, resource);
+            try(ResultSet resultSet = statement.executeQuery()) {
+                if(resultSet.next()) {
+                    res = new LockRecord(resource);
+                    res.setOwner(resultSet.getString(2));
+                    res.setUpdated(resultSet.getLong(3));
+                    res.setTimeout(resultSet.getLong(4));
+                    res.setVer(resultSet.getLong(5));
+                }
+            }
+        }
+        return res;
+    }
+
+    protected LockRecord loadLockRecord(Connection connection, String resource,String owner) throws SQLException {
+        LockRecord res = null;
+        try(PreparedStatement statement = connection.prepareStatement(SQL_LOAD_LOCK_RECORD_WITH_OWNER)) {
+            statement.setString(1, resource);
+            statement.setString(2, owner);
+            try(ResultSet resultSet = statement.executeQuery()) {
+                if(resultSet.next()) {
+                    res = new LockRecord(resource);
+                    res.setOwner(resultSet.getString(2));
+                    res.setUpdated(resultSet.getLong(3));
+                    res.setTimeout(resultSet.getLong(4));
+                    res.setVer(resultSet.getLong(5));
+                }
+            }
+        }
+        return res;
+    }
 
-	protected void addLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
-		if(sqlInsertLockRecord == null) {
-			sqlInsertLockRecord = String.format(SQL_INSERT_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlInsertLockRecord)) {
-			statement.setString(1, resource);
-			statement.setString(2, owner);
+    protected void addLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
+        if(sqlInsertLockRecord == null) {
+            sqlInsertLockRecord = String.format(SQL_INSERT_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlInsertLockRecord)) {
+            statement.setString(1, resource);
+            statement.setString(2, owner);
             statement.setLong(3, getCurrentTime(connection));
-			statement.setLong(4, timeout);
-			statement.setLong(5, 1);
-			statement.executeUpdate();
-		}
-	}
+            statement.setLong(4, timeout);
+            statement.setLong(5, 1);
+            statement.executeUpdate();
+        }
+    }
 
-	protected boolean updateLockRecord(Connection connection, String resource, String owner, long timeout, long ver) throws SQLException {
-		if(sqlUpdateLockRecord == null) {
-			sqlUpdateLockRecord = String.format(SQL_UPDATE_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlUpdateLockRecord)) {
-			long newVer = (ver >= Long.MAX_VALUE) ? 1 : (ver + 1);
-			statement.setString(1, owner);
+    protected boolean updateLockRecord(Connection connection, String resource, String owner, long timeout, long ver) throws SQLException {
+        if(sqlUpdateLockRecord == null) {
+            sqlUpdateLockRecord = String.format(SQL_UPDATE_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlUpdateLockRecord)) {
+            long newVer = (ver >= Long.MAX_VALUE) ? 1 : (ver + 1);
+            statement.setString(1, owner);
             statement.setLong(2, getCurrentTime(connection));
-			statement.setLong(3, timeout);
-			statement.setLong(4, newVer);
-			statement.setString(5, resource);
-			statement.setLong(6, ver);
-			return (statement.executeUpdate() != 0);
-		}
-	}
+            statement.setLong(3, timeout);
+            statement.setLong(4, newVer);
+            statement.setString(5, resource);
+            statement.setLong(6, ver);
+            return (statement.executeUpdate() != 0);
+        }
+    }
 
-//	protected void deleteLockRecord(Connection connection, String resource, long ver) throws SQLException {
-//		if(sqlDeleteLockRecord == null) {
-//			sqlDeleteLockRecord = String.format(SQL_DELETE_LOCK_RECORD, tableName);
-//		}
-//		try(PreparedStatement statement = connection.prepareStatement(sqlDeleteLockRecord)) {
-//			statement.setString(1, resource);
-//			statement.setLong(2, ver);
-//			statement.executeUpdate();
-//		}
-//	}
+//    protected void deleteLockRecord(Connection connection, String resource, long ver) throws SQLException {
+//        if(sqlDeleteLockRecord == null) {
+//            sqlDeleteLockRecord = String.format(SQL_DELETE_LOCK_RECORD, tableName);
+//        }
+//        try(PreparedStatement statement = connection.prepareStatement(sqlDeleteLockRecord)) {
+//            statement.setString(1, resource);
+//            statement.setLong(2, ver);
+//            statement.executeUpdate();
+//        }
+//    }
 
-	private boolean isLockExpired(LockRecord lockRecord, Connection connection) throws SQLException {
-		long timeout = lockRecord.getTimeout();
-		if(timeout == 0) {
-			return false;
-		}
-		long updated = lockRecord.getUpdated();
+    private boolean isLockExpired(LockRecord lockRecord, Connection connection) throws SQLException {
+        long timeout = lockRecord.getTimeout();
+        if(timeout == 0) {
+            return false;
+        }
+        long updated = lockRecord.getUpdated();
         long now = getCurrentTime(connection);
-		long expiration = updated + timeout;
-		return (now > expiration);
-	}
+        long expiration = updated + timeout;
+        return (now > expiration);
+    }
 
-	private long getCurrentTime(Connection connection) throws SQLException {
-		long res = -1;
-		if(connection != null) {
-			try(PreparedStatement statement = connection.prepareStatement(SQL_CURRENT_TIMESTAMP)) {
-				try(ResultSet resultSet = statement.executeQuery()) {
-					if(resultSet.next()) {
-						res = resultSet.getTimestamp(1).getTime();
-					}
-				}
-			}
-		}
-		if(res == -1) {
-			res = System.currentTimeMillis();
-		}
-		return res;
-	}
+    private long getCurrentTime(Connection connection) throws SQLException {
+        long res = -1;
+        if(connection != null) {
+            try(PreparedStatement statement = connection.prepareStatement(SQL_CURRENT_TIMESTAMP)) {
+                try(ResultSet resultSet = statement.executeQuery()) {
+                    if(resultSet.next()) {
+                        res = resultSet.getTimestamp(1).getTime();
+                    }
+                }
+            }
+        }
+        if(res == -1) {
+            res = System.currentTimeMillis();
+        }
+        return res;
+    }
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/LockRecord.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/LockRecord.java
index 1960ba9a3..3a3799697 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/LockRecord.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/LockRecord.java
@@ -26,40 +26,40 @@ package org.onap.appc.lockmanager.impl.sql.pessimistic;
 
 class LockRecord {
 
-	private String resource;
-	private String owner;
-	private long updated;
-	private long timeout;
+    private String resource;
+    private String owner;
+    private long updated;
+    private long timeout;
 
-	LockRecord(String resource) {
-		this.resource = resource;
-	}
+    LockRecord(String resource) {
+        this.resource = resource;
+    }
 
-	public String getResource() {
-		return resource;
-	}
+    public String getResource() {
+        return resource;
+    }
 
-	public String getOwner() {
-		return owner;
-	}
+    public String getOwner() {
+        return owner;
+    }
 
-	public void setOwner(String owner) {
-		this.owner = owner;
-	}
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
 
-	public long getUpdated() {
-		return updated;
-	}
+    public long getUpdated() {
+        return updated;
+    }
 
-	public void setUpdated(long updated) {
-		this.updated = updated;
-	}
+    public void setUpdated(long updated) {
+        this.updated = updated;
+    }
 
-	public long getTimeout() {
-		return timeout;
-	}
+    public long getTimeout() {
+        return timeout;
+    }
 
-	public void setTimeout(long timeout) {
-		this.timeout = timeout;
-	}
+    public void setTimeout(long timeout) {
+        this.timeout = timeout;
+    }
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/MySqlLockManager.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/MySqlLockManager.java
index b76f15c8f..5268acf20 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/MySqlLockManager.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/MySqlLockManager.java
@@ -33,56 +33,56 @@ import org.onap.appc.lockmanager.api.LockRuntimeException;
 
 public class MySqlLockManager extends SqlLockManager {
 
-	private static final int DEF_CRITICAL_SECTION_WAIT_TIMEOUT = 3;
+    private static final int DEF_CRITICAL_SECTION_WAIT_TIMEOUT = 3;
 
-	protected int criticalSectionWaitTimeoutSecs = DEF_CRITICAL_SECTION_WAIT_TIMEOUT;
+    protected int criticalSectionWaitTimeoutSecs = DEF_CRITICAL_SECTION_WAIT_TIMEOUT;
 
-	public void setCriticalSectionWaitTimeoutSecs(int criticalSectionWaitTimeoutSecs) {
-		this.criticalSectionWaitTimeoutSecs = criticalSectionWaitTimeoutSecs;
-	}
+    public void setCriticalSectionWaitTimeoutSecs(int criticalSectionWaitTimeoutSecs) {
+        this.criticalSectionWaitTimeoutSecs = criticalSectionWaitTimeoutSecs;
+    }
 
-	@Override
-	protected void enterCriticalSection(Connection connection, String resource) {
-		try {
-			CallableStatement statement = connection.prepareCall("SELECT COALESCE(GET_LOCK(?,?),0)");
-			try {
-				statement.setString(1, resource);
-				statement.setInt(2, criticalSectionWaitTimeoutSecs);
-				boolean execRes = statement.execute();
-				int result = 0;
-				if(execRes) {
-					ResultSet resultSet = statement.getResultSet();
-					try {
-						if(resultSet.next()) {
-							result = resultSet.getInt(1);
-						}
-					} finally {
-						resultSet.close();
-					}
-				}
-				if(result != 1) { // lock is not obtained
-					throw new LockRuntimeException("Cannot obtain critical section lock for resource [" + resource + "].");
-				}
-			} finally {
-				statement.close();
-			}
-		} catch(SQLException e) {
+    @Override
+    protected void enterCriticalSection(Connection connection, String resource) {
+        try {
+            CallableStatement statement = connection.prepareCall("SELECT COALESCE(GET_LOCK(?,?),0)");
+            try {
+                statement.setString(1, resource);
+                statement.setInt(2, criticalSectionWaitTimeoutSecs);
+                boolean execRes = statement.execute();
+                int result = 0;
+                if(execRes) {
+                    ResultSet resultSet = statement.getResultSet();
+                    try {
+                        if(resultSet.next()) {
+                            result = resultSet.getInt(1);
+                        }
+                    } finally {
+                        resultSet.close();
+                    }
+                }
+                if(result != 1) { // lock is not obtained
+                    throw new LockRuntimeException("Cannot obtain critical section lock for resource [" + resource + "].");
+                }
+            } finally {
+                statement.close();
+            }
+        } catch(SQLException e) {
             throw new LockRuntimeException("Cannot obtain critical section lock for resource [" + resource + "].", e);
-		}
-	}
+        }
+    }
 
-	@Override
-	protected void leaveCriticalSection(Connection connection, String resource) {
-		try {
-			CallableStatement statement = connection.prepareCall("SELECT RELEASE_LOCK(?)");
-			try {
-				statement.setString(1, resource);
-				statement.execute();
-			} finally {
-				statement.close();
-			}
-		} catch(SQLException e) {
-			throw new LockRuntimeException("Error releasing critical section lock.", e);
-		}
-	}
+    @Override
+    protected void leaveCriticalSection(Connection connection, String resource) {
+        try {
+            CallableStatement statement = connection.prepareCall("SELECT RELEASE_LOCK(?)");
+            try {
+                statement.setString(1, resource);
+                statement.execute();
+            } finally {
+                statement.close();
+            }
+        } catch(SQLException e) {
+            throw new LockRuntimeException("Error releasing critical section lock.", e);
+        }
+    }
 }
diff --git a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/SqlLockManager.java b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/SqlLockManager.java
index a1536d969..98c753616 100644
--- a/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/SqlLockManager.java
+++ b/appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/main/java/org/onap/appc/lockmanager/impl/sql/pessimistic/SqlLockManager.java
@@ -36,219 +36,240 @@ import org.onap.appc.lockmanager.impl.sql.Messages;
 
 abstract class SqlLockManager extends JdbcLockManager {
 
-	private static final String SQL_LOAD_LOCK_RECORD = "SELECT * FROM %s WHERE RESOURCE_ID=?";
-	private static final String SQL_INSERT_LOCK_RECORD = "INSERT INTO %s (RESOURCE_ID, OWNER_ID, UPDATED, TIMEOUT) VALUES (?, ?, ?, ?)";
-	private static final String SQL_UPDATE_LOCK_RECORD = "UPDATE %s SET OWNER_ID=?, UPDATED=?, TIMEOUT=? WHERE RESOURCE_ID=?";
-	private static final String SQL_CURRENT_TIMESTAMP = "SELECT CURRENT_TIMESTAMP()";
-
-	private String sqlLoadLockRecord;
-	private String sqlInsertLockRecord;
-	private String sqlUpdateLockRecord;
-
-	@Override
-	public boolean acquireLock(String resource, String owner) throws LockException {
-		return acquireLock(resource, owner, 0);
-	}
-
-	@Override
-	public boolean acquireLock(String resource, String owner, long timeout) throws LockException {
-		if(owner == null) {
-			throw new LockRuntimeException(Messages.ERR_NULL_LOCK_OWNER.format(resource));
-		}
-		boolean res = false;
-		Connection connection = openDbConnection();
-		try {
-			enterCriticalSection(connection, resource);
-			try {
-				res = lockResource(connection, resource, owner, timeout);
-			} finally {
-				leaveCriticalSection(connection, resource);
-			}
-		} finally {
-			closeDbConnection(connection);
-		}
-		return res;
-	}
-
-	@Override
-	public void releaseLock(String resource, String owner) throws LockException {
-		Connection connection = openDbConnection();
-		try {
-			enterCriticalSection(connection, resource);
-			try {
-				unlockResource(connection, resource, owner);
-			} finally {
-				leaveCriticalSection(connection, resource);
-			}
-		} finally {
-			closeDbConnection(connection);
-		}
-	}
-
-	@Override
-	public boolean isLocked(String resource) {
-		Connection connection=openDbConnection();
-		try {
-			LockRecord lockRecord=loadLockRecord(connection,resource);
-			if(lockRecord==null){
-				return false;
-			}else{
-				if(lockRecord.getOwner()==null){
-					return false;
-				}else if(isLockExpired(lockRecord, connection)){
-					return false;
-				}else{
-					return true;
-				}
-			}
-		} catch (SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
-		}finally {
-			closeDbConnection(connection);
-		}
-	}
-
-	private boolean lockResource(Connection connection, String resource, String owner, long timeout) throws LockException {
-		try {
-			boolean res = false;
-			LockRecord lockRecord = loadLockRecord(connection, resource);
-			if(lockRecord != null) {
-				// lock record already exists
-				String currentOwner = lockRecord.getOwner();
-				if(currentOwner != null) {
-					if(isLockExpired(lockRecord, connection)) {
-						currentOwner = null;
-					} else if(!owner.equals(currentOwner)) {
-						throw new LockException(Messages.ERR_LOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
-					}
-				}
-				// set new owner on the resource lock record
-				updateLockRecord(connection, resource, owner, timeout);
-				if(currentOwner == null) {
-					// no one locked the resource before
-					res = true;
-				}
-			} else {
-				// resource record does not exist in lock table => create new record
-				addLockRecord(connection, resource, owner, timeout);
-				res = true;
-			}
-			return res;
-		} catch(SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_LOCK.format(resource), e);
-		}
-	}
-
-	private void unlockResource(Connection connection, String resource, String owner) throws LockException {
-		try {
-			LockRecord lockRecord = loadLockRecord(connection, resource);
-			if(lockRecord != null) {
-				// check if expired
-				if(isLockExpired(lockRecord, connection)) {
-					// lock is expired => no lock
-					lockRecord = null;
-				}
-			}
-			if((lockRecord == null) || (lockRecord.getOwner() == null)) {
-				// resource is not locked
-				throw new LockException(Messages.ERR_UNLOCK_NOT_LOCKED.format(resource));
-			}
-			String currentOwner = lockRecord.getOwner();
-			if(!owner.equals(currentOwner)) {
-				throw new LockException(Messages.ERR_UNLOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
-			}
-			updateLockRecord(connection, resource, null, 0);
-			// TODO delete record from table on lock release?
-//			deleteLockRecord(connection, resource);
-		} catch(SQLException e) {
-			throw new LockRuntimeException(Messages.EXP_UNLOCK.format(resource), e);
-		}
-	}
-
-	protected abstract void enterCriticalSection(Connection connection, String resource);
-
-	protected abstract void leaveCriticalSection(Connection connection, String resource);
-
-	protected LockRecord loadLockRecord(Connection connection, String resource) throws SQLException {
-		LockRecord res = null;
-		if(sqlLoadLockRecord == null) {
-			sqlLoadLockRecord = String.format(SQL_LOAD_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlLoadLockRecord)) {
-			statement.setString(1, resource);
-			try(ResultSet resultSet = statement.executeQuery()) {
-				if(resultSet.next()) {
-					res = new LockRecord(resource);
-					res.setOwner(resultSet.getString(2));
-					res.setUpdated(resultSet.getLong(3));
-					res.setTimeout(resultSet.getLong(4));
-				}
-			}
-		}
-		return res;
-	}
-
-	protected void addLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
-		if(sqlInsertLockRecord == null) {
-			sqlInsertLockRecord = String.format(SQL_INSERT_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlInsertLockRecord)) {
-			statement.setString(1, resource);
-			statement.setString(2, owner);
-			statement.setLong(3, getCurrentTime(connection));
-			statement.setLong(4, timeout);
-			statement.executeUpdate();
-		}
-	}
-
-	protected void updateLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
-		if(sqlUpdateLockRecord == null) {
-			sqlUpdateLockRecord = String.format(SQL_UPDATE_LOCK_RECORD, tableName);
-		}
-		try(PreparedStatement statement = connection.prepareStatement(sqlUpdateLockRecord)) {
-			statement.setString(1, owner);
-			statement.setLong(2, getCurrentTime(connection));
-			statement.setLong(3, timeout);
-			statement.setString(4, resource);
-			statement.executeUpdate();
-		}
-	}
-
-//	protected void deleteLockRecord(Connection connection, String resource) throws SQLException {
-//		if(sqlDeleteLockRecord == null) {
-//			sqlDeleteLockRecord = String.format(SQL_DELETE_LOCK_RECORD, tableName);
-//		}
-//		try(PreparedStatement statement = connection.prepareStatement(sqlDeleteLockRecord)) {
-//			statement.setString(1, resource);
-//			statement.executeUpdate();
-//		}
-//	}
-
-	private boolean isLockExpired(LockRecord lockRecord, Connection connection) throws SQLException {
-		long timeout = lockRecord.getTimeout();
-		if(timeout == 0) {
-			return false;
-		}
-		long updated = lockRecord.getUpdated();
-		long now = getCurrentTime(connection);
-		long expiration = updated + timeout;
-		return (now > expiration);
-	}
-
-	private long getCurrentTime(Connection connection) throws SQLException {
-		long res = -1;
-		if(connection != null) {
-			try(PreparedStatement statement = connection.prepareStatement(SQL_CURRENT_TIMESTAMP)) {
-				try(ResultSet resultSet = statement.executeQuery()) {
-					if(resultSet.next()) {
-						res = resultSet.getTimestamp(1).getTime();
-					}
-				}
-			}
-		}
-		if(res == -1) {
-			res = System.currentTimeMillis();
-		}
-		return res;
-	}
+    private static final String SQL_LOAD_LOCK_RECORD = "SELECT * FROM %s WHERE RESOURCE_ID=?";
+    private static final String SQL_INSERT_LOCK_RECORD = "INSERT INTO %s (RESOURCE_ID, OWNER_ID, UPDATED, TIMEOUT) VALUES (?, ?, ?, ?)";
+    private static final String SQL_UPDATE_LOCK_RECORD = "UPDATE %s SET OWNER_ID=?, UPDATED=?, TIMEOUT=? WHERE RESOURCE_ID=?";
+    private static final String SQL_CURRENT_TIMESTAMP = "SELECT CURRENT_TIMESTAMP()";
+
+    private String sqlLoadLockRecord;
+    private String sqlInsertLockRecord;
+    private String sqlUpdateLockRecord;
+
+    @Override
+    public boolean acquireLock(String resource, String owner) throws LockException {
+        return acquireLock(resource, owner, 0);
+    }
+
+    @Override
+    public boolean acquireLock(String resource, String owner, long timeout) throws LockException {
+        if(owner == null) {
+            throw new LockRuntimeException(Messages.ERR_NULL_LOCK_OWNER.format(resource));
+        }
+        boolean res = false;
+        Connection connection = openDbConnection();
+        try {
+            enterCriticalSection(connection, resource);
+            try {
+                res = lockResource(connection, resource, owner, timeout);
+            } finally {
+                leaveCriticalSection(connection, resource);
+            }
+        } finally {
+            closeDbConnection(connection);
+        }
+        return res;
+    }
+
+    @Override
+    public void releaseLock(String resource, String owner) throws LockException {
+        Connection connection = openDbConnection();
+        try {
+            enterCriticalSection(connection, resource);
+            try {
+                unlockResource(connection, resource, owner);
+            } finally {
+                leaveCriticalSection(connection, resource);
+            }
+        } finally {
+            closeDbConnection(connection);
+        }
+    }
+
+    @Override
+    public boolean isLocked(String resource) {
+        Connection connection=openDbConnection();
+        try {
+            LockRecord lockRecord=loadLockRecord(connection,resource);
+            if(lockRecord==null){
+                return false;
+            }else{
+                if(lockRecord.getOwner()==null){
+                    return false;
+                }else if(isLockExpired(lockRecord, connection)){
+                    return false;
+                }else{
+                    return true;
+                }
+            }
+        } catch (SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
+        }finally {
+            closeDbConnection(connection);
+        }
+    }
+
+    @Override
+    public String getLockOwner(String resource) {
+        Connection connection=openDbConnection();
+        try {
+            org.onap.appc.lockmanager.impl.sql.pessimistic.LockRecord lockRecord=loadLockRecord(connection,resource);
+            if(lockRecord==null || lockRecord.getOwner() ==null ){
+                return null;
+            }else{
+                if(isLockExpired(lockRecord, connection)){
+                    return null;
+                }else{
+                    return lockRecord.getOwner();
+                }
+            }
+        } catch (SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_CHECK_LOCK.format(resource));
+        }finally {
+            closeDbConnection(connection);
+        }
+    }
+
+    private boolean lockResource(Connection connection, String resource, String owner, long timeout) throws LockException {
+        try {
+            boolean res = false;
+            LockRecord lockRecord = loadLockRecord(connection, resource);
+            if(lockRecord != null) {
+                // lock record already exists
+                String currentOwner = lockRecord.getOwner();
+                if(currentOwner != null) {
+                    if(isLockExpired(lockRecord, connection)) {
+                        currentOwner = null;
+                    } else if(!owner.equals(currentOwner)) {
+                        throw new LockException(Messages.ERR_LOCK_LOCKED_BY_OTHER.format(resource, currentOwner));
+                    }
+                }
+                // set new owner on the resource lock record
+                updateLockRecord(connection, resource, owner, timeout);
+                if(currentOwner == null) {
+                    // no one locked the resource before
+                    res = true;
+                }
+            } else {
+                // resource record does not exist in lock table => create new record
+                addLockRecord(connection, resource, owner, timeout);
+                res = true;
+            }
+            return res;
+        } catch(SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_LOCK.format(resource), e);
+        }
+    }
+
+    private void unlockResource(Connection connection, String resource, String owner) throws LockException {
+        try {
+            LockRecord lockRecord = loadLockRecord(connection, resource);
+            if(lockRecord != null) {
+                // check if expired
+                if(isLockExpired(lockRecord, connection)) {
+                    // lock is expired => no lock
+                    lockRecord = null;
+                }
+            }
+            if((lockRecord == null) || (lockRecord.getOwner() == null)) {
+                // resource is not locked
+                throw new LockException(Messages.ERR_UNLOCK_NOT_LOCKED.format(resource));
+            }
+            String currentOwner = lockRecord.getOwner();
+            if(!owner.equals(currentOwner)) {
+                throw new LockException(Messages.ERR_UNLOCK_LOCKED_BY_OTHER.format(resource, owner, currentOwner));
+            }
+            updateLockRecord(connection, resource, null, 0);
+            // TODO delete record from table on lock release?
+//            deleteLockRecord(connection, resource);
+        } catch(SQLException e) {
+            throw new LockRuntimeException(Messages.EXP_UNLOCK.format(resource), e);
+        }
+    }
+
+    protected abstract void enterCriticalSection(Connection connection, String resource);
+
+    protected abstract void leaveCriticalSection(Connection connection, String resource);
+
+    protected LockRecord loadLockRecord(Connection connection, String resource) throws SQLException {
+        LockRecord res = null;
+        if(sqlLoadLockRecord == null) {
+            sqlLoadLockRecord = String.format(SQL_LOAD_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlLoadLockRecord)) {
+            statement.setString(1, resource);
+            try(ResultSet resultSet = statement.executeQuery()) {
+                if(resultSet.next()) {
+                    res = new LockRecord(resource);
+                    res.setOwner(resultSet.getString(2));
+                    res.setUpdated(resultSet.getLong(3));
+                    res.setTimeout(resultSet.getLong(4));
+                }
+            }
+        }
+        return res;
+    }
+
+    protected void addLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
+        if(sqlInsertLockRecord == null) {
+            sqlInsertLockRecord = String.format(SQL_INSERT_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlInsertLockRecord)) {
+            statement.setString(1, resource);
+            statement.setString(2, owner);
+            statement.setLong(3, getCurrentTime(connection));
+            statement.setLong(4, timeout);
+            statement.executeUpdate();
+        }
+    }
+
+    protected void updateLockRecord(Connection connection, String resource, String owner, long timeout) throws SQLException {
+        if(sqlUpdateLockRecord == null) {
+            sqlUpdateLockRecord = String.format(SQL_UPDATE_LOCK_RECORD, tableName);
+        }
+        try(PreparedStatement statement = connection.prepareStatement(sqlUpdateLockRecord)) {
+            statement.setString(1, owner);
+            statement.setLong(2, getCurrentTime(connection));
+            statement.setLong(3, timeout);
+            statement.setString(4, resource);
+            statement.executeUpdate();
+        }
+    }
+
+//    protected void deleteLockRecord(Connection connection, String resource) throws SQLException {
+//        if(sqlDeleteLockRecord == null) {
+//            sqlDeleteLockRecord = String.format(SQL_DELETE_LOCK_RECORD, tableName);
+//        }
+//        try(PreparedStatement statement = connection.prepareStatement(sqlDeleteLockRecord)) {
+//            statement.setString(1, resource);
+//            statement.executeUpdate();
+//        }
+//    }
+
+    private boolean isLockExpired(LockRecord lockRecord, Connection connection) throws SQLException {
+        long timeout = lockRecord.getTimeout();
+        if(timeout == 0) {
+            return false;
+        }
+        long updated = lockRecord.getUpdated();
+        long now = getCurrentTime(connection);
+        long expiration = updated + timeout;
+        return (now > expiration);
+    }
+
+    private long getCurrentTime(Connection connection) throws SQLException {
+        long res = -1;
+        if(connection != null) {
+            try(PreparedStatement statement = connection.prepareStatement(SQL_CURRENT_TIMESTAMP)) {
+                try(ResultSet resultSet = statement.executeQuery()) {
+                    if(resultSet.next()) {
+                        res = resultSet.getTimestamp(1).getTime();
+                    }
+                }
+            }
+        }
+        if(res == -1) {
+            res = System.currentTimeMillis();
+        }
+        return res;
+    }
 }