feat: add clients handler via thread

.settings/org.eclipse.buildship.core.prefs

@@ -1,4 +1,4 @@
-arguments=--init-script /home/xeon0x/.var/app/dev.zed.Zed/data/zed/extensions/work/java/jdtls/jdt-language-server-1.46.1-202504011455/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
+arguments=--init-script /home/xeon0x/.var/app/dev.zed.Zed/data/zed/extensions/work/java/jdtls/jdt-language-server-1.46.0-202503271314/configuration/org.eclipse.osgi/58/0/.cp/gradle/init/init.gradle
 auto.sync=false
 build.scans.enabled=false
 connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)

README.md

@@ -1,24 +1,5 @@
 # ClientServer
 
-A Java-based ☕️↔️ UDP client-server chat 💬 system with automatic 🔄 text-to-emoji 😊 conversion using Mistral API.
-
-## Features
-
-### Available Commands
-
-- `/list` : Display connected clients list
-- `/msg <nickname> <message>` : Send private message to specific client
-- `/help` : Display help with all available commands
-- `/disconnect` : Clean server disconnection
-- `<message>` : Broadcast message translated to emojis to all connected clients
-
-### Technical Features
-
-- UDP Communication
-- Multi-threading for client handling
-- Mistral API for text-to-emoji conversion
-- Disconnection handling
-
 ## Build
 
 ```bash
@@ -30,76 +11,33 @@ A Java-based ☕️↔️ UDP client-server chat 💬 system with automatic 🔄
 ### Client
 
 ```bash
-./gradlew runClient
+./gradlew run --args='client'
 ```
 
-The client will ask for a pseudo, an IP (type `localhost` if server and clients are on the same machine), and a port (type `6666` by default).
-
-### Server
+or
 
 ```bash
 ./gradlew runServer
 ```
 
-## Configuration
+### Server
 
-Create a `config.properties` file at project root (`ClientServer/app/config.properties`) with:
-
-```properties
-mistral.api.key=your_api_key
+```bash
+./gradlew run --args='server'
 ```
 
-Replace `your_api_key` with your actual Mistral API key. Create one for free at https://console.mistral.ai/api-keys. If no API key is provided, the server will not be able to convert broadcasted messages to emojis and empty broadcasted messages will be sent.
+or
+
+```bash
+./gradlew runServer
+```
 
 ## Documentation
 
-### Sequence Diagram
-
 ```mermaid
 sequenceDiagram
-    participant MainServer
-
-    participant Alice
-    Note over Alice: Creates DatagramSocket
-    Alice->>+MainServer: Sends username "Alice"
-    Note over MainServer: Creates new socket<br/>for AliceHandler
-    create participant AliceHandler
-    MainServer->>AliceHandler: Create new handler thread
-    MainServer->>-Alice: PORT:{AlicePort}
-
-    participant Bob
-    Bob->>+MainServer: Sends username "Bob"
-    Note over MainServer: Creates new socket<br/>for BobHandler
-    create participant BobHandler
-    MainServer->>BobHandler: Create new handler thread
-    MainServer->>-Bob: PORT:{BobPort}
-
-    rect rgb(200, 200, 255)
-        Note over Alice,Bob: Chat loop
-        Alice->>+AliceHandler: "Hi everyone!"
-        Note over AliceHandler: Converts to emojis
-        AliceHandler->>+BobHandler: Broadcast message
-        BobHandler->>-Bob: "Alice: 👋👩‍👩🌍🎉"
-        AliceHandler->>-Alice: Message sent
-
-        Bob->>+BobHandler: "Hello Alice, how are you?"
-        Note over BobHandler: Converts to emojis
-        BobHandler->>+AliceHandler: Broadcast message
-        AliceHandler->>-Alice: "Bob: 👋🏻👩🏼‍🦰🐰🤔👩🏼‍🦰🐇💬👩🏼‍🦰🐰👍🏻😊👩🏼‍🦰🐇👋🏻"
-        BobHandler->>-Bob: Message sent
-    end
-
-    Alice->>+AliceHandler: /disconnect
-    Note over AliceHandler: Removes Alice<br/>from map
-    AliceHandler->>-Alice: Disconnection confirmation
-    AliceHandler->>MainServer: Thread terminated
-    MainServer-->>AliceHandler: destroy
-
-    Bob->>+BobHandler: /disconnect
-    Note over BobHandler: Removes Bob<br/>from map
-    BobHandler->>-Bob: Disconnection confirmation
-    BobHandler->>MainServer: Thread terminated
-    MainServer-->>BobHandler: destroy
-
-    Note over Alice,Bob: Close sockets
+    Note over Client, Serveur: DatagramSocket("localhost", 66666)
+    Client->>+Serveur: DatagramPacket("Salve !", 7, "localhost", 6666)
+    Note over Serveur, Client: DatagramSocket("localhost", 66666)
+    Serveur->>+Client: DatagramPacket("Accusé de réception", 19, "localhost", 6666)
 ```

app/build.gradle

@@ -55,5 +55,4 @@ task runClient(type: JavaExec) {
     mainClass = application.mainClass
     classpath = sourceSets.main.runtimeClasspath
     args = ['--client']
-    standardInput = System.in
 }

app/src/main/java/clientserver/client/Client.java

@@ -1,78 +1,15 @@
 package clientserver.client;
 
-import clientserver.server.Server;
-import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-import java.util.Scanner;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.TimeUnit;
 
 public class Client {
 
     InetAddress clientAddress;
     int clientPort;
-    private InetAddress serverAddress;
-    private int serverPort;
-    private String pseudo;
-    private Scanner scan;
-    private DatagramSocket clientSocket;
-    private int handlerPort;
-
-    public Client(InetAddress address, int port) {
-        this.clientAddress = address;
-        this.clientPort = port;
-    }
-
-    private static class MessageReceiver implements Runnable {
-
-        private final DatagramSocket socket;
-        private volatile boolean running = true;
-
-        public MessageReceiver(DatagramSocket socket) {
-            this.socket = socket;
-        }
-
-        @Override
-        public void run() {
-            try {
-                socket.setSoTimeout(500); // Petit timeout pour pouvoir vérifier régulièrement si on doit s'arrêter,
-                // evite thread zombie car receive() est bloquant
-
-                while (running && !socket.isClosed()) {
-                    try {
-                        byte[] buffer = new byte[1024];
-                        DatagramPacket packet = new DatagramPacket(
-                            buffer,
-                            buffer.length
-                        );
-
-                        socket.receive(packet);
-                        String message = new String(
-                            packet.getData(),
-                            0,
-                            packet.getLength()
-                        );
-
-                        // Afficher le message reçu avec une mise en forme claire
-                        System.out.println(message);
-                    } catch (SocketTimeoutException e) {}
-                }
-            } catch (IOException e) {
-                if (!socket.isClosed()) {
-                    System.err.println(
-                        "Error in the reception of messages: " + e.getMessage()
-                    );
-                }
-            }
-            System.out.println("Message receiver stopped");
-        }
-
-        public void stop() {
-            running = false;
-        }
-    }
 
     public void setPort(int port) {
         this.clientPort = port;
@@ -86,196 +23,65 @@ public class Client {
         return this.clientAddress;
     }
 
-    public InetAddress getServerAddress() {
-        return this.serverAddress;
-    }
-
-    public int getServerPort() {
-        return this.serverPort;
-    }
-
-    public void setServerPort(int port) {
-        this.serverPort = port;
-    }
-
-    public String getPseudo() {
-        return this.pseudo;
-    }
-
-    public void setPseudo(String pseudo) {
-        this.pseudo = pseudo;
-    }
-
-    public Scanner getScanner() {
-        return this.scan;
-    }
-
-    public void setScanner(Scanner scan) {
-        this.scan = scan;
-    }
-
-    public DatagramSocket getClientSocket() {
-        return this.clientSocket;
-    }
-
-    public void setClientSocket(DatagramSocket clientSocket) {
-        this.clientSocket = clientSocket;
-    }
-
-    public int getHandlerPort() {
-        return handlerPort;
-    }
-
-    public void setHandlerPort(int handlerPort) {
-        this.handlerPort = handlerPort;
-    }
-
-    public static Client createAndConfigureClient(DatagramSocket socketClient) {
-        System.out.println("Enter your Pseudo :");
-
-        // Créer le client avec l'adresse locale et le port du socket
-        Client client = new Client(
-            socketClient.getLocalAddress(),
-            socketClient.getLocalPort()
-        );
-        client.setScanner(new Scanner(System.in));
-        String userPseudo = client.getScanner().next();
-        client.setPseudo(userPseudo);
-
-        System.out.println("Enter the IP address of the server :");
-        try {
-            client.serverAddress = InetAddress.getByName(
-                client.getScanner().next()
-            );
-        } catch (UnknownHostException e) {
-            System.err.println(
-                "The address you choose create an UnknownHostException: " + e
-            );
-        }
-
-        System.out.println("Enter the port of the server:");
-        client.setServerPort(client.getScanner().nextInt());
-        client.getScanner().nextLine(); // Consume the remaining newline to avoid sending a void line message like
-        // (morph (/127.0.0.1:39056) : ...)
-
-        if (socketClient != null && client.serverAddress != null) {
-            Server.sendMessage(
-                socketClient,
-                client.getPseudo(),
-                client.serverAddress,
-                client.getServerPort()
-            );
-            System.out.println("New connection request sent");
-        }
-
-        return client;
-    }
-
-    private static void deconnexionClient(
-        DatagramSocket socketClient,
-        Client client,
-        int handlerPort
-    ) {
-        try {
-            String disconnectMsg = "/disconnect";
-            byte[] disconnectData = disconnectMsg.getBytes();
-            DatagramPacket disconnectPacket = new DatagramPacket(
-                disconnectData,
-                disconnectData.length,
-                client.getServerAddress(),
-                handlerPort
-            );
-            socketClient.send(disconnectPacket);
-            System.out.println(
-                "Deconnection sended on the server port: " + handlerPort
-            );
-        } catch (Exception e) {
-            System.err.println(
-                "Error during sending the deconnection message: " + e
-            );
-        }
-    }
-
-    public void run() {
-        // 1 - Boucle principale pour l'envoi des messages
-        boolean running = true;
-
-        System.out.println("\n=== Chat client ready ===");
-        // System.out.println(
-        //     "Type your messages then press 'Enter' to send them to the server."
-        // );
-        System.out.println("Type /list to see all the clients connected.");
-        System.out.println(
-            "Type '/msg <target> <message>' to send a private message."
-        );
-        System.out.println("Type '/help' to see all the commands.");
-        System.out.println("Type '/disconnect' to quit.\n");
-
-        while (running) {
-            String message = this.getScanner().nextLine();
-
-            if ("/disconnect".equalsIgnoreCase(message)) {
-                running = false;
-            } else {
-                Server.sendMessage(
-                    this.clientSocket,
-                    message,
-                    this.getServerAddress(),
-                    this.getHandlerPort()
-                );
-            }
-        }
-
-        // 2 - Gérer la déconnexion proprement
-        System.out.println("Deconnection in progress...");
-        deconnexionClient(this.getClientSocket(), this, this.getHandlerPort());
+    public Client(InetAddress address, int port) {
+        this.clientAddress = address;
+        this.clientPort = port;
     }
 
     public static void main(String[] args) {
         try {
             // 1 - Création du canal avec un port libre
             DatagramSocket socketClient = new DatagramSocket();
+            InetAddress adresseServeur = InetAddress.getByName("localhost");
+            int portServeur = 6666;
 
-            // 2 - Création du client avec l'envoi du pseudo pour l'établissement de la
-            // connexion
-            Client client = createAndConfigureClient(socketClient);
+            // 2 - Envoyer un message au serveur
+            String message = "Hello Server";
+            byte[] envoyees = message.getBytes();
+            DatagramPacket paquetEnvoye = new DatagramPacket(
+                envoyees,
+                envoyees.length,
+                adresseServeur,
+                portServeur
+            );
+            socketClient.send(paquetEnvoye);
+            System.out.println("Message envoyé au serveur");
 
-            // 3 - Recevoir la réponse initiale du serveur
-            DatagramPacket receivedPacket = Server.receivedPacket(socketClient);
-            String reponse = Server.packetToMessage(receivedPacket);
+            // 3 - Recevoir
+            byte[] recues = new byte[1024]; // tampon de réception
+            DatagramPacket paquetRecu = new DatagramPacket(
+                recues,
+                recues.length
+            );
+            socketClient.receive(paquetRecu);
+            String reponse = new String(
+                paquetRecu.getData(),
+                0,
+                paquetRecu.getLength()
+            );
 
             if (reponse.startsWith("PORT:")) {
-                int handlerPort = Integer.parseInt(reponse.substring(5));
-                System.out.println("Connected on handler port: " + handlerPort);
+                int newPort = Integer.parseInt(reponse.substring(5));
 
-                client.setClientSocket(socketClient);
-                client.setHandlerPort(handlerPort);
+                System.out.println("Connexion au nouveau port: " + newPort);
 
-                // 4 - Lancer uniquement le thread de réception des messages
-                MessageReceiver receiver = new MessageReceiver(socketClient);
-                Thread receiverThread = new Thread(receiver);
-                receiverThread.setDaemon(true);
-                receiverThread.start();
-
-                // 5 - Éxecution du client, bloquant tant que le client est connecté.
-                client.run();
-
-                // 6 - Arrêter le thread de réception
-                receiver.stop();
-                try {
-                    receiverThread.join(1000);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                }
-            } else {
-                System.err.println(
-                    "Unexpected response from the server: " + reponse
+                // 4 - Communiquer sur le nouveau port
+                for (int i = 0; i < 5; i++) {
+                    String messagePort = "Message au nouveau port";
+                    byte[] envoyeesPort = messagePort.getBytes();
+                    DatagramPacket paquetPort = new DatagramPacket(
+                        envoyeesPort,
+                        envoyeesPort.length,
+                        adresseServeur,
+                        newPort
                     );
+                    socketClient.send(paquetPort);
+                    TimeUnit.SECONDS.sleep(1);
+                }
             }
 
-            // 8 - Libérer le canal
+            // 5 - Libérer le canal
             socketClient.close();
-            System.out.println("Client closed");
         } catch (Exception e) {
             System.err.println(e);
         }

app/src/main/java/clientserver/common/MistralDirectAPI.java

@@ -10,9 +10,10 @@ import java.util.Properties;
 
 public class MistralDirectAPI {
 
-    private static String apiKey;
+    public static void main(String[] args) {
+        String apiKey;
 
-    static {
+        // Load API key from properties file
         try {
             Properties props = new Properties();
             FileInputStream input = new FileInputStream("config.properties");
@@ -21,22 +22,18 @@ public class MistralDirectAPI {
             input.close();
         } catch (IOException e) {
             System.err.println("Could not load API key: " + e.getMessage());
-        }
+            return;
         }
 
-    public static String translateToEmojis(String message) {
-        String payload = String.format(
+        String payload =
             """
             {
                 "model": "mistral-medium",
                 "messages": [
-                    { "role": "system", "content": "Please translate the following message to emojis only. Do not include any comments. End the emoji message with ;" },
-                    { "role": "user", "content": "%s" }
+                    { "role": "user", "content": "Reverse turing test." }
                 ]
             }
-            """,
-            message
-        );
+            """;
 
         HttpRequest request = HttpRequest.newBuilder()
             .uri(URI.create("https://api.mistral.ai/v1/chat/completions"))
@@ -52,26 +49,10 @@ public class MistralDirectAPI {
                 request,
                 HttpResponse.BodyHandlers.ofString()
             );
-            String responseBody = response.body();
-            return extractContent(responseBody);
+            System.out.println("Response Code: " + response.statusCode());
+            System.out.println("Response Body: " + response.body());
         } catch (IOException | InterruptedException e) {
             System.err.println("Error occurred: " + e.getMessage());
-            return message;
         }
     }
-
-    private static String extractContent(String jsonResponse) {
-        // Find the content field in the response
-        int contentIndex = jsonResponse.indexOf("\"content\":\"");
-        if (contentIndex != -1) {
-            int startIndex = contentIndex + "\"content\":\"".length();
-
-            int endIndex = jsonResponse.indexOf(";", startIndex);
-
-            if (endIndex != -1) {
-                return jsonResponse.substring(startIndex, endIndex);
-            }
-        }
-        return "";
-    }
 }

app/src/main/java/clientserver/server/ClientHandler.java

@@ -6,51 +6,39 @@ import java.net.DatagramSocket;
 
 public class ClientHandler implements Runnable {
 
-    private final DatagramSocket clientHandlerSocket;
+    private final DatagramSocket socket;
     private final Client client;
     private boolean running = true;
-    private final MessageProcessor messageProcessor;
 
     public ClientHandler(DatagramSocket socket, Client client) {
-        this.clientHandlerSocket = socket;
+        this.socket = socket;
         this.client = client;
-        this.messageProcessor = new MessageProcessor(
-            client,
-            clientHandlerSocket,
-            this
-        );
-    }
-
-    public Client getClient() {
-        return client;
     }
 
     public void stop() {
         running = false;
-        if (clientHandlerSocket != null && !clientHandlerSocket.isClosed()) {
-            clientHandlerSocket.close();
+        if (socket != null && !socket.isClosed()) {
+            socket.close();
         }
     }
 
-    public static String prettyPrint(Client client) {
-        StringBuilder str = new StringBuilder();
-        str.append(
-            client.getPseudo() +
-            " (" +
-            client.getAddress() +
-            ":" +
-            client.getPort() +
-            ")"
-        );
-        return str.toString();
-    }
-
     @Override
     public void run() {
-        System.out.println("Started handler for client " + prettyPrint(client));
+        System.out.println(
+            "Started handler for client " +
+            client.getAddress() +
+            ":" +
+            client.getPort()
+        );
 
-        while (running && !clientHandlerSocket.isClosed()) {
-            DatagramPacket packet = Server.receivedPacket(clientHandlerSocket);
+        // try {
+        //     socket.setSoTimeout(30000);
+        // } catch (Exception e) {
+        //     System.err.println("Could not set socket timeout");
+        // }
+
+        while (running && !socket.isClosed()) {
+            DatagramPacket packet = Server.receivePacket(socket);
             if (packet == null) continue;
 
             String message = new String(
@@ -58,13 +46,29 @@ public class ClientHandler implements Runnable {
                 0,
                 packet.getLength()
             );
-            System.out.println(prettyPrint(client) + " : " + message);
-
-            messageProcessor.processMessage(message);
+            System.out.println(
+                "Received from " +
+                client.getAddress() +
+                ":" +
+                client.getPort() +
+                ": " +
+                message
+            );
+            // Reply with echo
+            // String response = "ECHO: " + message;
+            // Server.sendMessage(
+            //     socket,
+            //     response,
+            //     client.getAddress(),
+            //     client.getPort()
+            // );
         }
 
         System.out.println(
-            "Client handler terminated for " + prettyPrint(client)
+            "Client handler terminated for " +
+            client.getAddress() +
+            ":" +
+            client.getPort()
         );
     }
 }

app/src/main/java/clientserver/server/MessageProcessor.java

@@ -1,170 +0,0 @@
-package clientserver.server;
-
-import clientserver.client.Client;
-import clientserver.common.MistralDirectAPI;
-import java.net.DatagramSocket;
-
-public class MessageProcessor {
-
-    private final Client client;
-    private final DatagramSocket clientHandlerSocket;
-    private final ClientHandler clientHandler;
-
-    public MessageProcessor(
-        Client client,
-        DatagramSocket clientHandlerSocket,
-        ClientHandler clientHandler
-    ) {
-        this.client = client;
-        this.clientHandlerSocket = clientHandlerSocket;
-        this.clientHandler = clientHandler;
-    }
-
-    public void processMessage(String message) {
-        if (message == null) {
-            return;
-        }
-
-        if (message.startsWith("/msg ")) {
-            handlePrivateMessage(message);
-            return;
-        }
-
-        switch (message) {
-            case "/list":
-                handleListCommand();
-                break;
-            case "/help":
-                handleHelpCommand();
-                break;
-            case "/msg":
-                handleMsgCommand();
-                break;
-            case "/disconnect":
-                handleDisconnect();
-                break;
-            default:
-                // Broadcast message to all clients
-                broadcastMessageEmoji(message);
-                break;
-        }
-    }
-
-    private void handlePrivateMessage(String message) {
-        String[] parts = message.split(" ", 3);
-        if (parts.length < 3) {
-            handleMsgCommand();
-            return;
-        }
-
-        String targetPseudo = parts[1];
-        String messageContent = parts[2];
-
-        ClientHandler targetHandler = Server.getClientHandler(targetPseudo);
-
-        if (targetHandler == null) {
-            Server.sendMessage(
-                clientHandlerSocket,
-                "> User " + targetPseudo + " not found",
-                client.getAddress(),
-                client.getPort()
-            );
-            return;
-        }
-
-        // Send private message to target
-        Client targetClient = targetHandler.getClient();
-        Server.sendMessage(
-            clientHandlerSocket,
-            "> " +
-            client.getPseudo() +
-            " -> " +
-            targetClient.getPseudo() +
-            ": " +
-            messageContent,
-            targetClient.getAddress(),
-            targetClient.getPort()
-        );
-
-        // Send confirmation to sender
-        Server.sendMessage(
-            clientHandlerSocket,
-            "> " +
-            client.getPseudo() +
-            " -> " +
-            targetClient.getPseudo() +
-            ": " +
-            messageContent,
-            client.getAddress(),
-            client.getPort()
-        );
-    }
-
-    private void broadcastMessage(String message) {
-        String formattedMessage = "> " + client.getPseudo() + ": " + message;
-
-        for (ClientHandler handler : Server.getAllClientHandlers()) {
-            Client targetClient = handler.getClient();
-            Server.sendMessage(
-                clientHandlerSocket,
-                formattedMessage,
-                targetClient.getAddress(),
-                targetClient.getPort()
-            );
-        }
-    }
-
-    private void broadcastMessageEmoji(String message) {
-        // Translate message to emojis
-        String emojiMessage = MistralDirectAPI.translateToEmojis(message);
-        String formattedMessage =
-            "> " + client.getPseudo() + ": " + emojiMessage;
-
-        for (ClientHandler handler : Server.getAllClientHandlers()) {
-            Client targetClient = handler.getClient();
-            Server.sendMessage(
-                clientHandlerSocket,
-                formattedMessage,
-                targetClient.getAddress(),
-                targetClient.getPort()
-            );
-        }
-    }
-
-    private void handleMsgCommand() {
-        Server.sendMessage(
-            clientHandlerSocket,
-            "> /msg <target> <message> : send a message to a client",
-            client.getAddress(),
-            client.getPort()
-        );
-    }
-
-    private void handleListCommand() {
-        Server.sendMessage(
-            clientHandlerSocket,
-            Server.getPseudos(),
-            client.getAddress(),
-            client.getPort()
-        );
-    }
-
-    private void handleHelpCommand() {
-        Server.sendMessage(
-            clientHandlerSocket,
-            "> /list : list all connected clients" +
-            "\n> /msg <target> <message> : send a message to a client" +
-            "\n> /disconnect : disconnect from the server",
-            client.getAddress(),
-            client.getPort()
-        );
-    }
-
-    private void handleDisconnect() {
-        System.out.println(
-            "Client deconnection : " + ClientHandler.prettyPrint(client)
-        );
-        Server.removeClientHandler(client.getPseudo());
-        clientHandler.stop();
-    }
-}

app/src/main/java/clientserver/server/Server.java

@@ -4,20 +4,12 @@ import clientserver.client.Client;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
-import java.net.InetAddress;
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 public class Server {
 
     private int mainServerPort;
     private DatagramSocket mainServerSocket;
     private boolean isRunning;
-    private static Map<
-        String,
-        ClientHandler
-    > mapPseudosConnectedClientsHandlers = new ConcurrentHashMap<>();
 
     public Server(int port) {
         this.mainServerPort = port;
@@ -35,7 +27,7 @@ public class Server {
         }
     }
 
-    private DatagramSocket createNewSocket() {
+    private DatagramSocket getNewSocket() {
         try {
             return new DatagramSocket(); // Reserve a random port
         } catch (Exception e) {
@@ -45,7 +37,7 @@ public class Server {
         }
     }
 
-    public static DatagramPacket receivedPacket(DatagramSocket socket) {
+    public static DatagramPacket receivePacket(DatagramSocket socket) {
         byte[] receivedData = new byte[1024];
         DatagramPacket receivedPacket = new DatagramPacket(
             receivedData,
@@ -61,10 +53,6 @@ public class Server {
         }
     }
 
-    public static String packetToMessage(DatagramPacket packet) {
-        return new String(packet.getData(), 0, packet.getLength());
-    }
-
     public static void sendMessage(
         DatagramSocket socket,
         String message,
@@ -89,59 +77,43 @@ public class Server {
     }
 
     private void handleNewConnection() {
-        DatagramPacket packet = receivedPacket(mainServerSocket);
+        DatagramPacket packet = receivePacket(mainServerSocket);
         if (packet == null) return;
 
-        int originalClientPort = packet.getPort();
-        InetAddress clientAddress = packet.getAddress();
+        Client client = new Client(packet.getAddress(), packet.getPort());
+
         // Log the initial connection request
         System.out.println(
             "New connection request from " +
-            clientAddress +
+            client.getAddress() +
             ":" +
-            originalClientPort
+            client.getPort()
         );
 
         // Process the received message
-        String pseudoMessage = new String(
-            packet.getData(),
-            0,
-            packet.getLength()
-        );
+        String message = new String(packet.getData(), 0, packet.getLength());
+        System.out.println("Received message: " + message);
 
-        System.out.println(
-            "Received message from " +
-            clientAddress +
-            ":" +
-            originalClientPort +
-            ": " +
-            pseudoMessage
-        );
         // Create a new socket for this client
-        DatagramSocket clientHandlerSocket = createNewSocket();
+        DatagramSocket clientSocket = getNewSocket();
+        if (clientSocket == null) return;
 
-        if (clientHandlerSocket == null) return;
-        int clientHandlerLocalPort = clientHandlerSocket.getLocalPort();
+        int newPort = clientSocket.getLocalPort();
+        client.setPort(newPort);
 
-        Client client = new Client(clientAddress, originalClientPort);
-
-        client.setPseudo(pseudoMessage);
         // Send new port information to client
-        String response = "PORT:" + clientHandlerLocalPort;
-
+        String response = "PORT:" + newPort;
         sendMessage(
             mainServerSocket,
             response,
-            clientAddress,
+            client.getAddress(),
             packet.getPort()
         );
-        // Create and start a ClientHandler for this connection
-        ClientHandler handler = new ClientHandler(clientHandlerSocket, client);
 
+        // Create and start a ClientHandler for this connection
+        ClientHandler handler = new ClientHandler(clientSocket, client);
         Thread thread = new Thread(handler);
         thread.start();
-        // Add client handler to mapPseudosConnectedClients
-        addConnectedClientHandler(pseudoMessage, handler);
     }
 
     public void run() {
@@ -158,40 +130,4 @@ public class Server {
         }
         System.out.println("Server shutdown");
     }
-
-    public static String getPseudos() {
-        StringBuilder pseudos = new StringBuilder();
-        int size = mapPseudosConnectedClientsHandlers.size();
-        int count = 0;
-        for (Map.Entry<
-            String,
-            ClientHandler
-        > entry : mapPseudosConnectedClientsHandlers.entrySet()) {
-            count++;
-            pseudos.append("> ").append(entry.getKey());
-            if (count < size) {
-                pseudos.append("\n");
-            }
-        }
-        return pseudos.toString();
-    }
-
-    public static ClientHandler getClientHandler(String pseudo) {
-        return mapPseudosConnectedClientsHandlers.get(pseudo);
-    }
-
-    public static Collection<ClientHandler> getAllClientHandlers() {
-        return mapPseudosConnectedClientsHandlers.values();
-    }
-
-    public void addConnectedClientHandler(
-        String pseudo,
-        ClientHandler clientHandler
-    ) {
-        mapPseudosConnectedClientsHandlers.putIfAbsent(pseudo, clientHandler);
-    }
-
-    public static void removeClientHandler(String pseudo) {
-        mapPseudosConnectedClientsHandlers.remove(pseudo);
-    }
 }

gradle.properties

@@ -1 +0,0 @@
-org.gradle.console=plain