115 refactor main

.github/workflows/maven.yml

@@ -1,10 +1,4 @@
-# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven
 
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
 
 name: Java CI with Maven
 
@@ -26,7 +20,10 @@ jobs:
         run: |
           Java_Version=$(mvn help:evaluate "-Dexpression=maven.compiler.release" -q -DforceStdout | sed -e 's/^1\./1.0./')
           echo "Java_Version=$Java_Version" >> $GITHUB_ENV
+
+
       - name: Set up JDK ${{ env.Java_Version }}
+
         uses: actions/setup-java@v4
         with:
           java-version: ${{ env.Java_Version }}
@@ -37,4 +34,3 @@ jobs:
 
       - name: Test with Maven
         run: mvn -B test --file pom.xml
-

.github/workflows/release.yml

@@ -18,7 +18,13 @@ jobs:
         run: |
           Java_Version=$(mvn help:evaluate "-Dexpression=maven.compiler.release" -q -DforceStdout | sed -e 's/^1\./1.0./')
           echo "Java_Version=$Java_Version" >> $GITHUB_ENV
-      - name: Set up JDK 21
+
+
+
+      - name: Set up  ${{env.Java_Version}}
+
+
+
         uses: actions/setup-java@v4
         with:
           java-version: ${{ env.Java_Version }}

.github/workflows/sonar.yml

@@ -17,7 +17,14 @@ jobs:
         run: |
           Java_Version=$(mvn help:evaluate "-Dexpression=maven.compiler.release" -q -DforceStdout | sed -e 's/^1\./1.0./')
           echo "Java_Version=$Java_Version" >> $GITHUB_ENV
-      - name: Set up JDK 21
+
+
+
+      - name: Set up  ${{env.Java_Version}}
+
+
+
+
         uses: actions/setup-java@v4
         with:
           java-version: ${{ env.Java_Version }}

src/main/java/org/fungover/haze/Auth.java

@@ -35,7 +35,7 @@ public static boolean authenticateClient(Auth auth, boolean isPasswordSet, Socke
         return clientAuthenticated;
     }
 
-   private static void shutdownClientIfNotAuthenticated(Socket client, boolean clientAuthenticated, boolean isPasswordSet) throws IOException {
+  public static void shutdownClientIfNotAuthenticated(Socket client, boolean clientAuthenticated, boolean isPasswordSet) throws IOException {
         if (!clientAuthenticated && isPasswordSet) {
             client.getOutputStream().write(Auth.printAuthError());
             client.shutdownOutput();

src/main/java/org/fungover/haze/Command.java

@@ -3,3 +3,4 @@
 public enum Command {
     SET, GET, DEL, PING, SETNX, EXISTS, SAVE, RPUSH, LPUSH, LPOP, RPOP, LLEN, LMOVE, LTRIM, AUTH, LINDEX, INCR, DECR, LSET, GETDEL, LINSERT
 }
+

src/main/java/org/fungover/haze/Initialize.java

@@ -41,9 +41,15 @@ public String getPassword() {
             return System.getenv("HAZE_PASSWORD");
         } else return null;
     }
-
     public void clearCliOptions() {
         cliOptions.clear();
     }
 
+
+    public static Initialize getInitialize(String[] args) {
+        Initialize initialize = new Initialize();
+        initialize.importCliOptions(args);
+        return initialize;
+    }
+
 }

src/main/java/org/fungover/haze/Main.java

@@ -8,88 +8,108 @@
 import java.io.InputStreamReader;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
+import java.net.Socket;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 
+
 public class Main {
     static boolean serverOpen = true;
     static Logger logger = LogManager.getLogger(Main.class);
 
-
     public static void main(String[] args) {
-
-
-        Initialize initialize = new Initialize();
-        initialize.importCliOptions(args);
+        Initialize initialize = Initialize.getInitialize(args);
         HazeDatabase hazeDatabase = new HazeDatabase();
         HazeList hazeList = new HazeList(hazeDatabase);
         Auth auth = new Auth();
         Initialize.initializeServer(args, initialize, auth);
         final boolean isPasswordSet = auth.isPasswordSet();
-
-
-        Thread printingHook = new Thread(() -> shutdown(hazeDatabase));
-        Runtime.getRuntime().addShutdownHook(printingHook);
+        addHook(hazeDatabase);
 
         try (ServerSocket serverSocket = new ServerSocket()) {
-            serverSocket.setReuseAddress(true);
-            serverSocket.bind(new InetSocketAddress(initialize.getPort()));
-            while (serverOpen) {
-                var client = serverSocket.accept();
-                logger.info("Application started: serverSocket.accept()");
-
-                Runnable newThread = () -> {
-                    try {
-                        BufferedReader input = new BufferedReader(new InputStreamReader(client.getInputStream()));
-                        boolean clientAuthenticated = false;
-                        while (!client.isClosed()) {
-                            List<String> inputList = new ArrayList<>();
-
-                            String firstReading = input.readLine();
+            initSocket(initialize, serverSocket);
+            whileServerOpen(hazeList, hazeDatabase, auth, isPasswordSet, serverSocket);
+        } catch (IOException e) {
+            logger.error(e);
+        }
+        logger.info("Shutting down....");
+    }
 
-                            if (firstReading == null) {
-                                logger.info("client has closed the connection");
-                                client.close();
-                                return;
-                            }
+    private static void whileServerOpen(HazeList hazeList, HazeDatabase hazeDatabase, Auth auth, boolean isPasswordSet, ServerSocket serverSocket) throws IOException {
+        while (serverOpen) {
+            var client = serverSocket.accept();
+            logger.info("Application started: serverSocket.accept()");
 
-                            readInputStream(input, inputList, firstReading);
+            runThread(hazeList, hazeDatabase, auth, isPasswordSet, client);
+        }
+    }
 
-                            clientAuthenticated = Auth.authenticateClient(auth, isPasswordSet, client, inputList, clientAuthenticated);
 
-                            client.getOutputStream().write(executeCommand(hazeDatabase, inputList, hazeList).getBytes());
+    private static void runThread(HazeList hazeList, HazeDatabase hazeDatabase, Auth auth, boolean isPasswordSet, Socket client) {
+        Runnable newThread = () -> createThread(hazeList, hazeDatabase, auth, isPasswordSet, client);
+        Thread.startVirtualThread(newThread);
+    }
 
-                            inputList.forEach(System.out::println); // For checking incoming message
 
-                            printThreadDebug();
+    private static void createThread(HazeList hazeList, HazeDatabase hazeDatabase, Auth auth, boolean isPasswordSet, Socket client) {
+        try {
+            BufferedReader input = new BufferedReader(new InputStreamReader(client.getInputStream()));
+            boolean clientAuthenticated = false;
+            while (!client.isClosed()) {
+                List<String> inputList = getInputList(input);
+                clientAuthenticated = Auth.authenticateClient(auth, isPasswordSet, client, inputList, clientAuthenticated);
+                handleThread(hazeList, hazeDatabase, client, inputList);
+            }
 
-                            inputList.clear();
-                        }
 
-                    } catch (IOException e) {
-                        logger.error(e);
-                    }
-                };
-                Thread.startVirtualThread(newThread);
-            }
         } catch (IOException e) {
             logger.error(e);
         }
-        logger.info("Shutting down....");
+    }
+
+
+    private static void handleThread(HazeList hazeList, HazeDatabase hazeDatabase, Socket client, List<String> inputList) throws IOException {
+        controlCommand(hazeList, hazeDatabase, client, inputList);
+        printThreadDebug();
+
+        inputList.clear();
+    }
+
+    private static void controlCommand(HazeList hazeList, HazeDatabase hazeDatabase, Socket client, List<String> inputList) throws IOException {
+        client.getOutputStream().write(executeCommand(hazeDatabase, inputList, hazeList).getBytes());
+
+        inputList.forEach(System.out::println); // For checking incoming message
+    }
+
+    public static List<String> getInputList(BufferedReader input) throws IOException {
+        List<String> inputList = new ArrayList<>();
+
+        String firstReading = input.readLine();
+        readInputStream(input, inputList, firstReading);
+        return inputList;
+    }
+
+    private static void initSocket(Initialize initialize, ServerSocket serverSocket) throws IOException {
+        serverSocket.setReuseAddress(true);
+        serverSocket.bind(new InetSocketAddress(initialize.getPort()));
+    }
+
+    private static void addHook(HazeDatabase hazeDatabase) {
+        Thread printingHook = new Thread(() -> shutdown(hazeDatabase));
+        Runtime.getRuntime().addShutdownHook(printingHook);
+
     }
 
     private static void shutdown(HazeDatabase hazeDatabase) {
         SaveFile.writeOnFile(hazeDatabase.copy());
         logger.info("Shutting down....");
     }
 
-
-    public static void printThreadDebug() {
-        logger.debug("ThreadID " + Thread.currentThread().threadId());  // Only for Debug
-        logger.debug("Is virtual Thread " + Thread.currentThread().isVirtual()); // Only for Debug
-
+    static void printThreadDebug() {
+        logger.debug("ThreadID {}", () -> Thread.currentThread().threadId());  // Only for Debug
+        logger.debug("Is virtual Thread {}", () -> Thread.currentThread().isVirtual()); // Only for Debug
     }
 
     public static String executeCommand(HazeDatabase hazeDatabase, List<String> inputList, HazeList hazeList) {
@@ -106,8 +126,9 @@ public static String executeCommand(HazeDatabase hazeDatabase, List<String> inpu
             commandEnum = Command.valueOf(command);
         } catch (IllegalArgumentException ex) {
             return "-ERR unknown command\r\n";
-        }
 
+
+        }
         return switch (commandEnum) {
             case SET -> hazeDatabase.set(inputList);
             case GET -> hazeDatabase.get(inputList);
@@ -132,9 +153,7 @@ public static String executeCommand(HazeDatabase hazeDatabase, List<String> inpu
             case LINSERT -> hazeList.lInsert(inputList);
         };
     }
-
-    private static void readInputStream(BufferedReader input, List<String> inputList, String firstReading) throws
-            IOException {
+    public static void readInputStream(BufferedReader input, List<String> inputList, String firstReading) throws IOException {
         logger.debug("readInputStream: {} {} {}", () -> input, () -> inputList, () -> firstReading);
         int size;
         if (firstReading.startsWith("*")) {
@@ -149,5 +168,9 @@ private static void readInputStream(BufferedReader input, List<String> inputList
             inputList.addAll(Arrays.asList(seperated));
         }
     }
-
 }
+
+
+
+
+

src/test/java/org/fungover/haze/InitializeTest.java

@@ -1,10 +1,12 @@
 package org.fungover.haze;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
-
+import java.lang.reflect.Field;
+import java.util.Map;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.mockito.Mockito.verify;
 
@@ -60,6 +62,24 @@ void passwordSetByCLIWithDashPortShouldReturn1233() {
         assertThat(initialize.getPassword()).isEqualTo("1233");
     }
 
+    @Test
+    public void testGetInitialize() throws NoSuchFieldException, IllegalAccessException {
+
+        String[] args = {"-p", "1234", "--password", "test"};
+
+
+        Initialize initialize = Initialize.getInitialize(args);
+
+
+        Field field = Initialize.class.getDeclaredField("cliOptions");
+        field.setAccessible(true);
+        Object obj = field.get(initialize);
+
+        Assertions.assertNotNull(obj);
+        Assertions.assertEquals("1234", ((Map<String, String>) obj).get("-p"));
+        Assertions.assertEquals("test", ((Map<String, String>) obj).get("--password"));
+    }
+
     @Test
     void shouldImportCliOptionsWhenInitializingServer() {
         String[] args = {"--password", "1234"};
@@ -71,7 +91,7 @@ void shouldImportCliOptionsWhenInitializingServer() {
         verify(initialize).importCliOptions(args);
     }
 
+}
 
 
 
-}