feat(cli): backup management commands

Cargo.toml

@@ -12,30 +12,31 @@ name = "mbm"
 path = "src/main.rs"
 
 [dependencies]
+async-stream = { version = "0.3.6", default-features = false }
 chrono = { version = "0.4.43", default-features = false, features = ["clock"] }
 clap = { version = "4.5.54", default-features = false, features = [
-    "derive",
-    "help",
-    "std",
-    "usage",
+  "derive",
+  "help",
+  "std",
+  "usage",
 ] }
 dotenvy = "0.15.7"
 mongodb = { version = "3.5.0", default-features = false, features = [
-    "bson-3",
-    "compat-3-3-0",
-    "dns-resolver",
-    "rustls-tls",
+  "bson-3",
+  "compat-3-3-0",
+  "dns-resolver",
+  "rustls-tls",
 ] }
 ratatui = { version = "0.30.0", default-features = false, features = [
-    "crossterm",
+  "crossterm",
 ] }
-tokio = { version = "1.49.0", features = ["full"] }
-regex = "1.12.2"
 cronexpr = "1.4.0"
 futures = { version = "0.3.31", default-features = false }
+regex = "1.12.2"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { version = "1.0.149", default-features = false, features = ["std"] }
 sha2 = { version = "0.10.9", default-features = false }
+tokio = { version = "1.49.0", features = ["full"] }
 
 [profile.release]
 opt-level = "z"

src/cli/commands/backup/inspect.rs

@@ -0,0 +1,102 @@
+use std::process::exit;
+
+use chrono::DateTime;
+
+use crate::{
+  datastores::{Datastore, DatastoreTrait},
+  utils::{Config, Log},
+};
+
+pub fn inspect(name: String) {
+  let config = Config::new();
+  let Some(backup_job) = config
+    .backups
+    .values()
+    .find(|backup_job| backup_job.identifier == name)
+  else {
+    Log::error("Backup not found");
+    exit(1);
+  };
+
+  let backup_dir_prefix = format!("backup_{name}_");
+  let backups = match &backup_job.datastore {
+    Datastore::FileSystem(store) => store
+      .list_backups()
+      .unwrap_or_default()
+      .into_iter()
+      .filter_map(|store| {
+        let dir_name = store.base_path.file_name()?.to_str()?.to_string();
+
+        if dir_name.starts_with(&backup_dir_prefix) {
+          Some((dir_name, Datastore::FileSystem(store)))
+        } else {
+          None
+        }
+      })
+      .collect::<Vec<_>>(),
+
+    Datastore::S3(store) => store
+      .list_backups()
+      .unwrap_or_default()
+      .into_iter()
+      .filter_map(|store| {
+        let dir_name = store.base_path.file_name()?.to_str()?.to_string();
+
+        if dir_name.starts_with(&backup_dir_prefix) {
+          Some((dir_name, Datastore::S3(store)))
+        } else {
+          None
+        }
+      })
+      .collect::<Vec<_>>(),
+  };
+
+  let datastore_type = backup_job.datastore.as_str();
+  let datastore_base_path = match &backup_job.datastore {
+    Datastore::FileSystem(store) => store.base_path.display().to_string(),
+    Datastore::S3(store) => store.base_path.display().to_string(),
+  };
+
+  println!("-- {} --", backup_job.display_name);
+  println!("Datastore:");
+  println!("\tType: {}", datastore_type);
+  println!("\tPath: {}", datastore_base_path);
+  println!(
+    "Schedule: {:?}",
+    if let Some(schedule) = backup_job.clone().raw_schedule {
+      schedule
+    } else {
+      "disabled".to_string()
+    }
+  );
+  if let Some(next) = backup_job.get_next_run() {
+    println!("Next run: {:?}", next);
+  }
+  println!(
+    "Encryption: {}",
+    if backup_job.is_encryption_enabled() {
+      "enabled"
+    } else {
+      "disabled"
+    }
+  );
+  println!("Available backups:");
+  for (dir_name, datastore) in backups {
+    let health_state = datastore.check_backup_integrity().is_ok_and(|res| res);
+    let timestamp = dir_name
+      .rsplit("_")
+      .next()
+      .and_then(|s| s.parse::<i64>().ok())
+      .unwrap_or(0);
+    let date = match DateTime::from_timestamp_secs(timestamp) {
+      Some(value) => value.to_rfc3339(),
+      None => "Unknown date".to_string(),
+    };
+    println!(
+      "\t{} - {} - {}",
+      dir_name,
+      date,
+      if health_state { "Healthy" } else { "Unhealthy" }
+    )
+  }
+}

src/cli/commands/backup/list.rs

@@ -0,0 +1,21 @@
+use crate::utils::Config;
+use crate::utils::backup_manager::BackupJob;
+
+pub fn list() {
+  let config = Config::new();
+
+  if config.backups.is_empty() {
+    println!("No backup jobs found")
+  }
+
+  let mut backup_jobs: Vec<&BackupJob> = config.backups.values().collect();
+  backup_jobs.sort_by_key(|a| a.get_next_run());
+
+  for backup_job in backup_jobs {
+    println!(
+      "- {} - Next run: {:?}",
+      backup_job.identifier,
+      backup_job.get_next_run()
+    );
+  }
+}

src/cli/commands/backup/mod.rs

@@ -1,3 +1,9 @@
+mod inspect;
+mod list;
+mod restore;
 mod start;
 
+pub use inspect::inspect;
+pub use list::list;
+pub use restore::restore;
 pub use start::start;

src/cli/commands/backup/restore.rs

@@ -0,0 +1,37 @@
+use std::process::exit;
+
+use futures::StreamExt;
+
+use crate::utils::{Config, Log, logger::StreamEvent};
+
+pub async fn restore(name: String, target: Option<String>) {
+  let config = Config::new();
+  let Some(backup_job) = config
+    .backups
+    .values()
+    .find(|backup_job| name.starts_with(&format!("backup_{}", &backup_job.identifier)))
+  else {
+    Log::error("Backup not found");
+    exit(1);
+  };
+
+  let mut events = Box::pin(backup_job.restore_backup_to_database(name, target));
+
+  let mut has_errors = false;
+  while let Some(event) = events.next().await {
+    if matches!(event, StreamEvent::Error(_)) && !has_errors {
+      has_errors = true;
+    }
+    Log::from_stream_event(event);
+  }
+
+  if !has_errors {
+    Log::highlight(
+      format!(
+        "Backup job {} successfully executed",
+        backup_job.display_name
+      )
+      .as_str(),
+    )
+  }
+}

src/cli/commands/backup/start.rs

@@ -1,30 +1,39 @@
 use std::process::exit;
 
-use crate::{
-  Daemon,
-  utils::{config::Config, logger::Logger},
-};
+use futures::StreamExt;
+
+use crate::utils::{Config, Log, logger::StreamEvent};
 
 pub async fn start(name: String) {
   let config = Config::new();
-  let Some((_, backup_config)) = config
+  let Some(backup_job) = config
     .backups
-    .iter()
-    .find(|(backup_name, _)| **backup_name == format!("backup.{name}"))
+    .values()
+    .find(|backup_job| backup_job.identifier == name)
   else {
-    Logger::error("Backup not found");
+    Log::error("Backup not found");
     exit(1);
   };
 
-  Logger::info(format!("Starting backup job {}...", backup_config.display_name).as_str());
-  match Daemon::start_backup_job(backup_config).await {
-    Ok(_) => Logger::highlight(
+  Log::info(format!("Starting backup job {}...", backup_job.display_name).as_str());
+
+  let mut events = Box::pin(backup_job.execute());
+
+  let mut has_errors = false;
+  while let Some(event) = events.next().await {
+    if matches!(event, StreamEvent::Error(_)) && !has_errors {
+      has_errors = true;
+    }
+    Log::from_stream_event(event);
+  }
+
+  if !has_errors {
+    Log::highlight(
       format!(
         "Backup job {} successfully executed",
-        backup_config.display_name
+        backup_job.display_name
       )
       .as_str(),
-    ),
-    Err(err) => Logger::error(err.as_str()),
-  };
+    )
+  }
 }