Bring back Sergio's "Add support for Process stdin strean"

This PR resurrects swiftlang#122, which we required in order to be able to forward standard input in the new swift-driver to the compile jobs it spawns.
The change was previously reverted in swiftlang#143, due to an error seen on Linux.

Author: artemcm

Sources/TSCBasic/Process.swift

@@ -374,8 +374,11 @@ public final class Process: ObjectIdentifierProtocol {
         }
     }
 
-    /// Launch the subprocess.
-    public func launch() throws {
+  /// Launch the subprocess. Returns a WritableByteStream object that can be used to communicate to the process's
+  /// stdin. If needed, the stream can be closed using the close() API. Otherwise, the stream will be closed
+  /// automatically.
+  @discardableResult
+  public func launch() throws -> WritableByteStream {
         precondition(arguments.count > 0 && !arguments[0].isEmpty, "Need at least one argument to launch the process.")
 
         self.launchedLock.withLock {
@@ -401,6 +404,9 @@ public final class Process: ObjectIdentifierProtocol {
         _process?.executableURL = executablePath.asURL
         _process?.environment = environment
 
+        let stdinPipe = Pipe()
+        _process?.standardInput = stdinPipe
+
         if outputRedirection.redirectsOutput {
             let stdoutPipe = Pipe()
             let stderrPipe = Pipe()
@@ -423,6 +429,8 @@ public final class Process: ObjectIdentifierProtocol {
         }
 
         try _process?.run()
+
+        return stdinPipe.fileHandleForWriting
         #else
         // Initialize the spawn attributes.
         #if canImport(Darwin) || os(Android)
@@ -497,14 +505,27 @@ public final class Process: ObjectIdentifierProtocol {
             #endif
         }
 
-        // Workaround for https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=89e435f3559c53084498e9baad22172b64429362
-        // Change allowing for newer version of glibc
-        guard let devNull = strdup("/dev/null") else {
-            throw SystemError.posix_spawn(0, arguments)
-        }
-        defer { free(devNull) }
-        // Open /dev/null as stdin.
-        posix_spawn_file_actions_addopen(&fileActions, 0, devNull, O_RDONLY, 0)
+        var stdinPipe: [Int32] = [-1, -1]
+        try open(pipe: &stdinPipe)
+
+        let stdinStream = try LocalFileOutputByteStream(filePointer: fdopen(stdinPipe[1], "wb"),
+                                                        closeOnDeinit: true)
+
+        // Dupe the read portion of the remote to 0.
+        posix_spawn_file_actions_adddup2(&fileActions, stdinPipe[0], STDIN_FILENO)
+
+        // Close the other side's pipe since it was dupped to 0.
+        posix_spawn_file_actions_addclose(&fileActions, stdinPipe[0])
+        posix_spawn_file_actions_addclose(&fileActions, stdinPipe[1])
+
+//        // Workaround for https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=89e435f3559c53084498e9baad22172b64429362
+//        // Change allowing for newer version of glibc
+//        guard let devNull = strdup("/dev/null") else {
+//            throw SystemError.posix_spawn(0, arguments)
+//        }
+//        defer { free(devNull) }
+//        // Open /dev/null as stdin.
+//        posix_spawn_file_actions_addopen(&fileActions, 0, devNull, O_RDONLY, 0)
 
         var outputPipe: [Int32] = [-1, -1]
         var stderrPipe: [Int32] = [-1, -1]
@@ -515,7 +536,7 @@ public final class Process: ObjectIdentifierProtocol {
             // Open the write end of the pipe.
             posix_spawn_file_actions_adddup2(&fileActions, outputPipe[1], 1)
 
-            // Close the other ends of the pipe.
+            // Close the other ends of the pipe since they were dupped to 1.
             posix_spawn_file_actions_addclose(&fileActions, outputPipe[0])
             posix_spawn_file_actions_addclose(&fileActions, outputPipe[1])
 
@@ -527,7 +548,7 @@ public final class Process: ObjectIdentifierProtocol {
                 try open(pipe: &stderrPipe)
                 posix_spawn_file_actions_adddup2(&fileActions, stderrPipe[1], 2)
 
-                // Close the other ends of the pipe.
+                // Close the other ends of the pipe since they were dupped to 2.
                 posix_spawn_file_actions_addclose(&fileActions, stderrPipe[0])
                 posix_spawn_file_actions_addclose(&fileActions, stderrPipe[1])
             }
@@ -548,6 +569,9 @@ public final class Process: ObjectIdentifierProtocol {
             throw SystemError.posix_spawn(rv, arguments)
         }
 
+        // Close the local read end of the input pipe.
+        try close(fd: stdinPipe[0])
+
         if !outputRedirection.redirectsOutput {
             // no stdout or stderr in this case
             self.stateLock.withLock {
@@ -559,8 +583,8 @@ public final class Process: ObjectIdentifierProtocol {
 
             let outputClosures = outputRedirection.outputClosures
 
-            // Close the write end of the output pipe.
-            try close(fd: &outputPipe[1])
+            // Close the local write end of the output pipe.
+            try close(fd: outputPipe[1])
 
             // Create a thread and start reading the output on it.
             let stdoutThread = Thread { [weak self] in
@@ -585,8 +609,8 @@ public final class Process: ObjectIdentifierProtocol {
             // Only schedule a thread for stderr if no redirect was requested.
             var stderrThread: Thread? = nil
             if !outputRedirection.redirectStderr {
-                // Close the write end of the stderr pipe.
-                try close(fd: &stderrPipe[1])
+                // Close the local write end of the stderr pipe.
+                try close(fd: stderrPipe[1])
 
                 // Create a thread and start reading the stderr output on it.
                 stderrThread = Thread { [weak self] in
@@ -619,6 +643,7 @@ public final class Process: ObjectIdentifierProtocol {
             stdoutThread.start()
             stderrThread?.start()
         }
+        return stdinStream
         #endif // POSIX implementation
     }
 
@@ -830,11 +855,15 @@ private func open(pipe: inout [Int32]) throws {
 }
 
 /// Close the given fd.
-private func close(fd: inout Int32) throws {
-    let rv = TSCLibc.close(fd)
-    guard rv == 0 else {
-        throw SystemError.close(rv)
+private func close(fd: Int32) throws {
+    func innerClose(_ fd: inout Int32) throws {
+        let rv = TSCLibc.close(fd)
+        guard rv == 0 else {
+            throw SystemError.close(rv)
+        }
     }
+    var innerFd = fd
+    try innerClose(&innerFd)
 }
 
 extension Process.Error: CustomStringConvertible {
@@ -900,3 +929,27 @@ extension ProcessResult.Error: CustomNSError {
         return [NSLocalizedDescriptionKey: self.description]
     }
 }
+
+#if os(Windows)
+extension FileHandle: WritableByteStream {
+    public var position: Int {
+        return Int(offsetInFile)
+    }
+
+    public func write(_ byte: UInt8) {
+        write(Data([byte]))
+    }
+
+    public func write<C: Collection>(_ bytes: C) where C.Element == UInt8 {
+        write(Data(bytes))
+    }
+
+    public func flush() {
+        synchronizeFile()
+    }
+
+    public func close() throws {
+        closeFile()
+    }
+}
+#endif

Tests/TSCBasicTests/ProcessTests.swift

@@ -216,6 +216,20 @@ class ProcessTests: XCTestCase {
         XCTAssertEqual(result2, "hello\n")
     }
 
+    func testStdin() throws {
+        var stdout = [UInt8]()
+        let process = Process(args: script("in-to-out"), outputRedirection: .stream(stdout: { stdoutBytes in
+            stdout += stdoutBytes
+        }, stderr: { _ in }))
+        let stdinStream = try process.launch()
+        stdinStream.write("hello\n")
+        stdinStream.flush()
+        try stdinStream.close()
+        try process.waitUntilExit()
+
+        XCTAssertEqual(String(decoding: stdout, as: UTF8.self), "hello\n")
+    }
+
     func testStdoutStdErr() throws {
         // A simple script to check that stdout and stderr are captured separatly.
         do {

Tests/TSCBasicTests/processInputs/in-to-out

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+import sys
+
+sys.stdout.write(sys.stdin.readline())