[HOTFIX] Clear PingTimeout (#607)

Fixes the ping clearTimeout

Author: Yoann-Abbes

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-sdk",
-  "version": "7.5.5",
+  "version": "7.5.6",
   "description": "Official Javascript SDK for Kuzzle",
   "author": "The Kuzzle Team <support@kuzzle.io>",
   "repository": {

package.json

@@ -14,6 +14,10 @@ export default class WebSocketProtocol extends BaseProtocolRealtime {
   private client: any;
   private lasturl: any;
   private ping: any;
+  private pongTimeoutId: ReturnType<typeof setTimeout>;
+  private pingIntervalId: ReturnType<typeof setInterval>;
+  private _pingInterval: number;
+  private _pongTimeout: number;
 
   /**
    * @param host Kuzzle server hostname or IP
@@ -66,6 +70,8 @@ export default class WebSocketProtocol extends BaseProtocolRealtime {
       }
     }
 
+    this._pingInterval = typeof options.pingInterval === 'number' ? options.pingInterval : 2000;
+    this._pongTimeout = this._pingInterval;
     this.client = null;
     this.lasturl = null;
   }
@@ -108,16 +114,13 @@ export default class WebSocketProtocol extends BaseProtocolRealtime {
         * Send pings to the server
         */
         this.pingIntervalId = setInterval(() => {
-          if (this.client.readyState === 1) {
+          if (this.client && this.client.readyState === 1) {
             this.ping();
           }
           this.pongTimeoutId = setTimeout(() => {
             const error: any = new Error('Connection lost.');
             error.status = 503;
             this.clientNetworkError(error);
-            this.emit('disconnect');
-            clearInterval(this.pingIntervalId);
-            clearTimeout(this.pongTimeoutId);
           }, this._pongTimeout);
         }, this._pingInterval);
         return resolve();
@@ -149,8 +152,6 @@ export default class WebSocketProtocol extends BaseProtocolRealtime {
           error.status = status;
           this.clientNetworkError(error);
         }
-        clearInterval(this.pingIntervalId);
-        clearTimeout(this.pongTimeoutId);
       };
 
       this.client.onerror = error => {
@@ -219,6 +220,25 @@ export default class WebSocketProtocol extends BaseProtocolRealtime {
     }
   }
 
+  /**
+   * @override
+   */
+  clientDisconnected() {
+    clearInterval(this.pingIntervalId);
+    clearTimeout(this.pongTimeoutId);
+    super.clientDisconnected();
+  }
+
+  /**
+   * @override
+   *
+   * @param {Error} error
+   */
+  clientNetworkError (error) {
+    clearInterval(this.pingIntervalId);
+    clearTimeout(this.pongTimeoutId);
+    super.clientNetworkError(error);
+  }
   /**
    * Closes the connection
    */

src/protocols/WebSocket.ts

@@ -5,21 +5,15 @@ import { KuzzleAbstractProtocol } from './Base';
 export abstract class BaseProtocolRealtime extends KuzzleAbstractProtocol {
   protected _autoReconnect: boolean;
   protected _reconnectionDelay: number;
-  protected _pingInterval: number;
-  protected _pongTimeout: number;
   protected wasConnected: boolean;
   protected stopRetryingToConnect: boolean;
   protected retrying: boolean;
-  protected pongTimeoutId: ReturnType<typeof setTimeout>;
-  protected pingIntervalId: ReturnType<typeof setInterval>;
 
   constructor (host, options: any = {}, name: string) {
     super(host, options, name);
 
     this._autoReconnect = typeof options.autoReconnect === 'boolean' ? options.autoReconnect : true;
     this._reconnectionDelay = typeof options.reconnectionDelay === 'number' ? options.reconnectionDelay : 1000;
-    this._pingInterval = typeof options.pingInterval === 'number' ? options.pingInterval : 2000;
-    this._pongTimeout = this._pingInterval;
 
     this.wasConnected = false;
     this.stopRetryingToConnect = false;

src/protocols/abstract/Realtime.ts

@@ -127,6 +127,45 @@ describe('WebSocket networking module', () => {
     should(cb).be.calledOnce();
   });
 
+  it('should clear pongTimeout and pingInterval on a networkError', () => {
+    const cb = sinon.stub();
+    const clearTimeout = sinon.stub(clock, 'clearTimeout');
+    const clearInterval = sinon.stub(clock, 'clearInterval');
+    
+    websocket.retrying = false;
+    websocket.addListener('networkError', cb);
+    should(websocket.listeners('networkError').length).be.eql(1);
+
+    websocket.connect();
+    websocket.connect = sinon.stub().rejects();
+    clientStub.onopen();
+    clientStub.onerror();
+    should(clearTimeout)
+      .be.calledOnce();
+    should(clearInterval)
+      .be.calledOnce();
+  });
+
+  it('should clear pongTimeout and pingInterval when the connection closes', () => {
+    const cb = sinon.stub();
+    const clearTimeout = sinon.stub(clock, 'clearTimeout');
+    const clearInterval = sinon.stub(clock, 'clearInterval');
+    
+    websocket.retrying = false;
+    websocket.addListener('disconnect', cb);
+    should(websocket.listeners('disconnect').length).be.eql(1);
+
+    websocket.connect();
+    websocket.connect = sinon.stub().resolves();
+    clientStub.onopen();
+    clientStub.onclose(1000);
+    websocket.close();
+    should(clearTimeout)
+      .be.calledOnce();
+    should(clearInterval)
+      .be.calledOnce();
+  });
+  
   it('should try to reconnect on a connection error with autoReconnect = true', () => {
     const cb = sinon.stub();