Merge branch 'add_test' into 'main'

Add tests

See merge request trangtd2/cs425_mp1!5

.gitignore

@@ -2,3 +2,4 @@
 *.iml
 out/*
 *.DS_Store
+files/generated_log/*

files/bash/run_jars.sh

+#!/bin/bash
+
+upperlim=10
+
+for ((i=1; i<=upperlim; i++)); do
+        echo "Running Server jars file in VM $i"
+        if [ "$i" -lt 10 ]; then
+          ssh maitp2@fa22-cs425-520$i.cs.illinois.edu 'java -jar /home/maitp2/grep_server.jar -p 5000'
+        else
+          ssh maitp2@fa22-cs425-52$i.cs.illinois.edu 'java -jar /home/maitp2/grep_server.jar -p 5000'
+        fi
+        sleep 3s
+        logout
+done
\ No newline at end of file

files/bash/send_jars.sh

+#!/bin/bash
+# This bash will send Client and server jars files to all VMs
+upperlim=10
+
+for ((i=1; i<=upperlim; i++)); do
+        echo "Sending jar file to VM $i"
+        if [ "$i" -lt 10 ]; then
+          scp /home/maipham/uiuc/cs425/mp1/grep/out/artifacts/grep_server_jar/grep_server.jar maitp2@fa22-cs425-520$i.cs.illinois.edu:/home/maitp2/
+        else
+          scp /home/maipham/uiuc/cs425/mp1/grep/out/artifacts/grep_server_jar/grep_server.jar maitp2@fa22-cs425-52$i.cs.illinois.edu:/home/maitp2/
+        fi
+done
\ No newline at end of file

files/config.txt

-localhost 5001 /home/maipham/uiuc/cs425/mp1/grep/files/test.log
\ No newline at end of file
+fa22-cs425-5201.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5202.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5203.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5204.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5205.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5206.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5207.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5208.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5209.cs.illinois.edu 5000 /home/maitp2/generated_log.log
+fa22-cs425-5210.cs.illinois.edu 5000 /home/maitp2/generated_log.log
\ No newline at end of file

files/configTest.txt

+localhost 5001 /home/maipham/uiuc/cs425/mp1/grep/files/generated_log/test1.log
\ No newline at end of file

pom.xml

@@ -31,14 +31,9 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.apache.logging.log4j</groupId>
-            <artifactId>log4j-api</artifactId>
-            <version>2.18.0</version>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.logging.log4j</groupId>
-            <artifactId>log4j-core</artifactId>
-            <version>2.18.0</version>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>2.0.0</version>
         </dependency>
     </dependencies>
     

src/main/java/META-INF/MANIFEST.MF

 Manifest-Version: 1.0
-Main-Class: cs425.mp1.Client
+Main-Class: cs425.mp1.Main
 

src/main/java/cs425/mp1/Client.java

@@ -5,10 +5,7 @@ import net.sourceforge.argparse4j.inf.ArgumentParser;
 import net.sourceforge.argparse4j.inf.ArgumentParserException;
 import net.sourceforge.argparse4j.inf.Namespace;
 
-import java.io.BufferedReader;
-import java.io.FileReader;
 import java.io.IOException;
-import java.util.ArrayList;
 
 public class Client {
     public static void main(String[] args) throws IOException {
@@ -33,9 +30,9 @@ public class Client {
         }
 
         /* Read config file */
-        String filePath = ns.getString("configFile");
+        String configFile = ns.getString("configFile");
         String pattern = String.join(" ", ns.getList("command"));
-        ClientHandler.init(filePath, pattern);
+        ClientHandler.start(configFile, pattern);
 
     }
 }

src/main/java/cs425/mp1/ClientHandler.java

@@ -6,9 +6,9 @@ import java.io.IOException;
 import java.util.ArrayList;
 
 public class ClientHandler {
-    public static void init(String filePath, String pattern) throws IOException {
-        /* Read server hosts, ports, and log files */
-        FileReader file = new FileReader(filePath);
+    public static String start(String confFile, String grepCommand) throws IOException {
+        /* Read server hosts, ports, and log files from config files */
+        FileReader file = new FileReader(confFile);
         ArrayList<ServerConf> servers = new ArrayList<>();
         String line;
         BufferedReader reader = new BufferedReader(file);
@@ -31,20 +31,24 @@ public class ClientHandler {
         Creating threads based on number of servers
          */
         int n = servers.size();
-        ArrayList<GrepThread> threads = new ArrayList<>(n);
+        StringBuilder result = new StringBuilder();
+        ArrayList<JobThread> threads = new ArrayList<>(n);
         for (int i = 0; i < n; i++) {
-            GrepThread t = new GrepThread(servers.get(i), pattern);
+            JobThread t = new JobThread(servers.get(i), grepCommand);
             threads.add(t);
             t.start();
         }
 
         /* End threads */
-        for (GrepThread t: threads) {
+        for (JobThread t: threads) {
             try {
                 t.join();
+                result.append(t.getResult()).append("\n");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
+
+        return result.toString();
     }
 }

src/main/java/cs425/mp1/Constant.java

+package cs425.mp1;
+
+public class Constant {
+    public static final String SUCCESS_CREATE_LOG = "SUCCESSFUL CREATE LOG";
+    public static final String ERROR_CREATE_LOG = "FAIL TO CREATE LOG FILE";
+    public static final String LOG_FILE_DOES_NOT_EXIST = "LOG FILE DOES NOT EXIST";
+}

src/main/java/cs425/mp1/GenLog.java

+package cs425.mp1;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Random;
+
+public class GenLog {
+    public static String generate_logs(String file) {
+        String knownLines =
+                "Error: This is error 1 in log file\n" +
+                        "Error: This is error 2 in log file";
+
+        try {
+            FileWriter myWriter = new FileWriter(file);
+//            int numLines = (int) (Math.random() * (100 + 1));
+            int numLines = 600000;
+            for (int l = 0; l < numLines; l++) {
+                int leftLimit = 32;
+                int rightLimit = 126;
+                int strLen = (int) (Math.random() * (200 + 1));
+                Random random = new Random();
+                StringBuilder buffer = new StringBuilder(strLen);
+
+                for (int i = 0; i < strLen; i++) {
+                    int randomLimitedInt = leftLimit + (int)
+                            (random.nextFloat() * (rightLimit - leftLimit + 1));
+                    buffer.append((char) randomLimitedInt);
+                }
+                String generatedString = buffer.toString();
+                myWriter.write(generatedString + "\n");
+            }
+
+            myWriter.write(knownLines);
+
+            myWriter.close();
+        } catch (IOException e) {
+            return Constant.ERROR_CREATE_LOG;
+        }
+
+        return Constant.SUCCESS_CREATE_LOG;
+    }
+}

src/main/java/cs425/mp1/GrepThread.java → src/main/java/cs425/mp1/JobThread.java

@@ -5,15 +5,23 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.Socket;
 
-public class GrepThread extends Thread{
+/**
+ * This class is run by server to create log or running thread command
+ */
+public class JobThread extends Thread{
     private final ServerConf server;
     private final String pattern;
+    private String result = "";
 
-    public GrepThread(ServerConf server, String pattern){
+    public JobThread(ServerConf server, String pattern){
         this.server = server;
         this.pattern = pattern;
     }
 
+    public String getResult() {
+        return result;
+    }
+
     @Override
     public void run() {
         try {
@@ -29,16 +37,25 @@ public class GrepThread extends Thread{
              */
             ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
             outputStream.writeObject(pattern + " " + logFile);
-            System.out.println("Connected to server. Running grep job...");
+            System.out.println("Connected to server. Running job...");
 
             /*
             Get input from servers and display results of query
              */
             ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
+
+            /*
+            2 cases: case 1 is generating log, case 2 is grep command
+             */
             String output = (String) inputStream.readObject();
             System.out.println("-----------------------------");
             System.out.println(output);
-            System.out.println("End querying for host " + host + ":" + logFile);
+            this.result = output;
+
+            if (!output.equals(Constant.ERROR_CREATE_LOG) & !output.equals(Constant.SUCCESS_CREATE_LOG)) {
+                System.out.println("End querying for host " + host + ":" + logFile);
+            }
+
             System.out.println("-----------------------------");
 
         } catch(IOException | ClassNotFoundException u) {

src/main/java/cs425/mp1/Server.java

@@ -5,6 +5,8 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 
 public class Server {
     private int port;
@@ -17,23 +19,53 @@ public class Server {
             /* Establish socket to client */
             server = new ServerSocket(port);
             System.out.println("Server start listening on port "+ port);
-            socket = server.accept();
-            System.out.println("Client connected");
+
+            while (true){
+                socket = server.accept();
+                System.out.println("Client connected");
 
             /*
             Input command from client and call Grep class to execute, then return output to output stream
              */
-            ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
-            try {
-                String mess = (String) inputStream.readObject();
-                String res = String.join("\n", Grep.run_cmd(mess));
-                System.out.println(res);
-
-                ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
-                outputStream.writeObject(res);
-            } catch (IOException | ClassNotFoundException e) {
-                System.err.println("Error reading message");
-                e.printStackTrace();
+                ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
+                try {
+                    String mess = (String) inputStream.readObject();
+
+                /*
+                2 case: 1 case is generate log, 1 case is command grep
+                 */
+                    String res;
+                    mess = mess.trim();
+                    String[] messToken = mess.split(" ");
+                    if (messToken[0].equals("grep")) {
+
+                    /* Grep command:
+                    Check if log file exist or not
+                    */
+                        String grepCommand = mess;
+                        boolean exists = Files.exists(Paths.get(messToken[messToken.length-1]));
+
+                        if (exists) {
+                            res = String.join("\n", Grep.run_cmd(grepCommand));
+                        } else {
+                            res = Constant.LOG_FILE_DOES_NOT_EXIST;
+                        }
+
+                    } else {
+
+                        /* Generating log */
+                        String fileLog = mess;
+                        res = GenLog.generate_logs(fileLog);
+                    }
+                    System.out.println(res);
+
+                    ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
+                    outputStream.writeObject(res);
+
+                } catch (IOException | ClassNotFoundException e) {
+                    System.err.println("Error reading message");
+                    e.printStackTrace();
+                }
             }
 
         } catch(IOException e) {

src/test/java/GrepTest.java

-import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.Test;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.RepeatedTest;
+import cs425.mp1.ClientHandler;
+import org.junit.jupiter.api.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.logging.Logger;
+import java.io.IOException;
 
-class GrepTest {
+import static org.junit.jupiter.api.Assertions.*;
 
-    private static final Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);
-
-    private ArrayList<String> generate_logs() {
-        /**
-         * known log lines
-         */
-
-        /**
-        unknown log lines
-         */
-        return null;
-    }
-
-    @BeforeEach
-    void setUp() {
-//        calculator = new Calculator();
-        /**
-         * Generate log files every machines
-         */
+public class GrepTest {
+    private static final Logger logger = LoggerFactory.getLogger(GrepTest.class);
+    private static final String configFile = "/home/maipham/uiuc/cs425/mp1/grep/files/configTest.txt";
 
+    @BeforeAll
+    public static void init(){
         logger.info("Generating log....");
-
+        try {
+            String res = ClientHandler.start(configFile, "");
+            logger.info(res);
+        } catch (IOException e) {
+            System.err.println("Error reading config file!");
+            e.printStackTrace();
+        }
     }
 
     @Test
     @DisplayName("Test frequent normal case")
     void test_normal_case() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
+        try {
+            String res = ClientHandler.start(configFile, "grep -c Error");
+            res = res.trim();
+            assertEquals("2", res, "Match pattern with normal case");
+        } catch (IOException e) {
+            logger.error(e.toString());
+        }
 
-    @RepeatedTest(5)
-    @DisplayName("Test rare query pattern")
-    void test_rare_case() {
-//        assertEquals(0, calculator.multiply(0, 5), "Multiple with zero should be zero");
-//        assertEquals(0, calculator.multiply(5, 0), "Multiple with zero should be zero");
     }
 
-    @Test
-    @DisplayName("Test partly frequent case")
-    void test_partly_frequent_case() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
+//    @RepeatedTest(5)
+//    @DisplayName("Test rare query pattern")
+//    void test_rare_case() {
+////        assertEquals(0, calculator.multiply(0, 5), "Multiple with zero should be zero");
+////        assertEquals(0, calculator.multiply(5, 0), "Multiple with zero should be zero");
+//    }
+//
+//    @Test
+//    @DisplayName("Test partly frequent case")
+//    void test_partly_frequent_case() {
+////        assertEquals(20, calculator.multiply(4, 5),
+////                "Regular multiplication should work");
+//    }
+//
+//    @Test
+//    @DisplayName("Test pattern occurs in one log")
+//    void test_pattern_occured_once() {
+////        assertEquals(20, calculator.multiply(4, 5),
+////                "Regular multiplication should work");
+//    }
+//
+//    @Test
+//    @DisplayName("Test pattern occurs in several logs")
+//    void test_pattern_occured_several_case() {
+////        assertEquals(20, calculator.multiply(4, 5),
+////                "Regular multiplication should work");
+//    }
+//
+//    @Test
+//    @DisplayName("Test pattern occurs in all logs")
+//    void test_pattern_occured_all_case() {
+////        assertEquals(20, calculator.multiply(4, 5),
+////                "Regular multiplication should work");
+//    }
+//
+//    @Test
+//    @DisplayName("Test non occurred pattern in any logs")
+//    void test_non_occured_pattern_case() {
+////        assertEquals(20, calculator.multiply(4, 5),
+////                "Regular multiplication should work");
+//    }
 
-    @Test
-    @DisplayName("Test pattern occurs in one log")
-    void test_pattern_occured_once() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
-
-    @Test
-    @DisplayName("Test pattern occurs in several logs")
-    void test_pattern_occured_several_case() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
-
-    @Test
-    @DisplayName("Test pattern occurs in all logs")
-    void test_pattern_occured_all_case() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
-
-    @Test
-    @DisplayName("Test non occurred pattern in any logs")
-    void test_non_occured_pattern_case() {
-//        assertEquals(20, calculator.multiply(4, 5),
-//                "Regular multiplication should work");
-    }
 }
\ No newline at end of file