feat: Add Repository::lock_repo

crates/core/src/backend.rs

@@ -6,15 +6,17 @@
 pub(crate) mod hotcold;
 pub(crate) mod ignore;
 pub(crate) mod local_destination;
+pub(crate) mod lock;
 pub(crate) mod node;
 pub(crate) mod stdin;
 pub(crate) mod warm_up;
 
 use std::{io::Read, ops::Deref, path::PathBuf, sync::Arc};
 
 use bytes::Bytes;
+use chrono::{DateTime, Local};
 use enum_map::Enum;
-use log::trace;
+use log::{debug, trace};
 
 #[cfg(test)]
 use mockall::mock;
@@ -337,6 +339,35 @@
     ///
     /// The result of the removal.
     fn remove(&self, tpe: FileType, id: &Id, cacheable: bool) -> RusticResult<()>;
+
+    /// Specify if the backend is able to lock files
+    fn can_lock(&self) -> bool {
+        false
+    }
+
+    /// Lock the given file.
+    ///
+    /// # Arguments
+    ///
+    /// * `tpe` - The type of the file.
+    /// * `id` - The id of the file.
+    /// * `until` - The date until when to lock. May be `None` which usually specifies a unlimited lock
+    ///
+    /// # Errors
+    ///
+    /// If the file could not be read.
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        debug!("no locking implemented. {tpe:?}, {id}, {until:?}");
+
+        if self.can_lock() {
+            unimplemented!("Using default implementation. No locking implemented in backend.");
+        } else {
+            Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ))
+        }
+    }
 }
 
 #[cfg(test)]
@@ -374,6 +405,12 @@
     fn remove(&self, tpe: FileType, id: &Id, cacheable: bool) -> RusticResult<()> {
         self.deref().remove(tpe, id, cacheable)
     }
+    fn can_lock(&self) -> bool {
+        self.deref().can_lock()
+    }
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        self.deref().lock(tpe, id, until)
+    }
 }
 
 impl ReadBackend for Arc<dyn WriteBackend> {

crates/core/src/backend/cache.rs

@@ -7,6 +7,7 @@
 };
 
 use bytes::Bytes;
+use chrono::{DateTime, Local};
 use dirs::cache_dir;
 use log::{trace, warn};
 use walkdir::WalkDir;
@@ -226,6 +227,21 @@
         }
         self.be.remove(tpe, id, cacheable)
     }
+
+    fn can_lock(&self) -> bool {
+        self.be.can_lock()
+    }
+
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        if !self.can_lock() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ));
+        }
+
+        self.be.lock(tpe, id, until)
+    }
 }
 
 /// Backend that caches data in a directory.

crates/core/src/backend/decrypt.rs

@@ -1,6 +1,7 @@
 use std::{num::NonZeroU32, sync::Arc};
 
 use bytes::Bytes;
+use chrono::{DateTime, Local};
 use crossbeam_channel::{Receiver, unbounded};
 use rayon::prelude::*;
 use zstd::stream::{copy_encode, decode_all, encode_all};
@@ -636,6 +637,21 @@
     fn remove(&self, tpe: FileType, id: &Id, cacheable: bool) -> RusticResult<()> {
         self.be.remove(tpe, id, cacheable)
     }
+
+    fn can_lock(&self) -> bool {
+        self.be.can_lock()
+    }
+
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        if !self.can_lock() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ));
+        }
+
+        self.be.lock(tpe, id, until)
+    }
 }
 
 #[cfg(test)]

crates/core/src/backend/dry_run.rs

@@ -1,4 +1,5 @@
 use bytes::Bytes;
+use chrono::{DateTime, Local};
 use zstd::decode_all;
 
 use crate::{
@@ -164,4 +165,18 @@
             self.be.remove(tpe, id, cacheable)
         }
     }
+
+    fn can_lock(&self) -> bool {
+        self.be.can_lock()
+    }
+
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        if !self.can_lock() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ));
+        }
+        self.be.lock(tpe, id, until)
+    }
 }

crates/core/src/backend/hotcold.rs

@@ -1,8 +1,10 @@
 use std::sync::Arc;
 
 use bytes::Bytes;
+use chrono::{DateTime, Local};
 
 use crate::{
+    ErrorKind, RusticError,
     backend::{FileType, ReadBackend, WriteBackend},
     error::RusticResult,
     id::Id,
@@ -98,4 +100,18 @@
         }
         Ok(())
     }
+
+    fn can_lock(&self) -> bool {
+        self.be.can_lock()
+    }
+
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        if !self.can_lock() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ));
+        }
+        self.be.lock(tpe, id, until)
+    }
 }

crates/core/src/backend/lock.rs

@@ -0,0 +1,142 @@
+use std::{process::Command, sync::Arc};
+
+use bytes::Bytes;
+use chrono::{DateTime, Local};
+use log::debug;
+
+use crate::{
+    CommandInput, ErrorKind, RusticError, RusticResult,
+    backend::{FileType, ReadBackend, WriteBackend},
+    id::Id,
+};
+
+/// A backend which warms up files by simply accessing them.
+#[derive(Clone, Debug)]
+pub struct LockBackend {
+    /// The backend to use.
+    be: Arc<dyn WriteBackend>,
+    /// The command to be called to lock files in the backend
+    command: CommandInput,
+}
+
+impl LockBackend {
+    /// Creates a new `WarmUpAccessBackend`.
+    ///
+    /// # Arguments
+    ///
+    /// * `be` - The backend to use.
+    pub fn new_lock(be: Arc<dyn WriteBackend>, command: CommandInput) -> Arc<dyn WriteBackend> {
+        Arc::new(Self { be, command })
+    }
+}
+
+impl ReadBackend for LockBackend {
+    fn location(&self) -> String {
+        self.be.location()
+    }
+
+    fn list_with_size(&self, tpe: FileType) -> RusticResult<Vec<(Id, u32)>> {
+        self.be.list_with_size(tpe)
+    }
+
+    fn read_full(&self, tpe: FileType, id: &Id) -> RusticResult<Bytes> {
+        self.be.read_full(tpe, id)
+    }
+
+    fn read_partial(
+        &self,
+        tpe: FileType,
+        id: &Id,
+        cacheable: bool,
+        offset: u32,
+        length: u32,
+    ) -> RusticResult<Bytes> {
+        self.be.read_partial(tpe, id, cacheable, offset, length)
+    }
+
+    fn list(&self, tpe: FileType) -> RusticResult<Vec<Id>> {
+        self.be.list(tpe)
+    }
+
+    fn needs_warm_up(&self) -> bool {
+        self.be.needs_warm_up()
+    }
+
+    fn warm_up(&self, tpe: FileType, id: &Id) -> RusticResult<()> {
+        self.be.warm_up(tpe, id)
+    }
+}
+
+fn path_to_id_from_file_type(tpe: FileType, id: &Id) -> String {
+    let hex_id = id.to_hex();
+    match tpe {
+        FileType::Config => "config".into(),
+        FileType::Pack => format!("data/{}/{}", &hex_id[0..2], &*hex_id),
+        _ => format!("{}/{}", tpe.dirname(), &*hex_id),
+    }
+}
+
+impl WriteBackend for LockBackend {
+    fn create(&self) -> RusticResult<()> {
+        self.be.create()
+    }
+
+    fn write_bytes(&self, tpe: FileType, id: &Id, cacheable: bool, buf: Bytes) -> RusticResult<()> {
+        self.be.write_bytes(tpe, id, cacheable, buf)
+    }
+
+    fn remove(&self, tpe: FileType, id: &Id, cacheable: bool) -> RusticResult<()> {
+        self.be.remove(tpe, id, cacheable)
+    }
+
+    fn can_lock(&self) -> bool {
+        true
+    }
+
+    fn lock(&self, tpe: FileType, id: &Id, until: Option<DateTime<Local>>) -> RusticResult<()> {
+        if !self.can_lock() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "No locking configured on backend.",
+            ));
+        }
+
+        let until = until.map_or_else(String::new, |u| u.to_rfc3339());
+
+        let path = path_to_id_from_file_type(tpe, id);
+
+        let args = self.command.args().iter().map(|c| {
+            c.replace("%id", &id.to_hex())
+                .replace("%type", tpe.dirname())
+                .replace("%path", &path)
+                .replace("%until", &until)
+        });
+
+        debug!("calling {:?}...", self.command);
+
+        let status = Command::new(self.command.command())
+            .args(args)
+            .status()
+            .map_err(|err| {
+                RusticError::with_source(
+                    ErrorKind::Internal,
+                    "error calling lock command for {tpe}, id: {id}.",
+                    err,
+                )
+                .attach_context("tpe", tpe.to_string())
+                .attach_context("id", id.to_string())
+            })?;
+
+        if !status.success() {
+            return Err(RusticError::new(
+                ErrorKind::Backend,
+                "lock command was not successful for {tpe}, id: {id}. {status}",
+            )
+            .attach_context("tpe", tpe.to_string())
+            .attach_context("id", id.to_string())
+            .attach_context("status", status.to_string()));
+        }
+
+        Ok(())
+    }
+}

crates/core/src/commands.rs

@@ -12,6 +12,7 @@ pub mod dump;
 pub mod forget;
 pub mod init;
 pub mod key;
+pub mod lock;
 pub mod merge;
 pub mod prune;
 /// The `repair` command.