Implement command handling system with CommandDispatcher, CommandRegistry, and CommandNode classes

Author: Sandro642

src/main/java/io/nodelink/server/NodeLink.java

@@ -3,14 +3,33 @@
 import io.nodelink.server.log.Logger;
 import io.nodelink.server.update.Updater;
 
+import java.io.File;
+
 public class NodeLink extends NodeLinkHelper {
 
     private static final NodeLink INSTANCE = new NodeLink();
 
     static void main(String[] args) {
         try {
-            NodeLink.getInstance().getUpdater().handleArguments(args);
-            NodeLink.getInstance().getUpdater().checkForUpdates().block();
+            NodeLink.getInstance().getUpdater().checkForUpdates();
+
+            for (int i = 0; i < args.length; i++) {
+                if ("--delete-old".equals(args[i]) && (i + 1) < args.length) {
+                    String oldJarPath = args[i + 1];
+                    File oldFile = new File(oldJarPath);
+                    Thread.sleep(2000);
+
+                    if (oldFile.exists()) {
+                        boolean deleted = oldFile.delete();
+                        if (!deleted) {
+                            System.err.println("Failed to delete old JAR: " + oldJarPath);
+                        } else {
+                            System.out.println("Old JAR deleted successfully: " + oldJarPath);
+                        }
+                    }
+                    break;
+                }
+            }
 
         } catch (Exception e) {
             getInstance().getLogger().ERROR("Error deleting old JAR: " + e.getMessage());

src/main/java/io/nodelink/server/NodeLinkHelper.java

@@ -1,15 +1,21 @@
 package io.nodelink.server;
 
+import io.nodelink.server.command.CommandDispatcher;
+import io.nodelink.server.command.CommandLogics;
+import io.nodelink.server.command.CommandRegistry;
+import io.nodelink.server.command.TabCompleter;
+import io.nodelink.server.enums.CommandsEnum;
 import io.nodelink.server.update.Version;
-import org.jline.reader.EndOfFileException;
-import org.jline.reader.UserInterruptException;
+
+import org.jline.reader.*;
 import org.jline.terminal.Terminal;
 import org.jline.terminal.TerminalBuilder;
-import org.jline.reader.LineReader;
-import org.jline.reader.LineReaderBuilder;
 import org.jline.utils.InfoCmp.Capability;
+
 import java.nio.file.Paths;
 
+import java.util.List;
+
 public class NodeLinkHelper {
 
     private static final NodeLinkHelper INSTANCE = new NodeLinkHelper();
@@ -21,9 +27,24 @@ public class NodeLinkHelper {
     private static final String WHITE = "\u001B[37m";
     private static final String YELLOW = "\u001B[33m";
 
-    private static String STATUS = "Main";
+
     private static String PRODUCT = "Post Production";
 
+    private Terminal terminal;
+
+    private String STATUS = "OFFLINE";
+
+    public synchronized void updateStatus(String newStatus) {
+        this.STATUS = (newStatus == null) ? "" : newStatus;
+        if (this.terminal != null) {
+            fullClearAndRefresh(this.terminal);
+        }
+    }
+
+    public synchronized String getStatus() {
+        return this.STATUS;
+    }
+
     private static final int RESERVED_ROWS = 36;
 
     public static NodeLinkHelper getHelper() {
@@ -36,13 +57,29 @@ public void INITIALIZE() {
 
     private void initTerminal() {
         try {
-            Terminal terminal = TerminalBuilder.builder()
+            terminal = TerminalBuilder.builder()
                     .name("NodeLink Server")
                     .system(true)
                     .build();
 
+            CommandRegistry registry = new CommandRegistry();
+            registry.registerParentEnum(CommandsEnum.class);
+
+            TabCompleter appCompleter = new TabCompleter(registry);
+
+            CommandDispatcher dispatcher = new CommandDispatcher(registry);
+
+            CommandLogics logics = new CommandLogics(dispatcher, terminal);
+
             LineReader reader = LineReaderBuilder.builder()
                     .terminal(terminal)
+                    .completer((lineReader, parsedLine, candidates) -> {
+                        String buffer = parsedLine.line();
+                        List<String> suggestions = appCompleter.complete(buffer);
+                        for (String s : suggestions) {
+                            candidates.add(new Candidate(s));
+                        }
+                    })
                     .variable(LineReader.HISTORY_FILE, Paths.get("bin/history.txt"))
                     .option(LineReader.Option.AUTO_FRESH_LINE, true)
                     .build();
@@ -55,26 +92,28 @@ private void initTerminal() {
                 try {
                     String command = reader.readLine(prompt);
 
-                    if (command == null || command.equalsIgnoreCase("exit")) System.exit(1);
+                    if (command == null || command.equalsIgnoreCase("exit" ) || command.equalsIgnoreCase("quit")) {
+                        System.exit(1);
+                    }
 
                     if (command.equalsIgnoreCase("clear")) {
                         fullClearAndRefresh(terminal);
                         continue;
                     }
 
-                    if (command.equalsIgnoreCase("wow")) {
-                        STATUS = "Wow Mode";
-                        fullClearAndRefresh(terminal);
-                        continue;
+                    boolean handled = dispatcher.dispatch(command);
+                    if (!handled) {
+                        terminal.writer().println("Commande inconnue : " + command);
+                        terminal.flush();
                     }
 
-                    terminal.writer().println("Exécution de : " + command);
-
                 } catch (UserInterruptException | EndOfFileException e) {
-                    break;
+                    System.exit(1);
                 }
             }
-        } catch (Exception e) {}
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 
     private void fullClearAndRefresh(Terminal terminal) {
@@ -164,12 +203,12 @@ private String LOGO() {
 
     private String HEADER() {
         return """
-                 __  __       __                        ____          __            ______       ____          __  __       ______  \s
-                /\\ \\/\\ \\     /\\ \\                      /\\  _`\\       /\\ \\          /\\__  _\\     /\\  _`\\       /\\ \\/\\ \\     /\\__  _\\ \s
-                \\ \\ `\\\\ \\    \\ \\ \\                     \\ \\ \\/\\_\\     \\ \\ \\         \\/_/\\ \\/     \\ \\ \\L\\_\\     \\ \\ `\\\\ \\    \\/_/\\ \\/ \s
-                 \\ \\ , ` \\    \\ \\ \\  __     _______     \\ \\ \\/_/_     \\ \\ \\  __       \\ \\ \\      \\ \\  _\\L      \\ \\ , ` \\      \\ \\ \\ \s
-                  \\ \\ \\`\\ \\    \\ \\ \\L\\ \\   /\\______\\     \\ \\ \\L\\ \\     \\ \\ \\L\\ \\       \\_\\ \\__    \\ \\ \\L\\ \\     \\ \\ \\`\\ \\      \\ \\ \\\s
-                   \\ \\_\\ \\_\\    \\ \\____/   \\/______/      \\ \\____/      \\ \\____/       /\\_____\\    \\ \\____/      \\ \\_\\ \\_\\      \\ \\_\\
-                    \\/_/\\/_/     \\/___/                    \\/___/        \\/___/        \\/_____/     \\/___/        \\/_/\\/_/       \\/_/""";
+                 __  __       __                        ____         ____          ____         __  __        ____          ____      \s
+                /\\ \\/\\ \\     /\\ \\                      /\\  _`\\      /\\  _`\\       /\\  _`\\      /\\ \\/\\ \\      /\\  _`\\       /\\  _`\\    \s
+                \\ \\ `\\\\ \\    \\ \\ \\                     \\ \\,\\L\\_\\    \\ \\ \\L\\_\\     \\ \\ \\L\\ \\    \\ \\ \\ \\ \\     \\ \\ \\L\\_\\     \\ \\ \\L\\ \\  \s
+                 \\ \\ , ` \\    \\ \\ \\  __     _______     \\/_\\__ \\     \\ \\  _\\L      \\ \\ ,  /     \\ \\ \\ \\ \\     \\ \\  _\\L      \\ \\ ,  /  \s
+                  \\ \\ \\`\\ \\    \\ \\ \\L\\ \\   /\\______\\      /\\ \\L\\ \\    \\ \\ \\L\\ \\     \\ \\ \\\\ \\     \\ \\ \\_/ \\     \\ \\ \\L\\ \\     \\ \\ \\\\ \\ \s
+                   \\ \\_\\ \\_\\    \\ \\____/   \\/______/      \\ `\\____\\    \\ \\____/      \\ \\_\\ \\_\\    \\ `\\___/      \\ \\____/      \\ \\_\\ \\_\\
+                    \\/_/\\/_/     \\/___/                    \\/_____/     \\/___/        \\/_/\\/ /     `\\/__/        \\/___/        \\/_/\\/ /""";
     }
 }

src/main/java/io/nodelink/server/command/CommandDispatcher.java

@@ -0,0 +1,36 @@
+package io.nodelink.server.command;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+/**
+ * Dispatcher simple : associe un Enum (handler key) à une action (Consumer<String[]>).
+ * Lors de l'exécution, on trouve le noeud le plus profond et on invoque le handler enregistré pour son owner.
+ */
+public class CommandDispatcher {
+
+    private final CommandRegistry registry;
+    private final Map<Enum<?>, Consumer<String[]>> handlers = new HashMap<>();
+
+    public CommandDispatcher(CommandRegistry registry) {
+        this.registry = registry;
+    }
+
+    public void registerHandler(Enum<?> key, Consumer<String[]> action) {
+        handlers.put(key, action);
+    }
+
+    public boolean dispatch(String inputLine) {
+        if (inputLine == null || inputLine.isBlank()) return false;
+        List<String> tokens = Arrays.asList(inputLine.trim().split("\\s+"));
+        Map.Entry<CommandNode, Integer> found = registry.findDeepest(tokens);
+        CommandNode node = found.getKey();
+        if (node == null) return false;
+        Enum<?> owner = node.getOwner();
+        if (owner == null) return false;
+        Consumer<String[]> action = handlers.get(owner);
+        if (action == null) return false;
+        action.accept(tokens.toArray(new String[0]));
+        return true;
+    }
+}

src/main/java/io/nodelink/server/command/CommandLogics.java

@@ -0,0 +1,22 @@
+package io.nodelink.server.command;
+
+import io.nodelink.server.NodeLink;
+import io.nodelink.server.enums.CommandsEnum;
+import org.jline.terminal.Terminal;
+
+public class CommandLogics {
+
+    public CommandLogics(CommandDispatcher dispatcher, Terminal terminal) {
+        dispatcher.registerHandler(CommandsEnum.SERVICE_SET_CLUSTER, tokens -> {
+            terminal.writer().println("Mode cluster activé");
+
+            NodeLink.getHelper().updateStatus("Cluster");
+        });
+
+        dispatcher.registerHandler(CommandsEnum.SERVICE_SET_BONE, tokens -> {
+            terminal.writer().println("Mode bone activé");
+
+            NodeLink.getHelper().updateStatus("Bone");
+        });
+    }
+}

src/main/java/io/nodelink/server/command/CommandNode.java

@@ -0,0 +1,61 @@
+package io.nodelink.server.command;
+
+import java.util.*;
+
+public class CommandNode {
+    private final String name;
+    private final LinkedHashMap<String, CommandNode> children = new LinkedHashMap<>();
+    private Enum<?> owner;
+
+    public CommandNode(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public CommandNode addChild(CommandNode child) {
+        children.put(child.name, child);
+        return this;
+    }
+
+    public CommandNode addChild(String childName, CommandNode child) {
+        children.put(childName, child);
+        return this;
+    }
+
+    public CommandNode child(String childName) {
+        return children.computeIfAbsent(childName, CommandNode::new);
+    }
+
+    public Collection<CommandNode> getChildren() {
+        return children.values();
+    }
+
+    public Set<String> getChildNames() {
+        return children.keySet();
+    }
+
+    public CommandNode getChild(String name) {
+        return children.get(name);
+    }
+
+    public boolean hasChildren() {
+        return !children.isEmpty();
+    }
+
+    public void setOwner(Enum<?> owner) {
+        this.owner = owner;
+    }
+
+    public Enum<?> getOwner() {
+        return owner;
+    }
+
+    @Override
+    public String toString() {
+        return "CommandNode{" + name + ", children=" + children.keySet() + "}";
+    }
+}
+

src/main/java/io/nodelink/server/command/CommandRegistry.java

@@ -0,0 +1,74 @@
+package io.nodelink.server.command;
+
+import io.nodelink.server.provider.CommandsProvider;
+
+import java.util.*;
+
+/**
+ * Registre central des commandes.
+ * registerParentEnum fusionne désormais les arbres fournis par plusieurs constantes
+ * du même enum (utile si vous définissez des sous-arbres dans le même enum ParentCommands).
+ */
+public class CommandRegistry {
+
+    private final Map<String, CommandNode> roots = new LinkedHashMap<>();
+
+    public void registerParentEnum(Class<? extends Enum<?>> enumClass) {
+        if (enumClass == null) return;
+        Enum<?>[] consts = enumClass.getEnumConstants();
+        if (consts == null) return;
+        for (Enum<?> e : consts) {
+            if (e instanceof CommandsProvider cpp) {
+                CommandNode node = cpp.getCommandNode();
+                if (node != null) {
+                    // fusionner l'arbre partiel sous la racine node.getName()
+                    CommandNode root = roots.computeIfAbsent(node.getName(), CommandNode::new);
+                    merge(root, node);
+                    // si la racine n'a pas de owner et que la constante fournit un owner sur la racine, conserver
+                    if (root.getOwner() == null && node.getOwner() != null) {
+                        root.setOwner(node.getOwner());
+                    }
+                }
+            }
+        }
+    }
+
+    private void merge(CommandNode target, CommandNode src) {
+        // si src a un owner et target n'en a pas, propager l'owner du noeud racine de src
+        if (target.getOwner() == null && src.getOwner() != null) {
+            target.setOwner(src.getOwner());
+        }
+        for (CommandNode child : src.getChildren()) {
+            CommandNode existing = target.getChild(child.getName());
+            if (existing == null) {
+                // cloner l'arbre child dans target
+                target.addChild(child);
+            } else {
+                // merger récursivement
+                merge(existing, child);
+            }
+        }
+    }
+
+    public Optional<CommandNode> getRoot(String name) {
+        return Optional.ofNullable(roots.get(name));
+    }
+
+    public Collection<CommandNode> getRoots() {
+        return roots.values();
+    }
+
+    public Map.Entry<CommandNode, Integer> findDeepest(List<String> tokens) {
+        if (tokens == null || tokens.isEmpty()) return Map.entry(null, -1);
+        CommandNode current = roots.get(tokens.get(0));
+        if (current == null) return Map.entry(null, -1);
+        int idx = 0;
+        while (idx + 1 < tokens.size()) {
+            CommandNode next = current.getChild(tokens.get(idx + 1));
+            if (next == null) break;
+            current = next;
+            idx++;
+        }
+        return Map.entry(current, idx);
+    }
+}