Remove Platform.run methods in favour of more direct Subprocess usages

Author: cmcgee1024

Sources/LinuxPlatform/Linux.swift

@@ -1,4 +1,5 @@
 import Foundation
+import Subprocess
 import SwiftlyCore
 import SystemPackage
 
@@ -255,7 +256,13 @@ public struct Linux: Platform {
         }
 
         if requireSignatureValidation {
-            guard (try? await self.runProgram("gpg", "--version", quiet: true)) != nil else {
+            let result = try await run(
+                .name("gpg"),
+                arguments: ["--version"],
+                output: .discarded
+            )
+
+            if !result.terminationStatus.isSuccess {
                 var msg = "gpg is not installed. "
                 if let manager {
                     msg += """
@@ -277,9 +284,9 @@ public struct Linux: Platform {
                 if let mockedHomeDir = ctx.mockedHomeDir {
                     var env = ProcessInfo.processInfo.environment
                     env["GNUPGHOME"] = (mockedHomeDir / ".gnupg").string
-                    try await sys.gpg()._import(key: tmpFile).run(self, env: env, quiet: true)
+                    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(self, quiet: true)
+                    try await sys.gpg()._import(key: tmpFile).run(quiet: true)
                 }
             }
         }
@@ -307,7 +314,12 @@ public struct Linux: Platform {
         do {
             switch manager {
             case "apt-get":
-                if let pkgList = try await self.runProgramOutput("dpkg", "-l", package) {
+                let result = try await run(.name("dpkg"), arguments: ["-l", package], output: .string(limit: 100 * 1024))
+                if !result.terminationStatus.isSuccess {
+                    return false
+                }
+
+                if let pkgList = result.standardOutput {
                     // The package might be listed but not in an installed non-error state.
                     //
                     // Look for something like this:
@@ -321,8 +333,8 @@ public struct Linux: Platform {
                 }
                 return false
             case "yum":
-                try await self.runProgram("yum", "list", "installed", package, quiet: true)
-                return true
+                let result = try await run(.name("yum"), arguments: ["list", "installed", package], output: .discarded)
+                return result.terminationStatus.isSuccess
             default:
                 return true
             }
@@ -382,7 +394,15 @@ public struct Linux: Platform {
                 tmpDir / String(name)
             }
 
-            try await self.runProgram((tmpDir / "swiftly").string, "init")
+            let config = Configuration(
+                executable: .path(tmpDir / "swiftly"),
+                arguments: ["init"]
+            )
+
+            let result = try await run(config, output: .standardOutput, error: .standardError)
+            if !result.terminationStatus.isSuccess {
+                throw RunProgramError(terminationStatus: result.terminationStatus, config: config)
+            }
         }
     }
 
@@ -416,11 +436,9 @@ public struct Linux: Platform {
             await ctx.message("Verifying toolchain signature...")
             do {
                 if let mockedHomeDir = ctx.mockedHomeDir {
-                    var env = ProcessInfo.processInfo.environment
-                    env["GNUPGHOME"] = (mockedHomeDir / ".gnupg").string
-                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(self, env: env, quiet: false)
+                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(environment: .inherit.updating(["GNUPGHOME": (mockedHomeDir / ".gnupg").string]), quiet: false)
                 } else {
-                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(self, quiet: !verbose)
+                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(quiet: !verbose)
                 }
             } catch {
                 throw SwiftlyError(message: "Signature verification failed: \(error).")
@@ -445,11 +463,9 @@ public struct Linux: Platform {
             await ctx.message("Verifying swiftly signature...")
             do {
                 if let mockedHomeDir = ctx.mockedHomeDir {
-                    var env = ProcessInfo.processInfo.environment
-                    env["GNUPGHOME"] = (mockedHomeDir / ".gnupg").string
-                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(self, env: env, quiet: false)
+                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(environment: .inherit.updating(["GNUPGHOME": (mockedHomeDir / ".gnupg").string]), quiet: false)
                 } else {
-                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(self, quiet: !verbose)
+                    try await sys.gpg().verify(detached_signature: sigFile, signed_data: archive).run(quiet: !verbose)
                 }
             } catch {
                 throw SwiftlyError(message: "Signature verification failed: \(error).")
@@ -603,7 +619,7 @@ public struct Linux: Platform {
 
     public func getShell() async throws -> String {
         let userName = ProcessInfo.processInfo.userName
-        if let entry = try await sys.getent(database: "passwd", key: userName).entries(self).first {
+        if let entry = try await sys.getent(database: "passwd", key: userName).entries().first {
             if let shell = entry.last { return shell }
         }
 

Sources/MacOSPlatform/MacOS.swift

@@ -1,5 +1,7 @@
 import Foundation
+import Subprocess
 import SwiftlyCore
+import System
 import SystemPackage
 
 typealias sys = SwiftlyCore.SystemCommand
@@ -17,21 +19,21 @@ public struct SwiftPkgInfo: Codable {
 public struct MacOS: Platform {
     public init() {}
 
-    public var defaultSwiftlyHomeDir: FilePath {
+    public var defaultSwiftlyHomeDir: SystemPackage.FilePath {
         fs.home / ".swiftly"
     }
 
-    public var defaultToolchainsDirectory: FilePath {
+    public var defaultToolchainsDirectory: SystemPackage.FilePath {
         fs.home / "Library/Developer/Toolchains"
     }
 
-    public func swiftlyBinDir(_ ctx: SwiftlyCoreContext) -> FilePath {
+    public func swiftlyBinDir(_ ctx: SwiftlyCoreContext) -> SystemPackage.FilePath {
         ctx.mockedHomeDir.map { $0 / "bin" }
             ?? ProcessInfo.processInfo.environment["SWIFTLY_BIN_DIR"].map { FilePath($0) }
             ?? fs.home / ".swiftly/bin"
     }
 
-    public func swiftlyToolchainsDir(_ ctx: SwiftlyCoreContext) -> FilePath {
+    public func swiftlyToolchainsDir(_ ctx: SwiftlyCoreContext) -> SystemPackage.FilePath {
         ctx.mockedHomeDir.map { $0 / "Toolchains" }
             ?? ProcessInfo.processInfo.environment["SWIFTLY_TOOLCHAINS_DIR"].map { FilePath($0) }
             // This is where the installer will put the toolchains, and where Xcode can find them
@@ -55,7 +57,7 @@ public struct MacOS: Platform {
     }
 
     public func install(
-        _ ctx: SwiftlyCoreContext, from tmpFile: FilePath, version: ToolchainVersion, verbose: Bool
+        _ ctx: SwiftlyCoreContext, from tmpFile: SystemPackage.FilePath, version: ToolchainVersion, verbose: Bool
     ) async throws {
         guard try await fs.exists(atPath: tmpFile) else {
             throw SwiftlyError(message: "\(tmpFile) doesn't exist")
@@ -71,7 +73,7 @@ public struct MacOS: Platform {
             // If the toolchains go into the default user location then we use the installer to install them
             await ctx.message("Installing package in user home directory...")
 
-            try await sys.installer(.verbose, .pkg(tmpFile), .target("CurrentUserHomeDirectory")).run(self, quiet: !verbose)
+            try await sys.installer(.verbose, .pkg(tmpFile), .target("CurrentUserHomeDirectory")).run()
         } else {
             // Otherwise, we extract the pkg into the requested toolchains directory.
             await ctx.message("Expanding pkg...")
@@ -84,7 +86,7 @@ public struct MacOS: Platform {
 
             await ctx.message("Checking package signature...")
             do {
-                try await sys.pkgutil().checksignature(pkg_path: tmpFile).run(self, quiet: !verbose)
+                try await sys.pkgutil().checksignature(pkg_path: tmpFile).run(quiet: !verbose)
             } catch {
                 // If this is not a test that uses mocked toolchains then we must throw this error and abort installation
                 guard ctx.mockedHomeDir != nil else {
@@ -94,7 +96,7 @@ public struct MacOS: Platform {
                 // We permit the signature verification to fail during testing
                 await ctx.message("Signature verification failed, which is allowable during testing with mocked toolchains")
             }
-            try await sys.pkgutil(.verbose).expand(pkg_path: tmpFile, dir_path: tmpDir).run(self, quiet: !verbose)
+            try await sys.pkgutil(.verbose).expand(pkg_path: tmpFile, dir_path: tmpDir).run()
 
             // There's a slight difference in the location of the special Payload file between official swift packages
             // and the ones that are mocked here in the test framework.
@@ -104,11 +106,11 @@ public struct MacOS: Platform {
             }
 
             await ctx.message("Untarring pkg Payload...")
-            try await sys.tar(.directory(toolchainDir)).extract(.verbose, .archive(payload)).run(self, quiet: !verbose)
+            try await sys.tar(.directory(toolchainDir)).extract(.verbose, .archive(payload)).run(quiet: !verbose)
         }
     }
 
-    public func extractSwiftlyAndInstall(_ ctx: SwiftlyCoreContext, from archive: FilePath) async throws {
+    public func extractSwiftlyAndInstall(_ ctx: SwiftlyCoreContext, from archive: SystemPackage.FilePath) async throws {
         guard try await fs.exists(atPath: archive) else {
             throw SwiftlyError(message: "\(archive) doesn't exist")
         }
@@ -120,16 +122,16 @@ public struct MacOS: Platform {
             try await sys.installer(
                 .pkg(archive),
                 .target("CurrentUserHomeDirectory")
-            ).run(self)
-            try? await sys.pkgutil(.volume(userHomeDir)).forget(pkg_id: "org.swift.swiftly").run(self)
+            ).run()
+            try? await sys.pkgutil(.volume(userHomeDir)).forget(pkg_id: "org.swift.swiftly").run()
         } else {
             let installDir = userHomeDir / ".swiftly"
             try await fs.mkdir(.parents, atPath: installDir)
 
             // In the case of a mock for testing purposes we won't use the installer, perferring a manual process because
             //  the installer will not install to an arbitrary path, only a volume or user home directory.
             let tmpDir = fs.mktemp()
-            try await sys.pkgutil().expand(pkg_path: archive, dir_path: tmpDir).run(self)
+            try await sys.pkgutil().expand(pkg_path: archive, dir_path: tmpDir).run()
 
             // There's a slight difference in the location of the special Payload file between official swift packages
             // and the ones that are mocked here in the test framework.
@@ -139,10 +141,10 @@ public struct MacOS: Platform {
             }
 
             await ctx.message("Extracting the swiftly package into \(installDir)...")
-            try await sys.tar(.directory(installDir)).extract(.verbose, .archive(payload)).run(self, quiet: false)
+            try await sys.tar(.directory(installDir)).extract(.verbose, .archive(payload)).run(quiet: false)
         }
 
-        try await self.runProgram((userHomeDir / ".swiftly/bin/swiftly").string, "init")
+        _ = try await run(.path(System.FilePath((userHomeDir / ".swiftly/bin/swiftly").string)), arguments: ["init"], input: .standardInput, output: .standardOutput, error: .standardError)
     }
 
     public func uninstall(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion, verbose: Bool)
@@ -164,22 +166,22 @@ public struct MacOS: Platform {
 
         try await fs.remove(atPath: toolchainDir)
 
-        try? await sys.pkgutil(.volume(fs.home)).forget(pkg_id: pkgInfo.CFBundleIdentifier).run(self, quiet: !verbose)
+        try? await sys.pkgutil(.volume(fs.home)).forget(pkg_id: pkgInfo.CFBundleIdentifier).run(quiet: !verbose)
     }
 
     public func getExecutableName() -> String {
         "swiftly-macos-osx"
     }
 
     public func verifyToolchainSignature(
-        _: SwiftlyCoreContext, toolchainFile _: ToolchainFile, archive _: FilePath, verbose _: Bool
+        _: SwiftlyCoreContext, toolchainFile _: ToolchainFile, archive _: SystemPackage.FilePath, verbose _: Bool
     ) async throws {
         // No signature verification is required on macOS since the pkg files have their own signing
         //  mechanism and the swift.org downloadables are trusted by stock macOS installations.
     }
 
     public func verifySwiftlySignature(
-        _: SwiftlyCoreContext, archiveDownloadURL _: URL, archive _: FilePath, verbose _: Bool
+        _: SwiftlyCoreContext, archiveDownloadURL _: URL, archive _: SystemPackage.FilePath, verbose _: Bool
     ) async throws {
         // No signature verification is required on macOS since the pkg files have their own signing
         //  mechanism and the swift.org downloadables are trusted by stock macOS installations.
@@ -201,11 +203,11 @@ public struct MacOS: Platform {
         return "/bin/zsh"
     }
 
-    public func findToolchainLocation(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) async throws -> FilePath
+    public func findToolchainLocation(_ ctx: SwiftlyCoreContext, _ toolchain: ToolchainVersion) async throws -> SystemPackage.FilePath
     {
         if toolchain == .xcodeVersion {
             // Print the toolchain location with the help of xcrun
-            if let xcrunLocation = try? await self.runProgramOutput("/usr/bin/xcrun", "-f", "swift") {
+            if let xcrunLocation = try? await run(.path(SystemPackage.FilePath("/usr/bin/xcrun")), arguments: ["-f", "swift"], output: .string(limit: 1024 * 10)).standardOutput {
                 return FilePath(xcrunLocation.replacingOccurrences(of: "\n", with: "")).removingLastComponent().removingLastComponent().removingLastComponent()
             }
         }

Sources/Swiftly/Proxy.swift

@@ -1,5 +1,6 @@
 import ArgumentParser
 import Foundation
+import Subprocess
 import SwiftlyCore
 
 @main
@@ -67,11 +68,24 @@ public enum Proxy {
             guard ProcessInfo.processInfo.environment["SWIFTLY_PROXY_IN_PROGRESS"] == nil else {
                 throw SwiftlyError(message: "Circular swiftly proxy invocation")
             }
-            let env = ["SWIFTLY_PROXY_IN_PROGRESS": "1"]
 
-            try await Swiftly.currentPlatform.proxy(ctx, toolchain, binName, Array(CommandLine.arguments[1...]), env)
+            let env = try await Swiftly.currentPlatform.proxyEnvironment(ctx, env: .inherit, toolchain: toolchain)
+
+            _ = try await Subprocess.run(
+                .name(binName),
+                arguments: Arguments(Array(CommandLine.arguments[1...])),
+                environment: env.updating(["SWIFTLY_PROXY_IN_PROGRESS": "1"]),
+                input: .standardInput,
+                output: .standardOutput,
+                error: .standardError
+            )
         } catch let terminated as RunProgramError {
-            exit(terminated.exitCode)
+            switch terminated.terminationStatus {
+            case let .exited(code):
+                exit(code)
+            case .unhandledException:
+                exit(1)
+            }
         } catch let error as SwiftlyError {
             await ctx.message(error.message)
             exit(1)

Sources/Swiftly/Run.swift

@@ -1,6 +1,8 @@
 import ArgumentParser
 import Foundation
+import Subprocess
 import SwiftlyCore
+import SystemPackage
 
 struct Run: SwiftlyCommand {
     public static let configuration = CommandConfiguration(
@@ -93,24 +95,47 @@ struct Run: SwiftlyCommand {
             throw SwiftlyError(message: "No installed swift toolchain is selected from either from a .swift-version file, or the default. You can try using one that's already installed with `swiftly use <toolchain version>` or install a new toolchain to use with `swiftly install --use <toolchain version>`.")
         }
 
-        do {
-            if let outputHandler = ctx.outputHandler {
-                if let output = try await Swiftly.currentPlatform.proxyOutput(ctx, toolchain, command[0], [String](command[1...])) {
-                    for line in output.split(separator: "\n") {
-                        await outputHandler.handleOutputLine(String(line))
-                    }
+        let env: Environment = try await Swiftly.currentPlatform.proxyEnvironment(ctx, env: .inherit, toolchain: toolchain)
+
+        let commandPath = FilePath(command[0])
+        let executable: Executable
+        if try await fs.exists(atPath: commandPath) {
+            executable = .path(commandPath)
+        } else {
+            // Search the toolchain ourselves to find the correct executable path. Subprocess's default search
+            // paths will interfere with preferring the selected toolchain over system toolchains.
+            let tcBinPath = try await Swiftly.currentPlatform.findToolchainLocation(ctx, toolchain) / "usr/bin"
+            let toolPath = tcBinPath / command[0]
+            if try await fs.exists(atPath: toolPath) && toolPath.isLexicallyNormal {
+                executable = .path(toolPath)
+            } else {
+                executable = .name(command[0])
+            }
+        }
+
+        let processConfig = Configuration(
+            executable: executable,
+            arguments: Arguments([String](command[1...])),
+            environment: env
+        )
+
+        if let outputHandler = ctx.outputHandler {
+            let result = try await Subprocess.run(processConfig) { _, output in
+                for try await line in output.lines() {
+                    await outputHandler.handleOutputLine(line.replacing("\n", with: ""))
                 }
-                return
             }
 
-            try await Swiftly.currentPlatform.proxy(ctx, toolchain, command[0], [String](command[1...]))
-        } catch let terminated as RunProgramError {
-            if ctx.mockedHomeDir != nil {
-                throw terminated
+            if !result.terminationStatus.isSuccess {
+                throw RunProgramError(terminationStatus: result.terminationStatus, config: processConfig)
             }
-            Foundation.exit(terminated.exitCode)
-        } catch {
-            throw error
+
+            return
+        }
+
+        let result = try await Subprocess.run(.path(FilePath(command[0])), arguments: Arguments([String](command[1...])), environment: env, input: .standardInput, output: .standardOutput, error: .standardError)
+        if !result.terminationStatus.isSuccess {
+            throw RunProgramError(terminationStatus: result.terminationStatus, config: processConfig)
         }
     }
 

Sources/SwiftlyCore/Commands+Runnable+Output.swift

@@ -2,8 +2,8 @@ import Foundation
 import SystemPackage
 
 extension SystemCommand.dsclCommand.readCommand: Output {
-    public func properties(_ p: Platform) async throws -> [(key: String, value: String)] {
-        let output = try await self.output(p)
+    public func properties(_: Platform) async throws -> [(key: String, value: String)] {
+        let output = try await self.output(limit: 1024 * 100)
         guard let output else { return [] }
 
         var props: [(key: String, value: String)] = []
@@ -21,8 +21,8 @@ extension SystemCommand.lipoCommand.createCommand: Runnable {}
 extension SystemCommand.pkgbuildCommand: Runnable {}
 
 extension SystemCommand.getentCommand: Output {
-    public func entries(_ platform: Platform) async throws -> [[String]] {
-        let output = try await output(platform)
+    public func entries() async throws -> [[String]] {
+        let output = try await output(limit: 1024 * 100)
         guard let output else { return [] }
 
         var entries: [[String]] = []