add lock info to repofiles

Author: aawsome

crates/core/src/commands/prune.rs

@@ -38,7 +38,7 @@ use crate::{
         GlobalIndex, ReadGlobalIndex, ReadIndex,
     },
     progress::{Progress, ProgressBars},
-    repofile::{HeaderEntry, IndexBlob, IndexFile, IndexPack, SnapshotFile},
+    repofile::{indexfile::LockOption, HeaderEntry, IndexBlob, IndexFile, IndexPack, SnapshotFile},
     repository::{Open, Repository},
 };
 
@@ -434,6 +434,8 @@ struct PrunePack {
     to_do: PackToDo,
     /// The time the pack was created
     time: Option<DateTime<Local>>,
+    /// Locking information
+    lock: LockOption,
     /// The blobs in the pack
     blobs: Vec<IndexBlob>,
 }
@@ -453,6 +455,7 @@ impl PrunePack {
             delete_mark,
             to_do: PackToDo::Undecided,
             time: p.time,
+            lock: p.lock,
             blobs: p.blobs,
         }
     }
@@ -481,6 +484,7 @@ impl PrunePack {
             id: self.id,
             time: self.time,
             size: None,
+            lock: self.lock,
             blobs: self.blobs,
         }
     }
@@ -495,6 +499,7 @@ impl PrunePack {
             id: self.id,
             time: Some(time),
             size: None,
+            lock: self.lock,
             blobs: self.blobs,
         }
     }
@@ -739,6 +744,12 @@ impl PrunePlan {
                     let to_compress = repack_uncompressed && !pack.is_compressed();
                     let size_mismatch = !pack_sizer[pack.blob_type].size_ok(pack.size);
 
+                    if pack.lock.is_locked(Some(self.time)) {
+                        // keep packs which are locked
+                        pack.set_todo(PackToDo::Keep, &pi, &mut self.stats);
+                        continue;
+                    }
+
                     match (pack.delete_mark, pi.used_blobs, pi.unused_blobs) {
                         (false, 0, _) => {
                             // unused pack
@@ -1056,6 +1067,7 @@ impl PrunePlan {
                         id,
                         size: Some(size),
                         time: Some(Local::now()),
+                        lock: LockOption::NotSet,
                         blobs: Vec::new(),
                     };
                     indexer.write().unwrap().add_remove(pack)?;

crates/core/src/repofile/indexfile.rs

@@ -1,7 +1,7 @@
 use std::{cmp::Ordering, num::NonZeroU32};
 
 use chrono::{DateTime, Local};
-
+use derivative::Derivative;
 use serde_derive::{Deserialize, Serialize};
 
 use crate::{
@@ -47,6 +47,40 @@ impl IndexFile {
     }
 }
 
+/// Options for locking packfiles.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Derivative, Copy)]
+#[derivative(Default)]
+pub enum LockOption {
+    /// No lock set.
+    #[derivative(Default)]
+    NotSet,
+    /// The pack is locked forever and we have a permanent lock on the backend for the packfile
+    LockedForever,
+    /// The pack is locked until the given timestamp and we have a temporary lock on the backend for the packfile
+    LockedUntil(DateTime<Local>),
+}
+
+impl From<Option<DateTime<Local>>> for LockOption {
+    fn from(value: Option<DateTime<Local>>) -> Self {
+        value.map_or(Self::LockedForever, Self::LockedUntil)
+    }
+}
+
+impl LockOption {
+    /// Returns whether the delete option is set to `NotSet`.
+    const fn is_not_set(&self) -> bool {
+        matches!(self, Self::NotSet)
+    }
+
+    pub fn is_locked(&self, time: Option<DateTime<Local>>) -> bool {
+        match (self, time) {
+            (Self::LockedForever, _) => true,
+            (Self::LockedUntil(locktime), Some(time)) => locktime >= &time,
+            _ => false,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Default, Debug, Clone)]
 /// Index information about a `pack`
 pub struct IndexPack {
@@ -57,6 +91,9 @@ pub struct IndexPack {
     #[serde(skip_serializing_if = "Option::is_none")]
     /// The pack creation time or time when the pack was marked for deletion
     pub time: Option<DateTime<Local>>,
+    /// Indication if the pack file is locked in the backend
+    #[serde(default, skip_serializing_if = "LockOption::is_not_set")]
+    pub lock: LockOption,
     #[serde(skip_serializing_if = "Option::is_none")]
     /// The pack size
     pub size: Option<u32>,

crates/core/src/repofile/snapshotfile.rs

@@ -228,13 +228,33 @@ pub enum DeleteOption {
     Never,
     /// Remove this snapshot after the given timestamp, but prevent removing it before.
     After(DateTime<Local>),
+    /// This snapshot is locked forever. This is similar to Never, but additionally indicates that we have a permanent lock on the
+    /// backend for the snapshot file
+    LockedForever,
+    /// This snapshot pack is locked until the given timestamp and we have a temporary lock on the backend for the snapshot file
+    LockedUntil(DateTime<Local>),
+}
+
+impl From<Option<DateTime<Local>>> for DeleteOption {
+    fn from(value: Option<DateTime<Local>>) -> Self {
+        value.map_or(Self::LockedForever, Self::LockedUntil)
+    }
 }
 
 impl DeleteOption {
     /// Returns whether the delete option is set to `NotSet`.
     const fn is_not_set(&self) -> bool {
         matches!(self, Self::NotSet)
     }
+
+    /// Returns whether a lock exists which extends the given time, where `None` means "forever"
+    pub fn is_locked(&self, time: Option<DateTime<Local>>) -> bool {
+        match (self, time) {
+            (Self::LockedForever, _) => true,
+            (Self::LockedUntil(locktime), Some(time)) => locktime >= &time,
+            _ => false,
+        }
+    }
 }
 
 #[serde_with::apply(Option => #[serde(default, skip_serializing_if = "Option::is_none")])]
@@ -700,20 +720,30 @@ impl SnapshotFile {
         matches!(self.delete,DeleteOption::After(time) if time < now)
     }
 
-    /// Returns whether a snapshot must be kept now
+    /// Returns whether a snapshot must be kept at the given time
     ///
     /// # Arguments
     ///
     /// * `now` - The current time
     #[must_use]
     pub fn must_keep(&self, now: DateTime<Local>) -> bool {
         match self.delete {
-            DeleteOption::Never => true,
-            DeleteOption::After(time) if time >= now => true,
+            DeleteOption::Never | DeleteOption::LockedForever => true,
+            DeleteOption::After(time) | DeleteOption::LockedUntil(time) => time >= now,
             _ => false,
         }
     }
 
+    /// Returns whether a snapshot is locked at the given time
+    ///
+    /// # Arguments
+    ///
+    /// * `now` - The current time
+    #[must_use]
+    pub fn is_locked(&self, now: DateTime<Local>) -> bool {
+        self.delete.is_locked(Some(now))
+    }
+
     /// Modifies the snapshot setting/adding/removing tag(s) and modifying [`DeleteOption`]s.
     ///
     /// # Arguments