http: add optimizeEmptyRequests server option

Signed-off-by: RafaelGSS <[email protected]> Co-Authored-By: RafaelGSS <[email protected]> PR-URL: #59778 Reviewed-By: Robert Nagy <[email protected]> Reviewed-By: Tim Perry <[email protected]> Reviewed-By: Gerhard Stöbich <[email protected]> Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Yagiz Nizipli <[email protected]>

Author: RafaelGSS

doc/api/http.md

@@ -3555,6 +3555,9 @@ Found'`.
 <!-- YAML
 added: v0.1.13
 changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/59778
+ description: Add optimizeEmptyRequests option.
  - version: v24.9.0
  pr-url: https://github.com/nodejs/node/pull/59824
  description: The `shouldUpgradeCallback` option is now supported.
@@ -3660,6 +3663,11 @@ changes:
  * `rejectNonStandardBodyWrites`{boolean} If set to `true`, an error is thrown
  when writing to an HTTP response which does not have a body.
  **Default:** `false`.
+ * `optimizeEmptyRequests`{boolean} If set to `true`, requests without `Content-Length`
+ or `Transfer-Encoding` headers (indicating no body) will be initialized with an
+ already-ended body stream, so they will never emit any stream events
+ (like `'data'` or `'end'`). You can use `req.readableEnded` to detect this case.
+ **Default:** `false`.
 
 * `requestListener`{Function}
 

lib/_http_incoming.js

@@ -423,6 +423,15 @@ function _addHeaderLineDistinct(field, value, dest){
 }
 }
 
+IncomingMessage.prototype._dumpAndCloseReadable=function_dumpAndCloseReadable(){
+this._dumped=true;
+this._readableState.ended=true;
+this._readableState.endEmitted=true;
+this._readableState.destroyed=true;
+this._readableState.closed=true;
+this._readableState.closeEmitted=true;
+};
+
 
 // Call this instead of resume() if we want to just
 // dump all the data to /dev/null

lib/_http_server.js

@@ -107,6 +107,8 @@ const onResponseFinishChannel = dc.channel('http.server.response.finish');
 constkServerResponse=Symbol('ServerResponse');
 constkServerResponseStatistics=Symbol('ServerResponseStatistics');
 
+constkOptimizeEmptyRequests=Symbol('OptimizeEmptyRequestsOption');
+
 const{
  hasObserver,
  startPerf,
@@ -455,6 +457,11 @@ function storeHTTPOptions(options){
 validateInteger(maxHeaderSize,'maxHeaderSize',0);
 this.maxHeaderSize=maxHeaderSize;
 
+constoptimizeEmptyRequests=options.optimizeEmptyRequests;
+if(optimizeEmptyRequests!==undefined)
+validateBoolean(optimizeEmptyRequests,'options.optimizeEmptyRequests');
+this[kOptimizeEmptyRequests]=optimizeEmptyRequests||false;
+
 constinsecureHTTPParser=options.insecureHTTPParser;
 if(insecureHTTPParser!==undefined)
 validateBoolean(insecureHTTPParser,'options.insecureHTTPParser');
@@ -1069,6 +1076,10 @@ function emitCloseNT(self){
 }
 }
 
+functionhasBodyHeaders(headers){
+return('content-length'inheaders)||('transfer-encoding'inheaders);
+}
+
 // The following callback is issued after the headers have been read on a
 // new message. In this callback we setup the response object and pass it
 // to the user.
@@ -1120,6 +1131,19 @@ function parserOnIncoming(server, socket, state, req, keepAlive){
 });
 }
 
+// Check if we should optimize empty requests (those without Content-Length or Transfer-Encoding headers)
+constshouldOptimize=server[kOptimizeEmptyRequests]===true&&!hasBodyHeaders(req.headers);
+
+if(shouldOptimize){
+// Fast processing where emitting 'data', 'end' and 'close' events is
+// skipped and data is dumped.
+// This avoids a lot of unnecessary overhead otherwise introduced by
+// stream.Readable life cycle rules. The downside is that this will
+// break some servers that read bodies for methods that don't have body headers.
+req._dumpAndCloseReadable();
+req._read();
+}
+
 if(socket._httpMessage){
 // There are already pending outgoing res, append.
 state.outgoing.push(res);

test/parallel/test-http-server-optimize-empty-requests.js

@@ -0,0 +1,77 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+consthttp=require('http');
+constnet=require('net');
+
+letreqs=0;
+letoptimizedReqs=0;
+constserver=http.createServer({
+optimizeEmptyRequests: true
+},(req,res)=>{
+reqs++;
+if(req._dumped){
+optimizedReqs++;
+req.on('data',common.mustNotCall());
+req.on('end',common.mustNotCall());
+
+assert.strictEqual(req._dumped,true);
+assert.strictEqual(req.readableEnded,true);
+assert.strictEqual(req.destroyed,true);
+}
+res.writeHead(200);
+res.end('ok');
+});
+
+server.listen(0,common.mustCall(async()=>{
+// GET request without Content-Length (should be optimized)
+constgetRequest='GET / HTTP/1.1\r\nHost: localhost\r\n\r\n';
+awaitmakeRequest(getRequest);
+
+// HEAD request (should always be optimized regardless of headers)
+constheadRequest='HEAD / HTTP/1.1\r\nHost: localhost\r\n\r\n';
+awaitmakeRequest(headRequest);
+
+// POST request without body headers (should be optimized)
+constpostWithoutBodyHeaders='POST / HTTP/1.1\r\nHost: localhost\r\n\r\n';
+awaitmakeRequest(postWithoutBodyHeaders);
+
+// DELETE request without body headers (should be optimized)
+constdeleteWithoutBodyHeaders='DELETE / HTTP/1.1\r\nHost: localhost\r\n\r\n';
+awaitmakeRequest(deleteWithoutBodyHeaders);
+
+// POST request with Content-Length header (should not be optimized)
+constpostWithContentLength='POST / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n\r\n';
+awaitmakeRequest(postWithContentLength);
+
+// GET request with Content-Length header (should not be optimized)
+constgetWithContentLength='GET / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n\r\n';
+awaitmakeRequest(getWithContentLength);
+
+// POST request with Transfer-Encoding header (should not be optimized)
+constpostWithTransferEncoding='POST / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\n\r\n';
+awaitmakeRequest(postWithTransferEncoding);
+
+// GET request with Transfer-Encoding header (should not be optimized)
+constgetWithTransferEncoding='GET / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\n\r\n';
+awaitmakeRequest(getWithTransferEncoding);
+
+server.close();
+
+assert.strictEqual(reqs,8,`Expected 8 requests but got ${reqs}`);
+assert.strictEqual(optimizedReqs,4,`Expected 4 optimized requests but got ${optimizedReqs}`);
+}));
+
+functionmakeRequest(str){
+returnnewPromise((resolve)=>{
+constclient=net.connect({port: server.address().port},common.mustCall(()=>{
+client.on('data',()=>{});
+client.on('end',common.mustCall(()=>{
+resolve();
+}));
+client.write(str);
+client.end();
+}));
+});
+}