feat: Add Repository::drop_index and ::drop_data_from_index

crates/core/src/index.rs

@@ -317,6 +317,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

@@ -75,6 +75,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

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

crates/core/src/repository.rs

@@ -1269,18 +1269,25 @@ pub trait IndexedTree: Open {
     type I: ReadGlobalIndex;
 
     fn index(&self) -> &Self::I;
+    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 {
+    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)]
@@ -1336,6 +1343,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.
 ///
@@ -1357,13 +1370,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(
@@ -1539,6 +1574,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> {
@@ -1764,6 +1811,18 @@ impl<P, S: IndexedFull> Repository<P, S> {
     pub fn get_blob_cached(&self, id: &Id, 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

@@ -439,6 +439,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