Update for swift 3.
- Convert code to swift 3 - Update alamofire to 4.0.1 for swift 3.
This commit is contained in:
Charlie Qiu
870
Pods/Alamofire/Source/Request.swift
generated
870
Pods/Alamofire/Source/Request.swift
generated
@ -24,490 +24,271 @@
|
||||
|
||||
import Foundation
|
||||
|
||||
/**
|
||||
Responsible for sending a request and receiving the response and associated data from the server, as well as
|
||||
managing its underlying `NSURLSessionTask`.
|
||||
*/
|
||||
public class Request {
|
||||
/// A type that can inspect and optionally adapt a `URLRequest` in some manner if necessary.
|
||||
public protocol RequestAdapter {
|
||||
/// Inspects and adapts the specified `URLRequest` in some manner if necessary and returns the result.
|
||||
///
|
||||
/// - parameter urlRequest: The URL request to adapt.
|
||||
///
|
||||
/// - throws: An `Error` if the adaptation encounters an error.
|
||||
///
|
||||
/// - returns: The adapted `URLRequest`.
|
||||
func adapt(_ urlRequest: URLRequest) throws -> URLRequest
|
||||
}
|
||||
|
||||
// MARK: - Properties
|
||||
// MARK: -
|
||||
|
||||
/// A closure executed when the `RequestRetrier` determines whether a `Request` should be retried or not.
|
||||
public typealias RequestRetryCompletion = (_ shouldRetry: Bool, _ timeDelay: TimeInterval) -> Void
|
||||
|
||||
/// A type that determines whether a request should be retried after being executed by the specified session manager
|
||||
/// and encountering an error.
|
||||
public protocol RequestRetrier {
|
||||
/// Determines whether the `Request` should be retried by calling the `completion` closure.
|
||||
///
|
||||
/// This operation is fully asychronous. Any amount of time can be taken to determine whether the request needs
|
||||
/// to be retried. The one requirement is that the completion closure is called to ensure the request is properly
|
||||
/// cleaned up after.
|
||||
///
|
||||
/// - parameter manager: The session manager the request was executed on.
|
||||
/// - parameter request: The request that failed due to the encountered error.
|
||||
/// - parameter error: The error encountered when executing the request.
|
||||
/// - parameter completion: The completion closure to be executed when retry decision has been determined.
|
||||
func should(_ manager: SessionManager, retry request: Request, with error: Error, completion: @escaping RequestRetryCompletion)
|
||||
}
|
||||
|
||||
// MARK: -
|
||||
|
||||
protocol TaskConvertible {
|
||||
func task(session: URLSession, adapter: RequestAdapter?, queue: DispatchQueue) throws -> URLSessionTask
|
||||
}
|
||||
|
||||
/// A dictionary of headers to apply to a `URLRequest`.
|
||||
public typealias HTTPHeaders = [String: String]
|
||||
|
||||
// MARK: -
|
||||
|
||||
/// Responsible for sending a request and receiving the response and associated data from the server, as well as
|
||||
/// managing its underlying `URLSessionTask`.
|
||||
open class Request {
|
||||
|
||||
// MARK: Helper Types
|
||||
|
||||
/// A closure executed when monitoring upload or download progress of a request.
|
||||
public typealias ProgressHandler = (Progress) -> Void
|
||||
|
||||
enum RequestTask {
|
||||
case data(TaskConvertible?, URLSessionTask?)
|
||||
case download(TaskConvertible?, URLSessionTask?)
|
||||
case upload(TaskConvertible?, URLSessionTask?)
|
||||
case stream(TaskConvertible?, URLSessionTask?)
|
||||
}
|
||||
|
||||
// MARK: Properties
|
||||
|
||||
/// The delegate for the underlying task.
|
||||
public let delegate: TaskDelegate
|
||||
open internal(set) var delegate: TaskDelegate {
|
||||
get {
|
||||
taskDelegateLock.lock() ; defer { taskDelegateLock.unlock() }
|
||||
return taskDelegate
|
||||
}
|
||||
set {
|
||||
taskDelegateLock.lock() ; defer { taskDelegateLock.unlock() }
|
||||
taskDelegate = newValue
|
||||
}
|
||||
}
|
||||
|
||||
/// The underlying task.
|
||||
public var task: NSURLSessionTask { return delegate.task }
|
||||
open var task: URLSessionTask? { return delegate.task }
|
||||
|
||||
/// The session belonging to the underlying task.
|
||||
public let session: NSURLSession
|
||||
open let session: URLSession
|
||||
|
||||
/// The request sent or to be sent to the server.
|
||||
public var request: NSURLRequest? { return task.originalRequest }
|
||||
open var request: URLRequest? { return task?.originalRequest }
|
||||
|
||||
/// The response received from the server, if any.
|
||||
public var response: NSHTTPURLResponse? { return task.response as? NSHTTPURLResponse }
|
||||
open var response: HTTPURLResponse? { return task?.response as? HTTPURLResponse }
|
||||
|
||||
/// The progress of the request lifecycle.
|
||||
public var progress: NSProgress { return delegate.progress }
|
||||
let originalTask: TaskConvertible?
|
||||
|
||||
var startTime: CFAbsoluteTime?
|
||||
var endTime: CFAbsoluteTime?
|
||||
|
||||
// MARK: - Lifecycle
|
||||
var validations: [() -> Void] = []
|
||||
|
||||
init(session: NSURLSession, task: NSURLSessionTask) {
|
||||
private var taskDelegate: TaskDelegate
|
||||
private var taskDelegateLock = NSLock()
|
||||
|
||||
// MARK: Lifecycle
|
||||
|
||||
init(session: URLSession, requestTask: RequestTask, error: Error? = nil) {
|
||||
self.session = session
|
||||
|
||||
switch task {
|
||||
case is NSURLSessionUploadTask:
|
||||
delegate = UploadTaskDelegate(task: task)
|
||||
case is NSURLSessionDataTask:
|
||||
delegate = DataTaskDelegate(task: task)
|
||||
case is NSURLSessionDownloadTask:
|
||||
delegate = DownloadTaskDelegate(task: task)
|
||||
default:
|
||||
delegate = TaskDelegate(task: task)
|
||||
switch requestTask {
|
||||
case .data(let originalTask, let task):
|
||||
taskDelegate = DataTaskDelegate(task: task)
|
||||
self.originalTask = originalTask
|
||||
case .download(let originalTask, let task):
|
||||
taskDelegate = DownloadTaskDelegate(task: task)
|
||||
self.originalTask = originalTask
|
||||
case .upload(let originalTask, let task):
|
||||
taskDelegate = UploadTaskDelegate(task: task)
|
||||
self.originalTask = originalTask
|
||||
case .stream(let originalTask, let task):
|
||||
taskDelegate = TaskDelegate(task: task)
|
||||
self.originalTask = originalTask
|
||||
}
|
||||
|
||||
delegate.queue.addOperationWithBlock { self.endTime = CFAbsoluteTimeGetCurrent() }
|
||||
delegate.error = error
|
||||
delegate.queue.addOperation { self.endTime = CFAbsoluteTimeGetCurrent() }
|
||||
}
|
||||
|
||||
// MARK: - Authentication
|
||||
// MARK: Authentication
|
||||
|
||||
/**
|
||||
Associates an HTTP Basic credential with the request.
|
||||
|
||||
- parameter user: The user.
|
||||
- parameter password: The password.
|
||||
- parameter persistence: The URL credential persistence. `.ForSession` by default.
|
||||
|
||||
- returns: The request.
|
||||
*/
|
||||
public func authenticate(
|
||||
user user: String,
|
||||
/// Associates an HTTP Basic credential with the request.
|
||||
///
|
||||
/// - parameter user: The user.
|
||||
/// - parameter password: The password.
|
||||
/// - parameter persistence: The URL credential persistence. `.ForSession` by default.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func authenticate(
|
||||
user: String,
|
||||
password: String,
|
||||
persistence: NSURLCredentialPersistence = .ForSession)
|
||||
persistence: URLCredential.Persistence = .forSession)
|
||||
-> Self
|
||||
{
|
||||
let credential = NSURLCredential(user: user, password: password, persistence: persistence)
|
||||
|
||||
let credential = URLCredential(user: user, password: password, persistence: persistence)
|
||||
return authenticate(usingCredential: credential)
|
||||
}
|
||||
|
||||
/**
|
||||
Associates a specified credential with the request.
|
||||
|
||||
- parameter credential: The credential.
|
||||
|
||||
- returns: The request.
|
||||
*/
|
||||
public func authenticate(usingCredential credential: NSURLCredential) -> Self {
|
||||
/// Associates a specified credential with the request.
|
||||
///
|
||||
/// - parameter credential: The credential.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func authenticate(usingCredential credential: URLCredential) -> Self {
|
||||
delegate.credential = credential
|
||||
|
||||
return self
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a base64 encoded basic authentication credential as an authorization header dictionary.
|
||||
/// Returns a base64 encoded basic authentication credential as an authorization header tuple.
|
||||
///
|
||||
/// - parameter user: The user.
|
||||
/// - parameter password: The password.
|
||||
///
|
||||
/// - returns: A tuple with Authorization header and credential value if encoding succeeds, `nil` otherwise.
|
||||
open static func authorizationHeader(user: String, password: String) -> (key: String, value: String)? {
|
||||
guard let data = "\(user):\(password)".data(using: .utf8) else { return nil }
|
||||
|
||||
- parameter user: The user.
|
||||
- parameter password: The password.
|
||||
let credential = data.base64EncodedString(options: [])
|
||||
|
||||
- returns: A dictionary with Authorization key and credential value or empty dictionary if encoding fails.
|
||||
*/
|
||||
public static func authorizationHeader(user user: String, password: String) -> [String: String] {
|
||||
guard let data = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding) else { return [:] }
|
||||
|
||||
let credential = data.base64EncodedStringWithOptions([])
|
||||
|
||||
return ["Authorization": "Basic \(credential)"]
|
||||
return (key: "Authorization", value: "Basic \(credential)")
|
||||
}
|
||||
|
||||
// MARK: - Progress
|
||||
// MARK: State
|
||||
|
||||
/**
|
||||
Sets a closure to be called periodically during the lifecycle of the request as data is written to or read
|
||||
from the server.
|
||||
/// Resumes the request.
|
||||
open func resume() {
|
||||
guard let task = task else { delegate.queue.isSuspended = false ; return }
|
||||
|
||||
- For uploads, the progress closure returns the bytes written, total bytes written, and total bytes expected
|
||||
to write.
|
||||
- For downloads and data tasks, the progress closure returns the bytes read, total bytes read, and total bytes
|
||||
expected to read.
|
||||
|
||||
- parameter closure: The code to be executed periodically during the lifecycle of the request.
|
||||
|
||||
- returns: The request.
|
||||
*/
|
||||
public func progress(closure: ((Int64, Int64, Int64) -> Void)? = nil) -> Self {
|
||||
if let uploadDelegate = delegate as? UploadTaskDelegate {
|
||||
uploadDelegate.uploadProgress = closure
|
||||
} else if let dataDelegate = delegate as? DataTaskDelegate {
|
||||
dataDelegate.dataProgress = closure
|
||||
} else if let downloadDelegate = delegate as? DownloadTaskDelegate {
|
||||
downloadDelegate.downloadProgress = closure
|
||||
}
|
||||
|
||||
return self
|
||||
}
|
||||
|
||||
/**
|
||||
Sets a closure to be called periodically during the lifecycle of the request as data is read from the server.
|
||||
|
||||
This closure returns the bytes most recently received from the server, not including data from previous calls.
|
||||
If this closure is set, data will only be available within this closure, and will not be saved elsewhere. It is
|
||||
also important to note that the `response` closure will be called with nil `responseData`.
|
||||
|
||||
- parameter closure: The code to be executed periodically during the lifecycle of the request.
|
||||
|
||||
- returns: The request.
|
||||
*/
|
||||
public func stream(closure: (NSData -> Void)? = nil) -> Self {
|
||||
if let dataDelegate = delegate as? DataTaskDelegate {
|
||||
dataDelegate.dataStream = closure
|
||||
}
|
||||
|
||||
return self
|
||||
}
|
||||
|
||||
// MARK: - State
|
||||
|
||||
/**
|
||||
Resumes the request.
|
||||
*/
|
||||
public func resume() {
|
||||
if startTime == nil { startTime = CFAbsoluteTimeGetCurrent() }
|
||||
|
||||
task.resume()
|
||||
NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidResume, object: task)
|
||||
|
||||
NotificationCenter.default.post(
|
||||
name: Notification.Name.Task.DidResume,
|
||||
object: self,
|
||||
userInfo: [Notification.Key.Task: task]
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
Suspends the request.
|
||||
*/
|
||||
public func suspend() {
|
||||
/// Suspends the request.
|
||||
open func suspend() {
|
||||
guard let task = task else { return }
|
||||
|
||||
task.suspend()
|
||||
NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidSuspend, object: task)
|
||||
|
||||
NotificationCenter.default.post(
|
||||
name: Notification.Name.Task.DidSuspend,
|
||||
object: self,
|
||||
userInfo: [Notification.Key.Task: task]
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
Cancels the request.
|
||||
*/
|
||||
public func cancel() {
|
||||
if let
|
||||
downloadDelegate = delegate as? DownloadTaskDelegate,
|
||||
downloadTask = downloadDelegate.downloadTask
|
||||
{
|
||||
downloadTask.cancelByProducingResumeData { data in
|
||||
downloadDelegate.resumeData = data
|
||||
}
|
||||
} else {
|
||||
task.cancel()
|
||||
}
|
||||
/// Cancels the request.
|
||||
open func cancel() {
|
||||
guard let task = task else { return }
|
||||
|
||||
NSNotificationCenter.defaultCenter().postNotificationName(Notifications.Task.DidCancel, object: task)
|
||||
}
|
||||
task.cancel()
|
||||
|
||||
// MARK: - TaskDelegate
|
||||
|
||||
/**
|
||||
The task delegate is responsible for handling all delegate callbacks for the underlying task as well as
|
||||
executing all operations attached to the serial operation queue upon task completion.
|
||||
*/
|
||||
public class TaskDelegate: NSObject {
|
||||
|
||||
/// The serial operation queue used to execute all operations after the task completes.
|
||||
public let queue: NSOperationQueue
|
||||
|
||||
let task: NSURLSessionTask
|
||||
let progress: NSProgress
|
||||
|
||||
var data: NSData? { return nil }
|
||||
var error: NSError?
|
||||
|
||||
var initialResponseTime: CFAbsoluteTime?
|
||||
var credential: NSURLCredential?
|
||||
|
||||
init(task: NSURLSessionTask) {
|
||||
self.task = task
|
||||
self.progress = NSProgress(totalUnitCount: 0)
|
||||
self.queue = {
|
||||
let operationQueue = NSOperationQueue()
|
||||
operationQueue.maxConcurrentOperationCount = 1
|
||||
operationQueue.suspended = true
|
||||
|
||||
if #available(OSX 10.10, *) {
|
||||
operationQueue.qualityOfService = NSQualityOfService.Utility
|
||||
}
|
||||
|
||||
return operationQueue
|
||||
}()
|
||||
}
|
||||
|
||||
deinit {
|
||||
queue.cancelAllOperations()
|
||||
queue.suspended = false
|
||||
}
|
||||
|
||||
// MARK: - NSURLSessionTaskDelegate
|
||||
|
||||
// MARK: Override Closures
|
||||
|
||||
var taskWillPerformHTTPRedirection: ((NSURLSession, NSURLSessionTask, NSHTTPURLResponse, NSURLRequest) -> NSURLRequest?)?
|
||||
var taskDidReceiveChallenge: ((NSURLSession, NSURLSessionTask, NSURLAuthenticationChallenge) -> (NSURLSessionAuthChallengeDisposition, NSURLCredential?))?
|
||||
var taskNeedNewBodyStream: ((NSURLSession, NSURLSessionTask) -> NSInputStream?)?
|
||||
var taskDidCompleteWithError: ((NSURLSession, NSURLSessionTask, NSError?) -> Void)?
|
||||
|
||||
// MARK: Delegate Methods
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
task: NSURLSessionTask,
|
||||
willPerformHTTPRedirection response: NSHTTPURLResponse,
|
||||
newRequest request: NSURLRequest,
|
||||
completionHandler: ((NSURLRequest?) -> Void))
|
||||
{
|
||||
var redirectRequest: NSURLRequest? = request
|
||||
|
||||
if let taskWillPerformHTTPRedirection = taskWillPerformHTTPRedirection {
|
||||
redirectRequest = taskWillPerformHTTPRedirection(session, task, response, request)
|
||||
}
|
||||
|
||||
completionHandler(redirectRequest)
|
||||
}
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
task: NSURLSessionTask,
|
||||
didReceiveChallenge challenge: NSURLAuthenticationChallenge,
|
||||
completionHandler: ((NSURLSessionAuthChallengeDisposition, NSURLCredential?) -> Void))
|
||||
{
|
||||
var disposition: NSURLSessionAuthChallengeDisposition = .PerformDefaultHandling
|
||||
var credential: NSURLCredential?
|
||||
|
||||
if let taskDidReceiveChallenge = taskDidReceiveChallenge {
|
||||
(disposition, credential) = taskDidReceiveChallenge(session, task, challenge)
|
||||
} else if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
|
||||
let host = challenge.protectionSpace.host
|
||||
|
||||
if let
|
||||
serverTrustPolicy = session.serverTrustPolicyManager?.serverTrustPolicyForHost(host),
|
||||
serverTrust = challenge.protectionSpace.serverTrust
|
||||
{
|
||||
if serverTrustPolicy.evaluateServerTrust(serverTrust, isValidForHost: host) {
|
||||
disposition = .UseCredential
|
||||
credential = NSURLCredential(forTrust: serverTrust)
|
||||
} else {
|
||||
disposition = .CancelAuthenticationChallenge
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if challenge.previousFailureCount > 0 {
|
||||
disposition = .RejectProtectionSpace
|
||||
} else {
|
||||
credential = self.credential ?? session.configuration.URLCredentialStorage?.defaultCredentialForProtectionSpace(challenge.protectionSpace)
|
||||
|
||||
if credential != nil {
|
||||
disposition = .UseCredential
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
completionHandler(disposition, credential)
|
||||
}
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
task: NSURLSessionTask,
|
||||
needNewBodyStream completionHandler: ((NSInputStream?) -> Void))
|
||||
{
|
||||
var bodyStream: NSInputStream?
|
||||
|
||||
if let taskNeedNewBodyStream = taskNeedNewBodyStream {
|
||||
bodyStream = taskNeedNewBodyStream(session, task)
|
||||
}
|
||||
|
||||
completionHandler(bodyStream)
|
||||
}
|
||||
|
||||
func URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError error: NSError?) {
|
||||
if let taskDidCompleteWithError = taskDidCompleteWithError {
|
||||
taskDidCompleteWithError(session, task, error)
|
||||
} else {
|
||||
if let error = error {
|
||||
self.error = error
|
||||
|
||||
if let
|
||||
downloadDelegate = self as? DownloadTaskDelegate,
|
||||
userInfo = error.userInfo as? [String: AnyObject],
|
||||
resumeData = userInfo[NSURLSessionDownloadTaskResumeData] as? NSData
|
||||
{
|
||||
downloadDelegate.resumeData = resumeData
|
||||
}
|
||||
}
|
||||
|
||||
queue.suspended = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - DataTaskDelegate
|
||||
|
||||
class DataTaskDelegate: TaskDelegate, NSURLSessionDataDelegate {
|
||||
var dataTask: NSURLSessionDataTask? { return task as? NSURLSessionDataTask }
|
||||
|
||||
private var totalBytesReceived: Int64 = 0
|
||||
private var mutableData: NSMutableData
|
||||
override var data: NSData? {
|
||||
if dataStream != nil {
|
||||
return nil
|
||||
} else {
|
||||
return mutableData
|
||||
}
|
||||
}
|
||||
|
||||
private var expectedContentLength: Int64?
|
||||
private var dataProgress: ((bytesReceived: Int64, totalBytesReceived: Int64, totalBytesExpectedToReceive: Int64) -> Void)?
|
||||
private var dataStream: ((data: NSData) -> Void)?
|
||||
|
||||
override init(task: NSURLSessionTask) {
|
||||
mutableData = NSMutableData()
|
||||
super.init(task: task)
|
||||
}
|
||||
|
||||
// MARK: - NSURLSessionDataDelegate
|
||||
|
||||
// MARK: Override Closures
|
||||
|
||||
var dataTaskDidReceiveResponse: ((NSURLSession, NSURLSessionDataTask, NSURLResponse) -> NSURLSessionResponseDisposition)?
|
||||
var dataTaskDidBecomeDownloadTask: ((NSURLSession, NSURLSessionDataTask, NSURLSessionDownloadTask) -> Void)?
|
||||
var dataTaskDidReceiveData: ((NSURLSession, NSURLSessionDataTask, NSData) -> Void)?
|
||||
var dataTaskWillCacheResponse: ((NSURLSession, NSURLSessionDataTask, NSCachedURLResponse) -> NSCachedURLResponse?)?
|
||||
|
||||
// MARK: Delegate Methods
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
dataTask: NSURLSessionDataTask,
|
||||
didReceiveResponse response: NSURLResponse,
|
||||
completionHandler: (NSURLSessionResponseDisposition -> Void))
|
||||
{
|
||||
var disposition: NSURLSessionResponseDisposition = .Allow
|
||||
|
||||
expectedContentLength = response.expectedContentLength
|
||||
|
||||
if let dataTaskDidReceiveResponse = dataTaskDidReceiveResponse {
|
||||
disposition = dataTaskDidReceiveResponse(session, dataTask, response)
|
||||
}
|
||||
|
||||
completionHandler(disposition)
|
||||
}
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
dataTask: NSURLSessionDataTask,
|
||||
didBecomeDownloadTask downloadTask: NSURLSessionDownloadTask)
|
||||
{
|
||||
dataTaskDidBecomeDownloadTask?(session, dataTask, downloadTask)
|
||||
}
|
||||
|
||||
func URLSession(session: NSURLSession, dataTask: NSURLSessionDataTask, didReceiveData data: NSData) {
|
||||
if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
|
||||
|
||||
if let dataTaskDidReceiveData = dataTaskDidReceiveData {
|
||||
dataTaskDidReceiveData(session, dataTask, data)
|
||||
} else {
|
||||
if let dataStream = dataStream {
|
||||
dataStream(data: data)
|
||||
} else {
|
||||
mutableData.appendData(data)
|
||||
}
|
||||
|
||||
totalBytesReceived += data.length
|
||||
let totalBytesExpected = dataTask.response?.expectedContentLength ?? NSURLSessionTransferSizeUnknown
|
||||
|
||||
progress.totalUnitCount = totalBytesExpected
|
||||
progress.completedUnitCount = totalBytesReceived
|
||||
|
||||
dataProgress?(
|
||||
bytesReceived: Int64(data.length),
|
||||
totalBytesReceived: totalBytesReceived,
|
||||
totalBytesExpectedToReceive: totalBytesExpected
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func URLSession(
|
||||
session: NSURLSession,
|
||||
dataTask: NSURLSessionDataTask,
|
||||
willCacheResponse proposedResponse: NSCachedURLResponse,
|
||||
completionHandler: ((NSCachedURLResponse?) -> Void))
|
||||
{
|
||||
var cachedResponse: NSCachedURLResponse? = proposedResponse
|
||||
|
||||
if let dataTaskWillCacheResponse = dataTaskWillCacheResponse {
|
||||
cachedResponse = dataTaskWillCacheResponse(session, dataTask, proposedResponse)
|
||||
}
|
||||
|
||||
completionHandler(cachedResponse)
|
||||
}
|
||||
NotificationCenter.default.post(
|
||||
name: Notification.Name.Task.DidCancel,
|
||||
object: self,
|
||||
userInfo: [Notification.Key.Task: task]
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - CustomStringConvertible
|
||||
|
||||
extension Request: CustomStringConvertible {
|
||||
|
||||
/**
|
||||
The textual representation used when written to an output stream, which includes the HTTP method and URL, as
|
||||
well as the response status code if a response has been received.
|
||||
*/
|
||||
public var description: String {
|
||||
/// The textual representation used when written to an output stream, which includes the HTTP method and URL, as
|
||||
/// well as the response status code if a response has been received.
|
||||
open var description: String {
|
||||
var components: [String] = []
|
||||
|
||||
if let HTTPMethod = request?.HTTPMethod {
|
||||
if let HTTPMethod = request?.httpMethod {
|
||||
components.append(HTTPMethod)
|
||||
}
|
||||
|
||||
if let URLString = request?.URL?.absoluteString {
|
||||
components.append(URLString)
|
||||
if let urlString = request?.url?.absoluteString {
|
||||
components.append(urlString)
|
||||
}
|
||||
|
||||
if let response = response {
|
||||
components.append("(\(response.statusCode))")
|
||||
}
|
||||
|
||||
return components.joinWithSeparator(" ")
|
||||
return components.joined(separator: " ")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - CustomDebugStringConvertible
|
||||
|
||||
extension Request: CustomDebugStringConvertible {
|
||||
/// The textual representation used when written to an output stream, in the form of a cURL command.
|
||||
open var debugDescription: String {
|
||||
return cURLRepresentation()
|
||||
}
|
||||
|
||||
func cURLRepresentation() -> String {
|
||||
var components = ["$ curl -i"]
|
||||
|
||||
guard let
|
||||
request = self.request,
|
||||
URL = request.URL,
|
||||
host = URL.host
|
||||
guard let request = self.request,
|
||||
let url = request.url,
|
||||
let host = url.host
|
||||
else {
|
||||
return "$ curl command could not be created"
|
||||
}
|
||||
|
||||
if let HTTPMethod = request.HTTPMethod where HTTPMethod != "GET" {
|
||||
components.append("-X \(HTTPMethod)")
|
||||
if let httpMethod = request.httpMethod, httpMethod != "GET" {
|
||||
components.append("-X \(httpMethod)")
|
||||
}
|
||||
|
||||
if let credentialStorage = self.session.configuration.URLCredentialStorage {
|
||||
let protectionSpace = NSURLProtectionSpace(
|
||||
if let credentialStorage = self.session.configuration.urlCredentialStorage {
|
||||
let protectionSpace = URLProtectionSpace(
|
||||
host: host,
|
||||
port: URL.port?.integerValue ?? 0,
|
||||
protocol: URL.scheme,
|
||||
port: url.port ?? 0,
|
||||
protocol: url.scheme,
|
||||
realm: host,
|
||||
authenticationMethod: NSURLAuthenticationMethodHTTPBasic
|
||||
)
|
||||
|
||||
if let credentials = credentialStorage.credentialsForProtectionSpace(protectionSpace)?.values {
|
||||
if let credentials = credentialStorage.credentials(for: protectionSpace)?.values {
|
||||
for credential in credentials {
|
||||
components.append("-u \(credential.user!):\(credential.password!)")
|
||||
}
|
||||
@ -518,20 +299,20 @@ extension Request: CustomDebugStringConvertible {
|
||||
}
|
||||
}
|
||||
|
||||
if session.configuration.HTTPShouldSetCookies {
|
||||
if let
|
||||
cookieStorage = session.configuration.HTTPCookieStorage,
|
||||
cookies = cookieStorage.cookiesForURL(URL) where !cookies.isEmpty
|
||||
if session.configuration.httpShouldSetCookies {
|
||||
if
|
||||
let cookieStorage = session.configuration.httpCookieStorage,
|
||||
let cookies = cookieStorage.cookies(for: url), !cookies.isEmpty
|
||||
{
|
||||
let string = cookies.reduce("") { $0 + "\($1.name)=\($1.value ?? String());" }
|
||||
components.append("-b \"\(string.substringToIndex(string.endIndex.predecessor()))\"")
|
||||
let string = cookies.reduce("") { $0 + "\($1.name)=\($1.value);" }
|
||||
components.append("-b \"\(string.substring(to: string.characters.index(before: string.endIndex)))\"")
|
||||
}
|
||||
}
|
||||
|
||||
var headers: [NSObject: AnyObject] = [:]
|
||||
var headers: [AnyHashable: Any] = [:]
|
||||
|
||||
if let additionalHeaders = session.configuration.HTTPAdditionalHeaders {
|
||||
for (field, value) in additionalHeaders where field != "Cookie" {
|
||||
if let additionalHeaders = session.configuration.httpAdditionalHeaders {
|
||||
for (field, value) in additionalHeaders where field != AnyHashable("Cookie") {
|
||||
headers[field] = value
|
||||
}
|
||||
}
|
||||
@ -546,23 +327,274 @@ extension Request: CustomDebugStringConvertible {
|
||||
components.append("-H \"\(field): \(value)\"")
|
||||
}
|
||||
|
||||
if let
|
||||
HTTPBodyData = request.HTTPBody,
|
||||
HTTPBody = String(data: HTTPBodyData, encoding: NSUTF8StringEncoding)
|
||||
{
|
||||
var escapedBody = HTTPBody.stringByReplacingOccurrencesOfString("\\\"", withString: "\\\\\"")
|
||||
escapedBody = escapedBody.stringByReplacingOccurrencesOfString("\"", withString: "\\\"")
|
||||
if let httpBodyData = request.httpBody, let httpBody = String(data: httpBodyData, encoding: .utf8) {
|
||||
var escapedBody = httpBody.replacingOccurrences(of: "\\\"", with: "\\\\\"")
|
||||
escapedBody = escapedBody.replacingOccurrences(of: "\"", with: "\\\"")
|
||||
|
||||
components.append("-d \"\(escapedBody)\"")
|
||||
}
|
||||
|
||||
components.append("\"\(URL.absoluteString)\"")
|
||||
components.append("\"\(url.absoluteString)\"")
|
||||
|
||||
return components.joinWithSeparator(" \\\n\t")
|
||||
}
|
||||
|
||||
/// The textual representation used when written to an output stream, in the form of a cURL command.
|
||||
public var debugDescription: String {
|
||||
return cURLRepresentation()
|
||||
return components.joined(separator: " \\\n\t")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: -
|
||||
|
||||
/// Specific type of `Request` that manages an underlying `URLSessionDataTask`.
|
||||
open class DataRequest: Request {
|
||||
|
||||
// MARK: Helper Types
|
||||
|
||||
struct Requestable: TaskConvertible {
|
||||
let urlRequest: URLRequest
|
||||
|
||||
func task(session: URLSession, adapter: RequestAdapter?, queue: DispatchQueue) throws -> URLSessionTask {
|
||||
let urlRequest = try self.urlRequest.adapt(using: adapter)
|
||||
return queue.syncResult { session.dataTask(with: urlRequest) }
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Properties
|
||||
|
||||
/// The progress of fetching the response data from the server for the request.
|
||||
open var progress: Progress { return dataDelegate.progress }
|
||||
|
||||
var dataDelegate: DataTaskDelegate { return delegate as! DataTaskDelegate }
|
||||
|
||||
// MARK: Stream
|
||||
|
||||
/// Sets a closure to be called periodically during the lifecycle of the request as data is read from the server.
|
||||
///
|
||||
/// This closure returns the bytes most recently received from the server, not including data from previous calls.
|
||||
/// If this closure is set, data will only be available within this closure, and will not be saved elsewhere. It is
|
||||
/// also important to note that the server data in any `Response` object will be `nil`.
|
||||
///
|
||||
/// - parameter closure: The code to be executed periodically during the lifecycle of the request.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func stream(closure: ((Data) -> Void)? = nil) -> Self {
|
||||
dataDelegate.dataStream = closure
|
||||
return self
|
||||
}
|
||||
|
||||
// MARK: Progress
|
||||
|
||||
/// Sets a closure to be called periodically during the lifecycle of the `Request` as data is read from the server.
|
||||
///
|
||||
/// - parameter queue: The dispatch queue to execute the closure on.
|
||||
/// - parameter closure: The code to be executed periodically as data is read from the server.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func downloadProgress(queue: DispatchQueue = DispatchQueue.main, closure: @escaping ProgressHandler) -> Self {
|
||||
dataDelegate.progressHandler = (closure, queue)
|
||||
return self
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: -
|
||||
|
||||
/// Specific type of `Request` that manages an underlying `URLSessionDownloadTask`.
|
||||
open class DownloadRequest: Request {
|
||||
|
||||
// MARK: Helper Types
|
||||
|
||||
/// A collection of options to be executed prior to moving a downloaded file from the temporary URL to the
|
||||
/// destination URL.
|
||||
public struct DownloadOptions: OptionSet {
|
||||
/// Returns the raw bitmask value of the option and satisfies the `RawRepresentable` protocol.
|
||||
public let rawValue: UInt
|
||||
|
||||
/// A `DownloadOptions` flag that creates intermediate directories for the destination URL if specified.
|
||||
public static let createIntermediateDirectories = DownloadOptions(rawValue: 1 << 0)
|
||||
|
||||
/// A `DownloadOptions` flag that removes a previous file from the destination URL if specified.
|
||||
public static let removePreviousFile = DownloadOptions(rawValue: 1 << 1)
|
||||
|
||||
/// Creates a `DownloadFileDestinationOptions` instance with the specified raw value.
|
||||
///
|
||||
/// - parameter rawValue: The raw bitmask value for the option.
|
||||
///
|
||||
/// - returns: A new log level instance.
|
||||
public init(rawValue: UInt) {
|
||||
self.rawValue = rawValue
|
||||
}
|
||||
}
|
||||
|
||||
/// A closure executed once a download request has successfully completed in order to determine where to move the
|
||||
/// temporary file written to during the download process. The closure takes two arguments: the temporary file URL
|
||||
/// and the URL response, and returns a two arguments: the file URL where the temporary file should be moved and
|
||||
/// the options defining how the file should be moved.
|
||||
public typealias DownloadFileDestination = (
|
||||
_ temporaryURL: URL,
|
||||
_ response: HTTPURLResponse)
|
||||
-> (destinationURL: URL, options: DownloadOptions)
|
||||
|
||||
enum Downloadable: TaskConvertible {
|
||||
case request(URLRequest)
|
||||
case resumeData(Data)
|
||||
|
||||
func task(session: URLSession, adapter: RequestAdapter?, queue: DispatchQueue) throws -> URLSessionTask {
|
||||
let task: URLSessionTask
|
||||
|
||||
switch self {
|
||||
case let .request(urlRequest):
|
||||
let urlRequest = try urlRequest.adapt(using: adapter)
|
||||
task = queue.syncResult { session.downloadTask(with: urlRequest) }
|
||||
case let .resumeData(resumeData):
|
||||
task = queue.syncResult { session.downloadTask(withResumeData: resumeData) }
|
||||
}
|
||||
|
||||
return task
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Properties
|
||||
|
||||
/// The resume data of the underlying download task if available after a failure.
|
||||
open var resumeData: Data? { return downloadDelegate.resumeData }
|
||||
|
||||
/// The progress of downloading the response data from the server for the request.
|
||||
open var progress: Progress { return downloadDelegate.progress }
|
||||
|
||||
var downloadDelegate: DownloadTaskDelegate { return delegate as! DownloadTaskDelegate }
|
||||
|
||||
// MARK: State
|
||||
|
||||
/// Cancels the request.
|
||||
open override func cancel() {
|
||||
downloadDelegate.downloadTask.cancel { self.downloadDelegate.resumeData = $0 }
|
||||
|
||||
NotificationCenter.default.post(
|
||||
name: Notification.Name.Task.DidCancel,
|
||||
object: self,
|
||||
userInfo: [Notification.Key.Task: task]
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: Progress
|
||||
|
||||
/// Sets a closure to be called periodically during the lifecycle of the `Request` as data is read from the server.
|
||||
///
|
||||
/// - parameter queue: The dispatch queue to execute the closure on.
|
||||
/// - parameter closure: The code to be executed periodically as data is read from the server.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func downloadProgress(queue: DispatchQueue = DispatchQueue.main, closure: @escaping ProgressHandler) -> Self {
|
||||
downloadDelegate.progressHandler = (closure, queue)
|
||||
return self
|
||||
}
|
||||
|
||||
// MARK: Destination
|
||||
|
||||
/// Creates a download file destination closure which uses the default file manager to move the temporary file to a
|
||||
/// file URL in the first available directory with the specified search path directory and search path domain mask.
|
||||
///
|
||||
/// - parameter directory: The search path directory. `.DocumentDirectory` by default.
|
||||
/// - parameter domain: The search path domain mask. `.UserDomainMask` by default.
|
||||
///
|
||||
/// - returns: A download file destination closure.
|
||||
open class func suggestedDownloadDestination(
|
||||
for directory: FileManager.SearchPathDirectory = .documentDirectory,
|
||||
in domain: FileManager.SearchPathDomainMask = .userDomainMask)
|
||||
-> DownloadFileDestination
|
||||
{
|
||||
return { temporaryURL, response in
|
||||
let directoryURLs = FileManager.default.urls(for: directory, in: domain)
|
||||
|
||||
if !directoryURLs.isEmpty {
|
||||
return (directoryURLs[0].appendingPathComponent(response.suggestedFilename!), [])
|
||||
}
|
||||
|
||||
return (temporaryURL, [])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: -
|
||||
|
||||
/// Specific type of `Request` that manages an underlying `URLSessionUploadTask`.
|
||||
open class UploadRequest: DataRequest {
|
||||
|
||||
// MARK: Helper Types
|
||||
|
||||
enum Uploadable: TaskConvertible {
|
||||
case data(Data, URLRequest)
|
||||
case file(URL, URLRequest)
|
||||
case stream(InputStream, URLRequest)
|
||||
|
||||
func task(session: URLSession, adapter: RequestAdapter?, queue: DispatchQueue) throws -> URLSessionTask {
|
||||
let task: URLSessionTask
|
||||
|
||||
switch self {
|
||||
case let .data(data, urlRequest):
|
||||
let urlRequest = try urlRequest.adapt(using: adapter)
|
||||
task = queue.syncResult { session.uploadTask(with: urlRequest, from: data) }
|
||||
case let .file(url, urlRequest):
|
||||
let urlRequest = try urlRequest.adapt(using: adapter)
|
||||
task = queue.syncResult { session.uploadTask(with: urlRequest, fromFile: url) }
|
||||
case let .stream(_, urlRequest):
|
||||
let urlRequest = try urlRequest.adapt(using: adapter)
|
||||
task = queue.syncResult { session.uploadTask(withStreamedRequest: urlRequest) }
|
||||
}
|
||||
|
||||
return task
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: Properties
|
||||
|
||||
/// The progress of uploading the payload to the server for the upload request.
|
||||
open var uploadProgress: Progress { return uploadDelegate.uploadProgress }
|
||||
|
||||
var uploadDelegate: UploadTaskDelegate { return delegate as! UploadTaskDelegate }
|
||||
|
||||
// MARK: Upload Progress
|
||||
|
||||
/// Sets a closure to be called periodically during the lifecycle of the `UploadRequest` as data is sent to
|
||||
/// the server.
|
||||
///
|
||||
/// After the data is sent to the server, the `progress(queue:closure:)` APIs can be used to monitor the progress
|
||||
/// of data being read from the server.
|
||||
///
|
||||
/// - parameter queue: The dispatch queue to execute the closure on.
|
||||
/// - parameter closure: The code to be executed periodically as data is sent to the server.
|
||||
///
|
||||
/// - returns: The request.
|
||||
@discardableResult
|
||||
open func uploadProgress(queue: DispatchQueue = DispatchQueue.main, closure: @escaping ProgressHandler) -> Self {
|
||||
uploadDelegate.uploadProgressHandler = (closure, queue)
|
||||
return self
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: -
|
||||
|
||||
#if !os(watchOS)
|
||||
|
||||
/// Specific type of `Request` that manages an underlying `URLSessionStreamTask`.
|
||||
open class StreamRequest: Request {
|
||||
enum Streamable: TaskConvertible {
|
||||
case stream(hostName: String, port: Int)
|
||||
case netService(NetService)
|
||||
|
||||
func task(session: URLSession, adapter: RequestAdapter?, queue: DispatchQueue) throws -> URLSessionTask {
|
||||
let task: URLSessionTask
|
||||
|
||||
switch self {
|
||||
case let .stream(hostName, port):
|
||||
task = queue.syncResult { session.streamTask(withHostName: hostName, port: port) }
|
||||
case let .netService(netService):
|
||||
task = queue.syncResult { session.streamTask(with: netService) }
|
||||
}
|
||||
|
||||
return task
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user