Fix .pants.bootstrap handling. (#108)

A re-exec approach is now used to ensure pants runs in a bash subprocess
for complete fidelity with the `./pants` bash script case.

Fixes #107

Author: jsirois

.pants.bootstrap

@@ -1,10 +1,16 @@
 function should_be_ignored() {
   # Normally `set` would print information about functions as well as variables; causing scie-pants
   # to emit warnings about skipping un-parseable env vars. This function stresses that corner in
-  # integration tests.
+  # integration tests. Although `set` is no longer used to evaluated `.pants.bootstrap` scripts,
+  # this shell function still serves to prevent a back-slide.
   return
 }
 
 # Ensure GIT_COMMIT is set
-: ${GIT_COMMIT:=$(git rev-parse HEAD)}
+export GIT_COMMIT="$(git rev-parse HEAD)"
+
+# Exercise https://github.com/pantsbuild/scie-pants/issues/107
+export PANTS_DOCKER_TOOLS="+['aws-oidc', 'open']"
+export COLUMNS="$(tput cols)"
+export LINES="$(tput lines)"
 

CHANGES.md

@@ -1,5 +1,11 @@
 # Release Notes
 
+## 0.4.2
+
+This release fixes `.pants.bootstrap` handling to robustly mimic handling by the `./pants` script.
+The `scie-pants` binary now re-execs itself through a bash shell when `.pants.bootstrap` needs to
+be sourced.
+
 ## 0.4.1
 
 This release supports using a released Pants version in the Pants repo when a Pants version to use

Cargo.lock

@@ -6,7 +6,7 @@ members = [
 [package]
 name = "scie-pants"
 description = "Protects your Pants from the elements."
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 authors = [
     "John Sirois <[email protected]>",
@@ -34,3 +34,6 @@ serde = { version = "1.0", features = ["derive"] }
 tempfile = { workspace = true }
 toml = "0.7"
 uuid = { version = "1.3", features = ["v4"] }
+
+[target.'cfg(unix)'.dependencies]
+shell-quote = "0.3.0"

Cargo.toml

@@ -800,17 +800,31 @@ fn test(
     );
     env::set_var("PANTS_PANTSRC", "False");
 
+    // Our `.pants.bootstrap` uses `tput` which requires TERM be set: ensure it is.
+    env::set_var("TERM", env::var_os("TERM").unwrap_or_else(|| "dumb".into()));
+
     // Max Python supported is 3.9 and only Linux x86_64 and macOS aarch64 and x86_64 wheels were
     // released.
     if matches!(
         *CURRENT_PLATFORM,
         Platform::LinuxX86_64 | Platform::MacOSAarch64 | Platform::MacOSX86_64
     ) {
         integration_test!("Linting, testing and packaging the tools codebase");
+        let tput_output = |subcommand| {
+            let result =
+                execute(Command::new("tput").arg(subcommand).stdout(Stdio::piped()))?.stdout;
+            String::from_utf8(result).map_err(|e| {
+                Code::FAILURE.with_message(format!(
+                    "Failed to decode output of tput {subcommand} as UTF-*: {e}"
+                ))
+            })
+        };
         execute(
             Command::new(scie_pants_scie)
                 .args(["fmt", "lint", "check", "test", "package", "::"])
-                .env("PEX_SCRIPT", "Does not exist!"),
+                .env("PEX_SCRIPT", "Does not exist!")
+                .env("EXPECTED_COLUMNS", tput_output("cols")?.trim())
+                .env("EXPECTED_LINES", tput_output("lines")?.trim()),
         )?;
 
         integration_test!("Checking .pants.bootstrap handling ignores bash functions");

package/src/main.rs

@@ -1,5 +1,5 @@
 [GLOBAL]
-pants_version = "2.15.0rc0"
+pants_version = "2.15.0rc3"
 
 backend_packages = [
     "pants.backend.python",

pants.toml

@@ -3,6 +3,7 @@
 
 use std::env;
 use std::ffi::{OsStr, OsString};
+use std::fmt::Debug;
 use std::path::PathBuf;
 
 use anyhow::{anyhow, bail, Context, Result};
@@ -12,11 +13,9 @@ use logging_timer::{time, timer, Level};
 use uuid::Uuid;
 
 use crate::config::PantsConfig;
-use crate::pants_bootstrap::PantsBootstrap;
 
 mod build_root;
 mod config;
-mod pants_bootstrap;
 
 #[derive(Debug, Default)]
 struct Process {
@@ -86,15 +85,73 @@ fn env_version(env_var_name: &str) -> Result<Option<String>> {
 
 fn find_pants_installation() -> Result<Option<PantsConfig>> {
     if let Ok(build_root) = BuildRoot::find(None) {
-        if let Some(pants_bootstrap) = PantsBootstrap::load(&build_root)? {
-            pants_bootstrap.export_env();
-        }
         let pants_config = PantsConfig::parse(build_root)?;
         return Ok(Some(pants_config));
     }
     Ok(None)
 }
 
+#[derive(Eq, PartialEq)]
+enum ScieBoot {
+    BootstrapTools,
+    Pants,
+    PantsDebug,
+}
+
+impl ScieBoot {
+    fn env_value(&self) -> OsString {
+        match self {
+            ScieBoot::BootstrapTools => "bootstrap-tools",
+            ScieBoot::Pants => "pants",
+            ScieBoot::PantsDebug => "pants-debug",
+        }
+        .into()
+    }
+
+    #[cfg(unix)]
+    fn quote<T: Into<OsString> + Debug>(value: T) -> Result<String> {
+        String::from_utf8(shell_quote::bash::escape(value))
+            .context("Shell-quoted value could not be interpreted as UTF-8.")
+    }
+
+    #[cfg(windows)]
+    fn quote<T: Into<OsString> + Debug>(_value: T) -> Result<String> {
+        // The shell_quote crate assumes unix and fails to compile on Windows.
+        todo!("TODO(John Sirois): Figure out Git bash? shell quoting for Windows WTF-16 strings.")
+    }
+
+    fn into_process(
+        self,
+        scie: String,
+        build_root: Option<PathBuf>,
+        env: Vec<(OsString, OsString)>,
+    ) -> Result<Process> {
+        Ok(match build_root.map(|br| br.join(".pants.bootstrap")) {
+            Some(pants_bootstrap) if self != Self::BootstrapTools && pants_bootstrap.is_file() => {
+                Process {
+                    exe: "/usr/bin/env".into(),
+                    args: vec![
+                        "bash".into(),
+                        "-c".into(),
+                        format!(
+                            r#"set -eou pipefail; source {bootstrap}; exec {scie} "$0" "$@""#,
+                            bootstrap = Self::quote(pants_bootstrap)?,
+                            scie = Self::quote(scie)?
+                        )
+                        .into(),
+                    ],
+                    env,
+                }
+            }
+            _ => Process {
+                exe: scie.into(),
+                env,
+                ..Default::default()
+            },
+        })
+    }
+}
+
 #[time("debug", "scie-pants::{}")]
 fn get_pants_process() -> Result<Process> {
     let pants_installation = find_pants_installation()?;
@@ -142,23 +199,23 @@ fn get_pants_process() -> Result<Process> {
     info!("The required Pants version is {pants_version:?}");
 
     let scie =
-        env::var_os("SCIE").context("Failed to retrieve SCIE location from the environment.")?;
+        env::var("SCIE").context("Failed to retrieve SCIE location from the environment.")?;
 
     let pants_debug = matches!(env::var_os("PANTS_DEBUG"), Some(value) if !value.is_empty());
     let scie_boot = match env::var_os("PANTS_BOOTSTRAP_TOOLS") {
-        Some(_) => "bootstrap-tools",
+        Some(_) => ScieBoot::BootstrapTools,
         None => {
             if pants_debug {
-                "pants-debug"
+                ScieBoot::PantsDebug
             } else {
-                "pants"
+                ScieBoot::Pants
             }
         }
     };
 
     let mut env = vec![
-        ("SCIE_BOOT".into(), scie_boot.into()),
-        ("PANTS_BIN_NAME".into(), scie.as_os_str().into()),
+        ("SCIE_BOOT".into(), scie_boot.env_value()),
+        ("PANTS_BIN_NAME".into(), scie.clone().into()),
         (
             "PANTS_DEBUG".into(),
             if pants_debug { "1" } else { "" }.into(),
@@ -168,7 +225,7 @@ fn get_pants_process() -> Result<Process> {
             debugpy_version.unwrap_or_default().into(),
         ),
     ];
-    if let Some(build_root) = build_root {
+    if let Some(ref build_root) = build_root {
         env.push((
             "PANTS_BUILDROOT_OVERRIDE".into(),
             build_root.as_os_str().to_os_string(),
@@ -192,11 +249,7 @@ fn get_pants_process() -> Result<Process> {
         ))
     }
 
-    Ok(Process {
-        exe: scie,
-        env,
-        ..Default::default()
-    })
+    scie_boot.into_process(scie, build_root, env)
 }
 
 fn get_pants_from_sources_process(pants_repo_location: PathBuf) -> Result<Process> {