|
|
// // SocketEnginePollable.swift // Socket.IO-Client-Swift // // Created by Erik Little on 1/15/16. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE.
import Foundation
/// Protocol that is used to implement socket.io polling support public protocol SocketEnginePollable: SocketEngineSpec { // MARK: Properties
/// `true` If engine's session has been invalidated. var invalidated: Bool { get }
/// A queue of engine.io messages waiting for POSTing /// /// **You should not touch this directly** var postWait: [Post] { get set }
/// The URLSession that will be used for polling. var session: URLSession? { get }
/// `true` if there is an outstanding poll. Trying to poll before the first is done will cause socket.io to /// disconnect us. /// /// **Do not touch this directly** var waitingForPoll: Bool { get set }
/// `true` if there is an outstanding post. Trying to post before the first is done will cause socket.io to /// disconnect us. /// /// **Do not touch this directly** var waitingForPost: Bool { get set }
// MARK: Methods
/// Call to send a long-polling request. /// /// You shouldn't need to call this directly, the engine should automatically maintain a long-poll request. func doPoll()
/// Sends an engine.io message through the polling transport. /// /// You shouldn't call this directly, instead call the `write` method on `SocketEngine`. /// /// - parameter message: The message to send. /// - parameter withType: The type of message to send. /// - parameter withData: The data associated with this message. func sendPollMessage(_ message: String, withType type: SocketEnginePacketType, withData datas: [Data], completion: (() -> ())?)
/// Call to stop polling and invalidate the URLSession. func stopPolling() }
// Default polling methods extension SocketEnginePollable { func createRequestForPostWithPostWait() -> URLRequest { defer { for packet in postWait { packet.completion?() } postWait.removeAll(keepingCapacity: true) }
var postStr = ""
if version.rawValue >= 3 { postStr = postWait.lazy.map({ $0.msg }).joined(separator: "\u{1e}") } else { for packet in postWait { postStr += "\(packet.msg.utf16.count):\(packet.msg)" } }
DefaultSocketLogger.Logger.log("Created POST string: \(postStr)", type: "SocketEnginePolling")
var req = URLRequest(url: urlPollingWithSid) let postData = postStr.data(using: .utf8, allowLossyConversion: false)!
addHeaders(to: &req)
req.httpMethod = "POST" req.setValue("text/plain; charset=UTF-8", forHTTPHeaderField: "Content-Type") req.httpBody = postData req.setValue(String(postData.count), forHTTPHeaderField: "Content-Length")
return req }
/// Call to send a long-polling request. /// /// You shouldn't need to call this directly, the engine should automatically maintain a long-poll request. public func doPoll() { guard polling && !waitingForPoll && connected && !closed else { return }
var req = URLRequest(url: urlPollingWithSid) addHeaders(to: &req)
doLongPoll(for: req) }
func doRequest(for req: URLRequest, callbackWith callback: @escaping (Data?, URLResponse?, Error?) -> ()) { guard polling && !closed && !invalidated && !fastUpgrade else { return }
DefaultSocketLogger.Logger.log("Doing polling \(req.httpMethod ?? "") \(req)", type: "SocketEnginePolling")
session?.dataTask(with: req, completionHandler: callback).resume() }
func doLongPoll(for req: URLRequest) { waitingForPoll = true
doRequest(for: req) {[weak self] data, res, err in guard let this = self, this.polling else { return } guard let data = data, let res = res as? HTTPURLResponse, res.statusCode == 200 else { if let err = err { DefaultSocketLogger.Logger.error(err.localizedDescription, type: "SocketEnginePolling") } else { DefaultSocketLogger.Logger.error("Error during long poll request", type: "SocketEnginePolling") }
if this.polling { this.didError(reason: err?.localizedDescription ?? "Error") }
return }
DefaultSocketLogger.Logger.log("Got polling response", type: "SocketEnginePolling")
if let str = String(data: data, encoding: .utf8) { this.parsePollingMessage(str) }
this.waitingForPoll = false
if this.fastUpgrade { this.doFastUpgrade() } else if !this.closed && this.polling { this.doPoll() } } }
private func flushWaitingForPost() { guard postWait.count != 0 && connected else { return } guard polling else { flushWaitingForPostToWebSocket()
return }
let req = createRequestForPostWithPostWait()
waitingForPost = true
DefaultSocketLogger.Logger.log("POSTing", type: "SocketEnginePolling")
doRequest(for: req) {[weak self] _, res, err in guard let this = self else { return } guard let res = res as? HTTPURLResponse, res.statusCode == 200 else { if let err = err { DefaultSocketLogger.Logger.error(err.localizedDescription, type: "SocketEnginePolling") } else { DefaultSocketLogger.Logger.error("Error flushing waiting posts", type: "SocketEnginePolling") }
if this.polling { this.didError(reason: err?.localizedDescription ?? "Error") }
return }
this.waitingForPost = false
if !this.fastUpgrade { this.flushWaitingForPost() this.doPoll() } } }
func parsePollingMessage(_ str: String) { guard !str.isEmpty else { return }
DefaultSocketLogger.Logger.log("Got poll message: \(str)", type: "SocketEnginePolling")
if version.rawValue >= 3 { let records = str.components(separatedBy: "\u{1e}")
for record in records { parseEngineMessage(record) } } else { guard str.count != 1 else { parseEngineMessage(str)
return }
var reader = SocketStringReader(message: str)
while reader.hasNext { if let n = Int(reader.readUntilOccurence(of: ":")) { parseEngineMessage(reader.read(count: n)) } else { parseEngineMessage(str) break } } } }
/// Sends an engine.io message through the polling transport. /// /// You shouldn't call this directly, instead call the `write` method on `SocketEngine`. /// /// - parameter message: The message to send. /// - parameter withType: The type of message to send. /// - parameter withData: The data associated with this message. /// - parameter completion: Callback called on transport write completion. public func sendPollMessage(_ message: String, withType type: SocketEnginePacketType, withData datas: [Data], completion: (() -> ())? = nil) { DefaultSocketLogger.Logger.log("Sending poll: \(message) as type: \(type.rawValue)", type: "SocketEnginePolling")
postWait.append((String(type.rawValue) + message, completion))
for data in datas { if case let .right(bin) = createBinaryDataForSend(using: data) { postWait.append((bin, {})) } }
if !waitingForPost { flushWaitingForPost() } }
/// Call to stop polling and invalidate the URLSession. public func stopPolling() { waitingForPoll = false waitingForPost = false session?.finishTasksAndInvalidate() } }
|