LiveQuery: Always receive and pass connection errors (#211)

* LiveQuery: Always receive and pass connection errors

* Add receive tests

* Fix failing testcase

* Fix error for tvOS

* Fix reconnections

* Improve and prepare for release

* Update .codecov.yml

Author: cbaker6

.codecov.yml

@@ -4,7 +4,7 @@ coverage:
   status:
     patch:
       default:
-        target: auto
+        target: 75
     changes: false
     project:
       default:

CHANGELOG.md

@@ -1,9 +1,14 @@
 # Parse-Swift Changelog
 
 ### main
-[Full Changelog](https://github.com/parse-community/Parse-Swift/compare/1.9.3...main)
+[Full Changelog](https://github.com/parse-community/Parse-Swift/compare/1.9.4...main)
 * _Contributing to this repo? Add info about your change here to be included in the next release_
 
+### 1.9.4
+[Full Changelog](https://github.com/parse-community/Parse-Swift/compare/1.9.3...1.9.4)
+__Fixes__
+- Fix LiveQuery reconnections when server disconnects. Always receive and pass connection errors to ParseLiveQuery delegate ([#211](https://github.com/parse-community/Parse-Swift/pull/211)), thanks to [Corey Baker](https://github.com/cbaker6).
+
 ### 1.9.3
 [Full Changelog](https://github.com/parse-community/Parse-Swift/compare/1.9.2...1.9.3)
 __Improvements__

ParseSwift.playground/Pages/11 - LiveQuery.xcplaygroundpage/Contents.swift

@@ -29,8 +29,26 @@ struct GameScore: ParseObject {
     }
 }
 
+//: Create a delegate for LiveQuery errors
+class LiveQueryDelegate: ParseLiveQueryDelegate {
+
+    func received(_ error: Error) {
+        print(error)
+    }
+
+    func closedSocket(_ code: URLSessionWebSocketTask.CloseCode?, reason: Data?) {
+        print("Socket closed with \(String(describing: code)) and \(String(describing: reason))")
+    }
+}
+
 //: Be sure you have LiveQuery enabled on your server.
 
+//: Set the delegate.
+let delegate = LiveQueryDelegate()
+if let socket = ParseLiveQuery.getDefault() {
+    socket.receiveDelegate = delegate
+}
+
 //: Create a query just as you normally would.
 var query = GameScore.query("score" < 11)
 

Sources/ParseSwift/LiveQuery/LiveQuerySocket.swift

@@ -15,6 +15,7 @@ import FoundationNetworking
 final class LiveQuerySocket: NSObject {
     private var session: URLSession!
     var delegates = [URLSessionWebSocketTask: LiveQuerySocketDelegate]()
+    var receivingTasks = [URLSessionWebSocketTask: Bool]()
     weak var authenticationDelegate: LiveQuerySocketDelegate?
 
     override init() {
@@ -25,10 +26,12 @@ final class LiveQuerySocket: NSObject {
     func createTask(_ url: URL, taskDelegate: LiveQuerySocketDelegate) -> URLSessionWebSocketTask {
         let task = session.webSocketTask(with: url)
         delegates[task] = taskDelegate
+        receive(task)
         return task
     }
 
     func removeTaskFromDelegates(_ task: URLSessionWebSocketTask) {
+        receivingTasks.removeValue(forKey: task)
         delegates.removeValue(forKey: task)
     }
 
@@ -90,7 +93,13 @@ extension LiveQuerySocket {
 extension LiveQuerySocket {
 
     func receive(_ task: URLSessionWebSocketTask) {
+        if receivingTasks[task] != nil {
+            // Receive has already been called for this task
+            return
+        }
+        receivingTasks[task] = true
         task.receive { result in
+            self.receivingTasks.removeValue(forKey: task)
             switch result {
             case .success(.string(let message)):
                 if let data = message.data(using: .utf8) {

Sources/ParseSwift/LiveQuery/ParseLiveQuery.swift

@@ -65,6 +65,15 @@ public final class ParseLiveQuery: NSObject {
     var attempts: Int = 1 {
         willSet {
             if newValue >= ParseLiveQueryConstants.maxConnectionAttempts + 1 {
+                let error = ParseError(code: .unknownError,
+                                       message: """
+ParseLiveQuery Error: Reached max attempts of
+\(ParseLiveQueryConstants.maxConnectionAttempts).
+Not attempting to open ParseLiveQuery socket anymore
+""")
+                notificationQueue.async {
+                    self.receiveDelegate?.received(error)
+                }
                 close() // Quit trying to reconnect
             }
         }
@@ -231,13 +240,17 @@ extension ParseLiveQuery {
         synchronizationQueue.sync {
             switch self.task.state {
             case .suspended:
+                URLSession.liveQuery.receive(task)
                 self.task.resume()
                 completion(nil)
             case .completed, .canceling:
-                URLSession.liveQuery.removeTaskFromDelegates(self.task)
+                let oldTask = self.task
                 self.task = URLSession.liveQuery.createTask(self.url,
                                                             taskDelegate: self)
                 self.task.resume()
+                if let oldTask = oldTask {
+                    URLSession.liveQuery.removeTaskFromDelegates(oldTask)
+                }
                 completion(nil)
             case .running:
                 self.open(isUserWantsToConnect: false, completion: completion)
@@ -481,23 +494,49 @@ extension ParseLiveQuery: LiveQuerySocketDelegate {
     }
 
     func receivedError(_ error: Error) {
+        if !isPosixError(error) {
+            if !isURLError(error) {
+                notificationQueue.async {
+                    self.receiveDelegate?.received(error)
+                }
+            }
+        }
+    }
+
+    func isPosixError(_ error: Error) -> Bool {
         guard let posixError = error as? POSIXError else {
             notificationQueue.async {
                 self.receiveDelegate?.received(error)
             }
-            return
+            return false
         }
         if posixError.code == .ENOTCONN {
-            if attempts + 1 >= ParseLiveQueryConstants.maxConnectionAttempts + 1 {
-                let parseError = ParseError(code: .unknownError,
-                                            message: """
-Max attempts (\(ParseLiveQueryConstants.maxConnectionAttempts) reached.
-Not attempting to connect to LiveQuery server anymore.
-""")
-                notificationQueue.async {
-                    self.receiveDelegate?.received(parseError)
+            isSocketEstablished = false
+            open(isUserWantsToConnect: false) { error in
+                guard let error = error else {
+                    // Resumed task successfully
+                    return
+                }
+                self.notificationQueue.async {
+                    self.receiveDelegate?.received(error)
                 }
             }
+        } else {
+            notificationQueue.async {
+                self.receiveDelegate?.received(error)
+            }
+        }
+        return true
+    }
+
+    func isURLError(_ error: Error) -> Bool {
+        guard let urlError = error as? URLError else {
+            notificationQueue.async {
+                self.receiveDelegate?.received(error)
+            }
+            return false
+        }
+        if urlError.errorCode == -1005 {
             isSocketEstablished = false
             open(isUserWantsToConnect: false) { error in
                 guard let error = error else {
@@ -513,6 +552,7 @@ Not attempting to connect to LiveQuery server anymore.
                 self.receiveDelegate?.received(error)
             }
         }
+        return true
     }
 
     func receivedUnsupported(_ data: Data?, socketMessage: URLSessionWebSocketTask.Message?) {
@@ -596,12 +636,15 @@ extension ParseLiveQuery {
             if self.isConnected {
                 self.task.cancel(with: .goingAway, reason: nil)
                 self.isDisconnectedByUser = true
+                let oldTask = self.task
+                isSocketEstablished = false
+                // Prepare new task for future use.
+                self.task = URLSession.liveQuery.createTask(self.url,
+                                                            taskDelegate: self)
+                if let oldTask = oldTask {
+                    URLSession.liveQuery.removeTaskFromDelegates(oldTask)
+                }
             }
-            URLSession.liveQuery.removeTaskFromDelegates(self.task)
-            isSocketEstablished = false
-            // Prepare new task for future use.
-            self.task = URLSession.liveQuery.createTask(self.url,
-                                                        taskDelegate: self)
         }
     }
 
@@ -636,22 +679,28 @@ extension ParseLiveQuery {
             synchronizationQueue.async {
                 if self.isConnected {
                     self.task.cancel(with: .goingAway, reason: nil)
+                    let oldTask = self.task
+                    self.isSocketEstablished = false
+                    // Prepare new task for future use.
+                    self.task = URLSession.liveQuery.createTask(self.url,
+                                                                taskDelegate: self)
+                    if let oldTask = oldTask {
+                        URLSession.liveQuery.removeTaskFromDelegates(oldTask)
+                    }
                 }
-                URLSession.liveQuery.removeTaskFromDelegates(self.task)
-                self.isSocketEstablished = false
-                // Prepare new task for future use.
-                self.task = URLSession.liveQuery.createTask(self.url,
-                                                            taskDelegate: self)
             }
         } else {
             if self.isConnected {
                 self.task.cancel(with: .goingAway, reason: nil)
+                let oldTask = task
+                isSocketEstablished = false
+                // Prepare new task for future use.
+                self.task = URLSession.liveQuery.createTask(self.url,
+                                                            taskDelegate: self)
+                if let oldTask = oldTask {
+                    URLSession.liveQuery.removeTaskFromDelegates(oldTask)
+                }
             }
-            URLSession.liveQuery.removeTaskFromDelegates(self.task)
-            isSocketEstablished = false
-            // Prepare new task for future use.
-            self.task = URLSession.liveQuery.createTask(self.url,
-                                                        taskDelegate: self)
         }
     }
 

Sources/ParseSwift/LiveQuery/Protocols/ParseLiveQueryDelegate.swift

@@ -39,6 +39,7 @@ public protocol ParseLiveQueryDelegate: AnyObject {
     /**
     Receive errors from the ParseLiveQuery task/connection.
      - parameter error: An error from the session task.
+     - note: The type of error received can vary from `ParseError`, `URLError`, `POSIXError`, etc.
      */
     func received(_ error: Error)
 

Sources/ParseSwift/ParseConstants.swift

@@ -10,7 +10,7 @@ import Foundation
 
 enum ParseConstants {
     static let sdk = "swift"
-    static let version = "1.9.3"
+    static let version = "1.9.4"
     static let fileManagementDirectory = "parse/"
     static let fileManagementPrivateDocumentsDirectory = "Private Documents/"
     static let fileManagementLibraryDirectory = "Library/"

TestHostTV/Info.plist

@@ -30,5 +30,10 @@
 	</array>
 	<key>UIUserInterfaceStyle</key>
 	<string>Automatic</string>
+    <key>NSAppTransportSecurity</key>
+    <dict>
+        <key>NSAllowsArbitraryLoads</key>
+        <true/>
+    </dict>
 </dict>
 </plist>

Tests/ParseSwiftTests/ParseLiveQueryCombineTests.swift

@@ -86,13 +86,14 @@ class ParseLiveQueryCombineTests: XCTestCase {
                     XCTFail("Should have produced failure")
                 case .failure(let error):
                     XCTAssertEqual(client.isSocketEstablished, false)
-                    guard let parseError = error as? ParseError else {
+                    guard let urlError = error as? URLError else {
                         XCTFail("Should have casted to ParseError.")
                         expectation1.fulfill()
                         return
                     }
-                    XCTAssertEqual(parseError.code, ParseError.Code.unknownError)
-                    XCTAssertTrue(parseError.message.contains("socket status"))
+                    // "Could not connect to the server"
+                    // because webSocket connections are not intercepted.
+                    XCTAssertEqual(urlError.errorCode, -1004)
                 }
                 expectation1.fulfill()