Include Cassandra locking

Change-Id: I085acf8336d5f27782ee12768846a5befd3ee60d
Issue-ID: MUSIC-148
Signed-off-by: Tschaen, Brendan <ctschaen@att.com>

51 files changed, 1361 insertions, 5168 deletions

diff --git a/src/main/java/org/onap/music/conductor/conditionals/JsonConditional.java b/src/main/java/org/onap/music/conductor/conditionals/JsonConditional.java
index 8cacc369..33a14bef 100644
--- a/src/main/java/org/onap/music/conductor/conditionals/JsonConditional.java
+++ b/src/main/java/org/onap/music/conductor/conditionals/JsonConditional.java
@@ -35,8 +35,8 @@ public class JsonConditional implements Serializable {
 	private String primaryKey;
 	private String primaryKeyValue;
 	private String casscadeColumnName;
-	private transient Map<String,Object> tableValues;
-	private transient Map<String,Object> casscadeColumnData;
+	private Map<String,Object> tableValues;
+	private Map<String,Object> casscadeColumnData;
 	private Map<String,Map<String,String>> conditions;
 	
 	public Map<String, Object> getTableValues() {
diff --git a/src/main/java/org/onap/music/conductor/conditionals/MusicConditional.java b/src/main/java/org/onap/music/conductor/conditionals/MusicConditional.java
index d5e9e4d5..8aadcba3 100644
--- a/src/main/java/org/onap/music/conductor/conditionals/MusicConditional.java
+++ b/src/main/java/org/onap/music/conductor/conditionals/MusicConditional.java
@@ -32,7 +32,6 @@ import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
 import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.lockingservice.MusicLockState;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
@@ -47,7 +46,6 @@ import com.datastax.driver.core.TableMetadata;
 
 public class MusicConditional {
 	private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicDataAPI.class);
-	private static final String CRITICAL = "critical";
 
 	public static ReturnType conditionalInsert(String keyspace, String tablename, String casscadeColumnName,
 			Map<String, Object> casscadeColumnData, String primaryKey, Map<String, Object> valuesMap,
@@ -94,7 +92,7 @@ public class MusicConditional {
 			if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
 				ReturnType criticalPutResult = conditionalInsertAtomic(lockId, keyspace, tablename, primaryKey,
 						queryBank);
-				MusicCore.destroyLockRef(lockId);
+				MusicCore.destroyLockRef(key,lockId);
 				if (criticalPutResult.getMessage().contains("insert"))
 					criticalPutResult
 							.setMessage("Insert values: ");
@@ -104,12 +102,11 @@ public class MusicConditional {
 				return criticalPutResult;
 
 			} else {
-				MusicCore.destroyLockRef(lockId);
+				MusicCore.destroyLockRef(key,lockId);
 				return lockAcqResult;
 			}
 		} catch (Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED);
-			MusicCore.destroyLockRef(lockId);
+			MusicCore.destroyLockRef(key,lockId);
 			return new ReturnType(ResultType.FAILURE, e.getMessage());
 		}
 
@@ -121,20 +118,19 @@ public class MusicConditional {
 		ResultSet results = null;
 
 		try {
-
-			MusicLockState mls = MusicCore.getLockingServiceHandle()
-					.getLockState(keyspace + "." + tableName + "." + primaryKey);
-			if (mls.getLockHolder().equals(lockId)) {
+			String fullyQualifiedKey = keyspace + "." + tableName + "." + primaryKey;
+	        ReturnType lockAcqResult = MusicCore.acquireLock(fullyQualifiedKey, lockId);
+	        if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
 				try {
 					results = MusicCore.getDSHandle().executeCriticalGet(queryBank.get(MusicUtil.SELECT));
 				} catch (Exception e) {
 					return new ReturnType(ResultType.FAILURE, e.getMessage());
 				}
 				if (results.all().isEmpty()) {
-					MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.INSERT), CRITICAL);
+					MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.INSERT), "critical");
 					return new ReturnType(ResultType.SUCCESS, "insert");
 				} else {
-					MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.UPDATE), CRITICAL);
+					MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.UPDATE), "critical");
 					return new ReturnType(ResultType.SUCCESS, "update");
 				}
 			} else {
@@ -145,7 +141,6 @@ public class MusicConditional {
 		} catch (Exception e) {
 			StringWriter sw = new StringWriter();
 			e.printStackTrace(new PrintWriter(sw));
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
 			String exceptionAsString = sw.toString();
 			return new ReturnType(ResultType.FAILURE,
 					"Exception thrown while doing the critical put, check sanctity of the row/conditions:\n"
@@ -159,21 +154,18 @@ public class MusicConditional {
 		String key = keyspace + "." + tableName + "." + primaryKeyValue;
 		String lockId = MusicCore.createLockReference(key);
 		long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-		ReturnType lockAcqResult = MusicCore.acquireLockWithLease(key, lockId, leasePeriod);
-
 		try {
-
+		ReturnType lockAcqResult = MusicCore.acquireLockWithLease(key, lockId, leasePeriod);
 			if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
 				return updateAtomic(lockId, keyspace, tableName, primaryKey,primaryKeyValue, queryBank,planId,cascadeColumnValues,cascadeColumnName);
 
 			} else {
-				MusicCore.destroyLockRef(lockId);
+				MusicCore.destroyLockRef(key,lockId);
 				return lockAcqResult;
 			}
 
 		} catch (Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-			MusicCore.destroyLockRef(lockId);
+			MusicCore.destroyLockRef(key,lockId);
 			return new ReturnType(ResultType.FAILURE, e.getMessage());
 
 		}
@@ -181,11 +173,11 @@ public class MusicConditional {
 
 	public static ReturnType updateAtomic(String lockId, String keyspace, String tableName, String primaryKey,String primaryKeyValue,
 			Map<String,PreparedQueryObject> queryBank,String planId,Map<String,String> cascadeColumnValues,String casscadeColumnName) {
+		String key = keyspace + "." + tableName + "." + primaryKeyValue;
+		long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
 		try {
-
-			MusicLockState mls = MusicCore.getLockingServiceHandle()
-					.getLockState(keyspace + "." + tableName + "." + primaryKeyValue);
-			if (mls.getLockHolder().equals(lockId)) {
+			ReturnType lockAcqResult = MusicCore.acquireLockWithLease(key, lockId, leasePeriod);
+			if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
 				Row row  = MusicCore.getDSHandle().executeCriticalGet(queryBank.get(MusicUtil.SELECT)).one();
 				
 				if(row != null) {
@@ -199,14 +191,14 @@ public class MusicConditional {
 					update.addValue(MusicUtil.convertToActualDataType(DataType.text(), vector_ts));
 					update.addValue(MusicUtil.convertToActualDataType(DataType.text(), primaryKeyValue));
 					try {
-						MusicCore.getDSHandle().executePut(update, CRITICAL);
+						MusicCore.getDSHandle().executePut(update, "critical");
 					} catch (Exception ex) {
 						return new ReturnType(ResultType.FAILURE, ex.getMessage());
 					}
 				}else {
 					return new ReturnType(ResultType.FAILURE,"Cannot find data related to key: "+primaryKey);
 				}
-				MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.UPSERT), CRITICAL);
+				MusicCore.getDSHandle().executePut(queryBank.get(MusicUtil.UPSERT), "critical");
 				return new ReturnType(ResultType.SUCCESS, "update success");
 
 			} else {
@@ -215,7 +207,6 @@ public class MusicConditional {
 			}
 
 		} catch (Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
 			StringWriter sw = new StringWriter();
 			e.printStackTrace(new PrintWriter(sw));
 			String exceptionAsString = sw.toString();
@@ -340,7 +331,7 @@ public class MusicConditional {
 
 		Map<String, String> finalValues = new HashMap<>();
 		values = (Map<String, String>) columnValue;
-		if (values != null && values.keySet().contains(planId)) {
+		if (values.keySet().contains(planId)) {
 			String valueString = values.get(planId);
 			String tempValueString = valueString.replaceAll("\\{", "").replaceAll("\"", "").replaceAll("\\}", "");
 			String[] elements = tempValueString.split(",");
@@ -355,4 +346,4 @@ public class MusicConditional {
 
 	}
 
-}
+}
\ No newline at end of file
diff --git a/src/main/java/org/onap/music/conductor/conditionals/RestMusicConditionalAPI.java b/src/main/java/org/onap/music/conductor/conditionals/RestMusicConditionalAPI.java
index eb466754..4292749c 100644
--- a/src/main/java/org/onap/music/conductor/conditionals/RestMusicConditionalAPI.java
+++ b/src/main/java/org/onap/music/conductor/conditionals/RestMusicConditionalAPI.java
@@ -103,7 +103,7 @@ public class RestMusicConditionalAPI {
 
 		Map<String, Object> authMap = null;
 		try {
-			authMap = MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "insertIntoTable");
+			authMap = MusicCore.authenticate(ns, userId, password, keyspace, aid, "insertIntoTable");
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGINFO, ErrorSeverity.CRITICAL,
 					ErrorTypes.AUTHENTICATIONERROR);
@@ -174,7 +174,7 @@ public class RestMusicConditionalAPI {
 
 		Map<String, Object> authMap = null;
 		try {
-			authMap = MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "updateTable");
+			authMap = MusicCore.authenticate(ns, userId, password, keyspace, aid, "updateTable");
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGINFO, ErrorSeverity.CRITICAL,
 					ErrorTypes.AUTHENTICATIONERROR);
diff --git a/src/main/java/org/onap/music/datastore/MusicDataStore.java b/src/main/java/org/onap/music/datastore/CassaDataStore.java
index 0154ad28..14934f6e 100644
--- a/src/main/java/org/onap/music/datastore/MusicDataStore.java
+++ b/src/main/java/org/onap/music/datastore/CassaDataStore.java
@@ -30,6 +30,8 @@ import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.UUID;
+
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
@@ -42,10 +44,8 @@ import com.datastax.driver.core.ColumnDefinitions;
 import com.datastax.driver.core.ColumnDefinitions.Definition;
 import com.datastax.driver.core.ConsistencyLevel;
 import com.datastax.driver.core.DataType;
-import com.datastax.driver.core.HostDistance;
 import com.datastax.driver.core.KeyspaceMetadata;
 import com.datastax.driver.core.Metadata;
-import com.datastax.driver.core.PoolingOptions;
 import com.datastax.driver.core.PreparedStatement;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
@@ -54,13 +54,42 @@ import com.datastax.driver.core.TableMetadata;
 import com.datastax.driver.core.exceptions.AlreadyExistsException;
 import com.datastax.driver.core.exceptions.InvalidQueryException;
 import com.datastax.driver.core.exceptions.NoHostAvailableException;
+import com.datastax.driver.core.utils.UUIDs;
 import com.sun.jersey.core.util.Base64;
 
 /**
  * @author nelson24
  *
  */
-public class MusicDataStore {
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+/**
+ * @author bharathb
+ *
+ */
+public class CassaDataStore {
 
     private Session session;
     private Cluster cluster;
@@ -90,12 +119,12 @@ public class MusicDataStore {
 
 
 
-    private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MusicDataStore.class);
+    private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(CassaDataStore.class);
 
     /**
      * 
      */
-    public MusicDataStore() {
+    public CassaDataStore() {
         connectToCassaCluster();
     }
 
@@ -104,7 +133,7 @@ public class MusicDataStore {
      * @param cluster
      * @param session
      */
-    public MusicDataStore(Cluster cluster, Session session) {
+    public CassaDataStore(Cluster cluster, Session session) {
         this.session = session;
         this.cluster = cluster;
     }
@@ -114,7 +143,7 @@ public class MusicDataStore {
      * @param remoteIp
      * @throws MusicServiceException
      */
-    public MusicDataStore(String remoteIp) {
+    public CassaDataStore(String remoteIp) {
         try {
             connectToCassaCluster(remoteIp);
         } catch (MusicServiceException e) {
@@ -151,35 +180,16 @@ public class MusicDataStore {
      * clusters.
      */
     private void connectToCassaCluster() {
-    	Iterator<String> it = getAllPossibleLocalIps().iterator();
+        Iterator<String> it = getAllPossibleLocalIps().iterator();
         String address = "localhost";
-        String[] addresses = null;
-        address = MusicUtil.getMyCassaHost();
-		addresses = address.split(",");
-		
         logger.info(EELFLoggerDelegate.applicationLogger,
                         "Connecting to cassa cluster: Iterating through possible ips:"
                                         + getAllPossibleLocalIps());
-        PoolingOptions poolingOptions = new PoolingOptions();
-        poolingOptions
-        .setConnectionsPerHost(HostDistance.LOCAL,  4, 10)
-        .setConnectionsPerHost(HostDistance.REMOTE, 2, 4);
         while (it.hasNext()) {
             try {
-            	if(MusicUtil.getCassName() != null && MusicUtil.getCassPwd() != null) {
-            		logger.info(EELFLoggerDelegate.applicationLogger,
-            				"Building with credentials "+MusicUtil.getCassName()+" & "+MusicUtil.getCassPwd());
-            		cluster = Cluster.builder().withPort(MusicUtil.getCassandraPort())
-            		                   .withCredentials(MusicUtil.getCassName(), MusicUtil.getCassPwd())
-            		                   //.withLoadBalancingPolicy(new RoundRobinPolicy())
-            		                   .withPoolingOptions(poolingOptions)
-            		                   .addContactPoints(addresses).build();
-            	}
-            	else
-            		cluster = Cluster.builder().withPort(MusicUtil.getCassandraPort())
-            		 					//.withLoadBalancingPolicy(new RoundRobinPolicy())
-            		 					.addContactPoints(addresses).build();
-                
+                cluster = Cluster.builder().withPort(9042)
+                                .withCredentials(MusicUtil.getCassName(), MusicUtil.getCassPwd())
+                                .addContactPoint(address).build();
                 Metadata metadata = cluster.getMetadata();
                 logger.info(EELFLoggerDelegate.applicationLogger, "Connected to cassa cluster "
                                 + metadata.getClusterName() + " at " + address);
@@ -206,27 +216,9 @@ public class MusicDataStore {
      * @param address
      */
     private void connectToCassaCluster(String address) throws MusicServiceException {
-    	String[] addresses = null;
-		addresses = address.split(",");
-		PoolingOptions poolingOptions = new PoolingOptions();
-        poolingOptions
-        .setConnectionsPerHost(HostDistance.LOCAL,  4, 10)
-        .setConnectionsPerHost(HostDistance.REMOTE, 2, 4);
-        if(MusicUtil.getCassName() != null && MusicUtil.getCassPwd() != null) {
-    		logger.info(EELFLoggerDelegate.applicationLogger,
-    				"Building with credentials "+MusicUtil.getCassName()+" & "+MusicUtil.getCassPwd());
-    		cluster = Cluster.builder().withPort(MusicUtil.getCassandraPort())
-	                   .withCredentials(MusicUtil.getCassName(), MusicUtil.getCassPwd())
-	                   //.withLoadBalancingPolicy(new RoundRobinPolicy())
-	                   .withPoolingOptions(poolingOptions)
-	                   .addContactPoints(addresses).build();
-        }
-        else {
-        	cluster = Cluster.builder().withPort(MusicUtil.getCassandraPort())
-        				//.withLoadBalancingPolicy(new RoundRobinPolicy())
-        				.withPoolingOptions(poolingOptions)
-        				.addContactPoints(addresses).build();
-        }
+        cluster = Cluster.builder().withPort(9042)
+                        .withCredentials(MusicUtil.getCassName(), MusicUtil.getCassPwd())
+                        .addContactPoint(address).build();
         Metadata metadata = cluster.getMetadata();
         logger.info(EELFLoggerDelegate.applicationLogger, "Connected to cassa cluster "
                         + metadata.getClusterName() + " at " + address);
@@ -315,7 +307,7 @@ public class MusicDataStore {
             DataType colType = colInfo.getType(colName);
             Object columnValue = getColValue(row, colName, colType);
             Object conditionValue = MusicUtil.convertToActualDataType(colType, entry.getValue());
-            if (!columnValue.equals(conditionValue))
+            if (columnValue.equals(conditionValue) == false)
                 return false;
         }
         return true;
@@ -479,5 +471,5 @@ public class MusicDataStore {
         return results;
 
     }
-
 }
+
diff --git a/src/main/java/org/onap/music/datastore/CassaLockStore.java b/src/main/java/org/onap/music/datastore/CassaLockStore.java
new file mode 100644
index 00000000..e03a1c07
--- /dev/null
+++ b/src/main/java/org/onap/music/datastore/CassaLockStore.java
@@ -0,0 +1,173 @@
+package org.onap.music.datastore;
+
+import java.util.UUID;
+
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.utils.UUIDs;
+
+/*
+ * This is the lock store that is built on top of Cassandra that is used by MUSIC to maintain lock state. 
+ */
+
+public class CassaLockStore {
+	
+	private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(CassaLockStore.class);
+	
+	public class LockObject{
+		public String lockRef;
+		public String createTime;
+		public String acquireTime;
+		public LockObject(String lockRef, String createTime, 	String acquireTime) {
+			this.lockRef = lockRef;
+			this.acquireTime = acquireTime;
+			this.createTime = createTime;
+			
+		}
+	}
+	CassaDataStore dsHandle;
+	public CassaLockStore() {
+		dsHandle = new CassaDataStore();
+	}
+	
+	public CassaLockStore(CassaDataStore dsHandle) {
+		this.dsHandle=dsHandle;
+	}
+
+    
+	/**
+	 * 
+	 * This method creates a shadow locking table for every main table in Cassandra. This table tracks all information regarding locks. 
+	 * @param keyspace of the application. 
+	 * @param table of the application. 
+	 * @return true if the operation was successful.
+	 * @throws MusicServiceException
+	 * @throws MusicQueryException
+	 */
+	public boolean createLockQueue(String keyspace, String table) throws MusicServiceException, MusicQueryException {
+        logger.info(EELFLoggerDelegate.applicationLogger,
+                "Create lock queue/table for " +  keyspace+"."+table);
+		table = "lockQ_"+table; 
+		String tabQuery = "CREATE TABLE IF NOT EXISTS "+keyspace+"."+table
+				+ " ( key text, lockReference bigint, createTime text, acquireTime text, guard bigint static, PRIMARY KEY ((key), lockReference) ) "
+				+ "WITH CLUSTERING ORDER BY (lockReference ASC);";
+		System.out.println(tabQuery);
+		PreparedQueryObject queryObject = new PreparedQueryObject(); 
+		
+		queryObject.appendQueryString(tabQuery);
+		boolean result;
+		result = dsHandle.executePut(queryObject, "eventual");
+		return result;
+	}
+
+	/**
+	 * This method creates a lock reference for each invocation. The lock references are monotonically increasing timestamps.
+	 * @param keyspace of the locks.
+	 * @param table of the locks.
+	 * @param lockName is the primary key of the lock table
+	 * @return the UUID lock reference.
+	 * @throws MusicServiceException
+	 * @throws MusicQueryException
+	 */
+	public String genLockRefandEnQueue(String keyspace, String table, String lockName) throws MusicServiceException, MusicQueryException {
+        logger.info(EELFLoggerDelegate.applicationLogger,
+                "Create lock reference for " +  keyspace + "." + table + "." + lockName);
+		table = "lockQ_" + table;
+		long lockEpochMillis = System.currentTimeMillis();
+		long lockRef = lockEpochMillis;
+
+		logger.info(EELFLoggerDelegate.applicationLogger,
+				"Created lock reference for " +  keyspace + "." + table + "." + lockName + ":" + lockRef);
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        String defaultQuery = " UPDATE " + keyspace + "." + table + " SET guard=-1 WHERE key=? IF guard = NULL;";
+
+        queryObject.addValue(lockName);
+        queryObject.appendQueryString(defaultQuery);
+        boolean dqResult = dsHandle.executePut(queryObject, "critical");
+//        System.out.println("dqResult: " + dqResult);
+
+
+        queryObject = new PreparedQueryObject();
+		String insQuery = "BEGIN BATCH" +
+                " UPDATE " + keyspace + "." + table + " SET guard=? WHERE key=? IF guard < ?;" +
+                " INSERT INTO " + keyspace + "." + table +
+				"(key, lockReference, createTime, acquireTime) VALUES (?,?,?,?) IF NOT EXISTS; APPLY BATCH;";
+
+        queryObject.addValue(lockRef);
+        queryObject.addValue(lockName);
+        queryObject.addValue(lockRef);
+
+        queryObject.addValue(lockName);
+        queryObject.addValue(lockRef);
+        queryObject.addValue(String.valueOf(lockEpochMillis));
+        queryObject.addValue("0");
+        queryObject.appendQueryString(insQuery);
+        boolean pResult = dsHandle.executePut(queryObject, "critical");
+//        System.out.println("pResult: " + pResult);
+		return String.valueOf(lockRef);
+	}
+	
+	
+	/**
+	 * This method returns the top of lock table/queue for the key. 
+	 * @param keyspace of the application. 
+	 * @param table of the application. 
+	 * @param key is the primary key of the application table
+	 * @return the UUID lock reference.
+	 * @throws MusicServiceException
+	 * @throws MusicQueryException
+	 */
+	public LockObject peekLockQueue(String keyspace, String table, String key) throws MusicServiceException, MusicQueryException{
+        logger.info(EELFLoggerDelegate.applicationLogger,
+                "Peek in lock table for " +  keyspace+"."+table+"."+key);
+		table = "lockQ_"+table; 
+		String selectQuery = "select * from "+keyspace+"."+table+" where key='"+key+"' LIMIT 1;";	
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        queryObject.appendQueryString(selectQuery);
+		ResultSet results = dsHandle.executeEventualGet(queryObject);
+		Row row = results.one();
+		String lockReference = "" + row.getLong("lockReference");
+		String createTime = row.getString("createTime");
+		String acquireTime = row.getString("acquireTime");
+
+		return new LockObject(lockReference, createTime,acquireTime);
+	}
+	
+	
+	/**
+	 * This method removes the lock ref from the lock table/queue for the key. 
+	 * @param keyspace of the application. 
+	 * @param table of the application. 
+	 * @param key is the primary key of the application table
+	 * @param lockReference the lock reference that needs to be dequeued.
+	 * @throws MusicServiceException
+	 * @throws MusicQueryException
+	 */	
+	public void deQueueLockRef(String keyspace, String table, String key, String lockReference) throws MusicServiceException, MusicQueryException{
+		table = "lockQ_"+table; 
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        Long lockReferenceL = Long.parseLong(lockReference);
+        String deleteQuery = "delete from "+keyspace+"."+table+" where key='"+key+"' AND lockReference ="+lockReferenceL+" IF EXISTS;";
+        queryObject.appendQueryString(deleteQuery);
+		dsHandle.executePut(queryObject, "critical");	
+	}
+	
+
+	public void updateLockAcquireTime(String keyspace, String table, String key, String lockReference) throws MusicServiceException, MusicQueryException{
+		table = "lockQ_"+table; 
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        Long lockReferenceL = Long.parseLong(lockReference);
+        String updateQuery = "update "+keyspace+"."+table+" set acquireTime='"+ System.currentTimeMillis()+"' where key='"+key+"' AND lockReference = "+lockReferenceL+" IF EXISTS;";
+        queryObject.appendQueryString(updateQuery);
+		dsHandle.executePut(queryObject, "eventual");	
+
+	}
+	
+
+}
diff --git a/src/main/java/org/onap/music/datastore/MusicLockState.java b/src/main/java/org/onap/music/datastore/MusicLockState.java
new file mode 100644
index 00000000..60a15b13
--- /dev/null
+++ b/src/main/java/org/onap/music/datastore/MusicLockState.java
@@ -0,0 +1,41 @@
+package org.onap.music.datastore;
+public class MusicLockState {
+    public enum LockStatus {
+        UNLOCKED, BEING_LOCKED, LOCKED
+    };// captures the state of the lock
+    
+    private LockStatus lockStatus;
+    private String lockHolder;
+    private String errorMessage = null;
+    
+    public String getErrorMessage() {
+		return errorMessage;
+	}
+
+	public void setErrorMessage(String errorMessage) {
+		this.errorMessage = errorMessage;
+	}
+
+	public MusicLockState(LockStatus lockStatus, String lockHolder) {
+		super();
+        this.lockStatus = lockStatus;
+		this.lockHolder = lockHolder;
+	}
+
+	public LockStatus getLockStatus() {
+        return lockStatus;
+    }
+
+    public void setLockStatus(LockStatus lockStatus) {
+        this.lockStatus = lockStatus;
+    }
+
+    public String getLockHolder() {
+        return lockHolder;
+    }
+
+    public void setLockHolder(String lockHolder) {
+        this.lockHolder = lockHolder;
+    }
+
+}
diff --git a/src/main/java/org/onap/music/datastore/PreparedQueryObject.java b/src/main/java/org/onap/music/datastore/PreparedQueryObject.java
index 694d9acd..534f7d65 100644
--- a/src/main/java/org/onap/music/datastore/PreparedQueryObject.java
+++ b/src/main/java/org/onap/music/datastore/PreparedQueryObject.java
@@ -34,6 +34,7 @@ public class PreparedQueryObject {
 
     private List<Object> values;
     private StringBuilder query;
+    
 
 
 
@@ -67,6 +68,10 @@ public class PreparedQueryObject {
         this.query.append(s);
     }
 
+    public void replaceQueryString(String s) {
+        this.query.replace(0, query.length(), s);
+    }
+
     /**
      * @return
      */
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JSONCallbackResponse.java b/src/main/java/org/onap/music/datastore/jsonobjects/JSONCallbackResponse.java
deleted file mode 100755
index f869c342..00000000
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JSONCallbackResponse.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.datastore.jsonobjects;
-
-import java.util.List;
-import java.util.Map;
-
-public class JSONCallbackResponse {
-
-	private String full_table;
-	private String keyspace;
-	private Map<String, String> changeValue;
-	private String operation;
-	private String table_name;
-	private String primary_key;
-	private Object miscObjects;
-	private List<String> updateList;
-	
-	public String getFull_table() {
-		return full_table;
-	}
-	public void setFull_table(String full_table) {
-		this.full_table = full_table;
-	}
-	public String getKeyspace() {
-		return keyspace;
-	}
-	public void setKeyspace(String keyspace) {
-		this.keyspace = keyspace;
-	}
-	public String getOperation() {
-		return operation;
-	}
-	public void setOperation(String operation) {
-		this.operation = operation;
-	}
-	public String getTable_name() {
-		return table_name;
-	}
-	public void setTable_name(String table_name) {
-		this.table_name = table_name;
-	}
-	public String getPrimary_key() {
-		return primary_key;
-	}
-	public void setPrimary_key(String primary_key) {
-		this.primary_key = primary_key;
-	}
-	public Object getMiscObjects() {
-		return miscObjects;
-	}
-	public void setMiscObjects(Object miscObjects) {
-		this.miscObjects = miscObjects;
-	}
-	public void setChangeValue(Map<String, String> changeValue) {
-		this.changeValue = changeValue;
-	}
-	public Map<String, String> getChangeValue() {
-		return changeValue;
-	}
-	public List<String> getUpdateList() {
-		return updateList;
-	}
-	public void setUpdateList(List<String> updateList) {
-		this.updateList = updateList;
-	}
-	
-	
-}
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonCallback.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonCallback.java
deleted file mode 100755
index 4a865320..00000000
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonCallback.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.datastore.jsonobjects;
-
-import java.io.Serializable;
-import java.util.Map;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-
-@ApiModel(value = "JsonCallback", description = "Json model for callback")
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class JsonCallback implements Serializable {
-	private String applicationName;
-    private String applicationUsername;
-    private String applicationPassword;
-    private String applicationNotificationEndpoint;
-    private String notifyOn;
-    private String notifyWhenChangeIn;
-    private String notifyWhenInsertsIn;
-    private String notifyWhenDeletesIn;
-    private Map<String, String> responseBody;
-
-    private String uuid;
-    
-    public String getUuid() {
-    	return uuid;
-    }
-    
-    public void setUuid(String uuid) {
-    	this.uuid = uuid;
-    }
-
-    @ApiModelProperty(value = "application name")
-    public String getApplicationName() {
-        return applicationName;
-    }
-
-    public void setApplicationName(String applicationName) {
-        this.applicationName = applicationName;
-    }
-    
-    @ApiModelProperty(value = "notify On")
-    public String getNotifyOn() {
-        return notifyOn;
-    }
-
-    public void setNotifyOn(String notifyOn) {
-        this.notifyOn = notifyOn;
-    }
-    
-    @ApiModelProperty(value = "application User name")
-    public String getApplicationUsername() {
-        return applicationUsername;
-    }
-
-    public void setApplicationUsername(String applicationUsername) {
-        this.applicationUsername = applicationUsername;
-    }
-
-    @ApiModelProperty(value = "application password")
-    public String getApplicationPassword() {
-        return applicationPassword;
-    }
-
-    public void setApplicationPassword(String applicationPassword) {
-        this.applicationPassword = applicationPassword;
-    }
-
-    @ApiModelProperty(value = "application notification endpoint")
-    public String getApplicationNotificationEndpoint() {
-        return applicationNotificationEndpoint;
-    }
-
-    public void setApplicationNotificationEndpoint(String applicationNotificationEndpoint) {
-        this.applicationNotificationEndpoint = applicationNotificationEndpoint;
-    }
-
-    @ApiModelProperty(value = "notify when updates")
-    public String getNotifyWhenChangeIn() {
-        return notifyWhenChangeIn;
-    }
-
-    public void setNotifyWhenChangeIn(String notifyWhenChangeIn) {
-        this.notifyWhenChangeIn = notifyWhenChangeIn;
-    }
-
-    @ApiModelProperty(value = "notify when inserts")
-    public String getNotifyWhenInsertsIn() {
-        return notifyWhenInsertsIn;
-    }
-
-    public void setNotifyWhenInsertsIn(String notifyWhenInsertsIn) {
-        this.notifyWhenInsertsIn = notifyWhenInsertsIn;
-    }
-
-    @ApiModelProperty(value = "notify when deletes")
-    public String getNotifyWhenDeletesIn() {
-        return notifyWhenDeletesIn;
-    }
-
-    public void setNotifyWhenDeletesIn(String notifyWhenDeletesIn) {
-        this.notifyWhenDeletesIn = notifyWhenDeletesIn;
-    }
-
-    public Map<String, String> getResponseBody() {
-		return responseBody;
-	}
-    
-    public void setResponseBody(Map<String, String> responseBody) {
-		this.responseBody = responseBody;
-	}
-    
-}
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
index ce7f509b..a5db4be5 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonDelete.java
@@ -36,8 +36,7 @@ public class JsonDelete {
     private ArrayList<String> columns = null;
     private Map<String, String> consistencyInfo;
     private Map<String, Object> conditions;
-    String ttl;
-    String timestamp;
+    String ttl, timestamp;
 
 
     @ApiModelProperty(value = "Conditions")
@@ -86,4 +85,3 @@ public class JsonDelete {
         this.timestamp = timestamp;
     }
 }
-
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
index c79ba9b7..9630abe0 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonInsert.java
@@ -38,11 +38,12 @@ import io.swagger.annotations.ApiModelProperty;
 public class JsonInsert implements Serializable {
     private String keyspaceName;
     private String tableName;
-    private transient Map<String, Object> values;
+    private Map<String, Object> values;
     private String ttl;
     private String timestamp;
-    private transient Map<String, Object> row_specification;
+    private Map<String, Object> row_specification;
     private Map<String, String> consistencyInfo;
+    private byte[] data;
     private Map<String, byte[]> objectMap;
     
     @ApiModelProperty(value = "objectMap")
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotification.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotification.java
deleted file mode 100755
index ce244e2c..00000000
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotification.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.datastore.jsonobjects;
-
-import java.io.Serializable;
-import java.util.Map;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonInclude.Include;
-
-import io.swagger.annotations.ApiModel;
-
-@ApiModel(value = "JsonNotification", description = "Json model for callback")
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JsonInclude(Include.NON_NULL) 
-public class JsonNotification implements Serializable {
-	
-	private String notify_field;
-    private String endpoint;
-    private String username;
-    private String password;
-    private String notify_change;
-    private String notify_insert;
-    private String notify_delete;
-    private String operation_type;
-    private String triggerName;
-    private Map<String, String> response_body;
-    
-	public String getNotify_field() {
-		return notify_field;
-	}
-	public void setNotify_field(String notify_field) {
-		this.notify_field = notify_field;
-	}
-	public String getEndpoint() {
-		return endpoint;
-	}
-	public void setEndpoint(String endpoint) {
-		this.endpoint = endpoint;
-	}
-	public String getUsername() {
-		return username;
-	}
-	public void setUsername(String username) {
-		this.username = username;
-	}
-	public String getPassword() {
-		return password;
-	}
-	public void setPassword(String password) {
-		this.password = password;
-	}
-	public Map<String, String> getResponse_body() {
-		return response_body;
-	}
-	public void setResponse_body(Map<String, String> response_body) {
-		this.response_body = response_body;
-	}
-	public String getNotify_change() {
-		return notify_change;
-	}
-	public void setNotify_change(String notify_change) {
-		this.notify_change = notify_change;
-	}
-	public String getNotify_insert() {
-		return notify_insert;
-	}
-	public void setNotify_insert(String notify_insert) {
-		this.notify_insert = notify_insert;
-	}
-	public String getNotify_delete() {
-		return notify_delete;
-	}
-	public void setNotify_delete(String notify_delete) {
-		this.notify_delete = notify_delete;
-	}
-	public String getOperation_type() {
-		return operation_type;
-	}
-	public void setOperation_type(String operation_type) {
-		this.operation_type = operation_type;
-	}
-	public String getTriggerName() {
-		return triggerName;
-	}
-	public void setTriggerName(String triggerName) {
-		this.triggerName = triggerName;
-	}
-	@Override
-	public String toString() {
-		try {
-	        return new com.fasterxml.jackson.databind.ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
-	    } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
-			return notify_field+ " : "+endpoint+ " : "+username+ " : "+password+ " : "+response_body;
-	    }
-
-	}
-	
-}
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotifyClientResponse.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotifyClientResponse.java
deleted file mode 100644
index 963352d0..00000000
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonNotifyClientResponse.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.datastore.jsonobjects;
-
-import java.io.Serializable;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-
-import io.swagger.annotations.ApiModel;
-
-@ApiModel(value = "JsonNotifyClientResponse", description = "Json model for callback")
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class JsonNotifyClientResponse implements Serializable {
-	private String message;
-    private String status;
-    
-	public String getMessage() {
-		return message;
-	}
-	public void setMessage(String message) {
-		this.message = message;
-	}
-	public String getStatus() {
-		return status;
-	}
-	public void setStatus(String status) {
-		this.status = status;
-	}
-
-	@Override
-	public String toString() {
-		try {
-	        return new com.fasterxml.jackson.databind.ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(this);
-	    } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
-			return message+ " : "+status;
-	    }
-
-	}
-    
-}
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
index ef56c5de..64bc3887 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonSelect.java
@@ -27,13 +27,13 @@ import java.io.ObjectOutput;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.Map;
-import org.apache.log4j.Logger;
+
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class JsonSelect implements Serializable {
     private Map<String, String> consistencyInfo;
-    static Logger logger = Logger.getLogger(JsonSelect.class.getName());
+
 
     public Map<String, String> getConsistencyInfo() {
         return consistencyInfo;
@@ -51,7 +51,6 @@ public class JsonSelect implements Serializable {
             out.writeObject(this);
         } catch (IOException e) {
             // TODO Auto-generated catch block
-        	logger.error("Error", e);
             e.printStackTrace();
         }
         return bos.toByteArray();
diff --git a/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java b/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
index c1a56819..3ab5ea0d 100644
--- a/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
+++ b/src/main/java/org/onap/music/datastore/jsonobjects/JsonUpdate.java
@@ -38,12 +38,11 @@ import io.swagger.annotations.ApiModelProperty;
 public class JsonUpdate implements Serializable {
     private String keyspaceName;
     private String tableName;
-    private transient Map<String, Object> values;
-    private String ttl;
-    private String timestamp;
+    private Map<String, Object> values;
+    private String ttl, timestamp;
     private Map<String, String> consistencyInfo;
-    private transient Map<String, Object> conditions;
-    private transient Map<String, Object> row_specification;
+    private Map<String, Object> conditions;
+    private Map<String, Object> row_specification;
 
     @ApiModelProperty(value = "Conditions")
     public Map<String, Object> getConditions() {
diff --git a/src/main/java/org/onap/music/eelf/healthcheck/MusicHealthCheck.java b/src/main/java/org/onap/music/eelf/healthcheck/MusicHealthCheck.java
index af6e6151..5f6329a1 100644
--- a/src/main/java/org/onap/music/eelf/healthcheck/MusicHealthCheck.java
+++ b/src/main/java/org/onap/music/eelf/healthcheck/MusicHealthCheck.java
@@ -25,12 +25,7 @@ import java.util.UUID;
 
 import org.onap.music.datastore.PreparedQueryObject;
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.exceptions.MusicLockingException;
 import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.lockingservice.MusicLockingService;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
@@ -56,19 +51,16 @@ public class MusicHealthCheck {
 			result = getAdminKeySpace(consistency);
 		} catch(Exception e) {
 			if(e.getMessage().toLowerCase().contains("unconfigured table healthcheck")) {
-				logger.error("Error", e);
-				logger.debug("Creating table....");
+				System.out.println("Creating table....");
 				boolean ksresult = createKeyspace();
 				if(ksresult)
 					try {
 						result = getAdminKeySpace(consistency);
 					} catch (MusicServiceException e1) {
 						// TODO Auto-generated catch block
-						logger.error("Error", e);
 						e1.printStackTrace();
 					}
 			} else {
-				logger.error("Error", e);
 				return "One or more nodes are down or not responding.";
 			}
 		}
@@ -106,32 +98,13 @@ public class MusicHealthCheck {
 		} catch (MusicServiceException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
-			logger.error("Error", e);
 		}
-		if(rs != null && rs.getResult().toLowerCase().contains("success"))
+		if(rs.getResult().toLowerCase().contains("success"))
 			return true;
 		else
 			return false;
 	}
 
-	public String getZookeeperStatus() {
-
-		String host = MusicUtil.getMyZkHost();
-		logger.info(EELFLoggerDelegate.applicationLogger, "Getting Status for Zookeeper Host: " + host);
-		try {
-			MusicLockingService lockingService = MusicCore.getLockingServiceHandle();
-			// additionally need to call the ZK to create,aquire and delete lock
-		} catch (MusicLockingException e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.LOCKINGERROR,
-					ErrorTypes.CONNECTIONERROR, ErrorSeverity.CRITICAL);
-			return "INACTIVE";
-		}
-
-		logger.info(EELFLoggerDelegate.applicationLogger, "Zookeeper is Active and Running");
-		return "ACTIVE";
-
-	}
-
 	public String getCassandrHost() {
 		return cassandrHost;
 	}
diff --git a/src/main/java/org/onap/music/lockingservice/LockListener.java b/src/main/java/org/onap/music/lockingservice/LockListener.java
deleted file mode 100644
index 33188e60..00000000
--- a/src/main/java/org/onap/music/lockingservice/LockListener.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.lockingservice;
-
-/**
- * This class has two methods which are call back methods when a lock is acquired and when the lock
- * is released.
- *
- */
-public interface LockListener {
-    /**
-     * call back called when the lock is acquired
-     */
-    public void lockAcquired();
-
-    /**
-     * call back called when the lock is released.
-     */
-    public void lockReleased();
-}
diff --git a/src/main/java/org/onap/music/lockingservice/MusicLockState.java b/src/main/java/org/onap/music/lockingservice/MusicLockState.java
deleted file mode 100644
index 04a1e6b2..00000000
--- a/src/main/java/org/onap/music/lockingservice/MusicLockState.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.lockingservice;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutput;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-
-// the state variable that will be stored in zookeeper, capturing the transitions of
-public class MusicLockState implements Serializable {
-    public enum LockStatus {
-        UNLOCKED, BEING_LOCKED, LOCKED
-    };// captures the state of the lock
-
-    private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MusicLockState.class);
-    LockStatus lockStatus;
-    boolean needToSyncQuorum = false;
-    String lockHolder;
-    long leasePeriod = Long.MAX_VALUE;
-    long leaseStartTime = -1;
-    
-    private String errorMessage = null;
-    
-    public MusicLockState(String errorMessage) {
-        this.errorMessage = errorMessage;
-    }
-
-    public MusicLockState(LockStatus lockStatus, String lockHolder) {
-        this.lockStatus = lockStatus;
-        this.lockHolder = lockHolder;
-    }
-
-    public MusicLockState(LockStatus lockStatus, String lockHolder, boolean needToSyncQuorum) {
-        this.lockStatus = lockStatus;
-        this.lockHolder = lockHolder;
-        this.needToSyncQuorum = needToSyncQuorum;
-    }
-
-
-    public long getLeasePeriod() {
-        return leasePeriod;
-    }
-
-    public boolean isNeedToSyncQuorum() {
-        return needToSyncQuorum;
-    }
-
-
-
-    public void setLeasePeriod(long leasePeriod) {
-        this.leasePeriod = leasePeriod;
-    }
-
-
-    public long getLeaseStartTime() {
-        return leaseStartTime;
-    }
-
-
-    public void setLeaseStartTime(long leaseStartTime) {
-        this.leaseStartTime = leaseStartTime;
-    }
-
-
-
-    public LockStatus getLockStatus() {
-        return lockStatus;
-    }
-
-    public void setLockStatus(LockStatus lockStatus) {
-        this.lockStatus = lockStatus;
-    }
-
-    public String getLockHolder() {
-        return lockHolder;
-    }
-
-    public void setLockHolder(String lockHolder) {
-        this.lockHolder = lockHolder;
-    }
-
-    public String getErrorMessage() {
-		return errorMessage;
-	}
-    
-    public byte[] serialize() {
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        ObjectOutput out = null;
-        try {
-            out = new ObjectOutputStream(bos);
-            out.writeObject(this);
-        } catch (IOException e) {
-        	logger.error("Error", e);
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.IOERROR, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
-        }
-        return bos.toByteArray();
-    }
-
-    public static MusicLockState deSerialize(byte[] data) {
-        ByteArrayInputStream bis = new ByteArrayInputStream(data);
-        Object o = null;
-        ObjectInput in = null;
-        try {
-            in = new ObjectInputStream(bis);
-            o = in.readObject();
-        } catch (ClassNotFoundException | IOException e) {
-        	logger.error("Error", e);
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.UNKNOWN);
-        }
-        return (MusicLockState) o;
-    }
-}
diff --git a/src/main/java/org/onap/music/lockingservice/MusicLockingService.java b/src/main/java/org/onap/music/lockingservice/MusicLockingService.java
deleted file mode 100644
index f9c09338..00000000
--- a/src/main/java/org/onap/music/lockingservice/MusicLockingService.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * ============LICENSE_START========================================== org.onap.music
- * =================================================================== Copyright (c) 2017 AT&T
- * Intellectual Property ===================================================================
- * 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.music.lockingservice;
-
-
-import java.io.IOException;
-import java.util.StringTokenizer;
-import java.util.concurrent.CountDownLatch;
-
-import org.apache.zookeeper.KeeperException;
-import org.apache.zookeeper.WatchedEvent;
-import org.apache.zookeeper.Watcher;
-import org.apache.zookeeper.Watcher.Event.KeeperState;
-import org.apache.zookeeper.ZooKeeper;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.exceptions.MusicLockingException;
-import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.main.CachingUtil;
-import org.onap.music.main.MusicUtil;
-
-
-public class MusicLockingService implements Watcher {
-
-    
-    private static final int SESSION_TIMEOUT = 180000;
-    ZkStatelessLockService zkLockHandle = null;
-    private CountDownLatch connectedSignal = new CountDownLatch(1);
-    private static EELFLoggerDelegate logger =
-                    EELFLoggerDelegate.getLogger(MusicLockingService.class);
-
-    public MusicLockingService() throws MusicServiceException {
-        try {
-            ZooKeeper zk = new ZooKeeper(MusicUtil.getMyZkHost(), SESSION_TIMEOUT, this);
-            connectedSignal.await();
-            zkLockHandle = new ZkStatelessLockService(zk);
-        } catch (IOException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.IOERROR, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
-            throw new MusicServiceException("IO Error has occured" + e.getMessage());
-        } catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-            throw new MusicServiceException("Exception Occured " + e.getMessage());
-        }
-    }
-
-    public ZkStatelessLockService getzkLockHandle() {
-        return zkLockHandle;
-    }
-
-    public MusicLockingService(String lockServer) {
-        try {
-            ZooKeeper zk = new ZooKeeper(lockServer, SESSION_TIMEOUT, this);
-            connectedSignal.await();
-            zkLockHandle = new ZkStatelessLockService(zk);
-        } catch (IOException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.IOERROR, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
-        }catch( InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-		}catch(Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-		}
-    }
-
-    public void createLockaIfItDoesNotExist(String lockName) {
-        if (!zkLockHandle.checkIfLockExists(lockName)) {
-            String lockHolder = null;
-            MusicLockState ml = new MusicLockState(MusicLockState.LockStatus.UNLOCKED, lockHolder);
-            byte[] data = ml.serialize();
-            zkLockHandle.createLock(lockName, data);
-        }
-    }
-
-    public void setLockState(String lockName, MusicLockState mls) {
-        byte[] data = mls.serialize();
-        zkLockHandle.setNodeData(lockName, data);
-    }
-
-    public MusicLockState getLockState(String lockName) throws MusicLockingException {
-
-    	byte[] data = null;
-        try{
-        	data = zkLockHandle.getNodeData(lockName);
-        }catch (Exception ex){
-        	logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-        if(data !=null)
-        return MusicLockState.deSerialize(data);
-        else {
-        	logger.error(EELFLoggerDelegate.errorLogger,"",AppMessages.INVALIDLOCK, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        	throw new  MusicLockingException("Invalid lock or acquire failed");
-        }
-    }
-
-    public String createLockId(String lockName) {
-        String lockIdWithSlash = zkLockHandle.createLockId(lockName);
-        return lockIdWithSlash.replace('/', '$');
-    }
-
-    public boolean isMyTurn(String lockIdWithDollar) {
-        String lockId = lockIdWithDollar.replace('$', '/');
-        StringTokenizer st = new StringTokenizer(lockId);
-        String lockName = "/" + st.nextToken("/");
-        try {
-            return zkLockHandle.lock(lockName, lockId);
-        } catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.LOCKINGERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch( InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-		}catch(Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-		}
-        return false;
-    }
-
-    public void unlockAndDeleteId(String lockIdWithDollar) throws KeeperException.NoNodeException {
-        String lockId = lockIdWithDollar.replace('$', '/');
-        zkLockHandle.unlock(lockId);
-        CachingUtil.deleteKeysFromDB("'"+lockId+"'");
-    }
-
-    public void deleteLock(String lockName) throws MusicLockingException {
-    	if(lockIdExists(lockName))
-    		zkLockHandle.deleteLock(lockName);
-    	else{
-    		throw new MusicLockingException("Lock does not exist.Please check the lock: " + lockName + " and try again");
-    	}
-    }
-
-    public String whoseTurnIsIt(String lockName) {
-        String lockHolder = zkLockHandle.currentLockHolder(lockName);
-        return lockHolder.replace('/', '$');
-
-    }
-
-    public void process(WatchedEvent event) { // Watcher interface
-        if (event.getState() == KeeperState.SyncConnected) {
-            connectedSignal.countDown();
-        }
-    }
-
-
-    public void close() {
-        zkLockHandle.close();
-    }
-
-	public boolean lockIdExists(String lockIdWithDollar) {
-		String lockId = lockIdWithDollar.replace('$', '/');
-		return zkLockHandle.checkIfLockExists(lockId);
-	}
-
-}
diff --git a/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java b/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java
deleted file mode 100644
index 19f49beb..00000000
--- a/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.lockingservice;
-
-import org.apache.zookeeper.CreateMode;
-import org.apache.zookeeper.KeeperException;
-import org.apache.zookeeper.ZooDefs;
-import org.apache.zookeeper.ZooKeeper;
-import org.apache.zookeeper.data.ACL;
-import org.apache.zookeeper.data.Stat;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.lockingservice.ZooKeeperOperation;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * A base class for protocol implementations which provides a number of higher level helper methods
- * for working with ZooKeeper along with retrying synchronous operations if the connection to
- * ZooKeeper closes such as {@link #retryOperation(ZooKeeperOperation)}
- *
- */
-class ProtocolSupport {
-    private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ProtocolSupport.class);
-
-    protected ZooKeeper zookeeper;
-    private AtomicBoolean closed = new AtomicBoolean(false);
-    private long retryDelay = 500L;
-    private int retryCount = 10;
-    private List<ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
-
-    /**
-     * Closes this strategy and releases any ZooKeeper resources; but keeps the ZooKeeper instance
-     * open
-     */
-    public void close() {
-        if (closed.compareAndSet(false, true)) {
-            doClose();
-        }
-    }
-
-    /**
-     * return zookeeper client instance
-     * 
-     * @return zookeeper client instance
-     */
-    public ZooKeeper getZookeeper() {
-        return zookeeper;
-    }
-
-    /**
-     * return the acl its using
-     * 
-     * @return the acl.
-     */
-    public List<ACL> getAcl() {
-        return acl;
-    }
-
-    /**
-     * set the acl
-     * 
-     * @param acl the acl to set to
-     */
-    public void setAcl(List<ACL> acl) {
-        this.acl = acl;
-    }
-
-    /**
-     * get the retry delay in milliseconds
-     * 
-     * @return the retry delay
-     */
-    public long getRetryDelay() {
-        return retryDelay;
-    }
-
-    /**
-     * Sets the time waited between retry delays
-     * 
-     * @param retryDelay the retry delay
-     */
-    public void setRetryDelay(long retryDelay) {
-        this.retryDelay = retryDelay;
-    }
-
-    /**
-     * Allow derived classes to perform some custom closing operations to release resources
-     */
-    protected void doClose() {
-        throw new UnsupportedOperationException();
-    }
-
-
-    /**
-     * Perform the given operation, retrying if the connection fails
-     * 
-     * @return object. it needs to be cast to the callee's expected return type.
-     * @param operation FILL IN
-     * @throws KeeperException FILL IN
-     * @throws InterruptedException FILL IN
-     */
-    protected Object retryOperation(ZooKeeperOperation operation)
-                    throws KeeperException, InterruptedException {
-        KeeperException exception = null;
-        for (int i = 0; i < retryCount; i++) {
-            try {
-                return operation.execute();
-            } catch (KeeperException.SessionExpiredException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.SESSIONEXPIRED+" for: " + zookeeper + " so reconnecting due to: " + e, ErrorSeverity.ERROR, ErrorTypes.SESSIONEXPIRED);
-                throw e;
-            } catch (KeeperException.ConnectionLossException e) {
-                if (exception == null) {
-                    exception = e;
-                }
-                logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.CONNCECTIVITYERROR, ErrorSeverity.ERROR, ErrorTypes.SESSIONEXPIRED);
-                logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Attempt " + i + " failed with connection loss so attempting to reconnect: " + e);
-                
-                retryDelay(i);
-            }
-        }
-        throw exception;
-    }
-
-    /**
-     * Ensures that the given path exists with no data, the current ACL and no flags
-     * 
-     * @param path the lock path
-     */
-    protected void ensurePathExists(String path) {
-        ensureExists(path, null, acl, CreateMode.PERSISTENT);
-    }
-
-    /**
-     * Ensures that the given path exists with the given data, ACL and flags
-     * 
-     * @param path the lock path
-     * @param data the data
-     * @param acl list of ACLs applying to the path
-     * @param flags create mode flags
-     */
-    protected void ensureExists(final String path, final byte[] data, final List<ACL> acl,
-                    final CreateMode flags) {
-        try {
-            retryOperation(new ZooKeeperOperation() {
-                public boolean execute() throws KeeperException, InterruptedException {
-                    Stat stat = zookeeper.exists(path, false);
-                    if (stat != null) {
-                        return true;
-                    }
-                    zookeeper.create(path, data, acl, flags);
-                    return true;
-                }
-            });
-        } catch (KeeperException e) {
-        	logger.error("Error", e);
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        } catch (InterruptedException e) {
-        	logger.error("Error", e);
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-    }
-
-    /**
-     * Returns true if this protocol has been closed
-     * 
-     * @return true if this protocol is closed
-     */
-    protected boolean isClosed() {
-        return closed.get();
-    }
-
-    /**
-     * Performs a retry delay if this is not the first attempt
-     * 
-     * @param attemptCount the number of the attempts performed so far
-     */
-    protected void retryDelay(int attemptCount) {
-        if (attemptCount > 0) {
-            try {
-                Thread.sleep(attemptCount * retryDelay);
-            } catch (InterruptedException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Thread failed to sleep: " + e);
-                Thread.currentThread().interrupt();
-            }
-        }
-    }
-}
diff --git a/src/main/java/org/onap/music/lockingservice/ZNodeName.java b/src/main/java/org/onap/music/lockingservice/ZNodeName.java
deleted file mode 100644
index 0c190f14..00000000
--- a/src/main/java/org/onap/music/lockingservice/ZNodeName.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.lockingservice;
-
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-
-/**
- * Represents an ephemeral znode name which has an ordered sequence number and can be sorted in
- * order
- *
- */
-class ZNodeName implements Comparable<ZNodeName> {
-    private final String name;
-    private String prefix;
-    private int sequence = -1;
-    private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ZNodeName.class);
-    
-    public ZNodeName(String name) {
-        if (name == null) {
-            throw new NullPointerException("id cannot be null");
-        }
-        this.name = name;
-        this.prefix = name;
-        int idx = name.lastIndexOf('-');
-        if (idx >= 0) {
-            this.prefix = name.substring(0, idx);
-            try {
-                this.sequence = Integer.parseInt(name.substring(idx + 1));
-                // If an exception occurred we misdetected a sequence suffix,
-                // so return -1.
-            } catch (NumberFormatException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Number format exception "+idx, ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
-            } catch (ArrayIndexOutOfBoundsException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Array out of bounds for  "+idx, ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
-            }
-        }
-    }
-
-    @Override
-    public String toString() {
-        return name.toString();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o)
-            return true;
-        if (o == null || getClass() != o.getClass())
-            return false;
-
-        ZNodeName sequence = (ZNodeName) o;
-
-        if (!name.equals(sequence.name))
-            return false;
-
-        return true;
-    }
-
-    @Override
-    public int hashCode() {
-        return name.hashCode() + 37;
-    }
-
-    public int compareTo(ZNodeName that) {
-        int answer = this.prefix.compareTo(that.prefix);
-        if (answer == 0) {
-            int s1 = this.sequence;
-            int s2 = that.sequence;
-            if (s1 == -1 && s2 == -1) {
-                return this.name.compareTo(that.name);
-            }
-            answer = s1 == -1 ? 1 : s2 == -1 ? -1 : s1 - s2;
-        }
-        return answer;
-    }
-
-    /**
-     * Returns the name of the znode
-     */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Returns the sequence number
-     */
-    public int getZNodeName() {
-        return sequence;
-    }
-
-    /**
-     * Returns the text prefix before the sequence number
-     */
-    public String getPrefix() {
-        return prefix;
-    }
-}
diff --git a/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java b/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java
deleted file mode 100644
index b09668b7..00000000
--- a/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java
+++ /dev/null
@@ -1,363 +0,0 @@
-/*
- * ============LICENSE_START========================================== org.onap.music
- * =================================================================== Copyright (c) 2017 AT&T
- * Intellectual Property ===================================================================
- * 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.music.lockingservice;
-
-
-import java.util.List;
-import java.util.SortedSet;
-import java.util.TreeSet;
-import org.apache.zookeeper.CreateMode;
-import org.apache.zookeeper.KeeperException;
-import org.apache.zookeeper.KeeperException.NoNodeException;
-import org.apache.zookeeper.ZooDefs;
-import org.apache.zookeeper.ZooKeeper;
-import org.apache.zookeeper.data.ACL;
-import org.apache.zookeeper.data.Stat;
-import org.onap.music.datastore.PreparedQueryObject;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.main.MusicCore;
-import org.onap.music.main.MusicUtil;
-
-import com.datastax.driver.core.DataType;
-
-/**
- * A <a href="package.html">protocol to implement an exclusive write lock or to elect a leader</a>.
- * <p/>
- * You invoke {@link #lock()} to start the process of grabbing the lock; you may get the lock then
- * or it may be some time later.
- * <p/>
- * You can register a listener so that you are invoked when you get the lock; otherwise you can ask
- * if you have the lock by calling {@link #isOwner()}
- *
- */
-public class ZkStatelessLockService extends ProtocolSupport {
-    public ZkStatelessLockService(ZooKeeper zk) {
-        zookeeper = zk;
-    }
-
-    private static EELFLoggerDelegate logger =
-                    EELFLoggerDelegate.getLogger(ZkStatelessLockService.class);
-
-    protected void createLock(final String path, final byte[] data) {
-        final List<ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
-        try {
-            retryOperation(new ZooKeeperOperation() {
-                public boolean execute() throws KeeperException, InterruptedException {
-                    zookeeper.create(path, data, acl, CreateMode.PERSISTENT);
-                    return true;
-                }
-            });
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-    }
-
-    public void close() {
-        try {
-            zookeeper.close();
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-    }
-
-    public void setNodeData(final String lockName, final byte[] data) {
-        try {
-            retryOperation(new ZooKeeperOperation() {
-                public boolean execute() throws KeeperException, InterruptedException {
-                    zookeeper.getSessionId();
-                    zookeeper.setData("/" + lockName, data, -1);
-                    return true;
-                }
-            });
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-
-    }
-
-    public byte[] getNodeData(final String lockName) {
-        try {
-            if (zookeeper.exists("/" + lockName, null) != null)
-                return zookeeper.getData("/" + lockName, false, null);
-            else
-                return null;
-
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-        return null;
-    }
-
-    public boolean checkIfLockExists(String lockName) {
-        boolean result = false;
-        try {
-            Stat stat = zookeeper.exists(lockName, false);
-            if (stat != null) {
-                result = true;
-            }
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-        return result;
-    }
-
-    public void createNode(String nodeName) {
-        ensurePathExists(nodeName);
-    }
-
-    public String createLockId(String dir) {
-        ensurePathExists(dir);
-        LockZooKeeperOperation zop = new LockZooKeeperOperation(dir);
-        try {
-            retryOperation(zop);
-        }catch (InterruptedException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }catch (KeeperException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-        }
-        return zop.getId();
-    }
-
-    /**
-     * Attempts to acquire the exclusive write lock returning whether or not it was acquired. Note
-     * that the exclusive lock may be acquired some time later after this method has been invoked
-     * due to the current lock owner going away.
-     */
-    public synchronized boolean lock(String dir, String lockId)
-                    throws KeeperException, InterruptedException {
-        if (isClosed()) {
-            return false;
-        }
-        LockZooKeeperOperation zop = new LockZooKeeperOperation(dir, lockId);
-        return (Boolean) retryOperation(zop);
-    }
-
-    /**
-     * Removes the lock or associated znode if you no longer require the lock. this also removes
-     * your request in the queue for locking in case you do not already hold the lock.
-     * 
-     * @throws RuntimeException throws a runtime exception if it cannot connect to zookeeper.
-     * @throws NoNodeException 
-     */
-    public synchronized void unlock(String lockId) throws RuntimeException, KeeperException.NoNodeException {
-        final String id = lockId;
-        if (!isClosed() && id != null) {
-            try {
-                ZooKeeperOperation zopdel = new ZooKeeperOperation() {
-                    public boolean execute() throws KeeperException, InterruptedException {
-                        zookeeper.delete(id, -1);
-                        return Boolean.TRUE;
-                    }
-                };
-                zopdel.execute();
-            } catch (InterruptedException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                // set that we have been interrupted.
-                Thread.currentThread().interrupt();
-            } catch (KeeperException.NoNodeException e) {
-                // do nothing
-            	throw new KeeperException.NoNodeException("Lock doesn't exists. Release lock operation failed.");
-            } catch (KeeperException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
-            }
-        }
-    }
-
-    public synchronized String currentLockHolder(String mainLock) {
-        final String id = mainLock;
-        if (!isClosed() && id != null) {
-            List<String> names;
-            try {
-                names = zookeeper.getChildren(id, false);
-                if (names.isEmpty())
-                    return "";
-                SortedSet<ZNodeName> sortedNames = new TreeSet<ZNodeName>();
-                for (String name : names) {
-                    sortedNames.add(new ZNodeName(id + "/" + name));
-                }
-                return sortedNames.first().getName();
-            } catch (InterruptedException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                // set that we have been interrupted.
-                Thread.currentThread().interrupt();
-            } catch (KeeperException.NoNodeException e) {
-                // do nothing
-            } catch (KeeperException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
-            }
-        }
-        return "No lock holder!";
-    }
-
-    public synchronized void deleteLock(String mainLock) {
-        final String id = mainLock;
-        if (!isClosed() && id != null) {
-            try {
-                ZooKeeperOperation zopdel = new ZooKeeperOperation() {
-                    public boolean execute() throws KeeperException, InterruptedException {
-                        List<String> names = zookeeper.getChildren(id, false);
-                        for (String name : names) {
-                            zookeeper.delete(id + "/" + name, -1);
-                        }
-                        zookeeper.delete(id, -1);
-                        return Boolean.TRUE;
-                    }
-                };
-                zopdel.execute();
-            } catch (InterruptedException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                // set that we have been interrupted.
-                Thread.currentThread().interrupt();
-            } catch (KeeperException.NoNodeException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                // do nothing
-            } catch (KeeperException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
-                throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
-            }
-        }
-
-    }
-
-    /**
-     * a zoookeeper operation that is mainly responsible for all the magic required for locking.
-     */
-    private class LockZooKeeperOperation implements ZooKeeperOperation {
-
-        /**
-         * find if we have been created earlier if not create our node
-         * 
-         * @param prefix the prefix node
-         * @param zookeeper the zookeeper client
-         * @param dir the dir parent
-         * @throws KeeperException
-         * @throws InterruptedException
-         */
-        private String dir;
-        private String id = null;
-
-        public String getId() {
-            return id;
-        }
-
-        public LockZooKeeperOperation(String dir) {
-            this.dir = dir;
-        }
-
-        public LockZooKeeperOperation(String dir, String id) {
-            this.dir = dir;
-            this.id = id;
-        }
-
-        /**
-         * the command that is run and retried for actually obtaining the lock
-         * 
-         * @return if the command was successful or not
-         */
-        public boolean execute() throws KeeperException, InterruptedException {
-            do {
-                if (id == null) {
-                    String prefix = "x-";
-                    byte[] data = {0x12, 0x34};
-                    id = zookeeper.create(dir + "/" + prefix, data, getAcl(),
-                                    CreateMode.PERSISTENT_SEQUENTIAL);
-
-                    if (logger.isDebugEnabled()) {
-                    	logger.debug(EELFLoggerDelegate.debugLogger, "Created id: " + id);
-                    }
-                    if (id != null) {
-                        Stat stat = null;
-                        try {
-                            stat = zookeeper.exists(id, false);
-                        } catch (KeeperException | InterruptedException e1) {
-                            logger.error(EELFLoggerDelegate.errorLogger, "Error in execute: " + e1);
-                        }
-                        Long ctime = stat.getCtime();
-                        MusicUtil.zkNodeMap.put(id, ctime);
-                        PreparedQueryObject pQuery = new PreparedQueryObject();
-                        pQuery.appendQueryString(
-                                        "INSERT INTO admin.locks(lock_id, ctime) VALUES (?,?)");
-                        try {
-                            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), id));
-                            pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), ctime));
-                            MusicCore.eventualPut(pQuery);
-                        } catch (Exception e) {
-                        	logger.error(EELFLoggerDelegate.errorLogger, "Error in execute: " + e);
-                        }
-                        break;
-                   }
-                }
-                if (id != null) {
-                    List<String> names = zookeeper.getChildren(dir, false);
-                    if (names.isEmpty()) {
-                        logger.info(EELFLoggerDelegate.applicationLogger, "No children in: " + dir
-                                        + " when we've just " + "created one! Lets recreate it...");
-                        // lets force the recreation of the id
-                        id = null;
-                        return Boolean.FALSE;
-
-                    } else {
-                        // lets sort them explicitly (though they do seem to come back in order
-                        // ususally :)
-                        ZNodeName idName = new ZNodeName(id);
-                        SortedSet<ZNodeName> sortedNames = new TreeSet<ZNodeName>();
-                        for (String name : names) {
-                            sortedNames.add(new ZNodeName(dir + "/" + name));
-                        }
-                        if (!sortedNames.contains(idName))
-                            return Boolean.FALSE;
-
-                        SortedSet<ZNodeName> lessThanMe = sortedNames.headSet(idName);
-                        if (!lessThanMe.isEmpty()) {
-                            ZNodeName lastChildName = lessThanMe.last();
-                            String lastChildId = lastChildName.getName();
-                            if (logger.isDebugEnabled()) {
-                            	logger.debug(EELFLoggerDelegate.debugLogger, "watching less than me node: " + lastChildId);
-                            }
-                            Stat stat = zookeeper.exists(lastChildId, false);
-                            if (stat != null) {
-                                return Boolean.FALSE;
-                            } else {
-                                logger.info(EELFLoggerDelegate.applicationLogger,
-                                                "Could not find the" + " stats for less than me: "
-                                                                + lastChildName.getName());
-                            }
-                        } else
-                            return Boolean.TRUE;
-                    }
-                }
-            } while (id == null);
-            return Boolean.FALSE;
-        }
-    }
-
-}
-
diff --git a/src/main/java/org/onap/music/lockingservice/ZooKeeperOperation.java b/src/main/java/org/onap/music/lockingservice/ZooKeeperOperation.java
deleted file mode 100644
index 7020d14d..00000000
--- a/src/main/java/org/onap/music/lockingservice/ZooKeeperOperation.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.lockingservice;
-
-import org.apache.zookeeper.KeeperException;
-
-/**
- * A callback object which can be used for implementing retry-able operations in the 
- * {@link org.onap.music.lockingservice.ProtocolSupport} class
- *
- */
-public interface ZooKeeperOperation {
-    
-    /**
-     * Performs the operation - which may be involved multiple times if the connection
-     * to ZooKeeper closes during this operation
-     *
-     * @return the result of the operation or null
-     * @throws KeeperException FILL IN
-     * @throws InterruptedException FILL IN
-     */
-    public boolean execute() throws KeeperException, InterruptedException;
-}
diff --git a/src/main/java/org/onap/music/main/CachingUtil.java b/src/main/java/org/onap/music/main/CachingUtil.java
index a81887a0..d3654118 100755
--- a/src/main/java/org/onap/music/main/CachingUtil.java
+++ b/src/main/java/org/onap/music/main/CachingUtil.java
@@ -21,24 +21,28 @@
  */
 package org.onap.music.main;
 
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.jcs.JCS;
 import org.apache.commons.jcs.access.CacheAccess;
+import org.codehaus.jackson.map.ObjectMapper;
 import org.mindrot.jbcrypt.BCrypt;
 import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.AAFResponse;
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
 import org.onap.music.eelf.logging.format.ErrorTypes;
 import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.datastore.jsonobjects.JsonCallback;
+
+import com.att.eelf.configuration.EELFLogger;
 import com.datastax.driver.core.DataType;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
@@ -61,8 +65,6 @@ public class CachingUtil implements Runnable {
     private static CacheAccess<String, Map<String, String>> aafCache = JCS.getInstance("aafCache");
     private static CacheAccess<String, String> appNameCache = JCS.getInstance("appNameCache");
     private static CacheAccess<String, Map<String, String>> musicValidateCache = JCS.getInstance("musicValidateCache");
-    private static CacheAccess<String, JsonCallback> callBackCache = JCS.getInstance("callBackCache");
-    private static CacheAccess<String, List<String>> callbackNotifyList = JCS.getInstance("callbackNotifyList");
     private static Map<String, Number> userAttempts = new HashMap<>();
     private static Map<String, Calendar> lastFailedTime = new HashMap<>();
 
@@ -71,25 +73,7 @@ public class CachingUtil implements Runnable {
             return true;
         return false;
     }
-    
-    public static void updateCallBackCache(String appName, JsonCallback jsonCallBack) {
-    	logger.info("updateCallBackCache: updating cache.....");
-    	callBackCache.put(appName, jsonCallBack);
-    }
-    
-    public static JsonCallback getCallBackCache(String appName) {
-    	return callBackCache.get(appName);
-    }
 
-    public static void updateCallbackNotifyList(List<String> notifyList) {
-    	logger.info("callbackNotifyList: updating cache.....");
-    	callbackNotifyList.put("callbackNotify", notifyList);
-    }
-    
-    public static List<String> getCallbackNotifyList() {
-    	return callbackNotifyList.get("callbackNotify");
-    }
-    
     public void initializeMusicCache() {
         logger.info(EELFLoggerDelegate.applicationLogger,"Initializing Music Cache...");
         musicCache.put("isInitialized", "true");
@@ -105,6 +89,7 @@ public class CachingUtil implements Runnable {
             pQuery.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), false));
         } catch (Exception e1) {
             logger.error(EELFLoggerDelegate.errorLogger, e1.getMessage(),AppMessages.CACHEERROR, ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
+            e1.printStackTrace();
         }
         ResultSet rs = MusicCore.get(pQuery);
         Iterator<Row> it = rs.iterator();
@@ -117,8 +102,8 @@ public class CachingUtil implements Runnable {
             String keySpace = row.getString("application_name");
             try {
                 userAttempts.put(nameSpace, 0);
-                boolean responseObj = triggerAAF(nameSpace, userId, password);
-                if (responseObj) {
+                AAFResponse responseObj = triggerAAF(nameSpace, userId, password);
+                if (responseObj.getNs().size() > 0) {
                     map = new HashMap<>();
                     map.put(userId, password);
                     aafCache.put(nameSpace, map);
@@ -129,6 +114,7 @@ public class CachingUtil implements Runnable {
             } catch (Exception e) {
                 logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.INFO, ErrorTypes.GENERALSERVICEERROR);
                 logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Something at AAF was changed for ns: " + nameSpace+" So not updating Cache for the namespace. ");
+                e.printStackTrace();
             }
         }
 
@@ -147,7 +133,7 @@ public class CachingUtil implements Runnable {
     public static boolean authenticateAAFUser(String nameSpace, String userId, String password,
                     String keySpace) throws Exception {
 
-        if (aafCache.get(nameSpace) != null && musicCache.get(keySpace)!=null) {
+        if (aafCache.get(nameSpace) != null) {
             if (keySpace != null && !musicCache.get(keySpace).equals(nameSpace)) {
             	logger.info(EELFLoggerDelegate.applicationLogger,"Create new application for the same namespace.");
             } else if (aafCache.get(nameSpace).get(userId).equals(password)) {
@@ -178,13 +164,12 @@ public class CachingUtil implements Runnable {
             }
         }
 
-        boolean responseObj = triggerAAF(nameSpace, userId, password);
-        if (responseObj) {
+        AAFResponse responseObj = triggerAAF(nameSpace, userId, password);
+        if (responseObj.getNs().size() > 0) {
             //if (responseObj.getNs().get(0).getAdmin().contains(userId)) {
-            	Map<String, String> map = new HashMap<>();
-                map.put(userId, password);
-                aafCache.put(nameSpace, map);
-                CachingUtil.updateMusicCache(keySpace, nameSpace);
+            	//Map<String, String> map = new HashMap<>();
+                //map.put(userId, password);
+                //aafCache.put(nameSpace, map);
             	return true;
             //}
         }
@@ -192,7 +177,7 @@ public class CachingUtil implements Runnable {
         return false;
     }
 
-    private static boolean triggerAAF(String nameSpace, String userId, String password)
+    private static AAFResponse triggerAAF(String nameSpace, String userId, String password)
                     throws Exception {
         if (MusicUtil.getAafEndpointUrl() == null) {
         	logger.error(EELFLoggerDelegate.errorLogger,"",AppMessages.UNKNOWNERROR,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
@@ -225,14 +210,14 @@ public class CachingUtil implements Runnable {
             // TODO Allow for 2-3 times and forbid any attempt to trigger AAF with invalid values
             // for specific time.
         }
-        /*response.getHeaders().put(HttpHeaders.CONTENT_TYPE,
+        response.getHeaders().put(HttpHeaders.CONTENT_TYPE,
                         Arrays.asList(MediaType.APPLICATION_JSON));
         // AAFResponse output = response.getEntity(AAFResponse.class);
         response.bufferEntity();
         String x = response.getEntity(String.class);
-        AAFResponse responseObj = new ObjectMapper().readValue(x, AAFResponse.class);*/
+        AAFResponse responseObj = new ObjectMapper().readValue(x, AAFResponse.class);
         
-        return true;
+        return responseObj;
     }
 
     public static void updateMusicCache(String keyspace, String nameSpace) {
@@ -271,6 +256,7 @@ public class CachingUtil implements Runnable {
                     appNameCache.put(namespace, isAAF);
             } catch (Exception e) {
             	logger.error(EELFLoggerDelegate.errorLogger,  e.getMessage(), AppMessages.QUERYERROR,ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+            	e.printStackTrace();
             }
         }
         return isAAF;
@@ -288,6 +274,7 @@ public class CachingUtil implements Runnable {
                 uuid = rs.getUUID("uuid").toString();
             } catch (Exception e) {
                 logger.error(EELFLoggerDelegate.errorLogger,"Exception occured during uuid retrieval from DB."+e.getMessage());
+                e.printStackTrace();
             }
         }
         return uuid;
@@ -304,6 +291,7 @@ public class CachingUtil implements Runnable {
             appName = rs.getString("application_name");
         } catch (Exception e) {
         	logger.error(EELFLoggerDelegate.errorLogger,  e.getMessage(), AppMessages.QUERYERROR, ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+            e.printStackTrace();
         }
         return appName;
     }
@@ -350,6 +338,7 @@ public class CachingUtil implements Runnable {
 			rs = MusicCore.get(queryObject).one();
 		} catch (MusicServiceException e) {
 			// TODO Auto-generated catch block
+			e.printStackTrace();
 			resultMap.put("Exception", "Unable to process operation. Error is "+e.getMessage());
 			return resultMap;
         } catch (InvalidQueryException e) {
@@ -393,13 +382,14 @@ public class CachingUtil implements Runnable {
         try {
             queryObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspace));
         } catch (Exception e) {
-        	 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR, ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
+            e.printStackTrace();
         }
         Row rs = null;
         try {
             rs = MusicCore.get(queryObject).one();
         } catch (MusicServiceException e) {
-        	resultMap.put("Exception", "Unable to process operation. Error is "+e.getMessage());
+            e.printStackTrace();
+            resultMap.put("Exception", "Unable to process operation. Error is "+e.getMessage());
             return resultMap;
         }
         if(rs == null) {
@@ -427,15 +417,4 @@ public class CachingUtil implements Runnable {
         CachingUtil.updateMusicValidateCache(nameSpace, userId, pwd);
         return resultMap;
     }
-
-    public static void deleteKeysFromDB(String deleteKeys) {
-        PreparedQueryObject pQuery = new PreparedQueryObject();
-        pQuery.appendQueryString(
-                        "DELETE FROM admin.locks WHERE lock_id IN ("+deleteKeys+")");
-        try {
-            MusicCore.nonKeyRelatedPut(pQuery, "eventual");
-        } catch (Exception e) {
-        	 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR, "Error in deleteKeysFromDB");
-        }
-    }
 }
diff --git a/src/main/java/org/onap/music/main/CronJobManager.java b/src/main/java/org/onap/music/main/CronJobManager.java
index 4928044e..5b7a8de4 100644
--- a/src/main/java/org/onap/music/main/CronJobManager.java
+++ b/src/main/java/org/onap/music/main/CronJobManager.java
@@ -32,21 +32,16 @@ import javax.servlet.ServletContextListener;
 import javax.servlet.annotation.WebListener;
 
 import org.onap.music.datastore.PreparedQueryObject;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
 import org.onap.music.exceptions.MusicLockingException;
 import org.onap.music.exceptions.MusicServiceException;
 
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
 
-//@WebListener
+@WebListener
 public class CronJobManager implements ServletContextListener {
 
     private ScheduledExecutorService scheduler;
-    private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(CronJobManager.class);
 
     @Override
     public void contextInitialized(ServletContextEvent event) {
@@ -58,25 +53,10 @@ public class CronJobManager implements ServletContextListener {
         try {
             ResultType result = MusicCore.nonKeyRelatedPut(pQuery, consistency);
         } catch (MusicServiceException e1) {
-        	logger.error(EELFLoggerDelegate.errorLogger, e1.getMessage(),ErrorSeverity.ERROR);
+            e1.printStackTrace();
         }
-
-      //Zookeeper cleanup
-        scheduler.scheduleAtFixedRate(new Runnable() {
-            @Override
-            public void run() {
-                deleteLocksFromDB();
-            }
-        } , 0, 24, TimeUnit.HOURS);
-    }
-
-    @Override
-    public void contextDestroyed(ServletContextEvent event) {
-        scheduler.shutdownNow();
-    }
-
-    public void deleteLocksFromDB() {
-        PreparedQueryObject pQuery = new PreparedQueryObject();
+        
+        pQuery = new PreparedQueryObject();
         pQuery.appendQueryString(
                         "select * from admin.locks");
             try {
@@ -91,22 +71,68 @@ public class CronJobManager implements ServletContextListener {
                     if(System.currentTimeMillis() >= ctime + 24 * 60 * 60 * 1000) {
                         expiredKeys = true;
                         String new_id = id.substring(1);
-                        try {
-                            MusicCore.deleteLock(new_id);
-                        } catch (MusicLockingException e) {
-                            logger.info(EELFLoggerDelegate.applicationLogger,
-                                     e.getMessage());
-                        }
-                        deleteKeys.append("'").append(id).append("'").append(",");
+                        MusicCore.deleteLock(new_id);
+                        deleteKeys.append(id).append(",");
                     }
-                }
+                    else {
+                        MusicUtil.zkNodeMap.put(id, ctime);
+                    }
+                };
                 if(expiredKeys) {
                     deleteKeys.deleteCharAt(deleteKeys.length()-1);
-                    CachingUtil.deleteKeysFromDB(deleteKeys.toString());
+                    deleteKeysFromDB(deleteKeys);
                }
             } catch (MusicServiceException e) {
-            	logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),ErrorSeverity.ERROR);
+                e.printStackTrace();
+            } catch (MusicLockingException e) {
+                e.printStackTrace();
+       }
+       
+      //Zookeeper cleanup
+        scheduler.scheduleAtFixedRate(new Runnable() {
+            @Override
+            public void run() {
+                Iterator<Entry<String, Long>> it = MusicUtil.zkNodeMap.entrySet().iterator();
+                StringBuilder deleteKeys = new StringBuilder();
+                Boolean expiredKeys = false;
+                while (it.hasNext()) {
+                    Map.Entry<String, Long> pair = (Map.Entry<String, Long>)it.next();
+                    long ctime = pair.getValue();
+                   if (System.currentTimeMillis() >= ctime + 24 * 60 * 60 * 1000) {
+                       try {
+                           expiredKeys = true;
+                           String id = pair.getKey();
+                           deleteKeys.append("'").append(id).append("'").append(",");
+                           MusicCore.deleteLock(id.substring(1));
+                           MusicUtil.zkNodeMap.remove(id);
+                           
+                       } catch (MusicLockingException e) {
+                          e.printStackTrace();
+                       }
+                   }
+                }
+                if(expiredKeys) {
+                    deleteKeys.deleteCharAt(deleteKeys.length()-1);
+                    deleteKeysFromDB(deleteKeys);
+               }
             }
+        } , 0, 24, TimeUnit.HOURS);
+    }
+
+    @Override
+    public void contextDestroyed(ServletContextEvent event) {
+        scheduler.shutdownNow();
+    }
+    
+    public void deleteKeysFromDB(StringBuilder deleteKeys) {
+        PreparedQueryObject pQuery = new PreparedQueryObject();
+        pQuery.appendQueryString(
+                        "DELETE FROM admin.locks WHERE lock_id IN ("+deleteKeys+")");
+        try {
+            MusicCore.nonKeyRelatedPut(pQuery, "eventual");
+        } catch (Exception e) {
+              e.printStackTrace();
+        }
     }
 
 }
diff --git a/src/main/java/org/onap/music/main/MusicCore.java b/src/main/java/org/onap/music/main/MusicCore.java
index 9f7b060b..6b32fc53 100644
--- a/src/main/java/org/onap/music/main/MusicCore.java
+++ b/src/main/java/org/onap/music/main/MusicCore.java
@@ -26,12 +26,13 @@ import java.io.StringWriter;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.StringTokenizer;
+import java.util.UUID;
 
-import org.apache.zookeeper.KeeperException;
-import org.apache.zookeeper.KeeperException.NoNodeException;
-import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.CassaDataStore;
+import org.onap.music.datastore.CassaLockStore;
+import org.onap.music.datastore.CassaLockStore.LockObject;
+import org.onap.music.datastore.MusicLockState;
 import org.onap.music.datastore.PreparedQueryObject;
-import org.onap.music.datastore.jsonobjects.JsonKeySpace;
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
@@ -39,9 +40,6 @@ import org.onap.music.eelf.logging.format.ErrorTypes;
 import org.onap.music.exceptions.MusicLockingException;
 import org.onap.music.exceptions.MusicQueryException;
 import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.lockingservice.MusicLockState;
-import org.onap.music.lockingservice.MusicLockState.LockStatus;
-import org.onap.music.lockingservice.MusicLockingService;
 
 import com.datastax.driver.core.ColumnDefinitions;
 import com.datastax.driver.core.ColumnDefinitions.Definition;
@@ -50,6 +48,7 @@ import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
 import com.datastax.driver.core.TableMetadata;
 
+
 /**
  * This class .....
  * 
@@ -57,10 +56,11 @@ import com.datastax.driver.core.TableMetadata;
  */
 public class MusicCore {
 
-    public static MusicLockingService mLockHandle = null;
-    public static MusicDataStore mDstoreHandle = null;
+    public static CassaLockStore mLockHandle = null;
+    public static CassaDataStore mDstoreHandle = null;
     private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MusicCore.class);
-
+    private static boolean unitTestRun=true;
+    
     public static class Condition {
         Map<String, Object> conditions;
         PreparedQueryObject selectQueryForTheRow;
@@ -73,22 +73,19 @@ public class MusicCore {
         public boolean testCondition() throws Exception {
             // first generate the row
             ResultSet results = quorumGet(selectQueryForTheRow);
-            Row row = null;
-            if(results != null) {
-                row = results.one();
-            }
+            Row row = results.one();
             return getDSHandle().doesRowSatisfyCondition(row, conditions);
         }
     }
 
 
-    public static MusicLockingService getLockingServiceHandle() throws MusicLockingException {
+    public static CassaLockStore getLockingServiceHandle() throws MusicLockingException {
         logger.info(EELFLoggerDelegate.applicationLogger,"Acquiring lock store handle");
         long start = System.currentTimeMillis();
 
         if (mLockHandle == null) {
             try {
-                mLockHandle = new MusicLockingService();
+                mLockHandle = new CassaLockStore(getDSHandle());
             } catch (Exception e) {
             	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKHANDLE,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
                 throw new MusicLockingException("Failed to aquire Locl store handle " + e);
@@ -104,11 +101,11 @@ public class MusicCore {
      * @param remoteIp
      * @return
      */
-    public static MusicDataStore getDSHandle(String remoteIp) {
+    public static CassaDataStore getDSHandle(String remoteIp) {
         logger.info(EELFLoggerDelegate.applicationLogger,"Acquiring data store handle");
         long start = System.currentTimeMillis();
         if (mDstoreHandle == null) {
-            mDstoreHandle = new MusicDataStore(remoteIp);
+            mDstoreHandle = new CassaDataStore(remoteIp);
         }
         long end = System.currentTimeMillis();
         logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to acquire data store handle:" + (end - start) + " ms");
@@ -120,15 +117,16 @@ public class MusicCore {
      * @return
      * @throws MusicServiceException 
      */
-    public static MusicDataStore getDSHandle() throws MusicServiceException {
+    public static CassaDataStore getDSHandle() throws MusicServiceException {
+		
         logger.info(EELFLoggerDelegate.applicationLogger,"Acquiring data store handle");
         long start = System.currentTimeMillis();
         if (mDstoreHandle == null) {
             // Quick Fix - Best to put this into every call to getDSHandle?
-            if (! "localhost".equals(MusicUtil.getMyCassaHost())) {
-                mDstoreHandle = new MusicDataStore(MusicUtil.getMyCassaHost());
+            if (! MusicUtil.getMyCassaHost().equals("localhost") ) {
+                mDstoreHandle = new CassaDataStore(MusicUtil.getMyCassaHost());
             } else {
-                mDstoreHandle = new MusicDataStore();
+                mDstoreHandle = new CassaDataStore();
             }
         }
         if(mDstoreHandle.getSession() == null) {
@@ -142,232 +140,160 @@ public class MusicCore {
         return mDstoreHandle;
     }
 
-    public static String createLockReference(String lockName) {
+    public static String createLockReference(String fullyQualifiedKey) {
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+        String lockName = splitString[2];
+
         logger.info(EELFLoggerDelegate.applicationLogger,"Creating lock reference for lock name:" + lockName);
         long start = System.currentTimeMillis();
-        String lockId = null;
+        String lockReference = null;
         try {
-            lockId = getLockingServiceHandle().createLockId("/" + lockName);
-        } catch (MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.CREATELOCK+lockName,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        	
-        }
+			lockReference = "" + getLockingServiceHandle().genLockRefandEnQueue(keyspace, table, lockName);
+		} catch (MusicLockingException | MusicServiceException | MusicQueryException e) {
+			e.printStackTrace();
+		}
         long end = System.currentTimeMillis();
         logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to create lock reference:" + (end - start) + " ms");
-        return lockId;
-    }
-
-    /**
-     * 
-     * @param key
-     * @return
-     */
-    public static boolean isTableOrKeySpaceLock(String key) {
-        String[] splitString = key.split("\\.");
-        if (splitString.length > 2)
-            return false;
-        else
-            return true;
+        return lockReference;
     }
 
-    /**
-     * 
-     * @param key
-     * @return
-     */
-    public static MusicLockState getMusicLockState(String key) {
-        long start = System.currentTimeMillis();
-        try {
-            String[] splitString = key.split("\\.");
-            String keyspaceName = splitString[0];
-            String tableName = splitString[1];
-            String primaryKey = splitString[2];
-            MusicLockState mls;
-            String lockName = keyspaceName + "." + tableName + "." + primaryKey;
-            mls = getLockingServiceHandle().getLockState(lockName);
-            long end = System.currentTimeMillis();
-            logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to get lock state:" + (end - start) + " ms");
-            return mls;
-        } catch (NullPointerException | MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.INVALIDLOCK,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-        return null;
-    }
 
-    public static ReturnType acquireLockWithLease(String key, String lockId, long leasePeriod) {
-        try {
-            long start = System.currentTimeMillis();
-            /* check if the current lock has exceeded its lease and if yes, release that lock */
-            MusicLockState mls = getMusicLockState(key);
-            if (mls != null) {
-                if (mls.getLockStatus().equals(LockStatus.LOCKED)) {
-                    logger.info(EELFLoggerDelegate.applicationLogger,"The current lock holder for " + key + " is " + mls.getLockHolder()
-                                    + ". Checking if it has exceeded lease");
-                    long currentLockPeriod = System.currentTimeMillis() - mls.getLeaseStartTime();
-                    long currentLeasePeriod = mls.getLeasePeriod();
-                    if (currentLockPeriod > currentLeasePeriod) {
-                        logger.info(EELFLoggerDelegate.applicationLogger,"Lock period " + currentLockPeriod
-                                        + " has exceeded lease period " + currentLeasePeriod);
-                        boolean voluntaryRelease = false;
-                        String currentLockHolder = mls.getLockHolder();
-                        mls = releaseLock(currentLockHolder, voluntaryRelease);
-                    }
-                }
-            } else
-            	logger.error(EELFLoggerDelegate.errorLogger,key, AppMessages.INVALIDLOCK,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-          
-            /*
-             * call the traditional acquire lock now and if the result returned is true, set the
-             * begin time-stamp and lease period
-             */
-            if (acquireLock(key, lockId).getResult() == ResultType.SUCCESS) {
-                mls = getMusicLockState(key);// get latest state
-                if ( mls == null ) {
-                    logger.info(EELFLoggerDelegate.applicationLogger,"Music Lock State is null");
-                    return new ReturnType(ResultType.FAILURE, "Could not acquire lock, Lock State is null");                    
-                }
-                if (mls.getLeaseStartTime() == -1) {// set it again only if it is not set already
-                    mls.setLeaseStartTime(System.currentTimeMillis());
-                    mls.setLeasePeriod(leasePeriod);
-                    getLockingServiceHandle().setLockState(key, mls);
-                }
-                long end = System.currentTimeMillis();
-                logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to acquire leased lock:" + (end - start) + " ms");
-                return new ReturnType(ResultType.SUCCESS, "Accquired lock");
-            } else {
-                long end = System.currentTimeMillis();
-                logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to fail to acquire leased lock:" + (end - start) + " ms");
-                return new ReturnType(ResultType.FAILURE, "Could not acquire lock");
-            }
-        } catch (Exception e) {
-            StringWriter sw = new StringWriter();
-           	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR506E] Failed to aquire lock ",ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-            
-            String exceptionAsString = sw.toString();
-            return new ReturnType(ResultType.FAILURE,
-                            "Exception thrown in acquireLockWithLease:\n" + exceptionAsString);
-        }
+    public static ReturnType acquireLockWithLease(String fullyQualifiedKey, String lockReference, long leasePeriod) throws MusicLockingException, MusicQueryException, MusicServiceException  {
+     	evictExpiredLockHolder(fullyQualifiedKey,leasePeriod);
+    		return acquireLock(fullyQualifiedKey, lockReference);
     }
 
-    public static ReturnType acquireLock(String key, String lockId) throws MusicLockingException {
-        /*
-         * first check if I am on top. Since ids are not reusable there is no need to check
-         * lockStatus If the status is unlocked, then the above call will automatically return
-         * false.
-         */
-        Boolean result = false;
-        try {
-            result = getLockingServiceHandle().isMyTurn(lockId);
-        } catch (MusicLockingException e2) {
-            logger.error(EELFLoggerDelegate.errorLogger,AppMessages.INVALIDLOCK + lockId + " " + e2);
-            throw new MusicLockingException();
-        }
-        if (!result) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Not your turn, someone else has the lock");
-            try {
-				if (!getLockingServiceHandle().lockIdExists(lockId)) {
-					logger.info(EELFLoggerDelegate.applicationLogger, "In acquire lock: this lockId doesn't exist");
-					return new ReturnType(ResultType.FAILURE, "Lockid doesn't exist");
-				}
-			} catch (MusicLockingException e) {
-				logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.INVALIDLOCK+lockId,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-				 throw new MusicLockingException();
-			}
-            logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: returning failure");
-            return new ReturnType(ResultType.FAILURE, "Not your turn, someone else has the lock");
-        }
-
-
-        // this is for backward compatibility where locks could also be acquired on just
-        // keyspaces or tables.
-        if (isTableOrKeySpaceLock(key)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: A table or keyspace lock so no need to perform sync...so returning true");
-            return new ReturnType(ResultType.SUCCESS, "A table or keyspace lock so no need to perform sync...so returning true");
-        }
+    private static void evictExpiredLockHolder(String fullyQualifiedKey, long leasePeriod) throws MusicLockingException, MusicQueryException, MusicServiceException {
 
-        // read the lock name corresponding to the key and if the status is locked or being locked,
-        // then return false
-        MusicLockState currentMls = null;
-        MusicLockState newMls = null;
-        try {
-            currentMls = getMusicLockState(key);
-            String currentLockHolder = null;
-            if(currentMls != null) { currentLockHolder = currentMls.getLockHolder(); };
-            if (lockId.equals(currentLockHolder)) {
-                logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: You already have the lock!");
-                return new ReturnType(ResultType.SUCCESS, "You already have the lock!");
-            }
-        } catch (NullPointerException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.INVALIDLOCK+lockId,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-
-        // change status to "being locked". This state transition is necessary to ensure syncing
-        // before granting the lock
-        String lockHolder = null;
-        boolean needToSyncQuorum = false;
-        if (currentMls != null)
-            needToSyncQuorum = currentMls.isNeedToSyncQuorum();
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+        String primaryKeyValue = splitString[2];
 
+		LockObject currentLockHolderObject = getLockingServiceHandle().peekLockQueue(keyspace, table, primaryKeyValue);
+		
+		/* Release the lock of the previous holder if it has expired. if the update to the acquire time has not reached due to network delays, simply use the create time as the 
+		 * reference*/
+		
+		long referenceTime = Math.max(Long.parseLong(currentLockHolderObject.acquireTime), Long.parseLong(currentLockHolderObject.createTime));
+		if((System.currentTimeMillis() - referenceTime) > leasePeriod) {
+			forciblyReleaseLock(fullyQualifiedKey,  currentLockHolderObject.lockRef+"");
+            logger.info(EELFLoggerDelegate.applicationLogger, currentLockHolderObject.lockRef+" forcibly released");
+		}    	
+    }
+    
+    private static ReturnType isTopOfLockStore(String keyspace, String table, String primaryKeyValue, String lockReference) throws MusicLockingException, MusicQueryException, MusicServiceException {
+        
+        //return failure to lock holders too early or already evicted from the lock store
+        String topOfLockStoreS = getLockingServiceHandle().peekLockQueue(keyspace, table, primaryKeyValue).lockRef;
+        long topOfLockStoreL = Long.parseLong(topOfLockStoreS);
+        long lockReferenceL = Long.parseLong(lockReference);
 
-        newMls = new MusicLockState(MusicLockState.LockStatus.BEING_LOCKED, lockHolder,
-                        needToSyncQuorum);
-        try {
-            getLockingServiceHandle().setLockState(key, newMls);
-        } catch (MusicLockingException e1) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e1.getMessage(), AppMessages.LOCKSTATE+key,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+        if(lockReferenceL > topOfLockStoreL) {
+            logger.info(EELFLoggerDelegate.applicationLogger, lockReference+" is not the lock holder yet");
+            return new ReturnType(ResultType.FAILURE, lockReference+" is not the lock holder yet");
         }
-        logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Set lock state to being_locked");
+    			
 
-        // do syncing if this was a forced lock release
-        if (needToSyncQuorum) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Since there was a forcible release, need to sync quorum!");
-            try {
-              syncQuorum(key);
-            } catch (Exception e) {
-              logger.error(EELFLoggerDelegate.errorLogger,"Failed to set Lock state " + e);
-            }
-        }
+        if(lockReferenceL < topOfLockStoreL) {
+            logger.info(EELFLoggerDelegate.applicationLogger, lockReference+" is no longer/or was never in the lock store queue");
+            return new ReturnType(ResultType.FAILURE, lockReference+" is no longer/or was never in the lock store queue");
+       	}
+    		
+       	return new ReturnType(ResultType.SUCCESS, lockReference+" is top of lock store");
+    }
+    
+    public static ReturnType acquireLock(String fullyQualifiedKey, String lockReference) throws MusicLockingException, MusicQueryException, MusicServiceException {
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+        String primaryKeyValue = splitString[2];
 
-        // change status to locked
-        lockHolder = lockId;
-        needToSyncQuorum = false;
-        newMls = new MusicLockState(MusicLockState.LockStatus.LOCKED, lockHolder, needToSyncQuorum);
-        try {
-            getLockingServiceHandle().setLockState(key, newMls);
-        } catch (MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKSTATE+key,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-        logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Set lock state to locked and assigned current lock ref "
-                        + lockId + " as holder");
+        ReturnType result = isTopOfLockStore(keyspace, table, primaryKeyValue, lockReference);
         
-        return new ReturnType(result?ResultType.SUCCESS:ResultType.FAILURE, "Set lock state to locked and assigned a lock holder");
+        if(result.getResult().equals(ResultType.FAILURE))
+        		return result;//not top of the lock store q
+    		
+        //check to see if the value of the key has to be synced in case there was a forceful release
+        String syncTable = keyspace+".unsyncedKeys_"+table;
+		String query = "select * from "+syncTable+" where key='"+fullyQualifiedKey+"';";
+        PreparedQueryObject readQueryObject = new PreparedQueryObject();
+        readQueryObject.appendQueryString(query);
+		ResultSet results = getDSHandle().executeCriticalGet(readQueryObject);			
+		if (results.all().size() != 0) {
+			logger.info("In acquire lock: Since there was a forcible release, need to sync quorum!");
+			try {
+				syncQuorum(keyspace, table, primaryKeyValue);
+			} catch (Exception e) {
+				StringWriter sw = new StringWriter();
+	           	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR506E] Failed to aquire lock ",ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+	            String exceptionAsString = sw.toString();
+	            return new ReturnType(ResultType.FAILURE, "Exception thrown while syncing key:\n" + exceptionAsString);			
+	        }
+			String cleanQuery = "delete * from music_internal.unsynced_keys where key='"+fullyQualifiedKey+"';";
+	        PreparedQueryObject deleteQueryObject = new PreparedQueryObject();
+	        deleteQueryObject.appendQueryString(cleanQuery);
+			getDSHandle().executePut(deleteQueryObject, "critical");
+		}
+		
+		getLockingServiceHandle().updateLockAcquireTime(keyspace, table, primaryKeyValue, lockReference);
+		
+		return new ReturnType(ResultType.SUCCESS, lockReference+" is the lock holder for the key");
     }
 
 
 
     /**
      * 
-     * @param keyspaceName
-     * @param kspObject
-     * @return
-     * @throws Exception
+     * @param tableQueryObject
+     * @param consistency
+     * @return Boolean Indicates success or failure
+     * @throws MusicServiceException 
+     * 
+     * 
      */
-    public boolean createKeyspace(String keyspaceName, JsonKeySpace kspObject) throws Exception {
-        return true;
-    }
-
-
-    private static void syncQuorum(String key) throws Exception {
+    public static ResultType createTable(String keyspace, String table, PreparedQueryObject tableQueryObject, String consistency) throws MusicServiceException {
+	    	boolean result = false;
+	
+	    	try {
+		    	//create shadow locking table 
+	    		result = getLockingServiceHandle().createLockQueue(keyspace, table);
+	    		if(result == false) 
+	    			return ResultType.FAILURE;
+	
+	    		result = false;
+	    		
+	    		//create table to track unsynced_keys
+	    		table = "unsyncedKeys_"+table; 
+	    		
+	    		String tabQuery = "CREATE TABLE IF NOT EXISTS "+keyspace+"."+table
+	    				+ " ( key text,PRIMARY KEY (key) );";
+	    		System.out.println(tabQuery);
+	    		PreparedQueryObject queryObject = new PreparedQueryObject(); 
+	    		
+	    		queryObject.appendQueryString(tabQuery);
+	    		result = false;
+	    		result = getDSHandle().executePut(queryObject, "eventual");
+
+	    	
+	    		//create actual table
+	    		result = getDSHandle().executePut(tableQueryObject, consistency);
+	    	} catch (MusicQueryException | MusicServiceException | MusicLockingException ex) {
+	    		logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
+	    		throw new MusicServiceException(ex.getMessage());
+	    	}
+	    	return result?ResultType.SUCCESS:ResultType.FAILURE;
+    }
+
+    private static void syncQuorum(String keyspace, String table, String primaryKeyValue) throws Exception {
         logger.info(EELFLoggerDelegate.applicationLogger,"Performing sync operation---");
-        String[] splitString = key.split("\\.");
-        String keyspaceName = splitString[0];
-        String tableName = splitString[1];
-        String primaryKeyValue = splitString[2];
         PreparedQueryObject selectQuery = new PreparedQueryObject();
         PreparedQueryObject updateQuery = new PreparedQueryObject();
 
         // get the primary key d
-        TableMetadata tableInfo = returnColumnMetadata(keyspaceName, tableName);
+        TableMetadata tableInfo = returnColumnMetadata(keyspace, table);
         String primaryKeyName = tableInfo.getPrimaryKey().get(0).getName();// we only support single
                                                                            // primary key
         DataType primaryKeyType = tableInfo.getPrimaryKey().get(0).getType();
@@ -375,7 +301,7 @@ public class MusicCore {
                         MusicUtil.convertToActualDataType(primaryKeyType, primaryKeyValue);
 
         // get the row of data from a quorum
-        selectQuery.appendQueryString("SELECT *  FROM " + keyspaceName + "." + tableName + " WHERE "
+        selectQuery.appendQueryString("SELECT *  FROM " + keyspace + "." + table + " WHERE "
                         + primaryKeyName + "= ?" + ";");
         selectQuery.addValue(cqlFormattedPrimaryKeyValue);
         ResultSet results = null;
@@ -400,7 +326,7 @@ public class MusicCore {
                     fieldValueString.append(",");
                 counter = counter + 1;
             }
-            updateQuery.appendQueryString("UPDATE " + keyspaceName + "." + tableName + " SET "
+            updateQuery.appendQueryString("UPDATE " + keyspace + "." + table + " SET "
                             + fieldValueString + " WHERE " + primaryKeyName + "= ? " + ";");
             updateQuery.addValue(cqlFormattedPrimaryKeyValue);
 
@@ -442,81 +368,68 @@ public class MusicCore {
 
     /**
      * 
-     * @param lockName
+     * @param fullyQualifiedKey lockName
      * @return
      */
-    public static String whoseTurnIsIt(String lockName) {
-
+    public static String whoseTurnIsIt(String fullyQualifiedKey) {
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+        String primaryKeyValue = splitString[2];
         try {
-            return getLockingServiceHandle().whoseTurnIsIt("/" + lockName) + "";
-        } catch (MusicLockingException e) {
-         	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKINGERROR+lockName ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+            return getLockingServiceHandle().peekLockQueue(keyspace, table, primaryKeyValue)+"";
+        } catch (MusicLockingException | MusicServiceException | MusicQueryException e) {
+         	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKINGERROR+fullyQualifiedKey ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
         }
         return null;
-
-
     }
 
     /**
      * 
-     * @param lockId
+     * @param lockReference
      * @return
      */
-    public static String getLockNameFromId(String lockId) {
-        StringTokenizer st = new StringTokenizer(lockId);
+    public static String getLockNameFromId(String lockReference) {
+        StringTokenizer st = new StringTokenizer(lockReference);
         return st.nextToken("$");
     }
 
-    public static void destroyLockRef(String lockId) {
+    public static MusicLockState destroyLockRef(String fullyQualifiedKey, String lockReference) {
         long start = System.currentTimeMillis();
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+        String primaryKeyValue = splitString[2];
         try {
-            getLockingServiceHandle().unlockAndDeleteId(lockId);
-        } catch (MusicLockingException | NoNodeException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.DESTROYLOCK+lockId  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+            getLockingServiceHandle().deQueueLockRef(keyspace, table, primaryKeyValue, lockReference);
+        } catch (MusicLockingException | MusicServiceException | MusicQueryException e) {
+        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.DESTROYLOCK+lockReference  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
         } 
         long end = System.currentTimeMillis();
         logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to destroy lock reference:" + (end - start) + " ms");
+        return getMusicLockState(fullyQualifiedKey);
     }
 
-    public static MusicLockState releaseLock(String lockId, boolean voluntaryRelease) {
-        long start = System.currentTimeMillis();
-        try {
-            getLockingServiceHandle().unlockAndDeleteId(lockId);
-        } catch (MusicLockingException e1) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e1.getMessage(), AppMessages.RELEASELOCK+lockId  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        } catch (KeeperException.NoNodeException nne) {
-			logger.error(EELFLoggerDelegate.errorLogger,"Failed to release Lock " + lockId + " " + nne);
-			MusicLockState mls = new MusicLockState("Lock doesn't exists. Release lock operation failed.");
-			return mls;
-        }
-        String lockName = getLockNameFromId(lockId);
-        MusicLockState mls;
-        String lockHolder = null;
-        if (voluntaryRelease) {
-            mls = new MusicLockState(MusicLockState.LockStatus.UNLOCKED, lockHolder);
-            logger.info(EELFLoggerDelegate.applicationLogger,"In unlock: lock voluntarily released for " + lockId);
-        } else {
-            boolean needToSyncQuorum = true;
-            mls = new MusicLockState(MusicLockState.LockStatus.UNLOCKED, lockHolder,
-                            needToSyncQuorum);
-            logger.info(EELFLoggerDelegate.applicationLogger,"In unlock: lock forcibly released for " + lockId);
-        }
-        try {
-            getLockingServiceHandle().setLockState(lockName, mls);
-        } catch (MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.RELEASELOCK+lockId  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to release lock:" + (end - start) + " ms");
-        return mls;
-    }
-    
-    public static  void  voluntaryReleaseLock(String lockId) throws MusicLockingException{
-		try {
-			getLockingServiceHandle().unlockAndDeleteId(lockId);
-		} catch (KeeperException.NoNodeException e) {
-			// ??? No way
-		}
+    public static  MusicLockState  voluntaryReleaseLock(String fullyQualifiedKey, String lockReference) throws MusicLockingException{
+		return destroyLockRef(fullyQualifiedKey, lockReference);
+	}
+
+    public static  MusicLockState  forciblyReleaseLock(String fullyQualifiedKey, String lockReference) throws MusicLockingException, MusicServiceException, MusicQueryException{
+        String[] splitString = fullyQualifiedKey.split("\\.");
+        String keyspace = splitString[0];
+        String table = splitString[1];
+
+    		//leave a signal that this key could potentially be unsynchronized
+        String syncTable = keyspace+".unsyncedKeys_"+table;	
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+		String values = "(?)";
+		queryObject.addValue(fullyQualifiedKey);
+		String insQuery = "insert into "+syncTable+" (key) values "+values+"';";
+        queryObject.appendQueryString(insQuery);
+        getDSHandle().executePut(queryObject, "critical");	
+        
+        //now release the lock
+		return destroyLockRef(fullyQualifiedKey, lockReference);
 	}
 
     /**
@@ -525,17 +438,8 @@ public class MusicCore {
      * @throws MusicLockingException 
      */
     public static void deleteLock(String lockName) throws MusicLockingException {
-        long start = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Deleting lock for " + lockName);
-        try {
-            getLockingServiceHandle().deleteLock("/" + lockName);
-        } catch (MusicLockingException e) {
-         	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.DELTELOCK+lockName  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-         	throw new MusicLockingException(e.getMessage());
-        }
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to delete lock:" + (end - start) + " ms");
-    }
+    		//deprecated
+    	}
 
 
 
@@ -551,63 +455,12 @@ public class MusicCore {
     }
 
 
-    /**
-     * 
-     * @param nodeName
-     */
-    public static void pureZkCreate(String nodeName) {
-        try {
-            getLockingServiceHandle().getzkLockHandle().createNode(nodeName);
-        } catch (MusicLockingException e) {
-         	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle "  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-    }
-
-    /**
-     * 
-     * @param nodeName
-     * @param data
-     */
-    public static void pureZkWrite(String nodeName, byte[] data) {
-        long start = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Performing zookeeper write to " + nodeName);
-        try {
-            getLockingServiceHandle().getzkLockHandle().setNodeData(nodeName, data);
-        } catch (MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle "  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-        logger.info(EELFLoggerDelegate.applicationLogger,"Performed zookeeper write to " + nodeName);
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the actual zk put:" + (end - start) + " ms");
-    }
-
-    /**
-     * 
-     * @param nodeName
-     * @return
-     */
-    public static byte[] pureZkRead(String nodeName) {
-        long start = System.currentTimeMillis();
-        byte[] data = null;
-        try {
-            data = getLockingServiceHandle().getzkLockHandle().getNodeData(nodeName);
-        } catch (MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle "  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-        }
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the actual zk put:" + (end - start) + " ms");
-        return data;
-    }
-
 
 
     // Prepared Query Additions.
 
     /**
      * 
-     * @param keyspaceName
-     * @param tableName
-     * @param primaryKey
      * @param queryObject
      * @return ReturnType
      * @throws MusicServiceException
@@ -627,52 +480,51 @@ public class MusicCore {
             return new ReturnType(ResultType.FAILURE, "Failure");
         }
     }
-
+    
     /**
      * 
-     * @param keyspaceName
-     * @param tableName
-     * @param primaryKey
+     * @param keyspace
+     * @param table
+     * @param primaryKeyValue
      * @param queryObject
-     * @param lockId
+     * @param lockReference
      * @return
      */
-    public static ReturnType criticalPut(String keyspaceName, String tableName, String primaryKey,
-                    PreparedQueryObject queryObject, String lockId, Condition conditionInfo) {
+    public static ReturnType criticalPut(String keyspace, String table, String primaryKeyValue,
+                    PreparedQueryObject queryObject, String lockReference, Condition conditionInfo) {
         long start = System.currentTimeMillis();
-
         try {
-            MusicLockState mls = getLockingServiceHandle()
-                            .getLockState(keyspaceName + "." + tableName + "." + primaryKey);
-            if (mls.getLockHolder().equals(lockId) == true) {
-                if (conditionInfo != null)
-                  try {
-                    if (conditionInfo.testCondition() == false)
-                        return new ReturnType(ResultType.FAILURE,
-                                        "Lock acquired but the condition is not true");
-                  } catch (Exception e) {
-                    return new ReturnType(ResultType.FAILURE,
-                            "Exception thrown while doing the critical put, check sanctity of the row/conditions:\n"
-                                            + e.getMessage());
-                  }
-                getDSHandle().executePut(queryObject, MusicUtil.CRITICAL);
-                long end = System.currentTimeMillis();
-                logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the critical put:" + (end - start) + " ms");
-                return new ReturnType(ResultType.SUCCESS, "Update performed");
-            } else
-                return new ReturnType(ResultType.FAILURE,
-                                "Cannot perform operation since you are the not the lock holder");
-        } catch (MusicQueryException | MusicServiceException  e) {
+        ReturnType result = isTopOfLockStore(keyspace, table, primaryKeyValue, lockReference);
+        if(result.getResult().equals(ResultType.FAILURE))
+        		return result;//not top of the lock store q
+
+        if (conditionInfo != null)
+            try {
+              if (conditionInfo.testCondition() == false)
+                  return new ReturnType(ResultType.FAILURE,
+                                  "Lock acquired but the condition is not true");
+            } catch (Exception e) {
+              return new ReturnType(ResultType.FAILURE,
+                      "Exception thrown while checking the condition, check its sanctity:\n"
+                                      + e.getMessage());
+            }
+        	 
+          String query = queryObject.getQuery();
+          query = query.replaceFirst("SET", "using TIMESTAMP "+ v2sTimeStampInMicroseconds(lockReference, System.currentTimeMillis())+ " SET");
+      	  queryObject.replaceQueryString(query);
+      	  getDSHandle().executePut(queryObject, MusicUtil.CRITICAL);
+          long end = System.currentTimeMillis();
+          logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the critical put:" + (end - start) + " ms");
+        }catch (MusicQueryException | MusicServiceException | MusicLockingException  e) {
             logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
             return new ReturnType(ResultType.FAILURE,
-                            "Exception thrown while doing the critical put, check sanctity of the row/conditions:\n"
+                            "Exception thrown while doing the critical put\n"
                                             + e.getMessage());
-        }catch(MusicLockingException ex){
-            return new ReturnType(ResultType.FAILURE,ex.getMessage());
         }
-
+         return new ReturnType(ResultType.SUCCESS, "Update performed");
     }
 
+    
     /**
      * 
      * @param queryObject
@@ -689,10 +541,11 @@ public class MusicCore {
         try {
             result = getDSHandle().executePut(queryObject, consistency);
         } catch (MusicQueryException | MusicServiceException ex) {
-        	logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
+        	logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(), AppMessages.UNKNOWNERROR,
+                    ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
             throw new MusicServiceException(ex.getMessage());
         }
-        return result?ResultType.SUCCESS:ResultType.FAILURE;
+        return result ? ResultType.SUCCESS : ResultType.FAILURE;
     }
 
     /**
@@ -712,46 +565,29 @@ public class MusicCore {
         }
         return results;
     }
-    
-    public static String getMyHostId() {
-    	PreparedQueryObject pQuery = new PreparedQueryObject();
-    	pQuery.appendQueryString("SELECT HOST_ID FROM SYSTEM.LOCAL");
-		ResultSet rs = null;
-		try {
-			rs = getDSHandle().executeEventualGet(pQuery);
-			Row row = rs.one();
-			return (row == null) ? "UNKNOWN" : row.getUUID("HOST_ID").toString();
-		} catch (Exception e) {
-			e.printStackTrace();
-            logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
-        }
-		logger.error(EELFLoggerDelegate.errorLogger, "Some issue during MusicCore.getMyHostId");
-		return "UNKNOW";
-	}
 
     /**
      * This method performs DDL operations on cassandra, if the the resource is available. Lock ID
      * is used to check if the resource is free.
      * 
-     * @param keyspaceName name of the keyspace
-     * @param tableName name of the table
-     * @param primaryKey primary key value
+     * @param keyspace name of the keyspace
+     * @param table name of the table
+     * @param primaryKeyValue primary key value
      * @param queryObject query object containing prepared query and values
-     * @param lockId lock ID to check if the resource is free to perform the operation.
+     * @param lockReference lock ID to check if the resource is free to perform the operation.
      * @return ResultSet
      */
-    public static ResultSet criticalGet(String keyspaceName, String tableName, String primaryKey,
-                    PreparedQueryObject queryObject, String lockId) throws MusicServiceException {
+    public static ResultSet criticalGet(String keyspace, String table, String primaryKeyValue,
+                    PreparedQueryObject queryObject, String lockReference) throws MusicServiceException {
         ResultSet results = null;
+        
         try {
-            MusicLockState mls = getLockingServiceHandle()
-                            .getLockState(keyspaceName + "." + tableName + "." + primaryKey);
-            if (mls.getLockHolder().equals(lockId)) {
+            ReturnType result = isTopOfLockStore(keyspace, table, primaryKeyValue, lockReference);
+            if(result.getResult().equals(ResultType.FAILURE))
+            		return null;//not top of the lock store q
                 results = getDSHandle().executeCriticalGet(queryObject);
-            } else
-                throw new MusicServiceException("YOU DO NOT HAVE THE LOCK");
         } catch (MusicQueryException | MusicServiceException | MusicLockingException e) {
-        	logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
+        		logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
         }
         return results;
     }
@@ -765,22 +601,23 @@ public class MusicCore {
      * @param queryObject query object containing prepared query and values
      * @return ReturnType
      * @throws MusicLockingException 
+     * @throws MusicServiceException 
+     * @throws MusicQueryException 
      */
     public static ReturnType atomicPut(String keyspaceName, String tableName, String primaryKey,
-                    PreparedQueryObject queryObject, Condition conditionInfo) throws MusicLockingException {
-
+                    PreparedQueryObject queryObject, Condition conditionInfo) throws MusicLockingException, MusicQueryException, MusicServiceException {
         long start = System.currentTimeMillis();
-        String key = keyspaceName + "." + tableName + "." + primaryKey;
-        String lockId = createLockReference(key);
+        String fullyQualifiedKey = keyspaceName + "." + tableName + "." + primaryKey;
+        String lockReference = createLockReference(fullyQualifiedKey);
         long lockCreationTime = System.currentTimeMillis();
-        ReturnType lockAcqResult = acquireLock(key, lockId);
+        ReturnType lockAcqResult = acquireLock(fullyQualifiedKey, lockReference);
         long lockAcqTime = System.currentTimeMillis();
         if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockId);
+            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockReference);
             ReturnType criticalPutResult = criticalPut(keyspaceName, tableName, primaryKey,
-                            queryObject, lockId, conditionInfo);
+                            queryObject, lockReference, conditionInfo);
             long criticalPutTime = System.currentTimeMillis();
-            voluntaryReleaseLock(lockId);
+            voluntaryReleaseLock(fullyQualifiedKey,lockReference);
             long lockDeleteTime = System.currentTimeMillis();
             String timingInfo = "|lock creation time:" + (lockCreationTime - start)
                             + "|lock accquire time:" + (lockAcqTime - lockCreationTime)
@@ -789,49 +626,8 @@ public class MusicCore {
             criticalPutResult.setTimingInfo(timingInfo);
             return criticalPutResult;
         } else {
-            logger.info(EELFLoggerDelegate.applicationLogger,"unable to acquire lock, id " + lockId);
-            destroyLockRef(lockId);
-            return lockAcqResult;
-        }
-    }
-    
-    /**
-     * this function is mainly for the benchmarks to see the effect of lock deletion.
-     * 
-     * @param keyspaceName
-     * @param tableName
-     * @param primaryKey
-     * @param queryObject
-     * @param conditionInfo
-     * @return
-     * @throws MusicLockingException 
-     */
-    public static ReturnType atomicPutWithDeleteLock(String keyspaceName, String tableName,
-                    String primaryKey, PreparedQueryObject queryObject, Condition conditionInfo) throws MusicLockingException {
-
-        long start = System.currentTimeMillis();
-        String key = keyspaceName + "." + tableName + "." + primaryKey;
-        String lockId = createLockReference(key);
-        long lockCreationTime = System.currentTimeMillis();
-        long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-        ReturnType lockAcqResult = acquireLock(key, lockId);
-        long lockAcqTime = System.currentTimeMillis();
-        if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockId);
-            ReturnType criticalPutResult = criticalPut(keyspaceName, tableName, primaryKey,
-                            queryObject, lockId, conditionInfo);
-            long criticalPutTime = System.currentTimeMillis();
-            deleteLock(key);
-            long lockDeleteTime = System.currentTimeMillis();
-            String timingInfo = "|lock creation time:" + (lockCreationTime - start)
-                            + "|lock accquire time:" + (lockAcqTime - lockCreationTime)
-                            + "|critical put time:" + (criticalPutTime - lockAcqTime)
-                            + "|lock delete time:" + (lockDeleteTime - criticalPutTime) + "|";
-            criticalPutResult.setTimingInfo(timingInfo);
-            return criticalPutResult;
-        } else {
-            logger.info(EELFLoggerDelegate.applicationLogger,"unable to acquire lock, id " + lockId);
-            deleteLock(key);
+            logger.info(EELFLoggerDelegate.applicationLogger,"unable to acquire lock, id " + lockReference);
+            voluntaryReleaseLock(fullyQualifiedKey,lockReference);
             return lockAcqResult;
         }
     }
@@ -849,47 +645,31 @@ public class MusicCore {
      * @return ResultSet
      * @throws MusicServiceException
      * @throws MusicLockingException 
+     * @throws MusicQueryException 
      */
     public static ResultSet atomicGet(String keyspaceName, String tableName, String primaryKey,
-                    PreparedQueryObject queryObject) throws MusicServiceException, MusicLockingException {
-        String key = keyspaceName + "." + tableName + "." + primaryKey;
-        String lockId = createLockReference(key);
+                    PreparedQueryObject queryObject) throws MusicServiceException, MusicLockingException, MusicQueryException {
+        String fullyQualifiedKey = keyspaceName + "." + tableName + "." + primaryKey;
+        String lockReference = createLockReference(fullyQualifiedKey);
         long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-        ReturnType lockAcqResult = acquireLock(key, lockId);
+        ReturnType lockAcqResult = acquireLock(fullyQualifiedKey, lockReference);
         if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockId);
+            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockReference);
             ResultSet result =
-                            criticalGet(keyspaceName, tableName, primaryKey, queryObject, lockId);
-            voluntaryReleaseLock(lockId);
+                            criticalGet(keyspaceName, tableName, primaryKey, queryObject, lockReference);
+            voluntaryReleaseLock(fullyQualifiedKey,lockReference);
             return result;
         } else {
-        	destroyLockRef(lockId);
-            logger.info(EELFLoggerDelegate.applicationLogger,"unable to acquire lock, id " + lockId);
+            voluntaryReleaseLock(fullyQualifiedKey,lockReference);
+            logger.info(EELFLoggerDelegate.applicationLogger,"unable to acquire lock, id " + lockReference);
             return null;
         }
     }
     
-	public static ResultSet atomicGetWithDeleteLock(String keyspaceName, String tableName, String primaryKey,
-			PreparedQueryObject queryObject) throws MusicServiceException, MusicLockingException {
-		String key = keyspaceName + "." + tableName + "." + primaryKey;
-		String lockId = createLockReference(key);
-		long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-
-		ReturnType lockAcqResult = acquireLock(key, lockId);
-
-		if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-			logger.info(EELFLoggerDelegate.applicationLogger, "acquired lock with id " + lockId);
-			ResultSet result = criticalGet(keyspaceName, tableName, primaryKey, queryObject, lockId);
-			deleteLock(key);
-			return result;
-		} else {
-			deleteLock(key);
-			logger.info(EELFLoggerDelegate.applicationLogger, "unable to acquire lock, id " + lockId);
-			return null;
-		}
-	}
-    
     
+    public static MusicLockState getMusicLockState(String fullyQualifiedKey) {
+    		return null;
+    }
 
     /**
      * authenticate user logic
@@ -903,7 +683,7 @@ public class MusicCore {
      * @return
      * @throws Exception
      */
-    public static Map<String, Object> autheticateUser(String nameSpace, String userId,
+    public static Map<String, Object> authenticate(String nameSpace, String userId,
                     String password, String keyspace, String aid, String operation)
                     throws Exception {
         Map<String, Object> resultMap = new HashMap<>();
@@ -999,4 +779,38 @@ public class MusicCore {
         resultMap.put("keyspace",keyspace);
         return resultMap;
     }
+    
+    
+	/**
+	 * Given the time of write for an update in a critical section, this method provides a transformed timestamp
+	 * that ensures that a previous lock holder who is still alive can never corrupt a later critical section.
+	 * The main idea is to us the lock reference to clearly demarcate the timestamps across critical sections. 
+	 * @param the UUID lock reference associated with the write. 
+	 * @param the long timeOfWrite which is the actual time at which the write took place 
+	 * @throws MusicServiceException
+	 * @throws MusicQueryException
+	 */	
+	private static long v2sTimeStampInMicroseconds(String lockReference, long timeOfWrite) throws MusicServiceException, MusicQueryException{
+        long lockEpochMillis = Long.parseLong(lockReference);
+
+        long lockEternityMillis = lockEpochMillis - MusicUtil.MusicEternityEpochMillis;
+
+        long ts = lockEternityMillis * MusicUtil.MaxCriticalSectionDurationMillis
+                + (timeOfWrite - lockEpochMillis);
+
+        return ts;
+
+//		long test = (lockReferenceUUID.timestamp()-MusicUtil.MusicEternityEpochMillis);
+//		long timeStamp = (lockReferenceUUID.timestamp()-MusicUtil.MusicEternityEpochMillis)*MusicUtil.MaxCriticalSectionDurationMillis
+//				+timeOfWrite;
+//		return timeStamp;
+
+//		return timeOfWrite*1000;
+	}
+
+	public static void main(String[] args) {
+		String x = "axe top";
+		x = x.replaceFirst("top", "sword");
+		System.out.print(x); //returns sword pickaxe
+	}
 }
diff --git a/src/main/java/org/onap/music/main/MusicUtil.java b/src/main/java/org/onap/music/main/MusicUtil.java
index cfad845d..c11b4c7e 100755
--- a/src/main/java/org/onap/music/main/MusicUtil.java
+++ b/src/main/java/org/onap/music/main/MusicUtil.java
@@ -23,15 +23,12 @@ package org.onap.music.main;
 
 import java.io.File;
 import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Properties;
 import java.util.Scanner;
 import java.util.StringTokenizer;
 import java.util.UUID;
@@ -72,8 +69,7 @@ public class MusicUtil {
     public static final String UPSERT = "upsert";
     public static final String USERID = "userId";
     public static final String PASSWORD = "password";
-
-	public static final String AUTHORIZATION = "Authorization";
+    public static final String AUTHORIZATION = "Authorization";
 
     private static final String LOCALHOST = "localhost";
     private static final String PROPERTIES_FILE = "/opt/app/music/etc/music.properties";
@@ -85,10 +81,6 @@ public class MusicUtil {
     private static String myZkHost = LOCALHOST;
     private static String myCassaHost = LOCALHOST;
     private static String defaultMusicIp = LOCALHOST;
-    private static int cassandraPort = 9042;
-    private static int notifytimeout = 30000;
-    private static int notifyinterval = 5000;
-    
     private static boolean debug = true;
     private static String version = "2.3.0";
     private static String musicRestIp = LOCALHOST;
@@ -96,31 +88,22 @@ public class MusicUtil {
     private static long defaultLockLeasePeriod = 6000;
     private static final String[] propKeys = new String[] { "zookeeper.host", "cassandra.host", "music.ip", "debug",
             "version", "music.rest.ip", "music.properties", "lock.lease.period", "id", "all.ids", "public.ip",
-            "all.pubic.ips", "cassandra.user", "cassandra.password", "aaf.endpoint.url","cassandra.port", "notify.timeout", "notify.interval" };
+            "all.pubic.ips", "cassandra.user", "cassandra.password", "aaf.endpoint.url" };
 
     private static String cassName = "cassandra";
     private static String cassPwd;
     private static String aafEndpointUrl = null;
-    public static final ConcurrentMap<String, Long> zkNodeMap = new ConcurrentHashMap<>();
+    public static ConcurrentMap<String, Long> zkNodeMap = new ConcurrentHashMap<>();
+    
+    public static final long MusicEternityEpochMillis = 1533081600000L; // Wednesday, August 1, 2018 12:00:00 AM
+    
+    public static final long MaxCriticalSectionDurationMillis = 1L * 24 * 60 * 60 * 1000; // 1 day
 
     private MusicUtil() {
         throw new IllegalStateException("Utility Class");
     }
-    /**
-     * 
-     * @return cassandra port
-     */
-    public static int getCassandraPort() {
-		return cassandraPort;
-	}
-
-    /**
-     * set cassandra port
-     * @param cassandraPort
-     */
-	public static void setCassandraPort(int cassandraPort) {
-		MusicUtil.cassandraPort = cassandraPort;
-	}
+    
+    
     /**
      * @return the cassName
      */
@@ -583,51 +566,5 @@ public class MusicUtil {
     	return authValues;
     	
     }
-    
-    public static void loadProperties() throws Exception {
-		Properties prop = new Properties();
-	    InputStream input = null;
-	    try {
-	    	// load the properties file
-	        input = MusicUtil.class.getClassLoader().getResourceAsStream("music.properties");
-	        prop.load(input);
-	    } catch (Exception ex) {
-	    	logger.error(EELFLoggerDelegate.errorLogger, "Unable to find properties file.");
-	        throw new Exception();
-	    } finally {
-	        if (input != null) {
-	            try {
-	                input.close();
-	            } catch (IOException e) {
-	                logger.error(EELFLoggerDelegate.applicationLogger,"Load properties failed "+e.getMessage(),e);
-	            }
-	        }
-	    }
-	    // get the property value and return it
-		MusicUtil.setMyCassaHost(prop.getProperty("cassandra.host"));
-		String zkHosts = prop.getProperty("zookeeper.host");
-		MusicUtil.setMyZkHost(zkHosts);
-		MusicUtil.setCassName(prop.getProperty("cassandra.user"));
-		MusicUtil.setCassPwd(prop.getProperty("cassandra.password"));
-		MusicUtil.setCassandraPort(Integer.parseInt(prop.getProperty("cassandra.port")));
-		MusicUtil.setNotifyTimeOut(Integer.parseInt(prop.getProperty("notify.timeout")));
-		MusicUtil.setNotifyInterval(Integer.parseInt(prop.getProperty("notify.interval")));
-		
-	}
-    
-	public static void setNotifyInterval(int notifyinterval) {
-		MusicUtil.notifyinterval = notifyinterval;
-	}
-	public static void setNotifyTimeOut(int notifytimeout) {
-		MusicUtil.notifytimeout = notifytimeout;
-	}
-
-	public static int getNotifyInterval() {
-		return MusicUtil.notifyinterval;
-	}
-	
-	public static int getNotifyTimeout() {
-		return MusicUtil.notifytimeout;
-		
-	}
+
 }
diff --git a/src/main/java/org/onap/music/main/PropertiesListener.java b/src/main/java/org/onap/music/main/PropertiesListener.java
index 0ed18be2..8b00e473 100755
--- a/src/main/java/org/onap/music/main/PropertiesListener.java
+++ b/src/main/java/org/onap/music/main/PropertiesListener.java
@@ -119,15 +119,6 @@ public class PropertiesListener implements ServletContextListener {
                         case "aaf.endpoint.url":
                             MusicUtil.setAafEndpointUrl(prop.getProperty(key));
                             break;
-                        case "cassandra.port":
-                            MusicUtil.setCassandraPort(Integer.parseInt(prop.getProperty(key)));
-                            break;
-                        case "notify.interval":
-                        	MusicUtil.setNotifyInterval(Integer.parseInt(prop.getProperty(key)));
-                        	break;
-                        case "notify.timeout":
-                        	MusicUtil.setNotifyTimeOut(Integer.parseInt(prop.getProperty(key)));
-                        	break;
                         default:
                             logger.error(EELFLoggerDelegate.errorLogger,
                                             "No case found for " + key);
diff --git a/src/main/java/org/onap/music/main/VotingAppJar.java b/src/main/java/org/onap/music/main/VotingAppJar.java
new file mode 100644
index 00000000..1c475639
--- /dev/null
+++ b/src/main/java/org/onap/music/main/VotingAppJar.java
@@ -0,0 +1,115 @@
+package org.onap.music.main;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicCore;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+
+/**
+ *
+ */
+public class VotingAppJar 
+{
+	String keyspaceName;
+	String tableName;
+	
+	public VotingAppJar() throws MusicServiceException {
+		keyspaceName = "VotingAppForMusic";
+		tableName = "votevount";
+		
+		createVotingKeyspace();
+		System.out.println("Created keyspaces");
+		createVotingTable();
+		System.out.println("Created tables");
+		
+		createEntryForCandidate("Popeye");
+		createEntryForCandidate("Judy");
+		createEntryForCandidate("Flash");
+		createEntryForCandidate("Mickey");
+		System.out.println("Created candidates");
+	}
+
+	private void createVotingKeyspace() throws MusicServiceException {
+		
+		Map<String,Object> replicationInfo = new HashMap<String, Object>();
+		replicationInfo.put("'class'", "'SimpleStrategy'");
+		replicationInfo.put("'replication_factor'", 1);
+		
+		PreparedQueryObject queryObject = new PreparedQueryObject();
+		queryObject.appendQueryString(
+                "CREATE KEYSPACE " + keyspaceName + " WITH REPLICATION = " + replicationInfo.toString().replaceAll("=", ":"));
+		
+		try {
+			MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+		} catch (MusicServiceException e) {
+			if (e.getMessage().equals("Keyspace votingappformusic already exists")) {
+				// ignore
+			} else {
+				throw(e);
+			}			
+		}
+	}
+	
+    private void createVotingTable() throws MusicServiceException {
+    	PreparedQueryObject queryObject = new PreparedQueryObject();
+		queryObject.appendQueryString(
+                "CREATE TABLE " + keyspaceName + "." + tableName + " (name text PRIMARY KEY, count varint);");
+		
+		try {
+			MusicCore.createTable(keyspaceName, tableName, queryObject, "eventual");		
+		} catch (MusicServiceException e) {
+			if (e.getMessage().equals("Table votingappformusic.votevount already exists")) {
+				//ignore
+			} else {
+				throw(e);
+			}
+		}
+	}
+
+	private void createEntryForCandidate(String candidateName) throws MusicServiceException {
+		PreparedQueryObject queryObject = new PreparedQueryObject();
+		queryObject.appendQueryString(
+                "INSERT INTO " + keyspaceName + "." + tableName + " (name, count) "
+                		+ "VALUES ('"+candidateName+"', 0);");
+		
+		MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+	}
+
+	public void vote() throws MusicLockingException, MusicQueryException, MusicServiceException {
+		updateVoteCount("Popeye",5);
+		updateVoteCount("Judy",7);
+		updateVoteCount("Mickey",8);
+		updateVoteCount("Flash",2);
+	}
+	
+	private void updateVoteCount(String candidateName, int numVotes) throws MusicLockingException, MusicQueryException, MusicServiceException {
+		PreparedQueryObject queryObject = new PreparedQueryObject();
+		queryObject.appendQueryString(
+                "INSERT INTO " + keyspaceName + "." + tableName + " (name, count) "
+                		+ "VALUES ('"+candidateName+"', "+numVotes+");");
+		MusicCore.atomicPut(keyspaceName, tableName, candidateName, queryObject, null);
+	}
+
+	private void readAllVotes() throws MusicServiceException {
+		PreparedQueryObject queryObject = new PreparedQueryObject();
+		queryObject.appendQueryString("SELECT * FROM " + keyspaceName + "." + tableName);
+		ResultSet rs = MusicCore.get(queryObject);
+		for(Row candidate : rs.all()) {
+			System.out.println(candidate.getString("name") + " - " + candidate.getVarint("count"));
+		}
+	}
+	
+	public static void main( String[] args ) throws Exception {
+        VotingAppJar vHandle = new VotingAppJar();
+        vHandle.vote();
+        vHandle.readAllVotes();
+    }
+
+}
diff --git a/src/main/java/org/onap/music/response/jsonobjects/JsonResponse.java b/src/main/java/org/onap/music/response/jsonobjects/JsonResponse.java
index a406afce..6a843607 100644
--- a/src/main/java/org/onap/music/response/jsonobjects/JsonResponse.java
+++ b/src/main/java/org/onap/music/response/jsonobjects/JsonResponse.java
@@ -24,15 +24,8 @@ package org.onap.music.response.jsonobjects;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.onap.music.lockingservice.MusicLockState.LockStatus;
+import org.onap.music.datastore.MusicLockState.LockStatus;
 import org.onap.music.main.ResultType;
-import org.powermock.core.spi.testresult.Result;
-
-import com.datastax.driver.core.ColumnDefinitions;
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.Row;
-import com.datastax.driver.core.ColumnDefinitions.Definition;
-
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 
diff --git a/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java b/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java
index 0e365650..90436499 100755
--- a/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java
@@ -23,17 +23,10 @@ package org.onap.music.rest;
 
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
 import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
 import java.util.UUID;
-
 import javax.ws.rs.Consumes;
 import javax.ws.rs.DELETE;
 import javax.ws.rs.POST;
@@ -45,47 +38,23 @@ import javax.ws.rs.core.Response;
 import javax.ws.rs.core.Response.ResponseBuilder;
 import javax.ws.rs.core.Response.Status;
 
-import org.codehaus.jackson.map.ObjectMapper;
 import org.mindrot.jbcrypt.BCrypt;
 import org.onap.music.datastore.PreparedQueryObject;
-import org.onap.music.datastore.jsonobjects.JSONCallbackResponse;
 import org.onap.music.datastore.jsonobjects.JSONObject;
-import org.onap.music.datastore.jsonobjects.JsonCallback;
-import org.onap.music.datastore.jsonobjects.JsonNotification;
-import org.onap.music.datastore.jsonobjects.JsonNotifyClientResponse;
 import org.onap.music.datastore.jsonobjects.JsonOnboard;
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
 import org.onap.music.eelf.logging.format.ErrorTypes;
-//import org.onap.music.main.CacheAccess;
 import org.onap.music.main.CachingUtil;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
-import org.onap.music.main.ReturnType;
-import org.onap.music.response.jsonobjects.JsonResponse;
-
 import com.datastax.driver.core.DataType;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
-import com.datastax.driver.core.exceptions.InvalidQueryException;
-import com.sun.jersey.api.client.Client;
-import com.sun.jersey.api.client.ClientResponse;
-import com.sun.jersey.api.client.WebResource;
-import com.sun.jersey.core.util.Base64;
-
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
-import com.datastax.driver.core.TableMetadata;
-
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import com.datastax.driver.core.ColumnDefinitions;
-import com.datastax.driver.core.ColumnDefinitions.Definition;
-import com.datastax.driver.core.TableMetadata;
-//import java.util.Base64.Encoder; 
-//import java.util.Base64.Decoder;
 
 @Path("/v2/admin")
 // @Path("/v{version: [0-9]+}/admin")
@@ -94,6 +63,7 @@ import com.datastax.driver.core.TableMetadata;
 public class RestMusicAdminAPI {
     private static EELFLoggerDelegate logger =
                     EELFLoggerDelegate.getLogger(RestMusicAdminAPI.class);
+
     /*
      * API to onboard an application with MUSIC. This is the mandatory first step.
      * 
@@ -175,7 +145,7 @@ public class RestMusicAdminAPI {
                             ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
             resultMap.put("Exception",
                             "Unauthorized: Please check the request parameters. Enter atleast one of the following parameters: appName(ns), aid, isAAF.");
-            return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
+            return Response.status(Status.UNAUTHORIZED).entity(resultMap).build();
         }
 
         PreparedQueryObject pQuery = new PreparedQueryObject();
@@ -189,8 +159,9 @@ public class RestMusicAdminAPI {
 
         if (cql.endsWith("AND "))
             cql = cql.trim().substring(0, cql.length() - 4);
-        logger.info("Query in callback is: " + cql);
+        System.out.println("Query is: " + cql);
         cql = cql + " allow filtering";
+        System.out.println("Get OnboardingInfo CQL: " + cql);
         pQuery.appendQueryString(cql);
         if (appName != null)
             pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
@@ -399,447 +370,14 @@ public class RestMusicAdminAPI {
 
         return Response.status(Status.OK).entity(resultMap).build();
     }
-
-    Client client = Client.create();
-	ObjectMapper mapper = new ObjectMapper();
-	
-    @POST
-    @Path("/callbackOps")
-    @Produces(MediaType.APPLICATION_JSON)
-    @Consumes(MediaType.APPLICATION_JSON)
-	public Response callbackOps(final JSONObject inputJsonObj) {
-         // {"keyspace":"conductor","full_table":"conductor.plans","changeValue":{"conductor.plans.status":"Who??","position":"3"},"operation":"update","table_name":"plans","primary_key":"3"}
-    	Map<String, Object> resultMap = new HashMap<>();
-    	new Thread(new Runnable() {
-    	    public void run() {
-    	        makeAsyncCall(inputJsonObj);
-    	    }
-    	}).start();
-	    
-		return Response.status(Status.OK).entity(resultMap).build();
-	}
-    
-    private Response makeAsyncCall(JSONObject inputJsonObj) {
-    	
-    	Map<String, Object> resultMap = new HashMap<>();
-    	try {
-    		logger.info(EELFLoggerDelegate.applicationLogger, "Got notification: " + inputJsonObj.getData());
-			String dataStr = inputJsonObj.getData();
-			JSONCallbackResponse jsonResponse = mapper.readValue(dataStr, JSONCallbackResponse.class);
-			String operation = jsonResponse.getOperation();
-			Map<String, String> changeValueMap = jsonResponse.getChangeValue();
-			String primaryKey = jsonResponse.getPrimary_key();
-			String ksTableName = jsonResponse.getFull_table(); //conductor.plans
-			if(ksTableName.equals("admin.notification_master")) {
-				CachingUtil.updateCallbackNotifyList(new ArrayList<String>());
-				return Response.status(Status.OK).entity(resultMap).build();
-			}
-			List<String> inputUpdateList = jsonResponse.getUpdateList();
-			/*String field_value = changeValueMap.get("field_value");
-			if(field_value == null)
-				field_value = jsonResponse.getFull_table();*/
-			String field_value = null;
-			List<String> notifiyList = CachingUtil.getCallbackNotifyList();
-			if(notifiyList == null || notifiyList.isEmpty()) {
-				logger.info("Is cache empty? reconstructing Object from cache..");
-				constructJsonCallbackFromCache();
-				/*notifiyList = CachingUtil.getCallbackNotifyList();
-				if("update".equals(operation)) {
-					List<String> updateList = jsonResponse.getUpdateList();
-					//logger.info("update list from trigger: "+updateList);
-					for(String element : updateList) {
-						logger.info("element: "+element);
-						logger.info("notifiyList: "+notifiyList);
-						if(notifiyList.contains(element)) {
-							logger.info("Found the notifyOn property: "+element);
-							field_value = element;
-						}
-					}
-				}
-				
-				baseRequestObj = CachingUtil.getCallBackCache(field_value);
-				logger.info("Reconstructing Object from cache is Successful.."+baseRequestObj);*/
-			}
-			notifiyList = CachingUtil.getCallbackNotifyList();
-			JsonCallback baseRequestObj = null;
-			
-			if("update".equals(operation)) {
-				for(String element: inputUpdateList) {
-					baseRequestObj = CachingUtil.getCallBackCache(element);
-					if(baseRequestObj != null) {
-						logger.info("Found the element that was changed... "+element);
-						break;
-					}
-				}
-				
-				List<String> updateList = jsonResponse.getUpdateList();
-				//logger.info("update list from trigger: "+updateList);
-				for(String element : updateList) {
-					if(notifiyList.contains(element)) {
-						logger.info("Found the notifyOn property: "+element);
-						field_value = element;
-						break;
-					}
-				}
-				if(baseRequestObj == null || field_value == null) {
-					for(String element: inputUpdateList) {
-						String[] elementArr = element.split(":");
-						String newElement = null;
-						if(elementArr.length >= 2) {
-							newElement = elementArr[0]+":"+elementArr[1];
-				        } 
-						baseRequestObj = CachingUtil.getCallBackCache(newElement);
-						if(baseRequestObj != null) {
-							logger.info("Found the element that was changed... "+newElement);
-							break;
-						}
-					}
-					for(String element : updateList) {
-						String[] elementArr = element.split(":");
-						String newElement = null;
-						if(elementArr.length >= 2) {
-							newElement = elementArr[0]+":"+elementArr[1];
-				        } 
-						if(notifiyList.contains(newElement)) {
-							logger.info("Found the notifyOn property: "+newElement);
-							field_value = newElement;
-							break;
-						}
-					}
-				}
-			} else {
-				field_value = jsonResponse.getFull_table();
-				baseRequestObj = CachingUtil.getCallBackCache(field_value);
-			}
-			
-			if(baseRequestObj == null) {
-				resultMap.put("Exception",
-	                    "Oops. Something went wrong. Please make sure Callback properties are onboarded.");
-				logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.INCORRECTDATA,
-	                    ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
-				return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
-			}
-			logger.info("Going through list: "+operation+ " && List: "+jsonResponse.getUpdateList());
-			
-			String key = "admin" + "." + "notification_master" + "." + baseRequestObj.getUuid();
-	        String lockId = MusicCore.createLockReference(key);
-	        ReturnType lockAcqResult = MusicCore.acquireLock(key, lockId);
-	        if(! lockAcqResult.getResult().toString().equals("SUCCESS")) {
-	        	logger.error(EELFLoggerDelegate.errorLogger, "Some other node is notifying the caller..: ");
-	        }
-			
-			logger.info(operation+ ": Operation :: changeValue: "+changeValueMap);
-			if(operation.equals("update")) {
-				String notifyWhenChangeIn = baseRequestObj.getNotifyWhenChangeIn(); // conductor.plans.status
-				if(null!=field_value) {
-					if(field_value.equals(notifyWhenChangeIn)) {
-						notifyCallBackAppl(jsonResponse, baseRequestObj);
-					}
-				}
-			} else if(operation.equals("delete")) {
-				String notifyWhenDeletesIn = baseRequestObj.getNotifyWhenDeletesIn(); // conductor.plans.status
-				if(null!=field_value) {
-					if(field_value.equals(notifyWhenDeletesIn)) {
-						notifyCallBackAppl(jsonResponse, baseRequestObj);
-					}
-				}
-			} else if(operation.equals("insert")) {
-				String notifyWhenInsertsIn = baseRequestObj.getNotifyWhenInsertsIn(); // conductor.plans.status
-				if(null!=field_value) {
-					if(field_value.equals(notifyWhenInsertsIn)) {
-						notifyCallBackAppl(jsonResponse, baseRequestObj);
-					}
-				}
-			}
-			MusicCore.releaseLock(lockId, true);	
-	    } catch(Exception e) {
-            e.printStackTrace();
-            logger.info("Exception...");
-        }
-    	logger.info(EELFLoggerDelegate.applicationLogger, "callback is completed. Notification was sent from Music...");
-    	return Response.status(Status.OK).entity(resultMap).build();
-    }
-    
-    private void notifyCallBackAppl(JSONCallbackResponse jsonResponse, JsonCallback baseRequestObj) {
-    	int notifytimeout = MusicUtil.getNotifyTimeout();
-    	int notifyinterval = MusicUtil.getNotifyInterval();
-    	String endpoint = baseRequestObj.getApplicationNotificationEndpoint();
-        String username = baseRequestObj.getApplicationUsername();
-        String password = baseRequestObj.getApplicationPassword();
-        JsonNotification jsonNotification = constructJsonNotification(jsonResponse, baseRequestObj);
-        jsonNotification.setOperation_type(jsonResponse.getOperation());
-        logger.info(EELFLoggerDelegate.applicationLogger, "Notification Response sent is: "+jsonNotification);
-        WebResource webResource = client.resource(endpoint);
-        String authData = username+":"+password;
-        byte[] plainCredsBytes = authData.getBytes();
-        byte[] base64CredsBytes = Base64.encode(plainCredsBytes);
-        String base64Creds = new String(base64CredsBytes);
-        Map<String, String> response_body = baseRequestObj.getResponseBody();
-        ClientResponse response = null;
-        try { 
-        	response = webResource.header("Authorization", "Basic " + base64Creds).accept("application/json").type("application/json")
-            .post(ClientResponse.class, jsonNotification);
-        } catch (com.sun.jersey.api.client.ClientHandlerException chf) {
-        	boolean ok = false;
-        	logger.info(EELFLoggerDelegate.applicationLogger, "Is Service down?");
-        	long now= System.currentTimeMillis();
-        	long end = now+notifytimeout;
-        	while(! ok) {
-        		logger.info(EELFLoggerDelegate.applicationLogger, "retrying since error in notifying callback..");
-        		try {
-        			response = webResource.header("Authorization", "Basic " + base64Creds).accept("application/json").type("application/json")
-        	            .post(ClientResponse.class, jsonNotification);
-        			if(response.getStatus() == 200) ok = true;
-        		}catch (Exception e) {
-        			logger.info(EELFLoggerDelegate.applicationLogger, "Retry until "+(end-System.currentTimeMillis()));
-        			if(response == null && System.currentTimeMillis() < end) ok = false;
-        			else ok = true;
-        			try{ Thread.sleep(notifyinterval); } catch(Exception e1) {}
-        		}
-        	}
-        }
-        if(response == null) {
-        	logger.error(EELFLoggerDelegate.errorLogger, "Can NOT notify the caller as caller failed to respond..");
-        	return;
-        }
-        JsonNotifyClientResponse responseStr = response.getEntity(JsonNotifyClientResponse.class);
-        logger.info(EELFLoggerDelegate.applicationLogger, "Response from Notified client: "+responseStr);
-        
-        if(response.getStatus() != 200){
-        	long now= System.currentTimeMillis();
-        	long end = now+30000;
-        	while(response.getStatus() != 200 && System.currentTimeMillis() < end) {
-        		logger.info(EELFLoggerDelegate.applicationLogger, "retrying since error in notifying callback..");
-        		response = webResource.header("Authorization", "Basic " + base64Creds).accept("application/json").type("application/json")
-        	            .post(ClientResponse.class, jsonNotification);
-        	}
-        	logger.info(EELFLoggerDelegate.applicationLogger, "Exception while notifying.. "+response.getStatus());
-        }
-    }
-    
-    private JsonNotification constructJsonNotification(JSONCallbackResponse jsonResponse, JsonCallback baseRequestObj) {
-    	
-    	JsonNotification jsonNotification = new JsonNotification();
-    	try {
-	    	jsonNotification.setNotify_field(baseRequestObj.getNotifyOn());
-	    	jsonNotification.setEndpoint(baseRequestObj.getApplicationNotificationEndpoint());
-	    	jsonNotification.setUsername(baseRequestObj.getApplicationUsername());
-	    	jsonNotification.setPassword(baseRequestObj.getApplicationPassword());
-	    	String pkValue = jsonResponse.getPrimary_key();
-	    	
-	    	String[] fullNotifyArr = baseRequestObj.getNotifyOn().split(":");
-	    	
-	    	String[] tableArr = fullNotifyArr[0].split("\\.");
-	    	TableMetadata tableInfo = MusicCore.returnColumnMetadata(tableArr[0], tableArr[1]);
-			DataType primaryIdType = tableInfo.getPrimaryKey().get(0).getType();
-			String primaryId = tableInfo.getPrimaryKey().get(0).getName();
-			
-			Map<String, String> responseBodyMap = baseRequestObj.getResponseBody();
-			Map<String, String> newMap = new HashMap<>();
-			if(responseBodyMap.size() == 1 && responseBodyMap.containsKey("")) {
-				jsonNotification.setResponse_body(newMap);
-			} else {
-				for (Entry<String, String> entry : new HashSet<>(responseBodyMap.entrySet())) {
-				    String trimmed = entry.getKey().trim();
-				    if (!trimmed.equals(entry.getKey())) {
-				    	responseBodyMap.remove(entry.getKey());
-				    	responseBodyMap.put(trimmed, entry.getValue());
-				    }
-				}
-				
-				Set<String> keySet = responseBodyMap.keySet();
-				String cql = "select *";
-				/*for(String keys: keySet) {
-					cql = cql + keys + ",";
-				}*/
-				//cql = cql.substring(0, cql.length()-1);
-				cql = cql + " FROM "+fullNotifyArr[0]+" WHERE "+primaryId+" = ?";
-				logger.info("CQL in constructJsonNotification: "+cql);
-				PreparedQueryObject pQuery = new PreparedQueryObject();
-				pQuery.appendQueryString(cql);
-				pQuery.addValue(MusicUtil.convertToActualDataType(primaryIdType, pkValue));
-				Row row = MusicCore.get(pQuery).one();
-				if(row != null) {
-					ColumnDefinitions colInfo = row.getColumnDefinitions();
-			        for (Definition definition : colInfo) {
-			            String colName = definition.getName();
-			            if(keySet.contains(colName)) {
-			                DataType colType = definition.getType();
-			                Object valueObj = MusicCore.getDSHandle().getColValue(row, colName, colType);
-			                Object valueString = MusicUtil.convertToActualDataType(colType, valueObj);
-			                logger.info(colName+" : "+valueString);
-			                newMap.put(colName, valueString.toString());
-			                keySet.remove(colName);
-			            }
-			        }
-				}
-				if(! keySet.isEmpty()) {
-					Iterator<String> iterator = keySet.iterator();
-					while (iterator.hasNext()) {
-					    String element = iterator.next();
-					    if(element != null && element.length() > 0)
-					    	newMap.put(element,"COLUMN_NOT_FOUND");
-					}
-				}
-			    
-				if("delete".equals(jsonResponse.getOperation()) || newMap.isEmpty()) {
-					newMap.put(primaryId, pkValue);
-				}
-				jsonNotification.setResponse_body(newMap);
-			}
-			} catch(Exception e) {
-			e.printStackTrace();
-			}
-			return jsonNotification;
-    }
-    
-    private void constructJsonCallbackFromCache() throws Exception{
-    	PreparedQueryObject pQuery = new PreparedQueryObject();
-		JsonCallback jsonCallback = null;
-		List<String> notifyList = new java.util.ArrayList<>();
-		String cql = 
-                "select id, endpoint_userid, endpoint_password, notify_to_endpoint, notify_insert_on,"
-                + " notify_delete_on, notify_update_on, request, notifyon from admin.notification_master allow filtering";
-        pQuery.appendQueryString(cql);
-        //pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), fullTable));
-        logger.info("Query: "+pQuery.getQuery());
-        
-        ResultSet rs = MusicCore.get(pQuery);
-        Iterator<Row> it = rs.iterator();
-        while (it.hasNext()) {
-            Row row = (Row) it.next();
-        	String endpoint = row.getString("notify_to_endpoint");
-            String username = row.getString("endpoint_userid");
-            ByteBuffer passwordBytes = row.getBytes("endpoint_password");
-            String insert = row.getString("notify_insert_on");
-            String delete = row.getString("notify_delete_on");
-            String update = row.getString("notify_update_on");
-            String request = row.getString("request");
-            String notifyon = row.getString("notifyon");
-            String uuid = row.getUUID("id").toString();
-            notifyList.add(notifyon);
-            jsonCallback = new JsonCallback();
-            jsonCallback.setApplicationNotificationEndpoint(endpoint);
-            
-            Charset charset = Charset.forName("ISO-8859-1");
-            String decodedPwd = charset.decode(passwordBytes).toString();
-            jsonCallback.setApplicationPassword(decodedPwd);
-            jsonCallback.setApplicationUsername(username);
-            jsonCallback.setNotifyOn(notifyon);
-            jsonCallback.setNotifyWhenInsertsIn(insert);
-            jsonCallback.setNotifyWhenDeletesIn(delete);
-            jsonCallback.setNotifyWhenChangeIn(update);
-            jsonCallback.setUuid(uuid);
-            logger.info("From DB. Saved request_body: "+request);
-            request = request.substring(1, request.length()-1);           
-            String[] keyValuePairs = request.split(",");              
-            Map<String,String> responseBody = new HashMap<>();               
-
-            for(String pair : keyValuePairs) {
-                String[] entry = pair.split("="); 
-                String val = "";
-                if(entry.length == 2)
-                	val = entry[1];
-                responseBody.put(entry[0], val);          
-            }
-            logger.info("After parsing. Saved request_body: "+responseBody);
-            jsonCallback.setResponseBody(responseBody);
-            logger.info("Updating Cache with updateCallBackCache: "+notifyon+ " :::: "+jsonCallback);
-            CachingUtil.updateCallBackCache(notifyon, jsonCallback);
-        }
-        CachingUtil.updateCallbackNotifyList(notifyList);
-    }
     
     @POST
-    @Path("/onboardCallback")
+    @Path("/callbackOps")
     @Produces(MediaType.APPLICATION_JSON)
     @Consumes(MediaType.APPLICATION_JSON)
-    public Response addCallback(JsonNotification jsonNotification) {
-        Map<String, Object> resultMap = new HashMap<>();
-        ResponseBuilder response =
-                        Response.noContent().header("X-latestVersion", MusicUtil.getVersion());
-        String username = jsonNotification.getUsername();
-        String password = jsonNotification.getPassword();
-        String endpoint = jsonNotification.getEndpoint();
-        String notify_field = jsonNotification.getNotify_field();
-        Map<String, String> responseBody = jsonNotification.getResponse_body();
-        String triggerName = jsonNotification.getTriggerName();
-        if(triggerName == null || triggerName.length() == 0)
-        	triggerName = "MusicTrigger";
-        
-        /*JsonCallback callBackCache = CachingUtil.getCallBackCache(notify_field);
-        if(callBackCache != null) {
-        	resultMap.put("Exception", "The notification property has already been onboarded.");
-            return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
-        }*/
-        
-        String[] allFields = notify_field.split(":");
-        String inserts = null;
-        String updates = null;
-        String deletes = null;
-        String tableName = null;
-        if(allFields.length >= 2) {
-        	inserts = updates = notify_field;
-        } else if(allFields.length == 1) {
-        	inserts = deletes = notify_field;;
-        }
-        tableName = allFields[0];
-        String cql = "CREATE TRIGGER IF NOT EXISTS musictrigger ON "+tableName+" Using '"+triggerName+"'";
-        PreparedQueryObject pQuery = new PreparedQueryObject();
-        
-        String uuid = CachingUtil.generateUUID();
-        try {
-	        pQuery.appendQueryString(
-	                        "INSERT INTO admin.notification_master (id, endpoint_userid, endpoint_password, notify_to_endpoint, "
-	                                        + "notifyon, notify_insert_on, notify_delete_on, notify_update_on, request, current_notifier) VALUES (?,?,?,?,?,?,?,?,?,?)");
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), username));
-	        Charset charset = Charset.forName("ISO-8859-1");
-            ByteBuffer decodedPwd = charset.encode(password); 
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.blob(), decodedPwd.array()));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), endpoint));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), notify_field));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), inserts));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), deletes));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), updates));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), responseBody));
-	        pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), MusicCore.getMyHostId()));
-	        MusicCore.nonKeyRelatedPut(pQuery, MusicUtil.EVENTUAL);
-	        JsonCallback jsonCallback = new JsonCallback();
-	        jsonCallback.setUuid(uuid);
-	        jsonCallback.setApplicationNotificationEndpoint(endpoint);
-	        jsonCallback.setApplicationPassword(password);
-	        jsonCallback.setApplicationUsername(username);
-	        jsonCallback.setNotifyOn(notify_field);
-	        jsonCallback.setNotifyWhenChangeIn(updates);
-	        jsonCallback.setNotifyWhenDeletesIn(deletes);
-	        jsonCallback.setNotifyWhenInsertsIn(inserts);
-	        jsonCallback.setResponseBody(responseBody);
-	        CachingUtil.updateCallBackCache(notify_field, jsonCallback);
-	        logger.info("Cache updated ");
-	        pQuery = new PreparedQueryObject();
-	        pQuery.appendQueryString(cql);
-	        ResultType nonKeyRelatedPut = MusicCore.nonKeyRelatedPut(pQuery, MusicUtil.EVENTUAL);
-	        logger.info(EELFLoggerDelegate.applicationLogger, "Created trigger");
-        //callBackCache.put(jsonCallback.getApplicationName(), jsonMap);
-        } catch (InvalidQueryException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,"Exception callback_api table not configured."+e.getMessage());
-            resultMap.put("Exception", "Please make sure admin.notification_master table is configured.");
-            return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
-        } catch(Exception e) {
-        	e.printStackTrace();
-        	resultMap.put("Exception", "Exception Occured.");
-            return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
-        }
-       return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setMessage("Callback api successfully registered").toMap()).build();
+    public String callbackOps(JSONObject inputJsonObj) throws Exception {
+       
+       System.out.println("Input JSON: "+inputJsonObj.getData());
+       return "Success";
     }
-
-    /*public String encodePwd(String password) {
-    	return Base64.getEncoder().encodeToString(password.getBytes());
-    }
-    
-    public String decodePwd(String password) {
-    	byte[] bytes = Base64.getDecoder().decode(password); 
-    	return new String(bytes);
-    }*/
 }
diff --git a/src/main/java/org/onap/music/rest/RestMusicBmAPI.java b/src/main/java/org/onap/music/rest/RestMusicBmAPI.java
deleted file mode 100644
index 55eb47f2..00000000
--- a/src/main/java/org/onap/music/rest/RestMusicBmAPI.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * ============LICENSE_START========================================== org.onap.music
- * =================================================================== Copyright (c) 2017 AT&T
- * Intellectual Property ===================================================================
- * 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.music.rest;
-
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import javax.ws.rs.Consumes;
-import javax.ws.rs.GET;
-import javax.ws.rs.POST;
-import javax.ws.rs.PUT;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.Context;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriInfo;
-import org.onap.music.datastore.jsonobjects.JsonInsert;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.main.MusicCore;
-import org.onap.music.main.MusicUtil;
-import org.onap.music.main.ResultType;
-import org.onap.music.main.ReturnType;
-import org.onap.music.datastore.PreparedQueryObject;
-import com.datastax.driver.core.DataType;
-import com.datastax.driver.core.TableMetadata;
-import io.swagger.annotations.Api;
-//import io.swagger.annotations.ApiOperation;
-//import io.swagger.annotations.ApiParam;
-
-/*
- * These are functions created purely for benchmarking purposes. Commented out Swagger - This should
- * be undocumented API
- * 
- */
-@Path("/v{version: [0-9]+}/benchmarks/")
-@Api(value = "Benchmark API", hidden = true)
-public class RestMusicBmAPI {
-
-    private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicBmAPI.class);
-
-    // pure zk calls...
-
-    /**
-     * 
-     * @param nodeName
-     * @throws Exception
-     */
-    @POST
-    @Path("/purezk/{name}")
-    @Consumes(MediaType.APPLICATION_JSON)
-    public void pureZkCreate(@PathParam("name") String nodeName) throws Exception {
-        MusicCore.pureZkCreate("/" + nodeName);
-    }
-
-
-    /**
-     * 
-     * @param insObj
-     * @param nodeName
-     * @throws Exception
-     */
-    @PUT
-    @Path("/purezk/{name}")
-    @Consumes(MediaType.APPLICATION_JSON)
-    public void pureZkUpdate(JsonInsert insObj, @PathParam("name") String nodeName)
-                    throws Exception {
-        logger.info(EELFLoggerDelegate.applicationLogger,"--------------Zk normal update-------------------------");
-        long start = System.currentTimeMillis();
-        MusicCore.pureZkWrite(nodeName, insObj.serialize());
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Total time taken for Zk normal update:" + (end - start) + " ms");
-    }
-
-    /**
-     * 
-     * @param nodeName
-     * @return
-     * @throws Exception
-     */
-    @GET
-    @Path("/purezk/{name}")
-    @Consumes(MediaType.TEXT_PLAIN)
-    public byte[] pureZkGet(@PathParam("name") String nodeName) throws Exception {
-        return MusicCore.pureZkRead(nodeName);
-    }
-
-    /**
-     * 
-     * @param insObj
-     * @param lockName
-     * @param nodeName
-     * @throws Exception
-     */
-    @PUT
-    @Path("/purezk/atomic/{lockname}/{name}")
-    @Consumes(MediaType.APPLICATION_JSON)
-    public void pureZkAtomicPut(JsonInsert updateObj, @PathParam("lockname") String lockname,
-                    @PathParam("name") String nodeName) throws Exception {
-        long startTime = System.currentTimeMillis();
-        String operationId = UUID.randomUUID().toString();// just for debugging purposes.
-        String consistency = updateObj.getConsistencyInfo().get("type");
-
-        logger.info(EELFLoggerDelegate.applicationLogger,"--------------Zookeeper " + consistency + " update-" + operationId
-                        + "-------------------------");
-
-        byte[] data = updateObj.serialize();
-        long jsonParseCompletionTime = System.currentTimeMillis();
-
-        String lockId = MusicCore.createLockReference(lockname);
-
-        long lockCreationTime = System.currentTimeMillis();
-
-        long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-        ReturnType lockAcqResult = MusicCore.acquireLockWithLease(lockname, lockId, leasePeriod);
-        long lockAcqTime = System.currentTimeMillis();
-        long zkPutTime = 0, lockReleaseTime = 0;
-
-        if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"acquired lock with id " + lockId);
-            MusicCore.pureZkWrite(lockname, data);
-            zkPutTime = System.currentTimeMillis();
-            boolean voluntaryRelease = true;
-            if (consistency.equals("atomic"))
-                MusicCore.releaseLock(lockId, voluntaryRelease);
-            else if (consistency.equals("atomic_delete_lock"))
-                MusicCore.deleteLock(lockname);
-            lockReleaseTime = System.currentTimeMillis();
-        } else {
-            MusicCore.destroyLockRef(lockId);
-        }
-
-        long actualUpdateCompletionTime = System.currentTimeMillis();
-
-
-        long endTime = System.currentTimeMillis();
-
-        String lockingInfo = "|lock creation time:" + (lockCreationTime - jsonParseCompletionTime)
-                        + "|lock accquire time:" + (lockAcqTime - lockCreationTime)
-                        + "|zk put time:" + (zkPutTime - lockAcqTime);
-
-        if (consistency.equals("atomic"))
-            lockingInfo = lockingInfo + "|lock release time:" + (lockReleaseTime - zkPutTime) + "|";
-        else if (consistency.equals("atomic_delete_lock"))
-            lockingInfo = lockingInfo + "|lock delete time:" + (lockReleaseTime - zkPutTime) + "|";
-
-        String timingString = "Time taken in ms for Zookeeper " + consistency + " update-"
-                        + operationId + ":" + "|total operation time:" + (endTime - startTime)
-                        + "|json parsing time:" + (jsonParseCompletionTime - startTime)
-                        + "|update time:" + (actualUpdateCompletionTime - jsonParseCompletionTime)
-                        + lockingInfo;
-
-        logger.info(EELFLoggerDelegate.applicationLogger,timingString);
-    }
-
-    /**
-     * 
-     * @param insObj
-     * @param lockName
-     * @param nodeName
-     * @throws Exception
-     */
-    @GET
-    @Path("/purezk/atomic/{lockname}/{name}")
-    @Consumes(MediaType.APPLICATION_JSON)
-    public void pureZkAtomicGet(JsonInsert insObj, @PathParam("lockname") String lockName,
-                    @PathParam("name") String nodeName) throws Exception {
-        logger.info("--------------Zk atomic read-------------------------");
-        long start = System.currentTimeMillis();
-        String lockId = MusicCore.createLockReference(lockName);
-        long leasePeriod = MusicUtil.getDefaultLockLeasePeriod();
-        ReturnType lockAcqResult = MusicCore.acquireLockWithLease(lockName, lockId, leasePeriod);
-        if (lockAcqResult.getResult().equals(ResultType.SUCCESS)) {
-            logger.info("acquired lock with id " + lockId);
-            MusicCore.pureZkRead(nodeName);
-            boolean voluntaryRelease = true;
-            MusicCore.releaseLock(lockId, voluntaryRelease);
-        } else {
-            MusicCore.destroyLockRef(lockId);
-        }
-
-        long end = System.currentTimeMillis();
-        logger.info(EELFLoggerDelegate.applicationLogger,"Total time taken for Zk atomic read:" + (end - start) + " ms");
-    }
-
-    /**
-     *
-     * doing an update directly to cassa but through the rest api
-     * 
-     * @param insObj
-     * @param keyspace
-     * @param tablename
-     * @param info
-     * @return
-     * @throws Exception
-     */
-    @PUT
-    @Path("/cassa/keyspaces/{keyspace}/tables/{tablename}/rows")
-    @Consumes(MediaType.APPLICATION_JSON)
-    @Produces(MediaType.APPLICATION_JSON)
-    public boolean updateTableCassa(JsonInsert insObj, @PathParam("keyspace") String keyspace,
-                    @PathParam("tablename") String tablename, @Context UriInfo info)
-                    throws Exception {
-        long startTime = System.currentTimeMillis();
-        String operationId = UUID.randomUUID().toString();// just for debugging purposes.
-        String consistency = insObj.getConsistencyInfo().get("type");
-        logger.info(EELFLoggerDelegate.applicationLogger,"--------------Cassandra " + consistency + " update-" + operationId
-                        + "-------------------------");
-        PreparedQueryObject queryObject = new PreparedQueryObject();
-        Map<String, Object> valuesMap = insObj.getValues();
-        TableMetadata tableInfo = MusicCore.returnColumnMetadata(keyspace, tablename);
-        String vectorTs = "'" + Thread.currentThread().getId() + System.currentTimeMillis() + "'";
-        String fieldValueString = "vector_ts= ? ,";
-        queryObject.addValue(vectorTs);
-
-        int counter = 0;
-        for (Map.Entry<String, Object> entry : valuesMap.entrySet()) {
-            Object valueObj = entry.getValue();
-            DataType colType = tableInfo.getColumn(entry.getKey()).getType();
-            Object valueString = MusicUtil.convertToActualDataType(colType, valueObj);
-            fieldValueString = fieldValueString + entry.getKey() + "= ?";
-            queryObject.addValue(valueString);
-            if (counter != valuesMap.size() - 1)
-                fieldValueString = fieldValueString + ",";
-            counter = counter + 1;
-        }
-
-        // get the row specifier
-        String rowSpec = "";
-        counter = 0;
-        queryObject.appendQueryString("UPDATE " + keyspace + "." + tablename + " ");
-        MultivaluedMap<String, String> rowParams = info.getQueryParameters();
-        String primaryKey = "";
-        for (MultivaluedMap.Entry<String, List<String>> entry : rowParams.entrySet()) {
-            String keyName = entry.getKey();
-            List<String> valueList = entry.getValue();
-            String indValue = valueList.get(0);
-            DataType colType = tableInfo.getColumn(entry.getKey()).getType();
-            Object formattedValue = MusicUtil.convertToActualDataType(colType, indValue);
-            primaryKey = primaryKey + indValue;
-            rowSpec = rowSpec + keyName + "= ? ";
-            queryObject.addValue(formattedValue);
-            if (counter != rowParams.size() - 1)
-                rowSpec = rowSpec + " AND ";
-            counter = counter + 1;
-        }
-
-
-        String ttl = insObj.getTtl();
-        String timestamp = insObj.getTimestamp();
-
-        if ((ttl != null) && (timestamp != null)) {
-
-            logger.info(EELFLoggerDelegate.applicationLogger,"both there");
-            queryObject.appendQueryString(" USING TTL ? AND TIMESTAMP ?");
-            queryObject.addValue(Integer.parseInt(ttl));
-            queryObject.addValue(Long.parseLong(timestamp));
-        }
-
-        if ((ttl != null) && (timestamp == null)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"ONLY TTL there");
-            queryObject.appendQueryString(" USING TTL ?");
-            queryObject.addValue(Integer.parseInt(ttl));
-        }
-
-        if ((ttl == null) && (timestamp != null)) {
-            logger.info(EELFLoggerDelegate.applicationLogger,"ONLY timestamp there");
-            queryObject.appendQueryString(" USING TIMESTAMP ?");
-            queryObject.addValue(Long.parseLong(timestamp));
-        }
-        queryObject.appendQueryString(" SET " + fieldValueString + " WHERE " + rowSpec + ";");
-
-        long jsonParseCompletionTime = System.currentTimeMillis();
-
-        boolean operationResult = true;
-        MusicCore.getDSHandle().executePut(queryObject, insObj.getConsistencyInfo().get("type"));
-
-        long actualUpdateCompletionTime = System.currentTimeMillis();
-
-        long endTime = System.currentTimeMillis();
-
-        String timingString = "Time taken in ms for Cassandra " + consistency + " update-"
-                        + operationId + ":" + "|total operation time:" + (endTime - startTime)
-                        + "|json parsing time:" + (jsonParseCompletionTime - startTime)
-                        + "|update time:" + (actualUpdateCompletionTime - jsonParseCompletionTime)
-                        + "|";
-        logger.info(EELFLoggerDelegate.applicationLogger,timingString);
-
-        return operationResult;
-    }
-}
diff --git a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
index 2d1a8836..99c60b30 100755
--- a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java
@@ -56,6 +56,7 @@ import org.onap.music.datastore.jsonobjects.JsonTable;
 import org.onap.music.datastore.jsonobjects.JsonUpdate;
 import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
 import org.onap.music.eelf.logging.format.ErrorTypes;
@@ -159,7 +160,7 @@ public class RestMusicDataAPI {
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
             response.status(Status.UNAUTHORIZED);
-            return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         if(kspObject == null || kspObject.getReplicationInfo() == null) {
             authMap.put(ResultType.EXCEPTION.getResult(), ResultType.BODYMISSING.getResult());
@@ -169,7 +170,7 @@ public class RestMusicDataAPI {
 
 
         try {
-            authMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+            authMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                             "createKeySpace");
         } catch (Exception e) {
             logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.MISSINGDATA  ,ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
@@ -183,7 +184,7 @@ public class RestMusicDataAPI {
             } else {
                 logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
                 response.status(Status.UNAUTHORIZED);
-                return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+                return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
             }
         }
 
@@ -285,7 +286,7 @@ public class RestMusicDataAPI {
 		Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
-        Map<String, Object> authMap = MusicCore.autheticateUser(ns, userId, password,keyspaceName, aid, "dropKeySpace");
+        Map<String, Object> authMap = MusicCore.authenticate(ns, userId, password,keyspaceName, aid, "dropKeySpace");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
@@ -362,13 +363,13 @@ public class RestMusicDataAPI {
 		Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
-        Map<String, Object> authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+        Map<String, Object> authMap = MusicCore.authenticate(ns, userId, password, keyspace,
                         aid, "createTable");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
-            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         String consistency = MusicUtil.EVENTUAL;
         // for now this needs only eventual consistency
@@ -548,7 +549,7 @@ public class RestMusicDataAPI {
         ResultType result = ResultType.FAILURE;
         try {
           //logger.info("cjc query="+queryObject.getQuery());
-            result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
+            result = MusicCore.createTable(keyspace, tablename, queryObject, consistency);
         } catch (MusicServiceException ex) {
             logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.CRITICAL, ErrorTypes.MUSICSERVICEERROR);
             response.status(Status.BAD_REQUEST);
@@ -588,20 +589,20 @@ public class RestMusicDataAPI {
 		Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
-        Map<String, Object> authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,aid, "createIndex");
+        Map<String, Object> authMap = MusicCore.authenticate(ns, userId, password, keyspace,aid, "createIndex");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
             response.status(Status.UNAUTHORIZED);
-            return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         MultivaluedMap<String, String> rowParams = info.getQueryParameters();
         String indexName = "";
         if (rowParams.getFirst("index_name") != null)
             indexName = rowParams.getFirst("index_name");
         PreparedQueryObject query = new PreparedQueryObject();
-        query.appendQueryString("Create index if not exists " + indexName + "  on " + keyspace + "."
+        query.appendQueryString("Create index " + indexName + " if not exists on " + keyspace + "."
                         + tablename + " (" + fieldName + ");");
         
         ResultType result = ResultType.FAILURE;
@@ -613,9 +614,9 @@ public class RestMusicDataAPI {
             return response.entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
         }
         if ( result.equals(ResultType.SUCCESS) ) {
-            return response.status(Status.OK).entity(new JsonResponse(result).setMessage("Index Created on " + keyspace+"."+tablename+"."+fieldName).toMap()).build();
+            return response.entity(new JsonResponse(result).setMessage("Index Created on " + keyspace+"."+tablename+"."+fieldName).toMap()).build();
         } else {
-            return response.status(Status.BAD_REQUEST).entity(new JsonResponse(result).setError("Unknown Error in create index.").toMap()).build();
+            return response.entity(new JsonResponse(result).setError("Unknown Error in create index.").toMap()).build();
         }
     }
 
@@ -652,7 +653,7 @@ public class RestMusicDataAPI {
         Map<String, Object> authMap = null;
         
         try {
-            authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+            authMap = MusicCore.authenticate(ns, userId, password, keyspace,
                           aid, "insertIntoTable");
         } catch (Exception e) {
           logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
@@ -662,7 +663,7 @@ public class RestMusicDataAPI {
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.CRITICAL, ErrorTypes.AUTHENTICATIONERROR);
-            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
 
         Map<String, Object> valuesMap = insObj.getValues();
@@ -808,10 +809,6 @@ public class RestMusicDataAPI {
                 result = MusicCore.atomicPut(keyspace, tablename, primaryKey, queryObject, null);
 
             }
-            else if (consistency.equalsIgnoreCase(MusicUtil.ATOMICDELETELOCK)) {
-                result = MusicCore.atomicPutWithDeleteLock(keyspace, tablename, primaryKey, queryObject, null);
-
-            }
         } catch (Exception ex) {
             logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
             return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
@@ -862,7 +859,7 @@ public class RestMusicDataAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         Map<String, Object> authMap;
         try {
-            authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+            authMap = MusicCore.authenticate(ns, userId, password, keyspace,
                           aid, "updateTable");
         } catch (Exception e) {
               logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
@@ -872,7 +869,7 @@ public class RestMusicDataAPI {
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
-              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         long startTime = System.currentTimeMillis();
         String operationId = UUID.randomUUID().toString();// just for infoging
@@ -991,20 +988,11 @@ public class RestMusicDataAPI {
             }
             operationResult = MusicCore.criticalPut(keyspace, tablename, rowId.primarKeyValue,
                             queryObject, lockId, conditionInfo);
-        } else if (consistency.equalsIgnoreCase("atomic_delete_lock")) {
-            // this function is mainly for the benchmarks
-            try {
-              operationResult = MusicCore.atomicPutWithDeleteLock(keyspace, tablename,
-                              rowId.primarKeyValue, queryObject, conditionInfo);
-            } catch (MusicLockingException e) {
-                logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
-                  return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
-            }
         } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
             try {
               operationResult = MusicCore.atomicPut(keyspace, tablename, rowId.primarKeyValue,
                               queryObject, conditionInfo);
-            } catch (MusicLockingException e) {
+            } catch (MusicLockingException | MusicQueryException | MusicServiceException e) {
                 logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
                 return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(e.getMessage()).toMap()).build();
             }
@@ -1075,7 +1063,7 @@ public class RestMusicDataAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         Map<String, Object> authMap = null;
         try {
-            authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
+            authMap = MusicCore.authenticate(ns, userId, password, keyspace,
                             aid, "deleteFromTable");
         } catch (Exception e) {
             logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
@@ -1085,7 +1073,7 @@ public class RestMusicDataAPI {
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
-              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         if(delObj == null) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGDATA  ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
@@ -1162,11 +1150,7 @@ public class RestMusicDataAPI {
                     operationResult = MusicCore.atomicPut(keyspace, tablename, rowId.primarKeyValue,
                                     queryObject, conditionInfo);
             }
-            else if (consistency.equalsIgnoreCase(MusicUtil.ATOMICDELETELOCK)) {
-                    operationResult = MusicCore.atomicPutWithDeleteLock(keyspace, tablename, rowId.primarKeyValue,
-                                    queryObject, conditionInfo);
-            }
-        } catch (MusicLockingException e) {
+        } catch (MusicLockingException | MusicQueryException | MusicServiceException e) {
             logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR  ,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
               return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
                     .setError("Unable to perform Delete operation. Exception from music").toMap()).build();
@@ -1215,12 +1199,12 @@ public class RestMusicDataAPI {
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         Map<String, Object> authMap =
-                        MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "dropTable");
+                        MusicCore.authenticate(ns, userId, password, keyspace, aid, "dropTable");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
-            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         String consistency = "eventual";// for now this needs only eventual
                                         // consistency
@@ -1270,12 +1254,12 @@ public class RestMusicDataAPI {
 		Map<String,String> userCredentials = MusicUtil.extractBasicAuthentication(authorization);
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
-        Map<String, Object> authMap = MusicCore.autheticateUser(ns, userId, password, keyspace,aid, "selectCritical");
+        Map<String, Object> authMap = MusicCore.authenticate(ns, userId, password, keyspace,aid, "selectCritical");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"Error while authentication... ", AppMessages.MISSINGINFO  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
-              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+              return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         String lockId = selObj.getConsistencyInfo().get("lockId");
 
@@ -1307,10 +1291,6 @@ public class RestMusicDataAPI {
         } else if (consistency.equalsIgnoreCase(MusicUtil.ATOMIC)) {
             results = MusicCore.atomicGet(keyspace, tablename, rowId.primarKeyValue, queryObject);
         }
-        
-        else if (consistency.equalsIgnoreCase(MusicUtil.ATOMICDELETELOCK)) {
-            results = MusicCore.atomicGetWithDeleteLock(keyspace, tablename, rowId.primarKeyValue, queryObject);
-        }
         if(results!=null && results.getAvailableWithoutFetching() >0) {
         	return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicCore.marshallResults(results)).toMap()).build();
         }
@@ -1353,12 +1333,12 @@ public class RestMusicDataAPI {
 		String userId = userCredentials.get(MusicUtil.USERID);
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         Map<String, Object> authMap =
-                        MusicCore.autheticateUser(ns, userId, password, keyspace, aid, "select");
+                        MusicCore.authenticate(ns, userId, password, keyspace, aid, "select");
         if (authMap.containsKey("aid"))
             authMap.remove("aid");
         if (!authMap.isEmpty()) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR  ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
-            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Error"))).toMap()).build();
+            return response.status(Status.UNAUTHORIZED).entity(new JsonResponse(ResultType.FAILURE).setError(String.valueOf(authMap.get("Exception"))).toMap()).build();
         }
         PreparedQueryObject queryObject = new PreparedQueryObject();
 
@@ -1380,7 +1360,7 @@ public class RestMusicDataAPI {
             if(results.getAvailableWithoutFetching() >0) {
             	return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicCore.marshallResults(results)).toMap()).build();
             }
-            return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setDataResult(MusicCore.marshallResults(results)).setError("No data found").toMap()).build();
+            return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS).setError("No data found").toMap()).build();
         } catch (MusicServiceException ex) {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.UNKNOWNERROR  ,ErrorSeverity.ERROR, ErrorTypes.MUSICSERVICEERROR);
             return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE).setError(ex.getMessage()).toMap()).build();
diff --git a/src/main/java/org/onap/music/rest/RestMusicHealthCheckAPI.java b/src/main/java/org/onap/music/rest/RestMusicHealthCheckAPI.java
index 895f0abf..c7e8fda1 100644
--- a/src/main/java/org/onap/music/rest/RestMusicHealthCheckAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicHealthCheckAPI.java
@@ -88,28 +88,8 @@ public class RestMusicHealthCheckAPI {
 			resultMap.put("INACTIVE", "One or more nodes in the Cluster is/are down or not responding.");
 			return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
 		}
-		
-		
-		
 	}
 	
-	@GET
-	@Path("/pingZookeeper")
-	@ApiOperation(value = "Get Health Status", response = Map.class)
-	@Produces(MediaType.APPLICATION_JSON)
-	public Response ZKStatus(@Context HttpServletResponse response) {
-		logger.info(EELFLoggerDelegate.applicationLogger,"Replying to request for MUSIC Health Check status for Zookeeper");
-		Map<String, Object> resultMap = new HashMap<>();
-		MusicHealthCheck ZKHealthCheck = new MusicHealthCheck();
-		String status = ZKHealthCheck.getZookeeperStatus();
-		if(status.equals("ACTIVE")) {
-			resultMap.put("ACTIVE", "Zookeeper is Active and Running");
-			return Response.status(Status.OK).entity(resultMap).build();
-		}else {
-			resultMap.put("INACTIVE", "Zookeeper is not responding");
-			return Response.status(Status.BAD_REQUEST).entity(resultMap).build();
-		}
-	}
 	
 	
 	
diff --git a/src/main/java/org/onap/music/rest/RestMusicLocksAPI.java b/src/main/java/org/onap/music/rest/RestMusicLocksAPI.java
index 70583baa..835dda14 100644
--- a/src/main/java/org/onap/music/rest/RestMusicLocksAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicLocksAPI.java
@@ -40,7 +40,7 @@ import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.eelf.logging.format.AppMessages;
 import org.onap.music.eelf.logging.format.ErrorSeverity;
 import org.onap.music.eelf.logging.format.ErrorTypes;
-import org.onap.music.lockingservice.MusicLockState;
+import org.onap.music.datastore.MusicLockState;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
@@ -96,7 +96,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "createLockReference");
         if (resultMap.containsKey("aid"))
             resultMap.remove("aid");
@@ -148,7 +148,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "accquireLock");
         if (resultMap.containsKey("aid"))
             resultMap.remove("aid");
@@ -198,7 +198,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "accquireLockWithLease");
 
         if (resultMap.containsKey("aid"))
@@ -245,7 +245,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "currentLockHolder");
         if (resultMap.containsKey("aid"))
             resultMap.remove("aid");
@@ -291,7 +291,7 @@ public class RestMusicLocksAPI {
         }
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "currentLockState");
         
         if (resultMap.containsKey("aid"))
@@ -301,7 +301,7 @@ public class RestMusicLocksAPI {
             return response.status(Status.BAD_REQUEST).entity(resultMap).build();
         }
         
-        MusicLockState mls = MusicCore.getMusicLockState(lockName);
+        org.onap.music.datastore.MusicLockState mls = MusicCore.getMusicLockState(lockName);
         Map<String,Object> returnMap = null;
         JsonResponse jsonResponse = new JsonResponse(ResultType.FAILURE).setLock(lockName);
         if(mls == null) {
@@ -348,7 +348,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "unLock");
         if (resultMap.containsKey("aid"))
             resultMap.remove("aid");
@@ -356,8 +356,9 @@ public class RestMusicLocksAPI {
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA  ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
             return response.status(Status.BAD_REQUEST).entity(resultMap).build();
         }
-        boolean voluntaryRelease = true; 
-        MusicLockState mls = MusicCore.releaseLock(lockId,voluntaryRelease);
+        String fullyQualifiedKey = lockId.substring(lockId.indexOf('$')+1, lockId.lastIndexOf('$'));
+        MusicLockState mls = MusicCore.voluntaryReleaseLock(fullyQualifiedKey, lockId);
+        		
         if(mls.getErrorMessage() != null) {
             resultMap.put(ResultType.EXCEPTION.getResult(), mls.getErrorMessage());
             logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.INCORRECTDATA  ,ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
@@ -405,7 +406,7 @@ public class RestMusicLocksAPI {
 		String password = userCredentials.get(MusicUtil.PASSWORD);
         String keyspaceName = (String) resultMap.get("keyspace");
         resultMap.remove("keyspace");
-        resultMap = MusicCore.autheticateUser(ns, userId, password, keyspaceName, aid,
+        resultMap = MusicCore.authenticate(ns, userId, password, keyspaceName, aid,
                 "deleteLock");
         if (resultMap.containsKey("aid"))
             resultMap.remove("aid");
diff --git a/src/main/java/org/onap/music/rest/RestMusicQAPI.java b/src/main/java/org/onap/music/rest/RestMusicQAPI.java
index 1f6ec24f..8af334c7 100755
--- a/src/main/java/org/onap/music/rest/RestMusicQAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicQAPI.java
@@ -34,6 +34,7 @@ import javax.ws.rs.core.UriInfo;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.core.Response.ResponseBuilder;
 import javax.ws.rs.core.Response.Status;
+// cjcimport javax.servlet.http.HttpServletResponse;
 import org.onap.music.datastore.jsonobjects.JsonDelete;
 import org.onap.music.datastore.jsonobjects.JsonInsert;
 import org.onap.music.datastore.jsonobjects.JsonTable;
@@ -50,19 +51,22 @@ import org.onap.music.exceptions.MusicServiceException;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
+// cjc import org.onap.music.main.ReturnType;
 import org.onap.music.response.jsonobjects.JsonResponse;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 
-
+// import io.swagger.models.Response;
 // @Path("/v{version: [0-9]+}/priorityq/")
 @Path("{version}/priorityq/")
 @Api(value = "Q Api")
 public class RestMusicQAPI {
 
   private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicQAPI.class);
+  // private static String xLatestVersion = "X-latestVersion";
   /*
+   * private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(RestMusicDataAPI.class);
    * private static final String XMINORVERSION = "X-minorVersion"; private static final String
    * XPATCHVERSION = "X-patchVersion"; private static final String NS = "ns"; private static final
    * String USERID = "userId"; private static final String PASSWORD = "password";
@@ -104,12 +108,12 @@ public class RestMusicQAPI {
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
           throws Exception {
-    
+    //logger.info(logger, "cjc before start in q 1** major version=" + version);
 
     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
 
     Map<String, String> fields = tableObj.getFields();
-    if (fields == null) {
+    if (fields == null) { // || (!fields.containsKey("order")) ){
       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
       return response.status(Status.BAD_REQUEST)
@@ -186,13 +190,9 @@ public class RestMusicQAPI {
             clusteringKey=clusteringKey.replaceAll("[\\(]+","");
             clusteringKey=clusteringKey.replaceAll("[\\)]+","");
             clusteringKey.trim();
-            if (clusteringKey.indexOf(",") == 0) {
-                clusteringKey=clusteringKey.substring(1);
-            }
+            if (clusteringKey.indexOf(",") == 0) clusteringKey=clusteringKey.substring(1);
             clusteringKey.trim();
-            if (",".equals(clusteringKey) ) {
-            	clusteringKey=""; // print error if needed    ( ... ),)
-            }
+            if (clusteringKey.equals(",") ) clusteringKey=""; // print error if needed    ( ... ),)
          }
     }
 
@@ -252,11 +252,15 @@ public class RestMusicQAPI {
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
           throws Exception {
+    // ,@Context HttpServletResponse response) throws Exception {
 
+    // Map<String, Object> valuesMap = insObj.getValues();
     // check valuesMap.isEmpty and proceed
+    // if(valuesMap.isEmpty() ) {
     // response.addHeader(xLatestVersion, MusicUtil.getVersion());
     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
     if (insObj.getValues().isEmpty()) {
+      // response.status(404);
       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
       return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
@@ -292,11 +296,13 @@ public class RestMusicQAPI {
           JsonUpdate updateObj,
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
-          @Context UriInfo info) {
+          @Context UriInfo info) throws Exception {
 
     //logger.info(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA, ErrorSeverity.CRITICAL,
+      //      ErrorTypes.DATAERROR);
     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
     if (updateObj.getValues().isEmpty()) {
+      // response.status(404);
       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
       return response.status(Status.BAD_REQUEST)
@@ -341,10 +347,11 @@ public class RestMusicQAPI {
           JsonDelete delObj,
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
-          @Context UriInfo info) {
+          @Context UriInfo info) throws Exception {
     // added checking as per RestMusicDataAPI
     ResponseBuilder response = MusicUtil.buildVersionResponse(version, minorVersion, patchVersion);
     if (delObj == null) {
+      // response.status(404);
       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.MISSINGDATA,
               ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
       return response.status(Status.BAD_REQUEST).entity(new JsonResponse(ResultType.FAILURE)
@@ -396,7 +403,6 @@ public class RestMusicQAPI {
         queryObject = new RestMusicDataAPI().selectSpecificQuery(version, minorVersion,
                 patchVersion, aid, ns, userId, password, keyspace, tablename, info, limit);
       } catch (MusicServiceException ex) {
-    	logger.error(EELFLoggerDelegate.errorLogger, "MusicServiceException occured in peek"+ ex);
         logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.UNKNOWNERROR,
                 ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
         return response.status(Status.BAD_REQUEST)
@@ -410,7 +416,6 @@ public class RestMusicQAPI {
       return response.status(Status.OK).entity(new JsonResponse(ResultType.SUCCESS)
               .setDataResult(MusicCore.marshallResults(results)).toMap()).build();
     } catch (MusicServiceException ex) {
-      logger.error(EELFLoggerDelegate.errorLogger, "MusicServiceException occured in peek"+ ex);
       logger.error(EELFLoggerDelegate.errorLogger, "", AppMessages.UNKNOWNERROR,
               ErrorSeverity.ERROR, ErrorTypes.MUSICSERVICEERROR);
       return response.status(Status.BAD_REQUEST)
@@ -447,9 +452,11 @@ public class RestMusicQAPI {
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename,
           @Context UriInfo info) throws Exception {
+    //int limit = -1;
     /*
      * PreparedQueryObject query = new RestMusicDataAPI().selectSpecificQuery(version, minorVersion,
      * patchVersion, aid, ns, userId, password, keyspace, tablename, info, limit); ResultSet results
+     * = MusicCore.get(query); return MusicCore.marshallResults(results);
      */
    /* Map<String ,String> auth = new HashMap<>();
     String userId =auth.get(MusicUtil.USERID);
@@ -485,6 +492,8 @@ public class RestMusicQAPI {
           @ApiParam(value = "Key Space", required = true) @PathParam("keyspace") String keyspace,
           @ApiParam(value = "Table Name", required = true) @PathParam("qname") String tablename)
           throws Exception {
+    // @Context HttpServletResponse response) throws Exception {
+    // tabObj never in use & thus no need to verify
 
 
     return new RestMusicDataAPI().dropTable(version, minorVersion, patchVersion, aid, ns, authorization, keyspace, tablename);
diff --git a/src/main/java/org/onap/music/rest/RestMusicVersionAPI.java b/src/main/java/org/onap/music/rest/RestMusicVersionAPI.java
index b9754f61..a5f2ac49 100644
--- a/src/main/java/org/onap/music/rest/RestMusicVersionAPI.java
+++ b/src/main/java/org/onap/music/rest/RestMusicVersionAPI.java
@@ -35,6 +35,9 @@ import org.onap.music.eelf.logging.EELFLoggerDelegate;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
 
+import com.att.eelf.configuration.EELFLogger;
+import com.att.eelf.configuration.EELFManager;
+
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 
diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml
index b75fcd85..fe7f54ae 100644
--- a/src/main/resources/logback.xml
+++ b/src/main/resources/logback.xml
@@ -259,13 +259,12 @@
        
   </logger>
   
+  
+
+  
   <root level="INFO">
     <appender-ref ref="asyncEELF" />
     <appender-ref ref="STDOUT" />
   </root>
 
-  <!-- Conductor Specific additions to squash WARNING and INFO -->
-  <logger name="com.datastax.driver.core.Cluster" level="ERROR"/> 
-  <logger name="org.onap.music.main.MusicCore" level="ERROR"/>  
-
 </configuration>
diff --git a/src/test/java/org/onap/music/unittests/CassandraCQL.java b/src/test/java/org/onap/music/unittests/CassandraCQL.java
index a4c250c2..a9cbe109 100644
--- a/src/test/java/org/onap/music/unittests/CassandraCQL.java
+++ b/src/test/java/org/onap/music/unittests/CassandraCQL.java
@@ -45,7 +45,7 @@ import com.datastax.driver.core.exceptions.NoHostAvailableException;
 import org.apache.cassandra.exceptions.ConfigurationException;
 import org.apache.thrift.transport.TTransportException;
 import org.cassandraunit.utils.EmbeddedCassandraServerHelper;
-import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.CassaDataStore;
 import org.onap.music.datastore.PreparedQueryObject;
 
 public class CassandraCQL {
@@ -222,7 +222,7 @@ public class CassandraCQL {
         return allPossibleIps;
     }
 
-    public static MusicDataStore connectToEmbeddedCassandra() {
+    public static CassaDataStore connectToEmbeddedCassandra() {
         Iterator<String> it = getAllPossibleLocalIps().iterator();
         String address = "localhost";
 
@@ -249,7 +249,7 @@ public class CassandraCQL {
 
             }
         }
-        return new MusicDataStore(cluster, session);
+        return new CassaDataStore(cluster, session);
 
     }
 
diff --git a/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java b/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java
index 16d2af02..3f7fd3b7 100644
--- a/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java
+++ b/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java
@@ -33,7 +33,7 @@ import org.mockito.Mock;
 import org.onap.music.exceptions.MusicQueryException;
 import org.onap.music.exceptions.MusicServiceException;
 
-import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.CassaDataStore;
 import org.onap.music.datastore.PreparedQueryObject;
 
 import com.datastax.driver.core.DataType;
@@ -44,7 +44,7 @@ import com.datastax.driver.core.TableMetadata;
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class MusicDataStoreTest {
 
-    static MusicDataStore dataStore;
+    static CassaDataStore dataStore;
     static PreparedQueryObject testObject;
 
     @BeforeClass
diff --git a/src/test/java/org/onap/music/unittests/MusicLockStoreTest.java b/src/test/java/org/onap/music/unittests/MusicLockStoreTest.java
new file mode 100644
index 00000000..86774538
--- /dev/null
+++ b/src/test/java/org/onap/music/unittests/MusicLockStoreTest.java
@@ -0,0 +1,170 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 AT&T Intellectual Property
+ * ===================================================================
+ *  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.music.unittests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.mockito.Mock;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+
+import org.onap.music.datastore.CassaDataStore;
+import org.onap.music.datastore.CassaLockStore;
+import org.onap.music.datastore.PreparedQueryObject;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.TableMetadata;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MusicLockStoreTest {
+
+    static CassaDataStore dataStore;
+    static CassaLockStore lockStore;
+    static PreparedQueryObject testObject;
+
+    @BeforeClass
+    public static void init() {
+        dataStore = CassandraCQL.connectToEmbeddedCassandra();
+        lockStore = new CassaLockStore(dataStore);
+
+    }
+
+    @AfterClass
+    public static void close() throws MusicServiceException, MusicQueryException {
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.dropKeyspace);
+        dataStore.executePut(testObject, "eventual");
+        dataStore.close();
+
+    }
+
+    @Test
+    public void Test1_SetUp() throws MusicServiceException, MusicQueryException {
+        boolean result = false;
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createKeySpace);
+        result = dataStore.executePut(testObject, "eventual");;
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createTableEmployees);
+        result = dataStore.executePut(testObject, "eventual");
+        assertEquals(true, result);
+
+    }
+
+    
+    @Test
+    public void Test_createLockQueue() throws MusicServiceException, MusicQueryException {
+    		String keyspace = "testCassa";
+    		String table = "employees";
+    		/*
+    		 * above two hard coded since this depends on the keyspace and table created in the 
+    		 * CassandraCQL class. Need to change this..
+    		 */
+    		boolean result = lockStore.createLockQueue(keyspace,table);
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test3_ExecutePut_critical_insert() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedInsertQueryObject2();
+        boolean result = dataStore.executePut(testObject, "Critical");
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test4_ExecutePut_eventual_update() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedUpdateQueryObject();
+        boolean result = false;
+        result = dataStore.executePut(testObject, "eventual");
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test5_ExecuteEventualGet() throws MusicServiceException, MusicQueryException {
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.selectALL);
+        boolean result = false;
+        int count = 0;
+        ResultSet output = null;
+        output = dataStore.executeEventualGet(testObject);
+        System.out.println(output);
+        ;
+        for (Row row : output) {
+            count++;
+            System.out.println(row.toString());
+        }
+        if (count == 2) {
+            result = true;
+        }
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test6_ExecuteCriticalGet() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedGetQuery();
+        boolean result = false;
+        int count = 0;
+        ResultSet output = null;
+        output = dataStore.executeCriticalGet(testObject);
+        System.out.println(output);
+        ;
+        for (Row row : output) {
+            count++;
+            System.out.println(row.toString());
+        }
+        if (count == 1) {
+            result = true;
+        }
+        assertEquals(true, result);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void Test7_exception() {
+        PreparedQueryObject queryObject = null;
+        try {
+            dataStore.executePut(queryObject, "critical");
+        } catch (MusicQueryException | MusicServiceException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+    
+    @Test
+    public void Test8_columnDataType() {
+        DataType data = dataStore.returnColumnDataType("testCassa", "employees", "empName");
+        String datatype = data.toString();
+        assertEquals("text",datatype);
+    }
+    
+    @Test
+    public void Test8_columnMetdaData() {
+        TableMetadata data = dataStore.returnColumnMetadata("testCassa", "employees");
+        assertNotNull(data);
+    }
+}
diff --git a/src/test/java/org/onap/music/unittests/TestCassaLockStore.java b/src/test/java/org/onap/music/unittests/TestCassaLockStore.java
new file mode 100644
index 00000000..bf058121
--- /dev/null
+++ b/src/test/java/org/onap/music/unittests/TestCassaLockStore.java
@@ -0,0 +1,71 @@
+package org.onap.music.unittests;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import org.onap.music.datastore.CassaLockStore;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicCore;
+
+public class TestCassaLockStore {
+	
+	
+	public static void main(String[] args) {
+		
+		
+		try {
+			CassaLockStore lockStore = new CassaLockStore();
+			String keyspace = "ks_testLockStore";
+			String table = "table_testLockStore";
+
+			Map<String,Object> replicationInfo = new HashMap<String, Object>();
+            replicationInfo.put("'class'", "'SimpleStrategy'");
+            replicationInfo.put("'replication_factor'", 1);
+            
+            PreparedQueryObject queryObject = new PreparedQueryObject();
+            queryObject.appendQueryString("CREATE KEYSPACE " + keyspace + " WITH REPLICATION = " + replicationInfo.toString().replaceAll("=", ":"));
+            MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+
+            
+            queryObject = new PreparedQueryObject();
+            queryObject.appendQueryString("CREATE TABLE " + keyspace + "." + table + " (name text PRIMARY KEY, count varint);");
+            MusicCore.createTable(keyspace, table, queryObject, "eventual");              
+
+			
+			lockStore.createLockQueue(keyspace, table);
+			
+			String lockRefb1 = lockStore.genLockRefandEnQueue(keyspace, table, "bharath");
+			
+			
+			
+			String lockRefc1 = lockStore.genLockRefandEnQueue(keyspace, table, "cat");
+
+			String lockRefc2 = lockStore.genLockRefandEnQueue(keyspace, table, "cat");
+
+
+			assert(lockStore.peekLockQueue(keyspace, table, "cat").equals(lockRefc1));
+			
+			assert(!lockStore.peekLockQueue(keyspace, table, "cat").equals(lockRefc2));
+
+			
+			assert(lockStore.peekLockQueue(keyspace, table, "bharath").equals(lockRefb1));
+			
+			
+			lockStore.deQueueLockRef(keyspace, table, "cat", lockRefc1);
+			
+			assert(lockStore.peekLockQueue(keyspace, table, "cat").equals(lockRefc2));
+
+		} catch (MusicServiceException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} catch (MusicQueryException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+
+
+}
diff --git a/src/test/java/org/onap/music/unittests/TestLockStore.java b/src/test/java/org/onap/music/unittests/TestLockStore.java
deleted file mode 100644
index 4dbc7b4f..00000000
--- a/src/test/java/org/onap/music/unittests/TestLockStore.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.unittests;
-
-import org.apache.log4j.Logger;
-import org.onap.music.lockingservice.MusicLockingService;
-
-public class TestLockStore {
-    final static Logger logger = Logger.getLogger(TestLockStore.class);
-
-    public static void main(String[] args) throws Exception {
-        String lockName = "/achristmkllas";
-        MusicLockingService ml = new MusicLockingService();
-        ml.deleteLock(lockName);
-
-
-        logger.info("lockname:" + lockName);
-
-        String lockId1 = ml.createLockId(lockName);
-        logger.info("lockId1 " + lockId1);
-        logger.info(ml.isMyTurn(lockId1));
-
-        String lockId2 = ml.createLockId(lockName);
-        logger.info("lockId2 " + lockId2);
-        logger.info("check " + ml.isMyTurn("$bank$x-94608776321630264-0000000000"));
-        logger.info(ml.isMyTurn(lockId2));
-
-        // zkClient.unlock(lockId1);
-        // logger.info(ml.lock(lockId2));
-        // zkClient.unlock(lockId2);
-    }
-
-
-}
diff --git a/src/test/java/org/onap/music/unittests/TestMusicCore.java b/src/test/java/org/onap/music/unittests/TestMusicCore.java
index ed9c2f68..3a28f963 100644
--- a/src/test/java/org/onap/music/unittests/TestMusicCore.java
+++ b/src/test/java/org/onap/music/unittests/TestMusicCore.java
@@ -1,678 +1,81 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 AT&T Intellectual Property
- * ===================================================================
- *  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.music.unittests;
 
-import static org.junit.Assert.*;
-import static org.onap.music.main.MusicCore.mDstoreHandle;
-import static org.onap.music.main.MusicCore.mLockHandle;
+import static org.junit.Assert.assertEquals;
+
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
-import org.apache.zookeeper.KeeperException.NoNodeException;
-import org.junit.Before;
-import org.junit.Ignore;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.onap.music.exceptions.MusicLockingException;
+import org.junit.runners.MethodSorters;
+import org.onap.music.datastore.CassaDataStore;
+import org.onap.music.datastore.PreparedQueryObject;
 import org.onap.music.exceptions.MusicQueryException;
 import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.lockingservice.MusicLockState;
-import org.onap.music.lockingservice.MusicLockingService;
-import org.onap.music.lockingservice.MusicLockState.LockStatus;
 import org.onap.music.main.MusicCore;
-import org.onap.music.main.MusicUtil;
-import org.onap.music.main.ResultType;
-import org.onap.music.main.ReturnType;
-import org.onap.music.main.MusicCore.Condition;
-import org.onap.music.datastore.MusicDataStore;
-import org.onap.music.datastore.PreparedQueryObject;
-import org.onap.music.eelf.logging.EELFLoggerDelegate;
-import org.onap.music.eelf.logging.format.AppMessages;
-import org.onap.music.eelf.logging.format.ErrorSeverity;
-import org.onap.music.eelf.logging.format.ErrorTypes;
-import com.att.eelf.exception.EELFException;
+
 import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.Session;
 
-@RunWith(MockitoJUnitRunner.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class TestMusicCore {
+	
+    static CassaDataStore dataStore;
+    String keyspace = "MusicCoreUnitTestKp";
+    String table = "SampleTable";
 
-    @Mock
-    private Condition condition;
-
-    @Mock
-    private ResultSet rs;
-
-    @Mock
-    private PreparedQueryObject preparedQueryObject;
-    
-    @Mock
-    private Session session;
-
-    @Before
-    public void setUp() {
-        mLockHandle = Mockito.mock(MusicLockingService.class);
-
-    }
-
-    @Test
-    public void testCreateLockReferenceforvalidlock() {
-        Mockito.when(mLockHandle.createLockId("/" + "test")).thenReturn("lock");
-        String lockId = MusicCore.createLockReference("test");
-        assertEquals("lock", lockId);
-        Mockito.verify(mLockHandle).createLockId("/" + "test");
-    }
-
-
-    @Test
-    public void testCreateLockReferencefornullname() {
-        Mockito.when(mLockHandle.createLockId("/" + "test")).thenReturn("lock");
-        String lockId = MusicCore.createLockReference("x"); //test");
-        //System.out.println("cjc exception lockhandle=" + mLockHandle+"lockid="+lockId );
-        assertNotEquals("lock", lockId);
-        //Mockito.verify(mLockHandle).createLockId("/" + "test");
-    }
-    
-    @Test
-    public void testIsTableOrKeySpaceLock() {
-        Boolean result = MusicCore.isTableOrKeySpaceLock("ks1.tn1");
-        assertTrue(result);
-    }
-
-    @Test
-    public void testIsTableOrKeySpaceLockwithPrimarykey() {
-        Boolean result = MusicCore.isTableOrKeySpaceLock("ks1.tn1.pk1");
-        assertFalse(result);
-    }
-
-    @Test
-    public void testGetMusicLockState() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        Mockito.when(mLockHandle.getLockState("ks1.tb1.pk1")).thenReturn(musicLockState);
-        MusicLockState mls = MusicCore.getMusicLockState("ks1.tb1.pk1");
-        assertEquals(musicLockState, mls);
-        Mockito.verify(mLockHandle).getLockState("ks1.tb1.pk1");
-    }
-
-    @Test
-    public void testAcquireLockifisMyTurnTrue() throws MusicLockingException {
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType lock = MusicCore.acquireLock("ks1.tn1", "id1");
-        assertEquals(lock.getResult(), ResultType.SUCCESS);
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-    }
-
-    @Test
-    public void testAcquireLockifisMyTurnFalse() throws MusicLockingException {
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
-        ReturnType lock = MusicCore.acquireLock("ks1.ts1", "id1");
-        assertEquals(lock.getResult(), ResultType.FAILURE);
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-    }
-
-    @Test
-    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockTrue() throws MusicLockingException {
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType lock = MusicCore.acquireLock("ks1.tn1", "id1");
-        assertEquals(lock.getResult(), ResultType.SUCCESS);
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-    }
+    @BeforeClass
+    public static void init() {
+        dataStore = CassandraCQL.connectToEmbeddedCassandra();       
+        MusicCore.mDstoreHandle = dataStore;
 
-    @Test
-    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockFalseandHaveLock() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id1");
-        assertEquals(lock.getResult(), ResultType.SUCCESS);
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
-    }
 
-    @Test
-    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockFalseandDontHaveLock() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id2");
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id1");
-        assertEquals(lock.getResult(), ResultType.SUCCESS);
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
     }
     
-    @Test
-    public void testAcquireLockifLockRefDoesntExist() throws MusicLockingException {
-        Mockito.when(mLockHandle.lockIdExists("bs1")).thenReturn(false);
-        ReturnType lock = MusicCore.acquireLock("ks1.ts1", "bs1");
-        assertEquals(lock.getResult(), ResultType.FAILURE);
-        assertEquals(lock.getMessage(), "Lockid doesn't exist");
-        Mockito.verify(mLockHandle).lockIdExists("bs1");
-    }
-    
-    @Test
-    public void testAcquireLockWithLeasewithLease() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
-        musicLockState.setLeasePeriod(0);
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+    @AfterClass
+    public static void close() throws MusicServiceException, MusicQueryException {
+        dataStore.close();
+    }
+
+    @Test
+    public void Test1_createKeyspace() throws MusicServiceException, MusicQueryException {
+
+        Map<String,Object> replicationInfo = new HashMap<String, Object>();
+        replicationInfo.put("'class'", "'SimpleStrategy'");
+        replicationInfo.put("'replication_factor'", 1);
+        
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        queryObject.appendQueryString(
+          "CREATE KEYSPACE " + keyspace + " WITH REPLICATION = " + replicationInfo.toString().replaceAll("=", ":"));
+        MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+        
+        
+        //check with the system table in cassandra
+        queryObject = new PreparedQueryObject();
+        String systemQuery = "SELECT keyspace_name FROM system_schema.keyspaces where keyspace_name='"+keyspace.toLowerCase()+"';";
+        queryObject.appendQueryString(systemQuery);
+        ResultSet rs = dataStore.executeEventualGet(queryObject);     
+        assert rs.all().size()> 0;
     }
     
     @Test
-    public void testAcquireLockWithLeasewithException() throws MusicLockingException {
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "failure");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenThrow(new MusicLockingException());
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
-    }
-
-    @Test
-    public void testAcquireLockWithLeasewithLockStatusLOCKED() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
-    }
-
-    @Test
-    public void testAcquireLockWithLeasewithLockStatusUNLOCKED() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
-
-    }
-
-    @Test
-    public void testAcquireLockWithLeaseIfNotMyTurn() throws MusicLockingException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
-        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
-    }
-
-    @Test
-    public void testQuorumGet() throws MusicServiceException, MusicQueryException {
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        rs = Mockito.mock(ResultSet.class);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
-        ResultSet rs1 = MusicCore.quorumGet(preparedQueryObject);
-        assertNotNull(rs1);
-    }
-
-    @Test
-    public void testGetLockNameFromId() {
-        String lockname = MusicCore.getLockNameFromId("lockName$id");
-        assertEquals("lockName", lockname);
-    }
-
-    @Test
-    public void testDestroyLockRef() throws NoNodeException {
-        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
-        MusicCore.destroyLockRef("id1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
-    }
-
-    @Test
-    public void testreleaseLockwithvoluntaryReleaseTrue() throws NoNodeException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
-        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
-        MusicLockState musicLockState1 = MusicCore.releaseLock("id1", true);
-        assertEquals(musicLockState.getLockStatus(), musicLockState1.getLockStatus());
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
-    }
-
-    @Test
-    public void testreleaseLockwithvoluntaryReleaseFalse() throws NoNodeException {
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
-        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
-        MusicLockState musicLockState1 = MusicCore.releaseLock("id1", false);
-        assertEquals(musicLockState.getLockStatus(), musicLockState1.getLockStatus());
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
-    }
-
-    @Test
-    public void testDeleteLock() throws MusicLockingException {
-        Mockito.doNothing().when(mLockHandle).deleteLock("/" + "id1");
-        MusicCore.deleteLock("id1");
-        Mockito.verify(mLockHandle).deleteLock("/" + "id1");
-    }
-
-    /*
-     * @Test public void testNonKeyRelatedPut() throws Exception { mDstoreHandle =
-     * Mockito.mock(MusicDataStore.class); Mockito.when(mDstoreHandle.executePut("qu1",
-     * "consistency")).thenReturn(true); Boolean result = MusicCore.nonKeyRelatedPut("qu1",
-     * "consistency"); assertTrue(result); Mockito.verify(mDstoreHandle).executePut("qu1",
-     * "consistency"); }
-     */
-
-    @Test
-    public void testEventualPutPreparedQuery() throws MusicServiceException, MusicQueryException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "eventual")).thenReturn(true);
-        ReturnType actualResult = MusicCore.eventualPut(preparedQueryObject);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "eventual");
-    }
-
-    @Test
-    public void testEventualPutPreparedQuerywithResultFalse()
-                    throws MusicServiceException, MusicQueryException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "eventual")).thenReturn(false);
-        ReturnType actualResult = MusicCore.eventualPut(preparedQueryObject);
-        assertEquals(expectedResult.getResult(), actualResult.getResult());
-        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "eventual");
-        //Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, MusicUtil.EVENTUAL);
-    }
-
-    @Test
-    public void testCriticalPutPreparedQuerywithValidLockId()
-                    throws Exception {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        Mockito.when(condition.testCondition()).thenReturn(true);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "critical")).thenReturn(true);
-        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
-                        "id1", condition);
-        assertEquals(expectedResult.getResult(), returnType.getResult());
-        Mockito.verify(condition).testCondition();
-        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
-        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "critical");
-    }
-
-    @Test
-    public void testCriticalPutPreparedQuerywithInvalidLockId() throws MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
-                        "id1", condition);
-        assertEquals(expectedResult.getResult(), returnType.getResult());
-        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
-    }
-
-    @Test
-    public void testCriticalPutPreparedQuerywithvalidLockIdandTestConditionFalse() throws Exception {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        Mockito.when(condition.testCondition()).thenReturn(false);
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
-                        "id1", condition);
-        assertEquals(expectedResult.getResult(), returnType.getResult());
-        Mockito.verify(condition).testCondition();
-        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
-    }
-
-    @Test
-    public void testNonKeyRelatedPutPreparedQuery() throws Exception {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "consistency")).thenReturn(true);
-        ResultType result = MusicCore.nonKeyRelatedPut(preparedQueryObject, "consistency");
-        assertEquals(ResultType.SUCCESS, result);
-        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "consistency");
-    }
-
-    @Test
-    public void testAtomicPutPreparedQuery() throws Exception {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
-        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        Mockito.when(condition.testCondition()).thenReturn(true);
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "critical")).thenReturn(true);
-        ReturnType returnType =
-                        MusicCore.atomicPut("ks1", "tn1", "pk1", preparedQueryObject, condition);
-        assertEquals(expectedResult.getResult(), returnType.getResult());
-        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(condition).testCondition();
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
-                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
-        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "critical");
-    }
-
-    @Test
-    public void testAtomicPutPreparedQuerywithAcquireLockWithLeaseFalse() throws MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
-        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
-        ReturnType returnType =
-                        MusicCore.atomicPut("ks1", "tn1", "pk1", preparedQueryObject, condition);
-        assertEquals(expectedResult.getResult(), returnType.getResult());
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
-    }
-
-    @Test
-    public void testAtomicGetPreparedQuery() throws MusicServiceException, MusicQueryException, MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        rs = Mockito.mock(ResultSet.class);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
-        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
-        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
-        ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
-        assertNotNull(rs1);
-        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
-                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
-        Mockito.verify(mDstoreHandle).executeCriticalGet(preparedQueryObject);
-    }
-
-    @Test
-    public void testAtomicGetPreparedQuerywithAcquireLockWithLeaseFalse()
-                    throws MusicServiceException, MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        rs = Mockito.mock(ResultSet.class);
-        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
-        ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
-        assertNull(rs1);
-        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-    }
-
-    @Test
-    public void testGetPreparedQuery() throws MusicServiceException, MusicQueryException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        rs = Mockito.mock(ResultSet.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mDstoreHandle.executeEventualGet(preparedQueryObject)).thenReturn(rs);
-        ResultSet rs1 = MusicCore.get(preparedQueryObject);
-        assertNotNull(rs1);
-        Mockito.verify(mDstoreHandle).executeEventualGet(preparedQueryObject);
+    public void Test1_createTable() throws MusicServiceException, MusicQueryException {
+    		PreparedQueryObject queryObject = new PreparedQueryObject();
+        queryObject.appendQueryString(
+          "CREATE TABLE " + keyspace + "." + table + " (name text PRIMARY KEY, count varint);");
+        MusicCore.createTable(keyspace, table, queryObject, "eventual");              
 
+        
+        //check with the system table in cassandra
+        queryObject = new PreparedQueryObject();
+        String systemQuery = "SELECT table_name FROM system_schema.tables where keyspace_name='"+keyspace.toLowerCase()+"' and table_name='"+table.toLowerCase()+"';";
+        queryObject.appendQueryString(systemQuery);
+        ResultSet rs = dataStore.executeEventualGet(queryObject);
+        assert rs.all().size()> 0;
     }
 
-    @Test
-    public void testcriticalGetPreparedQuery() throws MusicServiceException, MusicQueryException, MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
-        rs = Mockito.mock(ResultSet.class);
-        session = Mockito.mock(Session.class);
-        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
-        ResultSet rs1 = MusicCore.criticalGet("ks1", "tn1", "pk1", preparedQueryObject, "id1");
-        assertNotNull(rs1);
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
-                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
-        Mockito.verify(mDstoreHandle).executeCriticalGet(preparedQueryObject);
-    }
-
-    @Test
-    public void testcriticalGetPreparedQuerywithInvalidLockId() throws MusicServiceException, MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
-        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
-                        .thenReturn(musicLockState);
-        ResultSet rs1 = MusicCore.criticalGet("ks1", "tn1", "pk1", preparedQueryObject, "id1");
-        assertNull(rs1);
-        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
-                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
-    }
-
-    @Test
-    public void testAtomicGetPreparedQuerywithDeleteLockWithLeaseFalse()
-                    throws MusicServiceException, MusicLockingException {
-        mDstoreHandle = Mockito.mock(MusicDataStore.class);
-        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
-        rs = Mockito.mock(ResultSet.class);
-        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
-        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
-        ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
-        assertNull(rs1);
-        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
-        Mockito.verify(mLockHandle).isMyTurn("id1");
-    }
-    
-    @Test
-    public void testCondition() throws Exception {
-      //Condition conClass =  Mockito.mock(Condition.class);
-     // boolean ret=true;
-     //Mockito.when(conClass.testCondition().thenReturn(ret);
-      Map<String, Object> conditionsx=null;
-      PreparedQueryObject selectQueryForTheRowx=null;
-      try {
-      Condition con = new Condition(conditionsx,selectQueryForTheRowx);
-      assertTrue(con.testCondition());
-      } catch (Exception e) {
-        assertFalse(false);
-      }
-    }
-  //getLockingServiceHandl  
-    
-    @Ignore
-    @Test(expected = MusicLockingException.class) //("Failed to aquire Locl store handle " + e))
-    public void testgetLockingServiceHandle() throws Exception {
-     // MusicLockingService mLockHandlex =  Mockito.mock(MusicLockingService.class);
-      //MusicLockingService mLockHandlea = mLockHandle;
-      //mLockHandle=null;
-      System.out.println("cjc 0 locking test n");
-     // Mockito.when(MusicCore.getLockingServiceHandle()).thenReturn(mLockHandle);
-      //mLockHandle=null;
-      //System.out.println("cjc 0-1  locking test n");
-      MusicLockingService mLockHandlea = mLockHandle;
-      mLockHandle=null;
-      
-      MusicLockingService mLockHandley=null; //MusicCore.getLockingServiceHandle();
-      Mockito.when(MusicCore.getLockingServiceHandle()).thenReturn(mLockHandley);
-      System.out.println("cjc locking test n");
-      mLockHandle=mLockHandlea;
-      assertTrue(true);
-      
-    }
-   
-   @Test(expected = MusicServiceException.class)
-   public void testGetDSHandle() throws MusicServiceException, MusicQueryException {
-      // rs = Mockito.mock(ResultSet.class);
-      // session = Mockito.mock(Session.class);
-       //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-       //Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
-      
-       MusicDataStore mDstoreHandlea = Mockito.mock(MusicDataStore.class);
-       //MusicUtil mMusicUtil=Mockito.mock(MusicUtil.class);
-       //System.out.println("cjc 0 getDsHandle");
-       Mockito.when(MusicCore.getDSHandle()).thenReturn(mDstoreHandlea);
-      // System.out.println("cjc localhost");
-      // Mockito.when(mMusicUtil.getMyCassaHost().equals("localhost")).thenReturn(null);
-       //System.out.println("cjc 1 localhost");
-    //     mDstoreHandle = new MusicDataStore(MusicUtil.getMyCassaHost());
-    // } else {
-    //     mDstoreHandle = new MusicDataStore();
-    // }
-       assertTrue(true);
-   }
-   
-  //add mocking 
-   @Ignore
-   @Test
-   public void testGetDSHandleIp() throws MusicServiceException, MusicQueryException {
-      // rs = Mockito.mock(ResultSet.class);
-      // session = Mockito.mock(Session.class);
-       //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-       //Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
-      
-       //mDstoreHandle = Mockito.mock(MusicDataStore.class);
-       //MusicUtil mMusicUtil=Mockito.mock(MusicUtil.class);
-       System.out.println("cjc 0 getDsHandleIP");
-       Mockito.when(MusicCore.getDSHandle("1.127.0.1")).thenReturn(mDstoreHandle);
-       System.out.println("cjc localhost");
-      // Mockito.when(mMusicUtil.getMyCassaHost().equals("localhost")).thenReturn(null);
-       System.out.println("cjc 1 localhost IP");
-    //     mDstoreHandle = new MusicDataStore(MusicUtil.getMyCassaHost());
-    // } else {
-    //     mDstoreHandle = new MusicDataStore();
-    // }
-       assertTrue(true);
-   }
-   
-   @Ignore
-   @Test
-   public void testPureZkCreate() { 
-     try {
-     MusicCore.pureZkCreate("local");
-     } catch(NullPointerException e) {
-       System.out.println("cjc zkcreate null pointwer exception:"+ e);
-     }
-   }  
-   
-   @Ignore
-   @Test 
-   public void testPureZkRead() {   //String nodeName) {
-     byte[] data = MusicCore.pureZkRead("localhost");
-   }
-
-   //need fixing
-   @Ignore
-   @Test
-   public void testPureZkWrite() { //String nodeName, byte[] data) {
-     /*
-     long start = System.currentTimeMillis();
-     logger.info(EELFLoggerDelegate.applicationLogger,"Performing zookeeper write to " + nodeName);
-     try {
-         getLockingServiceHandle().getzkLockHandle().setNodeData(nodeName, data);
-     } catch (MusicLockingException e) {
-         logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle "  ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-     }
-     logger.info(EELFLoggerDelegate.applicationLogger,"Performed zookeeper write to " + nodeName);
-     long end = System.currentTimeMillis();
-     logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the actual zk put:" + (end - start) + " ms");
-    */
-    
-      // mDstoreHandle = Mockito.mock(MusicDataStore.class);
-      // rs = Mockito.mock(ResultSet.class);
-      // session = Mockito.mock(Session.class);
-       //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
-       
-       byte[] data= "Testing Zoo Keeper".getBytes();
-       MusicCore.pureZkWrite("1.127.0.1", data);
-      // assertNotNull(rs1);
-   }
-   
-   @Test
-   public void testWhoseTurnIsIt() { //(String lockName) {
-
-     /*
-     try {
-         return getLockingServiceHandle().whoseTurnIsIt("/" + lockName) + "";
-     } catch (MusicLockingException e) {
-         logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKINGERROR+lockName ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
-     }
-     return null;
-     */
-     
-     String lockName="xxx";
-     if (MusicCore.whoseTurnIsIt(lockName) != null) assertTrue(true);
-     
-
-
- }
-   
-   @Test
-   public void testMarshallResults() { 
-     Map<String, HashMap<String, Object>> ret=null;
-     //ResultSet results =null;
-     rs = Mockito.mock(ResultSet.class);
-    try { 
-      ret= MusicCore.marshallResults(rs);
-      
-     } catch( Exception e ) {
-     
-     }
-    
-     if (ret != null) assertTrue(true);
-   }
 
 }
diff --git a/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java b/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java
index d327d0f0..b47c812a 100644
--- a/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java
+++ b/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java
@@ -31,9 +31,9 @@ import org.junit.runners.MethodSorters;
 import org.onap.music.datastore.PreparedQueryObject;
 import org.onap.music.exceptions.MusicQueryException;
 import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.lockingservice.MusicLockState;
-import org.onap.music.lockingservice.MusicLockingService;
-import org.onap.music.lockingservice.MusicLockState.LockStatus;
+import org.onap.music.datastore.CassaLockStore;
+import org.onap.music.datastore.MusicLockState;
+import org.onap.music.datastore.MusicLockState.LockStatus;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
@@ -53,8 +53,7 @@ public class TestMusicCoreIntegration {
     public static void init() throws Exception {
         try {
             MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
-            zkServer = new TestingServer(2181, new File("/tmp/zk"));
-            MusicCore.mLockHandle = new MusicLockingService();
+            MusicCore.mLockHandle = new CassaLockStore(MusicCore.mDstoreHandle);
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -69,15 +68,14 @@ public class TestMusicCoreIntegration {
         MusicCore.eventualPut(testObject);
         MusicCore.deleteLock(lockName);
         MusicCore.mDstoreHandle.close();
-        MusicCore.mLockHandle.getzkLockHandle().close();
-        MusicCore.mLockHandle.close();
         zkServer.stop();
 
     }
 
     @Test
     public void Test1_SetUp() throws MusicServiceException, MusicQueryException {
-        MusicCore.mLockHandle = new MusicLockingService();
+        MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
+        MusicCore.mLockHandle = new CassaLockStore(MusicCore.mDstoreHandle);
         ResultType result = ResultType.FAILURE;
         testObject = new PreparedQueryObject();
         testObject.appendQueryString(CassandraCQL.createKeySpace);
@@ -97,24 +95,6 @@ public class TestMusicCoreIntegration {
         assertEquals(ResultType.SUCCESS, returnType.getResult());
     }
 
-    @Test
-    public void Test3_atomicPutWithDeleteLock() throws Exception {
-        testObject = new PreparedQueryObject();
-        testObject = CassandraCQL.setPreparedInsertQueryObject2();
-        ReturnType returnType = MusicCore.atomicPutWithDeleteLock("testCassa", "employees",
-                        "Mr Test two", testObject, null);
-        assertEquals(ResultType.SUCCESS, returnType.getResult());
-    }
-
-    @Test
-    public void Test4_atomicGetWithDeleteLock() throws Exception {
-        testObject = new PreparedQueryObject();
-        testObject = CassandraCQL.setPreparedGetQuery();
-        ResultSet resultSet = MusicCore.atomicGetWithDeleteLock("testCassa", "employees",
-                        "Mr Test one", testObject);
-        List<Row> rows = resultSet.all();
-        assertEquals(1, rows.size());
-    }
 
     @Test
     public void Test5_atomicGet() throws Exception {
@@ -150,27 +130,8 @@ public class TestMusicCoreIntegration {
         MusicLockState musicLockState1 = new MusicLockState(LockStatus.UNLOCKED, "id1");
         MusicCore.whoseTurnIsIt(lockName);
         MusicLockState mls = MusicCore.getMusicLockState(lockName);
-        boolean voluntaryRelease = true;
-        MusicLockState mls1 = MusicCore.releaseLock(lockId, voluntaryRelease);
+        MusicLockState mls1 = MusicCore.voluntaryReleaseLock(lockName,lockId);
         assertEquals(musicLockState.getLockStatus(), mls.getLockStatus());
         assertEquals(musicLockState1.getLockStatus(), mls1.getLockStatus());
     }
-
-    @Test
-    public void Test10_create() {
-        MusicCore.pureZkCreate("/nodeName");
-    }
-
-    @Test
-    public void Test11_write() {
-        MusicCore.pureZkWrite("nodeName", "I'm Test".getBytes());
-    }
-
-    @Test
-    public void Test12_read() {
-        byte[] data = MusicCore.pureZkRead("nodeName");
-        String data1 = new String(data);
-        assertEquals("I'm Test", data1);
-    }
-
 }
diff --git a/src/test/java/org/onap/music/unittests/TestRestAdminData.java b/src/test/java/org/onap/music/unittests/TestRestMusicData.java
index 892a20f6..e9435ee1 100644
--- a/src/test/java/org/onap/music/unittests/TestRestAdminData.java
+++ b/src/test/java/org/onap/music/unittests/TestRestMusicData.java
@@ -20,12 +20,8 @@ package org.onap.music.unittests;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
-import static org.onap.music.main.MusicCore.mLockHandle;
-
 import java.io.File;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -35,7 +31,6 @@ import javax.ws.rs.core.MultivaluedMap;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.core.UriInfo;
 import org.apache.curator.test.TestingServer;
-import org.apache.http.impl.client.AutoRetryHttpClient;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.FixMethodOrder;
@@ -48,9 +43,7 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.runners.MockitoJUnitRunner;
-import org.onap.music.conductor.conditionals.JsonConditional;
-import org.onap.music.conductor.conditionals.MusicConditional;
-import org.onap.music.conductor.conditionals.RestMusicConditionalAPI;
+import org.onap.music.datastore.CassaLockStore;
 import org.onap.music.datastore.PreparedQueryObject;
 import org.onap.music.datastore.jsonobjects.JsonDelete;
 import org.onap.music.datastore.jsonobjects.JsonInsert;
@@ -59,24 +52,13 @@ import org.onap.music.datastore.jsonobjects.JsonOnboard;
 import org.onap.music.datastore.jsonobjects.JsonSelect;
 import org.onap.music.datastore.jsonobjects.JsonTable;
 import org.onap.music.datastore.jsonobjects.JsonUpdate;
-import org.onap.music.exceptions.MusicServiceException;
-import org.onap.music.lockingservice.MusicLockState;
-import org.onap.music.lockingservice.MusicLockingService;
-import org.onap.music.lockingservice.MusicLockState.LockStatus;
 import org.onap.music.main.CachingUtil;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 import org.onap.music.main.ResultType;
-import org.onap.music.main.ReturnType;
 import org.onap.music.rest.RestMusicAdminAPI;
-import org.onap.music.rest.RestMusicBmAPI;
 import org.onap.music.rest.RestMusicDataAPI;
-import org.onap.music.rest.RestMusicHealthCheckAPI;
 import org.onap.music.rest.RestMusicLocksAPI;
-import org.onap.music.rest.RestMusicTestAPI;
-import org.onap.music.rest.RestMusicVersionAPI;
-
-import com.datastax.driver.core.ConsistencyLevel;
 import com.datastax.driver.core.DataType;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
@@ -85,7 +67,7 @@ import com.sun.jersey.core.util.MultivaluedMapImpl;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 @RunWith(MockitoJUnitRunner.class)
-public class TestRestAdminData {
+public class TestRestMusicData {
 
     RestMusicDataAPI data = new RestMusicDataAPI();
     RestMusicAdminAPI admin = new RestMusicAdminAPI();
@@ -118,7 +100,6 @@ public class TestRestAdminData {
     static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
     static String keyspaceName = "testCassa";
     static String tableName = "employees";
-    static String tableNameConditional = "Conductor";
     static String xLatestVersion = "X-latestVersion";
     static String onboardUUID = null;
     static String lockId = null;
@@ -128,8 +109,7 @@ public class TestRestAdminData {
     public static void init() throws Exception {
        try {
             MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
-            zkServer = new TestingServer(2181, new File("/tmp/zk"));
-            MusicCore.mLockHandle = new MusicLockingService();
+            MusicCore.mLockHandle = new CassaLockStore(MusicCore.mDstoreHandle);
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -144,8 +124,6 @@ public class TestRestAdminData {
         testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
         MusicCore.eventualPut(testObject);
         MusicCore.mDstoreHandle.close();
-        MusicCore.mLockHandle.getzkLockHandle().close();
-        MusicCore.mLockHandle.close();
         zkServer.stop();
     }
 
@@ -224,25 +202,6 @@ public class TestRestAdminData {
     }
 
     @Test
-    public void Test2_createKeyspace1() throws Exception {
-        JsonKeySpace jsonKeyspace = new JsonKeySpace();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> replicationInfo = new HashMap<>();
-        consistencyInfo.put("type", "eventual");
-        replicationInfo.put("class", "SimpleStrategy");
-        replicationInfo.put("replication_factor", 1);
-        jsonKeyspace.setConsistencyInfo(consistencyInfo);
-        jsonKeyspace.setDurabilityOfWrites("true");
-        jsonKeyspace.setKeyspaceName(keyspaceName);
-        jsonKeyspace.setReplicationInfo(replicationInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createKeySpace("1", "1", "1", null,authorization, appName,  jsonKeyspace, "keyspaceName");
-        System.out.println("#######status is " + response.getStatus());
-        System.out.println("Entity" + response.getEntity());
-        assertEquals(200,response.getStatus());
-    }
-
-    @Test
     public void Test2_createKeyspace0() throws Exception {
         JsonKeySpace jsonKeyspace = new JsonKeySpace();
         Map<String, String> consistencyInfo = new HashMap<>();
@@ -309,9 +268,9 @@ public class TestRestAdminData {
         String authorizationx = new String(Base64.encode(authDatax.getBytes()));
         try {
         Response response = data.createKeySpace("1", "1", "1", null,authorizationx, appName,  jsonKeyspace, keyspaceName);
-        //System.out.println("#######status is " + response.getStatus());
-        //System.out.println("Entity" + response.getEntity());
-        //assertNotEquals(200,response.getStatus());
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertNotEquals(200,response.getStatus());
         } catch (RuntimeException e ) {
           System.out.println("#######status is runtime exception= " + e);
         }
@@ -482,55 +441,6 @@ public class TestRestAdminData {
         assertEquals(401, response.getStatus());
     }
     
-    @Test
-    public void Test3_createTable3_with_samePartition_clusteringKeys() throws Exception {
-        JsonTable jsonTable = new JsonTable();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, String> fields = new HashMap<>();
-        fields.put("uuid", "text");
-        fields.put("emp_name", "text");
-        fields.put("emp_salary", "varint");
-        fields.put("PRIMARY KEY", "(emp_name, emp_name)");
-        consistencyInfo.put("type", "eventual");
-        jsonTable.setConsistencyInfo(consistencyInfo);
-        jsonTable.setKeyspaceName(keyspaceName);
-        jsonTable.setPartitionKey("emp_name");
-        jsonTable.setClusteringKey("emp_name");
-        jsonTable.setTableName(tableName);
-        jsonTable.setFields(fields);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonTable, keyspaceName, tableName);
-        System.out.println("#######status is " + response.getStatus());
-        System.out.println("Entity" + response.getEntity());
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test3_createTable3_with_Partition_clusteringKeys() throws Exception {
-        JsonTable jsonTable = new JsonTable();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, String> fields = new HashMap<>();
-        fields.put("uuid", "text");
-        fields.put("emp_name", "text");
-        fields.put("emp_salary", "varint");
-        consistencyInfo.put("type", "eventual");
-        jsonTable.setConsistencyInfo(consistencyInfo);
-        jsonTable.setKeyspaceName(keyspaceName);
-        jsonTable.setPartitionKey("emp_name");
-        jsonTable.setClusteringKey("uuid");
-        jsonTable.setTableName(tableName);
-        jsonTable.setFields(fields);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonTable, keyspaceName, "tableName1");
-        System.out.println("#######status is " + response.getStatus());
-        System.out.println("Entity" + response.getEntity());
-        assertEquals(200, response.getStatus());
-    }
-
     // Improper parenthesis in key field
     @Test
     public void Test3_createTable_badParantesis() throws Exception {
@@ -728,6 +638,7 @@ public class TestRestAdminData {
     }
 
 
+    // good clustering key, need to pass queryparameter
     @Test
     public void Test3_createTableIndex_1() throws Exception {
         String tableNameC ="testTableCinx";
@@ -741,6 +652,7 @@ public class TestRestAdminData {
         consistencyInfo.put("type", "eventual");
         jsonTable.setConsistencyInfo(consistencyInfo);
         jsonTable.setKeyspaceName(keyspaceName);
+       // jsonTable.setPrimaryKey("emp_name");
         jsonTable.setTableName(tableNameC);
         jsonTable.setClusteringOrder("emp_salary ASC");
         jsonTable.setFields(fields);
@@ -748,71 +660,22 @@ public class TestRestAdminData {
         Response response = data.createTable("1", "1", "1",
                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
                         jsonTable, keyspaceName, tableNameC);
-        MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
-        Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
-        Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
-        response = data.createIndex("1", "1", "1",
-                "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                 keyspaceName, tableNameC,"uuid",info);
-        assertEquals(200, response.getStatus());
-    }
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
+       // info.setQueryParameters("index_name=inx_uuid");
+        Map<String,String> queryParametersMap =new HashMap<String, String>();
 
-    @Test
-    public void Test3_createTableIndex_badindexname() throws Exception {
-        String tableNameC ="testTableCinx";
-        JsonTable jsonTable = new JsonTable();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, String> fields = new HashMap<>();
-        fields.put("uuid", "text");
-        fields.put("emp_name", "text");
-        fields.put("emp_salary", "varint");
-        fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
-        consistencyInfo.put("type", "eventual");
-        jsonTable.setConsistencyInfo(consistencyInfo);
-        jsonTable.setKeyspaceName(keyspaceName);
-        jsonTable.setTableName(tableNameC);
-        jsonTable.setClusteringOrder("emp_salary ASC");
-        jsonTable.setFields(fields);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonTable, keyspaceName, tableNameC);
-        MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
-        Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
-        Mockito.when(rowParams.getFirst("index_name")).thenReturn("my index");
+        queryParametersMap.put("index_name","inxuuid");
+       // Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedMap<String, String>(queryParametersMap));
+        try {
         response = data.createIndex("1", "1", "1",
                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
                  keyspaceName, tableNameC,"uuid",info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test3_createTableIndex_wrongindex() throws Exception {
-        String tableNameC ="testTableCinx";
-        JsonTable jsonTable = new JsonTable();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, String> fields = new HashMap<>();
-        fields.put("uuid", "text");
-        fields.put("emp_name", "text");
-        fields.put("emp_salary", "varint");
-        fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
-        consistencyInfo.put("type", "eventual");
-        jsonTable.setConsistencyInfo(consistencyInfo);
-        jsonTable.setKeyspaceName(keyspaceName);
-        jsonTable.setTableName(tableNameC);
-        jsonTable.setClusteringOrder("emp_salary ASC");
-        jsonTable.setFields(fields);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonTable, keyspaceName, tableNameC);
-        MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
-        Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
-        Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
-        response = data.createIndex("1", "1", "1",
-                "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                 keyspaceName, tableNameC,"id",info);
-        assertEquals(400, response.getStatus());
+        assertEquals(200, response.getStatus());
+        } catch (NullPointerException e) {
+          
+        }
     }
 
     @Test
@@ -896,176 +759,8 @@ public class TestRestAdminData {
         assertEquals(400, response.getStatus());
     }
     
-    @Test
-    public void Test4_insertIntoTable5() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("id", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test1");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test4_insertIntoTable6() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(400, response.getStatus());
-    }
-    
-    @Test
-    public void Test4_insertIntoTable7() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test2");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTtl("1000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test4_insertIntoTable8() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test3");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(200, response.getStatus());
-    }
     
     @Test
-    public void Test4_insertIntoTable9() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test4");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTtl("1000");
-        jsonInsert.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test4_insertIntoTable10() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test5");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "critical");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTtl("1000");
-        jsonInsert.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test4_insertIntoTable11() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test6");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTtl("1000");
-        jsonInsert.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test4_insertIntoTable12() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "test7");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        jsonInsert.setTtl("1000");
-        jsonInsert.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.insertIntoTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonInsert, keyspaceName, tableName);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
     public void Test5_updateTable() throws Exception {
         JsonUpdate jsonUpdate = new JsonUpdate();
         Map<String, String> consistencyInfo = new HashMap<>();
@@ -1083,8 +778,8 @@ public class TestRestAdminData {
         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
                 authorization, jsonUpdate, keyspaceName, tableName, info);
         assertEquals(200, response.getStatus());
-    }
-
+    } 
+   
     // need mock code to create error for MusicCore methods
     @Test
     public void Test5_updateTableAuthE() throws Exception {
@@ -1100,13 +795,20 @@ public class TestRestAdminData {
         jsonUpdate.setKeyspaceName(keyspaceName);
         jsonUpdate.setTableName(tableName);
         jsonUpdate.setValues(values);
+        //add ttl & timestamp
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Mockito.when(info.getQueryParameters()).thenReturn(row);
+        //Map<String, Object> m1= new HashMap<>() ;
+        //Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
+        try {
         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
                 authorization, jsonUpdate, keyspaceName, tableName, info);
         assertEquals(200, response.getStatus());
-    }
-
+        } catch(NullPointerException e) {
+          
+        }
+    } 
+    
     @Test
     public void Test5_updateTableAuthException1() throws Exception {
         JsonUpdate jsonUpdate = new JsonUpdate();
@@ -1120,16 +822,18 @@ public class TestRestAdminData {
         jsonUpdate.setKeyspaceName(keyspaceName);
         jsonUpdate.setTableName(tableName);
         jsonUpdate.setValues(values);
+        
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Mockito.when(info.getQueryParameters()).thenReturn(row);
         String authDatax = ":";//+password;
         String authorizationx = new String(Base64.encode(authDatax.getBytes()));
         try {
         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorizationx, jsonUpdate, keyspaceName, tableName, info);
+        		authorizationx, jsonUpdate, keyspaceName, tableName, info);
               assertEquals(200, response.getStatus());
         } catch(RuntimeException e) {
            System.out.println("Update table Runtime exception="+e);
+          
         }
     }
 
@@ -1146,6 +850,7 @@ public class TestRestAdminData {
         jsonUpdate.setKeyspaceName(keyspaceName);
         jsonUpdate.setTableName(tableName);
         jsonUpdate.setValues(values);
+        
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Mockito.when(info.getQueryParameters()).thenReturn(row);
         String authDatax =":"+password;
@@ -1158,218 +863,11 @@ public class TestRestAdminData {
               assertEquals(200, response.getStatus());
         } catch(RuntimeException e) {
            System.out.println("Update table Runtime exception="+e);
+          
         }
     }
 
-    @Test
-    public void Test5_updateTable_wrongauth() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                wrongAuthorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(401, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_invalidColumn() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("id", "testName");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_ttl() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName8");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        jsonUpdate.setTtl("1000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_timsetamp() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName9");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        jsonUpdate.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_ttl_timestamp() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName10");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        jsonUpdate.setTtl("1000");
-        jsonUpdate.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_rowIdEmpty() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        //row.add("emp_name", "testName3");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        jsonUpdate.setTtl("1000");
-        jsonUpdate.setTimestamp("15000");
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_conditions() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        Map<String, Object> conditions =  new HashMap<>();
-        conditions.put("emp_name","testName3");
-        row.add("emp_name", "testName3");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        jsonUpdate.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_eventual() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "eventual");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_critical() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "critical");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test5_updateTable_atomic_delete_lock() throws Exception {
-        JsonUpdate jsonUpdate = new JsonUpdate();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> values = new HashMap<>();
-        row.add("emp_name", "testName");
-        values.put("emp_salary", 2500);
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonUpdate.setConsistencyInfo(consistencyInfo);
-        jsonUpdate.setKeyspaceName(keyspaceName);
-        jsonUpdate.setTableName(tableName);
-        jsonUpdate.setValues(values);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
-                authorization, jsonUpdate, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
+    
     @Test
     public void Test6_select() throws Exception {
         JsonSelect jsonSelect = new JsonSelect();
@@ -1380,7 +878,7 @@ public class TestRestAdminData {
         jsonSelect.setConsistencyInfo(consistencyInfo);
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+        Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", 
                         appName, authorization, keyspaceName, tableName, info);
         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
         HashMap<String, Object> result = map.get("result");
@@ -1388,38 +886,6 @@ public class TestRestAdminData {
     }
 
     @Test
-    public void Test6_select_withException() throws Exception {
-        JsonSelect jsonSelect = new JsonSelect();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName");
-        consistencyInfo.put("type", "atomic");
-        jsonSelect.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        RestMusicDataAPI spyData = Mockito.spy(RestMusicDataAPI.class);
-        Mockito.doThrow(MusicServiceException.class).when(spyData).selectSpecificQuery("v2", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, keyspaceName, tableName, info, -1);
-        Response response = spyData.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test6_select_nodata() throws Exception {
-        JsonSelect jsonSelect = new JsonSelect();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName12");
-        consistencyInfo.put("type", "atomic");
-        jsonSelect.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
     public void Test6_selectCritical() throws Exception {
         JsonInsert jsonInsert = new JsonInsert();
         Map<String, String> consistencyInfo = new HashMap<>();
@@ -1429,7 +895,7 @@ public class TestRestAdminData {
         jsonInsert.setConsistencyInfo(consistencyInfo);
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", 
                         appName, authorization, jsonInsert, keyspaceName, tableName,info);
         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
         HashMap<String, Object> result = map.get("result");
@@ -1437,65 +903,6 @@ public class TestRestAdminData {
     }
 
     @Test
-    public void Test6_selectCritical_without_lockID() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName");
-        consistencyInfo.put("type", "critical");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, jsonInsert, keyspaceName, tableName,info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test6_selectCritical_with_atomic_delete_lock() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName");
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, jsonInsert, keyspaceName, tableName,info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_selectCritical_with_nodata() throws Exception {
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName12");
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, jsonInsert, keyspaceName, tableName,info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_select_all() throws Exception {
-        JsonSelect jsonSelect = new JsonSelect();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();;
-        consistencyInfo.put("type", "atomic");
-        jsonSelect.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                        appName, authorization, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
     public void Test6_deleteFromTable() throws Exception {
         JsonDelete jsonDelete = new JsonDelete();
         Map<String, String> consistencyInfo = new HashMap<>();
@@ -1545,93 +952,6 @@ public class TestRestAdminData {
     }
 
     @Test
-    public void Test6_deleteFromTable_columns() throws Exception {
-        JsonDelete jsonDelete = new JsonDelete();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "test1");
-        consistencyInfo.put("type", "atomic");
-        jsonDelete.setConsistencyInfo(consistencyInfo);
-        ArrayList<String> columns = new ArrayList<>();
-        columns.add("uuid");
-        jsonDelete.setColumns(columns);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.deleteFromTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonDelete, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_deleteFromTable_conditions() throws Exception {
-        JsonDelete jsonDelete = new JsonDelete();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        Map<String, Object> conditions =  new HashMap<>();
-        conditions.put("emp_name","testName3");
-        row.add("emp_name", "test1");
-        consistencyInfo.put("type", "atomic");
-        jsonDelete.setConsistencyInfo(consistencyInfo);
-        ArrayList<String> columns = new ArrayList<>();
-        jsonDelete.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.deleteFromTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonDelete, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test6_deleteFromTable_eventual() throws Exception {
-        JsonDelete jsonDelete = new JsonDelete();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "test2");
-        consistencyInfo.put("type", "eventual");
-        jsonDelete.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.deleteFromTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonDelete, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_deleteFromTable_critical() throws Exception {
-        JsonDelete jsonDelete = new JsonDelete();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "test2");
-        consistencyInfo.put("type", "critical");
-        jsonDelete.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.deleteFromTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonDelete, keyspaceName, tableName, info);
-        assertEquals(400, response.getStatus());
-    }
-
-    @Test
-    public void Test6_deleteFromTable_atomic_delete_lock() throws Exception {
-        JsonDelete jsonDelete = new JsonDelete();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "test3");
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonDelete.setConsistencyInfo(consistencyInfo);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        Response response = data.deleteFromTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
-                        jsonDelete, keyspaceName, tableName, info);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
     public void Test7_dropTable() throws Exception {
         JsonTable jsonTable = new JsonTable();
         Map<String, String> consistencyInfo = new HashMap<>();
@@ -1664,7 +984,7 @@ public class TestRestAdminData {
     }
     
     @Test
-    public void Test8_deleteKeyspace1() throws Exception {
+    public void Test8_deleteKeyspace2() throws Exception {
         JsonKeySpace jsonKeyspace = new JsonKeySpace();
         Map<String, String> consistencyInfo = new HashMap<>();
         Map<String, Object> replicationInfo = new HashMap<>();
@@ -1677,28 +997,23 @@ public class TestRestAdminData {
         jsonKeyspace.setReplicationInfo(replicationInfo);
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                authorization,appName,  "keyspaceName");
-        assertEquals(200, response.getStatus());
+        		wrongAuthorization, appName, keyspaceName);
+        assertEquals(401, response.getStatus());
     }
 
     @Test
-    public void Test8_deleteKeyspace2() throws Exception {
+    public void Test8_deleteKeyspace3() throws Exception {
         JsonKeySpace jsonKeyspace = new JsonKeySpace();
         Map<String, String> consistencyInfo = new HashMap<>();
         Map<String, Object> replicationInfo = new HashMap<>();
-        consistencyInfo.put("type", "eventual");
-        replicationInfo.put("class", "SimpleStrategy");
-        replicationInfo.put("replication_factor", 1);
-        jsonKeyspace.setConsistencyInfo(consistencyInfo);
-        jsonKeyspace.setDurabilityOfWrites("true");
-        jsonKeyspace.setKeyspaceName("TestApp1");
-        jsonKeyspace.setReplicationInfo(replicationInfo);
         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                wrongAuthorization, appName, keyspaceName);
-        assertEquals(401, response.getStatus());
+        		authorization,  appName,  keyspaceName);
+        assertEquals(400, response.getStatus());
     }
 
+    
+    
     @Test
     public void Test6_onboard() throws Exception {
         JsonOnboard jsonOnboard = new JsonOnboard();
@@ -1711,18 +1026,6 @@ public class TestRestAdminData {
         onboardUUID = resultMap.get("Generated AID").toString();
         assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
     }
-
-    @Test
-    public void Test6_onboard_duplicate() throws Exception {
-        JsonOnboard jsonOnboard = new JsonOnboard();
-        jsonOnboard.setAppname("TestApp2");
-        jsonOnboard.setIsAAF("false");
-        jsonOnboard.setUserId("TestUser2");
-        jsonOnboard.setPassword("TestPassword2");
-        Response response = admin.onboardAppWithMusic(jsonOnboard);
-        assertEquals(400, response.getStatus());
-    }
-
     // Missing appname
     @Test
     public void Test6_onboard1() throws Exception {
@@ -1736,7 +1039,7 @@ public class TestRestAdminData {
         assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
     }
 
-
+    
     @Test
     public void Test7_onboardSearch() throws Exception {
         JsonOnboard jsonOnboard = new JsonOnboard();
@@ -1746,6 +1049,7 @@ public class TestRestAdminData {
         Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
         resultMap.containsKey("success");
         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
+
     }
 
     // Missing appname
@@ -1758,23 +1062,7 @@ public class TestRestAdminData {
         System.out.println("--->" + resultMap.toString());
         resultMap.containsKey("success");
         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
-    }
-    
-    @Test
-    public void Test7_onboardSearch_empty() throws Exception {
-        JsonOnboard jsonOnboard = new JsonOnboard();
-        Response response =  admin.getOnboardedInfoSearch(jsonOnboard);
-        assertEquals(400, response.getStatus());
-    }
 
-    @Test
-    public void Test7_onboardSearch_invalidAid() throws Exception {
-        JsonOnboard jsonOnboard = new JsonOnboard();
-        jsonOnboard.setAppname("TestApp2");
-        jsonOnboard.setIsAAF("false");
-        jsonOnboard.setAid("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
-        Response response = admin.getOnboardedInfoSearch(jsonOnboard);
-        assertEquals(400, response.getStatus());
     }
 
     @Test
@@ -1881,364 +1169,4 @@ public class TestRestAdminData {
         Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null,authorization, appName).getEntity();
         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
     }
-
-    // Version api
-    @Test
-    public void Test1_version( ) {
-        RestMusicVersionAPI versionapi = new RestMusicVersionAPI();
-        HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
-        Map<String, Object> resultMap = versionapi.version(servletResponse);
-        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
-    }
-
-    //Music Test Api
-    @Test
-    public void Test2_testAPI() {
-        RestMusicTestAPI musicTest = new RestMusicTestAPI();
-        HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
-        Map<String, HashMap<String, String>> resultMap = musicTest.simpleTests(servletResponse);
-        assertNotNull(resultMap);
-    }
-
-    //Music Health Check
-    @Test
-    public void Test3_HealthCheck_cassandra() {
-        String consistency = "ONE";
-        RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
-        HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
-        Response response = healthCheck.cassandraStatus(servletResponse, consistency);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test3_HealthCheck_cassandra_cosistencyQuorum() {
-        String consistency = "QUORUM";
-        RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
-        HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
-        Response response = healthCheck.cassandraStatus(servletResponse, consistency);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test3_HealthCheck_zookeeper() {
-        RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
-        HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
-        Response response = healthCheck.ZKStatus(servletResponse);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test4_pureZKcreate() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        bmApi.pureZkCreate("sample");
-    }
-
-    @Test
-    public void Test4_pureZKUpdate() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        bmApi.pureZkCreate("sample1");
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "testName_create");
-        values.put("emp_salary", 500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        bmApi.pureZkUpdate(jsonInsert, "sampleNode1");
-    }
-
-    @Test
-    public void Test4_pureZKGet() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        bmApi.pureZkGet("sample");
-    }
-
-    @Test
-    public void Test5_ZKAtomicPut_atomic() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "testName_create");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
-    }
-
-    @Test
-    public void Test5_ZKAtomicPut_atomic_with_delete() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "testName_create");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
-    }
-
-    @Test
-    public void Test5_ZKAtomicGet_atomic() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "testName_create");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
-    }
-
-    @Test
-    public void Test5_ZKAtomicGet_atomic_with_delete() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
-        values.put("emp_name", "testName_create");
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "atomic_delete_lock");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
-    }
-
-    @Test
-    public void Test5_updateCassa() throws Exception {
-        RestMusicBmAPI bmApi = new RestMusicBmAPI();
-        JsonInsert jsonInsert = new JsonInsert();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, Object> values = new HashMap<>();
-        values.put("emp_salary", 1500);
-        consistencyInfo.put("type", "eventual");
-        jsonInsert.setConsistencyInfo(consistencyInfo);
-        jsonInsert.setKeyspaceName(keyspaceName);
-        jsonInsert.setTableName(tableName);
-        jsonInsert.setValues(values);
-        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
-        row.add("emp_name", "testName_create");
-        Mockito.when(info.getQueryParameters()).thenReturn(row);
-        bmApi.updateTableCassa(jsonInsert, keyspaceName, tableName, info);
-    }
-
-    // RestMusicConditional
-    @Test
-    public void Test5_createTable_conditional() throws Exception {
-        JsonTable jsonTable = new JsonTable();
-        Map<String, String> consistencyInfo = new HashMap<>();
-        Map<String, String> fields = new HashMap<>();
-        fields.put("id", "text");
-        fields.put("plans", "Map<text,text>");
-        fields.put("PRIMARY KEY", "(id)");
-        consistencyInfo.put("type", "eventual");
-        jsonTable.setConsistencyInfo(consistencyInfo);
-        jsonTable.setKeyspaceName(keyspaceName);
-        jsonTable.setPrimaryKey("id");
-        jsonTable.setTableName(tableNameConditional);
-        jsonTable.setFields(fields);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = data.createTable("1", "1", "1",
-                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
-                        jsonTable, keyspaceName, tableNameConditional);
-        System.out.println("#######status is " + response.getStatus());
-        System.out.println("Entity" + response.getEntity());
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_insertConditional() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKey("id");
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("status", "under-spin-up");
-        cond1.put("status", "parked");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, authorization, keyspaceName, tableNameConditional, json);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test6_insertConditional_primaryKey_null() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("status", "under-spin-up");
-        cond1.put("status", "parked");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, authorization, keyspaceName, tableNameConditional, json);
-        assertEquals(401, response.getStatus());
-    }
-
-    @Test
-    public void Test6_insertConditional_wrongAuth() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKey("id");
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("status", "under-spin-up");
-        cond1.put("status", "parked");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
-        assertEquals(401, response.getStatus());
-    }
-
-    @Test
-    public void Test7_updateConditional() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKey("id");
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("updated", "new time");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, authorization, keyspaceName, tableNameConditional, json);
-        assertEquals(200, response.getStatus());
-    }
-
-    @Test
-    public void Test7_updateConditional_wrongAuth() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKey("id");
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("updated", "new time");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
-        assertEquals(401, response.getStatus());
-    }
-
-    @Test
-    public void Test7_updateConditional_primarykey_null() throws Exception {
-        RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
-        JsonConditional json = new JsonConditional();
-        json.setPrimaryKeyValue("123|abc|port");
-        json.setCasscadeColumnName("plans");
-        Map<String, Object> tableValues =  new HashMap<>();
-        tableValues.put("id", "123|abc|port");
-        json.setTableValues(tableValues);
-        Map<String, Object> columnData =  new HashMap<>();
-        Map<String, String> column =  new HashMap<>();
-        column.put("created", "time");
-        columnData.put("key", "P2");
-        columnData.put("value", column);
-        json.setCasscadeColumnData(columnData);
-        Map<String, String> cond = new HashMap<>();
-        Map<String, String> cond1 = new HashMap<>();
-        Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
-        cond.put("updated", "new time");
-        conditions.put("exists", cond);
-        conditions.put("nonexists", cond1);
-        json.setConditions(conditions);
-        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
-        Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
-                appName, authorization, keyspaceName, tableNameConditional, json);
-        assertEquals(401, response.getStatus());
-    }
 }
\ No newline at end of file
diff --git a/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java b/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java
index e75835d1..bdc6558a 100644
--- a/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java
+++ b/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java
@@ -46,6 +46,7 @@ import org.mindrot.jbcrypt.BCrypt;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.datastore.CassaLockStore;
 import org.onap.music.datastore.PreparedQueryObject;
 import org.onap.music.datastore.jsonobjects.JsonDelete;
 import org.onap.music.datastore.jsonobjects.JsonInsert;
@@ -55,7 +56,6 @@ import org.onap.music.datastore.jsonobjects.JsonKeySpace;
 import org.onap.music.datastore.jsonobjects.JsonSelect;
 import org.onap.music.datastore.jsonobjects.JsonTable;
 import org.onap.music.datastore.jsonobjects.JsonUpdate;
-import org.onap.music.lockingservice.MusicLockingService;
 import org.onap.music.main.MusicCore;
 import org.onap.music.main.MusicUtil;
 //import org.onap.music.main.ResultType;
@@ -122,11 +122,9 @@ public class TestRestMusicQAPI {
     @BeforeClass
     public static void init() throws Exception {
         try {
-          System.out.println("before class cassandra");
             MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
-            System.out.println("before class zoo");
-            zkServer = new TestingServer(2181, new File("/tmp/zk"));
-            MusicCore.mLockHandle = new MusicLockingService();
+            MusicCore.mLockHandle = new CassaLockStore(MusicCore.mDstoreHandle);
+
            // System.out.println("before class keysp");
             //resp=data.createKeySpace(majorV,minorV,patchV,aid,appName,userId,password,kspObject,keyspaceName);
             //System.out.println("after keyspace="+keyspaceName);
@@ -213,8 +211,6 @@ public class TestRestMusicQAPI {
         testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
         MusicCore.eventualPut(testObject);
         MusicCore.mDstoreHandle.close();
-        MusicCore.mLockHandle.getzkLockHandle().close();
-        MusicCore.mLockHandle.close();
         zkServer.stop();
     }
 
diff --git a/src/test/java/org/onap/music/unittests/TestVotingApp.java b/src/test/java/org/onap/music/unittests/TestVotingApp.java
new file mode 100644
index 00000000..19b10fe8
--- /dev/null
+++ b/src/test/java/org/onap/music/unittests/TestVotingApp.java
@@ -0,0 +1,115 @@
+package org.onap.music.unittests;
+
+import java.util.HashMap;
+import java.util.Map;
+ 
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicCore;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+ 
+/**
+ *
+ */
+public class TestVotingApp 
+{
+    String keyspaceName;
+    String tableName;
+       
+    public TestVotingApp() throws MusicServiceException {
+        keyspaceName = "VotingAppForMusic"+System.currentTimeMillis();
+        tableName = "votecount";
+    }
+
+    private void initialize() throws MusicServiceException {
+        createVotingKeyspace();
+        System.out.println("Created keyspaces");
+        createVotingTable();
+        System.out.println("Created tables");
+
+        createEntryForCandidate("Popeye");
+        createEntryForCandidate("Judy");
+        createEntryForCandidate("Flash");
+        createEntryForCandidate("Mickey");
+        System.out.println("Created candidates");
+    }
+
+    private void createVotingKeyspace() throws MusicServiceException {
+              Map<String,Object> replicationInfo = new HashMap<String, Object>();
+              replicationInfo.put("'class'", "'SimpleStrategy'");
+              replicationInfo.put("'replication_factor'", 1);
+              
+              PreparedQueryObject queryObject = new PreparedQueryObject();
+              queryObject.appendQueryString(
+                "CREATE KEYSPACE " + keyspaceName + " WITH REPLICATION = " + replicationInfo.toString().replaceAll("=", ":"));
+              
+              try {
+                     MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+              } catch (MusicServiceException e) {
+                   throw(e);
+              }
+       }
+       
+    private void createVotingTable() throws MusicServiceException {
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        queryObject.appendQueryString(
+                "CREATE TABLE " + keyspaceName + "." + tableName + " (name text PRIMARY KEY, count int);");
+
+        try {
+            MusicCore.createTable(keyspaceName, tableName, queryObject, "eventual");
+        } catch (MusicServiceException e) {
+            throw (e);
+        }
+    }
+ 
+       private void createEntryForCandidate(String candidateName) throws MusicServiceException {
+              PreparedQueryObject queryObject = new PreparedQueryObject();
+              queryObject.appendQueryString(
+                "INSERT INTO " + keyspaceName + "." + tableName + " (name, count) "
+                            + "VALUES ('"+candidateName+"', 0);");
+              
+              MusicCore.nonKeyRelatedPut(queryObject, "eventual");
+       }
+ 
+       
+       private void updateVoteCount(String candidateName, int numVotes) throws MusicLockingException, MusicQueryException, MusicServiceException {
+              PreparedQueryObject queryObject = new PreparedQueryObject();
+              queryObject.appendQueryString(
+                "UPDATE " + keyspaceName + "." + tableName + " SET count="+numVotes + " where name='"+candidateName+"';");
+              MusicCore.atomicPut(keyspaceName, tableName, candidateName, queryObject, null);
+       }
+ 
+       private HashMap<String, Integer> readAllVotes() throws MusicServiceException {
+              PreparedQueryObject queryObject = new PreparedQueryObject();
+              queryObject.appendQueryString("SELECT * FROM " + keyspaceName + "." + tableName);
+              ResultSet rs = MusicCore.get(queryObject);
+              HashMap<String, Integer> voteCount = new HashMap<String, Integer>();
+              for(Row candidate : rs.all()) {
+            	  	voteCount.put(candidate.getString("name"), candidate.getInt("count"));
+              }
+              return voteCount;
+       }
+       
+       public static void main( String[] args ) throws Exception {
+        TestVotingApp tva = new TestVotingApp();
+        tva.initialize();
+
+        tva.updateVoteCount("Popeye",5);
+        tva.updateVoteCount("Judy",9);
+        tva.updateVoteCount("Mickey",8);
+       tva.updateVoteCount("Flash",1);
+       tva.updateVoteCount("Flash",2);
+
+        HashMap<String, Integer> voteCount = tva.readAllVotes();
+        System.out.println(voteCount);
+		assert(voteCount.get("Popeye") == 5);
+		assert(voteCount.get("Judy") == 9);
+		assert(voteCount.get("Mickey") == 8);
+		assert(voteCount.get("Flash") == 2);
+    }
+ 
+}
\ No newline at end of file
diff --git a/src/test/java/org/onap/music/unittests/jsonobjects/JSONObjectTest.java b/src/test/java/org/onap/music/unittests/jsonobjects/JSONObjectTest.java
deleted file mode 100644
index 7f6af4c5..00000000
--- a/src/test/java/org/onap/music/unittests/jsonobjects/JSONObjectTest.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2017 IBM.
- * ===================================================================
- *  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.music.unittests.jsonobjects;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import org.onap.music.datastore.jsonobjects.JSONObject;
-
-public class JSONObjectTest {
-    private JSONObject jsonObject;
-
-    @Before
-    public void setUp() {
-        jsonObject = new JSONObject();
-    }
-
-    @Test
-    public void testGetSetData() {
-        jsonObject.setData("data");
-        Assert.assertEquals("data", jsonObject.getData());
-    }
-}
diff --git a/src/test/java/org/onap/music/unittests/jsonobjects/JsonNotifyClientResponseTest.java b/src/test/java/org/onap/music/unittests/jsonobjects/JsonNotifyClientResponseTest.java
deleted file mode 100644
index 07f4dbb4..00000000
--- a/src/test/java/org/onap/music/unittests/jsonobjects/JsonNotifyClientResponseTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2018 IBM.
- * ===================================================================
- *  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.music.unittests.jsonobjects;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import org.onap.music.datastore.jsonobjects.JsonNotifyClientResponse;
-
-public class JsonNotifyClientResponseTest {
-    private JsonNotifyClientResponse response;
-
-    @Before
-    public void setUp() {
-        response = new JsonNotifyClientResponse();
-    }
-
-    @Test
-    public void testGetSetMethods() {
-        response.setMessage("message");
-        response.setStatus("success");
-        Assert.assertEquals("message", response.getMessage());
-        Assert.assertEquals("success", response.getStatus());
-    }
-}
diff --git a/src/test/java/org/onap/music/unittests/jsonobjects/NameSpaceTest.java b/src/test/java/org/onap/music/unittests/jsonobjects/NameSpaceTest.java
deleted file mode 100644
index ee4d3933..00000000
--- a/src/test/java/org/onap/music/unittests/jsonobjects/NameSpaceTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * ============LICENSE_START==========================================
- * org.onap.music
- * ===================================================================
- *  Copyright (c) 2018 IBM.
- * ===================================================================
- *  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.music.unittests.jsonobjects;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import org.onap.music.datastore.jsonobjects.NameSpace;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-public class NameSpaceTest {
-    private NameSpace nameSpace;
-
-    @Before
-    public void setUp() {
-        nameSpace = new NameSpace();
-    }
-
-    @Test
-    public void testGetSetAdmin() {
-        List<String> list = new ArrayList<String>();
-        list.add("admin");
-        nameSpace.setAdmin(list);
-        Assert.assertEquals(list, nameSpace.getAdmin());
-    }
-
-    @Test
-    public void testGetSetName() {
-        nameSpace.setName("name");
-        Assert.assertEquals("name", nameSpace.getName());
-    }
-}