Add timeout to requests

Author: andrewshell

config.js

@@ -20,7 +20,8 @@ nconf
         "MAX_CONSECUTIVE_ERRORS": 3,
         "MAX_RESOURCE_SIZE": 256000,
         "CT_SECS_RESOURCE_EXPIRE": 90000,
-        "MIN_SECS_BETWEEN_PINGS": 0
+        "MIN_SECS_BETWEEN_PINGS": 0,
+        "REQUEST_TIMEOUT": 4000
     });
 
 module.exports = {
@@ -32,5 +33,6 @@ module.exports = {
     maxConsecutiveErrors: nconf.get('MAX_CONSECUTIVE_ERRORS'),
     maxResourceSize: nconf.get('MAX_RESOURCE_SIZE'),
     ctSecsResourceExpire: nconf.get('CT_SECS_RESOURCE_EXPIRE'),
-    minSecsBetweenPings: nconf.get('MIN_SECS_BETWEEN_PINGS')
-};
+    minSecsBetweenPings: nconf.get('MIN_SECS_BETWEEN_PINGS'),
+    requestTimeout: nconf.get('REQUEST_TIMEOUT')
+};

services/notify-one-challenge.js

@@ -1,7 +1,8 @@
 (function () {
     "use strict";
 
-    const notifyOne = require('./notify-one'),
+    const config = require('../config'),
+        notifyOne = require('./notify-one'),
         getRandomPassword = require('./get-random-password'),
         querystring = require('querystring'),
         request = require('request-promise-native');
@@ -14,6 +15,7 @@
             }),
             res = await request({
                 uri: testUrl,
+                timeout: config.requestTimeout,
                 resolveWithFullResponse: true
             });
 

services/notify-one.js

@@ -2,12 +2,14 @@
     "use strict";
 
     const builder = require('xmlbuilder'),
+        config = require('../config'),
         request = require('request-promise-native');
 
     async function notifyOneRest(apiurl, resourceUrl) {
         const res = await request({
             method: 'POST',
             uri: apiurl,
+            timeout: config.requestTimeout,
             form: {
                 'url': resourceUrl
             },
@@ -36,6 +38,7 @@
         let res = await request({
             method: 'POST',
             uri: apiurl,
+            timeout: 4000,
             body: xmldoc,
             resolveWithFullResponse: true,
             headers: {

services/ping.js

@@ -33,6 +33,7 @@
             res = await request({
                 method: 'GET',
                 uri: resourceUrl,
+                timeout: config.requestTimeout,
                 followRedirect: true,
                 maxRedirects: 3,
                 resolveWithFullResponse: true

services/please-notify.js

@@ -17,6 +17,7 @@
         return request({
             method: 'GET',
             uri: resourceUrl,
+            timeout: config.requestTimeout,
             followRedirect: true,
             maxRedirects: 3,
             resolveWithFullResponse: true

test/ping.js

@@ -408,6 +408,71 @@ for (const pingProtocol of ['XML-RPC', 'REST']) {
             }
         });
 
+        it(`should consider a very slow subscription an error`, async function () {
+            const feedPath = '/rss.xml',
+                pingPath = '/feedupdated',
+                resourceUrl = mock.serverUrl + feedPath;
+
+            let apiurl = ('http-post' === protocol ? mock.serverUrl : mock.secureServerUrl) + pingPath,
+                notifyProcedure = false;
+
+            if ('xml-rpc' === protocol) {
+                apiurl = mock.serverUrl + '/RPC2';
+                notifyProcedure = 'river.feedUpdated';
+            }
+
+            function slowRestResponse(req) {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve('Thanks for the update! :-)');
+                    }, 8000)
+                });
+            }
+
+            function slowRpcResponse(req) {
+                return new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(rpcReturnSuccess(true));
+                    }, 8000)
+                });
+            }
+
+            mock.route('GET', feedPath, 200, '<RSS Feed />');
+            mock.route('POST', pingPath, 200, slowRestResponse);
+            mock.rpc(notifyProcedure, slowRpcResponse);
+            await mongodb.addSubscription(resourceUrl, notifyProcedure, apiurl, protocol);
+
+            let res = await ping(pingProtocol, resourceUrl, returnFormat);
+
+            expect(res).status(200);
+
+            const subscription = await mongodb.addSubscription(resourceUrl, notifyProcedure, apiurl, protocol);
+            expect(subscription.ctConsecutiveErrors).equal(1);
+
+            if ('XML-RPC' === pingProtocol) {
+                expect(res.text).xml.equal(rpcReturnSuccess(true));
+            } else {
+                if ('JSON' === returnFormat) {
+                    expect(res.body).deep.equal({ success: true, msg: 'Thanks for the ping.' });
+                } else {
+                    expect(res.text).xml.equal('<result success="true" msg="Thanks for the ping."/>');
+                }
+            }
+
+            expect(mock.requests.GET).property(feedPath).lengthOf(1, `Missing GET ${feedPath}`);
+
+            if ('xml-rpc' === protocol) {
+                expect(mock.requests.RPC2).property(notifyProcedure).lengthOf(1, `Missing XML-RPC call ${notifyProcedure}`);
+                expect(mock.requests.RPC2[notifyProcedure][0]).property('rpcBody');
+                expect(mock.requests.RPC2[notifyProcedure][0].rpcBody.params[0]).equal(resourceUrl);
+            } else {
+                expect(mock.requests.POST).property(pingPath).lengthOf(1, `Missing POST ${pingPath}`);
+                expect(mock.requests.POST[pingPath][0]).property('body');
+                expect(mock.requests.POST[pingPath][0].body).property('url');
+                expect(mock.requests.POST[pingPath][0].body.url).equal(resourceUrl);
+            }
+        });
+
     });
 
 } // end for pingProtocol