more

Author: cirospaciari

src/js/node/_http_outgoing.ts

@@ -492,6 +492,16 @@ const OutgoingMessagePrototype = {
   end(_chunk, _encoding, _callback) {
     return this;
   },
+  get writableCorked() {
+    return this.socket.writableCorked;
+  },
+  set writableCorked(value) {},
+  cork() {
+    this.socket.cork();
+  },
+  uncork() {
+    this.socket.uncork();
+  },
   destroy(_err?: Error) {
     if (this.destroyed) return this;
     const handle = this[kHandle];

src/js/node/_http_server.ts

@@ -510,6 +510,7 @@ const ServerResponsePrototype = {
       handle.abort();
     }
     this?.socket?.destroy();
+    this.emit("close");
     return this;
   },
 

test/js/node/test/parallel/test-http-response-close.js

@@ -0,0 +1,102 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+{
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.writeHead(200);
+      res.write('a');
+    })
+  );
+  server.listen(
+    0,
+    common.mustCall(() => {
+      http.get(
+        { port: server.address().port },
+        common.mustCall((res) => {
+          res.on('data', common.mustCall(() => {
+            res.destroy();
+          }));
+          assert.strictEqual(res.destroyed, false);
+          res.on('close', common.mustCall(() => {
+            assert.strictEqual(res.destroyed, true);
+            server.closeAllConnections();
+          }));
+        })
+      );
+    })
+  );
+}
+
+{
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.writeHead(200);
+      res.end('a');
+    })
+  );
+  server.listen(
+    0,
+    common.mustCall(() => {
+      http.get(
+        { port: server.address().port },
+        common.mustCall((res) => {
+          assert.strictEqual(res.destroyed, false);
+          res.on('end', common.mustCall(() => {
+            assert.strictEqual(res.destroyed, false);
+          }));
+          res.on('close', common.mustCall(() => {
+            assert.strictEqual(res.destroyed, true);
+            server.close();
+          }));
+          res.resume();
+        })
+      );
+    })
+  );
+}
+
+{
+  const server = http.createServer(
+    common.mustCall((req, res) => {
+      res.on('close', common.mustCall());
+      res.destroy();
+    })
+  );
+
+  server.listen(
+    0,
+    common.mustCall(() => {
+      http.get(
+        { port: server.address().port },
+        common.mustNotCall()
+      )
+      .on('error', common.mustCall(() => {
+        server.close();
+      }));
+    })
+  );
+}

test/js/node/test/parallel/test-http-response-cork.js

@@ -0,0 +1,34 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+const server = http.createServer((req, res) => {
+  let corked = false;
+  const originalWrite = res.socket.write;
+  // This calls are not visible neither in the same quantity than node.js implementation
+  // res.socket.write = common.mustCall((...args) => {
+  //   assert.strictEqual(corked, false);
+  //   return originalWrite.call(res.socket, ...args);
+  // }, 5);
+  corked = true;
+  res.cork();
+  assert.strictEqual(res.writableCorked, res.socket.writableCorked);
+  res.cork();
+  assert.strictEqual(res.writableCorked, res.socket.writableCorked);
+  res.writeHead(200, { 'a-header': 'a-header-value' });
+  res.uncork();
+  assert.strictEqual(res.writableCorked, res.socket.writableCorked);
+  corked = false;
+  res.end('asd');
+  assert.strictEqual(res.writableCorked, res.socket.writableCorked);
+});
+
+server.listen(0, () => {
+  http.get({ port: server.address().port }, (res) => {
+    res.on('data', common.mustCall());
+    res.on('end', common.mustCall(() => {
+      server.close();
+    }));
+  });
+});

test/js/node/test/parallel/test-http-server-close-all.js

@@ -0,0 +1,61 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const { createServer } = require('http');
+const { connect } = require('net');
+
+let connections = 0;
+
+const server = createServer(common.mustCall(function(req, res) {
+  res.writeHead(200, { Connection: 'keep-alive' });
+  res.end();
+}, 2), {
+  headersTimeout: 0,
+  keepAliveTimeout: 0,
+  requestTimeout: common.platformTimeout(60000),
+});
+
+server.on('connection', function() {
+  connections++;
+});
+
+server.listen(0, function() {
+  const port = server.address().port;
+
+  // Create a first request but never finish it
+  const client1 = connect(port);
+
+  client1.on('connect', common.mustCall(() => {
+    // Create a second request, let it finish but leave the connection opened using HTTP keep-alive
+    const client2 = connect(port);
+    let response = '';
+
+    client2.setEncoding('utf8');
+
+    client2.on('data', common.mustCall((chunk) => {
+      response += chunk;
+
+      if (response.endsWith('0\r\n\r\n')) {
+        assert(response.startsWith('HTTP/1.1 200 OK\r\nConnection: keep-alive'));
+        assert.strictEqual(connections, 2);
+
+        server.closeAllConnections();
+        server.close(common.mustCall());
+
+        // This timer should never go off as the server.close should shut everything down
+        setTimeout(common.mustNotCall(), common.platformTimeout(1500)).unref();
+      }
+    }));
+
+    client2.on('close', common.mustCall());
+
+    client2.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n');
+  }));
+
+  client1.on('close', common.mustCall());
+
+  client1.on('error', () => {});
+
+  client1.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'); // Bun only reports connect after headers are received
+});