test passing

.vscode/settings.json

@@ -1,7 +1,5 @@
 {
-  "editor.rulers": [
-    80
-  ],
+  "editor.rulers": [80],
   "editor.tabSize": 2,
   "editor.detectIndentation": false,
   "editor.trimAutoWhitespace": true,
@@ -12,8 +10,21 @@
   "rust-analyzer.checkOnSave": true,
   "rust-analyzer.check.command": "clippy",
   "rust-analyzer.cargo.noDefaultFeatures": true,
-  "rust-analyzer.cargo.features": [
-    "dev",
-    "test"
-  ],
+  "rust-analyzer.cargo.features": ["dev", "test"],
+  "cSpell.words": [
+    "canonicalize",
+    "chrono",
+    "crond",
+    "curr",
+    "dialoguer",
+    "dotenv",
+    "dotenvy",
+    "errno",
+    "Insertable",
+    "nanocl",
+    "Nanocld",
+    "nstore",
+    "ntex",
+    "statefile"
+  ]
 }

bin/nanocl/src/commands/install.rs

@@ -22,7 +22,7 @@ use crate::{
 /// It will install nanocl system containers
 pub async fn exec_install(args: &InstallOpts) -> IoResult<()> {
   let home_dir = std::env::var("HOME").map_err(|err| {
-    IoError::interupted("Unable to get $HOME env variable", &err.to_string())
+    IoError::interrupted("Unable to get $HOME env variable", &err.to_string())
   })?;
   let detected_host = utils::docker::detect_docker_host()?;
   let (docker_host, is_docker_desktop) = match &args.docker_host {

bin/nanocl/src/main.rs

@@ -75,7 +75,7 @@ async fn execute_arg(cli_args: &Cli) -> IoResult<()> {
 }
 
 /// Nanocl is a command line interface for the Nanocl Daemon.
-/// It will translate the conresponding commands to the Nanocl Daemon API.
+/// It will translate the corresponding commands to the Nanocl Daemon API.
 /// You can use it to manage your cargoes and virtual machines.
 #[ntex::main]
 async fn main() -> std::io::Result<()> {
@@ -88,7 +88,7 @@ async fn main() -> std::io::Result<()> {
     std::process::exit(0);
   })
   .map_err(|err| {
-    IoError::interupted("Signal", &format!("Unable to register ctrl-c: {err}"))
+    IoError::interrupted("Signal", &format!("Unable to register ctrl-c: {err}"))
   })?;
   if let Err(err) = execute_arg(&args).await {
     err.print_and_exit();
@@ -253,24 +253,24 @@ mod tests {
   async fn state_apply_default_statefile_name() {
     let tests_path = Path::new("../../tests")
       .canonicalize()
-      .expect("Can't cannonicalize tests folder path");
+      .expect("Can't canonicalize tests folder path");
     env::set_current_dir(tests_path).expect("Can't move in tests folder");
     assert_cli_ok!("state", "apply", "-y");
     let tests_path = Path::new("./without_s_option")
       .canonicalize()
-      .expect("Can't cannonicalize without_s_option folder path");
+      .expect("Can't canonicalize without_s_option folder path");
     env::set_current_dir(tests_path)
       .expect("Can't move in without_s_option folder");
     assert_cli_ok!("state", "apply", "-y");
     let tests_path = Path::new("../without_s_option_yml")
       .canonicalize()
-      .expect("Can't cannonicalize without_s_option_yml folder path");
+      .expect("Can't canonicalize without_s_option_yml folder path");
     env::set_current_dir(tests_path)
       .expect("Can't move in without_s_option_yml folder");
     assert_cli_ok!("state", "apply", "-y");
     let tests_path = Path::new("../../bin/nanocl")
       .canonicalize()
-      .expect("Can't cannonicalize tests folder path");
+      .expect("Can't canonicalize tests folder path");
     env::set_current_dir(tests_path).expect("Can't move back in nanocl folder");
     assert_cli_err!("state", "apply", "-y");
   }
@@ -300,7 +300,7 @@ mod tests {
   }
 
   #[ntex::test]
-  async fn state_apply_args_advenced() {
+  async fn state_apply_args_advanced() {
     assert_cli_ok!(
       "state",
       "apply",
@@ -365,7 +365,7 @@ mod tests {
     assert!(
       Path::new("/tmp/toto")
         .canonicalize()
-        .expect("Can't cannonicalize bind /tmp/toto folder path")
+        .expect("Can't canonicalize bind /tmp/toto folder path")
         .exists(),
       "Relative bind was not created",
     );
@@ -472,7 +472,6 @@ mod tests {
     ntex::rt::spawn(async {
       assert_cli_ok!("cargo", "stats", CARGO_NAME);
     });
-    assert_cli_ok!("cargo", "restart", CARGO_NAME);
     assert_cli_ok!("cargo", "stop", CARGO_NAME);
     assert_cli_ok!("cargo", "ls");
     assert_cli_ok!("cargo", "ls", "-q");
@@ -494,7 +493,7 @@ mod tests {
 
   #[ntex::test]
   async fn cargo_inspect_invalid() {
-    assert_cli_err!("cargo", "inspect", "ewfwefew");
+    assert_cli_err!("cargo", "inspect", "unknown-cargo");
   }
 
   #[ntex::test]

bin/nanocld/src/models/raw_emitter.rs

@@ -75,7 +75,7 @@ impl RawEventEmitter {
   fn check_connection(&mut self) -> IoResult<()> {
     let mut alive_clients = Vec::new();
     let mut inner = self.inner.lock().map_err(|err| {
-      IoError::interupted("RawEmitterMutex", err.to_string().as_str())
+      IoError::interrupted("RawEmitterMutex", err.to_string().as_str())
     })?;
     for client in &inner.clients {
       if client.try_send(Bytes::from("")).is_err() {
@@ -106,7 +106,7 @@ impl RawEventEmitter {
   /// Send an event to all clients
   pub fn emit(&self, e: &Event) -> IoResult<()> {
     let inner = self.inner.lock().map_err(|err| {
-      IoError::interupted("RawEmitterMutex", err.to_string().as_str())
+      IoError::interrupted("RawEmitterMutex", err.to_string().as_str())
     })?;
     for client in &inner.clients {
       match e.try_to_bytes() {
@@ -128,7 +128,7 @@ impl RawEventEmitter {
       .inner
       .lock()
       .map_err(|err| {
-        IoError::interupted("RawEmitterMutex", err.to_string().as_str())
+        IoError::interrupted("RawEmitterMutex", err.to_string().as_str())
       })?
       .clients
       .push(tx);

bin/nanocld/src/models/system.rs

@@ -184,7 +184,7 @@ impl SystemState {
       .send(SystemEventKind::Emit(event))
       .await
       .map_err(|err| {
-        IoError::interupted("EventEmitter", err.to_string().as_str())
+        IoError::interrupted("EventEmitter", err.to_string().as_str())
       })?;
     Ok(())
   }
@@ -207,7 +207,7 @@ impl SystemState {
       .send(SystemEventKind::Subscribe(sx))
       .await
       .map_err(|err| {
-        IoError::interupted("EventEmitter", err.to_string().as_str())
+        IoError::interrupted("EventEmitter", err.to_string().as_str())
       })?;
     Ok(rx)
   }

bin/nanocld/src/models/task_manager.rs

@@ -1,12 +1,10 @@
 use std::{
   sync::{Arc, Mutex},
   collections::HashMap,
-  future::IntoFuture,
-  ops::Deref,
 };
 
 use ntex::{rt, web};
-use futures_util::{Future, FutureExt};
+use futures_util::Future;
 
 use nanocl_error::io::{IoResult, IoError};
 
@@ -15,15 +13,15 @@ use nanocl_stubs::system::NativeEventAction;
 #[derive(Clone)]
 pub struct ObjTask {
   pub kind: NativeEventAction,
-  pub fut: Arc<rt::JoinHandle<IoResult<()>>>,
+  pub fut: Arc<Mutex<rt::JoinHandle<IoResult<()>>>>,
 }
 
 impl ObjTask {
   pub fn new<F>(kind: NativeEventAction, task: F) -> Self
   where
     F: Future<Output = IoResult<()>> + 'static,
   {
-    let fut = Arc::new(rt::spawn(task));
+    let fut = Arc::new(Mutex::new(rt::spawn(task)));
     Self { kind, fut }
   }
 }
@@ -42,9 +40,7 @@ impl TaskManager {
     let key = key.to_owned();
     let tasks = Arc::clone(&self.tasks);
     web::block(move || {
-      let mut tasks = tasks
-        .lock()
-        .map_err(|err| IoError::interupted("Task", err.to_string().as_str()))?;
+      let mut tasks = tasks.lock()?;
       log::debug!("Adding task: {key} {}", task.kind);
       tasks.insert(key.clone(), task.clone());
       Ok::<_, IoError>(())
@@ -57,13 +53,13 @@ impl TaskManager {
     let key = key.to_owned();
     let tasks = Arc::clone(&self.tasks);
     web::block(move || {
-      let mut tasks = tasks
-        .lock()
-        .map_err(|err| IoError::interupted("Task", err.to_string().as_str()))?;
+      let mut tasks = tasks.lock().map_err(|err| {
+        IoError::interrupted("Task", err.to_string().as_str())
+      })?;
       let task = tasks.get(&key);
       if let Some(task) = task {
         log::debug!("Removing task: {key} {}", task.kind);
-        task.fut.abort();
+        task.fut.lock()?.abort();
       }
       tasks.remove(&key);
       Ok::<_, IoError>(())
@@ -76,9 +72,9 @@ impl TaskManager {
     let key = key.to_owned();
     let tasks = Arc::clone(&self.tasks);
     let res = web::block(move || {
-      let tasks = tasks
-        .lock()
-        .map_err(|err| IoError::interupted("Task", err.to_string().as_str()))?;
+      let tasks = tasks.lock().map_err(|err| {
+        IoError::interrupted("Task", err.to_string().as_str())
+      })?;
       Ok::<_, IoError>(tasks.get(&key).cloned())
     })
     .await;

bin/nanocld/src/objects/job.rs

@@ -1,11 +1,8 @@
-use bollard_next::container::RemoveContainerOptions;
-use futures_util::{StreamExt, stream::FuturesUnordered};
-
-use nanocl_error::http::{HttpResult, HttpError};
+use nanocl_error::http::HttpResult;
 use nanocl_stubs::{
   job::{Job, JobPartial, JobInspect},
   process::ProcessKind,
-  system::{NativeEventAction, ObjPsStatusPartial, ObjPsStatusKind},
+  system::{ObjPsStatusPartial, ObjPsStatusKind},
 };
 
 use crate::{

bin/nanocld/src/subsystem/docker_event.rs

@@ -85,28 +85,28 @@ async fn exec_docker(
   Ok(())
 }
 
-/// Create a new thread with his own loop to analize events from docker
-pub fn analize(state: &SystemState) {
+/// Create a new thread with his own loop to analyze events from docker
+pub fn analyze(state: &SystemState) {
   let state = state.clone();
   rt::Arbiter::new().exec_fn(move || {
     rt::spawn(async move {
       loop {
         let mut streams =
           state.docker_api.events(None::<EventsOptions<String>>);
-        log::info!("event::analize_docker: stream connected");
+        log::info!("event::analyze_docker: stream connected");
         while let Some(event) = streams.next().await {
           match event {
             Ok(event) => {
               if let Err(err) = exec_docker(&event, &state).await {
-                log::warn!("event::analize_docker: {err}")
+                log::warn!("event::analyze_docker: {err}")
               }
             }
             Err(err) => {
-              log::warn!("event::analize_docker: {err}");
+              log::warn!("event::analyze_docker: {err}");
             }
           }
         }
-        log::warn!("event::analize_docker: disconnected trying to reconnect");
+        log::warn!("event::analyze_docker: disconnected trying to reconnect");
         ntex::time::sleep(std::time::Duration::from_secs(1)).await;
       }
     });