fix: collisions of newly written object's don't trigger collisions anymore. (#819)

It's solved by special-casing windows and assume that certain kinds of filesystem errors
are the result of a collision (with some degree of concurrency/contention).

Author: Byron

gix-odb/src/store_impls/loose/write.rs

@@ -126,7 +126,18 @@ impl Store {
             }
         }
         let file = file.into_inner();
-        file.persist(&object_path).map_err(|err| Error::Persist {
+        let res = file.persist(&object_path);
+        // On windows, we assume that such errors are due to its special filesystem semantics,
+        // on any other platform that would be a legitimate error though.
+        #[cfg(windows)]
+        if let Err(err) = &res {
+            if err.error.kind() == std::io::ErrorKind::PermissionDenied
+                || err.error.kind() == std::io::ErrorKind::AlreadyExists
+            {
+                return Ok(id);
+            }
+        }
+        res.map_err(|err| Error::Persist {
             source: err,
             target: object_path,
         })?;

gix-odb/tests/odb/store/loose.rs

@@ -70,6 +70,35 @@ mod write {
         }
         Ok(())
     }
+
+    #[test]
+    fn collisions_do_not_cause_failure() -> crate::Result {
+        let dir = tempfile::tempdir()?;
+
+        fn write_empty_trees(dir: &std::path::Path) {
+            let db = loose::Store::at(dir, gix_hash::Kind::Sha1);
+            let empty_tree = gix_object::Tree::empty();
+            for _ in 0..2 {
+                let id = db.write(&empty_tree).expect("works");
+                assert!(db.contains(id), "written objects are actually available");
+
+                let empty_blob = db.write_buf(gix_object::Kind::Blob, &[]).expect("works");
+                assert!(db.contains(empty_blob), "written objects are actually available");
+                let id = db
+                    .write_stream(gix_object::Kind::Blob, 0, &mut [].as_slice())
+                    .expect("works");
+                assert_eq!(id, empty_blob);
+                assert!(db.contains(empty_blob), "written objects are actually available");
+            }
+        }
+
+        gix_features::parallel::threads(|scope| {
+            scope.spawn(|| write_empty_trees(dir.path()));
+            scope.spawn(|| write_empty_trees(dir.path()));
+        });
+
+        Ok(())
+    }
 }
 
 mod contains {