import java.util.Iterator;
import java.util.Map;
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.MusicQueryException;
import org.onap.music.exceptions.MusicServiceException;
import org.onap.music.main.MusicUtil;
-import org.onap.music.main.ResultType;
-
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ColumnDefinitions;
import com.datastax.driver.core.ColumnDefinitions.Definition;
}
}
} catch (SocketException e) {
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.CONNCECTIVITYERROR, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
+ }catch(Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
}
return allPossibleIps;
}
break;
} catch (NoHostAvailableException e) {
address = it.next();
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.HOSTUNAVAILABLE, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
}
}
}
try {
session = cluster.connect();
} catch (Exception ex) {
- logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(),AppMessages.CASSANDRACONNECTIVITY, ErrorSeverity.ERROR, ErrorTypes.SERVICEUNAVAILABLE);
throw new MusicServiceException(
"Error while connecting to Cassandra cluster.. " + ex.getMessage());
}
boolean result = false;
if (!MusicUtil.isValidQueryObject(!queryObject.getValues().isEmpty(), queryObject)) {
- logger.error(EELFLoggerDelegate.errorLogger,
- "Error while processing prepared query object");
+ logger.error(EELFLoggerDelegate.errorLogger, queryObject.getQuery(),AppMessages.QUERYERROR, ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
throw new MusicQueryException("Ill formed queryObject for the request = " + "["
+ queryObject.getQuery() + "]");
}
}
catch (AlreadyExistsException ae) {
- logger.error(EELFLoggerDelegate.errorLogger, "Executing Session Failure for Request = "
- + "[" + queryObject.getQuery() + "]" + " Reason = " + ae.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, ae.getMessage(),AppMessages.SESSIONFAILED+ " [" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
throw new MusicServiceException(ae.getMessage());
}
catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger, "Executing Session Failure for Request = "
- + "[" + queryObject.getQuery() + "]" + " Reason = " + e.getMessage());
- throw new MusicServiceException("Executing Session Failure for Request = " + "["
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.SESSIONFAILED+ " [" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ throw new MusicQueryException("Executing Session Failure for Request = " + "["
+ queryObject.getQuery() + "]" + " Reason = " + e.getMessage());
}
throws MusicServiceException, MusicQueryException {
if (!MusicUtil.isValidQueryObject(!queryObject.getValues().isEmpty(), queryObject)) {
- throw new MusicQueryException("Ill formed queryObject for the request = " + "["
+ logger.error(EELFLoggerDelegate.errorLogger, "",AppMessages.QUERYERROR+ " [" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ throw new MusicQueryException("Ill formed queryObject for the request = " + "["
+ queryObject.getQuery() + "]");
}
logger.info(EELFLoggerDelegate.applicationLogger,
results = session.execute(preparedEventualGet.bind(queryObject.getValues().toArray()));
} catch (Exception ex) {
- logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage());
- throw new MusicServiceException(ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(),AppMessages.UNKNOWNERROR+ "[" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ throw new MusicServiceException(ex.getMessage());
}
return results;
}
public ResultSet executeCriticalGet(PreparedQueryObject queryObject)
throws MusicServiceException, MusicQueryException {
if (!MusicUtil.isValidQueryObject(!queryObject.getValues().isEmpty(), queryObject)) {
- logger.error(EELFLoggerDelegate.errorLogger, "Error processing Prepared Query Object");
- throw new MusicQueryException("Ill formed queryObject for the request = " + "["
+ logger.error(EELFLoggerDelegate.errorLogger, "",AppMessages.QUERYERROR+ " [" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ throw new MusicQueryException("Error processing Prepared Query Object for the request = " + "["
+ queryObject.getQuery() + "]");
}
logger.info(EELFLoggerDelegate.applicationLogger,
try {
results = session.execute(preparedEventualGet.bind(queryObject.getValues().toArray()));
} catch (Exception ex) {
- logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage());
- throw new MusicServiceException(ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(),AppMessages.UNKNOWNERROR+ "[" + queryObject.getQuery() + "]", ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ throw new MusicServiceException(ex.getMessage());
}
return results;
--- /dev/null
+/*
+ * ============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.eelf.logging.format;
+
+/**
+ * @author inam
+ *
+ */
+public enum AppMessages {
+
+
+
+ /*
+ * 100-199 Security/Permission Related - Authentication problems
+ * [ERR100E] Missing Information
+ * [ERR101E] Authentication error occured
+ *
+ * 200-299 Availability/Timeout Related/IO - connectivity error - connection timeout
+ * [ERR200E] Connectivity
+ * [ERR201E] Host not available
+ * [ERR202E] Error while connecting to Cassandra cluster
+ * [ERR203E] IO Error has occured
+ * [ERR204E] Execution Interrupted
+ * [ERR205E] Session Expired
+ * [ERR206E] Cache not authenticated
+ *
+ *
+ * 300-399 Data Access/Integrity Related
+ *
+ * 400-499 - Cassandra Query Related
+ * [ERR400E] Error while processing prepared query object
+ * [ERR401E] Executing Session Failure for Request
+ * [ERR402E] Ill formed queryObject for the request
+ * [ERR403E] Error processing Prepared Query Object
+ *
+ * 500-599 - Zookeepr/Locking Related
+ * [ERR500E] Invalid lock
+ * [ERR501E] Locking Error has occured
+ * [ERR502E] Zookeeper error has occured
+ * [ERR503E] Failed to aquire lock store handle
+ * [ERR504E] Failed to create Lock Reference
+ * [ERR505E] Lock does not exist
+ * [ERR506E] Failed to aquire lock
+ * [ERR507E] Lock not aquired
+ * [ERR508E] Lock state not set
+ * [ERR509E] Lock not destroyed
+ * [ERR510E] Lock not released
+ * [ERR511E] Lock not deleted
+ * [ERR512E] Failed to get ZK Lock Handle
+ *
+ *
+ * 600 - 699 - Music Service Errors
+ * [ERR600E] Error initializing the cache
+ *
+ * 700-799 Schema Interface Type/Validation - received Pay-load checksum is
+ * invalid - received JSON is not valid
+ *
+ * 800-899 Business/Flow Processing Related - check out to service is not
+ * allowed - Roll-back is done - failed to generate heat file
+ *
+ *
+ * 900-999 Unknown Errors - Unexpected exception
+ * [ERR900E] Unexpected error occured
+ * [ERR901E] Number format exception
+ *
+ *
+ * 1000-1099 Reserved - do not use
+ *
+ */
+
+
+
+
+ MISSINGINFO("[ERR100E]", "Missing Information ","Details: NA", "Please check application credentials and headers"),
+ AUTHENTICATIONERROR("[ERR101E]", "Authentication error occured ","Details: NA", "Please verify application credentials"),
+ CONNCECTIVITYERROR("[ERR200E]"," Connectivity error","Details: NA ","Please check connectivity to external resources"),
+ HOSTUNAVAILABLE("[ERR201E]","Host not available","Details: NA","Please verify the host details"),
+ CASSANDRACONNECTIVITY("[ERR202E]","Error while connecting to Cassandra cluster",""," Please check cassandra cluster details"),
+ IOERROR("[ERR203E]","IO Error has occured","","Please check IO"),
+ EXECUTIONINTERRUPTED("[ERR204E]"," Execution Interrupted","",""),
+ SESSIONEXPIRED("[ERR205E]"," Session Expired","","Session has expired."),
+ CACHEAUTHENTICATION("[ERR206E]","Cache not authenticated",""," Cache not authenticated"),
+
+ QUERYERROR("[ERR400E]","Error while processing prepared query object",""," Please verify the query"),
+ SESSIONFAILED("[ERR401E]","Executing Session Failure for Request","","Please verify the session and request"),
+
+ INVALIDLOCK("[ERR500E]"," Invalid lock or acquire failed",""," Lock is not valid to aquire"),
+ LOCKINGERROR("[ERR501E]"," Locking Error has occured",""," Locking Error has occured"),
+ KEEPERERROR("[ERR502E]"," Zookeeper error has occured","","Please check zookeeper details"),
+ LOCKHANDLE("[ERR503E]","Failed to aquire lock store handle",""," Failed to aquire lock store handle"),
+ CREATELOCK("[ERR504E]","Failed to aquire lock store handle ","","Failed to aquire lock store handle "),
+ LOCKSTATE("[ERR508E]"," Lock state not set",""," Lock state not set"),
+ DESTROYLOCK("[ERR509E]"," Lock not destroyed",""," Lock not destroyed"),
+ RELEASELOCK("[ERR510E]"," Lock not released",""," Lock not released"),
+ DELTELOCK("[ERR511E]",""," Lock not deleted "," Lock not deleted "),
+ CACHEERROR("[ERR600E]"," Error initializing the cache",""," Error initializing the cache"),
+
+ UNKNOWNERROR("[ERR900E]"," Unexpected error occured",""," Please check logs for details");
+
+
+
+ ErrorTypes eType;
+ ErrorSeverity alarmSeverity;
+ ErrorSeverity errorSeverity;
+ String errorCode;
+ String errorDescription;
+ String details;
+ String resolution;
+
+
+ AppMessages(String errorCode, String errorDescription, String details,String resolution) {
+
+ this.errorCode = errorCode;
+ this.errorDescription = errorDescription;
+ this.details = details;
+ this.resolution = resolution;
+ }
+
+
+
+
+ AppMessages(ErrorTypes eType, ErrorSeverity alarmSeverity,
+ ErrorSeverity errorSeverity, String errorCode, String errorDescription, String details,
+ String resolution) {
+
+ this.eType = eType;
+ this.alarmSeverity = alarmSeverity;
+ this.errorSeverity = errorSeverity;
+ this.errorCode = errorCode;
+ this.errorDescription = errorDescription;
+ this.details = details;
+ this.resolution = resolution;
+ }
+
+ public String getDetails() {
+ return this.details;
+ }
+
+ public String getResolution() {
+ return this.resolution;
+ }
+
+ public String getErrorCode() {
+ return this.errorCode;
+ }
+
+ public String getErrorDescription() {
+ return this.errorDescription;
+ }
+
+
+
+
+
+
+
+}
--- /dev/null
+/*
+ * ============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.eelf.logging.format;
+
+
+
+/**
+ * @author inam
+ *
+ */
+public enum ErrorCodes {
+
+
+ /*
+ * 100-199 Security/Permission Related - Authentication problems
+ * [ERR100E] Missing Information
+ * [ERR101E] Authentication error occured
+ *
+ * 200-299 Availability/Timeout Related/IO - connectivity error - connection timeout
+ * [ERR200E] Connectivity
+ * [ERR201E] Host not available
+ * [ERR202E] Error while connecting to Cassandra cluster
+ * [ERR203E] IO Error has occured
+ * [ERR204E] Execution Interrupted
+ * [ERR205E] Session Expired
+ * [ERR206E] Cache not authenticated
+ *
+ *
+ * 300-399 Data Access/Integrity Related
+ *
+ * 400-499 - Cassandra Query Related
+ * [ERR400E] Error while processing prepared query object
+ * [ERR401E] Executing Session Failure for Request
+ * [ERR402E] Ill formed queryObject for the request
+ * [ERR403E] Error processing Prepared Query Object
+ *
+ * 500-599 - Zookeepr/Locking Related
+ * [ERR500E] Invalid lock
+ * [ERR501E] Locking Error has occured
+ * [ERR502E] Zookeeper error has occured
+ * [ERR503E] Failed to aquire lock store handle
+ * [ERR504E] Failed to create Lock Reference
+ * [ERR505E] Lock does not exist
+ * [ERR506E] Failed to aquire lock
+ * [ERR507E] Lock not aquired
+ * [ERR508E] Lock state not set
+ * [ERR509E] Lock not destroyed
+ * [ERR510E] Lock not released
+ * [ERR511E] Lock not deleted
+ * [ERR512E] Failed to get ZK Lock Handle
+ *
+ *
+ * 600 - 699 - Music Service Errors
+ * [ERR600E] Error initializing the cache
+ *
+ * 700-799 Schema Interface Type/Validation - received Pay-load checksum is
+ * invalid - received JSON is not valid
+ *
+ * 800-899 Business/Flow Processing Related - check out to service is not
+ * allowed - Roll-back is done - failed to generate heat file
+ *
+ *
+ * 900-999 Unknown Errors - Unexpected exception
+ * [ERR900E] Unexpected error occured
+ * [ERR901E] Number format exception
+ *
+ *
+ * 1000-1099 Reserved - do not use
+ *
+ */
+
+ /*SUCCESS("Success"), FAILURE("Failure");
+
+ private String result;
+
+ ResultType(String result) {
+ this.result = result;
+ }
+
+ public String getResult() {
+ return result;
+ }
+*/
+
+
+
+}
--- /dev/null
+/*
+ * ============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.eelf.logging.format;
+
+/**
+ * @author inam
+ *
+ */
+public enum ErrorSeverity {
+ INFO,
+ WARN,
+ ERROR,
+ FATAL,
+ CRITICAL,
+ MAJOR,
+ MINOR,
+ NONE,
+}
--- /dev/null
+/*
+ * ============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.eelf.logging.format;
+
+import com.att.eelf.i18n.EELFResolvableErrorEnum;
+
+/**
+ * @author inam
+ *
+ */
+public enum ErrorTypes implements EELFResolvableErrorEnum {
+
+
+ CONNECTIONERROR,
+ SESSIONEXPIRED,
+ AUTHENTICATIONERROR,
+ SERVICEUNAVAILABLE,
+ QUERYERROR,
+ DATAERROR,
+ GENERALSERVICEERROR,
+ MUSICSERVICEERROR,
+ LOCKINGERROR,
+ UNKNOWN,
+
+}
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 {
out = new ObjectOutputStream(bos);
out.writeObject(this);
} catch (IOException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.IOERROR, ErrorSeverity.ERROR, ErrorTypes.CONNECTIONERROR);
}
return bos.toByteArray();
}
in = new ObjectInputStream(bis);
o = in.readObject();
} catch (ClassNotFoundException | IOException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.UNKNOWN);
}
return (MusicLockState) o;
}
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.MusicUtil;
connectedSignal.await();
zkLockHandle = new ZkStatelessLockService(zk);
} catch (IOException e) {
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ 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());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
throw new MusicServiceException("Exception Occured " + e.getMessage());
}
}
ZooKeeper zk = new ZooKeeper(lockServer, SESSION_TIMEOUT, this);
connectedSignal.await();
zkLockHandle = new ZkStatelessLockService(zk);
- } catch (IOException | InterruptedException e) {
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
- }
+ } 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) {
try{
data = zkLockHandle.getNodeData(lockName);
}catch (Exception ex){
- logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, ex.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
}
if(data !=null)
return MusicLockState.deSerialize(data);
- else
- throw new MusicLockingException("Invalid lock or acquire failed");
+ 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 lockName = "/" + st.nextToken("/");
try {
return zkLockHandle.lock(lockName, lockId);
- } catch (KeeperException | InterruptedException e) {
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
- }
+ } 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;
}
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;
*
*/
class ProtocolSupport {
- private EELFLoggerDelegate LOG = EELFLoggerDelegate.getLogger(ProtocolSupport.class);
+ private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ProtocolSupport.class);
protected ZooKeeper zookeeper;
private AtomicBoolean closed = new AtomicBoolean(false);
try {
return operation.execute();
} catch (KeeperException.SessionExpiredException e) {
- LOG.debug("Session expired for: " + zookeeper + " so reconnecting due to: " + e, 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;
}
- LOG.debug("Attempt " + i + " failed with connection loss so "
- + "attempting to reconnect: " + e, 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);
}
}
return true;
}
});
- } catch (InterruptedException|KeeperException e) {
- LOG.error(EELFLoggerDelegate.errorLogger,"Caught: " + e, e);
+ } catch (KeeperException e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
+ } catch (InterruptedException e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
}
}
try {
Thread.sleep(attemptCount * retryDelay);
} catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger,"Failed to sleep: " + e, 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();
}
}
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
private final String name;
private String prefix;
private int sequence = -1;
- private EELFLoggerDelegate LOG = EELFLoggerDelegate.getLogger(ZNodeName.class);
+ private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ZNodeName.class);
public ZNodeName(String name) {
if (name == null) {
// If an exception occurred we misdetected a sequence suffix,
// so return -1.
} catch (NumberFormatException e) {
- LOG.error(EELFLoggerDelegate.errorLogger,"Number format exception for " + idx, e);
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Number format exception "+idx, ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
} catch (ArrayIndexOutOfBoundsException e) {
- LOG.error(EELFLoggerDelegate.errorLogger,"Array out of bounds for " + idx, e);
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),"Array out of bounds for "+idx, ErrorSeverity.ERROR, ErrorTypes.GENERALSERVICEERROR);
}
}
}
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;
/**
* A <a href="package.html">protocol to implement an exclusive write lock or to elect a leader</a>.
zookeeper = zk;
}
- private static EELFLoggerDelegate LOG =
+ private static EELFLoggerDelegate logger =
EELFLoggerDelegate.getLogger(ZkStatelessLockService.class);
protected void createLock(final String path, final byte[] data) {
return true;
}
});
- } catch (KeeperException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
- } catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ }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) {
- LOG.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ }catch (InterruptedException e) {
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.EXECUTIONINTERRUPTED, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
}
}
return true;
}
});
- } catch (KeeperException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
- } catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ }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);
}
}
else
return null;
- } catch (KeeperException | InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ }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;
}
if (stat != null) {
result = true;
}
- } catch (KeeperException | InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ }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;
}
LockZooKeeperOperation zop = new LockZooKeeperOperation(dir);
try {
retryOperation(zop);
- } catch (KeeperException | InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ }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();
}
};
zopdel.execute();
} catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, 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) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
}
}
}
return sortedNames.first().getName();
} catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, 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) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
}
}
};
zopdel.execute();
} catch (InterruptedException e) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, 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) {
- LOG.error(EELFLoggerDelegate.errorLogger, "Caught: " + e, e);
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.KEEPERERROR, ErrorSeverity.ERROR, ErrorTypes.LOCKINGERROR);
throw (RuntimeException) new RuntimeException(e.getMessage()).initCause(e);
}
}
id = zookeeper.create(dir + "/" + prefix, data, getAcl(),
CreateMode.PERSISTENT_SEQUENTIAL);
- if (LOG.isDebugEnabled()) {
- LOG.debug("Created id: " + id);
+ if (logger.isDebugEnabled()) {
+ logger.debug(EELFLoggerDelegate.debugLogger, "Created id: " + id);
}
if (id != null)
break;
if (id != null) {
List<String> names = zookeeper.getChildren(dir, false);
if (names.isEmpty()) {
- LOG.info(EELFLoggerDelegate.applicationLogger, "No children in: " + dir);
+ 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 :)
if (!lessThanMe.isEmpty()) {
ZNodeName lastChildName = lessThanMe.last();
String lastChildId = lastChildName.getName();
- if (LOG.isDebugEnabled()) {
- LOG.debug("watching less than me node: " + lastChildId);
+ 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 {
- LOG.info(EELFLoggerDelegate.applicationLogger,
+ logger.info(EELFLoggerDelegate.applicationLogger,
"Could not find the" + " stats for less than me: "
+ lastChildName.getName());
}
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 com.att.eelf.configuration.EELFLogger;
try {
pQuery.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), false));
} catch (Exception e1) {
+ logger.error(EELFLoggerDelegate.errorLogger, e1.getMessage(),AppMessages.CACHEERROR, ErrorSeverity.CRITICAL, ErrorTypes.GENERALSERVICEERROR);
e1.printStackTrace();
- logger.error(EELFLoggerDelegate.errorLogger,"Exception is "+ e1.getMessage() + "during initalizeAafCache");
}
ResultSet rs = MusicCore.get(pQuery);
Iterator<Row> it = rs.iterator();
+ nameSpace);
}
} catch (Exception e) {
- // TODO Auto-generated catch block
+ 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();
- logger.error("Something at AAF was changed for ns: " + nameSpace
- + ". So not updating Cache for the namespace. ");
- logger.error("Exception is " + e.getMessage());
}
}
@Override
public void run() {
- logger.debug("Scheduled task invoked. Refreshing Cache...");
+ logger.info(EELFLoggerDelegate.applicationLogger,"Scheduled task invoked. Refreshing Cache...");
try {
initializeAafCache();
} catch (MusicServiceException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(),AppMessages.UNKNOWNERROR, ErrorSeverity.INFO, ErrorTypes.GENERALSERVICEERROR);
}
}
if (aafCache.get(nameSpace) != null) {
if (keySpace != null && !musicCache.get(nameSpace).equals(keySpace)) {
- logger.debug("Create new application for the same namespace.");
+ logger.info(EELFLoggerDelegate.applicationLogger,"Create new application for the same namespace.");
} else if (aafCache.get(nameSpace).get(userId).equals(password)) {
- logger.debug("Authenticated with cache value..");
+ logger.info(EELFLoggerDelegate.applicationLogger,"Authenticated with cache value..");
// reset invalid attempts to 0
userAttempts.put(nameSpace, 0);
return true;
logger.info(EELFLoggerDelegate.applicationLogger,"Resetting failed attempt.");
userAttempts.put(nameSpace, 0);
} else {
+ logger.info(EELFLoggerDelegate.applicationLogger,"No more attempts allowed. Please wait for atleast 2 min.");
throw new Exception("No more attempts allowed. Please wait for atleast 2 min.");
}
}
- logger.error(EELFLoggerDelegate.errorLogger,"Cache not authenticated..");
+ logger.error(EELFLoggerDelegate.errorLogger,"",AppMessages.CACHEAUTHENTICATION,ErrorSeverity.WARN, ErrorTypes.GENERALSERVICEERROR);
logger.info(EELFLoggerDelegate.applicationLogger,"Check AAF again...");
}
}
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);
throw new Exception("AAF endpoint is not set. Please specify in the properties file.");
}
Client client = Client.create();
response.bufferEntity();
String x = response.getEntity(String.class);
AAFResponse responseObj = new ObjectMapper().readValue(x, AAFResponse.class);
+
return responseObj;
}
musicCache.put(keyspace, uuid);
} catch (Exception e) {
String msg = e.getMessage();
- logger.error("Exception occured during uuid retrieval from DB." + e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.QUERYERROR,ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
resultMap.put("Exception", "Unauthorized operation. Check AID and Keyspace. "
+ "Exception from MUSIC is: "
+ (msg == null ? "Keyspace is new so no AID should be passed in Header."
uuid = rs.getUUID("uuid").toString();
musicLockCache.put(nameSpace, uuid);
} catch (Exception e) {
- logger.error("Exception occured during uuid retrieval from DB." + e.getMessage());
- resultMap.put("Exception", "Unauthorized operation. Check AID and Namespace. ");
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.QUERYERROR,ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ resultMap.put("Exception", "Unauthorized operation. Check AID and Namespace. ");
return resultMap;
}
if (!musicLockCache.get(nameSpace).toString().equals(aid)) {
public static void updateMusicCache(String aid, String keyspace) {
- logger.info("Updating musicCache for keyspace " + keyspace + " with aid " + aid);
+ logger.info(EELFLoggerDelegate.applicationLogger,"Updating musicCache for keyspace " + keyspace + " with aid " + aid);
musicCache.put(keyspace, aid);
}
isAAF = String.valueOf(rs.getBool("is_aaf"));
appNameCache.put(namespace, isAAF);
} catch (Exception e) {
- logger.error("Exception occured during uuid retrieval from DB." + e.getMessage());
- e.printStackTrace();
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.QUERYERROR,ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
+ e.printStackTrace();
}
}
-
return Boolean.valueOf(isAAF);
}
try {
appName = rs.getString("application_name");
} catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Exception occured during uuid retrieval from DB."+e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger, e.getMessage(), AppMessages.QUERYERROR, ErrorSeverity.ERROR, ErrorTypes.QUERYERROR);
e.printStackTrace();
}
return appName;
public static Map<String, Object> verifyOnboarding(String ns, String userId, String password) {
Map<String, Object> resultMap = new HashMap<>();
if (ns == null || userId == null || password == null) {
- logger.error(EELFLoggerDelegate.errorLogger,"One or more required headers is missing. userId: "+userId+" :: password: "+password);
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
+ logger.error(EELFLoggerDelegate.errorLogger,"One or more required headers is missing. userId: "+userId+" :: password: "+password);
resultMap.put("Exception",
"One or more required headers appName(ns), userId, password is missing. Please check.");
return resultMap;
return resultMap;
}
if (rs == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR, ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
logger.error(EELFLoggerDelegate.errorLogger,"Namespace, UserId and password doesn't match. namespace: "+ns+" and userId: "+userId);
resultMap.put("Exception", "Namespace, UserId and password doesn't match. namespace: "+ns+" and userId: "+userId);
String keyspace = rs.getString("keyspace_name");
if (!is_aaf) {
if (!keyspace.equals(MusicUtil.DEFAULTKEYSPACENAME)) {
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
logger.error(EELFLoggerDelegate.errorLogger,"Non AAF applications are allowed to have only one keyspace per application.");
resultMap.put("Exception",
"Non AAF applications are allowed to have only one keyspace per application.");
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;
+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;
try {
mLockHandle = new MusicLockingService();
} catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to aquire Locl store handle" + e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKHANDLE,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
throw new MusicLockingException("Failed to aquire Locl store handle " + e);
}
}
try {
lockId = getLockingServiceHandle().createLockId("/" + lockName);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to create Lock Reference " + lockName);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.CREATELOCK+lockName,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+
}
long end = System.currentTimeMillis();
logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to create lock reference:" + (end - start) + " ms");
logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to get lock state:" + (end - start) + " ms");
return mls;
} catch (NullPointerException | MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"No lock object exists as of now.." + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.INVALIDLOCK,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
return null;
}
}
}
} else
- logger.debug("There is no lock state object for " + key);
-
+ 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
}
} catch (Exception e) {
StringWriter sw = new StringWriter();
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ 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);
try {
result = getLockingServiceHandle().isMyTurn(lockId);
} catch (MusicLockingException e2) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to aquireLock lockId " + lockId + " " + e2);
+ logger.error(EELFLoggerDelegate.errorLogger,AppMessages.INVALIDLOCK + lockId + " " + e2);
}
if (!result) {
logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Not your turn, someone else has the lock");
return new ReturnType(ResultType.FAILURE, "Lockid doesn't exist");
}
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to check if lockid exists - lockId " + lockId + " " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.INVALIDLOCK+lockId,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: returning failure");
return new ReturnType(ResultType.FAILURE, "Not your turn, someone else has the lock");
return new ReturnType(ResultType.SUCCESS, "You already have the lock!");
}
} catch (NullPointerException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"In acquire lock:No one has tried to acquire the lock yet..");
+ 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
try {
getLockingServiceHandle().setLockState(key, newMls);
} catch (MusicLockingException e1) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to set Lock state " + key + " " + e1);
+ logger.error(EELFLoggerDelegate.errorLogger,e1.getMessage(), AppMessages.LOCKSTATE+key,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
logger.info(EELFLoggerDelegate.applicationLogger,"In acquire lock: Set lock state to being_locked");
try {
getLockingServiceHandle().setLockState(key, newMls);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to set Lock state " + key + " " + 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");
getDSHandle().executePut(updateQuery, "critical");
} catch (MusicServiceException | MusicQueryException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to execute update query " + updateQuery + " " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.QUERYERROR +""+updateQuery ,ErrorSeverity.MAJOR, ErrorTypes.QUERYERROR);
}
}
try {
results = getDSHandle().executeCriticalGet(query);
} catch (MusicServiceException | MusicQueryException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.MAJOR, ErrorTypes.GENERALSERVICEERROR);
+
}
return results;
try {
return getLockingServiceHandle().whoseTurnIsIt("/" + lockName) + "";
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed whoseTurnIsIt " + lockName + " " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKINGERROR+lockName ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
return null;
try {
getLockingServiceHandle().unlockAndDeleteId(lockId);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to Destroy Lock Ref " + lockId + " " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.DESTROYLOCK+lockId ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
long end = System.currentTimeMillis();
logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to destroy lock reference:" + (end - start) + " ms");
try {
getLockingServiceHandle().unlockAndDeleteId(lockId);
} catch (MusicLockingException e1) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to release Lock " + lockId + " " + e1);
+ logger.error(EELFLoggerDelegate.errorLogger,e1.getMessage(), AppMessages.RELEASELOCK+lockId ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
String lockName = getLockNameFromId(lockId);
MusicLockState mls;
try {
getLockingServiceHandle().setLockState(lockName, mls);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to release Lock " + lockName + " " + 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");
try {
getLockingServiceHandle().deleteLock("/" + lockName);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to Delete Lock " + lockName + " " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.DELTELOCK+lockName ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
long end = System.currentTimeMillis();
logger.info(EELFLoggerDelegate.applicationLogger,"Time taken to delete lock:" + (end - start) + " ms");
try {
getLockingServiceHandle().getzkLockHandle().createNode(nodeName);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to get ZK Lock Handle " + e);
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle " ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
}
}
try {
getLockingServiceHandle().getzkLockHandle().setNodeData(nodeName, data);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to get ZK Lock Handle " + 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();
try {
data = getLockingServiceHandle().getzkLockHandle().getNodeData(nodeName);
} catch (MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,"Failed to get ZK Lock Handle " + 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");
try {
result = getDSHandle().executePut(queryObject, MusicUtil.EVENTUAL);
} catch (MusicServiceException | MusicQueryException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), "[ERR512E] Failed to get ZK Lock Handle " ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage() + " " + ex.getCause() + " " + ex);
}
if (result) {
try {
result = getDSHandle().executePut(queryObject, consistency);
} catch (MusicQueryException | MusicServiceException ex) {
- logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
throw new MusicServiceException(ex.getMessage());
}
return result;
} else
throw new MusicServiceException("YOU DO NOT HAVE THE LOCK");
} catch (MusicQueryException | MusicServiceException | MusicLockingException e) {
- logger.error(EELFLoggerDelegate.errorLogger,e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
}
return results;
}
return resultMap;
}
if (aid == null && (userId == null || password == null)) {
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO ,ErrorSeverity.WARN, ErrorTypes.DATAERROR);
logger.error(EELFLoggerDelegate.errorLogger,"One or more required headers is missing. userId: " + userId
+ " :: password: " + password);
resultMap.put("Exception",
try {
isValid = CachingUtil.authenticateAAFUser(nameSpace, userId, password, keyspace);
} catch (Exception e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.AUTHENTICATIONERROR ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
logger.error(EELFLoggerDelegate.errorLogger,"Got exception while AAF authentication for namespace " + nameSpace);
resultMap.put("Exception", e.getMessage());
}
if (!isValid) {
- logger.error(EELFLoggerDelegate.errorLogger,"User not authenticated with AAF.");
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
resultMap.put("Exception", "User not authenticated...");
}
if (!resultMap.isEmpty())
pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), password));
pQuery.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
pQuery.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
- CachingUtil.updateMusicCache(uuid, keyspace);
+ //CachingUtil.updateMusicCache(uuid, keyspace);
MusicCore.eventualPut(pQuery);
resultMap.put("aid", uuid);
}
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
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;
@WebListener
public class PropertiesListener implements ServletContextListener {
}
}
} catch (IOException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.IOERROR ,ErrorSeverity.CRITICAL, ErrorTypes.CONNECTIONERROR);
logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
}
import org.onap.music.datastore.PreparedQueryObject;
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.CachingUtil;
import org.onap.music.main.MusicCore;
import org.onap.music.main.MusicUtil;
String password = jsonObj.getPassword();
response.addHeader("X-latestVersion", MusicUtil.getVersion());
if (appName == null || userId == null || isAAF == null || password == null) {
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.MISSINGINFO ,ErrorSeverity.CRITICAL, ErrorTypes.DATAERROR);
resultMap.put("Exception",
"Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.");
return resultMap;
import org.onap.music.datastore.jsonobjects.JsonUpdate;
import org.onap.music.eelf.logging.EELFLoggerDelegate;
import org.onap.music.exceptions.MusicLockingException;
+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.main.CachingUtil;
import org.onap.music.main.MusicCore;
queryObject.appendQueryString(";");
result = MusicCore.nonKeyRelatedPut(queryObject, consistency);
} catch (Exception e) {
- logger.error(EELFLoggerDelegate.errorLogger, e.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
}
resultMap.remove("uuid");
try {
@ApiParam(value = "Table Name",
required = true) @PathParam("tablename") String tablename,
@Context HttpServletResponse response) throws Exception {
+
Map<String, Object> resultMap = MusicCore.autheticateUser(ns, userId, password, keyspace,
aid, "createTable");
response.addHeader(xLatestVersion, MusicUtil.getVersion());
: new ReturnType(ResultType.FAILURE,
"Null result - Please Contact admin").toMap();
} catch (Exception ex) {
- logger.error(EELFLoggerDelegate.applicationLogger, ex.getMessage());
+ logger.error(EELFLoggerDelegate.errorLogger,ex.getMessage(), AppMessages.UNKNOWNERROR ,ErrorSeverity.WARN, ErrorTypes.MUSICSERVICEERROR);
return new ReturnType(ResultType.FAILURE, ex.getMessage()).toMap();
}
}
if (resultMap.containsKey("aid"))
resultMap.remove("aid");
if (!resultMap.isEmpty()) {
- logger.error("Error while authentication... ");
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.AUTHENTICATIONERROR ,ErrorSeverity.WARN, ErrorTypes.AUTHENTICATIONERROR);
HashMap<String, Object> tempMap = new HashMap<>();
tempMap.putAll(resultMap);
Map<String, HashMap<String, Object>> results = new HashMap<>();
ResultSet results = MusicCore.get(queryObject);
return MusicCore.marshallResults(results);
} catch (MusicServiceException ex) {
+ logger.error(EELFLoggerDelegate.errorLogger,"", AppMessages.UNKNOWNERROR ,ErrorSeverity.ERROR, ErrorTypes.MUSICSERVICEERROR);
return MusicUtil.setErrorResponse(ex);
}
-///*
-// * ============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 org.junit.Before;
-//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.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.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 com.datastax.driver.core.ResultSet;
-//
-//@RunWith(MockitoJUnitRunner.class)
-//public class TestMusicCore {
-//
-// @Mock
-// private Condition condition;
-//
-// @Mock
-// private ResultSet rs;
-//
-// @Mock
-// private PreparedQueryObject preparedQueryObject;
-//
-// @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 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() {
-// 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() {
-// 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() {
-// 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 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() {
-// 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");
-// }
-//
-// @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);
-// 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() {
-// Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
-// MusicCore.destroyLockRef("id1");
-// Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
-// }
-//
-// @Test
-// public void testreleaseLockwithvoluntaryReleaseTrue() {
-// 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() {
-// 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() {
-// 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");
-// 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");
-// Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "eventual")).thenReturn(false);
-// ReturnType actualResult = MusicCore.eventualPut(preparedQueryObject);
-// assertEquals(expectedResult.getResult(), actualResult.getResult());
-// Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "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);
-// 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);
-// Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "consistency")).thenReturn(true);
-// Boolean result = MusicCore.nonKeyRelatedPut(preparedQueryObject, "consistency");
-// assertTrue(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");
-// 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);
-// 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);
-// Mockito.when(mDstoreHandle.executeEventualGet(preparedQueryObject)).thenReturn(rs);
-// ResultSet rs1 = MusicCore.get(preparedQueryObject);
-// assertNotNull(rs1);
-// Mockito.verify(mDstoreHandle).executeEventualGet(preparedQueryObject);
-//
-// }
-//
-// @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);
-// 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");
-// }
-//
-//}
+/*
+ * ============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 org.junit.Before;
+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.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 com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Session;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestMusicCore {
+
+ @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 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() {
+ 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() {
+ 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() {
+ 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 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() {
+ 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");
+ }
+
+ @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() {
+ Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
+ MusicCore.destroyLockRef("id1");
+ Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
+ }
+
+ @Test
+ public void testreleaseLockwithvoluntaryReleaseTrue() {
+ 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() {
+ 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() {
+ 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);
+ Boolean result = MusicCore.nonKeyRelatedPut(preparedQueryObject, "consistency");
+ assertTrue(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);
+
+ }
+
+ @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");
+ }
+
+}
--- /dev/null
+/*
+ * ============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.onap.music.main.MusicCore.mLockHandle;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.UriInfo;
+
+import org.apache.curator.test.TestingServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+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.CachingUtil;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.rest.RestMusicDataAPI;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@RunWith(MockitoJUnitRunner.class)
+public class TestRestMusicData {
+
+ RestMusicDataAPI data = new RestMusicDataAPI();
+ static PreparedQueryObject testObject;
+ static TestingServer zkServer;
+
+ @Mock
+ HttpServletResponse http;
+
+ @Mock
+ UriInfo info;
+
+ static String appName = "TestApp";
+ static String userId = "TestUser";
+ static String password = "TestPassword";
+ static boolean isAAF = false;
+ static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
+ static String keyspaceName = "testCassa";
+ static String tableName = "employees";
+ static String xLatestVersion = "X-latestVersion";
+
+ @BeforeClass
+ public static void init() throws Exception {
+ try {
+ MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
+ zkServer = new TestingServer(2181, new File("/tmp/zk"));
+ MusicCore.mLockHandle = new MusicLockingService();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ @AfterClass
+ public static void tearDownAfterClass() throws Exception {
+ System.out.println("After class");
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
+ MusicCore.eventualPut(testObject);
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
+ MusicCore.eventualPut(testObject);
+ MusicCore.mDstoreHandle.close();
+ MusicCore.mLockHandle.getzkLockHandle().close();
+ MusicCore.mLockHandle.close();
+ zkServer.stop();
+ }
+
+ @Test
+ public void Test1_createKeyspace() throws Exception {
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = " + "{'class' : 'SimpleStrategy' , "
+ + "'replication_factor': 1} AND DURABLE_WRITES = true");
+ MusicCore.eventualPut(testObject);
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("CREATE TABLE admin.keyspace_master (" + " uuid uuid, keyspace_name text,"
+ + " application_name text, is_api boolean," + " password text, username text,"
+ + " is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject
+ .appendQueryString("INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+ + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), MusicUtil.DEFAULTKEYSPACENAME));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), password));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject
+ .appendQueryString("INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+ + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
+ UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), MusicUtil.DEFAULTKEYSPACENAME));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), password));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject
+ .appendQueryString("select uuid from admin.keyspace_master where application_name = ? allow filtering");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+ ResultSet rs = MusicCore.get(testObject);
+ List<Row> rows = rs.all();
+ if (rows.size() > 0) {
+ System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
+ }
+ }
+
+ @Test
+ public void Test2_createKeyspace() 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());
+ Map<String, Object> resultMap = data.createKeySpace("1", "1", "1", null, appName, userId, password,
+ jsonKeyspace, keyspaceName, http);
+ assertEquals(uuid.toString(), resultMap.get("aid"));
+ }
+
+ @Test
+ public void Test3_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("TestApp1");
+ jsonKeyspace.setReplicationInfo(replicationInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Map<String, Object> resultMap = data.createKeySpace("1", "1", "1", null, "TestApp1", "TestUser1", password,
+ jsonKeyspace, keyspaceName, http);
+ System.out.println("#######status is " + resultMap.get("Exception"));
+ assertEquals("Couldn't create keyspace. Please make sure all the information is correct.",
+ resultMap.get("Exception"));
+ }
+
+ @Test
+ public void Test3_createTable() 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)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Map<String, Object> resultMap = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ userId, password, jsonTable, keyspaceName, tableName, http);
+ assertEquals("SUCCESS", resultMap.get("status"));
+ }
+
+ @Test
+ public void Test4_insertIntoTable() 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", "test");
+ values.put("emp_salary", 500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Map<String, Object> resultMap = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, userId, password, jsonInsert, keyspaceName, tableName, http);
+ assertEquals("Success", resultMap.get("result"));
+ }
+
+ @Test
+ public void Test4_insertIntoTable2() 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", "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());
+ Map<String, Object> resultMap = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, userId, password, jsonInsert, keyspaceName, tableName, http);
+ assertEquals("Success", resultMap.get("result"));
+ }
+
+ @Test
+ public void Test5_updateTable() 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", "test");
+ 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);
+ Map<String, Object> resultMap = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ userId, password, jsonUpdate, keyspaceName, tableName, info, http);
+ assertEquals("Success", resultMap.get("result"));
+ }
+
+ @Test
+ public void Test6_select() throws Exception {
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Map<String, HashMap<String, Object>> resultMap = data.select("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, keyspaceName, tableName, info, http);
+ assertEquals("2500", resultMap.get("row 0").get("emp_salary").toString());
+ }
+
+ @Test
+ public void Test6_selectCritical() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test");
+ consistencyInfo.put("type", "atomic");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Map<String, HashMap<String, Object>> resultMap = data.selectCritical("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, jsonInsert, keyspaceName, tableName,
+ info, http);
+ assertEquals("2500", resultMap.get("row 0").get("emp_salary").toString());
+ }
+
+ @Test
+ public void Test6_deleteFromTable() 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);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Map<String, Object> resultMap = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, userId, password, jsonDelete, keyspaceName, tableName, info, http);
+ assertEquals("Success", resultMap.get("result"));
+ }
+
+ @Test
+ public void Test7_dropTable() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ consistencyInfo.put("type", "atomic");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Map<String, Object> resultMap = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ userId, password, jsonTable, keyspaceName, tableName, http);
+ assertEquals("SUCCESS", resultMap.get("status"));
+ }
+
+ @Test
+ public void Test8_deleteKeyspace() 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());
+ Map<String, Object> resultMap = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, userId, password, jsonKeyspace, keyspaceName, http);
+ assertEquals("SUCCESS", resultMap.get("status"));
+ }
+
+}
Code Review / music.git / commitdiff