fix: avoid empty files

Author: nachoaldamav

Cargo.toml

@@ -7,13 +7,11 @@ version = "0.0.0"
 crate-type = ["cdylib"]
 
 [dependencies]
+futures = "0.3.28"
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
 napi = { version = "2.12.2", default-features = false, features = ["napi4"] }
 napi-derive = "2.12.2"
-reflink-copy = "0.1.9"
-
-[target.'cfg(unix)'.dependencies]
-xattr = "1.0.1"
+reflink-copy = { git = "https://github.com/nachoaldamav/reflink-copy", rev = "a55b1e9" }
 
 [build-dependencies]
 napi-build = "2.0.1"

benchmark.mjs

@@ -0,0 +1,78 @@
+import { join } from 'path';
+import { mkdir, rm, writeFile, link } from 'fs/promises';
+import { linkSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { performance } from 'perf_hooks';
+import chalk from 'chalk';
+import { reflinkFileSync, reflinkFile } from './index.js';
+
+const sandboxDir = join(process.cwd(), `__link-tests-${randomUUID()}`);
+const testFilePath = join(sandboxDir, 'testFile.txt');
+
+const results = {};
+
+async function setup() {
+  await rm(sandboxDir, { recursive: true, force: true });
+  await mkdir(sandboxDir, { recursive: true });
+  await writeFile(testFilePath, 'Hello, world!');
+}
+
+async function teardown() {
+  await rm(sandboxDir, { recursive: true, force: true });
+}
+
+async function runBenchmark(name, fn) {
+  await setup();
+  const start = performance.now();
+  for (let i = 0; i < 1000; i++) {
+    const destPath = join(sandboxDir, `clone-${i}.txt`);
+    await fn(destPath);
+  }
+  const end = performance.now();
+  const time = end - start;
+  results[name] = time.toFixed(2);
+  console.log(chalk.green(`${name}: ${chalk.blue(time)} ms`));
+  await teardown();
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function main() {
+  console.log(chalk.bold('Running Benchmarks...'));
+
+  await runBenchmark('Node fs.linkSync', (destPath) => {
+    linkSync(testFilePath, destPath);
+  });
+  await delay(2000);
+
+  await runBenchmark('Node fs.promises.link', async (destPath) => {
+    await link(testFilePath, destPath);
+  });
+  await delay(2000);
+
+  await runBenchmark('reflinkFileSync', (destPath) => {
+    reflinkFileSync(testFilePath, destPath);
+  });
+  await delay(2000);
+
+  await runBenchmark('reflinkFile', async (destPath) => {
+    await reflinkFile(testFilePath, destPath);
+  });
+
+  console.log(chalk.bold('\nBenchmark Summary:'));
+  for (const [name, time] of Object.entries(results)) {
+    console.log(`${name}: ${time} ms`);
+  }
+
+  const fastest = Object.entries(results).sort((a, b) => a[1] - b[1])[0];
+  console.log(
+    chalk.green.bold(`\nFastest is ${fastest[0]} with ${fastest[1]} ms`)
+  );
+}
+
+main().catch((err) => {
+  console.error(chalk.red('An error occurred:', err));
+  process.exit(1);
+});

package.json

@@ -42,6 +42,7 @@
     "prepublishOnly": "napi prepublish -t npm",
     "pretest": "yarn build",
     "test": "cargo t && vitest",
+    "bench": "node benchmark.mjs",
     "universal": "napi universal",
     "version": "napi version"
   },

src/lib.rs

@@ -6,78 +6,28 @@ extern crate napi_derive;
 use napi::{bindgen_prelude::AsyncTask, Env, Error, JsNumber, Result, Task};
 use std::path::PathBuf;
 use reflink_copy;
-use std::fs;
-
-#[cfg(not(target_os = "windows"))]
-extern crate xattr;
 
 pub struct AsyncReflink {
     src: PathBuf,
     dst: PathBuf,
 }
 
-#[cfg(not(target_os = "windows"))]
-fn set_destination_metadata(src: &PathBuf, dst: &PathBuf) -> std::io::Result<()> {
-    let metadata_key = "user.reflink_destinations";
-    
-    let mut destinations = match xattr::get(src, metadata_key) {
-        Ok(Some(data)) => String::from_utf8_lossy(&data).to_string(),
-        _ => String::from(""),
-    };
-
-    if !destinations.is_empty() {
-        destinations.push_str(",");
-    }
-    destinations.push_str(dst.to_str().unwrap());
-
-    xattr::set(src, metadata_key, destinations.as_bytes())
-}
-
 #[napi]
 impl Task for AsyncReflink {
     type Output = ();
     type JsValue = JsNumber;
 
     fn compute(&mut self) -> Result<Self::Output> {
-        let mut retry_count = 0;
-        loop {
-            match reflink_copy::reflink(&self.src, &self.dst) {
-                Ok(_) => {
-                    #[cfg(not(target_os = "windows"))]
-                    {
-                        if let Err(err) = set_destination_metadata(&self.src, &self.dst) {
-                            return Err(Error::from_reason(err.to_string()));
-                        }
-                    }
-                    
-                    // Further validation: compare the contents of both files to make sure they are identical
-                    let src_contents = fs::read(&self.src).map_err(|e| Error::from_reason(e.to_string()))?;
-                    let dst_contents = fs::read(&self.dst).map_err(|e| Error::from_reason(e.to_string()))?;
-
-                    if src_contents != dst_contents {
-                        // Delete the destination and retry if the files are not identical
-                        fs::remove_file(&self.dst).map_err(|e| Error::from_reason(e.to_string()))?;
-                        retry_count += 1;
-
-                        if retry_count >= 3 {  // Limit the number of retries
-                            return Err(Error::from_reason(format!(
-                                "Max retries reached, could not create identical reflink for '{}' -> '{}'",
-                                self.src.display(),
-                                self.dst.display()
-                            )));
-                        }
-                        continue; // Retry the operation
-                    }
-
-                    return Ok(());
-                },
-                Err(err) => return Err(Error::from_reason(format!(
-                    "{}, reflink '{}' -> '{}'",
-                    err.to_string(),
-                    self.src.display(),
-                    self.dst.display()
-                ))),
-            }
+        match reflink_copy::reflink(&self.src, &self.dst) {
+            Ok(_) => {
+                Ok(())
+            },
+            Err(err) => return Err(Error::from_reason(format!(
+                "{}, reflink '{}' -> '{}'",
+                err.to_string(),
+                self.src.display(),
+                self.dst.display()
+            ))),
         }
     }
 
@@ -86,7 +36,6 @@ impl Task for AsyncReflink {
     }
 }
 
-
 // Async version
 #[napi(js_name = "reflinkFile")]
 pub fn reflink_task(src: String, dst: String) -> AsyncTask<AsyncReflink> {
@@ -98,58 +47,16 @@ pub fn reflink_task(src: String, dst: String) -> AsyncTask<AsyncReflink> {
 // Sync version
 #[napi(js_name = "reflinkFileSync")]
 pub fn reflink_sync(env: Env, src: String, dst: String) -> Result<JsNumber> {
-    let src_path = PathBuf::from(src.clone());
-    let dst_path = PathBuf::from(dst.clone());
-    let mut retry_count = 0;
-
-    loop {
-        // Attempt to perform reflink
-        let reflink_result = reflink_copy::reflink(&src_path, &dst_path);
-
-        match reflink_result {
-            Ok(_) => {
-                // Further validation: compare the contents of both files to make sure they are identical
-                let src_contents = fs::read(&src_path).map_err(|e| Error::from_reason(e.to_string()))?;
-                let dst_contents = fs::read(&dst_path).map_err(|e| Error::from_reason(e.to_string()))?;
-
-                if src_contents != dst_contents {
-                    if retry_count >= 3 {  // Max retry count
-                        return Err(Error::from_reason(format!(
-                            "Max retries reached, could not create identical reflink for '{}' -> '{}'",
-                            src_path.display(),
-                            dst_path.display()
-                        )));
-                    }
-                    // Remove the destination and retry
-                    if let Err(err) = fs::remove_file(&dst_path) {
-                        return Err(Error::from_reason(format!(
-                            "Failed to remove destination file '{}': {}",
-                            dst_path.display(),
-                            err.to_string()
-                        )));
-                    }
-                    retry_count += 1;
-                    continue; // Retry the operation
-                }
-                
-                // Metadata and return handling here (existing code)
-                #[cfg(not(target_os = "windows"))]
-                {
-                    if let Err(err) = set_destination_metadata(&src_path, &dst_path) {
-                        return Err(Error::from_reason(err.to_string()));
-                    }
-                }
-                return Ok(env.create_int32(0)?);
-            },
-            Err(err) => {
-                return Err(Error::from_reason(format!(
-                    "{}, reflink '{}' -> '{}'",
-                    err.to_string(),
-                    src_path.display(),
-                    dst_path.display()
-                )));
-            },
-        }
+    let src_path = PathBuf::from(src);
+    let dst_path = PathBuf::from(dst);
+    match reflink_copy::reflink(&src_path, &dst_path) {
+        Ok(_) => Ok(env.create_int32(0)?),
+        Err(err) => Err(Error::from_reason(format!(
+            "{}, reflink '{}' -> '{}'",
+            err.to_string(),
+            src_path.display(),
+            dst_path.display()
+        ))),
     }
 }
 
@@ -160,7 +67,7 @@ pub fn test_pyc_file() {
 
     // Remove the destination file if it already exists
     if dst.exists() {
-        fs::remove_file(&dst).unwrap();
+        std::fs::remove_file(&dst).unwrap();
     }
 
     // Run the reflink operation
@@ -170,13 +77,13 @@ pub fn test_pyc_file() {
     println!("Reflinked '{}' -> '{}'", src.display(), dst.display());
 
     // Further validation: compare the contents of both files to make sure they are identical
-    let src_contents = fs::read(&src).expect("Failed to read source file");
-    let dst_contents = fs::read(&dst).expect("Failed to read destination file");
+    let src_contents = std::fs::read(&src).expect("Failed to read source file");
+    let dst_contents = std::fs::read(&dst).expect("Failed to read destination file");
 
     assert_eq!(src_contents, dst_contents);
 
     // Remove the destination file
-    fs::remove_file(&dst).unwrap();
+    std::fs::remove_file(&dst).unwrap();
 
     println!("File contents match, reflink operation successful")
 }

vitest.config.mts

@@ -4,5 +4,6 @@ export default defineConfig({
   test: {
     watchExclude: ['__reflink-tests-*'],
     watch: false,
+    testTimeout: 10000,
   },
 });