Process: Deprecate old methods and properties, implement run()

- Mark launchPath and currentDirectoryPath as deprecated,
  replace with executableURL and currentDirectoryURL.

- Implement run() and Process.run(_:arguments:terminationHandler:)
  and mark launch() and Process.launchedProcess(path:arguments:) as
  deprecated.

- Update DarwinCompatibility Tests to 10.13 to use run().

Author: spevans

DarwinCompatibilityTests.xcodeproj/project.pbxproj

@@ -642,7 +642,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.12;
+				MACOSX_DEPLOYMENT_TARGET = 10.13;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = macosx;
@@ -693,7 +693,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.12;
+				MACOSX_DEPLOYMENT_TARGET = 10.13;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";

Foundation/Process.swift

@@ -1,6 +1,6 @@
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2016, 2018 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
@@ -153,7 +153,7 @@ open class Process: NSObject {
             }
         }
     }
-    
+
     // Create an Process which can be run at a later time
     // An Process can only be run once. Subsequent attempts to
     // run an Process will raise.
@@ -162,48 +162,36 @@ open class Process: NSObject {
     //
 
     public override init() {
-    
+
     }
-    
-    // These methods can only be set before a launch.
-    
-    open var launchPath: String?
+
+    // These properties can only be set before a launch.
+    open var executableURL: URL?
+    open var currentDirectoryURL = URL(fileURLWithPath: FileManager.default.currentDirectoryPath, isDirectory: true)
     open var arguments: [String]?
     open var environment: [String : String]? // if not set, use current
-    
-    open var currentDirectoryPath: String = FileManager.default.currentDirectoryPath
-    
-    open var executableURL: URL? {
-        get {
-            guard let launchPath = self.launchPath else {
-                return nil
-            }
-            
-            return URL(fileURLWithPath: launchPath)
-        }
-        set {
-            self.launchPath = newValue?.path
-        }
+
+    @available(*, deprecated: 4, renamed: "executableURL")
+    open var launchPath: String? {
+        get { return executableURL?.path }
+        set { executableURL = (newValue != nil) ? URL(fileURLWithPath: newValue!) : nil }
     }
-    
-    open var currentDirectoryURL: URL {
-        get {
-            return URL(fileURLWithPath: self.currentDirectoryPath)
-        }
-        set {
-            self.currentDirectoryPath = newValue.path
-        }
+
+    @available(*, deprecated: 4, renamed: "currentDirectoryURL")
+    open var currentDirectoryPath: String {
+        get { return currentDirectoryURL.path }
+        set { currentDirectoryURL = URL(fileURLWithPath: newValue) }
     }
-    
+
     // Standard I/O channels; could be either a FileHandle or a Pipe
-    
+
     open var standardInput: Any? {
         willSet {
             precondition(newValue is Pipe || newValue is FileHandle,
                          "standardInput must be either Pipe or FileHandle")
         }
     }
-    
+
     open var standardOutput: Any? {
         willSet {
             precondition(newValue is Pipe || newValue is FileHandle,
@@ -227,7 +215,30 @@ open class Process: NSObject {
 
     // Actions
 
+    @available(*, deprecated: 4, renamed: "run")
     open func launch() {
+        do {
+            try run()
+        } catch let nserror as NSError {
+            if let path = nserror.userInfo[NSFilePathErrorKey] as? String, path == currentDirectoryPath {
+                // Foundation throws an NSException when changing the working directory fails,
+                // and unfortunately launch() is not marked `throws`, so we get away with a
+                // fatalError.
+                switch CocoaError.Code(rawValue: nserror.code) {
+                case .fileReadNoSuchFile:
+                    fatalError("Process: The specified working directory does not exist.")
+                case .fileReadNoPermission:
+                    fatalError("Process: The specified working directory cannot be accessed.")
+                default:
+                    fatalError("Process: The specified working directory cannot be set.")
+                }
+            }
+        } catch {
+            fatalError(String(describing: error))
+        }
+    }
+
+    open func run() throws {
 
         self.processLaunchedCondition.lock()
 
@@ -236,9 +247,8 @@ open class Process: NSObject {
         Process.setup()
 
         // Ensure that the launch path is set
-        
-        guard let launchPath = self.launchPath else {
-            fatalError()
+        guard let launchPath = self.executableURL?.path else {
+            throw NSError(domain: NSCocoaErrorDomain, code: NSFileNoSuchFileError)
         }
 
         // Convert the arguments array into a posix_spawn-friendly format
@@ -260,7 +270,6 @@ open class Process: NSObject {
             for arg in argv ..< argv + args.count {
                 free(UnsafeMutableRawPointer(arg.pointee))
             }
-            
             argv.deallocate()
         }
 
@@ -294,7 +303,7 @@ open class Process: NSObject {
         context.version = 0
         context.retain = runLoopSourceRetain
         context.release = runLoopSourceRelease
-	context.info = Unmanaged.passUnretained(self).toOpaque()
+        context.info = Unmanaged.passUnretained(self).toOpaque()
 
         let socket = CFSocketCreateWithNative( nil, taskSocketPair[0], CFOptionFlags(kCFSocketDataCallBack), {
             (socket, type, address, data, info )  in
@@ -316,7 +325,7 @@ open class Process: NSObject {
             }
 #endif
             var waitResult : Int32 = 0
-            
+
             repeat {
 #if CYGWIN
                 waitResult = waitpid( process.processIdentifier, exitCodePtrWrapper, 0)
@@ -344,9 +353,9 @@ open class Process: NSObject {
             }
 
             // Set the running flag to false
-            
             process.isRunning = false
-            
+            process.processIdentifier = -1
+
             // Invalidate the source and wake up the run loop, if it's available
 
             CFRunLoopSourceInvalidate(process.runLoopSource)
@@ -417,24 +426,16 @@ open class Process: NSObject {
 
         let fileManager = FileManager()
         let previousDirectoryPath = fileManager.currentDirectoryPath
-        if !fileManager.changeCurrentDirectoryPath(currentDirectoryPath) {
-            // Foundation throws an NSException when changing the working directory fails,
-            // and unfortunately launch() is not marked `throws`, so we get away with a
-            // fatalError.
-            switch errno {
-            case ENOENT:
-                fatalError("Process: The specified working directory does not exist.")
-            case EACCES:
-                fatalError("Process: The specified working directory cannot be accessed.")
-            default:
-                fatalError("Process: The specified working directory cannot be set.")
-            }
+        if !fileManager.changeCurrentDirectoryPath(currentDirectoryURL.path) {
+            throw _NSErrorWithErrno(errno, reading: true, url: currentDirectoryURL)
         }
 
         // Launch
 
         var pid = pid_t()
-        posix(posix_spawn(&pid, launchPath, &fileActions, nil, argv, envp))
+        guard posix_spawn(&pid, launchPath, &fileActions, nil, argv, envp) == 0 else {
+            throw _NSErrorWithErrno(errno, reading: true, path: launchPath)
+        }
 
         // Reset the previous working directory path.
         fileManager.changeCurrentDirectoryPath(previousDirectoryPath)
@@ -506,10 +507,18 @@ open class Process: NSObject {
     */
     open var terminationHandler: ((Process) -> Void)?
     open var qualityOfService: QualityOfService = .default  // read-only after the process is launched
-}
 
-extension Process {
-    
+
+    open class func run(_ url: URL, arguments: [String], terminationHandler: ((Process) -> Void)? = nil) throws -> Process {
+        let process = Process()
+        process.executableURL = url
+        process.arguments = arguments
+        process.terminationHandler = terminationHandler
+        try process.run()
+        return process
+    }
+
+    @available(*, deprecated: 4, renamed: "run(_:arguments:terminationHandler:)")
     // convenience; create and launch
     open class func launchedProcess(launchPath path: String, arguments: [String]) -> Process {
         let process = Process()
@@ -519,7 +528,7 @@ extension Process {
 
         return process
     }
-    
+
     // poll the runLoop in defaultMode until process completes
     open func waitUntilExit() {
 

TestFoundation/TestProcess.swift

@@ -1,6 +1,6 @@
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2015 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2015 - 2016, 2018 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
@@ -28,6 +28,7 @@ class TestProcess : XCTestCase {
                    ("test_passthrough_environment", test_passthrough_environment),
                    ("test_no_environment", test_no_environment),
                    ("test_custom_environment", test_custom_environment),
+                   ("test_run", test_run),
         ]
 #endif
     }
@@ -286,6 +287,25 @@ class TestProcess : XCTestCase {
             XCTFail("Test failed: \(error)")
         }
     }
+
+    func test_run() {
+        do {
+            let process = try Process.run(URL(fileURLWithPath: "/bin/sh", isDirectory: false), arguments: ["-c", "exit 123"], terminationHandler: nil)
+            process.waitUntilExit()
+            XCTAssertEqual(process.terminationReason, .exit)
+            XCTAssertEqual(process.terminationStatus, 123)
+        } catch {
+            XCTFail("Cant execute /bin/sh: error")
+        }
+
+        do {
+            let process = try Process.run(URL(fileURLWithPath: "/..", isDirectory: false), arguments: [], terminationHandler: nil)
+            XCTFail("Somehow executed a directory!")
+            process.terminate()
+        } catch {
+        }
+    }
+
 #endif
 }