feat: Add Repository::drop_index and ::drop_data_from_index (#166)

Adds the methods `drop_index` and `drop_data_from_index` to
`Repository`. This can be handy to save memory if the index is no longer
needed.

---------

Signed-off-by: simonsan <14062932+simonsan@users.noreply.github.com>
Co-authored-by: simonsan <14062932+simonsan@users.noreply.github.com>

crates/core/src/index.rs

@@ -319,6 +319,12 @@ impl GlobalIndex {
             }
         }
     }
+
+    pub(crate) fn drop_data(self) -> Self {
+        Self {
+            index: Arc::new(self.into_index().drop_data()),
+        }
+    }
 }
 
 impl ReadGlobalIndex for GlobalIndex {}

crates/core/src/index/binarysorted.rs

@@ -77,6 +77,23 @@ pub(crate) struct TypeIndex {
 #[derive(Debug)]
 pub struct Index(BlobTypeMap<TypeIndex>);
 
+impl Index {
+    /// drop all index entries related to data blobs
+    pub(crate) fn drop_data(self) -> Self {
+        Self(self.0.map(|blob_type, i| {
+            if blob_type == BlobType::Data {
+                TypeIndex {
+                    packs: Vec::new(),
+                    entries: EntriesVariants::None,
+                    total_size: 0,
+                }
+            } else {
+                i
+            }
+        }))
+    }
+}
+
 impl IndexCollector {
     #[must_use]
     pub fn new(tpe: IndexType) -> Self {

crates/core/src/lib.rs

@@ -152,7 +152,7 @@ pub use crate::{
         PathList, SnapshotGroup, SnapshotGroupCriterion, SnapshotOptions, StringList,
     },
     repository::{
-        CommandInput, FullIndex, IndexedFull, IndexedIds, IndexedStatus, IndexedTree, OpenStatus,
-        Repository, RepositoryOptions,
+        CommandInput, FullIndex, IndexedFull, IndexedIds, IndexedStatus, IndexedTree, Open,
+        OpenStatus, Repository, RepositoryOptions,
     },
 };

crates/core/src/repository.rs

@@ -1288,20 +1288,30 @@ pub trait IndexedTree: Open {
     /// The used index
     type I: ReadGlobalIndex;
 
-    /// Returns the used indexs
+    /// Returns the used indexes
     fn index(&self) -> &Self::I;
+
+    /// Turn the repository into the `Open` state
+    fn into_open(self) -> impl Open;
 }
 
 /// A repository which is indexed such that all tree blobs are contained in the index
 /// and additionally the `Id`s of data blobs are also contained in the index.
-pub trait IndexedIds: IndexedTree {}
+pub trait IndexedIds: IndexedTree {
+    /// Turn the repository into the `IndexedTree` state by reading and storing a size-optimized index
+    fn into_indexed_tree(self) -> impl IndexedTree;
+}
 
 impl<P, S: IndexedTree> IndexedTree for Repository<P, S> {
     type I = S::I;
 
     fn index(&self) -> &Self::I {
         self.status.index()
     }
+
+    fn into_open(self) -> impl Open {
+        self.status.into_open()
+    }
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -1357,6 +1367,12 @@ pub struct IndexedStatus<T, S: Open> {
     open: S,
 }
 
+#[derive(Debug, Clone, Copy)]
+/// A type of an index, that only contains [`Id`]s.
+///
+/// Used for the [`IndexedTrees`] state of a repository in [`IndexedStatus`].
+pub struct TreeIndex;
+
 #[derive(Debug, Clone, Copy)]
 /// A type of an index, that only contains [`Id`]s.
 ///
@@ -1378,13 +1394,35 @@ impl<T, S: Open> IndexedTree for IndexedStatus<T, S> {
     fn index(&self) -> &Self::I {
         &self.index
     }
+
+    fn into_open(self) -> impl Open {
+        self.open
+    }
 }
 
-impl<S: Open> IndexedIds for IndexedStatus<IdIndex, S> {}
+impl<S: Open> IndexedIds for IndexedStatus<IdIndex, S> {
+    fn into_indexed_tree(self) -> impl IndexedTree {
+        Self {
+            index: self.index.drop_data(),
+            ..self
+        }
+    }
+}
 
-impl<S: Open> IndexedIds for IndexedStatus<FullIndex, S> {}
+impl<S: Open> IndexedIds for IndexedStatus<FullIndex, S> {
+    fn into_indexed_tree(self) -> impl IndexedTree {
+        Self {
+            index: self.index.drop_data(),
+            ..self
+        }
+    }
+}
 
-impl<P, S: IndexedFull> IndexedIds for Repository<P, S> {}
+impl<P, S: IndexedFull> IndexedIds for Repository<P, S> {
+    fn into_indexed_tree(self) -> impl IndexedTree {
+        self.status.into_indexed_tree()
+    }
+}
 
 impl<S: Open> IndexedFull for IndexedStatus<FullIndex, S> {
     fn get_blob_or_insert_with(
@@ -1561,6 +1599,18 @@ impl<P, S: IndexedTree> Repository<P, S> {
     ) -> RusticResult<FindMatches> {
         Tree::find_matching_nodes(self.dbe(), self.index(), ids, matches)
     }
+
+    /// drop the `Repository` index leaving an `Open` `Repository`
+    pub fn drop_index(self) -> Repository<P, impl Open> {
+        Repository {
+            name: self.name,
+            be: self.be,
+            be_hot: self.be_hot,
+            opts: self.opts,
+            pb: self.pb,
+            status: self.status.into_open(),
+        }
+    }
 }
 
 impl<P: ProgressBars, S: IndexedTree> Repository<P, S> {
@@ -1786,6 +1836,18 @@ impl<P, S: IndexedFull> Repository<P, S> {
     pub fn get_blob_cached(&self, id: &BlobId, tpe: BlobType) -> RusticResult<Bytes> {
         self.get_blob_or_insert_with(id, || self.index().blob_from_backend(self.dbe(), tpe, id))
     }
+
+    /// drop the data pack information from the `Repository` index leaving an `IndexedTree` `Repository`
+    pub fn drop_data_from_index(self) -> Repository<P, impl IndexedTree> {
+        Repository {
+            name: self.name,
+            be: self.be,
+            be_hot: self.be_hot,
+            opts: self.opts,
+            pb: self.pb,
+            status: self.status.into_indexed_tree(),
+        }
+    }
 }
 
 impl<P: ProgressBars, S: IndexedFull> Repository<P, S> {

crates/core/tests/integration.rs

@@ -528,6 +528,8 @@ fn test_prune(
     let paths = PathList::from_iter(Some(source.0.path().join("0/0/9/3")));
     let _ = repo.backup(&opts, &paths, SnapshotFile::default())?;
 
+    // drop index
+    let repo = repo.drop_index();
     repo.delete_snapshots(&[snapshot1.id])?;
 
     // get prune plan