Try to force-enable Windows LongPaths

Author: relrod

Cargo.lock

@@ -24,6 +24,9 @@ serde_yaml_ng = "0.10.0"
 sysinfo = "0.37.2"
 tar = "0.4.44"
 
+[target.'cfg(windows)'.dependencies]
+windows-registry = "0.6.1"
+
 [dev-dependencies]
 assert_cmd = "2.0"
 predicates = { version = "3.0", features = ["regex"] }

Cargo.toml

@@ -20,3 +20,10 @@ available:
   download `micromamba` if it was not found in `$PATH`. This is mostly useful
   for testing, but could be useful if you wish to ensure `csm` never downloads
   `micromamba` even if the one in `$PATH` should disappear.
+
+* `skip_longpaths_check` - A boolean, which, if true, disables checking for
+  LongPaths support on Windows. By default when `csm.exe` runs, it will check
+  for LongPaths support. If not already enabled, it will try to enable it. If
+  this fails (for example, because the user running `csm.exe` is not an
+  administrator), `csm.exe` will prompt for confirmation before continuing.
+  Setting this configuration option to true, disables the check entirely.

README.md

@@ -26,6 +26,10 @@ pub struct Config {
     /// the configuration file is parsed after logging is initialized. The user
     /// can technically do it, we won't error, but it won't have much effect.
     pub verbose: bool,
+
+    /// If true, skip checking for LongPaths support on Windows, and never try
+    /// to set it.
+    pub skip_longpaths_check: bool,
 }
 
 #[allow(clippy::derivable_impls)]
@@ -37,6 +41,7 @@ impl Default for Config {
             cache_dir: None,
             download_micromamba: true,
             verbose: false,
+            skip_longpaths_check: false,
         }
     }
 }

src/csmrc.rs

@@ -13,6 +13,8 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 use std::process::ExitCode;
+#[cfg(windows)]
+use windows_registry::LOCAL_MACHINE;
 
 #[derive(Parser, Debug)]
 #[command(version)]
@@ -117,6 +119,34 @@ fn main() -> ExitCode {
         );
     }
 
+    #[cfg(windows)]
+    if !config.skip_longpaths_check
+        && let Err(e) = windows_set_longpaths()
+    {
+        warn!(
+            "Error while checking or enabling LongPaths for Windows: {}",
+            e
+        );
+        eprintln!(
+            "Continuing without LongPaths support can have unwanted effects and is not recommended."
+        );
+        eprint!("Continue anyway? [y/N]: ");
+        let mut input = String::new();
+        if let Err(_) = std::io::stdin().read_line(&mut input) {
+            error!("Failed to get user input");
+        }
+        match input.trim().as_ref() {
+            "y" | "Y" | "yes" => info!(
+                "You can add the line 'skip_longpaths_check: true' to {} to skip this prompt in the future",
+                home.join(".csmrc").display()
+            ),
+            _ => {
+                error!("Exiting.");
+                return ExitCode::FAILURE;
+            }
+        }
+    }
+
     match cli.command {
         Command::Env(sub) => env::run(config, sub).finish(),
         Command::Robot(sub) => robot::run(config, sub).finish(),
@@ -150,3 +180,25 @@ fn create_mambarc(config: &Config, home: &Path) -> std::io::Result<()> {
     }
     Ok(())
 }
+
+/// On windows, check if LongPaths are enabled in the registry, and enable them
+/// if they are not.
+#[cfg(windows)]
+fn windows_set_longpaths() -> windows_registry::Result<()> {
+    let reg_path = r"SYSTEM\CurrentControlSet\Control\FileSystem";
+    let ro_key = LOCAL_MACHINE.open(reg_path)?;
+    match ro_key.get_u32("LongPathsEnabled") {
+        Ok(1) => {
+            debug!("Windows LongPathsEnabled setting is already enabled");
+            Ok(())
+        }
+        Ok(_) => {
+            info!(
+                "Enabling LongPaths in the registry, this may require administrative permissions"
+            );
+            let rw_key = LOCAL_MACHINE.create(reg_path)?;
+            rw_key.set_u32("LongPathsEnabled", 1)
+        }
+        e @ Err(_) => e.map(|_| ()),
+    }
+}