Use HTTPClient for all LCP networking requests (readium#35)

Author: mickael-menu

CHANGELOG.md

@@ -14,6 +14,9 @@ All notable changes to this project will be documented in this file. Take a look
 * A new `Publication.conforms(to:)` API to identify the profile of a publication.
 * Support for the [`conformsTo` RWPM metadata](https://github.com/readium/webpub-manifest/issues/65), to identify the profile of a `Publication`.
 * Support for right-to-left PDF documents by extracting the reading progression from the `ViewerPreferences/Direction` metadata.
+* HTTP client:
+    * A new `HTTPClient.download()` API to download HTTP resources to a temporary location.
+    * `HTTPRequest` and `DefaultHTTPClient` take an optional `userAgent` property to customize the user agent. 
 
 #### Navigator
 
@@ -28,12 +31,22 @@ All notable changes to this project will be documented in this file. Take a look
 * `Publication.format` is now deprecated in favor of the new `Publication.conforms(to:)` API which is more accurate.
     * For example, replace `publication.format == .epub` with `publication.conforms(to: .epub)` before opening a publication with the `EPUBNavigatorViewController`.
 
+### Changed
+
+#### LCP
+
+* The `LCPService` now uses a provided `HTTPClient` instance for all HTTP requests.
+
 ### Fixed
 
 #### Navigator
 
 * [#14](https://github.com/readium/swift-toolkit/issues/14) Backward compatibility (iOS 10+) of JavaScript files is now handled with Babel.
 
+#### LCP
+
+* Fixed the notification of acquisition progress.
+
 
 ## 2.2.0
 

Sources/LCP/LCPAcquisition.swift

@@ -10,7 +10,7 @@ import R2Shared
 /// Represents an on-going LCP acquisition task.
 ///
 /// You can cancel the on-going download with `acquisition.cancel()`.
-public final class LCPAcquisition: Loggable {
+public final class LCPAcquisition: Loggable, Cancellable {
 
     /// Informations about an acquired publication protected with LCP.
     public struct Publication {
@@ -20,10 +20,6 @@ public final class LCPAcquisition: Loggable {
 
         /// Filename that should be used for the publication when importing it in the user library.
         public let suggestedFilename: String
-        
-        /// Download task used to fetch the publication.
-        @available(*, unavailable, message: "R2Shared.DownloadSession is deprecated")
-        public let downloadTask: URLSessionDownloadTask?
     }
 
     /// Percent-based progress of the acquisition.
@@ -36,25 +32,19 @@ public final class LCPAcquisition: Loggable {
 
     /// Cancels the acquisition.
     public func cancel() {
-        guard !isCancelled else {
-            return
-        }
-        isCancelled = true
-        downloadTask?.cancel()
+        cancellable.cancel()
         didComplete(with: .cancelled)
     }
 
-    let progress = MutableObservable<Progress>(.indefinite)
-
-    private(set) var isCancelled = false
+    let onProgress: (Progress) -> Void
+    var cancellable = MediatorCancellable()
+    
     private var isCompleted = false
     private let completion: (CancellableResult<Publication, LCPError>) -> Void
 
-    var downloadTask: URLSessionDownloadTask?
-    
     init(onProgress: @escaping (Progress) -> Void, completion: @escaping (CancellableResult<Publication, LCPError>) -> Void) {
+        self.onProgress = onProgress
         self.completion = completion
-        self.progress.observe(onProgress)
     }
 
     func didComplete(with result: CancellableResult<Publication, LCPError>) -> Void {

Sources/LCP/LCPService.swift

@@ -21,7 +21,7 @@ public final class LCPService: Loggable {
     private let licenses: LicensesService
     private let passphrases: PassphrasesRepository
 
-    public init(client: LCPClient) {
+    public init(client: LCPClient, httpClient: HTTPClient = DefaultHTTPClient()) {
         // Determine whether the embedded liblcp.a is in production mode, by attempting to open a production license.
         let isProduction: Bool = {
             guard
@@ -35,15 +35,14 @@ public final class LCPService: Loggable {
         }()
 
         let db = Database.shared
-        let network = NetworkService()
         passphrases = db.transactions
         licenses = LicensesService(
             isProduction: isProduction,
             client: client,
             licenses: db.licenses,
-            crl: CRLService(network: network),
-            device: DeviceService(repository: db.licenses, network: network),
-            network: network,
+            crl: CRLService(httpClient: httpClient),
+            device: DeviceService(repository: db.licenses, httpClient: httpClient),
+            httpClient: httpClient,
             passphrases: PassphrasesService(client: client, repository: passphrases)
         )
     }

Sources/LCP/License/LCPError+wrap.swift

@@ -10,6 +10,7 @@
 //
 
 import Foundation
+import R2Shared
 
 extension LCPError {
 
@@ -30,6 +31,10 @@ extension LCPError {
             return .parsing(error)
         }
 
+        if let error = error as? HTTPError {
+            return .network(error)
+        }
+        
         let nsError = error as NSError
         switch nsError.domain {
         case "R2LCPClient.LCPClientError":

Sources/LCP/License/License.swift

@@ -24,15 +24,15 @@ final class License: Loggable {
     private let validation: LicenseValidation
     private let licenses: LicensesRepository
     private let device: DeviceService
-    private let network: NetworkService
+    private let httpClient: HTTPClient
 
-    init(documents: ValidatedDocuments, client: LCPClient, validation: LicenseValidation, licenses: LicensesRepository, device: DeviceService, network: NetworkService) {
+    init(documents: ValidatedDocuments, client: LCPClient, validation: LicenseValidation, licenses: LicensesRepository, device: DeviceService, httpClient: HTTPClient) {
         self.documents = documents
         self.client = client
         self.validation = validation
         self.licenses = licenses
         self.device = device
-        self.network = network
+        self.httpClient = httpClient
 
         validation.observe { [weak self] result in
             if case .success(let documents) = result {
@@ -212,13 +212,9 @@ extension License: LCPLicense {
                 .flatMap {
                     // We fetch the Status Document again after the HTML interaction is done, in case it changed the
                     // License.
-                    self.network.fetch(statusURL)
-                        .tryMap { status, data in
-                            guard 100..<400 ~= status else {
-                                throw LCPError.network(nil)
-                            }
-                            return data
-                        }
+                    self.httpClient.fetch(statusURL)
+                        .map { $0.body ?? Data() }
+                        .eraseToAnyError()
                 }
         }
 
@@ -246,19 +242,20 @@ extension License: LCPLicense {
 
             return preferredEndDate()
                 .tryMap(makeRenewURL(from:))
-                .flatMap { self.network.fetch($0, method: .put) }
-                .tryMap { status, data -> Data in
-                    switch status {
-                    case 100..<400:
-                        break
-                    case 400:
-                        throw RenewError.renewFailed
-                    case 403:
-                        throw RenewError.invalidRenewalPeriod(maxRenewDate: self.maxRenewDate)
-                    default:
-                        throw RenewError.unexpectedServerError
-                    }
-                    return data
+                .flatMap {
+                    self.httpClient.fetch(HTTPRequest(url: $0, method: .put))
+                        .map { $0.body ?? Data() }
+                        .mapError { error -> RenewError in
+                            switch error.kind {
+                            case .badRequest:
+                                return .renewFailed
+                            case .forbidden:
+                                return .invalidRenewalPeriod(maxRenewDate: self.maxRenewDate)
+                            default:
+                                return .unexpectedServerError
+                            }
+                        }
+                        .eraseToAnyError()
                 }
         }
 
@@ -285,20 +282,18 @@ extension License: LCPLicense {
             return
         }
 
-        network.fetch(url, method: .put)
-            .tryMap { status, data in
-                switch status {
-                case 100..<400:
-                    break
-                case 400:
-                    throw ReturnError.returnFailed
-                case 403:
-                    throw ReturnError.alreadyReturnedOrExpired
+        httpClient.fetch(HTTPRequest(url: url, method: .put))
+            .mapError { error -> ReturnError in
+                switch error.kind {
+                case .badRequest:
+                    return .returnFailed
+                case .forbidden:
+                    return .alreadyReturnedOrExpired
                 default:
-                    throw ReturnError.unexpectedServerError
+                    return .unexpectedServerError
                 }
-                return data
             }
+            .map { $0.body ?? Data() }
             .flatMap(validateStatusDocument)
             .mapError(LCPError.wrap)
             .resolveWithError(completion)

Sources/LCP/License/LicenseValidation.swift

@@ -61,7 +61,7 @@ final class LicenseValidation: Loggable {
     fileprivate let sender: Any?
     fileprivate let crl: CRLService
     fileprivate let device: DeviceService
-    fileprivate let network: NetworkService
+    fileprivate let httpClient: HTTPClient
     fileprivate let passphrases: PassphrasesService
 
     // List of observers notified when the Documents are validated, or if an error occurred.
@@ -85,7 +85,7 @@ final class LicenseValidation: Loggable {
         client: LCPClient,
         crl: CRLService,
         device: DeviceService,
-        network: NetworkService,
+        httpClient: HTTPClient,
         passphrases: PassphrasesService,
         onLicenseValidated: @escaping (LicenseDocument) throws -> Void
     ) {
@@ -96,7 +96,7 @@ final class LicenseValidation: Loggable {
         self.client = client
         self.crl = crl
         self.device = device
-        self.network = network
+        self.httpClient = httpClient
         self.passphrases = passphrases
         self.onLicenseValidated = onLicenseValidated
     }
@@ -304,14 +304,9 @@ extension LicenseValidation {
     private func fetchStatus(of license: LicenseDocument) throws {
         let url = try license.url(for: .status, preferredType: .lcpStatusDocument)
         // Short timeout to avoid blocking the License, since the LSD is optional.
-        network.fetch(url, timeout: 5)
-            .tryMap { status, data -> Event in
-                guard 100..<400 ~= status else {
-                    throw LCPError.network(nil)
-                }
-                
-                return .retrievedStatusData(data)
-            }
+        httpClient.fetch(HTTPRequest(url: url, timeoutInterval: 5))
+            .map { .retrievedStatusData($0.body ?? Data()) }
+            .eraseToAnyError()
             .resolve(raise)
     }
 
@@ -323,13 +318,9 @@ extension LicenseValidation {
     private func fetchLicense(from status: StatusDocument) throws {
         let url = try status.url(for: .license, preferredType: .lcpLicenseDocument)
         // Short timeout to avoid blocking the License, since it can be updated next time.
-        network.fetch(url, timeout: 5)
-            .tryMap { status, data -> Event in
-                guard 100..<400 ~= status else {
-                    throw LCPError.network(nil)
-                }
-                return .retrievedLicenseData(data)
-            }
+        httpClient.fetch(HTTPRequest(url: url, timeoutInterval: 5))
+            .map { .retrievedLicenseData($0.body ?? Data()) }
+            .eraseToAnyError()
             .resolve(raise)
     }
 

Sources/LCP/Services/CRLService.swift

@@ -21,10 +21,10 @@ final class CRLService {
     private static let crlKey = "org.readium.r2-lcp-swift.CRL"
     private static let dateKey = "org.readium.r2-lcp-swift.CRLDate"
 
-    private let network: NetworkService
+    private let httpClient: HTTPClient
 
-    init(network: NetworkService) {
-        self.network = network
+    init(httpClient: HTTPClient) {
+        self.httpClient = httpClient
     }
 
     /// Retrieves the CRL either from the cache, or from EDRLab if the cache is outdated.
@@ -52,12 +52,13 @@ final class CRLService {
     private func fetch(timeout: TimeInterval? = nil) -> Deferred<String, Error> {
         let url = URL(string: "http://crl.edrlab.telesec.de/rl/EDRLab_CA.crl")!
 
-        return network.fetch(url, timeout: timeout)
-            .tryMap { status, data in
-                guard 100..<400 ~= status else {
+        return httpClient.fetch(HTTPRequest(url: url, timeoutInterval: timeout))
+            .mapError { _ in LCPError.crlFetching }
+            .tryMap {
+                guard let body = $0.body?.base64EncodedString() else {
                     throw LCPError.crlFetching
                 }
-                return "-----BEGIN X509 CRL-----\(data.base64EncodedString())-----END X509 CRL-----";
+                return "-----BEGIN X509 CRL-----\(body)-----END X509 CRL-----";
             }
 
     }

Sources/LCP/Services/DeviceService.swift

@@ -16,11 +16,11 @@ import R2Shared
 final class DeviceService {
 
     private let repository: DeviceRepository
-    private let network: NetworkService
+    private let httpClient: HTTPClient
 
-    init(repository: DeviceRepository, network: NetworkService) {
+    init(repository: DeviceRepository, httpClient: HTTPClient) {
         self.repository = repository
-        self.network = network
+        self.httpClient = httpClient
     }
 
     /// Returns the device ID, creates it if needed.
@@ -60,14 +60,14 @@ final class DeviceService {
                 throw LCPError.licenseInteractionNotAvailable
             }
 
-            return self.network.fetch(url, method: .post)
-                .tryMap { status, data in
-                    guard 100..<400 ~= status else {
+            return self.httpClient.fetch(HTTPRequest(url: url, method: .post))
+                .tryMap { response in
+                    guard 100..<400 ~= response.statusCode else {
                         return nil
                     }
 
                     try self.repository.registerDevice(for: license)
-                    return data
+                    return response.body
                 }
         }
     }