Fail reflink_or_copy if target file already exist (#81)

Author: Vaiz

.gitignore

@@ -1,2 +1,5 @@
 /target
 **/*.rs.bk
+
+# JetBrains
+/.idea

examples/clone_or_copy.rs

@@ -0,0 +1,18 @@
+// cargo run --example clone_or_copy V:\file.bin V:\file-clone.bin
+
+fn main() -> std::io::Result<()> {
+    let args: Vec<_> = std::env::args().collect();
+    if args.len() < 3 {
+        eprintln!("Usage: {} <source_file> <target_file>", args[0]);
+        return Ok(());
+    }
+    let src_file = &args[1];
+    let tgt_file = &args[2];
+
+    let result = reflink_copy::reflink_or_copy(src_file, tgt_file)?;
+    match result {
+        Some(_) => println!("File has been copied"),
+        None => println!("File has been cloned"),
+    }
+    Ok(())
+}

examples/clonefile.rs

@@ -0,0 +1,13 @@
+// cargo run --example clonefile V:\file.bin V:\file-clone.bin
+
+fn main() -> std::io::Result<()> {
+    let args: Vec<_> = std::env::args().collect();
+    if args.len() < 3 {
+        eprintln!("Usage: {} <source_file> <target_file>", args[0]);
+        return Ok(());
+    }
+    let src_file = &args[1];
+    let tgt_file = &args[2];
+
+    reflink_copy::reflink(src_file, tgt_file)
+}

src/lib.rs

@@ -18,6 +18,7 @@ mod sys;
 
 use std::fs;
 use std::io;
+use std::io::ErrorKind;
 use std::path::Path;
 
 /// Copies a file using COW semantics.
@@ -93,6 +94,8 @@ pub fn reflink(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
 ///
 /// If the function copied a file, the return value will be `Ok(Some(written))`.
 ///
+/// If target file already exists, operation fails with [`ErrorKind::AlreadyExists`].
+///
 /// ```rust
 /// match reflink_copy::reflink_or_copy("src.txt", "dest.txt") {
 ///     Ok(None) => println!("file has been reflinked"),
@@ -116,13 +119,20 @@ pub fn reflink_or_copy(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Resu
         tracing_attributes::instrument(name = "reflink_or_copy")
     )]
     fn inner(from: &Path, to: &Path) -> io::Result<Option<u64>> {
-        if let Err(_err) = sys::reflink(from, to) {
+        if let Err(err) = sys::reflink(from, to) {
+            match err.kind() {
+                ErrorKind::NotFound | ErrorKind::PermissionDenied | ErrorKind::AlreadyExists => {
+                    return Err(err);
+                }
+                _ => {}
+            }
+
             #[cfg(feature = "tracing")]
-            tracing::warn!(?_err, "Failed to reflink, fallback to fs::copy");
+            tracing::warn!(?err, "Failed to reflink, fallback to fs::copy");
 
             fs::copy(from, to).map(Some).map_err(|err| {
                 // Both regular files and symlinks to regular files can be copied, so unlike
-                // `reflink` we don't want to report invalid input on both files and and symlinks
+                // `reflink` we don't want to report invalid input on both files and symlinks
                 if from.is_file() {
                     err
                 } else {