Merge branch 'master' into breaking-changes

Author: mikuso

README.md

@@ -250,6 +250,7 @@ await cli.connect();
   - `protocols` {Array<String>} - Array of subprotocols supported by this server. Can be overridden in an [auth](#serverauthcallback) callback. Defaults to `[]`.
   - `callTimeoutMs` {Number} - Milliseconds to wait before unanswered outbound calls are rejected automatically. Defaults to `30000`.
   - `pingIntervalMs` {Number} - Milliseconds between WebSocket pings to connected clients. Defaults to `30000`.
+  - `deferPingsOnActivity` {Boolean} - Should connected clients skip sending pings if activity received? Defaults to `false`.
   - `respondWithDetailedErrors` {Boolean} - Specifies whether to send detailed errors (including stack trace) to remote party upon an error being thrown by a handler. Defaults to `false`.
   - `callConcurrency` {Number} - The number of concurrent in-flight outbound calls permitted at any one time. Additional calls are queued. (There is no limit on inbound calls.) Defaults to `1`.
   - `strictMode` {Boolean} - Enable strict validation of calls & responses. Defaults to `false`. (See [Strict Validation](#strict-validation) to understand how this works.)
@@ -388,6 +389,7 @@ Returns a `Promise` which resolves when the server has completed closing.
   - `query` {Object|String} - An optional query string or object to append as the query string of the connection URL. Defaults to `''`.
   - `callTimeoutMs` {Number} - Milliseconds to wait before unanswered outbound calls are rejected automatically. Defaults to `60000`.
   - `pingIntervalMs` {Number} - Milliseconds between WebSocket pings. Defaults to `30000`.
+  - `deferPingsOnActivity` {Boolean} - Should the client skip sending pings if activity received? Defaults to `false`.
   - `strictMode` {Boolean} - Enable strict validation of calls & responses. Defaults to `false`. (See [Strict Validation](#strict-validation) to understand how this works.)
   - `strictModeValidators` {Array<Validator>} - Optional additional validators to be used in conjunction with `strictMode`. (See [Strict Validation](#adding-additional-validation-schemas) to understand how this works.)
   - `respondWithDetailedErrors` {Boolean} - Specifies whether to send detailed errors (including stack trace) to remote party upon an error being thrown by a handler. Defaults to `false`.

lib/client.js

@@ -30,6 +30,7 @@ class RPCClient extends EventEmitter {
         this._keepAliveAbortController = undefined;
         this._pendingPingResponse = false;
         this._lastPingTime = 0;
+        this._skipNextPing = false;
         this._closePromise = undefined;
         this._protocolOptions = [];
         this._protocol = undefined;
@@ -51,6 +52,7 @@ class RPCClient extends EventEmitter {
             password: null,
             callTimeoutMs: 1000*60,
             pingIntervalMs: 1000*30,
+            deferPingsOnActivity: false,
             wsOpts: {},
             headers: {},
             protocols: [],
@@ -582,13 +584,18 @@ class RPCClient extends EventEmitter {
                     break;
                 }
 
+                if (this._skipNextPing) {
+                    this._skipNextPing = false;
+                    continue;
+                }
+
                 if (this._pendingPingResponse) {
                     // we didn't get a response to our last ping
                     throw Error("Ping timeout");
                 }
 
                 this._lastPingTime = Date.now();
-                this._pendingPingResponse = true;
+                this._pendingPingResponse = true;                
                 this._ws.ping();
             }
 
@@ -641,6 +648,10 @@ class RPCClient extends EventEmitter {
     }
 
     _onMessage(buffer) {
+        if (this._options.deferPingsOnActivity) {
+            this._skipNextPing = true;
+        }
+
         const message = buffer.toString('utf8');
 
         if (!message.length) {

lib/server.js

@@ -22,6 +22,7 @@ class RPCServer extends EventEmitter {
             protocols: [],
             callTimeoutMs: 1000*30,
             pingIntervalMs: 1000*30,
+            deferPingsOnActivity: false,
             respondWithDetailedErrors: false,
             callConcurrency: 1,
             maxBadMessages: Infinity,
@@ -231,6 +232,7 @@ class RPCServer extends EventEmitter {
                 reconnect: false,
                 callTimeoutMs: this._options.callTimeoutMs,
                 pingIntervalMs: this._options.pingIntervalMs,
+                deferPingsOnActivity: this._options.deferPingsOnActivity,
                 respondWithDetailedErrors: this._options.respondWithDetailedErrors,
                 callConcurrency: this._options.callConcurrency,
                 strictMode: this._options.strictMode,

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpp-rpc",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "A client & server implementation of the WAMP-like RPC-over-websocket system defined in the OCPP protcols (e.g. OCPP1.6-J and OCPP2.0.1).",
   "main": "index.js",
   "scripts": {

package.json

@@ -2471,6 +2471,77 @@ describe('RPCClient', function(){
 
         });
 
+
+        it('should skip pinging client if other activity received with option deferPingsOnActivity', async () => {
+            
+            let pings = 0;
+            const {endpoint, close, server} = await createServer({}, {
+                withClient: async (client) => {
+                    client.handle('Echo', async ({params}) => {
+                        return params;
+                    });
+                    for (let i = 0; i < 4; i++) {
+                        await cli.call('Echo', {});
+                        await setTimeout(25);
+                    }
+                    await client.close();
+                }
+            });
+            const cli = new RPCClient({
+                endpoint,
+                identity: 'X',
+                reconnect: false,
+                deferPingsOnActivity: true,
+                pingIntervalMs: 40
+            });
+
+            cli.on('ping', () => {++pings;});
+
+            try {
+                await cli.connect();
+                await once(cli, 'close');
+                assert.equal(pings, 0);
+            } finally {
+                await cli.close();
+                close();
+            }
+        });
+
+        it('should allow pinging client if other activity received without option deferPingsOnActivity', async () => {
+            
+            let pings = 0;
+            const {endpoint, close, server} = await createServer({}, {
+                withClient: async (client) => {
+                    client.handle('Echo', async ({params}) => {
+                        return params;
+                    });
+                    for (let i = 0; i < 4; i++) {
+                        await cli.call('Echo', {});
+                        await setTimeout(25);
+                    }
+                    await client.close();
+                }
+            });
+            const cli = new RPCClient({
+                endpoint,
+                identity: 'X',
+                reconnect: false,
+                deferPingsOnActivity: false,
+                pingIntervalMs: 40
+            });
+
+            cli.on('ping', () => {++pings;});
+
+            try {
+                await cli.connect();
+                await once(cli, 'close');
+                assert.ok(pings > 0);
+            } finally {
+                await cli.close();
+                close();
+            }
+        });
+
     });
 
 

test/client.js

@@ -767,6 +767,68 @@ describe('RPCServer', function(){
             }
         });
 
+        it('should skip pinging client if other activity received with option deferPingsOnActivity', async () => {
+            
+            let pings = 0;
+            const {endpoint, close, server} = await createServer({
+                pingIntervalMs: 40,
+                deferPingsOnActivity: true,
+            }, {
+                withClient: async (client) => {
+                    client.on('ping', () => {++pings;});
+                }
+            });
+            const cli = new RPCClient({
+                endpoint,
+                identity: 'X',
+                reconnect: false,
+            });
+
+            try {
+                await cli.connect();
+                for (let i = 0; i < 4; i++) {
+                    await cli.call('Echo', {});
+                    await setTimeout(25);
+                }
+                await cli.close();
+                assert.equal(pings, 0);
+            } finally {
+                await cli.close();
+                close();
+            }
+        });
+
+        it('should allow pinging client if other activity received without option deferPingsOnActivity', async () => {
+            
+            let pings = 0;
+            const {endpoint, close, server} = await createServer({
+                pingIntervalMs: 40,
+                deferPingsOnActivity: false,
+            }, {
+                withClient: async (client) => {
+                    client.on('ping', () => {++pings;});
+                }
+            });
+            const cli = new RPCClient({
+                endpoint,
+                identity: 'X',
+                reconnect: false,
+            });
+
+            try {
+                await cli.connect();
+                for (let i = 0; i < 4; i++) {
+                    await cli.call('Echo', {});
+                    await setTimeout(25);
+                }
+                await cli.close();
+                assert.ok(pings > 0);
+            } finally {
+                await cli.close();
+                close();
+            }
+        });
+
 
         it('should reject non-websocket requests with a 404', async () => {