introduce subcommands and lock repository/keys

Author: aawsome

src/commands/lock.rs

@@ -8,12 +8,90 @@ use abscissa_core::{Command, Runnable, Shutdown};
 use anyhow::Result;
 use chrono::{DateTime, Duration, Local};
 
-use rustic_core::LockOptions;
+use rustic_core::{FileType, LockOptions};
 
-/// `prune` subcommand
-#[allow(clippy::struct_excessive_bools)]
-#[derive(clap::Parser, Command, Debug, Clone)]
+/// `lock` subcommand
+#[derive(clap::Parser, Command, Debug)]
 pub(crate) struct LockCmd {
+    /// Subcommand to run
+    #[clap(subcommand)]
+    cmd: LockSubCmd,
+}
+
+impl Runnable for LockCmd {
+    fn run(&self) {
+        let config = RUSTIC_APP.config();
+        if config.global.dry_run {
+            println!("lock is not supported in dry-run mode");
+        } else {
+            self.cmd.run();
+        }
+    }
+}
+
+/// `lock` subcommand
+#[derive(clap::Subcommand, Debug, Runnable)]
+enum LockSubCmd {
+    /// Lock the complete repository
+    Repository(RepoSubCmd),
+    /// Lock all key files
+    Keys(KeysSubCmd),
+    /// Lock snapshots and relevant pack files
+    Snapshots(SnapSubCmd),
+}
+
+#[derive(clap::Parser, Command, Debug, Clone)]
+pub(crate) struct RepoSubCmd {
+    #[clap(long)]
+    /// Duration for how long to extend the locks (e.g. "10d"). "forever" is also allowed
+    duration: LockDuration,
+}
+
+impl Runnable for RepoSubCmd {
+    fn run(&self) {
+        if let Err(err) = self.inner_run() {
+            status_err!("{}", err);
+            RUSTIC_APP.shutdown(Shutdown::Crash);
+        };
+    }
+}
+
+impl RepoSubCmd {
+    fn inner_run(&self) -> Result<()> {
+        let config = RUSTIC_APP.config();
+        let repo = open_repository(&config.repository)?;
+        repo.lock_repo(self.duration.0)?;
+        Ok(())
+    }
+}
+
+#[derive(clap::Parser, Command, Debug, Clone)]
+pub(crate) struct KeysSubCmd {
+    #[clap(long)]
+    /// Duration for how long to extend the locks (e.g. "10d"). "forever" is also allowed
+    duration: LockDuration,
+}
+
+impl Runnable for KeysSubCmd {
+    fn run(&self) {
+        if let Err(err) = self.inner_run() {
+            status_err!("{}", err);
+            RUSTIC_APP.shutdown(Shutdown::Crash);
+        };
+    }
+}
+
+impl KeysSubCmd {
+    fn inner_run(&self) -> Result<()> {
+        let config = RUSTIC_APP.config();
+        let repo = open_repository(&config.repository)?;
+        repo.lock_repo_files(FileType::Key, self.duration.0)?;
+        Ok(())
+    }
+}
+
+#[derive(clap::Parser, Command, Debug, Clone)]
+pub(crate) struct SnapSubCmd {
     /// Extend locks even if the files are already locked long enough
     #[clap(long)]
     always_extend_lock: bool,
@@ -44,7 +122,7 @@ impl FromStr for LockDuration {
     }
 }
 
-impl Runnable for LockCmd {
+impl Runnable for SnapSubCmd {
     fn run(&self) {
         if let Err(err) = self.inner_run() {
             status_err!("{}", err);
@@ -53,7 +131,7 @@ impl Runnable for LockCmd {
     }
 }
 
-impl LockCmd {
+impl SnapSubCmd {
     fn inner_run(&self) -> Result<()> {
         let config = RUSTIC_APP.config();
         let repo = open_repository(&config.repository)?;
@@ -64,15 +142,11 @@ impl LockCmd {
             repo.get_snapshots(&self.ids)?
         };
 
-        if config.global.dry_run {
-            println!("lock is not supported in dry-run mode");
-        } else {
-            let lock_opts = LockOptions::default()
-                .always_extend_lock(self.always_extend_lock)
-                .until(self.duration.0);
+        let lock_opts = LockOptions::default()
+            .always_extend_lock(self.always_extend_lock)
+            .until(self.duration.0);
 
-            repo.lock(&lock_opts, &snapshots)?;
-        }
+        repo.lock_snaphots(&lock_opts, &snapshots)?;
 
         Ok(())
     }