Reworked reconnection logic to be easier to understand and more stable

Author: hamchapman

Source/PusherConnection.swift

@@ -25,19 +25,17 @@ public class PusherConnection {
     public var reconnectAttemptsMax: Int? = 6
     public var reconnectAttempts: Int = 0
     public var maxReconnectGapInSeconds: Double? = nil
-    private var reconnectTimer: NSTimer? = nil
-    internal var reconnectOperation: NSOperation?
+    internal var reconnectTimer: NSTimer? = nil
 
     public lazy var reachability: Reachability? = {
         let reachability = try? Reachability.reachabilityForInternetConnection()
         reachability?.whenReachable = { [unowned self] reachability in
-            self.reconnectOperation?.cancel()
+            self.debugLogger?("[PUSHER DEBUG] WE ARE REACHABLE AGAIN")
             if self.connectionState == .Disconnected {
-                self.socket.connect()
+                self.attemptReconnect()
             }
         }
         reachability?.whenUnreachable = { [unowned self] reachability in
-            self.reconnectOperation?.cancel()
             print("Network unreachable")
         }
         return reachability
@@ -182,7 +180,7 @@ public class PusherConnection {
     /**
         Establish a websocket connection
     */
-    public func connect() {
+    @objc public func connect() {
         if self.connectionState == .Connected {
             return
         } else {
@@ -283,13 +281,13 @@ public class PusherConnection {
                 updateConnectionState(.Connected)
                 self.socketId = socketId
 
-                // cancel any other outstanding reconnect attempts
-                self.reconnectOperation?.cancel()
                 self.reconnectAttempts = 0
                 self.reconnectTimer?.invalidate()
 
                 for (_, channel) in self.channels.channels {
+                    print("Here's my channel \(channel.name)")
                     if !channel.subscribed {
+                        print("And we aren't subbed")
                         if !self.authorize(channel) {
                             print("Unable to subscribe to channel: \(channel.name)")
                         }
@@ -665,35 +663,14 @@ public class PusherConnection {
                 )
             }
     }
-
-    /**
-        Attempt to reconnect triggered by a disconnection
-    */
-    @objc internal func attemptReconnect() {
-        if connectionState != .Connected {
-            if (reconnectAttemptsMax == nil || reconnectAttempts < reconnectAttemptsMax) {
-                connect()
-                reconnectAttempts += 1
-                let reconnectInterval = Double(reconnectAttempts * reconnectAttempts) * 2.0
-                let timeInterval = maxReconnectGapInSeconds != nil ? max(reconnectInterval, maxReconnectGapInSeconds!)
-                                                                   : reconnectInterval
-                reconnectTimer = NSTimer.scheduledTimerWithTimeInterval(
-                    timeInterval,
-                    target: self,
-                    selector: #selector(attemptReconnect),
-                    userInfo: nil,
-                    repeats: false
-                )
-            }
-        }
-    }
 }
 
 public enum ConnectionState {
     case Connecting
     case Connected
     case Disconnecting
     case Disconnected
+    case Reconnecting
 }
 
 public protocol ConnectionStateChangeDelegate: class {

Source/PusherWebsocketDelegate.swift

@@ -30,37 +30,71 @@ extension PusherConnection: WebSocketDelegate {
         - parameter error: The error, if one exists, when disconnected
     */
     public func websocketDidDisconnect(ws: WebSocket, error: NSError?) {
-        updateConnectionState(.Disconnected)
-        for (_, channel) in self.channels.channels {
-            channel.subscribed = false
+        // Handles setting channel subscriptions to unsubscribed wheter disconnection
+        // is intentional or not
+        if connectionState == .Disconnecting || connectionState == .Connected {
+            for (_, channel) in self.channels.channels {
+                channel.subscribed = false
+            }
         }
 
         // Handle error (if any)
         guard let error = error where error.code != Int(WebSocket.CloseCode.Normal.rawValue) else {
-            return
+            self.debugLogger?("[PUSHER DEBUG] Deliberate disconnection - skipping reconnect attempts")
+            return updateConnectionState(.Disconnected)
         }
 
         print("Websocket is disconnected. Error: \(error.localizedDescription)")
+        // Attempt reconnect if possible
 
-        // Reconnect if possible
-        if self.options.autoReconnect && reconnectAttempts == 0 {
-            if let reachability = self.reachability where reachability.isReachable() {
-                let operation = NSBlockOperation {
-                    self.socket.connect()
-                }
+        guard self.options.autoReconnect else {
+            return updateConnectionState(.Disconnected)
+        }
 
-                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(NSEC_PER_SEC)), dispatch_get_main_queue()) {
-                    NSOperationQueue.mainQueue().addOperation(operation)
-                }
+        guard reconnectAttemptsMax != nil && reconnectAttempts < reconnectAttemptsMax! else {
+            self.debugLogger?("[PUSHER DEBUG] Max reconnect attempts reached")
+            return updateConnectionState(.Disconnected)
+        }
 
-                self.reconnectOperation?.cancel()
-                self.reconnectOperation = operation
-            }
+        guard let reachability = self.reachability where reachability.isReachable() else {
+            self.debugLogger?("[PUSHER DEBUG] Network unreachable so waiting to attempt reconnect")
+            return updateConnectionState(.Disconnected)
+        }
+
+        if connectionState != .Reconnecting {
+            updateConnectionState(.Reconnecting)
+        }
+        self.debugLogger?("[PUSHER DEBUG] Network reachable so will setup reconnect attempt")
+
+        attemptReconnect()
+    }
+
+    /**
+        Attempt to reconnect triggered by a disconnection
+    */
+    internal func attemptReconnect() {
+        if connectionState != .Connected {
+            if (reconnectAttemptsMax == nil || reconnectAttempts < reconnectAttemptsMax!) {
+                let reconnectInterval = Double(reconnectAttempts * reconnectAttempts)
 
-            attemptReconnect()
+                let timeInterval = maxReconnectGapInSeconds != nil ? min(reconnectInterval, maxReconnectGapInSeconds!)
+                                                                   : reconnectInterval
+
+                self.debugLogger?("[PUSHER DEBUG] Waiting \(timeInterval) seconds before attempting to reconnect (attempt \(reconnectAttempts + 1) of \(reconnectAttemptsMax))")
+
+                reconnectTimer = NSTimer.scheduledTimerWithTimeInterval(
+                    timeInterval,
+                    target: self,
+                    selector: #selector(connect),
+                    userInfo: nil,
+                    repeats: false
+                )
+                reconnectAttempts += 1
+            }
         }
     }
 
+
     public func websocketDidConnect(ws: WebSocket) {}
     public func websocketDidReceiveData(ws: WebSocket, data: NSData) {}
 }