finally an understanding on collision checking (#301)

Let's not try to imitate git here but instead solve the problem our
way while learning from bugs git ran into in the process.

This will be particularly interesting when dealing with parallel
checkouts, something we need to implement for sure.

On the bright side, there seems to be opportunity for a performance
boost due to less iops during clone.

Author: Byron

git-worktree/src/index.rs

@@ -1,16 +1,35 @@
 use git_hash::oid;
 
+use crate::{index, index::checkout::Collision};
+
 pub mod checkout {
     use bstr::BString;
     use quick_error::quick_error;
 
+    #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+    pub struct Collision {
+        /// the path that collided with something already present on disk.
+        pub path: BString,
+        /// The io error we encountered when checking out `path`.
+        pub error_kind: std::io::ErrorKind,
+    }
+
+    pub struct Outcome {
+        pub collisions: Vec<Collision>,
+    }
+
     #[derive(Clone, Copy)]
     pub struct Options {
         /// capabilities of the file system
         pub fs: crate::fs::Capabilities,
         /// If true, we assume no file to exist in the target directory, and want exclusive access to it.
-        /// This should be enabled when cloning.
+        /// This should be enabled when cloning to avoid checks for freshness of files. This also enables
+        /// detection of collisions based on whether or not exclusive file creation succeeds or fails.
         pub destination_is_initially_empty: bool,
+        /// If true, default false, try to checkout as much as possible and don't abort on first error which isn't
+        /// due to a conflict.
+        /// The operation will never fail, but count the encountered errors instead along with their paths.
+        pub keep_going: bool,
         /// If true, a files creation time is taken into consideration when checking if a file changed.
         /// Can be set to false in case other tools alter the creation time in ways that interfere with our operation.
         ///
@@ -29,6 +48,7 @@ pub mod checkout {
             Options {
                 fs: Default::default(),
                 destination_is_initially_empty: false,
+                keep_going: false,
                 trust_ctime: true,
                 check_stat: true,
             }
@@ -63,24 +83,43 @@ pub fn checkout<Find>(
     path: impl AsRef<std::path::Path>,
     mut find: Find,
     options: checkout::Options,
-) -> Result<(), checkout::Error>
+) -> Result<checkout::Outcome, checkout::Error>
 where
     Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<git_object::BlobRef<'a>>,
 {
-    if !options.destination_is_initially_empty {
-        todo!("non-clone logic isn't implemented or vetted yet");
-    }
     let root = path.as_ref();
     let mut buf = Vec::new();
+    let mut collisions = Vec::new();
     for (entry, entry_path) in index.entries_mut_with_paths() {
         // TODO: write test for that
         if entry.flags.contains(git_index::entry::Flags::SKIP_WORKTREE) {
             continue;
         }
 
-        entry::checkout(entry, entry_path, &mut find, root, options, &mut buf)?;
+        let res = entry::checkout(entry, entry_path, &mut find, root, options, &mut buf);
+        match res {
+            Ok(()) => {}
+            // TODO: use ::IsDirectory as well when stabilized instead of raw_os_error()
+            Err(index::checkout::Error::Io(err))
+                if err.kind() == std::io::ErrorKind::AlreadyExists || err.raw_os_error() == Some(21) =>
+            {
+                // We are here because a file existed or was blocked by a directory which shouldn't be possible unless
+                // we are on a file insensitive file system.
+                collisions.push(Collision {
+                    path: entry_path.into(),
+                    error_kind: err.kind(),
+                });
+            }
+            Err(err) => {
+                if options.keep_going {
+                    todo!("keep going")
+                } else {
+                    return Err(err);
+                }
+            }
+        }
     }
-    Ok(())
+    Ok(checkout::Outcome { collisions })
 }
 
 pub(crate) mod entry {
@@ -109,6 +148,7 @@ pub(crate) mod entry {
                     executable_bit,
                     ..
                 },
+            destination_is_initially_empty,
             ..
         }: index::checkout::Options,
         buf: &mut Vec<u8>,
@@ -130,7 +170,10 @@ pub(crate) mod entry {
                     path: root.to_path_buf(),
                 })?;
                 let mut options = OpenOptions::new();
-                options.create(true).write(true);
+                options
+                    .create_new(destination_is_initially_empty)
+                    .create(!destination_is_initially_empty)
+                    .write(true);
                 #[cfg(unix)]
                 if executable_bit && entry.mode == git_index::entry::Mode::FILE_EXECUTABLE {
                     use std::os::unix::fs::OpenOptionsExt;
@@ -151,6 +194,8 @@ pub(crate) mod entry {
                 let symlink_destination = git_features::path::from_byte_slice(obj.data)
                     .map_err(|_| index::checkout::Error::IllformedUtf8 { path: obj.data.into() })?;
 
+                // TODO: how to deal with mode changes? Maybe this info can be passed once we check for whether
+                // a checkout is needed at all.
                 if symlink {
                     symlink::symlink_auto(symlink_destination, &dest)?;
                 } else {

git-worktree/tests/fixtures/make_ignorecase_collisions.sh

@@ -4,8 +4,17 @@ set -eu -o pipefail
 git init -q
 git config commit.gpgsign false
 
-touch a A
-git add a
-echo A | git update-index --add --stdin
+empty_oid=$(git hash-object -w --stdin </dev/null)
+
+git update-index --index-info <<-EOF
+100644 $empty_oid	FILE_X
+100644 $empty_oid	FILE_x
+100644 $empty_oid	file_X
+100644 $empty_oid	file_x
+100644 $empty_oid	D/B
+100644 $empty_oid	D/C
+100644 $empty_oid	d
+EOF
 
 git commit -m "init"
+git checkout -f HEAD;

git-worktree/tests/index/mod.rs

@@ -3,13 +3,13 @@ mod checkout {
     use std::os::unix::prelude::MetadataExt;
     use std::{
         fs,
+        io::ErrorKind,
         path::{Path, PathBuf},
     };
 
     use git_object::bstr::ByteSlice;
     use git_odb::FindExt;
-    use git_worktree::fs::Capabilities;
-    use git_worktree::index;
+    use git_worktree::{fs::Capabilities, index, index::checkout::Collision};
     use tempfile::TempDir;
 
     use crate::fixture_path;
@@ -34,9 +34,11 @@ mod checkout {
     #[test]
     fn symlinks_become_files_if_disabled() -> crate::Result {
         let opts = opts_with_symlink(false);
-        let (source_tree, destination, _index) = checkout_index_in_tmp_dir(opts, "make_mixed_without_submodules")?;
+        let (source_tree, destination, _index, outcome) =
+            checkout_index_in_tmp_dir(opts, "make_mixed_without_submodules")?;
 
         assert_equality(&source_tree, &destination, opts.fs.symlink)?;
+        assert!(outcome.collisions.is_empty());
 
         Ok(())
     }
@@ -49,9 +51,11 @@ mod checkout {
             // skip if symlinks aren't supported anyway.
             return Ok(());
         };
-        let (source_tree, destination, _index) = checkout_index_in_tmp_dir(opts, "make_mixed_without_submodules")?;
+        let (source_tree, destination, _index, outcome) =
+            checkout_index_in_tmp_dir(opts, "make_mixed_without_submodules")?;
 
         assert_equality(&source_tree, &destination, opts.fs.symlink)?;
+        assert!(outcome.collisions.is_empty());
         Ok(())
     }
 
@@ -62,11 +66,12 @@ mod checkout {
             return;
         }
         let opts = opts_with_symlink(true);
-        let (source_tree, destination, index) = checkout_index_in_tmp_dir(opts, "make_ignorecase_collisions").unwrap();
-        assert_eq!(index.entries().len(), 2, "there is just one colliding item");
+        let (source_tree, destination, index, outcome) =
+            checkout_index_in_tmp_dir(opts, "make_ignorecase_collisions").unwrap();
 
         let num_files = assert_equality(&source_tree, &destination, opts.fs.symlink).unwrap();
         assert_eq!(num_files, index.entries().len(), "it checks out all files");
+        assert!(outcome.collisions.is_empty());
     }
 
     #[test]
@@ -76,21 +81,44 @@ mod checkout {
             return;
         }
         let opts = opts_with_symlink(true);
-        let (source_tree, destination, index) = checkout_index_in_tmp_dir(opts, "make_ignorecase_collisions").unwrap();
-        assert_eq!(index.entries().len(), 2, "there is just one colliding item");
+        let (source_tree, destination, _index, outcome) =
+            checkout_index_in_tmp_dir(opts, "make_ignorecase_collisions").unwrap();
+
+        assert_eq!(
+            outcome.collisions,
+            vec![
+                Collision {
+                    path: "FILE_x".into(),
+                    error_kind: ErrorKind::AlreadyExists,
+                },
+                Collision {
+                    path: "d".into(),
+                    error_kind: ErrorKind::AlreadyExists,
+                },
+                Collision {
+                    path: "file_X".into(),
+                    error_kind: ErrorKind::AlreadyExists,
+                },
+                Collision {
+                    path: "file_x".into(),
+                    error_kind: ErrorKind::AlreadyExists,
+                },
+            ],
+            "these files couldn't be checked out"
+        );
 
         let source_files = dir_structure(&source_tree);
         assert_eq!(
             stripped_prefix(&source_tree, &source_files),
-            vec![PathBuf::from("a")],
-            "the source also only contains the first created file"
+            vec![PathBuf::from("d"), PathBuf::from("file_x")],
+            "plenty of collisions prevent a checkout"
         );
 
         let dest_files = dir_structure(&destination);
         assert_eq!(
             stripped_prefix(&destination, &dest_files),
-            vec![PathBuf::from("A")],
-            "it only creates the first file of a collision"
+            vec![PathBuf::from("D/B"), PathBuf::from("D/C"), PathBuf::from("FILE_X")],
+            "we checkout files in order and generally handle collision detection differently, hence the difference"
         );
     }
 
@@ -138,20 +166,25 @@ mod checkout {
     fn checkout_index_in_tmp_dir(
         opts: index::checkout::Options,
         name: &str,
-    ) -> crate::Result<(PathBuf, TempDir, git_index::File)> {
+    ) -> crate::Result<(
+        PathBuf,
+        TempDir,
+        git_index::File,
+        git_worktree::index::checkout::Outcome,
+    )> {
         let source_tree = fixture_path(name);
         let git_dir = source_tree.join(".git");
         let mut index = git_index::File::at(git_dir.join("index"), Default::default())?;
         let odb = git_odb::at(git_dir.join("objects"))?;
         let destination = tempfile::tempdir()?;
 
-        index::checkout(
+        let outcome = index::checkout(
             &mut index,
             &destination,
             move |oid, buf| odb.find_blob(oid, buf).ok(),
             opts,
         )?;
-        Ok((source_tree, destination, index))
+        Ok((source_tree, destination, index, outcome))
     }
 
     fn stripped_prefix(prefix: impl AsRef<Path>, source_files: &[PathBuf]) -> Vec<&Path> {