Merge pull request #172 from IanMcCurdy/tcpkeepalive

Add configurable TCP keepalive

Author: jeffalbion

README.md

@@ -23,6 +23,7 @@ Table of contents
 * [Transaction handling](#transaction-handling)
 * [Streaming Large Objects](#streaming-large-objects)
 * [CESU-8 encoding support](#cesu-8-encoding-support)
+* [TCP Keepalive](#tcp-keepalive)
 * [Running tests](#running-tests)
 * [Running examples](#running-examples)
 
@@ -586,6 +587,38 @@ This setting is per client and cannot be changed later.
 
 __Note:__ Using CESU-8 brings performance penalties proportionate to the text size that has to be converted.
 
+TCP Keepalive
+-------------
+
+To configure TCP keepalive behaviour, include the tcpKeepAliveIdle connect option. The value provided for this option is the number of seconds before an idle connection will begin sending keepalive packets. By default, TCP keepalive will be turned on with a value of 200 seconds. If a value of 0 is specified, keepalive behaviour is determined by the operating system.
+The following example creates a client whose connections will begin sending keepalive packets after 300 seconds.
+
+```js
+var hdb    = require('hdb');
+var client = hdb.createClient({
+  host             : 'hostname',
+  port             : 30015,
+  user             : 'user',
+  password         : 'secret',
+  tcpKeepAliveIdle : 300
+});
+
+```
+
+TCP keepalive can be explicity disabled by specifying tcpKeepAliveIdle=false as in the example below.
+
+```js
+var hdb    = require('hdb');
+var client = hdb.createClient({
+  host             : 'hostname',
+  port             : 30015,
+  user             : 'user',
+  password         : 'secret',
+  tcpKeepAliveIdle : false
+});
+
+```
+
 Running tests
 -------------
 

lib/protocol/tcp.js

@@ -15,6 +15,7 @@
 
 var net = require('net');
 var tls = require('tls');
+var defaultKeepAliveIdle = 200000; // milliseconds
 
 exports.createSocket = net.connect;
 exports.createSecureSocket = tls.connect;
@@ -32,5 +33,17 @@ exports.connect = function connect(options, cb) {
   }
   var socket = createSocket(options, cb);
   socket.setNoDelay(true);
+  var keepAliveIdle = defaultKeepAliveIdle;
+  var enableKeepAlive = true;
+  if ('tcpKeepAliveIdle' in options) {
+    var val = options['tcpKeepAliveIdle'];
+    if (val === false) {
+      enableKeepAlive = false;
+    } else {
+      keepAliveIdle = val * 1000;
+      if (isNaN(keepAliveIdle)) keepAliveIdle = defaultKeepAliveIdle;
+    }
+  }
+  socket.setKeepAlive(enableKeepAlive, keepAliveIdle);
   return socket;
 };

test/hdb.Client.js

@@ -227,6 +227,71 @@ describe('hdb', function () {
 
     });
 
+    describe('#TCP keepalive', function () {
+
+      var tcp = require('../lib/protocol/tcp');
+      var originalCreateSocket = tcp.createSocket;
+      var socketStub;
+
+      beforeEach(function () {
+        socketStub = new mock.createSocket({});
+        socketStub.setNoDelay = function () {
+          process.nextTick(function () {
+            socketStub.write();
+          });
+        };
+        tcp.createSocket = function () {
+            return socketStub;
+        };
+      });
+
+      afterEach(function () {
+        tcp.createSocket = originalCreateSocket;
+      });
+
+      it('should set tcpKeepAliveIdle by default', function (done) {
+        var client = new lib.Client({});
+        client.connect(function (err) {
+          should(client._connection._socket.keepAlive).be.true();
+          should(client._connection._socket.keepAliveIdle).be.equal(200000);
+          done();
+        });
+      });
+
+      it('should set tcpKeepAliveIdle via numeric connect option', function (done) {
+        var client = new lib.Client({
+          tcpKeepAliveIdle: 300
+        });
+        client.connect(function (err) {
+          should(client._connection._socket.keepAlive).be.true();
+          should(client._connection._socket.keepAliveIdle).be.equal(300000);
+          done();
+        });
+      });
+
+      it('should set tcpKeepAliveIdle via string connect option', function (done) {
+        var client = new lib.Client({
+          tcpKeepAliveIdle: '300'
+        });
+        client.connect(function (err) {
+          should(client._connection._socket.keepAlive).be.true();
+          should(client._connection._socket.keepAliveIdle).be.equal(300000);
+          done();
+        });
+      });
+
+      it('should disable tcp keepalive', function (done) {
+        var client = new lib.Client({
+          tcpKeepAliveIdle: false
+        });
+        client.connect(function (err) {
+          should(client._connection._socket.keepAlive).be.false();
+          done();
+        });
+      });
+
+    });
+
     it('should connect with saml assertion', function (done) {
       var client = new TestClient({
         assertion: 'assertion'
@@ -804,4 +869,4 @@ describe('hdb', function () {
     });
 
   });
-});
+});

test/lib.tcp.js

@@ -19,7 +19,8 @@ var createSecureSocket = tcp.createSecureSocket;
 var socket = {
   setNoDelay: function setNoDelay(noDelay) {
     noDelay.should.equal(true);
-  }
+  },
+  setKeepAlive: function setKeepAlive(enable, time) {}
 };
 
 describe('Lib', function () {

test/mock/MockSocket.js

@@ -25,6 +25,8 @@ function MockSocket(options) {
   this.writable = true;
   this.readable = true;
   this.delay = options.delay || 1;
+  this.keepAlive = false;
+  this.keepAliveIdle = 0;
   this.invalidInitializationReply = !!options.invalidInitializationReply;
   this.initializationErrorCode = options.initializationErrorCode;
   var chunk;
@@ -69,6 +71,15 @@ MockSocket.prototype.write = function write() {
   }, this.delay);
 };
 
+MockSocket.prototype.setKeepAlive = function setKeepAlive(enable, time) {
+  if (enable) {
+    this.keepAlive = true;
+    this.keepAliveIdle = time;
+  } else {
+    this.keepAlive = false;
+  }
+};
+
 Object.defineProperty(MockSocket.prototype, 'readyState', {
   get: function () {
     if (this.readable && this.writable) {