fastlane 2.69.2 → 2.69.3

data/fastlane/swift/SocketClient.swift

@@ -0,0 +1,283 @@
+//
+//  SocketClient.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 7/30/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+public enum SocketClientResponse: Error {
+    case alreadyClosedSockets
+    case malformedRequest
+    case malformedResponse
+    case serverError
+    case commandTimeout(seconds: Int)
+    case connectionFailure
+    case success(returnedObject: String?, closureArgumentValue: String?)
+}
+
+class SocketClient: NSObject {
+    
+    enum SocketStatus {
+        case ready
+        case closed
+    }
+    
+    static let connectTimeoutSeconds = 2
+    static let defaultCommandTimeoutSeconds = 3_600 // Hopefully 1 hr is enough ¯\_(ツ)_/¯
+    static let doneToken = "done"
+    
+    fileprivate var inputStream: InputStream!
+    fileprivate var outputStream: OutputStream!
+    fileprivate var cleaningUpAfterDone = false
+    fileprivate let dispatchGroup: DispatchGroup = DispatchGroup()
+    fileprivate let commandTimeoutSeconds: Int
+    
+    private let streamQueue: DispatchQueue
+    private let host: String
+    private let port: UInt32
+
+    let maxReadLength = 65_536 // max for ipc on 10.12 is kern.ipc.maxsockbuf: 8388608 ($sysctl kern.ipc.maxsockbuf)
+    
+    weak private(set) var socketDelegate: SocketClientDelegateProtocol?
+    
+    public private(set) var socketStatus: SocketStatus
+    
+    // localhost only, this prevents other computers from connecting
+    init(host: String = "localhost", port: UInt32 = 2000, commandTimeoutSeconds: Int = defaultCommandTimeoutSeconds, socketDelegate: SocketClientDelegateProtocol) {
+        self.host = host
+        self.port = port
+        self.commandTimeoutSeconds = commandTimeoutSeconds
+        self.streamQueue = DispatchQueue(label: "streamQueue")
+        self.socketStatus = .closed
+        self.socketDelegate = socketDelegate
+        super.init()
+    }
+    
+    func connectAndOpenStreams() {
+        var readStream: Unmanaged<CFReadStream>?
+        var writeStream: Unmanaged<CFWriteStream>?
+        
+        self.streamQueue.async {
+            CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, self.host as CFString, self.port, &readStream, &writeStream)
+            
+            self.inputStream = readStream!.takeRetainedValue()
+            self.outputStream = writeStream!.takeRetainedValue()
+            
+            self.inputStream.delegate = self
+            self.outputStream.delegate = self
+            
+            self.inputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
+            self.outputStream.schedule(in: .main, forMode: .defaultRunLoopMode)
+        }
+        
+        self.dispatchGroup.enter()
+        self.streamQueue.async {
+            self.inputStream.open()
+        }
+        
+        self.dispatchGroup.enter()
+        self.streamQueue.async {
+            self.outputStream.open()
+        }
+        
+        let secondsToWait = DispatchTimeInterval.seconds(SocketClient.connectTimeoutSeconds)
+        let connectTimeout = DispatchTime.now() + secondsToWait
+        
+        let timeoutResult = self.dispatchGroup.wait(timeout: connectTimeout)
+        let failureMessage = "Couldn't connect to ruby process within: \(SocketClient.connectTimeoutSeconds) seconds"
+        
+        let success = testDispatchTimeoutResult(timeoutResult, failureMessage: failureMessage, timeToWait: secondsToWait)
+        
+        guard success else {
+            self.socketDelegate?.commandExecuted(serverResponse: .connectionFailure)
+            return
+        }
+        
+        self.socketStatus = .ready
+        self.socketDelegate?.connectionsOpened()
+    }
+    
+    public func send(rubyCommand: RubyCommandable) {
+        verbose(message: "sending: \(rubyCommand.json)")
+        send(string: rubyCommand.json)
+    }
+    
+    public func sendComplete() {
+        sendAbort()
+    }
+    
+    private func testDispatchTimeoutResult(_ timeoutResult: DispatchTimeoutResult, failureMessage: String, timeToWait: DispatchTimeInterval) -> Bool {
+        switch timeoutResult {
+        case .success:
+            return true
+        case .timedOut:
+            log(message: "Timeout: \(failureMessage)")
+            
+            if case .seconds(let seconds) = timeToWait {
+                socketDelegate?.commandExecuted(serverResponse: .commandTimeout(seconds: seconds))
+            }
+            return false
+        }
+    }
+    
+    private func stopInputSession() {
+        inputStream.close()
+    }
+    
+    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()
+        streamQueue.async {
+            let data = string.data(using: .utf8)!
+            _ = data.withUnsafeBytes { self.outputStream.write($0, maxLength: data.count) }
+        }
+
+        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() {
+        self.socketStatus = .closed
+        
+        stopInputSession()
+        
+        // and error occured, let's try to send the "done" message
+        send(string: SocketClient.doneToken)
+        
+        stopOutputSession()
+        self.socketDelegate?.connectionsClosed()
+    }
+}
+
+extension SocketClient: StreamDelegate {
+    func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
+        guard !self.cleaningUpAfterDone else {
+            // Still getting response from server eventhough we are done.
+            // No big deal, we're closing the streams anyway.
+            // That being said, we need to balance out the dispatchGroups
+            self.dispatchGroup.leave()
+            return
+        }
+        
+        if aStream === self.inputStream {
+            switch eventCode {
+            case Stream.Event.openCompleted:
+                self.dispatchGroup.leave()
+                
+            case Stream.Event.errorOccurred:
+                verbose(message: "input stream error occurred")
+                sendAbort()
+                
+            case Stream.Event.hasBytesAvailable:
+                read()
+                
+            case Stream.Event.endEncountered:
+                // nothing special here
+                break
+                
+            case Stream.Event.hasSpaceAvailable:
+                // we don't care about this
+                break
+                
+            default:
+                verbose(message: "input stream caused unrecognized event: \(eventCode)")
+            }
+            
+        } else if aStream === self.outputStream {
+            switch eventCode {
+            case Stream.Event.openCompleted:
+                self.dispatchGroup.leave()
+                
+            case Stream.Event.errorOccurred:
+                // probably safe to close all the things because Ruby already disconnected
+                verbose(message: "output stream recevied error")
+                break
+                
+            case Stream.Event.endEncountered:
+                // nothing special here
+                break
+                
+            case Stream.Event.hasSpaceAvailable:
+                // we don't care about this
+                break
+
+            default:
+                verbose(message: "output stream caused unrecognized event: \(eventCode)")
+            }
+        }
+    }
+    
+    func read() {
+        var buffer = [UInt8](repeating: 0, count: maxReadLength)
+        var output = ""
+        while self.inputStream!.hasBytesAvailable {
+            let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count)
+            if bytesRead >= 0 {
+                output += NSString(bytes: UnsafePointer(buffer), length: bytesRead, encoding: String.Encoding.utf8.rawValue)! as String
+            } else {
+                verbose(message: "Stream read() error")
+            }
+        }
+
+        processResponse(string: output)
+    }
+    
+    func handleFailure(message: [String]) {
+        log(message: "Encountered a problem: \(message.joined(separator:"\n"))")
+        sendAbort()
+    }
+    
+    func processResponse(string: String) {
+        guard string.count > 0 else {
+            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse)
+            self.handleFailure(message: ["empty response from ruby process"])
+
+            return
+        }
+        
+        let responseString = string.trimmingCharacters(in: .whitespacesAndNewlines)
+        let socketResponse = SocketResponse(payload: responseString)
+        verbose(message: "response is: \(responseString)")
+        switch socketResponse.responseType {
+        case .failure(let failureInformation):
+            self.socketDelegate?.commandExecuted(serverResponse: .serverError)
+            self.handleFailure(message: failureInformation)
+
+        case .parseFailure(let failureInformation):
+            self.socketDelegate?.commandExecuted(serverResponse: .malformedResponse)
+            self.handleFailure(message: failureInformation)
+
+        case .readyForNext(let returnedObject, let closureArgumentValue):
+            self.socketDelegate?.commandExecuted(serverResponse: .success(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue))
+            // 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]

data/fastlane/swift/SocketClientDelegateProtocol.swift

@@ -0,0 +1,19 @@
+//
+//  SocketClientDelegateProtocol.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 8/12/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+protocol SocketClientDelegateProtocol: class {
+    func connectionsOpened()
+    func connectionsClosed()
+    func commandExecuted(serverResponse: SocketClientResponse)
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/SocketResponse.swift

@@ -0,0 +1,74 @@
+//
+//  SocketResponse.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 7/30/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+struct SocketResponse {
+    enum ResponseType {
+        case parseFailure(failureInformation: [String])
+        case failure(failureInformation: [String])
+        case readyForNext(returnedObject: String?, closureArgumentValue: String?)
+        
+        init(statusDictionary: [String : Any]) {
+            guard let status = statusDictionary["status"] as? String else {
+                self = .parseFailure(failureInformation: ["Message failed to parse from Ruby server"])
+                return
+            }
+            
+            if status == "ready_for_next" {
+                let returnedObject = statusDictionary["return_object"] as? String
+                let closureArgumentValue = statusDictionary["closure_argument_value"] as? String
+                self = .readyForNext(returnedObject: returnedObject, closureArgumentValue: closureArgumentValue)
+                return
+                
+            } else if status == "failure" {
+                guard let failureInformation = statusDictionary["failure_information"] as? [String] else {
+                    self = .parseFailure(failureInformation: ["Ruby server indicated failure but Swift couldn't receive it"])
+                    return
+                }
+                
+                self = .failure(failureInformation: failureInformation)
+                return
+            }
+            self = .parseFailure(failureInformation: ["Message status: \(status) not a supported status"])
+        }
+    }
+    
+    let responseType: ResponseType
+    
+    init(payload: String) {
+        guard let data = SocketResponse.convertToDictionary(text: payload) else {
+            self.responseType = .parseFailure(failureInformation: ["Unable to parse message from Ruby server"])
+            return
+        }
+        
+        guard case let statusDictionary? = data["payload"] as? [String : Any] else {
+            self.responseType = .parseFailure(failureInformation: ["Payload missing from Ruby server response"])
+            return
+        }
+        
+        self.responseType = ResponseType(statusDictionary: statusDictionary)
+    }
+}
+
+extension SocketResponse {
+    static func convertToDictionary(text: String) -> [String : Any]? {
+        if let data = text.data(using: .utf8) {
+            do {
+                return try JSONSerialization.jsonObject(with: data, options: []) as? [String : Any]
+            } catch {
+                log(message: error.localizedDescription)
+            }
+        }
+        return nil
+    }
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/fastlane/swift/main.swift

@@ -0,0 +1,43 @@
+//
+//  main.swift
+//  FastlaneSwiftRunner
+//
+//  Created by Joshua Liebowitz on 8/26/17.
+//  Copyright © 2017 Joshua Liebowitz. All rights reserved.
+//
+
+import Foundation
+
+let argumentProcessor = ArgumentProcessor(args: CommandLine.arguments)
+let timeout = argumentProcessor.commandTimeout
+
+class MainProcess {
+    var doneRunningLane = false
+    var thread: Thread!
+    
+    @objc func connectToFastlaneAndRunLane() {
+        runner.startSocketThread()
+        
+        Fastfile.runLane(named: argumentProcessor.currentLane)
+        runner.disconnectFromFastlaneProcess()
+        
+        doneRunningLane = true
+    }
+    
+    func startFastlaneThread() {
+        thread = Thread(target: self, selector: #selector(connectToFastlaneAndRunLane), object: nil)
+        thread.name = "worker thread"
+        thread.start()
+    }
+}
+
+let process: MainProcess = MainProcess()
+process.startFastlaneThread()
+
+while (!process.doneRunningLane && (RunLoop.current.run(mode: RunLoopMode.defaultRunLoopMode, before: Date(timeIntervalSinceNow: 2)))) {
+    // no op
+}
+
+// Please don't remove the lines below
+// They are used to detect outdated files
+// FastlaneRunnerAPIVersion [0.9.1]

data/match/lib/match/encrypt.rb

@@ -93,6 +93,18 @@ module Match
       success = system(command.join(' '))
 
       UI.crash!("Error decrypting '#{path}'") unless success
+
+      # On non-Mac systems (more specific Ubuntu Linux) it might take some time for the file to actually be there (see #11182).
+      # To try to circumvent this flakyness (in tests), we wait a bit until the file appears (max 2s) (usually only 0.1 is actually waited)
+      unless FastlaneCore::Helper.is_mac?
+        count = 0
+        # sleep until file exists or 20*0.1s (=2s) passed
+        until File.exist?(tmpfile) || count == 20
+          sleep(0.1)
+          count += 1
+        end
+      end
+
       FileUtils.mv(tmpfile, path)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane
 version: !ruby/object:Gem::Version
-  version: 2.69.2
+  version: 2.69.3
 platform: ruby
 authors:
 - Felix Krause
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-13 00:00:00.000000000 Z
+date: 2017-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slack-notifier
@@ -1200,6 +1200,36 @@ files:
 - fastlane/lib/fastlane/swift_lane_manager.rb
 - fastlane/lib/fastlane/tools.rb
 - fastlane/lib/fastlane/version.rb
+- fastlane/swift/Appfile.swift
+- fastlane/swift/ArgumentProcessor.swift
+- fastlane/swift/Deliverfile.swift
+- fastlane/swift/DeliverfileProtocol.swift
+- fastlane/swift/Fastfile.swift
+- fastlane/swift/Fastlane.swift
+- fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/project.pbxproj
+- fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/project.xcworkspace/contents.xcworkspacedata
+- fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/project.xcworkspace/xcuserdata/liebowitz.xcuserdatad/UserInterfaceState.xcuserstate
+- fastlane/swift/FastlaneSwiftRunner/FastlaneSwiftRunner.xcodeproj/xcshareddata/xcschemes/FastlaneRunner.xcscheme
+- fastlane/swift/Gymfile.swift
+- fastlane/swift/GymfileProtocol.swift
+- fastlane/swift/LaneFileProtocol.swift
+- fastlane/swift/Matchfile.swift
+- fastlane/swift/MatchfileProtocol.swift
+- fastlane/swift/Precheckfile.swift
+- fastlane/swift/PrecheckfileProtocol.swift
+- fastlane/swift/RubyCommand.swift
+- fastlane/swift/Runner.swift
+- fastlane/swift/RunnerArgument.swift
+- fastlane/swift/Scanfile.swift
+- fastlane/swift/ScanfileProtocol.swift
+- fastlane/swift/Screengrabfile.swift
+- fastlane/swift/ScreengrabfileProtocol.swift
+- fastlane/swift/Snapshotfile.swift
+- fastlane/swift/SnapshotfileProtocol.swift
+- fastlane/swift/SocketClient.swift
+- fastlane/swift/SocketClientDelegateProtocol.swift
+- fastlane/swift/SocketResponse.swift
+- fastlane/swift/main.swift
 - fastlane_core/README.md
 - fastlane_core/lib/assets/XMLTemplate.xml.erb
 - fastlane_core/lib/fastlane_core.rb