fix(backup): skip locked files on Windows instead of aborting (#147)

Backing up a Windows user folder aborted the whole run when any file was
held open by another process (NTUSER.DAT, browser/Outlook DBs, app lock
files), surfacing as os error 32 (ERROR_SHARING_VIOLATION).

Extend the existing soft-error classifier is_soft_backup_io_error() to
treat ERROR_SHARING_VIOLATION (32) and ERROR_LOCK_VIOLATION (33) as
per-file soft skips, matching the warn/skip/continue handling already
given to macOS dataless and Windows cloud-file cases. The backup degrades
to a partial snapshot with a per-file warning instead of failing.

Update the stale soft-error enumerations in the walk/pipeline doc
comments and add #[cfg(windows)] tests for both codes.

Author: m3nu

crates/vykar-core/src/commands/backup/pipeline/mod.rs

@@ -81,9 +81,10 @@ pub(super) enum ProcessedEntry {
     NonFile {
         item: crate::snapshot::item::Item,
     },
-    /// A file skipped due to a soft error (permission denied, not found,
-    /// or drift detected between walk and open / during read). No data
-    /// was committed for this file.
+    /// A file skipped due to a soft error (e.g. permission denied, not found,
+    /// EIO, Windows cloud-file or locked-file failure, or drift detected
+    /// between walk and open / during read). No data was committed for this
+    /// file.
     Skipped {
         path: String,
         /// Pre-formatted reason (avoids carrying `VykarError` across threads).
@@ -99,7 +100,8 @@ pub(super) enum ProcessedEntry {
     },
     /// The walker reported a soft error before it could materialize an
     /// `Item` (e.g. directory-iteration `EACCES`, Windows unsupported
-    /// reparse tag, cloud-file unavailable). Carries the failing path and
+    /// reparse tag, cloud-file unavailable, locked file held by another
+    /// process). Carries the failing path and
     /// pre-formatted reason so the consumer can emit a path-bearing
     /// warning. Mirrors `sequential.rs` `WalkEvent::Skipped` handling.
     WalkSkip {

crates/vykar-core/src/commands/backup/walk/inode_walk.rs

@@ -107,7 +107,8 @@ pub(super) fn rel_path_from_abs(abs_source: &Path, abs_path: &Path) -> String {
 pub(in crate::commands::backup) enum WalkEvent {
     Entry(WalkedEntry),
     /// A soft error occurred (permission denied, not found, EIO, or a
-    /// Windows-specific unsupported-reparse / cloud-file failure). Carries
+    /// Windows-specific unsupported-reparse / cloud-file / locked-file
+    /// (sharing or lock violation) failure). Carries
     /// the failing path and a pre-formatted reason so consumers can surface
     /// a path-bearing warning rather than just bumping an opaque counter.
     Skipped {

crates/vykar-core/src/commands/backup/walk/mod.rs

@@ -118,9 +118,9 @@ pub(super) enum Materialized {
         abs_path: PathBuf,
         metadata: fs::MetadataSummary,
     },
-    /// Soft I/O error (e.g. permission denied on readlink, Windows
-    /// unsupported reparse tag) — caller should count as error and surface
-    /// `path` + `reason` in a path-bearing warning.
+    /// Soft I/O error from the read_link step (e.g. permission denied on
+    /// readlink, Windows unsupported reparse tag) — caller should count as
+    /// error and surface `path` + `reason` in a path-bearing warning.
     SoftError { path: PathBuf, reason: String },
     /// Unsupported file type (block device, FIFO, etc.) — silent skip.
     Unsupported,
@@ -239,7 +239,8 @@ pub(super) enum WalkEntry {
         item: Item,
     },
     /// A file that was skipped due to a soft error (permission denied, not
-    /// found, EIO, Windows unsupported reparse, cloud-file). Carries the
+    /// found, EIO, Windows unsupported reparse, cloud-file, locked file).
+    /// Carries the
     /// failing path (snapshot/abs string form) and a pre-formatted reason
     /// so consumers can surface a path-bearing warning.
     Skipped {

crates/vykar-types/src/error.rs

@@ -183,6 +183,11 @@ fn is_eio(e: &std::io::Error) -> bool {
 ///   surface from `File::open` / `read` / `fstat` on cloud placeholders when
 ///   the provider can't materialize content. List intentionally narrow;
 ///   verified against winerror.h, expand only on concrete user reports.
+/// - **`ERROR_SHARING_VIOLATION` (32) and `ERROR_LOCK_VIOLATION` (33)** for
+///   files locked by another process — pervasive in a user folder (NTUSER.DAT,
+///   browser/Outlook DBs, app lock files):
+///   - `32  ERROR_SHARING_VIOLATION` — file held open by another process
+///   - `33  ERROR_LOCK_VIOLATION` — byte-range lock held (LockFileEx)
 pub fn is_soft_backup_io_error(e: &std::io::Error) -> bool {
     if matches!(
         e.kind(),
@@ -197,14 +202,16 @@ pub fn is_soft_backup_io_error(e: &std::io::Error) -> bool {
         if e.raw_os_error().is_none() && e.to_string().contains("Unsupported reparse point type") {
             return true;
         }
-        // (b) cloud-file / can't-access codes from winerror.h:
+        // (b) cloud-file / can't-access and sharing/lock codes from winerror.h:
         //     1920 ERROR_CANT_ACCESS_FILE
         //     362  ERROR_CLOUD_FILE_PROVIDER_NOT_RUNNING
         //     395  ERROR_CLOUD_FILE_ACCESS_DENIED
         //     404  ERROR_CLOUD_FILE_PROVIDER_TERMINATED
+        //     32   ERROR_SHARING_VIOLATION (file held open by another process)
+        //     33   ERROR_LOCK_VIOLATION    (byte-range lock held, LockFileEx)
         if matches!(
             e.raw_os_error(),
-            Some(1920) | Some(362) | Some(395) | Some(404)
+            Some(1920) | Some(362) | Some(395) | Some(404) | Some(32) | Some(33)
         ) {
             return true;
         }
@@ -215,8 +222,9 @@ pub fn is_soft_backup_io_error(e: &std::io::Error) -> bool {
 impl VykarError {
     /// Returns `true` for I/O errors that indicate a file was unreadable
     /// (permission denied, file vanished, EIO, or a Windows-specific
-    /// unsupported-reparse / cloud-file failure) **before** any data was
-    /// committed. These are safe to skip for partial-backup support.
+    /// unsupported-reparse / cloud-file / locked-file (sharing or lock
+    /// violation) failure) **before** any data was committed. These are safe to
+    /// skip for partial-backup support.
     pub fn is_soft_file_error(&self) -> bool {
         match self {
             VykarError::Io(e) => is_soft_backup_io_error(e),
@@ -296,8 +304,24 @@ mod tests {
 
     #[test]
     #[cfg(windows)]
-    fn non_soft_io_error_outside_cloud_file_list() {
-        // 361 is just outside the cloud-file range we recognise; treat as hard.
+    fn soft_io_error_sharing_violation() {
+        // ERROR_SHARING_VIOLATION — file held open by another process.
+        let e = std::io::Error::from_raw_os_error(32);
+        assert!(is_soft_backup_io_error(&e));
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn soft_io_error_lock_violation() {
+        // ERROR_LOCK_VIOLATION — byte-range lock held (LockFileEx).
+        let e = std::io::Error::from_raw_os_error(33);
+        assert!(is_soft_backup_io_error(&e));
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn non_soft_io_error_outside_windows_allowlist() {
+        // 361 is just outside the codes we recognise; treat as hard.
         let e = std::io::Error::from_raw_os_error(361);
         assert!(!is_soft_backup_io_error(&e));
     }