[Policy-20] getConfig & Policy resolved blockers

Change-Id: If08e4c90d419e8d6e1426d817a12dde5b7cafba3
Signed-off-by: rb7147 <rb7147@att.com>

7 files changed, 535 insertions, 148 deletions

diff --git a/LogParser/pom.xml b/LogParser/pom.xml
index 20e06045a..81784b8a2 100644
--- a/LogParser/pom.xml
+++ b/LogParser/pom.xml
@@ -58,9 +58,14 @@
 			</exclusions>
 		</dependency>
 		<dependency>
-			<groupId>log4j</groupId>
-			<artifactId>log4j</artifactId>
-			<version>1.2.17</version>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-api</artifactId>
+			<version>2.4</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-core</artifactId>
+			<version>2.4</version>
 		</dependency>
 		<dependency>
 			<groupId>org.eclipse.persistence</groupId>
diff --git a/LogParser/src/main/java/org/openecomp/xacml/parser/LogEntryObject.java b/LogParser/src/main/java/org/openecomp/xacml/parser/LogEntryObject.java
index 4b03d2aaa..3b1ccffc5 100644
--- a/LogParser/src/main/java/org/openecomp/xacml/parser/LogEntryObject.java
+++ b/LogParser/src/main/java/org/openecomp/xacml/parser/LogEntryObject.java
@@ -32,7 +32,7 @@ public class LogEntryObject {
 	private LOGTYPE logType;
 	
 	public enum LOGTYPE {
-		INFO, ERROR, SEVERE, WARN;
+		INFO, DEBUG, ERROR, SEVERE, WARN;
 	}
 		
 	public String getSystem() {
@@ -71,4 +71,4 @@ public class LogEntryObject {
 	public void setLogType(LOGTYPE logType) {
 		this.logType = logType;
 	}	
-}
+}
\ No newline at end of file
diff --git a/LogParser/src/main/java/org/openecomp/xacml/parser/ParseLog.java b/LogParser/src/main/java/org/openecomp/xacml/parser/ParseLog.java
index 8c6df28b0..443267309 100644
--- a/LogParser/src/main/java/org/openecomp/xacml/parser/ParseLog.java
+++ b/LogParser/src/main/java/org/openecomp/xacml/parser/ParseLog.java
@@ -48,6 +48,7 @@ import org.apache.log4j.Logger;
 import org.openecomp.policy.common.im.AdministrativeStateException;
 import org.openecomp.policy.common.im.IntegrityMonitor;
 import org.openecomp.policy.common.im.StandbyStatusException;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
 import org.openecomp.xacml.parser.LogEntryObject.LOGTYPE;
 
 /**
@@ -57,15 +58,24 @@ import org.openecomp.xacml.parser.LogEntryObject.LOGTYPE;
  */
 public class ParseLog {
 	
-	private static final Logger logger = Logger.getLogger(ParseLog.class.getName());
+	// only logging last line of each log file processed to the log4j log file defined by property - PARSERLOGPATH
+	private static final Logger log4jlogger = Logger.getLogger(ParseLog.class.getName());
+
+	// processing logging 
+	private static org.openecomp.policy.common.logging.flexlogger.Logger logger = FlexLogger.getLogger(ParseLog.class.getName());
 
 	private static String system;
 	private static int lastNumberRead = 0;
+	private static int debuglastNumberRead = 0;
+	private static int errorlastNumberRead = 0;
 	private static String type;
 	private static long startFileSize;
+	private static long debugStartFileSize;
+	private static long errorStartFileSize;
 	private static String systemLogFile;
 	private static String logFile;
-	
+	private static String debuglogFile;
+	private static String errorlogFile;
 	private static String JDBC_URL;
 	private static String JDBC_USER;
 	private static String JDBC_PASSWORD = "";
@@ -73,84 +83,240 @@ public class ParseLog {
 	private static int maxLength = 255;   //Max length that is allowed in the DB table
 	private static String resourceName;
 	private static long sleepTimer = 50000;
-	static IntegrityMonitor im;
+	static  IntegrityMonitor im;
+	private static boolean isMissingLogFile;
 
 	private static RandomAccessFile randomAccessFile;
 	
 	public static void main(String[] args) throws Exception {
 
 		Properties logProperties = getPropertiesValue("parserlog.properties");
-		Path filePath = Paths.get(logFile);
-		File file = new File(logFile);
+		
+		if(logProperties == null || isMissingLogFile){
+			// missing the path of log file in the properties file, so stop the process
+			logger.error("logProperties is null or LOGPATH is missing in parserlog.properties, so stop the process.");
+			return;
+		}
+     
 		File fileLog = new File(systemLogFile);
-		startFileSize = file.length();
-			
+
 		im = IntegrityMonitor.getInstance(resourceName,logProperties );
 		
-		logger.info("System: " + system );  
-		logger.info("System type: " + type );  
-		logger.info("Logging File: " + systemLogFile );
-		logger.info("log file: " + logFile);
-		logger.info("JDBC_URL: " + JDBC_URL);
-		logger.info("JDBC_DRIVER: " + JDBC_DRIVER);
-		
-		String filesRead = PullLastLineRead(fileLog);
-		if (filesRead!= null){			
-			filesRead = filesRead.replaceAll("(\\r\\n|\\n)", "<br />");
-			lastNumberRead= Integer.parseInt(filesRead.trim());
-		}else{
-			lastNumberRead = 0;
-		}
-		startFileSize =  countLines(logFile);
-		logger.info("File Line Count: " + startFileSize + " value read in: " + lastNumberRead);
-		if (startFileSize < lastNumberRead ){
-			logger.error("Filed Rolled: set Last number read to 0");
-			lastNumberRead = 0;
-		}
-		Runnable  runnable = new Runnable (){
-		public void run(){
-			while (true){		
-	             
-				if (file.isFile()){
-					try (Stream<String> lines = Files.lines(filePath, Charset.defaultCharset()).onClose(() -> logger.info("Last line Read: " + lastNumberRead)).skip(lastNumberRead)) {
+		startDebugLogParser(fileLog);
+		startErrorLogParser(fileLog);
+		startAPIRestLogParser(fileLog);	
+	
+	}	
+	
+	private static void startDebugLogParser(File fileLog) throws Exception{
+		if(debuglogFile != null && !debuglogFile.isEmpty()){
+			
+			// pull the last line number 
+			String dataFileName = "debug.log";
+			String filesRead = PullLastLineRead(fileLog, dataFileName);  
+			if (filesRead!= null){			
+				filesRead = filesRead.replaceAll("(\\r\\n|\\n)", "<br />");
+				debuglastNumberRead= Integer.parseInt(filesRead.trim());
+			}else{
+				debuglastNumberRead = 0;
+			}	
+			
+			debugStartFileSize =  countLines(debuglogFile);
+			if (debugStartFileSize < debuglastNumberRead ){ 
+				logger.error("Filed Rolled: set Last debug number read to 0");
+				debuglastNumberRead = 0;
+			}
+			
+			isMissingLogFile = false; 
+			Path debugfilePath = Paths.get(debuglogFile);
+			File debugfile = new File(debuglogFile);
+			debugStartFileSize = debugfile.length();
+			// start process debug.log file
+
+			Runnable  runnable = new Runnable (){
+				boolean isStop = false;
+				
+				public void run(){
+					while (!isStop){	
+			             
+						if (debugfile.isFile()){
+							// log4jlogger must use .info
+							try (Stream<String> lines = Files.lines(debugfilePath, Charset.defaultCharset()).onClose(() -> log4jlogger.info("Last-"+dataFileName+"-line-Read:" + debuglastNumberRead)).skip(debuglastNumberRead)) {
+								
+								lines.forEachOrdered(line -> process(line, type, LOGTYPE.DEBUG));
+
+							} catch (IOException e) {
+								logger.error("Error processing line in " + dataFileName + ":" + e);
+								logger.error("break the loop.");
+								isStop = true;
+							}	
+						}
+						try {
+							Thread.sleep(sleepTimer);
+							debugStartFileSize =  countLines(debuglogFile);
+						} catch (InterruptedException | IOException e) {
+							logger.error("Error processing line in " + dataFileName + ":" + e);
+							logger.error("break the loop.");
+							isStop = true;
+						}
 						
-						lines.forEachOrdered(line -> process(line, type));
-		
-					} catch (IOException e) {
-						logger.error("Error processing line in log file: " + e);
+						logger.debug("File Line Count of debug.log: " + debugStartFileSize + " value read in: " + debuglastNumberRead);
+						if (debugStartFileSize < debuglastNumberRead ){
+							logger.debug("Failed Rolled: set Last number read to 0");
+							debuglastNumberRead = 0;
+						}
 					}	
 				}
-				try {
-					Thread.sleep(sleepTimer);
-					startFileSize =  countLines(logFile);
-				} catch (InterruptedException | IOException e) {
-					logger.error("Error: " + e);
-				}
+			};
+			
+			Thread thread = new Thread(runnable);
+			thread.start();
+			
+		} 	
+	}
+
+	private static void startErrorLogParser(File fileLog) throws Exception{
+		
+		if(errorlogFile != null && !errorlogFile.isEmpty()){
+			
+			// pull the last line number 
+			String dataFileName = "error.log";
+			String filesRead = PullLastLineRead(fileLog, dataFileName);  
+			if (filesRead!= null){			
+				filesRead = filesRead.replaceAll("(\\r\\n|\\n)", "<br />");
+				errorlastNumberRead= Integer.parseInt(filesRead.trim());
+			}else{
+				errorlastNumberRead = 0;
+			}	
+			
+			errorStartFileSize =  countLines(errorlogFile);
+			if (errorStartFileSize < errorlastNumberRead ){
+				logger.error("Filed Rolled: set Last error number read to 0");
+				errorlastNumberRead = 0;
+			}
+			
+			isMissingLogFile = false;			
+			Path errorfilePath = Paths.get(errorlogFile);
+			File errorfile = new File(errorlogFile);
+			errorStartFileSize = errorfile.length();
+			// start process error.log file
+			Runnable  runnable = new Runnable (){
+				boolean isStop = false;
+				public void run(){
+                    
+					while (!isStop){
+						if (errorfile.isFile()){
+							// log4jlogger must use .info
+							try (Stream<String> lines = Files.lines(errorfilePath, Charset.defaultCharset()).onClose(() -> log4jlogger.info("Last-"+dataFileName+"-line-Read:" + errorlastNumberRead)).skip(errorlastNumberRead)) {
+								
+								lines.forEachOrdered(line -> process(line, type, LOGTYPE.ERROR));
 				
-				logger.info("File Line Count: " + startFileSize + " value read in: " + lastNumberRead);
-				if (startFileSize < lastNumberRead ){
-					logger.info("Failed Rolled: set Last number read to 0");
-					lastNumberRead = 0;
+							} catch (IOException e) {
+								logger.error("Error processing line in " + dataFileName + ":" + e);
+								logger.error("break the loop.");
+								isStop = true;
+							}	
+						}
+						try {
+							Thread.sleep(sleepTimer);
+							errorStartFileSize =  countLines(errorlogFile);
+						} catch (InterruptedException | IOException e) {
+							logger.error("Error processing line in " + dataFileName + ":" + e);
+							logger.error("break the loop.");
+							isStop = true;
+						}
+						
+						logger.debug("File Line Count of error.log: " + errorStartFileSize + " value read in: " + errorlastNumberRead);
+						if (errorStartFileSize < errorlastNumberRead ){
+							logger.debug("Failed Rolled: set Last error number read to 0");
+							errorlastNumberRead = 0;
+						}
+					}	
 				}
-			}	
-		}
-		};
+			};
+			
+			Thread thread = new Thread(runnable);
+			thread.start();
+		}		
+	}
+	
+	private static void startAPIRestLogParser(File fileLog) throws Exception{
 		
-		Thread thread = new Thread(runnable);
-		thread.start();
-
-	}			
-
+		if(logFile != null && !logFile.isEmpty()){
+			
+			// pull the last line number 
+			String dataFileName = type.toLowerCase()+"-rest.log";
+			String filesRead = PullLastLineRead(fileLog, dataFileName);  
+			if (filesRead!= null){			
+				filesRead = filesRead.replaceAll("(\\r\\n|\\n)", "<br />");
+				lastNumberRead= Integer.parseInt(filesRead.trim());
+			}else{
+				lastNumberRead = 0;
+			}			
+			startFileSize =  countLines(logFile);
+			if (startFileSize < lastNumberRead ){
+				logger.error("Filed Rolled: set Last number read to 0");
+				lastNumberRead = 0;
+			}
+			
+			isMissingLogFile = false;
+	        Path filePath = Paths.get(logFile);
+	        File file = new File(logFile);		
+			startFileSize = file.length();
+			// start process pap/pdp-rest.log file
+			Runnable  runnable = new Runnable () {
+				boolean isStop = false;
+				public void run(){
+					while (!isStop){		
+						
+						if (file.isFile()){
+							// log4jlogger must use .info
+							try (Stream<String> lines = Files.lines(filePath, Charset.defaultCharset()).onClose(() -> log4jlogger.info("Last-"+dataFileName+"-line-Read:" + lastNumberRead)).skip(lastNumberRead)) {
+								
+								lines.forEachOrdered(line -> process(line, type, LOGTYPE.INFO));
+				
+							} catch (IOException e) {
+								logger.error("Error processing line in " + dataFileName + ":" + e);
+								logger.error("break the loop.");
+								isStop = true;
+							}	
+						}
+						try {
+							Thread.sleep(sleepTimer);
+							startFileSize =  countLines(logFile);
+						} catch (InterruptedException | IOException e) {
+							logger.error("Error processing line in " + dataFileName + ":" + e);
+							logger.error("break the loop.");
+							isStop = true;
+						}
+						
+						logger.debug("File Line Count of " + dataFileName+": " + startFileSize + " value read in: " + lastNumberRead);
+						if (startFileSize < lastNumberRead ){
+							logger.debug("Failed Rolled: set Last number read to 0");
+							lastNumberRead = 0;
+						}
+					}	
+				}
+			};
+				
+			Thread thread = new Thread(runnable);
+			thread.start();
+		}		
+	}
+	
 	public static int countLines(String filename) throws IOException {
 	    LineNumberReader reader  = new LineNumberReader(new FileReader(filename));
 	    int cnt = 0;
-	    while ((reader.readLine()) != null);
+	    String line= null;
+	    while ((line = reader.readLine()) != null) {
+	    	logger.info("Reading the Logs"+line);
+	    }
 	    cnt = reader.getLineNumber(); 
 	    reader.close();
 	    return cnt;
 	}	
 	
-	public static String PullLastLineRead(File file) throws IOException {
+	public static String PullLastLineRead(File file, String dataFileName) throws IOException {
 		if(!file.exists()){
 			file.createNewFile();
 			return null;
@@ -158,38 +324,48 @@ public class ParseLog {
 		randomAccessFile = new RandomAccessFile(file, "r");
         StringBuilder builder = new StringBuilder();
         long length = file.length();
-        length--;
-        randomAccessFile.seek(length);
-        for(long seek = length; seek >= 0; --seek){
-            randomAccessFile.seek(seek);
-            char c = (char)randomAccessFile.read();
-            builder.append(c);
-            if(c == '\n'){
-                builder = builder.reverse();
-                if (builder.toString().contains("Last line Read:")){
-            		String[] parseString = builder.toString().split("Last line Read:");
-            		String returnValue = parseString[1].replace("\r", "");
-            		return returnValue.trim();
-            	}
-                builder = null;
-                builder = new StringBuilder();
-             }
-
+        logger.debug("dataFileName: " +dataFileName);
+        if(length > 0){
+	        length--;	        
+	        randomAccessFile.seek(length);
+	        for(long seek = length; seek >= 0; --seek){
+	            randomAccessFile.seek(seek);
+	            char c = (char)randomAccessFile.read();
+	            builder.append(c);
+	            if(c == '\n'){
+	                builder = builder.reverse();
+	                logger.debug("builder.toString(): " +builder.toString());
+	                if (builder.toString().contains("Last-"+dataFileName+"-line-Read:")){
+	            		String[] parseString = builder.toString().split("Last-"+dataFileName+"-line-Read:");
+	            		String returnValue = parseString[1].replace("\r", "");
+	            		return returnValue.trim();
+	            	}
+	                builder = null;
+	                builder = new StringBuilder();
+	             }	
+	        }
         }
+        
 		return null;
 	}
 
 	public static LogEntryObject pullOutLogValues(String line, String type){
 		Date date;
 		LogEntryObject logEntry = new LogEntryObject();
+		String description = "";
 		logEntry.setSystemType(type);
-		String description = null;
-		
 		logEntry.setSystem(system);
-		
-		//Values for PDP/PAP log file
-		if(line.contains("||INFO||") || line.contains("||ERROR||")){
-			String[] splitString = line.split("[||]");
+		logger.debug("In pullOutLogValues ...");
+		//Values for PDP/PAP debug.log file contains "INFO:", error.log file contains ""ERROR:", others are in PDP/PAP rest log file
+		if(line.contains("||INFO||") || line.contains("||ERROR||") || line.contains("INFO:") || line.contains("ERROR:")){
+			String[] splitString = null;
+			if(line.contains("||INFO||") || line.contains("||ERROR||")){
+				splitString = line.split("[||]");
+			}else if(line.contains("INFO:")){
+				splitString = line.split("INFO:");
+			}else{
+				splitString = line.split("ERROR:");
+			}
 			String dateString = splitString[0].substring(0, 19);
 			logEntry.setDescription(splitString[splitString.length-1]);	
 
@@ -198,12 +374,13 @@ public class ParseLog {
 			logEntry.setDate(date);
 			
 			logEntry.setRemote(parseRemoteSystem(line));
-			if (line.contains("||INFO||")){
+			if (line.contains("INFO:") || line.contains("||INFO||")){
 				logEntry.setLogType(LOGTYPE.INFO);
 			}else{
 				logEntry.setLogType(LOGTYPE.ERROR);
-			}		
-		}else if (line.contains("INFO") && line.contains(")-")){
+			}
+           // from PDP/PAP rest log file below
+		}else if (line.contains("INFO") && line.contains(")-")){ 
 			//parse out description
 			logEntry.setDescription(line.substring(line.indexOf(")-")+3));
 
@@ -272,8 +449,7 @@ public class ParseLog {
 			logEntry.setLogType(LOGTYPE.ERROR);
 		}else {
 			return null;
-		}
-		
+		}		
 
 		return logEntry;
 	}
@@ -287,20 +463,28 @@ public class ParseLog {
 		}
 	}
 
-	public static void process(String line, String type)  {
+	public static void process(String line, String type, LOGTYPE logFile)  {
+		
+		logger.debug("In process: processing line : " + line);
 		LogEntryObject returnLogValue = null;
 		if (im!=null){
 			try {
 				im.startTransaction();
 			} catch (AdministrativeStateException e) {
-				logger.error("Error received" + e);
-				
+				logger.error("Error received" + e);				
 			} catch (StandbyStatusException e) {
 				logger.error("Error received" + e);
 			}
 		}
 		returnLogValue = pullOutLogValues(line, type);
-		lastNumberRead++;
+		
+		if(logFile.equals(LOGTYPE.DEBUG)){
+		   debuglastNumberRead++;
+		}else if(logFile.equals(LOGTYPE.ERROR)){
+		   errorlastNumberRead++;
+		}else if(logFile.equals(LOGTYPE.INFO)){
+		   lastNumberRead++;
+		}
 		if (returnLogValue!=null){
 			writeDB(returnLogValue);
 		}
@@ -310,6 +494,7 @@ public class ParseLog {
 	}
 	
 	private static void writeDB(LogEntryObject returnLogValue) {
+
 		Connection conn = DBConnection(JDBC_DRIVER, JDBC_URL, JDBC_USER,JDBC_PASSWORD);
 		DBAccesss(conn, returnLogValue.getSystem(), returnLogValue.getDescription(),  
 						returnLogValue.getDate(), returnLogValue.getRemote(), 
@@ -334,7 +519,10 @@ public class ParseLog {
 		
 		if (date!=null){
 			Format formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-			sdate = formatter.format(date);		
+			sdate = formatter.format(date);	
+			logger.debug("DBAccesss : sdate : " + sdate);
+		}else{
+			logger.debug("DBAccesss : sdate is null");
 		}
 		
 		//ensure the length of description is less than the maximumm db char length
@@ -399,11 +587,26 @@ public class ParseLog {
 		return null;
 	}
 	
+	public static String[] getPaths(String logPath){	
+		
+		if(logPath != null && !logPath.isEmpty()){
+			if(logPath.contains(";")){
+		       return logPath.split(";");
+			}else{
+				 String[] oneFile = new String[1];
+				 oneFile[0] = logPath;
+				 return oneFile;
+			}
+		}
+		
+	    return null;	
+	}
+	
 	public static Properties getPropertiesValue(String fileName) {
 		Properties config = new Properties();
 		Path file = Paths.get(fileName);
 		if (Files.notExists(file)) {
-			logger.info("File doesn't exist in the specified Path "	+ file.toString());
+			logger.debug("File doesn't exist in the specified Path "	+ file.toString());
 		}else{ 
 			if (file.toString().endsWith(".properties")) {
 				InputStream in;
@@ -415,7 +618,44 @@ public class ParseLog {
 					system = config.getProperty("SERVER");
 					type = config.getProperty("LOGTYPE");
 					systemLogFile = config.getProperty("PARSERLOGPATH");
-					logFile = config.getProperty("LOGPATH");
+					String logFiles = config.getProperty("LOGPATH");
+					if(logFiles == null || logFiles.isEmpty()){
+						isMissingLogFile = true;
+						return null;
+					}
+					
+					String[] splitString = getPaths(logFiles);
+					
+					if(splitString != null){
+                        for(int i=0;  i < splitString.length; i++){
+                        	
+                        	if(splitString[i].contains("debug")){
+        						// get path of debug.log file
+        						debuglogFile = splitString[i];
+        						if(debuglogFile != null && !debuglogFile.isEmpty()){
+        							debuglogFile = debuglogFile.trim();
+        						}
+                        	}else if(splitString[i].contains("error")){
+        						// get path of error.log file
+        						errorlogFile = splitString[i];
+        						if(errorlogFile != null && !errorlogFile.isEmpty()){
+        							errorlogFile = errorlogFile.trim();
+        						}
+                        	}else {
+        						// get path of default file
+                        		logFile = splitString[i];
+        						if(logFile != null && !logFile.isEmpty()){
+        							logFile = logFile.trim();
+        						}
+                        	}
+                        }
+					}else{	
+						
+						debuglogFile = null;
+						errorlogFile = null;
+						logFile = null;
+					}
+					
 					JDBC_URL = config.getProperty("JDBC_URL").replace("'", "");
 					JDBC_USER = config.getProperty("JDBC_USER");
 					JDBC_DRIVER =  config.getProperty("JDBC_DRIVER");
@@ -423,11 +663,11 @@ public class ParseLog {
 					return config;
 
 				} catch (IOException e) {					
-					logger.info("Error porcessing Cofnig file will be unable to create Health Check");
+					logger.debug("Error porcessing Config file will be unable to create Health Check" + e);
 				}
 				
 			}
 		}
 		return null;
 	}	
-}
+}
\ No newline at end of file
diff --git a/LogParser/src/test/java/org/openecomp/xacml/parser/ParseLogTest.java b/LogParser/src/test/java/org/openecomp/xacml/parser/ParseLogTest.java
index 621f39742..2bd70f2be 100644
--- a/LogParser/src/test/java/org/openecomp/xacml/parser/ParseLogTest.java
+++ b/LogParser/src/test/java/org/openecomp/xacml/parser/ParseLogTest.java
@@ -21,6 +21,7 @@
 package org.openecomp.xacml.parser;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import java.io.BufferedReader;
@@ -38,15 +39,19 @@ import org.mockito.Mockito;
 import org.openecomp.policy.common.im.AdministrativeStateException;
 import org.openecomp.policy.common.im.IntegrityMonitor;
 import org.openecomp.policy.common.im.StandbyStatusException;
+import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
+import org.openecomp.policy.common.logging.flexlogger.Logger;
 import org.openecomp.xacml.parser.LogEntryObject.LOGTYPE;
 
 
 public class ParseLogTest {
-
+	
+	private static Logger logger = FlexLogger.getLogger(ParseLogTest.class);
 	private Properties config = new Properties();
-	private String configFile = "test_config.properties";
+	private String configFile;
+	private String testFile1;
+	private String testFile2;
 	private IntegrityMonitor im;
-
 	
 	@Before
 	public void setUp() throws Exception {
@@ -59,41 +64,56 @@ public class ParseLogTest {
 			fail();
 		}
 		Mockito.doNothing().when(im).endTransaction();
-
+		ClassLoader classLoader = getClass().getClassLoader();
+		configFile = classLoader.getResource("test_config.properties").getFile();
+		if(configFile.startsWith("/C:/")){
+			configFile = configFile.substring(1);
+		}
+		testFile1 = classLoader.getResource("LineTest.txt").getFile();
+		testFile2 = classLoader.getResource("LineTest2.txt").getFile();
+		
 	}
 
 	@After
 	public void tearDown() {
+		
+		logger.debug("tearDown: enter");
+		
 		File file = new File("nonExistFile.txt");
 		file.delete();
-	}
-
-	//@Test
-	public void testMain() {
-		try {	
-			ParseLog.main(null);
-		} catch (Exception e) {
-			fail();
-		}
+		logger.debug("tearDown: exit");
 	}
 
 	@Test
 	public void testCountLines() throws IOException {
-		String fileName = "LineTest.txt";
-		int returnValue = ParseLog.countLines(fileName);
 		
-		assertEquals(9, returnValue);
+		logger.debug("testCountLines: enter");
+		
+		int returnValue = ParseLog.countLines(testFile1);
+		logger.debug("testCountLines: returnValue: " + returnValue);
+		assertEquals(12, returnValue);
+		
+		logger.debug("testCountLines: exit");
 	}
-	
+
 	@Test
 	public void testParseRemoteSystem() {
+		
+		logger.debug("testParseRemoteSystem: enter");
+		
 		String line = "||org.openecomp.policy.pap.xacml.rest.XACMLPapServlet$Heartbeat.run(XACMLPapServlet.java:2801)||Heartbeat 'https://localhost:8081/pdp/' status='UP_TO_DATE'";
 		String returnValue = ParseLog.parseRemoteSystem(line);
+		logger.debug("testParseRemoteSystem: returnValue: " + returnValue);
 		assertEquals("localhost:8081", returnValue);
+		
+		logger.debug("testParseRemoteSystem: exit");
 	}
 
 	@Test
 	public void testGetPropertiesValue() {
+		
+		logger.debug("testGetPropertiesValue: enter");
+		
 		config = new Properties();
 		config.put("RESOURCE_NAME", "logparser_pap01");
 		config.put("JDBC_DRIVER" ,"com.mysql.jdbc.Driver");
@@ -108,76 +128,123 @@ public class ParseLogTest {
 		config.put("PARSERLOGPATH", "IntegrityMonitor.log");
 		
 		Properties returnConfig = ParseLog.getPropertiesValue(configFile);
-
-		
+		logger.debug("testGetPropertiesValue: returnConfig: " + returnConfig);
 		assertEquals(config.get("RESOURCE_NAME"), returnConfig.get("RESOURCE_NAME"));	
+		
+		logger.debug("testGetPropertiesValue: exit");
 	}
-	
+
 	@Test
 	public void testGetPropertiesFail() {	
-		Properties returnValue = ParseLog.getPropertiesValue("nonExistFile");
 		
+		logger.debug("testGetPropertiesFail: enter");
+		
+		Properties returnValue = ParseLog.getPropertiesValue("nonExistFile");
+		logger.debug("testGetPropertiesFail: returnValue: " + returnValue);
 		assertEquals(null, returnValue);	
+		
+		logger.debug("testGetPropertiesFail: exit");
 	}
 
 	@Test
 	public  void  testParseDate(){
+		
+		logger.debug("testParseDate: enter");
+		
 		String line = "2016-02-23 08:07:30";
 		Date returnValue = ParseLog.parseDate(line, "yyyy-MM-dd HH:mm:ss", false);
+		logger.debug("testParseDate: returnValue: " + returnValue);
 		line = returnValue.toString().substring(0, returnValue.toString().lastIndexOf(":30")+3);
 		assertEquals("Tue Feb 23 08:07:30", line);
+		
+		logger.debug("testParseDate: exit");
 	}
-	
+
 	@Test
 	public  void  testParseDateFail(){
+		
+		logger.debug("testParseDateFail: enter");
+		
 		String line = "2016-02-23 08:07:30";
 		Date returnValue = ParseLog.parseDate(line, "yyyy-MM-dd HH:mm:ss", true);
-		
+		logger.debug("testParseDateFail: returnValue: " + returnValue);
 		assertEquals(null, returnValue);
+		
+		logger.debug("testParseDateFail: exit");
 	}
-	
+
 	@Test
 	public void testPullLastLineRead(){
 		
-		File file = new File("LineTest.txt");
+		logger.debug("testPullLastLineRead: enter");
+		File file = new File(testFile1);
 		String returnValue = null;
 		try {
-			returnValue = ParseLog.PullLastLineRead(file).trim();
+			returnValue = ParseLog.PullLastLineRead(file, "pap-rest.log");
+			logger.debug("testPullLastLineRead: returnValue for pap-rest.log: " + returnValue);
+		} catch (IOException e) {
+			fail();
+		}		
+		assertEquals("52", returnValue);
+		
+		try {
+			returnValue = ParseLog.PullLastLineRead(file, "debug.log");
+			logger.debug("testPullLastLineRead: returnValue for debug.log: " + returnValue);
 		} catch (IOException e) {
 			fail();
 		}		
-		assertEquals("12", returnValue);
+		assertEquals("17", returnValue);
+		
+		try {
+			returnValue = ParseLog.PullLastLineRead(file, "error.log");
+			logger.debug("testPullLastLineRead: returnValue for error.log: " + returnValue);
+		} catch (IOException e) {
+			fail();
+		}		
+		assertEquals("22", returnValue);
 
+		logger.debug("testPullLastLineRead: exit");
 	}
-	
+
 	@Test
 	public void testPullLastLineReadNoFile(){
 		
+		logger.debug("testPullLastLineReadNoFile: enter");
+		
 		File file = new File("nonExistFile.txt");
 		try {
-			assertEquals(null, ParseLog.PullLastLineRead(file));
+			assertEquals(null, ParseLog.PullLastLineRead(file, "pap-rest"));
 		} catch (IOException e) {
 			fail();
 		}
+		
+		logger.debug("testPullLastLineReadNoFile: exit");
 	}
+
 	@Test
 	public void testPullLastLineReadFail(){
 		
-		File file = new File("LineTest2.txt");
+		logger.debug("testPullLastLineReadFail: enter");
+		
+		File file = new File(testFile2);
 		try {
-			assertEquals(null, ParseLog.PullLastLineRead(file));
+			assertEquals(null, ParseLog.PullLastLineRead(file, "pap-rest"));
 		} catch (IOException e) {
 			fail();
 		}
+		
+		logger.debug("testPullLastLineReadFail: exit");
 	}
 
 	@Test
 	public void testPullOutLogValues(){
+		
+		logger.debug("testPullOutLogValues: enter");
 		//ERROR_VALUE
 		// Open the file
 		FileInputStream fstream;
 		try {
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			LogEntryObject retrunObject = ParseLog.pullOutLogValues(strLine, "ERROR");
@@ -186,15 +253,47 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
-//		assert(true);
+
+		logger.debug("testPullOutLogValues: exit");
 	}
+	
+	@Test
+	public void testGetPaths(){
+		
+		logger.debug("testGetPaths: enter");
+		
+		try {
+			// valid test
+			String logPaths = "C:\\pap-log\\pap-rest.log;C:\\pap-log\\debug.log;C:\\pap-log\\error.log";
+			String [] retrunObject = ParseLog.getPaths(logPaths);
+			assertEquals(3, retrunObject.length);
+			
+			// valid test
+			logPaths = "C:\\pap-log\\pap-rest.log";
+			retrunObject = ParseLog.getPaths(logPaths);
+			assertEquals(1, retrunObject.length);
+			
+			// invalid test
+			logPaths = "";
+			retrunObject = ParseLog.getPaths(logPaths);
+			assertTrue(retrunObject == null);
+
+		} catch (Exception e) {
+			fail();
+		}	
+
+		logger.debug("testGetPaths: exit");
+	}	
+
 	@Test
 	public void testPullOutLogValuesSecond(){
+		
+		logger.debug("testPullOutLogValuesSecond: enter");
 		//ERROR_VALUE
 		// Open the file
 		FileInputStream fstream;
 		try {
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			strLine = br.readLine();
@@ -204,16 +303,20 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesSecond: exit");
 	}
-	
+
 	@Test
 	public void testPullOutLogValuesThird(){
+		
+		logger.debug("testPullOutLogValuesThird: enter");
 		//ERROR_VALUE
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 3;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -225,15 +328,19 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesThird: exit");
 	}
 
 	@Test
 	public void testPullOutLogValuesFourth(){
+		
+		logger.debug("testPullOutLogValuesFourth: enter");
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 4;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -245,15 +352,19 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesFourth: exit");
 	}
-	
+
 	@Test
 	public void testPullOutLogValuesFith(){
+		
+		logger.debug("testPullOutLogValuesFith: enter");
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 5;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -265,15 +376,19 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesFith: exit");
 	}
-	
+
 	@Test
 	public void testPullOutLogValuesSixth(){
+		
+		logger.debug("testPullOutLogValuesSixth: enter");
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 6;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -285,15 +400,19 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesSixth: exit");
 	}
 
 	@Test
 	public void testPullOutLogValuesSeven(){
+		
+		logger.debug("testPullOutLogValuesSeven: enter");
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 7;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -305,15 +424,19 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesSeven: exit");
 	}
-	
+
 	@Test
 	public void testPullOutLogValuesEight(){
+		
+		logger.debug("testPullOutLogValuesEight: enter");
 		// Open the file
 		FileInputStream fstream;
 		try {
 			int number = 8;
-			fstream = new FileInputStream("LineTest.txt");
+			fstream = new FileInputStream(testFile1);
 			BufferedReader br = new BufferedReader(new InputStreamReader(fstream));
 			String strLine = br.readLine();
 			for (int i =0; i < number; i++){
@@ -325,17 +448,26 @@ public class ParseLogTest {
 		} catch (IOException e) {
 			fail();
 		}	
+		
+		logger.debug("testPullOutLogValuesEight: exit");
 	}
-	
+
 	@Test
 	public void testPullOutLogValuesNull(){
+		
+		logger.debug("testPullOutLogValuesNull: enter");
 		// Open the file
 		LogEntryObject retrunObject = ParseLog.pullOutLogValues("", "Console");
 		assertEquals(null, retrunObject);
+		
+		logger.debug("testPullOutLogValuesNull: exit");
 	}
-	
+
 	@Test
 	public void testLogEntryObject(){
+		
+		logger.debug("testLogEntryObject: enter");
+		
 		Date date = new Date();
 	 
 		// Open the file
@@ -349,10 +481,15 @@ public class ParseLogTest {
 		assertEquals("pap", logObject.getSystemType());
 		assertEquals(date, logObject.getDate());
 		assertEquals("remote", logObject.getRemote());
+		
+		logger.debug("testLogEntryObject: exit");
 	}
 
 	@Test
 	public void testProcess(){
+		
+		logger.debug("testProcess: enter");
+		
 		String line = "2015-04-01 09:13:44.947  DEBUG 17482 --- [nio-8480-exec-7] c.a.l.ecomp.policy.std.StdPolicyConfig   : config Retrieved ";
 	
 		im = Mockito.mock(IntegrityMonitor.class);
@@ -362,6 +499,8 @@ public class ParseLogTest {
 			fail();
 		}
 		Mockito.doNothing().when(im).endTransaction();
-		ParseLog.process(line, "pap");
+		ParseLog.process(line, "pap", LOGTYPE.INFO);
+		
+		logger.debug("testProcess: exit");
 	}
 }
\ No newline at end of file
diff --git a/LogParser/LineTest.txt b/LogParser/src/test/resources/LineTest.txt
index 449644219..32ec6cb0e 100644
--- a/LogParser/LineTest.txt
+++ b/LogParser/src/test/resources/LineTest.txt
@@ -6,4 +6,7 @@
 08-Apr-2015 10:31:26.503 WARNING [localhost-startStop-2] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [PyPDPServer] appears to have started a thread named [Grizzly(1) SelectorRunner] but has failed to stop it. This is very likely to create a memory leak. service Catalina08-Apr-2015 10:31:26.503 WARNING [localhost-startStop-2] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [PyPDPServer] appears to have started a thread named [Grizzly(1) SelectorRunner] but has failed to stop it. This is very likely to create a memory leak. 
 06-Mar-2015 11:50:06.243 SEVERE [main] org.apache.coyote.AbstractProtocol.init Failed to initialize end point associated with ProtocolHandler ["ajp-nio-8009"] java.net.BindException: Address already in use
 2015_09_30_10_39_31_675 [http-nio-8081-exec-1] ERROR org.openecomp.research.xacml.rest.XACMLPdpServlet.doPost(XACMLPdpServlet.java:644)- PE100 - Permissions Error: PEP not Authorized for making this Request!! 
-2015_03_17_15_01_08_348 [qtp1688376486-32] WARN  org.openecomp.research.xacml.admin.components.PolicyManagement$1.accept(PolicyManagement.java:184)- Filtering out: C:\git\D2PE-take2\policy-engine-prototype\XACML-PAP-ADMIN\workspace\admin\repository\com\.svnignore
\ No newline at end of file
+2015_03_17_15_01_08_348 [qtp1688376486-32] WARN  org.openecomp.research.xacml.admin.components.PolicyManagement$1.accept(PolicyManagement.java:184)- Filtering out: C:\git\D2PE-take2\policy-engine-prototype\XACML-PAP-ADMIN\workspace\admin\repository\com\.svnignore
+2017-05-31T22:18:42{GMT+0}+00:00|||Thread-4||||INFO|||||org.openecomp.xacml.parser.ParseLog$1.lambda$0(ParseLog.java:136)||Last-debug.log-line-Read:17
+2017-05-31T22:18:42{GMT+0}+00:00|||Thread-5||||INFO|||||org.openecomp.xacml.parser.ParseLog$2.lambda$0(ParseLog.java:194)||Last-error.log-line-Read:22
+2017-05-31T22:18:42{GMT+0}+00:00|||Thread-6||||INFO|||||org.openecomp.xacml.parser.ParseLog$3.lambda$0(ParseLog.java:250)||Last-pap-rest.log-line-Read:52
\ No newline at end of file
diff --git a/LogParser/LineTest2.txt b/LogParser/src/test/resources/LineTest2.txt
index 2243960df..2243960df 100644
--- a/LogParser/LineTest2.txt
+++ b/LogParser/src/test/resources/LineTest2.txt
diff --git a/LogParser/test_config.properties b/LogParser/src/test/resources/test_config.properties
index 5a6a460ba..6512184c8 100644
--- a/LogParser/test_config.properties
+++ b/LogParser/src/test/resources/test_config.properties
@@ -27,5 +27,5 @@ JDBC_PASSWORD=password
 jmx_url=service:jmx:rmi:///jndi/rmi://localhost:9996/jmxrmi
 SERVER=https://localhost:9091/pap/
 LOGTYPE=PAP
-LOGPATH=C:\\Workspaces\\HealthCheck\\pap-rest.log
+LOGPATH=/Workspaces/HealthCheck/pap-rest.log
 PARSERLOGPATH=IntegrityMonitor.log