feat: reconfigurable pingIntervalMs. closes #4

Author: mikuso

lib/client.js

@@ -84,7 +84,7 @@ class RPCClient extends EventEmitter {
     }
 
     reconfigure(options) {
-        const newOpts = Object.assign({}, this._options, options);
+        const newOpts = Object.assign(this._options, options);
 
         if (!newOpts.identity) {
             throw Error(`'identity' is required`);
@@ -119,7 +119,9 @@ class RPCClient extends EventEmitter {
         this._callQueue.setConcurrency(newOpts.callConcurrency);
         this._backoffStrategy = new ExponentialStrategy(newOpts.backoff);
 
-        this._options = newOpts;
+        if ('pingIntervalMs' in options) {
+            this._keepAlive();
+        }
     }
 
     /**
@@ -348,8 +350,7 @@ class RPCClient extends EventEmitter {
             this.emit('ping', {rtt});
         });
 
-        this._keepAliveAbortController = new AbortController();
-        this._keepAlive(this._keepAliveAbortController.signal);
+        this._keepAlive();
 
         process.nextTick(() => {
             if (leadMsgBuffer) {
@@ -494,26 +495,42 @@ class RPCClient extends EventEmitter {
         return this._connectPromise;
     }
 
-    async _keepAlive(signal) {
+    async _keepAlive() {
+        // abort any previously running keepAlive
+        this._keepAliveAbortController?.abort();
+        
         try {
+            if (this._state !== OPEN) {
+                // don't start pinging if connection not open
+                return;
+            }
+
             if (!this._options.pingIntervalMs || this._options.pingIntervalMs <= 0 || this._options.pingIntervalMs > 2147483647) {
-                // don't ping
+                // don't ping for unusuable intervals
                 return;
             }
+            
+            // setup new abort controller
+            this._keepAliveAbortController = new AbortController();
 
-            for await (const _ of setInterval(this._options.pingIntervalMs, 1, {signal})) {
+            while (true) {
+                await setTimeout(this._options.pingIntervalMs, undefined, {signal: this._keepAliveAbortController.signal});
+                
                 if (this._state !== OPEN) {
-                    throw Error("Cannot ping while connection not open");
+                    // keepalive no longer required
+                    break;
                 }
+
                 if (this._pendingPingResponse) {
                     // we didn't get a response to our last ping
-                    this._ws.terminate();
-                    return;
+                    throw Error("Ping timeout");
                 }
+
                 this._lastPingTime = Date.now();
                 this._pendingPingResponse = true;
                 this._ws.ping();
             }
+
         } catch (err) {
             if (err.name !== 'AbortError') {
                 // throws on ws.ping() error

test/client.js

@@ -2247,6 +2247,38 @@ describe('RPCClient', function(){
 
         });
 
+        it("should be able to adjust ping interval", async () => {
+            
+            const {endpoint, close, server} = await createServer();
+            const cli = new RPCClient({
+                endpoint,
+                identity: 'X',
+                pingIntervalMs: 30,
+            });
+
+            try {
+                
+                await cli.connect();
+
+                const t1 = Date.now();
+                await once(cli, 'ping');
+                const r1 = Date.now() - t1;
+                
+                cli.reconfigure({pingIntervalMs: 10});
+
+                const t2 = Date.now();
+                await once(cli, 'ping');
+                const r2 = Date.now() - t2;
+
+                assert.ok(r1 > 20);
+                assert.ok(r2 < 20);
+
+            } finally {
+                await cli.close();
+                close();
+            }
+
+        });
 
     });