Prioritizes app refresh order

Tries to refresh apps that are about to expire first, and then always refreshes AltStore itself last, since refreshing AltStore means that the app will quit.

AltStore/Operations/AppOperationContext.swift

@@ -0,0 +1,35 @@
+//
+//  Contexts.swift
+//  AltStore
+//
+//  Created by Riley Testut on 6/20/19.
+//  Copyright © 2019 Riley Testut. All rights reserved.
+//
+
+import Foundation
+import CoreData
+import Network
+
+class AppOperationContext
+{
+    var appIdentifier: String
+    var group: OperationGroup
+        
+    var installedApp: InstalledApp? {
+        didSet {
+            self.installedAppContext = self.installedApp?.managedObjectContext
+        }
+    }
+    private var installedAppContext: NSManagedObjectContext?
+    
+    var resignedFileURL: URL?
+    var connection: NWConnection?
+    
+    var error: Error?
+    
+    init(appIdentifier: String, group: OperationGroup)
+    {
+        self.appIdentifier = appIdentifier
+        self.group = group
+    }
+}

AltStore/Operations/DownloadAppOperation.swift

@@ -19,16 +19,18 @@ class DownloadAppOperation: ResultOperation<InstalledApp>
     var useCachedAppIfAvailable = false
     lazy var context = DatabaseManager.shared.persistentContainer.newBackgroundContext()
     
-    private let downloadURL: URL
-    private let ipaURL: URL
+    private let appIdentifier: String
+    private let sourceURL: URL
+    private let destinationURL: URL
     
     private let session = URLSession(configuration: .default)
     
     init(app: App)
     {
         self.app = app
-        self.downloadURL = app.downloadURL
-        self.ipaURL = InstalledApp.ipaURL(for: app)
+        self.appIdentifier = app.identifier
+        self.sourceURL = app.downloadURL
+        self.destinationURL = InstalledApp.fileURL(for: app)
         
         super.init()
         
@@ -39,14 +41,36 @@ class DownloadAppOperation: ResultOperation<InstalledApp>
     {
         super.main()
         
-        func finish(error: Error?)
+        print("Downloading App:", self.appIdentifier)
+        
+        func finishOperation(_ result: Result<URL, Error>)
         {
-            if let error = error
-            {
-                self.finish(.failure(error))
-            }
-            else
+            do
             {
+                let fileURL = try result.get()
+                
+                var isDirectory: ObjCBool = false
+                guard FileManager.default.fileExists(atPath: fileURL.path, isDirectory: &isDirectory) else { throw OperationError.appNotFound }
+                
+                if isDirectory.boolValue
+                {
+                    // Directory, so assuming this is .app bundle.
+                    guard Bundle(url: fileURL) != nil else { throw OperationError.invalidApp }
+                    
+                    try FileManager.default.copyItem(at: fileURL, to: self.destinationURL, shouldReplace: true)
+                }
+                else
+                {
+                    // File, so assuming this is a .ipa file.
+                    
+                    let temporaryDirectory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+                    try FileManager.default.createDirectory(at: temporaryDirectory, withIntermediateDirectories: true, attributes: nil)
+                    defer { try? FileManager.default.removeItem(at: temporaryDirectory) }
+                    
+                    let bundleURL = try FileManager.default.unzipAppBundle(at: fileURL, toDirectory: temporaryDirectory)
+                    try FileManager.default.copyItem(at: bundleURL, to: self.destinationURL, shouldReplace: true)
+                }
+                
                 self.context.perform {
                     let app = self.context.object(with: self.app.objectID) as! App
                     
@@ -59,40 +83,41 @@ class DownloadAppOperation: ResultOperation<InstalledApp>
                     }
                     else
                     {
-                        installedApp = InstalledApp(app: app,
-                                                    bundleIdentifier: app.identifier,
-                                                    expirationDate: Date(),
-                                                    context: self.context)
+                        installedApp = InstalledApp(app: app, bundleIdentifier: app.identifier, context: self.context)
                     }
                     
                     installedApp.version = app.version
                     self.finish(.success(installedApp))
                 }
             }
+            catch
+            {
+                self.finish(.failure(error))
+            }
         }
         
-        if self.useCachedAppIfAvailable && FileManager.default.fileExists(atPath: self.ipaURL.path)
+        if self.sourceURL.isFileURL
         {
-            finish(error: nil)
-            return
+            finishOperation(.success(self.sourceURL))
+            
+            self.progress.completedUnitCount += 1
         }
-        
-        let downloadTask = self.session.downloadTask(with: self.downloadURL) { (fileURL, response, error) in
-            do
-            {
-                let (fileURL, _) = try Result((fileURL, response), error).get()
-                
-                try FileManager.default.copyItem(at: fileURL, to: self.ipaURL, shouldReplace: true)
-                
-                finish(error: nil)
-            }
-            catch let error
-            {
-                finish(error: error)
+        else
+        {
+            let downloadTask = self.session.downloadTask(with: self.sourceURL) { (fileURL, response, error) in
+                do
+                {
+                    let (fileURL, _) = try Result((fileURL, response), error).get()
+                    finishOperation(.success(fileURL))
+                }
+                catch
+                {
+                    finishOperation(.failure(error))
+                }
             }
+            self.progress.addChild(downloadTask.progress, withPendingUnitCount: 1)
+            
+            downloadTask.resume()
         }
-        
-        self.progress.addChild(downloadTask.progress, withPendingUnitCount: 1)
-        downloadTask.resume()
     }
 }

AltStore/Operations/InstallAppOperation.swift

@@ -2,7 +2,7 @@
 //  InstallAppOperation.swift
 //  AltStore
 //
-//  Created by Riley Testut on 6/7/19.
+//  Created by Riley Testut on 6/19/19.
 //  Copyright © 2019 Riley Testut. All rights reserved.
 //
 
@@ -10,277 +10,83 @@ import Foundation
 import Network
 
 import AltKit
-
-extension ALTServerError
-{
-    init<E: Error>(_ error: E)
-    {
-        switch error
-        {
-        case let error as ALTServerError: self = error
-        case is DecodingError: self = ALTServerError(.invalidResponse)
-        case is EncodingError: self = ALTServerError(.invalidRequest)
-        default:
-            assertionFailure("Caught unknown error type")
-            self = ALTServerError(.unknown)
-        }
-    }
-}
-
-enum InstallationError: LocalizedError
-{
-    case serverNotFound
-    case connectionFailed
-    case connectionDropped
-    case invalidApp
-    
-    var errorDescription: String? {
-        switch self
-        {
-        case .serverNotFound: return NSLocalizedString("Could not find AltServer.", comment: "")
-        case .connectionFailed: return NSLocalizedString("Could not connect to AltServer.", comment: "")
-        case .connectionDropped: return NSLocalizedString("The connection to AltServer was dropped.", comment: "")
-        case .invalidApp: return NSLocalizedString("The app is invalid.", comment: "")
-        }
-    }
-}
+import Roxas
 
 @objc(InstallAppOperation)
 class InstallAppOperation: ResultOperation<Void>
 {
-    var fileURL: URL?
+    let context: AppOperationContext
     
-    private let dispatchQueue = DispatchQueue(label: "com.altstore.InstallAppOperation")
-    
-    private var connection: NWConnection?
-    
-    override init()
+    init(context: AppOperationContext)
     {
+        self.context = context
+        
         super.init()
         
-        self.progress.totalUnitCount = 4
+        self.progress.totalUnitCount = 100
     }
     
     override func main()
     {
         super.main()
         
-        guard let fileURL = self.fileURL else { return self.finish(.failure(OperationError.appNotFound)) }
+        if let error = self.context.error
+        {
+            self.finish(.failure(error))
+            return
+        }
         
-        // Connect to server.
-        self.connect { (result) in
+        guard
+            let installedApp = self.context.installedApp,
+            let connection = self.context.connection,
+            let server = self.context.group.server
+        else { return self.finish(.failure(OperationError.invalidParameters)) }
+        
+        installedApp.managedObjectContext?.perform {
+            print("Installing app:", installedApp.app.identifier)
+            self.context.group.beginInstallationHandler?(installedApp)
+        }
+        
+        let request = BeginInstallationRequest()
+        server.send(request, via: connection) { (result) in
             switch result
             {
             case .failure(let error): self.finish(.failure(error))
-            case .success(let connection):
-                self.connection = connection
+            case .success:
                 
-                // Send app to server.
-                self.sendApp(at: fileURL, via: connection) { (result) in
-                    switch result
-                    {
-                    case .failure(let error): self.finish(.failure(error))
-                    case .success:
-                        self.progress.completedUnitCount += 1
-                        
-                        // Receive response from server.
-                        let progress = self.receiveResponse(from: connection) { (result) in
-                            switch result
-                            {
-                            case .failure(let error): self.finish(.failure(error))
-                            case .success: self.finish(.success(()))
-                            }
-                        }
-                        
-                        self.progress.addChild(progress, withPendingUnitCount: 3)
-                    }
+                self.receive(from: connection, server: server) { (result) in
+                    self.finish(result)
                 }
             }
         }
     }
     
-    override func finish(_ result: Result<Void, Error>)
+    func receive(from connection: NWConnection, server: Server, completionHandler: @escaping (Result<Void, Error>) -> Void)
     {
-        super.finish(result)
-        
-        if let connection = self.connection
-        {
-            connection.cancel()
-        }
-    }
-}
-
-private extension InstallAppOperation
-{
-    func connect(completionHandler: @escaping (Result<NWConnection, Error>) -> Void)
-    {
-        guard let server = ServerManager.shared.discoveredServers.first else { return completionHandler(.failure(InstallationError.serverNotFound)) }
-        
-        let connection = NWConnection(to: .service(name: server.service.name, type: server.service.type, domain: server.service.domain, interface: nil), using: .tcp)
-        
-        connection.stateUpdateHandler = { [unowned connection] (state) in
-            switch state
+        server.receive(ServerResponse.self, from: connection) { (result) in
+            do
             {
-            case .failed(let error):
-                print("Failed to connect to service \(server.service.name).", error)
-                completionHandler(.failure(InstallationError.connectionFailed))
-               
-            case .cancelled:
-                completionHandler(.failure(OperationError.cancelled))
+                let response = try result.get()
+                print(response)
                 
-            case .ready:
-                completionHandler(.success(connection))
-            
-            case .waiting: break
-            case .setup: break
-            case .preparing: break
-            @unknown default: break
-            }
-        }
-        
-        connection.start(queue: self.dispatchQueue)
-    }
-    
-    func sendApp(at fileURL: URL, via connection: NWConnection, completionHandler: @escaping (Result<Void, Error>) -> Void)
-    {
-        do
-        {
-            guard let appData = try? Data(contentsOf: fileURL) else { throw InstallationError.invalidApp }
-            guard let udid = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.deviceID) as? String else { throw OperationError.unknownUDID }
-            
-            let request = ServerRequest(udid: udid, contentSize: appData.count)
-            let requestData: Data
-                
-            do {
-                requestData = try JSONEncoder().encode(request)
-            }
-            catch {
-                print("Invalid request.", error)
-                throw ALTServerError(.invalidRequest)
-            }
-            
-            let requestSize = Int32(requestData.count)
-            let requestSizeData = withUnsafeBytes(of: requestSize) { Data($0) }
-            
-            func process(_ error: Error?) -> Bool
-            {
-                if error != nil
+                if let error = response.error
                 {
-                    completionHandler(.failure(InstallationError.connectionDropped))
-                    return false
+                    self.finish(.failure(error))
+                }
+                else if response.progress == 1.0
+                {
+                    self.finish(.success(()))
                 }
                 else
                 {
-                    return true
+                    self.progress.completedUnitCount = Int64(response.progress * 100)
+                    self.receive(from: connection, server: server, completionHandler: completionHandler)
                 }
             }
-            
-            // Send request data size.
-            print("Sending request data size \(requestSize)")
-            connection.send(content: requestSizeData, completion: .contentProcessed { (error) in
-                guard process(error) else { return }
-                
-                // Send request.
-                print("Sending request \(request)")
-                connection.send(content: requestData, completion: .contentProcessed { (error) in
-                    guard process(error) else { return }
-                    
-                    // Send app data.
-                    print("Sending app data (Size: \(appData.count))")
-                    connection.send(content: appData, completion: .contentProcessed { (error) in
-                        print("Sent app data!")
-                        
-                        guard process(error) else { return }
-                        completionHandler(.success(()))
-                    })
-                })
-            })
-        }
-        catch
-        {
-            completionHandler(.failure(error))
-        }
-    }
-    
-    func receiveResponse(from connection: NWConnection, completionHandler: @escaping (Result<Void, Error>) -> Void) -> Progress
-    {
-        func receive(from connection: NWConnection, progress: Progress, completionHandler: @escaping (Result<Void, Error>) -> Void)
-        {
-            let size = MemoryLayout<Int32>.size
-            
-            connection.receive(minimumIncompleteLength: size, maximumLength: size) { (data, _, _, error) in
-                do
-                {
-                    let data = try self.process(data: data, error: error, from: connection)
-                    
-                    let expectedBytes = Int(data.withUnsafeBytes { $0.load(as: Int32.self) })
-                    connection.receive(minimumIncompleteLength: expectedBytes, maximumLength: expectedBytes) { (data, _, _, error) in
-                        do
-                        {
-                            let data = try self.process(data: data, error: error, from: connection)
-                            
-                            let response = try JSONDecoder().decode(ServerResponse.self, from: data)
-                            print(response)
-                            
-                            if let error = response.error
-                            {
-                                completionHandler(.failure(error))
-                            }
-                            else if response.progress == 1.0
-                            {
-                                completionHandler(.success(()))
-                            }
-                            else
-                            {
-                                progress.completedUnitCount = Int64(response.progress * 100)
-                                receive(from: connection, progress: progress, completionHandler: completionHandler)
-                            }
-                        }
-                        catch
-                        {
-                            completionHandler(.failure(ALTServerError(error)))
-                        }
-                    }
-                }
-                catch
-                {
-                    completionHandler(.failure(ALTServerError(error)))
-                }
-            }
-        }
-        
-        let progress = Progress.discreteProgress(totalUnitCount: 100)
-        receive(from: connection, progress: progress, completionHandler: completionHandler)
-        return progress
-    }
-    
-    func process(data: Data?, error: NWError?, from connection: NWConnection) throws -> Data
-    {
-        do
-        {
-            do
-            {
-                guard let data = data else { throw error ?? ALTServerError(.unknown) }
-                return data
-            }
-            catch let error as NWError
-            {
-                print("Error receiving data from connection \(connection)", error)
-                
-                throw ALTServerError(.lostConnection)
-            }
             catch
             {
-                throw error
+                completionHandler(.failure(ALTServerError(error)))
             }
         }
-        catch let error as ALTServerError
-        {
-            throw error
-        }
-        catch
-        {
-            preconditionFailure("A non-ALTServerError should never be thrown from this method.")
-        }
     }
 }

AltStore/Operations/Operation.swift

@@ -23,9 +23,9 @@ class ResultOperation<ResultType>: Operation
     {
         guard !self.isFinished else { return }
         
-        super.finish()
-        
         self.resultHandler?(result)
+        
+        super.finish()
     }
 }
 
@@ -73,6 +73,8 @@ class Operation: RSTOperation, ProgressReporting
     
     override func finish()
     {
+        guard !self.isFinished else { return }
+        
         super.finish()
         
         if let backgroundTaskID = self.backgroundTaskID

AltStore/Operations/OperationError.swift

@@ -19,6 +19,9 @@ enum OperationError: LocalizedError
     
     case unknownUDID
     
+    case invalidApp
+    case invalidParameters
+    
     var errorDescription: String? {
         switch self {
         case .unknown: return NSLocalizedString("An unknown error occured.", comment: "")
@@ -27,6 +30,8 @@ enum OperationError: LocalizedError
         case .notAuthenticated: return NSLocalizedString("You are not signed in.", comment: "")
         case .appNotFound: return NSLocalizedString("App not found.", comment: "")
         case .unknownUDID: return NSLocalizedString("Unknown device UDID.", comment: "")
+        case .invalidApp: return NSLocalizedString("The app is invalid.", comment: "")
+        case .invalidParameters: return NSLocalizedString("Invalid parameters.", comment: "")
         }
     }
 }

AltStore/Operations/OperationGroup.swift

@@ -0,0 +1,63 @@
+//
+//  OperationGroup.swift
+//  AltStore
+//
+//  Created by Riley Testut on 6/20/19.
+//  Copyright © 2019 Riley Testut. All rights reserved.
+//
+
+import Foundation
+import CoreData
+
+import AltSign
+
+class OperationGroup
+{
+    let progress = Progress.discreteProgress(totalUnitCount: 0)
+    
+    var completionHandler: ((Result<[String: Result<InstalledApp, Error>], Error>) -> Void)?
+    var beginInstallationHandler: ((InstalledApp) -> Void)?
+    
+    var server: Server?
+    var signer: ALTSigner?
+    
+    var error: Error?
+    
+    var results = [String: Result<InstalledApp, Error>]()
+    
+    private let operationQueue = OperationQueue()
+    private let installOperationQueue = OperationQueue()
+    
+    init()
+    {
+        // Enforce only one installation at a time.
+        self.installOperationQueue.maxConcurrentOperationCount = 1
+    }
+    
+    func cancel()
+    {
+        self.operationQueue.cancelAllOperations()
+        self.installOperationQueue.cancelAllOperations()
+    }
+    
+    func addOperations(_ operations: [Operation])
+    {
+        for operation in operations
+        {
+            if let installOperation = operation as? InstallAppOperation
+            {
+                if let previousOperation = self.installOperationQueue.operations.last
+                {
+                    // Ensures they execute in the order they're added, since isReady is still false at this point.
+                    installOperation.addDependency(previousOperation)
+                }
+                
+                self.installOperationQueue.addOperation(installOperation)
+            }
+            else
+            {
+                self.operationQueue.addOperation(operation)
+            }
+        }
+    }
+}

AltStore/Operations/ResignAppOperation.swift

@@ -14,15 +14,13 @@ import AltSign
 @objc(ResignAppOperation)
 class ResignAppOperation: ResultOperation<URL>
 {
-    let installedApp: InstalledApp
-    private var context: NSManagedObjectContext?
+    let context: AppOperationContext
     
-    var signer: ALTSigner?
+    private let temporaryDirectory: URL = FileManager.default.uniqueTemporaryURL()
     
-    init(installedApp: InstalledApp)
+    init(context: AppOperationContext)
     {
-        self.installedApp = installedApp
-        self.context = installedApp.managedObjectContext
+        self.context = context
         
         super.init()
         
@@ -33,17 +31,38 @@ class ResignAppOperation: ResultOperation<URL>
     {
         super.main()
         
-        guard let context = self.context else { return self.finish(.failure(OperationError.appNotFound)) }
-        guard let signer = self.signer else { return self.finish(.failure(OperationError.notAuthenticated)) }
+        do
+        {
+            try FileManager.default.createDirectory(at: self.temporaryDirectory, withIntermediateDirectories: true, attributes: nil)
+        }
+        catch
+        {
+            self.finish(.failure(error))
+            return
+        }
         
-        context.perform {
+        if let error = self.context.error
+        {
+            self.finish(.failure(error))
+            return
+        }
+        
+        guard
+            let installedApp = self.context.installedApp,
+            let appContext = installedApp.managedObjectContext,
+            let signer = self.context.group.signer
+        else { return self.finish(.failure(OperationError.invalidParameters)) }
+        
+        appContext.perform {
+            let appIdentifier = installedApp.app.identifier
+            
             // Register Device
             self.registerCurrentDevice(for: signer.team) { (result) in
                 guard let _ = self.process(result) else { return }
                 
                 // Register App
-                context.perform {
-                    self.register(self.installedApp.app, team: signer.team) { (result) in
+                appContext.perform {
+                    self.register(installedApp.app, team: signer.team) { (result) in
                         guard let appID = self.process(result) else { return }
                         
                         // Fetch Provisioning Profile
@@ -51,27 +70,29 @@ class ResignAppOperation: ResultOperation<URL>
                             guard let profile = self.process(result) else { return }
                             
                             // Prepare app bundle
-                            context.perform {
+                            appContext.perform {
                                 let prepareAppProgress = Progress.discreteProgress(totalUnitCount: 2)
                                 self.progress.addChild(prepareAppProgress, withPendingUnitCount: 3)
                                 
-                                let prepareAppBundleProgress = self.prepareAppBundle(for: self.installedApp) { (result) in
+                                let prepareAppBundleProgress = self.prepareAppBundle(for: installedApp) { (result) in
                                     guard let appBundleURL = self.process(result) else { return }
                                     
+                                    print("Resigning App:", appIdentifier)
+                                    
                                     // Resign app bundle
                                     let resignProgress = self.resignAppBundle(at: appBundleURL, signer: signer, profile: profile) { (result) in
                                         guard let resignedURL = self.process(result) else { return }
                                         
                                         // Finish
-                                        context.perform {
+                                        appContext.perform {
                                             do
                                             {
-                                                try FileManager.default.copyItem(at: resignedURL, to: self.installedApp.refreshedIPAURL, shouldReplace: true)
+                                                installedApp.expirationDate = profile.expirationDate
+                                                installedApp.refreshedDate = Date()
                                                 
-                                                let refreshedDirectory = resignedURL.deletingLastPathComponent()
-                                                try? FileManager.default.removeItem(at: refreshedDirectory)
+                                                try FileManager.default.copyItem(at: resignedURL, to: installedApp.refreshedIPAURL, shouldReplace: true)
                                                 
-                                                self.finish(.success(self.installedApp.refreshedIPAURL))
+                                                self.finish(.success(installedApp.refreshedIPAURL))
                                             }
                                             catch
                                             {
@@ -107,6 +128,17 @@ class ResignAppOperation: ResultOperation<URL>
             return value
         }
     }
+    
+    override func finish(_ result: Result<URL, Error>)
+    {
+        super.finish(result)
+                
+        if FileManager.default.fileExists(atPath: self.temporaryDirectory.path, isDirectory: nil)
+        {
+            do { try FileManager.default.removeItem(at: self.temporaryDirectory) }
+            catch { print("Failed to remove app bundle.", error) }
+        }
+    }
 }
 
 private extension ResignAppOperation
@@ -179,25 +211,21 @@ private extension ResignAppOperation
     {
         let progress = Progress.discreteProgress(totalUnitCount: 1)
         
-        let refreshedAppDirectory = installedApp.directoryURL.appendingPathComponent("Refreshed", isDirectory: true)
-        let ipaURL = installedApp.ipaURL
         let bundleIdentifier = installedApp.bundleIdentifier
         let openURL = installedApp.openAppURL
         let appIdentifier = installedApp.app.identifier
         
+        let fileURL = installedApp.fileURL
+        
         DispatchQueue.global().async {
             do
             {
-                if FileManager.default.fileExists(atPath: refreshedAppDirectory.path)
-                {
-                    try FileManager.default.removeItem(at: refreshedAppDirectory)
-                }
-                try FileManager.default.createDirectory(at: refreshedAppDirectory, withIntermediateDirectories: true, attributes: nil)
+                let appBundleURL = self.temporaryDirectory.appendingPathComponent("App.app")
+                try FileManager.default.copyItem(at: fileURL, to: appBundleURL)
                 
                 // Become current so we can observe progress from unzipAppBundle().
                 progress.becomeCurrent(withPendingUnitCount: 1)
                 
-                let appBundleURL = try FileManager.default.unzipAppBundle(at: ipaURL, toDirectory: refreshedAppDirectory)
                 guard let bundle = Bundle(url: appBundleURL) else { throw ALTError(.missingAppBundle) }
                 
                 guard var infoDictionary = NSDictionary(contentsOf: bundle.infoPlistURL) as? [String: Any] else { throw ALTError(.missingInfoPlist) }

AltStore/Operations/SendAppOperation.swift

@@ -0,0 +1,128 @@
+//
+//  SendAppOperation.swift
+//  AltStore
+//
+//  Created by Riley Testut on 6/7/19.
+//  Copyright © 2019 Riley Testut. All rights reserved.
+//
+
+import Foundation
+import Network
+
+import AltKit
+
+@objc(SendAppOperation)
+class SendAppOperation: ResultOperation<NWConnection>
+{
+    let context: AppOperationContext
+    
+    private let dispatchQueue = DispatchQueue(label: "com.altstore.SendAppOperation")
+    
+    private var connection: NWConnection?
+    
+    init(context: AppOperationContext)
+    {
+        self.context = context
+        
+        super.init()
+        
+        self.progress.totalUnitCount = 1
+    }
+    
+    override func main()
+    {
+        super.main()
+        
+        if let error = self.context.error
+        {
+            self.finish(.failure(error))
+            return
+        }
+        
+        guard let fileURL = self.context.resignedFileURL, let server = self.context.group.server else { return self.finish(.failure(OperationError.invalidParameters)) }
+        
+        // Connect to server.
+        self.connect(to: server) { (result) in
+            switch result
+            {
+            case .failure(let error): self.finish(.failure(error))
+            case .success(let connection):
+                self.connection = connection
+                
+                // Send app to server.
+                self.sendApp(at: fileURL, via: connection, server: server) { (result) in
+                    switch result
+                    {
+                    case .failure(let error): self.finish(.failure(error))
+                    case .success:
+                        self.progress.completedUnitCount += 1
+                        self.finish(.success(connection))
+                    }
+                }
+            }
+        }
+    }
+}
+
+private extension SendAppOperation
+{
+    func connect(to server: Server, completionHandler: @escaping (Result<NWConnection, Error>) -> Void)
+    {
+        let connection = NWConnection(to: .service(name: server.service.name, type: server.service.type, domain: server.service.domain, interface: nil), using: .tcp)
+        
+        connection.stateUpdateHandler = { [unowned connection] (state) in
+            switch state
+            {
+            case .failed(let error):
+                print("Failed to connect to service \(server.service.name).", error)
+                completionHandler(.failure(ConnectionError.connectionFailed))
+               
+            case .cancelled:
+                completionHandler(.failure(OperationError.cancelled))
+                
+            case .ready:
+                completionHandler(.success(connection))
+            
+            case .waiting: break
+            case .setup: break
+            case .preparing: break
+            @unknown default: break
+            }
+        }
+        
+        connection.start(queue: self.dispatchQueue)
+    }
+    
+    func sendApp(at fileURL: URL, via connection: NWConnection, server: Server, completionHandler: @escaping (Result<Void, Error>) -> Void)
+    {
+        do
+        {
+            guard let appData = try? Data(contentsOf: fileURL) else { throw OperationError.invalidApp }
+            guard let udid = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.deviceID) as? String else { throw OperationError.unknownUDID }
+            
+            let request = PrepareAppRequest(udid: udid, contentSize: appData.count)
+            
+            print("Sending request \(request)")
+            server.send(request, via: connection) { (result) in
+                switch result
+                {
+                case .failure(let error): completionHandler(.failure(error))
+                case .success:
+                    
+                    print("Sending app data (\(appData.count) bytes)")
+                    server.send(appData, via: connection, prependSize: false) { (result) in
+                        switch result
+                        {
+                        case .failure(let error): completionHandler(.failure(error))
+                        case .success: completionHandler(.success(()))
+                        }
+                    }
+                }
+            }
+        }
+        catch
+        {
+            completionHandler(.failure(error))
+        }
+    }
+}