Rigorously check statuses and echo commands in build swiftly release script

cmcgee1024 · cmcgee1024 · commit 48c1b257078e · 2025-10-31T11:41:18.000-04:00
diff --git a/Sources/LinuxPlatform/Linux.swift b/Sources/LinuxPlatform/Linux.swift
@@ -282,8 +282,6 @@ public struct Linux: Platform {
             try await fs.withTemporary(files: tmpFile) {
                 try await ctx.httpClient.getGpgKeys().download(to: tmpFile)
                 if let mockedHomeDir = ctx.mockedHomeDir {
-                    var env = ProcessInfo.processInfo.environment
-                    env["GNUPGHOME"] = (mockedHomeDir / ".gnupg").string
                     try await sys.gpg()._import(key: tmpFile).run(environment: .inherit.updating(["GNUPGHOME": (mockedHomeDir / ".gnupg").string]), quiet: true)
                 } else {
                     try await sys.gpg()._import(key: tmpFile).run(quiet: true)
diff --git a/Sources/TestSwiftly/TestSwiftly.swift b/Sources/TestSwiftly/TestSwiftly.swift
@@ -101,9 +101,9 @@ struct TestSwiftly: AsyncParsableCommand {
 
         print("Extracting swiftly release")
 #if os(Linux)
-        try await sys.tar().extract(.verbose, .compressed, .archive(swiftlyArchive)).run(quiet: false)
+        try await sys.tar().extract(.verbose, .compressed, .archive(swiftlyArchive)).run()
 #elseif os(macOS)
-        try await sys.installer(.verbose, .pkg(swiftlyArchive), .target("CurrentUserHomeDirectory")).run(quiet: false)
+        try await sys.installer(.verbose, .pkg(swiftlyArchive), .target("CurrentUserHomeDirectory")).run()
 #endif
 
 #if os(Linux)
@@ -127,8 +127,16 @@ struct TestSwiftly: AsyncParsableCommand {
                 "SWIFTLY_TOOLCHAINS_DIR": (customLoc! / "toolchains").string,
             ])
 
-            _ = try await Subprocess.run(.path(extractedSwiftly), arguments: ["init", "--assume-yes", "--no-modify-profile", "--skip-install"], environment: env, input: .standardInput, output: .standardOutput, error: .standardError)
-            _ = try await sh(executable: .path(shell), .login, .command(". \"\(customLoc! / "env.sh")\" && swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(environment: env, output: .standardOutput, error: .standardError)
+            let config = Configuration(
+                .path(extractedSwiftly),
+                arguments: ["init", "--assume-yes", "--no-modify-profile", "--skip-install"],
+                environment: env
+            )
+            let result = try await Subprocess.run(config, output: .standardOutput, error: .standardError)
+            if !result.terminationStatus.isSuccess {
+                throw RunProgramError(terminationStatus: result.terminationStatus, config: config)
+            }
+            try await sh(executable: .path(shell), .login, .command(". \"\(customLoc! / "env.sh")\" && swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(environment: env, quiet: false)
         } else {
             print("Installing swiftly to the default location.")
             // Setting this environment helps to ensure that the profile gets sourced with bash, even if it is not in an interactive shell
@@ -140,8 +148,16 @@ struct TestSwiftly: AsyncParsableCommand {
                 env = env.updating(["XDG_CONFIG_HOME": (fs.home / ".config").string])
             }
 
-            _ = try await Subprocess.run(.path(extractedSwiftly), arguments: ["init", "--assume-yes", "--skip-install"], environment: env, input: .standardInput, output: .standardOutput, error: .standardError)
-            _ = try await sh(executable: .path(shell), .login, .command("swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(environment: env, output: .standardOutput, error: .standardError)
+            let config = Configuration(
+                .path(extractedSwiftly),
+                arguments: ["init", "--assume-yes", "--skip-install"],
+                environment: env
+            )
+            let result = try await Subprocess.run(config, output: .standardOutput, error: .standardError)
+            if !result.terminationStatus.isSuccess {
+                throw RunProgramError(terminationStatus: result.terminationStatus, config: config)
+            }
+            try await sh(executable: .path(shell), .login, .command("swiftly install --assume-yes latest --post-install-file=./post-install.sh")).run(environment: env)
         }
 
         var swiftReady = false
@@ -158,9 +174,9 @@ struct TestSwiftly: AsyncParsableCommand {
         }
 
         if let customLoc = customLoc, swiftReady {
-            _ = try await sh(executable: .path(shell), .login, .command(". \"\(customLoc / "env.sh")\" && swift --version")).run(environment: env, output: .standardOutput, error: .standardError)
+            try await sh(executable: .path(shell), .login, .command(". \"\(customLoc / "env.sh")\" && swift --version")).run(environment: env)
         } else if swiftReady {
-            _ = try await sh(executable: .path(shell), .login, .command("swift --version")).run(environment: env, output: .standardOutput, error: .standardError)
+            try await sh(executable: .path(shell), .login, .command("swift --version")).run(environment: env)
         }
 
         // Test self-uninstall functionality
@@ -171,13 +187,13 @@ struct TestSwiftly: AsyncParsableCommand {
     private func testSelfUninstall(customLoc: SystemPackage.FilePath?, shell: SystemPackage.FilePath, env: Environment) async throws {
         if let customLoc = customLoc {
             // Test self-uninstall for custom location
-            _ = try await sh(executable: .path(shell), .login, .command(". \"\(customLoc / "env.sh")\" && swiftly self-uninstall --assume-yes")).run(environment: env, output: .standardOutput, error: .standardError)
+            try await sh(executable: .path(shell), .login, .command(". \"\(customLoc / "env.sh")\" && swiftly self-uninstall --assume-yes")).run(environment: env)
 
             // Verify cleanup for custom location
             try await self.verifyCustomLocationCleanup(customLoc: customLoc)
         } else {
             // Test self-uninstall for default location
-            _ = try await sh(executable: .path(shell), .login, .command("swiftly self-uninstall --assume-yes")).run(environment: env, output: .standardOutput, error: .standardError)
+            try await sh(executable: .path(shell), .login, .command("swiftly self-uninstall --assume-yes")).run(environment: env)
 
             // Verify cleanup for default location
             try await self.verifyDefaultLocationCleanup(shell: shell, env: env)
@@ -245,7 +261,7 @@ struct TestSwiftly: AsyncParsableCommand {
 
         // Verify swiftly command is no longer available
         do {
-            _ = try await sh(executable: .path(shell), .login, .command("which swiftly")).run(environment: env, output: .standardOutput, error: .standardError)
+            try await sh(executable: .path(shell), .login, .command("which swiftly")).run(environment: env)
             throw TestError("swiftly command is still available in PATH after uninstall")
         } catch {
             // Expected - swiftly should not be found
diff --git a/Tools/build-swiftly-release/BuildSwiftlyRelease.swift b/Tools/build-swiftly-release/BuildSwiftlyRelease.swift
@@ -2,9 +2,9 @@ import ArgumentParser
 import AsyncHTTPClient
 import Foundation
 import NIOFileSystem
+import Subprocess
 import SwiftlyCore
 import SystemPackage
-import Subprocess
 
 #if os(macOS)
 import MacOSPlatform
@@ -23,12 +23,10 @@ typealias sys = SystemCommand
 
 extension Runnable {
     // Runs the command while echoing the full command-line to stdout for logging and reproduction
-    func runEcho(quiet: Bool = false) async throws {
+    func runEcho(environment: Environment = .inherit, quiet: Bool = false) async throws {
         let config = self.config()
-        // if !quiet { print("\(args.joined(separator: " "))") }
         if !quiet { print("\(config)") }
-
-        try await self.run()
+        try await self.run(environment: environment, quiet: quiet)
     }
 }
 
@@ -117,7 +115,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         }
 
         do {
-            try await sys.git().diffindex(.quiet, tree_ish: "HEAD").run()
+            try await sys.git().diffindex(.quiet, tree_ish: "HEAD").runEcho()
         } catch {
             throw Error(message: "Git repo has local changes. First commit these changes, tag the commit with release \(self.version) and push the tag to GitHub.")
         }
@@ -136,7 +134,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         try await self.checkGitRepoStatus()
 
         // Start with a fresh SwiftPM package
-        try await sys.swift().package().reset().run()
+        try await sys.swift().package().reset().runEcho()
 
         // Build a specific version of libarchive with a check on the tarball's SHA256
         let libArchiveVersion = "3.8.1"
@@ -172,14 +170,20 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             let shaActual = libArchiveTarShaActual ?? "none"
             throw Error(message: "The libarchive tar.gz file sha256sum is \(shaActual), but expected \(libArchiveTarSha)")
         }
-        try await sys.tar(.directory(buildCheckoutsDir)).extract(.compressed, .archive(buildCheckoutsDir / "libarchive-\(libArchiveVersion).tar.gz")).run()
+        try await sys.tar(.directory(buildCheckoutsDir)).extract(.compressed, .archive(buildCheckoutsDir / "libarchive-\(libArchiveVersion).tar.gz")).runEcho()
 
         let cwd = fs.cwd
         FileManager.default.changeCurrentDirectoryPath(libArchivePath.string)
 
         let swiftVerRegex: Regex<(Substring, Substring)> = try! Regex("Swift version (\\d+\\.\\d+\\.?\\d*) ")
 
-        let swiftVerOutput = (try await Subprocess.run(.name("swift"), arguments: ["--version"], output: .string(limit: 1024))).standardOutput ?? ""
+        let swiftVersionCmd = Configuration(
+            .name("swift"),
+            arguments: ["--version"]
+        )
+        print("\(swiftVersionCmd)")
+
+        let swiftVerOutput = (try await Subprocess.run(swiftVersionCmd, output: .string(limit: 1024))).standardOutput ?? ""
         guard let swiftVerMatch = try swiftVerRegex.firstMatch(in: swiftVerOutput) else {
             throw Error(message: "Unable to detect swift version")
         }
@@ -201,15 +205,15 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             throw Error(message: "Swift release \(swiftVersion) has no Static SDK offering")
         }
 
-        _ = try await sys.swift().sdk().install(.checksum(sdkPlatform.checksum ?? "deadbeef"), bundle_path_or_url: "https://download.swift.org/swift-\(swiftVersion)-release/static-sdk/swift-\(swiftVersion)-RELEASE/swift-\(swiftVersion)-RELEASE_static-linux-0.0.1.artifactbundle.tar.gz").run(output: .standardOutput, error: .standardError)
+        try await sys.swift().sdk().install(.checksum(sdkPlatform.checksum ?? "deadbeef"), bundle_path_or_url: "https://download.swift.org/swift-\(swiftVersion)-release/static-sdk/swift-\(swiftVersion)-RELEASE/swift-\(swiftVersion)-RELEASE_static-linux-0.0.1.artifactbundle.tar.gz").runEcho()
 
         var customEnv: Environment = .inherit
         customEnv = customEnv.updating([
             "CC": "\(cwd)/Tools/build-swiftly-release/musl-clang",
-            "MUSL_PREFIX":  "\(fs.home / ".swiftpm/swift-sdks/\(sdkName).artifactbundle/\(sdkName)/swift-linux-musl/musl-1.2.5.sdk/\(arch)/usr")",
+            "MUSL_PREFIX": "\(fs.home / ".swiftpm/swift-sdks/\(sdkName).artifactbundle/\(sdkName)/swift-linux-musl/musl-1.2.5.sdk/\(arch)/usr")",
         ])
 
-        _ = try await Subprocess.run(
+        let configCmd = Configuration(
             .path(FilePath("./configure")),
             arguments: [
                 "--prefix=\(pkgConfigPath)",
@@ -231,23 +235,31 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
                 "--disable-bsdcat",
             ],
             environment: customEnv,
-            input: .standardInput,
+        )
+        print("\(configCmd)")
+
+        let result = try await Subprocess.run(
+            configCmd,
             output: .standardOutput,
             error: .standardError,
         )
 
-        _ = try await sys.make().run(environment: customEnv, output: .standardOutput, error: .standardError)
+        if !result.terminationStatus.isSuccess {
+            throw RunProgramError(terminationStatus: result.terminationStatus, config: configCmd)
+        }
+
+        try await sys.make().runEcho(environment: customEnv)
 
-        try await sys.make().install().run()
+        try await sys.make().install().runEcho()
 
         FileManager.default.changeCurrentDirectoryPath(cwd.string)
 
-        try await sys.swift().build(.swift_sdk("\(arch)-swift-linux-musl"), .product("swiftly"), .pkg_config_path(pkgConfigPath / "lib/pkgconfig"), .static_swift_stdlib, .configuration("release")).run()
+        try await sys.swift().build(.swift_sdk("\(arch)-swift-linux-musl"), .product("swiftly"), .pkg_config_path(pkgConfigPath / "lib/pkgconfig"), .static_swift_stdlib, .configuration("release")).runEcho()
 
         let releaseDir = cwd / ".build/release"
 
         // Strip the symbols from the binary to decrease its size
-        try await sys.strip(name: releaseDir / "swiftly").run()
+        try await sys.strip(name: releaseDir / "swiftly").runEcho()
 
         try await self.collectLicenses(releaseDir)
 
@@ -257,7 +269,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         let releaseArchive = releaseDir / "swiftly-\(version)-x86_64.tar.gz"
 #endif
 
-        try await sys.tar(.directory(releaseDir)).create(.compressed, .archive(releaseArchive), files: ["swiftly", "LICENSE.txt"]).run()
+        try await sys.tar(.directory(releaseDir)).create(.compressed, .archive(releaseArchive), files: ["swiftly", "LICENSE.txt"]).runEcho()
 
         print(releaseArchive)
 
@@ -270,8 +282,8 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             let testArchive = debugDir / "test-swiftly-linux-x86_64.tar.gz"
 #endif
 
-            try await sys.swift().build(.swift_sdk("\(arch)-swift-linux-musl"), .product("test-swiftly"), .pkg_config_path(pkgConfigPath / "lib/pkgconfig"), .static_swift_stdlib, .configuration("debug")).run()
-            try await sys.tar(.directory(debugDir)).create(.compressed, .archive(testArchive), files: ["test-swiftly"]).run()
+            try await sys.swift().build(.swift_sdk("\(arch)-swift-linux-musl"), .product("test-swiftly"), .pkg_config_path(pkgConfigPath / "lib/pkgconfig"), .static_swift_stdlib, .configuration("debug")).runEcho()
+            try await sys.tar(.directory(debugDir)).create(.compressed, .archive(testArchive), files: ["test-swiftly"]).runEcho()
 
             print(testArchive)
         }
@@ -282,11 +294,11 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
     func buildMacOSRelease(cert: String?, identifier: String) async throws {
         try await self.checkGitRepoStatus()
 
-        try await sys.swift().package().clean().run()
+        try await sys.swift().package().clean().runEcho()
 
         for arch in ["x86_64", "arm64"] {
-            try await sys.swift().build(.product("swiftly"), .configuration("release"), .arch("\(arch)")).run()
-            try await sys.strip(name: FilePath(".build") / "\(arch)-apple-macosx/release/swiftly").run()
+            try await sys.swift().build(.product("swiftly"), .configuration("release"), .arch("\(arch)")).runEcho()
+            try await sys.strip(name: FilePath(".build") / "\(arch)-apple-macosx/release/swiftly").runEcho()
         }
 
         let swiftlyBinDir = fs.cwd / ".build/release/.swiftly/bin"
@@ -362,7 +374,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             .create(.output(swiftlyBinDir / "swiftly"))
             .runEcho()
 
-            try await sys.tar(.directory(".build/x86_64-apple-macosx/debug")).create(.compressed, .archive(testArchive), files: ["test-swiftly"]).run()
+            try await sys.tar(.directory(".build/x86_64-apple-macosx/debug")).create(.compressed, .archive(testArchive), files: ["test-swiftly"]).runEcho()
 
             print(testArchive)
         }
