http: add options to http.createServer()

This adds the optional options argument to `http.createServer()`. It contains two options: the `IncomingMessage` and `ServerReponse` option. PR-URL: #15752 Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Anatoli Papirovski <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Evan Lucas <[email protected]>

Author: Peter Marton

doc/api/http.md

@@ -1663,10 +1663,20 @@ A collection of all the standard HTTP response status codes, and the
 short description of each. For example, `http.STATUS_CODES[404] === 'Not
 Found'`.
 
-## http.createServer([requestListener])
+## http.createServer([options][, requestListener])
 <!-- YAML
 added: v0.1.13
--->
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/15752
+ description: The `options` argument is supported now.
+-->
+-`options`{Object}
+*`IncomingMessage`{http.IncomingMessage} Specifies the IncomingMessage class
+ to be used. Useful for extending the original `IncomingMessage`. Defaults
+ to: `IncomingMessage`
+*`ServerResponse`{http.ServerResponse} Specifies the ServerResponse class to
+ be used. Useful for extending the original `ServerResponse`. Defaults to:
+`ServerResponse`
 -`requestListener`{Function}
 
 * Returns:{http.Server}

doc/api/https.md

@@ -65,7 +65,8 @@ See [`http.Server#keepAliveTimeout`][].
 <!-- YAML
 added: v0.3.4
 -->
--`options`{Object} Accepts `options` from [`tls.createServer()`][] and [`tls.createSecureContext()`][].
+-`options`{Object} Accepts `options` from [`tls.createServer()`][],
+[`tls.createSecureContext()`][] and [`http.createServer()`][].
 -`requestListener`{Function} A listener to be added to the `request` event.
 
 Example:
@@ -258,6 +259,7 @@ const req = https.request(options, (res) =>{
 [`http.Server#setTimeout()`]: http.html#http_server_settimeout_msecs_callback
 [`http.Server#timeout`]: http.html#http_server_timeout
 [`http.Server`]: http.html#http_class_http_server
+[`http.createServer()`]: http.html#httpcreateserveroptions-requestlistener
 [`http.close()`]: http.html#http_server_close_callback
 [`http.get()`]: http.html#http_http_get_options_callback
 [`http.request()`]: http.html#http_http_request_options_callback

lib/_http_common.js

@@ -34,6 +34,7 @@ const{
 
 constdebug=require('util').debuglog('http');
 
+constkIncomingMessage=Symbol('IncomingMessage');
 constkOnHeaders=HTTPParser.kOnHeaders|0;
 constkOnHeadersComplete=HTTPParser.kOnHeadersComplete|0;
 constkOnBody=HTTPParser.kOnBody|0;
@@ -73,7 +74,11 @@ function parserOnHeadersComplete(versionMajor, versionMinor, headers, method,
 parser._url='';
 }
 
-parser.incoming=newIncomingMessage(parser.socket);
+// Parser is also used by http client
+varParserIncomingMessage=parser.socket&&parser.socket.server ?
+parser.socket.server[kIncomingMessage] : IncomingMessage;
+
+parser.incoming=newParserIncomingMessage(parser.socket);
 parser.incoming.httpVersionMajor=versionMajor;
 parser.incoming.httpVersionMinor=versionMinor;
 parser.incoming.httpVersion=`${versionMajor}.${versionMinor}`;
@@ -300,5 +305,6 @@ module.exports ={
  freeParser,
  httpSocketSetup,
  methods,
- parsers
+ parsers,
+ kIncomingMessage
 };

lib/_http_server.js

@@ -33,6 +33,7 @@ const{
  continueExpression,
  chunkExpression,
  httpSocketSetup,
+ kIncomingMessage,
 _checkInvalidHeaderChar: checkInvalidHeaderChar
 }=require('_http_common');
 const{ OutgoingMessage }=require('_http_outgoing');
@@ -41,9 +42,12 @@ const{
  defaultTriggerAsyncIdScope,
  getOrSetAsyncId
 }=require('internal/async_hooks');
+const{ IncomingMessage }=require('_http_incoming');
 consterrors=require('internal/errors');
 constBuffer=require('buffer').Buffer;
 
+constkServerResponse=Symbol('ServerResponse');
+
 constSTATUS_CODES={
 100: 'Continue',
 101: 'Switching Protocols',
@@ -263,9 +267,19 @@ function writeHead(statusCode, reason, obj){
 // Docs-only deprecated: DEP0063
 ServerResponse.prototype.writeHeader=ServerResponse.prototype.writeHead;
 
+functionServer(options,requestListener){
+if(!(thisinstanceofServer))returnnewServer(options,requestListener);
+
+if(typeofoptions==='function'){
+requestListener=options;
+options={};
+}elseif(options==null||typeofoptions==='object'){
+options=util._extend({},options);
+}
+
+this[kIncomingMessage]=options.IncomingMessage||IncomingMessage;
+this[kServerResponse]=options.ServerResponse||ServerResponse;
 
-functionServer(requestListener){
-if(!(thisinstanceofServer))returnnewServer(requestListener);
 net.Server.call(this,{allowHalfOpen: true});
 
 if(requestListener){
@@ -587,7 +601,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive){
 }
 }
 
-varres=newServerResponse(req);
+varres=newserver[kServerResponse](req);
 res._onPendingData=updateOutgoingData.bind(undefined,socket,state);
 
 res.shouldKeepAlive=keepAlive;
@@ -690,5 +704,6 @@ module.exports ={
 STATUS_CODES,
  Server,
  ServerResponse,
-_connectionListener: connectionListener
+_connectionListener: connectionListener,
+ kServerResponse
 };

lib/https.js

@@ -36,6 +36,9 @@ const{inherits } = util;
 constdebug=util.debuglog('https');
 const{ urlToOptions, searchParamsSymbol }=require('internal/url');
 consterrors=require('internal/errors');
+const{ IncomingMessage, ServerResponse }=require('http');
+const{ kIncomingMessage }=require('_http_common');
+const{ kServerResponse }=require('_http_server');
 
 functionServer(opts,requestListener){
 if(!(thisinstanceofServer))returnnewServer(opts,requestListener);
@@ -57,6 +60,9 @@ function Server(opts, requestListener){
 opts.ALPNProtocols=['http/1.1'];
 }
 
+this[kIncomingMessage]=opts.IncomingMessage||IncomingMessage;
+this[kServerResponse]=opts.ServerResponse||ServerResponse;
+
 tls.Server.call(this,opts,_connectionListener);
 
 this.httpAllowHalfOpen=false;

test/parallel/test-http-server-options-incoming-message.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * This test covers http.Server({IncomingMessage }) option:
+ * With IncomingMessage option the server should use
+ * the new class for creating req Object instead of the default
+ * http.IncomingMessage.
+ */
+constcommon=require('../common');
+constassert=require('assert');
+consthttp=require('http');
+
+classMyIncomingMessageextendshttp.IncomingMessage{
+getUserAgent(){
+returnthis.headers['user-agent']||'unknown';
+}
+}
+
+constserver=http.Server({
+IncomingMessage: MyIncomingMessage
+},common.mustCall(function(req,res){
+assert.strictEqual(req.getUserAgent(),'node-test');
+res.statusCode=200;
+res.end();
+}));
+server.listen();
+
+server.on('listening',functionmakeRequest(){
+http.get({
+port: this.address().port,
+headers: {
+'User-Agent': 'node-test'
+}
+},(res)=>{
+assert.strictEqual(res.statusCode,200);
+res.on('end',()=>{
+server.close();
+});
+res.resume();
+});
+});

test/parallel/test-http-server-options-server-response.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * This test covers http.Server({ServerResponse }) option:
+ * With ServerResponse option the server should use
+ * the new class for creating res Object instead of the default
+ * http.ServerResponse.
+ */
+constcommon=require('../common');
+constassert=require('assert');
+consthttp=require('http');
+
+classMyServerResponseextendshttp.ServerResponse{
+status(code){
+returnthis.writeHead(code,{'Content-Type': 'text/plain'});
+}
+}
+
+constserver=http.Server({
+ServerResponse: MyServerResponse
+},common.mustCall(function(req,res){
+res.status(200);
+res.end();
+}));
+server.listen();
+
+server.on('listening',functionmakeRequest(){
+http.get({port: this.address().port},(res)=>{
+assert.strictEqual(res.statusCode,200);
+res.on('end',()=>{
+server.close();
+});
+res.resume();
+});
+});

test/parallel/test-https-server-options-incoming-message.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * This test covers http.Server({IncomingMessage }) option:
+ * With IncomingMessage option the server should use
+ * the new class for creating req Object instead of the default
+ * http.IncomingMessage.
+ */
+constcommon=require('../common');
+constfixtures=require('../common/fixtures');
+
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+consthttp=require('http');
+consthttps=require('https');
+
+classMyIncomingMessageextendshttp.IncomingMessage{
+getUserAgent(){
+returnthis.headers['user-agent']||'unknown';
+}
+}
+
+constserver=https.createServer({
+key: fixtures.readKey('agent1-key.pem'),
+cert: fixtures.readKey('agent1-cert.pem'),
+ca: fixtures.readKey('ca1-cert.pem'),
+IncomingMessage: MyIncomingMessage
+},common.mustCall(function(req,res){
+assert.strictEqual(req.getUserAgent(),'node-test');
+res.statusCode=200;
+res.end();
+}));
+server.listen();
+
+server.on('listening',functionmakeRequest(){
+https.get({
+port: this.address().port,
+rejectUnauthorized: false,
+headers: {
+'User-Agent': 'node-test'
+}
+},(res)=>{
+assert.strictEqual(res.statusCode,200);
+res.on('end',()=>{
+server.close();
+});
+res.resume();
+});
+});

test/parallel/test-https-server-options-server-response.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * This test covers http.Server({ServerResponse }) option:
+ * With ServerResponse option the server should use
+ * the new class for creating res Object instead of the default
+ * http.ServerResponse.
+ */
+constcommon=require('../common');
+constfixtures=require('../common/fixtures');
+
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+consthttp=require('http');
+consthttps=require('https');
+
+classMyServerResponseextendshttp.ServerResponse{
+status(code){
+returnthis.writeHead(code,{'Content-Type': 'text/plain'});
+}
+}
+
+constserver=https.createServer({
+key: fixtures.readKey('agent1-key.pem'),
+cert: fixtures.readKey('agent1-cert.pem'),
+ca: fixtures.readKey('ca1-cert.pem'),
+ServerResponse: MyServerResponse
+},common.mustCall(function(req,res){
+res.status(200);
+res.end();
+}));
+server.listen();
+
+server.on('listening',functionmakeRequest(){
+https.get({
+port: this.address().port,
+rejectUnauthorized: false
+},(res)=>{
+assert.strictEqual(res.statusCode,200);
+res.on('end',()=>{
+server.close();
+});
+res.resume();
+});
+});