@@ -279,6 +279,8 @@ function initSocketHandle(self) {
279
279
const kBytesRead = Symbol ( 'kBytesRead' ) ;
280
280
const kBytesWritten = Symbol ( 'kBytesWritten' ) ;
281
281
const kSetNoDelay = Symbol ( 'kSetNoDelay' ) ;
282
+ const kSetKeepAlive = Symbol ( 'kSetKeepAlive' ) ;
283
+ const kSetKeepAliveInitialDelay = Symbol ( 'kSetKeepAliveInitialDelay' ) ;
282
284
283
285
function Socket ( options ) {
284
286
if ( ! ( this instanceof Socket ) ) return new Socket ( options ) ;
@@ -297,6 +299,15 @@ function Socket(options) {
297
299
'is not supported'
298
300
) ;
299
301
}
302
+ if ( typeof options ?. keepAliveInitialDelay !== 'undefined' ) {
303
+ validateNumber (
304
+ options ?. keepAliveInitialDelay , 'options.keepAliveInitialDelay'
305
+ ) ;
306
+
307
+ if ( options . keepAliveInitialDelay < 0 ) {
308
+ options . keepAliveInitialDelay = 0 ;
309
+ }
310
+ }
300
311
301
312
this . connecting = false ;
302
313
// Problem with this is that users can supply their own handle, that may not
@@ -307,7 +318,6 @@ function Socket(options) {
307
318
this [ kHandle ] = null ;
308
319
this . _parent = null ;
309
320
this . _host = null ;
310
- this [ kSetNoDelay ] = false ;
311
321
this [ kLastWriteQueueSize ] = 0 ;
312
322
this [ kTimeout ] = null ;
313
323
this [ kBuffer ] = null ;
@@ -381,6 +391,10 @@ function Socket(options) {
381
391
this [ kBufferCb ] = onread . callback ;
382
392
}
383
393
394
+ this [ kSetNoDelay ] = Boolean ( options . noDelay ) ;
395
+ this [ kSetKeepAlive ] = Boolean ( options . keepAlive ) ;
396
+ this [ kSetKeepAliveInitialDelay ] = ~ ~ ( options . keepAliveInitialDelay / 1000 ) ;
397
+
384
398
// Shut down the socket when we're finished with it.
385
399
this . on ( 'end' , onReadableStreamEnd ) ;
386
400
@@ -504,31 +518,38 @@ Socket.prototype._onTimeout = function() {
504
518
505
519
506
520
Socket . prototype . setNoDelay = function ( enable ) {
521
+ // Backwards compatibility: assume true when `enable` is omitted
522
+ enable = Boolean ( enable === undefined ? true : enable ) ;
523
+
507
524
if ( ! this . _handle ) {
508
- this . once ( 'connect' ,
509
- enable ? this . setNoDelay : ( ) => this . setNoDelay ( enable ) ) ;
525
+ this [ kSetNoDelay ] = enable ;
510
526
return this ;
511
527
}
512
528
513
- // Backwards compatibility: assume true when `enable` is omitted
514
- const newValue = enable === undefined ? true : ! ! enable ;
515
- if ( this . _handle . setNoDelay && newValue !== this [ kSetNoDelay ] ) {
516
- this [ kSetNoDelay ] = newValue ;
517
- this . _handle . setNoDelay ( newValue ) ;
529
+ if ( this . _handle . setNoDelay && enable !== this [ kSetNoDelay ] ) {
530
+ this [ kSetNoDelay ] = enable ;
531
+ this . _handle . setNoDelay ( enable ) ;
518
532
}
519
533
520
534
return this ;
521
535
} ;
522
536
523
537
524
- Socket . prototype . setKeepAlive = function ( setting , msecs ) {
538
+ Socket . prototype . setKeepAlive = function ( enable , initialDelayMsecs ) {
539
+ enable = Boolean ( enable ) ;
540
+ const initialDelay = ~ ~ ( initialDelayMsecs / 1000 ) ;
541
+
525
542
if ( ! this . _handle ) {
526
- this . once ( 'connect' , ( ) => this . setKeepAlive ( setting , msecs ) ) ;
543
+ this [ kSetKeepAlive ] = enable ;
544
+ this [ kSetKeepAliveInitialDelay ] = initialDelay ;
527
545
return this ;
528
546
}
529
547
530
- if ( this . _handle . setKeepAlive )
531
- this . _handle . setKeepAlive ( setting , ~ ~ ( msecs / 1000 ) ) ;
548
+ if ( this . _handle . setKeepAlive && enable !== this [ kSetKeepAlive ] ) {
549
+ this [ kSetKeepAlive ] = enable ;
550
+ this [ kSetKeepAliveInitialDelay ] = initialDelay ;
551
+ this . _handle . setKeepAlive ( enable , initialDelay ) ;
552
+ }
532
553
533
554
return this ;
534
555
} ;
@@ -1141,6 +1162,14 @@ function afterConnect(status, handle, req, readable, writable) {
1141
1162
}
1142
1163
self . _unrefTimer ( ) ;
1143
1164
1165
+ if ( self [ kSetNoDelay ] && self . _handle . setNoDelay ) {
1166
+ self . _handle . setNoDelay ( true ) ;
1167
+ }
1168
+
1169
+ if ( self [ kSetKeepAlive ] && self . _handle . setKeepAlive ) {
1170
+ self . _handle . setKeepAlive ( true , self [ kSetKeepAliveInitialDelay ] ) ;
1171
+ }
1172
+
1144
1173
self . emit ( 'connect' ) ;
1145
1174
self . emit ( 'ready' ) ;
1146
1175
@@ -1204,6 +1233,15 @@ function Server(options, connectionListener) {
1204
1233
} else {
1205
1234
throw new ERR_INVALID_ARG_TYPE ( 'options' , 'Object' , options ) ;
1206
1235
}
1236
+ if ( typeof options . keepAliveInitialDelay !== 'undefined' ) {
1237
+ validateNumber (
1238
+ options . keepAliveInitialDelay , 'options.keepAliveInitialDelay'
1239
+ ) ;
1240
+
1241
+ if ( options . keepAliveInitialDelay < 0 ) {
1242
+ options . keepAliveInitialDelay = 0 ;
1243
+ }
1244
+ }
1207
1245
1208
1246
this . _connections = 0 ;
1209
1247
@@ -1215,6 +1253,9 @@ function Server(options, connectionListener) {
1215
1253
1216
1254
this . allowHalfOpen = options . allowHalfOpen || false ;
1217
1255
this . pauseOnConnect = ! ! options . pauseOnConnect ;
1256
+ this . noDelay = Boolean ( options . noDelay ) ;
1257
+ this . keepAlive = Boolean ( options . keepAlive ) ;
1258
+ this . keepAliveInitialDelay = ~ ~ ( options . keepAliveInitialDelay / 1000 ) ;
1218
1259
}
1219
1260
ObjectSetPrototypeOf ( Server . prototype , EventEmitter . prototype ) ;
1220
1261
ObjectSetPrototypeOf ( Server , EventEmitter ) ;
@@ -1567,6 +1608,14 @@ function onconnection(err, clientHandle) {
1567
1608
writable : true
1568
1609
} ) ;
1569
1610
1611
+ if ( self . noDelay && handle . setNoDelay ) {
1612
+ handle . setNoDelay ( true ) ;
1613
+ }
1614
+
1615
+ if ( self . keepAlive && self . setKeepAlive ) {
1616
+ handle . setKeepAlive ( true , handle . keepAliveInitialDelay ) ;
1617
+ }
1618
+
1570
1619
self . _connections ++ ;
1571
1620
socket . server = self ;
1572
1621
socket . _server = self ;
0 commit comments