Implementing a read-only projection of the conserve archive for Windows

.cargo/mutants.toml

@@ -39,10 +39,12 @@ exclude_globs = [
     "backup.rs",            # almost well tested but some gaps
     "metric_recorder.rs",
     "progress.rs",
+    "src/hunk_index.rs",    # not well tested yet?
+    "src/mount/projfs.rs",  # mostly for Windows
+    "src/owner/windows.rs",
     "src/progress/term.rs",
     "src/transport.rs",     # almost well tested but some gaps
     "src/transport/s3.rs",
     "src/ui/termui.rs",
-    "src/owner/windows.rs",
     "stats.rs",
 ]

.github/workflows/rust.yml

@@ -66,11 +66,19 @@ jobs:
           cargo --version
           rustc --version
       - name: Build
-        run: >
-          cargo build --all-targets --features fail/failpoints
-      - name: Test
-        run: >
-          cargo test --features fail/failpoints -- --include-ignored
+        run: cargo build --all-targets --features fail/failpoints
+      - name: Test (without mount)
+        run:
+          cargo test --features fail/failpoints -- --skip mount
+          --include-ignored
+      - name: Test (mount)
+        run:
+          cargo test --features fail/failpoints --test mount --
+          --include-ignored
+        env:
+          # Running multiple instances in parallel might cause a crash on low-end environments
+          # when executing the mounting tests on Windows due to projfs.
+          RUST_TEST_THREADS: 1
 
   # Run rustfmt separately so that it does not block test results
   rustfmt:

Cargo.toml

@@ -8,7 +8,7 @@ license = "GPL-2.0"
 name = "conserve"
 readme = "README.md"
 repository = "https://github.com/sourcefrog/conserve/"
-version = "24.8.0"
+version = "23.11.0"
 rust-version = "1.79"
 
 [features]
@@ -81,6 +81,9 @@ whoami = "1.5.2"
 uzers = "0.11"
 nix = { version = "0.28", features = ["fs", "user"] }
 
+[target.'cfg(windows)'.dependencies]
+windows-projfs = { version = "0.1.6", features = ["dynamic-import"] }
+
 [dependencies.clap]
 version = "4.3"
 features = ["derive", "deprecated", "wrap_help"]

src/bin/conserve.rs

@@ -15,7 +15,7 @@
 
 use std::cell::RefCell;
 use std::fs::{File, OpenOptions};
-use std::io::{BufWriter, Write};
+use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock};
 use std::time::Instant;
@@ -180,6 +180,36 @@ enum Command {
         long_listing: bool,
     },
 
+    /// Mount the archive as a filesystem.
+    ///
+    /// Files and directories from all previous backups are visible.
+    ///
+    /// This is currently only supported on Windows.
+    ///
+    /// On Windows you must first enable the Projected Filesystem feature by running this command
+    /// in an elevated PowerShell:
+    ///
+    ///     Enable-WindowsOptionalFeature -Online -FeatureName Client-ProjFS -NoRestart
+    ///
+    /// ProjFS by default retains extracted files in the destination directory. This can make
+    /// access to the archive faster on subsequent mounts, but will use more disk space.
+    ///
+    /// If `--cleanup-projfs` is set, then the directory will be deleted when the projection is stopped.
+    /// Also, if this option is set, the destination directory must not exist.
+    #[cfg(windows)]
+    Mount {
+        /// The archive to mount
+        archive: String,
+
+        /// Target folder where the archive should be mounted to
+        destination: PathBuf,
+
+        /// Create the target folder and remove all temporarily created
+        /// files on exit
+        #[arg(long)]
+        cleanup_projfs: bool,
+    },
+
     /// Copy a stored tree to a restore directory.
     Restore {
         archive: String,
@@ -306,7 +336,7 @@ impl std::process::Termination for ExitCode {
 
 impl Command {
     fn run(&self, monitor: Arc<TermUiMonitor>) -> Result<ExitCode> {
-        let mut stdout = std::io::stdout();
+        let mut stdout = io::stdout();
         match self {
             Command::Backup {
                 archive,
@@ -468,6 +498,42 @@ impl Command {
                     show::show_entry_names(entry_iter, &mut stdout, *long_listing)?;
                 }
             }
+            #[cfg(windows)]
+            Command::Mount {
+                archive,
+                destination,
+                cleanup_projfs: cleanup,
+            } => {
+                use std::io::Read;
+
+                let archive = Archive::open(Transport::new(archive)?)?;
+                let options = MountOptions { clean: *cleanup };
+                let projection = match mount(archive, destination, options) {
+                    Ok(handle) => handle,
+                    Err(Error::MountDestinationExists) => {
+                        error!("Mount point {} already exists", destination.display());
+                        return Ok(ExitCode::Failure);
+                    }
+                    Err(Error::MountDestinationDoesNotExists) => {
+                        error!("Mount destination {} does not exist", destination.display());
+                        return Ok(ExitCode::Failure);
+                    }
+                    Err(error) => return Err(error),
+                };
+
+                info!(
+                    "Projection started at {}.",
+                    projection.mount_root().display()
+                );
+                {
+                    info!("Press any key to stop the projection...");
+                    let mut stdin = io::stdin();
+                    let _ = stdin.read(&mut [0u8]).unwrap();
+                }
+
+                info!("Stopping projection.");
+                drop(projection);
+            }
             Command::Restore {
                 archive,
                 destination,

src/errors.rs

@@ -167,6 +167,15 @@ pub enum Error {
     #[error("Unexpected file {path:?} in archive directory")]
     UnexpectedFile { path: String },
 
+    #[error("This feature is not implemented")]
+    NotImplemented,
+
+    #[error("The destination already exists")]
+    MountDestinationExists,
+
+    #[error("The destination does not exists")]
+    MountDestinationDoesNotExists,
+
     /// Generic IO error.
     #[error(transparent)]
     IOError {
@@ -189,6 +198,13 @@ pub enum Error {
         #[from]
         source: transport::Error,
     },
+
+    #[cfg(windows)]
+    #[error(transparent)]
+    Projection {
+        #[from]
+        source: windows_projfs::Error,
+    },
 }
 
 impl From<jsonio::Error> for Error {