net: persist net.Socket options before connect

Remembers net.Socket options called before connect and retroactively
applies them after the handle has been created.

This change makes the following function calls more user-friendly:

- setKeepAlive()
- setNoDelay()
- ref()
- unref()

Related: nodejs/node-v0.x-archive#7077 and
nodejs/node-v0.x-archive#8572

lib/net.js

@@ -328,13 +328,23 @@ Socket.prototype._onTimeout = function() {
 
 
 Socket.prototype.setNoDelay = function(enable) {
+  if (!this._handle) {
+    this.once('connect', this.setNoDelay.bind(this, enable));
+    return;
+  }
+
   // backwards compatibility: assume true when `enable` is omitted
   if (this._handle && this._handle.setNoDelay)
     this._handle.setNoDelay(enable === undefined ? true : !!enable);
 };
 
 
 Socket.prototype.setKeepAlive = function(setting, msecs) {
+  if (!this._handle) {
+    this.once('connect', this.setKeepAlive.bind(this, setting, msecs));
+    return;
+  }
+
   if (this._handle && this._handle.setKeepAlive)
     this._handle.setKeepAlive(setting, ~~(msecs / 1000));
 };
@@ -957,14 +967,22 @@ Socket.prototype.connect = function(options, cb) {
 
 
 Socket.prototype.ref = function() {
-  if (this._handle)
-    this._handle.ref();
+  if (!this._handle) {
+    this.once('connect', this.ref);
+    return;
+  }
+
+  this._handle.ref();
 };
 
 
 Socket.prototype.unref = function() {
-  if (this._handle)
-    this._handle.unref();
+  if (!this._handle) {
+    this.once('connect', this.unref);
+    return;
+  }
+
+  this._handle.unref();
 };
 
 

test/parallel/test-net-persistent-keepalive.js

@@ -0,0 +1,32 @@
+var common = require('../common');
+var assert = require('assert');
+var net = require('net');
+
+var serverConnection;
+var echoServer = net.createServer(function(connection) {
+  serverConnection = connection;
+  connection.setTimeout(0);
+  assert.notEqual(connection.setKeepAlive, undefined);
+  connection.on('end', function() {
+    connection.end();
+  });
+});
+echoServer.listen(common.PORT);
+
+echoServer.on('listening', function() {
+  var clientConnection = new net.Socket();
+  // send a keepalive packet after 1000 ms
+  // and make sure it persists
+  clientConnection.setKeepAlive(true, 400);
+  clientConnection.connect(common.PORT);
+  clientConnection.setTimeout(0);
+
+  setTimeout(function() {
+    // make sure both connections are still open
+    assert.equal(serverConnection.readyState, 'open');
+    assert.equal(clientConnection.readyState, 'open');
+    serverConnection.end();
+    clientConnection.end();
+    echoServer.close();
+  }, 600);
+});

test/parallel/test-net-persistent-nodelay.js

@@ -0,0 +1,33 @@
+var common = require('../common');
+var assert = require('assert');
+var net = require('net');
+var TCPWrap = process.binding('tcp_wrap').TCP;
+
+var echoServer = net.createServer(function(connection) {
+  connection.end();
+});
+echoServer.listen(common.PORT);
+
+var setTrue = 0;
+
+var Socket = net.Socket;
+var setNoDelay = TCPWrap.prototype.setNoDelay;
+
+TCPWrap.prototype.setNoDelay = function(enable) {
+  setNoDelay.call(this, enable);
+  setTrue++;
+};
+
+echoServer.on('listening', function() {
+  var sock1 = new Socket();
+  // setNoDelay before the handle is created
+  // there is probably a better way to test this
+
+  sock1.setNoDelay();
+  sock1.connect(common.PORT);
+  sock1.on('end', process.exit);
+});
+
+process.on('exit', function() {
+  assert.ok(setTrue);
+});

test/parallel/test-net-persistent-ref-unref.js

@@ -0,0 +1,39 @@
+var common = require('../common');
+var assert = require('assert');
+var net = require('net');
+var TCPWrap = process.binding('tcp_wrap').TCP;
+
+var echoServer = net.createServer(function(conn) {
+  conn.end();
+});
+
+var ref = TCPWrap.prototype.ref;
+var unref = TCPWrap.prototype.unref;
+
+var refed = false;
+var unrefed = false;
+
+TCPWrap.prototype.ref = function() {
+  ref.call(this);
+  refed = true;
+};
+
+TCPWrap.prototype.unref = function() {
+  unref.call(this);
+  unrefed = true;
+};
+
+echoServer.listen(common.PORT);
+
+echoServer.on('listening', function() {
+  var sock = new net.Socket();
+  sock.unref();
+  sock.ref();
+  sock.connect(common.PORT);
+  sock.on('end', process.exit);
+});
+
+process.on('exit', function() {
+  assert.ok(refed);
+  assert.ok(unrefed);
+});