fastlane 2.73.0 → 2.74.0.beta.20180106010004

data/fastlane/lib/fastlane/server/socket_server_action_command_executor.rb

@@ -1,4 +1,5 @@
-require 'fastlane/server/command.rb'
+require 'fastlane/server/action_command_return.rb'
+require 'fastlane/server/command_parser.rb'
 require 'fastlane/server/command_executor.rb'
 
 module Fastlane
@@ -44,7 +45,7 @@ module Fastlane
         parameter_map: parameter_map
       )
 
-      command_return = CommandReturn.new(
+      command_return = ActionCommandReturn.new(
         return_value: action_return,
         return_value_type: action_class_ref.return_type,
         closure_argument_value: closure_argument_value
@@ -88,7 +89,7 @@ module Fastlane
         action_return = Fastlane::FastFile.sh(command_param, log: log_param, error_callback: error_callback)
       end
 
-      command_return = CommandReturn.new(
+      command_return = ActionCommandReturn.new(
         return_value: action_return,
         return_value_type: action_return_type,
         closure_argument_value: closure_argument_value

data/fastlane/lib/fastlane/swift_lane_manager.rb

@@ -26,23 +26,34 @@ module Fastlane
         socket_thread = self.start_socket_thread
         sleep(0.250) while socket_thread[:ready].nil?
         # wait on socket_thread to be in ready state, then start the runner thread
-        runner_thread = self.cruise_swift_lane_in_thread(lane, parameters)
+        self.cruise_swift_lane_in_thread(lane, parameters)
 
-        runner_thread.join
         socket_thread.join
       rescue Exception => ex # rubocop:disable Lint/RescueException
+        e = ex
+      end
+      # If we have a thread exception, drop that in the exception
+      # won't ever have a situation where e is non-nil, and socket_thread[:exception] is also non-nil
+      e ||= socket_thread[:exception]
+
+      unless e.nil?
+        print_lane_context
+
         # We also catch Exception, since the implemented action might send a SystemExit signal
         # (or similar). We still want to catch that, since we want properly finish running fastlane
         # Tested with `xcake`, which throws a `Xcake::Informative` object
+        UI.error e.to_s if e.kind_of?(StandardError) # we don't want to print things like 'system exit'
+      end
 
-        print_lane_context
-        UI.error ex.to_s if ex.kind_of?(StandardError) # we don't want to print things like 'system exit'
-        e = ex
+      skip_message = false
+      exit_reason = socket_thread[:exit_reason]
+      if exit_reason == :cancelled && e.nil?
+        skip_message = true
       end
 
       duration = ((Time.now - started) / 60.0).round
 
-      finish_fastlane(nil, duration, e)
+      finish_fastlane(nil, duration, e, skip_message: skip_message)
     end
 
     def self.display_lanes

data/fastlane/lib/fastlane/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
-  VERSION = '2.73.0'.freeze
+  VERSION = '2.74.0.beta.20180106010004'.freeze
   DESCRIPTION = "The easiest way to automate beta deployments and releases for your iOS and Android apps".freeze
   MINIMUM_XCODE_RELEASE = "7.0".freeze
   RUBOCOP_REQUIREMENT = '0.49.1'.freeze

data/fastlane/swift/ControlCommand.swift

@@ -0,0 +1,71 @@
+//
+//  ClientShutdownCommand.swift
+//  FastlaneRunner
+//
+//  Created by Joshua Liebowitz on 1/3/18.
+//  Copyright © 2018 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+struct ControlCommand: RubyCommandable {
+    static let commandKey = "command"
+    var type: CommandType { return .control }
+
+    enum ShutdownCommandType {
+        static let userMessageKey: String = "userMessage"
+
+        enum CancelReason {
+            static let reasonKey: String = "reason"
+            case clientError
+            case serverError
+
+            var reasonText: String {
+                switch self {
+                case .clientError:
+                    return "clientError"
+                case .serverError:
+                    return "serverError"
+                }
+            }
+        }
+
+        case done
+        case cancel(cancelReason: CancelReason)
+
+        var token: String {
+            switch self {
+            case .done:
+                return "done"
+            case .cancel:
+                return "cancelFastlaneRun"
+            }
+        }
+    }
+
+    let message: String?
+    let shutdownCommandType: ShutdownCommandType
+    var commandJson: String {
+        var jsonDictionary: [String: Any] = [ControlCommand.commandKey : self.shutdownCommandType.token]
+
+        if let message = message {
+            jsonDictionary[ShutdownCommandType.userMessageKey] = message
+        }
+        if case .cancel(let reason) = shutdownCommandType {
+            jsonDictionary[ShutdownCommandType.CancelReason.reasonKey] = reason.reasonText
+        }
+
+        let jsonData = try! JSONSerialization.data(withJSONObject: jsonDictionary, options: [])
+        let jsonString = String(data: jsonData, encoding: .utf8)!
+        return jsonString
+    }
+
+    init(commandType: ShutdownCommandType, message: String? = nil) {
+        self.shutdownCommandType = commandType
+        self.message = message
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/project.pbxproj

@@ -32,7 +32,9 @@
 		D55B28C91F6C588300DC42C5 /* Snapshotfile.swift in Sources */ = {isa = PBXBuildFile; fileRef = D55B28C21F6C588300DC42C5 /* Snapshotfile.swift */; };
 		D5A7C48F1F7C4DAF00A91DE6 /* Appfile.swift in Sources */ = {isa = PBXBuildFile; fileRef = D5A7C48D1F7C4DAF00A91DE6 /* Appfile.swift */; };
 		D5A7C4901F7C4DAF00A91DE6 /* Fastfile.swift in Sources */ = {isa = PBXBuildFile; fileRef = D5A7C48E1F7C4DAF00A91DE6 /* Fastfile.swift */; };
+		D5B8A5B31FFDC49E00536B24 /* ControlCommand.swift in Sources */ = {isa = PBXBuildFile; fileRef = D5B8A5B21FFDC49D00536B24 /* ControlCommand.swift */; };
 		D5BAFD121F7DAAFC0030B324 /* ArgumentProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = D5BAFD111F7DAAFC0030B324 /* ArgumentProcessor.swift */; };
+		D5D1DE991FFEE8EA00502A00 /* RubyCommandable.swift in Sources */ = {isa = PBXBuildFile; fileRef = D5D1DE981FFEE8E900502A00 /* RubyCommandable.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
@@ -62,7 +64,9 @@
 		D55B28C21F6C588300DC42C5 /* Snapshotfile.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = Snapshotfile.swift; path = ../Snapshotfile.swift; sourceTree = "<group>"; };
 		D5A7C48D1F7C4DAF00A91DE6 /* Appfile.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Appfile.swift; path = ../Appfile.swift; sourceTree = "<group>"; };
 		D5A7C48E1F7C4DAF00A91DE6 /* Fastfile.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Fastfile.swift; path = ../Fastfile.swift; sourceTree = "<group>"; };
+		D5B8A5B21FFDC49D00536B24 /* ControlCommand.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = ControlCommand.swift; path = ../ControlCommand.swift; sourceTree = "<group>"; };
 		D5BAFD111F7DAAFC0030B324 /* ArgumentProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = ArgumentProcessor.swift; path = ../ArgumentProcessor.swift; sourceTree = "<group>"; };
+		D5D1DE981FFEE8E900502A00 /* RubyCommandable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = RubyCommandable.swift; path = ../RubyCommandable.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -107,7 +111,9 @@
 		B3BA65B11F5A325E00B34850 /* Networking */ = {
 			isa = PBXGroup;
 			children = (
+				D5B8A5B21FFDC49D00536B24 /* ControlCommand.swift */,
 				B3BA65A01F5A269100B34850 /* RubyCommand.swift */,
+				D5D1DE981FFEE8E900502A00 /* RubyCommandable.swift */,
 				B3BA65A11F5A269100B34850 /* Runner.swift */,
 				B3BA65A21F5A269100B34850 /* SocketClient.swift */,
 				B3BA65A31F5A269100B34850 /* SocketClientDelegateProtocol.swift */,
@@ -225,6 +231,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				B3BA65A91F5A269100B34850 /* RubyCommand.swift in Sources */,
+				D5D1DE991FFEE8EA00502A00 /* RubyCommandable.swift in Sources */,
 				D55B28C41F6C588300DC42C5 /* Gymfile.swift in Sources */,
 				B302067D1F5E3E9000DE6EBD /* MatchfileProtocol.swift in Sources */,
 				B3BA65AC1F5A269100B34850 /* SocketClientDelegateProtocol.swift in Sources */,
@@ -243,6 +250,7 @@
 				B30206811F5E3E9000DE6EBD /* DeliverfileProtocol.swift in Sources */,
 				B3BA65AA1F5A269100B34850 /* Runner.swift in Sources */,
 				B3BA65AF1F5A2D5C00B34850 /* RunnerArgument.swift in Sources */,
+				D5B8A5B31FFDC49E00536B24 /* ControlCommand.swift in Sources */,
 				B302067E1F5E3E9000DE6EBD /* PrecheckfileProtocol.swift in Sources */,
 				B3BA65AD1F5A269100B34850 /* SocketResponse.swift in Sources */,
 				B3BA65A81F5A269100B34850 /* main.swift in Sources */,

data/fastlane/swift/LaneFileProtocol.swift

@@ -10,8 +10,8 @@ import Foundation
 
 public protocol LaneFileProtocol: class {
     var fastlaneVersion: String { get }
-    static func runLane(named: String, parameters: [String : String])
-    
+    static func runLane(named: String, parameters: [String : String]) -> Bool
+
     func recordLaneDescriptions()
     func beforeAll()
     func afterAll(currentLane: String)
@@ -29,38 +29,54 @@ public extension LaneFileProtocol {
 @objcMembers
 public class LaneFile: NSObject, LaneFileProtocol {
     private(set) static var fastfileInstance: Fastfile?
-    
+
     // Called before any lane is executed.
     private func setupAllTheThings() {
-        // Step 1, add lange descriptions
-        (self as! Fastfile).recordLaneDescriptions()
-        
-        // Step 2, run beforeAll() function
         LaneFile.fastfileInstance!.beforeAll()
     }
-    
-    public static var lanes: [String : String] {
-        var laneToMethodName: [String : String] = [:]
+
+    private static func trimLaneFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 4))
+    }
+
+    private static func trimLaneWithOptionsFromName(laneName: String) -> String {
+        return String(laneName.prefix(laneName.count - 12))
+    }
+
+    private static var laneFunctionNames: [String] {
+        var lanes: [String] = []
         var methodCount: UInt32 = 0
         let methodList = class_copyMethodList(self, &methodCount)
         for i in 0..<Int(methodCount) {
             let selName = sel_getName(method_getName(methodList![i]))
             let name = String(cString: selName)
+            let lowercasedName = name.lowercased()
+            if lowercasedName.hasSuffix("lane") || lowercasedName.hasSuffix("lanewithoptions:") {
+                lanes.append(name)
+            }
+        }
+        return lanes
+    }
+
+    public static var lanes: [String : String] {
+        var laneToMethodName: [String : String] = [:]
+        self.laneFunctionNames.forEach { name in
             let lowercasedName = name.lowercased()
             if lowercasedName.hasSuffix("lane") {
                 laneToMethodName[lowercasedName] = name
-                let lowercasedNameNoLane = String(lowercasedName.prefix(lowercasedName.count - 4))
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedName)
                 laneToMethodName[lowercasedNameNoLane] = name
             } else if lowercasedName.hasSuffix("lanewithoptions:") {
-                let lowercasedNameNoOptions = String(lowercasedName.prefix(lowercasedName.count - 12))
+                let lowercasedNameNoOptions = trimLaneWithOptionsFromName(laneName: lowercasedName)
                 laneToMethodName[lowercasedNameNoOptions] = name
-                let lowercasedNameNoLane = String(lowercasedNameNoOptions.prefix(lowercasedNameNoOptions.count - 4))
+                let lowercasedNameNoLane = trimLaneFromName(laneName: lowercasedNameNoOptions)
                 laneToMethodName[lowercasedNameNoLane] = name
             }
         }
+
         return laneToMethodName
     }
-    
+
     public static func loadFastfile() {
         if self.fastfileInstance == nil {
             let fastfileType: AnyObject.Type = NSClassFromString(self.className())!
@@ -69,38 +85,50 @@ public class LaneFile: NSObject, LaneFileProtocol {
             self.fastfileInstance = currentFastfileInstance
         }
     }
-    
-    public static func runLane(named: String, parameters: [String : String]) {
+
+    public static func runLane(named: String, parameters: [String : String]) -> Bool {
         log(message: "Running lane: \(named)")
         self.loadFastfile()
-        
+
         guard let fastfileInstance: Fastfile = self.fastfileInstance else {
             let message = "Unable to instantiate class named: \(self.className())"
             log(message: message)
             fatalError(message)
         }
-        
-        // call all methods that need to be called before we start calling lanes
-        fastfileInstance.setupAllTheThings()
-        
+
         let currentLanes = self.lanes
         let lowerCasedLaneRequested = named.lowercased()
-        
+
         guard let laneMethod = currentLanes[lowerCasedLaneRequested] else {
-            let message = "unable to find lane named: \(named)"
+            let laneNames = self.laneFunctionNames.map { laneFuctionName in
+                if laneFuctionName.hasSuffix("lanewithoptions:") {
+                    return trimLaneWithOptionsFromName(laneName: laneFuctionName)
+                } else {
+                    return trimLaneFromName(laneName: laneFuctionName)
+                }
+            }.joined(separator: ", ")
+
+            let message = "[!] Could not find lane '\(named)'. Available lanes: \(laneNames)"
             log(message: message)
-            fatalError(message)
+
+            let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .clientError), message: message)
+            _ = runner.executeCommand(shutdownCommand)
+            return false
         }
-        
+
+        // call all methods that need to be called before we start calling lanes
+        fastfileInstance.setupAllTheThings()
+
         // We need to catch all possible errors here and display a nice message
         _ = fastfileInstance.perform(NSSelectorFromString(laneMethod), with: parameters)
-        
+
         // only call on success
         fastfileInstance.afterAll(currentLane: named)
         log(message: "Done running lane: \(named) 🚀")
+        return true
     }
 }
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.1]
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/RubyCommand.swift

@@ -8,11 +8,9 @@
 
 import Foundation
 
-protocol RubyCommandable {
-    var json: String { get }
-}
-
 struct RubyCommand: RubyCommandable {
+    var type: CommandType { return .action }
+
     struct Argument {
         enum ArgType {
             case stringClosure
@@ -41,7 +39,6 @@ struct RubyCommand: RubyCommandable {
 
         var json: String {
             get {
-
                 if let someValue = value {
                     let typeJson: String
                     if let type = type {
@@ -102,7 +99,7 @@ struct RubyCommand: RubyCommandable {
         callbackClosure(callbackArg)
     }
 
-    var json: String {
+    var commandJson: String {
         let argsArrayJson = self.args
             .map { $0.json }
             .filter { $0 != "" }

data/fastlane/swift/RubyCommandable.swift

@@ -0,0 +1,38 @@
+//
+//  RubyCommandable.swift
+//  FastlaneRunner
+//
+//  Created by Joshua Liebowitz on 1/4/18.
+//  Copyright © 2018 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+enum CommandType {
+    case action
+    case control
+
+    var token: String {
+        switch self {
+        case .action:
+            return "action"
+        case .control:
+            return "control"
+        }
+    }
+}
+
+protocol RubyCommandable {
+    var type: CommandType { get }
+    var commandJson: String { get }
+}
+
+extension RubyCommandable {
+    var json: String {
+        return "{\"commandType\" : \"\(self.type.token)\", \"command\" : \(self.commandJson)}"
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/Runner.swift

@@ -27,7 +27,7 @@ class Runner {
     fileprivate var returnValue: String? // lol, so safe
     fileprivate var currentlyExecutingCommand: RubyCommandable? = nil
     fileprivate var shouldLeaveDispatchGroupDuringDisconnect = false
-    
+
     func executeCommand(_ command: RubyCommandable) -> String {
         self.dispatchGroup.enter()
         currentlyExecutingCommand = command
@@ -115,7 +115,10 @@ extension Runner : SocketClientDelegateProtocol {
                 }
             }
             self.dispatchGroup.leave()
-            
+        case .clientInitiatedCancelAcknowledged:
+            verbose(message: "server acknowledged a cancel request")
+            self.dispatchGroup.leave()
+
         case .alreadyClosedSockets, .connectionFailure, .malformedRequest, .malformedResponse, .serverError:
             log(message: "error encountered while executing command:\n\(serverResponse)")
             self.dispatchGroup.leave()
@@ -187,4 +190,4 @@ func verbose(message: String) {
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.1]
+// FastlaneRunnerAPIVersion [0.9.2]

data/fastlane/swift/SocketClient.swift

@@ -13,6 +13,7 @@ public enum SocketClientResponse: Error {
     case malformedRequest
     case malformedResponse
     case serverError
+    case clientInitiatedCancelAcknowledged
     case commandTimeout(seconds: Int)
     case connectionFailure
     case success(returnedObject: String?, closureArgumentValue: String?)
@@ -27,7 +28,8 @@ class SocketClient: NSObject {
     
     static let connectTimeoutSeconds = 2
     static let defaultCommandTimeoutSeconds = 3_600 // Hopefully 1 hr is enough ¯\_(ツ)_/¯
-    static let doneToken = "done"
+    static let doneToken = "done" // TODO: remove these
+    static let cancelToken = "cancelFastlaneRun"
     
     fileprivate var inputStream: InputStream!
     fileprivate var outputStream: OutputStream!
@@ -106,7 +108,7 @@ class SocketClient: NSObject {
     }
     
     public func sendComplete() {
-        sendAbort()
+        closeSession(sendAbort: true)
     }
     
     private func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
@@ -130,42 +132,50 @@ class SocketClient: NSObject {
     private func stopOutputSession() {
         outputStream.close()
     }
-    
-    private func send(string: String) {
-        guard !self.cleaningUpAfterDone else {
-            // This will happen after we abort if there are commands waiting to be executed
-            // Need to check state of SocketClient in command runner to make sure we can accept `send`
-            socketDelegate?.commandExecuted(serverResponse: .alreadyClosedSockets)
-            return
-        }
-        
-        if string == SocketClient.doneToken {
-            self.cleaningUpAfterDone = true
-        }
-        
-        self.dispatchGroup.enter()
+
+    private func sendThroughQueue(string: String) {
         streamQueue.async {
             let data = string.data(using: .utf8)!
             _ = data.withUnsafeBytes { self.outputStream.write($0, maxLength: data.count) }
         }
+    }
 
-        let timeoutSeconds = self.cleaningUpAfterDone ? 1 : self.commandTimeoutSeconds
+    private func privateSend(string: String) {
+        self.dispatchGroup.enter()
+        sendThroughQueue(string: string)
 
+        let timeoutSeconds = self.cleaningUpAfterDone ? 1 : self.commandTimeoutSeconds
         let timeToWait = DispatchTimeInterval.seconds(timeoutSeconds)
         let commandTimeout = DispatchTime.now() + timeToWait
         let timeoutResult =  self.dispatchGroup.wait(timeout: commandTimeout)
 
         _ = testDispatchTimeoutResult(timeoutResult, failureMessage: "Ruby process didn't return after: \(SocketClient.connectTimeoutSeconds) seconds", timeToWait: timeToWait)
     }
-    
-    func sendAbort() {
+
+    private func send(string: String) {
+        guard !self.cleaningUpAfterDone else {
+            // This will happen after we abort if there are commands waiting to be executed
+            // Need to check state of SocketClient in command runner to make sure we can accept `send`
+            socketDelegate?.commandExecuted(serverResponse: .alreadyClosedSockets)
+            return
+        }
+
+        if string == SocketClient.doneToken {
+            self.cleaningUpAfterDone = true
+        }
+
+        privateSend(string: string)
+    }
+
+    func closeSession(sendAbort: Bool = true) {
         self.socketStatus = .closed
-        
+
         stopInputSession()
-        
-        // and error occured, let's try to send the "done" message
-        send(string: SocketClient.doneToken)
-        
+
+        if sendAbort {
+            send(rubyCommand: ControlCommand(commandType: .done))
+        }
+
         stopOutputSession()
         self.socketDelegate?.connectionsClosed()
     }
@@ -188,7 +198,7 @@ extension SocketClient: StreamDelegate {
                 
             case Stream.Event.errorOccurred:
                 verbose(message: "input stream error occurred")
-                sendAbort()
+                closeSession(sendAbort: true)
                 
             case Stream.Event.hasBytesAvailable:
                 read()
@@ -246,7 +256,8 @@ extension SocketClient: StreamDelegate {
     
     func handleFailure(message: [String]) {
         log(message: "Encountered a problem: \(message.joined(separator:"\n"))")
-        sendAbort()
+        let shutdownCommand = ControlCommand(commandType: .cancel(cancelReason: .serverError))
+        self.send(rubyCommand: shutdownCommand)
     }
     
     func processResponse(string: String) {
@@ -261,6 +272,10 @@ extension SocketClient: StreamDelegate {
         let socketResponse = SocketResponse(payload: responseString)
         verbose(message: "response is: \(responseString)")
         switch socketResponse.responseType {
+        case .clientInitiatedCancel:
+            self.socketDelegate?.commandExecuted(serverResponse: .clientInitiatedCancelAcknowledged)
+            self.closeSession(sendAbort: false)
+
         case .failure(let failureInformation):
             self.socketDelegate?.commandExecuted(serverResponse: .serverError)
             self.handleFailure(message: failureInformation)
@@ -274,10 +289,11 @@ extension SocketClient: StreamDelegate {
             // cool, ready for next command
             break
         }
+
         self.dispatchGroup.leave() // should now pull the next piece of work
     }
 }
 
 // Please don't remove the lines below
 // They are used to detect outdated files
-// FastlaneRunnerAPIVersion [0.9.1]
+// FastlaneRunnerAPIVersion [0.9.2]