Merge branch 'master'

Author: dmitryro

server/src/cli/cli.rs

@@ -1,61 +1,66 @@
 // server/src/cli/cli.rs
 
-// This file serves as the main entry point for the GraphDB CLI executable.
-// It parses command-line arguments and dispatches them to appropriate handlers
-// in other modules.
-
-use anyhow::Result;
-use clap::{CommandFactory, Parser};
+use clap::Parser;
 use std::process;
-use std::env; // Import std::env for accessing command-line arguments
+use std::env;
+use std::collections::HashMap;
+use tokio::sync::{oneshot, Mutex};
+use tokio::task::JoinHandle;
+use std::sync::Arc;
 
-// Import necessary items from the cli module (which re-exports from its sub-modules)
 use crate::cli::{
-    commands::{CliArgs, GraphDbCommands},
-    handlers,
-    interactive,
+    commands::{CliArgs, GraphDbCommands, StartAction, DaemonCliCommand, RestCliCommand, StorageAction, StatusArgs, StopArgs, ReloadArgs},
+    handlers::{self as handlers_mod, print_welcome_screen},
+    interactive::{self as interactive_mod, run_cli_interactive},
     daemon_management,
-    config,
-    help_display,
+    config::{self as config_mod},
+    help_display::{self as help_display_mod},
 };
 
+use anyhow::Result;
+use clap::CommandFactory;
+use lib::storage_engine::config::StorageEngineType as LibStorageEngineType;
+
 /// The main entry point for the CLI logic, called by server/src/main.rs
 /// This function parses command-line arguments and dispatches to appropriate handlers.
 #[tokio::main]
 pub async fn start_cli() -> Result<()> {
     // --- Custom Help Command Handling ---
-    // Manually check for "help" as the first argument to bypass clap's default parsing
     let args_vec: Vec<String> = env::args().collect();
     if args_vec.len() > 1 && args_vec[1].to_lowercase() == "help" {
-        let help_command_args: Vec<String> = args_vec.into_iter().skip(2).collect(); // Get args after "graphdb-cli help"
+        let help_command_args: Vec<String> = args_vec.into_iter().skip(2).collect();
         let filter_command = if help_command_args.is_empty() {
-            "".to_string() // No filter, show general help
+            "".to_string()
         } else {
-            help_command_args.join(" ") // Join all subsequent arguments as the filter string
+            help_command_args.join(" ")
         };
-        let mut cmd = CliArgs::command(); // Get the top-level Command object for clap's help generation
-        help_display::print_filtered_help_clap_generated(&mut cmd, &filter_command);
-        process::exit(0); // Exit after displaying help
+        let mut cmd = CliArgs::command();
+        help_display_mod::print_filtered_help_clap_generated(&mut cmd, &filter_command);
+        process::exit(0);
     }
     // --- End Custom Help Command Handling ---
 
-
     let args = CliArgs::parse();
 
-    // Handle internal daemon runs first. These are special invocations
-    // where the CLI executable is run as a background daemon.
     if args.internal_rest_api_run || args.internal_storage_daemon_run {
+        let converted_storage_engine = args.internal_storage_engine.map(|se_cli| {
+            match se_cli {
+                config_mod::StorageEngineType::Sled => LibStorageEngineType::Sled,
+                config_mod::StorageEngineType::RocksDB => LibStorageEngineType::RocksDB,
+                config_mod::StorageEngineType::InMemory => LibStorageEngineType::InMemory,
+            }
+        });
+
         return daemon_management::handle_internal_daemon_run(
             args.internal_rest_api_run,
             args.internal_storage_daemon_run,
             args.internal_port,
             args.internal_storage_config_path,
-            args.internal_storage_engine,
+            converted_storage_engine,
         ).await;
     }
 
-    // Load CLI configuration. If it fails, print an error and exit.
-    let config = match config::load_cli_config() {
+    let config = match config_mod::load_cli_config() {
         Ok(cfg) => cfg,
         Err(e) => {
             eprintln!("Error loading configuration: {}", e);
@@ -68,10 +73,8 @@ pub async fn start_cli() -> Result<()> {
         }
     };
 
-    // Handle direct query execution if the `--query` flag is present.
     if let Some(query_string) = args.query {
         println!("Executing direct query: {}", query_string);
-        // Assuming lib::query_parser is accessible and QueryType is defined
         use lib::query_parser::{parse_query_from_string, QueryType};
         match parse_query_from_string(&query_string) {
             Ok(parsed_query) => match parsed_query {
@@ -81,10 +84,17 @@ pub async fn start_cli() -> Result<()> {
             },
             Err(e) => eprintln!("Error parsing query: {}", e),
         }
-        return Ok(()); // Exit after processing a direct query
+        return Ok(());
     }
 
-    // Handle explicit command execution if a subcommand is provided.
+    // Shared state for interactive mode to manage daemon processes
+    let daemon_handles: Arc<Mutex<HashMap<u16, (JoinHandle<()>, oneshot::Sender<()>)>>> = Arc::new(Mutex::new(HashMap::new()));
+    let rest_api_shutdown_tx_opt: Arc<Mutex<Option<oneshot::Sender<()>>>> = Arc::new(Mutex::new(None));
+    let rest_api_port_arc: Arc<Mutex<Option<u16>>> = Arc::new(Mutex::new(None));
+    let rest_api_handle: Arc<Mutex<Option<JoinHandle<()>>>> = Arc::new(Mutex::new(None));
+
+    let should_enter_interactive_mode = args.cli || args.command.is_none();
+
     if let Some(command) = args.command {
         if args.enable_plugins {
             println!("Experimental plugins are enabled.");
@@ -128,53 +138,108 @@ pub async fn start_cli() -> Result<()> {
                     println!("Executing cache-node-state with no node ID specified");
                 }
             }
-            GraphDbCommands::Start { port, cluster, listen_port, storage_port, storage_config_file } => {
-                // Delegate to the handler module for 'start' command logic
-                handlers::handle_start_command(port, cluster, listen_port, storage_port, storage_config_file, &config).await?;
+            GraphDbCommands::Start(start_args) => {
+                match start_args.action {
+                    StartAction::All { port, cluster, listen_port, storage_port, storage_config_file } => {
+                        handlers_mod::handle_start_all_interactive(
+                            port,
+                            cluster,
+                            listen_port,
+                            storage_port,
+                            storage_config_file,
+                            daemon_handles.clone(),
+                            rest_api_shutdown_tx_opt.clone(),
+                            rest_api_port_arc.clone(),
+                            rest_api_handle.clone(),
+                        ).await?;
+                    }
+                    StartAction::Daemon { port, cluster } => {
+                        handlers_mod::handle_daemon_command_interactive(
+                            DaemonCliCommand::Start { port, cluster },
+                            daemon_handles.clone(),
+                        ).await?;
+                    }
+                    StartAction::Rest { port, listen_port } => {
+                        handlers_mod::handle_rest_command_interactive(
+                            RestCliCommand::Start { port, listen_port },
+                            rest_api_shutdown_tx_opt.clone(),
+                            rest_api_port_arc.clone(),
+                            rest_api_handle.clone(),
+                        ).await?;
+                    }
+                    StartAction::Storage { port, config_file } => {
+                        handlers_mod::handle_storage_command_interactive(
+                            StorageAction::Start { port, config_file },
+                        ).await?;
+                    }
+                }
             }
             GraphDbCommands::Stop(stop_args) => {
-                // Delegate to the handler module for 'stop' command logic
-                handlers::handle_stop_command(stop_args).await?;
+                handlers_mod::handle_stop_command(stop_args).await?;
             }
             GraphDbCommands::Status(status_args) => {
-                // Delegate to the handler module for 'status' command logic
-                handlers::handle_status_command(status_args).await?;
+                handlers_mod::handle_status_command(status_args).await?;
+            }
+            GraphDbCommands::Reload(reload_args) => {
+                handlers_mod::handle_reload_command(
+                    reload_args,
+                    daemon_handles.clone(),
+                    rest_api_shutdown_tx_opt.clone(),
+                    rest_api_port_arc.clone(),
+                    rest_api_handle.clone(),
+                ).await?;
             }
             GraphDbCommands::Storage(storage_action) => {
-                // Delegate to the handler module for 'storage' command logic
-                handlers::handle_storage_command(storage_action).await?;
+                handlers_mod::handle_storage_command_interactive(storage_action).await?;
             }
             GraphDbCommands::Daemon(daemon_cmd) => {
-                // Delegate to the handler module for 'daemon' command logic
-                handlers::handle_daemon_command(daemon_cmd).await?;
+                handlers_mod::handle_daemon_command_interactive(daemon_cmd, daemon_handles.clone()).await?;
             }
             GraphDbCommands::Rest(rest_cmd) => {
-                // Delegate to the handler module for 'rest' command logic
-                handlers::handle_rest_command(rest_cmd).await?;
+                handlers_mod::handle_rest_command_interactive(
+                    rest_cmd,
+                    rest_api_shutdown_tx_opt.clone(),
+                    rest_api_port_arc.clone(),
+                    rest_api_handle.clone(),
+                ).await?;
+            }
+            GraphDbCommands::Auth(auth_args) => {
+                println!("Auth command received: {:?}", auth_args);
+            }
+            GraphDbCommands::Authenticate(auth_args) => {
+                println!("Authenticate command received: {:?}", auth_args);
+            }
+            GraphDbCommands::Register(register_args) => {
+                println!("Register command received: {:?}", register_args);
+            }
+            GraphDbCommands::Version => {
+                println!("Version command received.");
+            }
+            GraphDbCommands::Health => {
+                println!("Health command received.");
+            }
+            GraphDbCommands::Clear | GraphDbCommands::Clean => {
+                handlers_mod::clear_terminal_screen().await?;
             }
-            // The GraphDbCommands::Help variant is removed, as 'help' is now handled manually.
         }
-        return Ok(()); // Exit after processing a direct command
+        return Ok(());
     }
 
-    // If no specific command or query is given, and `--cli` flag is present,
-    // or if no arguments are given at all, enter interactive CLI mode.
-    if args.cli {
+    if should_enter_interactive_mode {
         if args.enable_plugins {
             println!("Experimental plugins are enabled.");
         }
-        interactive::run_cli_interactive().await?;
-        return Ok(());
-    }
-
-    // If only `--enable-plugins` is given without other commands.
-    if args.enable_plugins {
+        // print_welcome_screen(); // Removed: This is now handled by interactive_mod::run_cli_interactive
+        interactive_mod::run_cli_interactive(
+            daemon_handles,
+            rest_api_shutdown_tx_opt,
+            rest_api_port_arc,
+            rest_api_handle,
+        ).await?;
+    } else if args.enable_plugins {
         println!("Experimental plugins is enabled.");
-        return Ok(());
     }
 
-    // Default to interactive CLI if no other commands/args are given
-    interactive::run_cli_interactive().await?;
     Ok(())
 }