[Code Refactoring]: updated dependencies. Improved error handling in main.rs for better clarity

Author: LorenzoTettamanti

cli/Cargo.lock

@@ -11,15 +11,15 @@ license = "Apache-2.0"
 readme = "../README.md"
 
 [dependencies]
-clap = { version = "4.5.38", features = ["derive"] }
+clap = { version = "4.5.51", features = ["derive"] }
 colored = "3.0.0"
 directories = "6.0.0"
 serde = { version = "1.0.219", features = ["derive"] }
 tracing = "0.1.41"
 tokio = {version = "1.47.0",features = ["macros",'rt-multi-thread']}
-anyhow = "1.0.98"
-tonic = "0.14.1"
-tonic-reflection = "0.14.1"
+anyhow = "1.0.100"
+tonic = "0.14.2"
+tonic-reflection = "0.14.2"
 prost-types = "0.14.1"
 prost = "0.14.1"
 cortexflow_agent_api = {path = "../core/api",features = ["client"]}

cli/Cargo.toml

@@ -1,4 +1,3 @@
-use std::fmt::format;
 use std::{ collections::BTreeMap, fmt, process::Command, result::Result::Ok };
 
 use kube::core::ErrorResponse;
@@ -67,6 +66,11 @@ impl From<anyhow::Error> for CliError {
         CliError::MonitoringError { reason: format!("{}", e) }
     }
 }
+impl From<()> for CliError {
+    fn from (v: ()) -> Self{
+        return ().into()
+    }
+}
 
 // docs:
 // fmt::Display implementation for CliError type. Creates a user friendly message error message.

cli/src/essential.rs

@@ -8,7 +8,6 @@ mod service;
 mod status;
 mod uninstall;
 
-use clap::command;
 use clap::{ Args, Parser, Subcommand };
 use colored::Colorize;
 use std::result::Result::Ok;
@@ -72,81 +71,66 @@ async fn args_parser() -> Result<(), CliError> {
         Some(Commands::Install(installation_args)) =>
             match installation_args.install_cmd {
                 InstallCommands::All => {
-                    install_cortexflow().await?;
-                    Ok(())
+                    install_cortexflow().await.map_err(|e| eprintln!("{}",e) )?;
                 }
                 InstallCommands::TestPods => {
-                    install_simple_example().await?;
-                    Ok(())
+                    install_simple_example().await.map_err(|e| eprintln!("{}",e) )?;
                 }
             }
         Some(Commands::Uninstall) => {
-            uninstall().await?;
-            Ok(())
+            uninstall().await.map_err(|e| eprintln!("{}",e) )?;
         }
         Some(Commands::Update) => {
             update_cli();
-            Ok(())
         }
         Some(Commands::Info) => {
             info();
-            Ok(())
         }
         Some(Commands::Service(service_args)) =>
             match service_args.service_cmd {
                 ServiceCommands::List { namespace } => {
-                    list_services(namespace).await?;
-                    Ok(())
+                    list_services(namespace).await.map_err(|e| eprintln!("{}",e) )?;
                 }
                 ServiceCommands::Describe { service_name, namespace } => {
-                    describe_service(service_name, &namespace).await?;
-                    Ok(())
+                    describe_service(service_name, &namespace).await.map_err(|e| eprintln!("{}",e) )?;
                 }
             }
         Some(Commands::Status(status_args)) => {
-            status_command(status_args.output, status_args.namespace).await?;
-            Ok(())
+            status_command(status_args.output, status_args.namespace).await.map_err(|e| eprintln!("{}",e) )?;
         }
         Some(Commands::Logs(logs_args)) => {
-            logs_command(logs_args.service, logs_args.component, logs_args.namespace).await?;
-            Ok(())
+            logs_command(logs_args.service, logs_args.component, logs_args.namespace).await.map_err(|e| eprintln!("{}",e) )?;
         }
         Some(Commands::Monitor(monitor_args)) =>
             match monitor_args.monitor_cmd {
                 MonitorCommands::List => {
-                    let _ = list_features().await?;
-                    Ok(())
+                    let _ = list_features().await.map_err(|e| eprintln!("{}",e) )?;
                 }
                 MonitorCommands::Connections => {
-                    let _ = monitor_identity_events().await?;
-                    Ok(())
+                    let _ = monitor_identity_events().await.map_err(|e| eprintln!("{}",e) )?;
                 }
             }
         Some(Commands::Policies(policies_args)) => {
             match policies_args.policy_cmd {
                 PoliciesCommands::CheckBlocklist => {
-                    let _ = check_blocklist().await?;
-                    Ok(())
+                    let _ = check_blocklist().await.map_err(|e| eprintln!("{}",e) )?;
                 }
                 PoliciesCommands::CreateBlocklist => {
                     // pass the ip as a monitoring flag
                     match policies_args.flags {
                         None => {
-                            println!("{}", "Insert at least one ip to create a blocklist".red());
-                            Ok(())
+                            eprintln!("{}", "Insert at least one ip to create a blocklist".red());
                         }
                         Some(ip) => {
                             println!("inserted ip: {} ", ip);
                             //insert the ip in the blocklist
                             match create_blocklist(&ip).await {
                                 Ok(_) => {
                                     //update the config metadata
-                                    let _ = update_config_metadata(&ip, "add").await?;
-                                    Ok(())
+                                    let _ = update_config_metadata(&ip, "add").await.map_err(|e| eprintln!("{}",e) )?;
                                 }
                                 Err(e) => {
-                                    println!("{}", e);
-                                    Ok(())
+                                    eprintln!("{}", e);
                                 }
                             }
                         }
@@ -155,22 +139,19 @@ async fn args_parser() -> Result<(), CliError> {
                 PoliciesCommands::RemoveIpFromBlocklist =>
                     match policies_args.flags {
                         None => {
-                            println!(
+                            eprintln!(
                                 "{}",
                                 "Insert at least one ip to remove from the blocklist".red()
                             );
-                            Ok(())
                         }
                         Some(ip) => {
                             println!("Inserted ip: {}", ip);
                             match remove_ip(&ip).await {
                                 Ok(_) => {
-                                    let _ = update_config_metadata(&ip, "delete").await?;
-                                    Ok(())
+                                    let _ = update_config_metadata(&ip, "delete").await.map_err(|e| eprintln!("{}",e) )?;
                                 }
                                 Err(e) => {
-                                    println!("{}", e);
-                                    Ok(())
+                                    eprintln!("{}", e);
                                 }
                             }
                         }
@@ -179,9 +160,9 @@ async fn args_parser() -> Result<(), CliError> {
         }
         None => {
             eprintln!("CLI unknown argument. Cli arguments passed: {:?}", args.cmd);
-            Ok(())
         }
     }
+    Ok(())
 }
 
 #[tokio::main]