Update shim behavior on Windows to use scripts

charlespierce · charlespierce · commit fa04c75e73e4 · 2024-05-15T23:25:11.000-07:00
Rather than using symlinks, which require administrator privileges
or developer mode on Windows, we can instead use small scripts that
call out to 'volta run' to actually handle the execution of 3rd
party binaries.

This also adds a migration to a new v4 layout, which allows Windows
installs to migrate immediately to using the script-based shims.
diff --git a/crates/volta-core/src/layout/mod.rs b/crates/volta-core/src/layout/mod.rs
@@ -5,7 +5,7 @@ use crate::error::{Context, ErrorKind, Fallible};
 use cfg_if::cfg_if;
 use dunce::canonicalize;
 use once_cell::sync::OnceCell;
-use volta_layout::v3::{VoltaHome, VoltaInstall};
+use volta_layout::v4::{VoltaHome, VoltaInstall};
 
 cfg_if! {
     if #[cfg(unix)] {
diff --git a/crates/volta-core/src/shim.rs b/crates/volta-core/src/shim.rs
@@ -1,16 +1,18 @@
 //! Provides utilities for modifying shims for 3rd-party executables
 
 use std::collections::HashSet;
-use std::fs::{self, DirEntry, Metadata};
+use std::fs;
 use std::io;
 use std::path::Path;
 
 use crate::error::{Context, ErrorKind, Fallible, VoltaError};
-use crate::fs::{read_dir_eager, symlink_file};
-use crate::layout::{volta_home, volta_install};
+use crate::fs::read_dir_eager;
+use crate::layout::volta_home;
 use crate::sync::VoltaLock;
 use log::debug;
 
+pub use platform::create;
+
 pub fn regenerate_shims_for_dir(dir: &Path) -> Fallible<()> {
     // Acquire a lock on the Volta directory, if possible, to prevent concurrent changes
     let _lock = VoltaLock::acquire();
@@ -30,7 +32,8 @@ fn get_shim_list_deduped(dir: &Path) -> Fallible<HashSet<String>> {
 
     #[cfg(unix)]
     {
-        let mut shims: HashSet<String> = contents.filter_map(entry_to_shim_name).collect();
+        let mut shims: HashSet<String> =
+            contents.filter_map(platform::entry_to_shim_name).collect();
         shims.insert("node".into());
         shims.insert("npm".into());
         shims.insert("npx".into());
@@ -43,19 +46,7 @@ fn get_shim_list_deduped(dir: &Path) -> Fallible<HashSet<String>> {
     #[cfg(windows)]
     {
         // On Windows, the default shims are installed in Program Files, so we don't need to generate them here
-        Ok(contents.filter_map(entry_to_shim_name).collect())
-    }
-}
-
-fn entry_to_shim_name((entry, metadata): (DirEntry, Metadata)) -> Option<String> {
-    if metadata.file_type().is_symlink() {
-        entry
-            .path()
-            .file_stem()
-            .and_then(|stem| stem.to_str())
-            .map(|stem| stem.to_string())
-    } else {
-        None
+        Ok(contents.filter_map(platform::entry_to_shim_name).collect())
     }
 }
 
@@ -67,35 +58,11 @@ pub enum ShimResult {
     DoesntExist,
 }
 
-pub fn create(shim_name: &str) -> Fallible<ShimResult> {
-    let executable = volta_install()?.shim_executable();
-    let shim = volta_home()?.shim_file(shim_name);
-
-    #[cfg(windows)]
-    windows::create_git_bash_script(shim_name)?;
-
-    match symlink_file(executable, shim) {
-        Ok(_) => Ok(ShimResult::Created),
-        Err(err) => {
-            if err.kind() == io::ErrorKind::AlreadyExists {
-                Ok(ShimResult::AlreadyExists)
-            } else {
-                Err(VoltaError::from_source(
-                    err,
-                    ErrorKind::ShimCreateError {
-                        name: shim_name.to_string(),
-                    },
-                ))
-            }
-        }
-    }
-}
-
 pub fn delete(shim_name: &str) -> Fallible<ShimResult> {
     let shim = volta_home()?.shim_file(shim_name);
 
     #[cfg(windows)]
-    windows::delete_git_bash_script(shim_name)?;
+    platform::delete_git_bash_script(shim_name)?;
 
     match fs::remove_file(shim) {
         Ok(_) => Ok(ShimResult::Deleted),
@@ -114,28 +81,111 @@ pub fn delete(shim_name: &str) -> Fallible<ShimResult> {
     }
 }
 
-/// These methods are a (hacky) workaround for an issue with Git Bash on Windows
-/// When executing the shim symlink, Git Bash resolves the symlink first and then calls shim.exe directly
-/// This results in the shim being unable to determine which tool is being executed
-/// However, both cmd.exe and PowerShell execute the symlink correctly
-/// To fix the issue specifically in Git Bash, we write a bash script in the shim dir, with the same name as the shim
-/// minus the '.exe' (e.g. we write `ember` next to the symlink `ember.exe`)
-/// Since the file doesn't have a file extension, it is ignored by cmd.exe and PowerShell, but is detected by Bash
-/// This bash script simply calls the shim using `cmd.exe`, so that it is resolved correctly
+#[cfg(unix)]
+mod platform {
+    //! Unix-specific shim utilities
+    //!
+    //! On macOS and Linux, creating a shim involves creating a symlink to the `volta-shim`
+    //! executable. Additionally, filtering the shims from directory entries means looking
+    //! for symlinks and ignoring the actual binaries
+    use std::ffi::OsStr;
+    use std::fs::{DirEntry, Metadata};
+    use std::io;
+
+    use super::ShimResult;
+    use crate::error::{ErrorKind, Fallible, VoltaError};
+    use crate::fs::symlink_file;
+    use crate::layout::{volta_home, volta_install};
+
+    pub fn create(shim_name: &str) -> Fallible<ShimResult> {
+        let executable = volta_install()?.shim_executable();
+        let shim = volta_home()?.shim_file(shim_name);
+
+        match symlink_file(executable, shim) {
+            Ok(_) => Ok(ShimResult::Created),
+            Err(err) => {
+                if err.kind() == io::ErrorKind::AlreadyExists {
+                    Ok(ShimResult::AlreadyExists)
+                } else {
+                    Err(VoltaError::from_source(
+                        err,
+                        ErrorKind::ShimCreateError {
+                            name: shim_name.to_string(),
+                        },
+                    ))
+                }
+            }
+        }
+    }
+
+    pub fn entry_to_shim_name((entry, metadata): (DirEntry, Metadata)) -> Option<String> {
+        if metadata.file_type().is_symlink() {
+            entry
+                .path()
+                .file_stem()
+                .and_then(OsStr::to_str)
+                .map(ToOwned::to_owned)
+        } else {
+            None
+        }
+    }
+}
+
 #[cfg(windows)]
-mod windows {
+mod platform {
+    //! Windows-specific shim utilities
+    //!
+    //! On Windows, creating a shim involves creating a small .cmd script, rather than a symlink.
+    //! This allows us to create shims without requiring administrator privileges or developer
+    //! mode. Also, to support Git Bash, we create a similar script with bash syntax that doesn't
+    //! have a file extension. This allows Powershell and Cmd to ignore it, while Bash detects it
+    //! as an executable script.
+    //!
+    //! Finally, filtering directory entries to find the shim files involves looking for the .cmd
+    //! files.
+    use std::ffi::OsStr;
+    use std::fs::{write, DirEntry, Metadata};
+
+    use super::ShimResult;
     use crate::error::{Context, ErrorKind, Fallible};
     use crate::fs::remove_file_if_exists;
     use crate::layout::volta_home;
-    use std::fs::write;
 
-    const BASH_SCRIPT: &str = r#"cmd //C $0 "$@""#;
+    const SHIM_SCRIPT_CONTENTS: &str = r#"@echo off
+volta run %~n0 %*
+"#;
 
-    pub fn create_git_bash_script(shim_name: &str) -> Fallible<()> {
-        let script_path = volta_home()?.shim_git_bash_script_file(shim_name);
-        write(script_path, BASH_SCRIPT).with_context(|| ErrorKind::ShimCreateError {
-            name: shim_name.to_string(),
-        })
+    const GIT_BASH_SCRIPT_CONTENTS: &str = r#"#!/bin/bash
+volta run "$(basename $0)" "$@""#;
+
+    pub fn create(shim_name: &str) -> Fallible<ShimResult> {
+        let shim = volta_home()?.shim_file(shim_name);
+
+        write(shim, SHIM_SCRIPT_CONTENTS).with_context(|| ErrorKind::ShimCreateError {
+            name: shim_name.to_owned(),
+        })?;
+
+        let git_bash_script = volta_home()?.shim_git_bash_script_file(shim_name);
+
+        write(git_bash_script, GIT_BASH_SCRIPT_CONTENTS).with_context(|| {
+            ErrorKind::ShimCreateError {
+                name: shim_name.to_owned(),
+            }
+        })?;
+
+        Ok(ShimResult::Created)
+    }
+
+    pub fn entry_to_shim_name((entry, _): (DirEntry, Metadata)) -> Option<String> {
+        let path = entry.path();
+
+        if path.extension().is_some_and(|ext| ext == "cmd") {
+            path.file_stem()
+                .and_then(OsStr::to_str)
+                .map(ToOwned::to_owned)
+        } else {
+            None
+        }
     }
 
     pub fn delete_git_bash_script(shim_name: &str) -> Fallible<()> {
diff --git a/crates/volta-layout/src/lib.rs b/crates/volta-layout/src/lib.rs
@@ -5,6 +5,7 @@ pub mod v0;
 pub mod v1;
 pub mod v2;
 pub mod v3;
+pub mod v4;
 
 fn executable(name: &str) -> String {
     format!("{}{}", name, std::env::consts::EXE_SUFFIX)
diff --git a/crates/volta-layout/src/v4.rs b/crates/volta-layout/src/v4.rs
@@ -0,0 +1,125 @@
+use std::path::PathBuf;
+
+use volta_layout_macro::layout;
+
+pub use crate::v1::VoltaInstall;
+
+layout! {
+    pub struct VoltaHome {
+        "cache": cache_dir {
+            "node": node_cache_dir {
+                "index.json": node_index_file;
+                "index.json.expires": node_index_expiry_file;
+            }
+        }
+        "bin": shim_dir {}
+        "log": log_dir {}
+        "tools": tools_dir {
+            "inventory": inventory_dir {
+                "node": node_inventory_dir {}
+                "npm": npm_inventory_dir {}
+                "pnpm": pnpm_inventory_dir {}
+                "yarn": yarn_inventory_dir {}
+            }
+            "image": image_dir {
+                "node": node_image_root_dir {}
+                "npm": npm_image_root_dir {}
+                "pnpm": pnpm_image_root_dir {}
+                "yarn": yarn_image_root_dir {}
+                "packages": package_image_root_dir {}
+            }
+            "shared": shared_lib_root {}
+            "user": default_toolchain_dir {
+                "bins": default_bin_dir {}
+                "packages": default_package_dir {}
+                "platform.json": default_platform_file;
+            }
+        }
+        "tmp": tmp_dir {}
+        "hooks.json": default_hooks_file;
+        "layout.v4": layout_file;
+    }
+}
+
+impl VoltaHome {
+    pub fn node_image_dir(&self, node: &str) -> PathBuf {
+        path_buf!(self.node_image_root_dir.clone(), node)
+    }
+
+    pub fn npm_image_dir(&self, npm: &str) -> PathBuf {
+        path_buf!(self.npm_image_root_dir.clone(), npm)
+    }
+
+    pub fn npm_image_bin_dir(&self, npm: &str) -> PathBuf {
+        path_buf!(self.npm_image_dir(npm), "bin")
+    }
+
+    pub fn pnpm_image_dir(&self, version: &str) -> PathBuf {
+        path_buf!(self.pnpm_image_root_dir.clone(), version)
+    }
+
+    pub fn pnpm_image_bin_dir(&self, version: &str) -> PathBuf {
+        path_buf!(self.pnpm_image_dir(version), "bin")
+    }
+
+    pub fn yarn_image_dir(&self, version: &str) -> PathBuf {
+        path_buf!(self.yarn_image_root_dir.clone(), version)
+    }
+
+    pub fn yarn_image_bin_dir(&self, version: &str) -> PathBuf {
+        path_buf!(self.yarn_image_dir(version), "bin")
+    }
+
+    pub fn package_image_dir(&self, name: &str) -> PathBuf {
+        path_buf!(self.package_image_root_dir.clone(), name)
+    }
+
+    pub fn default_package_config_file(&self, package_name: &str) -> PathBuf {
+        path_buf!(
+            self.default_package_dir.clone(),
+            format!("{}.json", package_name)
+        )
+    }
+
+    pub fn default_tool_bin_config(&self, bin_name: &str) -> PathBuf {
+        path_buf!(self.default_bin_dir.clone(), format!("{}.json", bin_name))
+    }
+
+    pub fn node_npm_version_file(&self, version: &str) -> PathBuf {
+        path_buf!(
+            self.node_inventory_dir.clone(),
+            format!("node-v{}-npm", version)
+        )
+    }
+
+    pub fn shim_file(&self, toolname: &str) -> PathBuf {
+        // On Windows, shims are created as `<name>.cmd` since they
+        // are thin scripts that use `volta run` to execute the command
+        #[cfg(windows)]
+        let toolname = format!("{}{}", toolname, ".cmd");
+
+        path_buf!(self.shim_dir.clone(), toolname)
+    }
+
+    pub fn shared_lib_dir(&self, library: &str) -> PathBuf {
+        path_buf!(self.shared_lib_root.clone(), library)
+    }
+}
+
+#[cfg(windows)]
+impl VoltaHome {
+    pub fn shim_git_bash_script_file(&self, toolname: &str) -> PathBuf {
+        path_buf!(self.shim_dir.clone(), toolname)
+    }
+
+    pub fn node_image_bin_dir(&self, node: &str) -> PathBuf {
+        self.node_image_dir(node)
+    }
+}
+
+#[cfg(unix)]
+impl VoltaHome {
+    pub fn node_image_bin_dir(&self, node: &str) -> PathBuf {
+        path_buf!(self.node_image_dir(node), "bin")
+    }
+}
diff --git a/crates/volta-migrate/src/lib.rs b/crates/volta-migrate/src/lib.rs
diff --git a/crates/volta-migrate/src/v4.rs b/crates/volta-migrate/src/v4.rs
