An API and a test for replacement configuration (#364)

Author: Byron

git-odb/src/lib.rs

@@ -100,6 +100,9 @@ pub struct Store {
     /// The source directory from which all content is loaded, and the central write lock for use when a directory refresh is needed.
     pub(crate) path: PathBuf,
 
+    /// A set of replacements that given a source OID return a destination OID. The vector is sorted.
+    pub(crate) replacements: Vec<(git_hash::ObjectId, git_hash::ObjectId)>,
+
     /// A list of indices keeping track of which slots are filled with data. These are usually, but not always, consecutive.
     pub(crate) index: ArcSwap<types::SlotMapIndex>,
 
@@ -123,12 +126,19 @@ pub struct Store {
 }
 
 /// Create a new cached handle to the object store with support for additional options.
-pub fn at_opts(objects_dir: impl Into<PathBuf>, options: store::init::Options) -> std::io::Result<Handle> {
-    let handle = OwnShared::new(Store::at_opts(objects_dir, options)?).to_handle();
+///
+/// `replacements` is an iterator over pairs of old and new object ids for replacement support.
+/// This means that when asking for object `X`, one will receive object `X-replaced` given an iterator like `Some((X, X-replaced))`.
+pub fn at_opts(
+    objects_dir: impl Into<PathBuf>,
+    replacements: impl IntoIterator<Item = (git_hash::ObjectId, git_hash::ObjectId)>,
+    options: store::init::Options,
+) -> std::io::Result<Handle> {
+    let handle = OwnShared::new(Store::at_opts(objects_dir, replacements, options)?).to_handle();
     Ok(Cache::from(handle))
 }
 
 /// Create a new cached handle to the object store.
 pub fn at(objects_dir: impl Into<PathBuf>) -> std::io::Result<Handle> {
-    at_opts(objects_dir, Default::default())
+    at_opts(objects_dir, Vec::new().into_iter(), Default::default())
 }

git-odb/src/store_impls/dynamic/access.rs

@@ -15,4 +15,9 @@ impl Store {
     pub fn use_multi_pack_index(&self) -> bool {
         self.use_multi_pack_index
     }
+
+    /// An iterator over replacements from object-ids `X` to `X-replaced` as `(X, X-replaced)`, sorted by the original id `X`.
+    pub fn replacements(&self) -> impl Iterator<Item = (git_hash::ObjectId, git_hash::ObjectId)> + '_ {
+        self.replacements.iter().cloned()
+    }
 }

git-odb/src/store_impls/dynamic/handle.rs

@@ -246,6 +246,7 @@ impl super::Store {
         super::Handle {
             store: self.clone(),
             refresh: RefreshMode::default(),
+            ignore_replacements: false,
             token: Some(token),
             snapshot: RefCell::new(self.collect_snapshot()),
             max_recursion_depth: Self::INITIAL_MAX_RECURSION_DEPTH,
@@ -260,6 +261,7 @@ impl super::Store {
         super::Handle {
             store: self.clone(),
             refresh: Default::default(),
+            ignore_replacements: false,
             token: Some(token),
             snapshot: RefCell::new(self.collect_snapshot()),
             max_recursion_depth: Self::INITIAL_MAX_RECURSION_DEPTH,
@@ -332,6 +334,7 @@ impl TryFrom<&super::Store> for super::Store {
     fn try_from(s: &super::Store) -> Result<Self, Self::Error> {
         super::Store::at_opts(
             s.path(),
+            s.replacements(),
             crate::store::init::Options {
                 slots: crate::store::init::Slots::Given(s.files.len().try_into().expect("BUG: too many slots")),
                 object_hash: Default::default(),
@@ -367,6 +370,7 @@ where
         super::Handle {
             store: self.store.clone(),
             refresh: self.refresh,
+            ignore_replacements: self.ignore_replacements,
             token: {
                 let token = self.store.register_handle();
                 match self.token.as_ref().expect("token is always set here ") {

git-odb/src/store_impls/dynamic/init.rs

@@ -63,8 +63,11 @@ impl Store {
     /// Note that the `slots` isn't used for packs, these are included with their multi-index or index respectively.
     /// For example, In a repository with 250m objects and geometric packing one would expect 27 index/pack pairs,
     /// or a single multi-pack index.
+    /// `replacements` is an iterator over pairs of old and new object ids for replacement support.
+    /// This means that when asking for object `X`, one will receive object `X-replaced` given an iterator like `Some((X, X-replaced))`.
     pub fn at_opts(
         objects_dir: impl Into<PathBuf>,
+        replacements: impl IntoIterator<Item = (git_hash::ObjectId, git_hash::ObjectId)>,
         Options {
             slots,
             object_hash,
@@ -97,8 +100,12 @@ impl Store {
                 "Cannot use more than 1^15 slots",
             ));
         }
+        let mut replacements: Vec<_> = replacements.into_iter().collect();
+        replacements.sort_by(|a, b| a.0.cmp(&b.0));
+
         Ok(Store {
             write: Default::default(),
+            replacements,
             path: objects_dir,
             files: Vec::from_iter(std::iter::repeat_with(MutableIndexAndPack::default).take(slot_count)),
             index: ArcSwap::new(Arc::new(SlotMapIndex::default())),

git-odb/src/store_impls/dynamic/mod.rs

@@ -19,6 +19,9 @@ where
     /// even more rare.
     pub max_recursion_depth: usize,
 
+    /// If true, replacements will not be performed even if these are available.
+    pub ignore_replacements: bool,
+
     pub(crate) token: Option<handle::Mode>,
     snapshot: RefCell<load_index::Snapshot>,
 }

git-odb/tests/odb/store/dynamic.rs

@@ -1,3 +1,4 @@
+use git_hash::ObjectId;
 use std::process::Command;
 
 use git_odb::{store, Find, FindExt, Write};
@@ -205,13 +206,13 @@ fn write() -> crate::Result {
 }
 
 #[test]
+#[ignore]
 fn object_replacement() {
     let dir = git_testtools::scripted_fixture_repo_read_only("make_replaced_history.sh").unwrap();
     let handle = git_odb::at(dir.join(".git/objects")).unwrap();
     let mut buf = Vec::new();
-    let third_commit = handle
-        .find_commit(hex_to_id("434e5a872d6738d1fffd1e11e52a1840b73668c6"), &mut buf)
-        .unwrap();
+    let short_history_link = hex_to_id("434e5a872d6738d1fffd1e11e52a1840b73668c6");
+    let third_commit = handle.find_commit(short_history_link, &mut buf).unwrap();
 
     let orphan_of_new_history = hex_to_id("0703c317e28068f39834ae61e7ab941b7d672322");
     assert_eq!(
@@ -223,6 +224,43 @@ fn object_replacement() {
     drop(third_commit);
     let orphan = handle.find_commit(orphan_of_new_history, &mut buf).unwrap();
     assert_eq!(orphan.parents.len(), 0);
+
+    let long_history_tip = hex_to_id("71f537d9d78bf6ae89a29a17e54b95a914d3d2ef");
+    let unrelated_mapping = (
+        ObjectId::null(handle.store_ref().object_hash()),
+        ObjectId::null(handle.store_ref().object_hash()),
+    );
+
+    let mut handle = git_odb::at_opts(
+        dir.join(".git/objects"),
+        vec![(short_history_link, long_history_tip), unrelated_mapping],
+        git_odb::store::init::Options { ..Default::default() },
+    )
+    .unwrap();
+    drop(orphan);
+
+    let replaced = handle.find_commit(short_history_link, &mut buf).unwrap();
+    let long_history_second_id = hex_to_id("753ccf815e7b69c9147db5bbf633fe5f7da24ad7");
+    assert_eq!(
+        replaced.parents().collect::<Vec<_>>(),
+        vec![long_history_second_id],
+        "replacements are applied by default when present"
+    );
+
+    handle.ignore_replacements = true;
+    drop(replaced);
+    let not_replaced = handle.find_commit(short_history_link, &mut buf).unwrap();
+    assert_eq!(
+        not_replaced.parents().collect::<Vec<_>>(),
+        vec![orphan_of_new_history],
+        "no replacements are made if explicitly disabled"
+    );
+
+    assert_eq!(
+        handle.store_ref().replacements().collect::<Vec<_>>(),
+        vec![unrelated_mapping, (short_history_link, long_history_tip)],
+        "one can query the list of replacements"
+    );
 }
 
 #[test]