diff options
Diffstat (limited to 'src')
17 files changed, 1394 insertions, 581 deletions
diff --git a/src/main/java/org/onap/music/datastore/MusicDataStore.java b/src/main/java/org/onap/music/datastore/MusicDataStore.java index 09bdc8a7..c64a96b3 100644 --- a/src/main/java/org/onap/music/datastore/MusicDataStore.java +++ b/src/main/java/org/onap/music/datastore/MusicDataStore.java @@ -30,11 +30,12 @@ import java.util.HashMap; 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; @@ -134,7 +135,9 @@ public class MusicDataStore { } } } 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; } @@ -162,7 +165,7 @@ public class MusicDataStore { 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); } } } @@ -189,7 +192,7 @@ public class MusicDataStore { 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()); } @@ -311,8 +314,7 @@ public class MusicDataStore { 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() + "]"); } @@ -342,14 +344,12 @@ public class MusicDataStore { } 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()); } @@ -369,7 +369,8 @@ public class MusicDataStore { 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, @@ -381,8 +382,8 @@ public class MusicDataStore { 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; } @@ -399,8 +400,8 @@ public class MusicDataStore { 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, @@ -411,8 +412,8 @@ public class MusicDataStore { 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; diff --git a/src/main/java/org/onap/music/eelf/logging/format/AppMessages.java b/src/main/java/org/onap/music/eelf/logging/format/AppMessages.java new file mode 100644 index 00000000..f265eae3 --- /dev/null +++ b/src/main/java/org/onap/music/eelf/logging/format/AppMessages.java @@ -0,0 +1,177 @@ +/* + * ============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; + } + + + + + + + +} diff --git a/src/main/java/org/onap/music/eelf/logging/format/ErrorCodes.java b/src/main/java/org/onap/music/eelf/logging/format/ErrorCodes.java new file mode 100644 index 00000000..b18c1771 --- /dev/null +++ b/src/main/java/org/onap/music/eelf/logging/format/ErrorCodes.java @@ -0,0 +1,106 @@ +/* + * ============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; + } +*/ + + + +} diff --git a/src/main/java/org/onap/music/eelf/logging/format/ErrorSeverity.java b/src/main/java/org/onap/music/eelf/logging/format/ErrorSeverity.java new file mode 100644 index 00000000..cda5dd31 --- /dev/null +++ b/src/main/java/org/onap/music/eelf/logging/format/ErrorSeverity.java @@ -0,0 +1,37 @@ +/* + * ============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, +} diff --git a/src/main/java/org/onap/music/eelf/logging/format/ErrorTypes.java b/src/main/java/org/onap/music/eelf/logging/format/ErrorTypes.java new file mode 100644 index 00000000..2536f4a4 --- /dev/null +++ b/src/main/java/org/onap/music/eelf/logging/format/ErrorTypes.java @@ -0,0 +1,44 @@ +/* + * ============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, + +} diff --git a/src/main/java/org/onap/music/lockingservice/MusicLockState.java b/src/main/java/org/onap/music/lockingservice/MusicLockState.java index 10cdc0e7..5d051be4 100644 --- a/src/main/java/org/onap/music/lockingservice/MusicLockState.java +++ b/src/main/java/org/onap/music/lockingservice/MusicLockState.java @@ -30,6 +30,9 @@ import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.io.Serializable; import org.onap.music.eelf.logging.EELFLoggerDelegate; +import org.onap.music.eelf.logging.format.AppMessages; +import org.onap.music.eelf.logging.format.ErrorSeverity; +import org.onap.music.eelf.logging.format.ErrorTypes; // the state variable that will be stored in zookeeper, capturing the transitions of public class MusicLockState implements Serializable { @@ -104,7 +107,7 @@ 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(); } @@ -117,7 +120,7 @@ public class MusicLockState implements Serializable { 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; } diff --git a/src/main/java/org/onap/music/lockingservice/MusicLockingService.java b/src/main/java/org/onap/music/lockingservice/MusicLockingService.java index e8a57dbf..2fc8a151 100644 --- a/src/main/java/org/onap/music/lockingservice/MusicLockingService.java +++ b/src/main/java/org/onap/music/lockingservice/MusicLockingService.java @@ -28,6 +28,9 @@ import org.apache.zookeeper.Watcher; import org.apache.zookeeper.Watcher.Event.KeeperState; import org.apache.zookeeper.ZooKeeper; import org.onap.music.eelf.logging.EELFLoggerDelegate; +import org.onap.music.eelf.logging.format.AppMessages; +import org.onap.music.eelf.logging.format.ErrorSeverity; +import org.onap.music.eelf.logging.format.ErrorTypes; import org.onap.music.exceptions.MusicLockingException; import org.onap.music.exceptions.MusicServiceException; import org.onap.music.main.MusicUtil; @@ -48,10 +51,10 @@ public class MusicLockingService implements Watcher { 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()); } } @@ -65,9 +68,13 @@ public class MusicLockingService implements Watcher { 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) { @@ -90,12 +97,14 @@ public class MusicLockingService implements Watcher { 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) { @@ -109,9 +118,13 @@ public class MusicLockingService implements Watcher { 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; } diff --git a/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java b/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java index ec612bcd..4082b3b8 100644 --- a/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java +++ b/src/main/java/org/onap/music/lockingservice/ProtocolSupport.java @@ -28,6 +28,9 @@ import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.data.ACL; import org.apache.zookeeper.data.Stat; import org.onap.music.eelf.logging.EELFLoggerDelegate; +import org.onap.music.eelf.logging.format.AppMessages; +import org.onap.music.eelf.logging.format.ErrorSeverity; +import org.onap.music.eelf.logging.format.ErrorTypes; import org.onap.music.lockingservice.ZooKeeperOperation; import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; @@ -39,7 +42,7 @@ 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); @@ -125,14 +128,15 @@ class ProtocolSupport { 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); } } @@ -169,8 +173,10 @@ class ProtocolSupport { 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); } } @@ -193,7 +199,8 @@ class ProtocolSupport { 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(); } } diff --git a/src/main/java/org/onap/music/lockingservice/ZNodeName.java b/src/main/java/org/onap/music/lockingservice/ZNodeName.java index eefc81a9..0c190f14 100644 --- a/src/main/java/org/onap/music/lockingservice/ZNodeName.java +++ b/src/main/java/org/onap/music/lockingservice/ZNodeName.java @@ -22,6 +22,8 @@ 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 @@ -32,7 +34,7 @@ class ZNodeName implements Comparable<ZNodeName> { 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) { @@ -48,9 +50,9 @@ class ZNodeName implements Comparable<ZNodeName> { // 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); } } } diff --git a/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java b/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java index f7464ec0..51efafbf 100644 --- a/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java +++ b/src/main/java/org/onap/music/lockingservice/ZkStatelessLockService.java @@ -28,6 +28,9 @@ import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.data.ACL; import org.apache.zookeeper.data.Stat; import org.onap.music.eelf.logging.EELFLoggerDelegate; +import org.onap.music.eelf.logging.format.AppMessages; +import org.onap.music.eelf.logging.format.ErrorSeverity; +import org.onap.music.eelf.logging.format.ErrorTypes; /** * A <a href="package.html">protocol to implement an exclusive write lock or to elect a leader</a>. @@ -44,7 +47,7 @@ public class ZkStatelessLockService extends ProtocolSupport { zookeeper = zk; } - private static EELFLoggerDelegate LOG = + private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ZkStatelessLockService.class); protected void createLock(final String path, final byte[] data) { @@ -56,18 +59,18 @@ public class ZkStatelessLockService extends ProtocolSupport { 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); } } @@ -80,10 +83,10 @@ public class ZkStatelessLockService extends ProtocolSupport { 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); } } @@ -95,8 +98,10 @@ public class ZkStatelessLockService extends ProtocolSupport { 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; } @@ -108,8 +113,10 @@ public class ZkStatelessLockService extends ProtocolSupport { 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; } @@ -123,8 +130,10 @@ public class ZkStatelessLockService extends ProtocolSupport { 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(); } @@ -161,13 +170,13 @@ public class ZkStatelessLockService extends ProtocolSupport { }; 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); } } @@ -187,13 +196,13 @@ public class ZkStatelessLockService extends ProtocolSupport { } 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); } } @@ -216,13 +225,14 @@ public class ZkStatelessLockService extends ProtocolSupport { }; 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); } } @@ -272,8 +282,8 @@ public class ZkStatelessLockService extends ProtocolSupport { 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; @@ -281,8 +291,12 @@ public class ZkStatelessLockService extends ProtocolSupport { 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 :) @@ -298,14 +312,14 @@ public class ZkStatelessLockService extends ProtocolSupport { 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()); } diff --git a/src/main/java/org/onap/music/main/CachingUtil.java b/src/main/java/org/onap/music/main/CachingUtil.java index aef261f0..40dffa2d 100755 --- a/src/main/java/org/onap/music/main/CachingUtil.java +++ b/src/main/java/org/onap/music/main/CachingUtil.java @@ -36,6 +36,9 @@ import org.codehaus.jackson.map.ObjectMapper; 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; @@ -83,8 +86,8 @@ public class CachingUtil implements Runnable { 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(); @@ -109,11 +112,9 @@ public class CachingUtil implements Runnable { + 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()); } } @@ -121,11 +122,11 @@ public class CachingUtil implements Runnable { @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); } } @@ -134,9 +135,9 @@ public class CachingUtil implements Runnable { 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; @@ -154,10 +155,11 @@ public class CachingUtil implements Runnable { 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..."); } } @@ -178,6 +180,7 @@ public class CachingUtil implements Runnable { 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(); @@ -213,6 +216,7 @@ public class CachingUtil implements Runnable { response.bufferEntity(); String x = response.getEntity(String.class); AAFResponse responseObj = new ObjectMapper().readValue(x, AAFResponse.class); + return responseObj; } @@ -235,7 +239,7 @@ public class CachingUtil implements Runnable { 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." @@ -273,8 +277,8 @@ public class CachingUtil implements Runnable { 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)) { @@ -295,7 +299,7 @@ public class CachingUtil implements Runnable { 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); } @@ -316,12 +320,11 @@ public class CachingUtil implements Runnable { 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); } @@ -354,7 +357,7 @@ public class CachingUtil implements Runnable { 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; @@ -381,7 +384,8 @@ public class CachingUtil implements Runnable { 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; @@ -408,6 +412,7 @@ public class CachingUtil implements Runnable { 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); @@ -416,6 +421,7 @@ public class CachingUtil implements Runnable { 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."); diff --git a/src/main/java/org/onap/music/main/MusicCore.java b/src/main/java/org/onap/music/main/MusicCore.java index 0306560a..fdf43a45 100644 --- a/src/main/java/org/onap/music/main/MusicCore.java +++ b/src/main/java/org/onap/music/main/MusicCore.java @@ -31,6 +31,9 @@ import org.onap.music.datastore.MusicDataStore; 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; @@ -82,7 +85,7 @@ public class MusicCore { 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); } } @@ -136,7 +139,8 @@ public class MusicCore { 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"); @@ -175,7 +179,7 @@ public class MusicCore { 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; } @@ -200,8 +204,8 @@ public class MusicCore { } } } 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 @@ -227,7 +231,8 @@ public class MusicCore { } } 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); @@ -244,7 +249,7 @@ public class MusicCore { 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"); @@ -254,7 +259,7 @@ public class MusicCore { 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"); @@ -280,7 +285,7 @@ public class MusicCore { 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 @@ -296,7 +301,7 @@ public class MusicCore { 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"); @@ -317,7 +322,7 @@ public class MusicCore { 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"); @@ -388,7 +393,7 @@ public class MusicCore { 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); } } @@ -405,7 +410,8 @@ public class MusicCore { 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; @@ -431,7 +437,7 @@ public class MusicCore { 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; @@ -453,7 +459,7 @@ public class MusicCore { 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"); @@ -464,7 +470,7 @@ public class MusicCore { 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; @@ -481,7 +487,7 @@ public class MusicCore { 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"); @@ -502,7 +508,7 @@ public class MusicCore { 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"); @@ -530,7 +536,7 @@ public class MusicCore { 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); } } @@ -545,7 +551,7 @@ public class MusicCore { 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(); @@ -563,7 +569,7 @@ public class MusicCore { 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"); @@ -588,6 +594,7 @@ public class MusicCore { 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) { @@ -658,7 +665,7 @@ public class MusicCore { 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; @@ -704,7 +711,7 @@ public class MusicCore { } 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; } @@ -882,6 +889,7 @@ public class MusicCore { 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", @@ -894,11 +902,12 @@ public class MusicCore { 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()) @@ -937,7 +946,7 @@ public class MusicCore { 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); } diff --git a/src/main/java/org/onap/music/main/PropertiesListener.java b/src/main/java/org/onap/music/main/PropertiesListener.java index de231542..afd35387 100755 --- a/src/main/java/org/onap/music/main/PropertiesListener.java +++ b/src/main/java/org/onap/music/main/PropertiesListener.java @@ -32,6 +32,9 @@ import javax.servlet.ServletContextEvent; 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 { @@ -127,6 +130,7 @@ 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()); } diff --git a/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java b/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java index 6d8ac088..849c3a98 100755 --- a/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java +++ b/src/main/java/org/onap/music/rest/RestMusicAdminAPI.java @@ -39,6 +39,9 @@ import javax.ws.rs.core.MediaType; 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; @@ -72,6 +75,7 @@ public class RestMusicAdminAPI { 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; diff --git a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java index 0eedbaa0..ed586d06 100755 --- a/src/main/java/org/onap/music/rest/RestMusicDataAPI.java +++ b/src/main/java/org/onap/music/rest/RestMusicDataAPI.java @@ -44,6 +44,9 @@ import org.onap.music.datastore.jsonobjects.JsonTable; import org.onap.music.datastore.jsonobjects.JsonUpdate; import org.onap.music.eelf.logging.EELFLoggerDelegate; import org.onap.music.exceptions.MusicLockingException; +import org.onap.music.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; @@ -257,7 +260,7 @@ public class RestMusicDataAPI { 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 { @@ -382,6 +385,7 @@ public class RestMusicDataAPI { @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()); @@ -655,7 +659,7 @@ public class RestMusicDataAPI { : 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(); } } @@ -1150,7 +1154,7 @@ public class RestMusicDataAPI { 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<>(); @@ -1175,6 +1179,7 @@ public class RestMusicDataAPI { 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); } diff --git a/src/test/java/org/onap/music/unittests/TestMusicCore.java b/src/test/java/org/onap/music/unittests/TestMusicCore.java index 3355e4cd..5b5665a8 100644 --- a/src/test/java/org/onap/music/unittests/TestMusicCore.java +++ b/src/test/java/org/onap/music/unittests/TestMusicCore.java @@ -1,463 +1,487 @@ -///* -// * ============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"); + } + +} diff --git a/src/test/java/org/onap/music/unittests/TestRestMusicData.java b/src/test/java/org/onap/music/unittests/TestRestMusicData.java new file mode 100644 index 00000000..bc5e9fb9 --- /dev/null +++ b/src/test/java/org/onap/music/unittests/TestRestMusicData.java @@ -0,0 +1,357 @@ +/* + * ============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")); + } + +} |