fulmine.js 5.19.2 → 5.19.4

package/src/cluster.js

@@ -16,16 +16,12 @@ limitations under the License.
 
 // express({ cluster: "auto" }): one process per core, all on the same port.
 //
-// A node process runs the application on one core, and the other fifteen sit there. The usual
-// answer is the cluster module, where the primary holds the listening socket and hands each
-// accepted connection to a worker over an IPC channel. µWS does not need that: it can bind with
-// the port marked shared, which is SO_REUSEPORT, and then every worker has its own listening
-// socket on the same port and the kernel picks which one gets each connection. No primary in the
-// path, no handle to pass, nothing serialised between processes.
+// The usual answer is the cluster module, where the primary holds the listening socket and passes
+// each accepted connection to a worker over IPC. uWS does not need that: it binds with the port
+// marked shared, which is SO_REUSEPORT, so every worker has its own listening socket on the same
+// port and the kernel picks who gets each connection. No primary in the path, nothing serialised.
 //
-// The flag has been passed for a while, see Application#listen: a worker binds shared and a lone
-// process binds exclusive. What was missing is the fork, which every application had to write for
-// itself, and an application that does not write it uses one core.
+// Application#listen already passes the flag. What was missing is the fork.
 
 "use strict";
 
@@ -54,8 +50,7 @@ function parallelism() {
  * The CPU quota a cgroup puts on this process, in cores, or undefined where there is none.
  *
  * This is the number that matters in a container: os.availableParallelism() reports the machine,
- * not the share of it the orchestrator gave away, so a 2-core pod on a 64-core node would fork 64
- * processes that fight over two cores. Both cgroup layouts are read, v2 first.
+ * so a 2-core pod on a 64-core node would fork 64 processes. Both cgroup layouts are read, v2 first.
  *
  * @param {(file: string) => string} [read] the file reader, for a test that has no cgroup
  * @returns {number|undefined}
@@ -103,8 +98,8 @@ function availableCores(read = readFile, cores = parallelism) {
  * How many workers a `cluster` setting asks for. Zero means the setting is off and the process
  * serves by itself, which is the default.
  *
- * A value nobody can read is a throw rather than a quiet zero: `cluster: "atuo"` running on one
- * core in production, with nothing said about it, is the failure this whole thing is against.
+ * A value nobody can read throws instead of quietly meaning zero: `cluster: "atuo"` would run on
+ * one core in production and say nothing about it.
  *
  * @param {boolean|number|"auto"|undefined} setting
  * @param {number} [cores] counted only when the setting asks for it: every application calls this,
@@ -124,9 +119,8 @@ function workerCount(setting, cores) {
     throw new TypeError(`cluster must be "auto", a boolean or a positive number, not ${JSON.stringify(setting)}`);
 }
 
-// Whether this process has forked workers, and so serves nothing itself. An application carries
-// the setting, but the answer is about the process: an entry with a second app on a TLS port would
-// otherwise bind that one here, exclusively, and every worker would fail on it.
+// Whether this process forked workers and serves nothing itself. About the process, not the app:
+// an entry with a second app on a TLS port would bind that one here and every worker would fail.
 let supervising = false;
 
 /**
@@ -141,9 +135,8 @@ function isSupervising() {
 /**
  * Says this process is the primary of a clustered application, before it has forked anything.
  *
- * Written when the application is constructed and not when it listens, because the order is the
- * application's to choose: an entry that listens on its TLS port first would otherwise have taken
- * that port here, exclusively, a line before the fork.
+ * Written when the application is constructed, not when it listens: an entry that listens on its
+ * TLS port first would take that port here, exclusively, one line before the fork.
  *
  * @returns {void}
  */
@@ -154,10 +147,8 @@ function becomeSupervisor() {
 /**
  * Forks the workers and keeps that many of them alive.
  *
- * A worker that dies is replaced, and there is nothing to rebuild when it comes back: it binds the
- * shared port again and the kernel starts handing it connections. A signal that reaches the
- * primary alone, which is what a container sends, is passed on rather than leaving the workers
- * running with nobody watching them.
+ * A dead worker is replaced and has nothing to rebuild, it binds the shared port again. A signal
+ * that reaches only the primary, which is what a container sends, is passed on to the workers.
  *
  * @param {number} count
  * @returns {{stop: () => void}}
@@ -165,7 +156,7 @@ function becomeSupervisor() {
 function forkWorkers(count) {
     let stopping = false;
     supervising = true;
-    /** @param {any} worker @param {number} code @param {string} signal */
+    /** @param {import("cluster").Worker} worker @param {number} code @param {string} signal */
     const onExit = (worker, code, signal) => {
         if (!stopping) {
             console.error(`worker ${worker.process.pid} exited (${signal || code}), starting another`);
@@ -181,14 +172,14 @@ function forkWorkers(count) {
         supervising = false;
         cluster.off("exit", onExit);
         for (const id of Object.keys(cluster.workers ?? {})) {
-            /** @type {any} */ (cluster.workers)[id]?.kill();
+            /** @type {NodeJS.Dict<import("cluster").Worker>} */ (cluster.workers)[id]?.kill();
         }
     };
     for (const signal of ["SIGTERM", "SIGINT"]) {
         process.on(signal, () => {
             stop();
-            // the primary exits on its own once the last IPC channel closes; this only makes sure
-            // it does, and being unref'd it never keeps the process up by itself
+            // the primary exits on its own once the last IPC channel closes, this only makes sure
+            // it does. Unref'd, so it never keeps the process up by itself
             const done = setInterval(() => {
                 if (Object.keys(cluster.workers ?? {}).length === 0) {
                     clearInterval(done);

package/src/compression.js

@@ -14,25 +14,29 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+/** @typedef {import("./request.js")} Request */
+/** @typedef {import("./response.js")} Response */
+/**
+ * What res.on was given, parked until there is a compressor to hang it on.
+ * @typedef {Parameters<import("stream").Writable["on"]>} OnArgs
+ */
+
 // express.compression(), which answers with a compressed body when the client asked for one.
 //
 // The options, the defaults and the order the decision is taken in are the compression module's,
-// so a front that already uses it can drop the require and change nothing else. Two things are
-// different, and both only ever turn a worse answer into a better one:
+// so a front that already uses it can drop the require and change nothing else. Three things are
+// different, and each one only turns a worse answer into a better one:
 //
 //   - a response that arrives whole, which is every res.send() and res.json(), is compressed in
-//     one call instead of through a transform stream, and goes out with a Content-Length. The
-//     bytes are the same bytes: zlib.gzipSync and a createGzip that receives the same body in one
-//     write produce the same deflate output.
-//   - partial content is left alone. The compression module compresses a 206 as well, and the
-//     result is a byte range of the file described as gzip, which no client can decode.
-//   - zstd is on offer, which the compression module cannot do at all. It is ranked below brotli,
-//     so a client that takes both is answered exactly as it was before, and above gzip, which it
-//     beats on ratio and on time. A Node whose zlib has no zstd never offers it.
+//     one call instead of through a transform stream, and goes out with a Content-Length. Same
+//     bytes: zlib.gzipSync and a createGzip fed the same body in one write agree.
+//   - partial content is left alone. The compression module compresses a 206 too, and the result
+//     is a byte range of the file described as gzip, which no client can decode.
+//   - zstd is on offer, which the compression module cannot do. Ranked below brotli and above
+//     gzip, so a client that takes both is answered as before. A Node with no zstd never offers it.
 //
-// The streaming half is the module's own design, because it is the right one: a transform stream,
-// its output written as it comes, and the drain listeners moved onto it so a pipe that fills up
-// hears from the compressor rather than from a socket that is no longer what it is waiting for.
+// The streaming half is the module's own design: a transform stream, its output written as it
+// comes, and the drain listeners moved onto it so a pipe that fills up hears from the compressor.
 
 "use strict";
 
@@ -46,7 +50,8 @@ const {
     ENCODING_GZIP,
     ENCODING_DEFLATE,
     ENCODING_ZSTD,
-    memoizeByString
+    memoizeByString,
+    applyWriteHead
 } = require("./utils.js");
 
 // zstd arrived in node's zlib during the range of versions this supports, so whether it can be
@@ -73,7 +78,7 @@ const NO_TRANSFORM = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
  * Says the answer depends on Accept-Encoding. res.vary() parses what is there and merges, which on
  * the usual response is parsing an absent header: only a response that already varies pays for it.
  *
- * @param {any} res
+ * @param {Response} res
  */
 function addVary(res) {
     if (res.getHeader("Vary") === undefined) {
@@ -95,30 +100,27 @@ if (HAS_ZSTD) {
     ENFORCEABLE.add("zstd");
 }
 
-// Up to this many bytes a whole body is compressed on this thread, and above it on the libuv pool.
-// One call either way; what changes is who waits. A small body pays more for the hop onto the pool
-// than the compression costs, and a large one is worth handing over, since the pool has four
-// threads and the loop has everyone else to serve: measured with gzip at the default level, sync
-// wins by 43% at 1.4KB and by 22% at 16KB, and loses by 32% at 32KB and by 90% at 78KB.
+// Up to this many bytes a whole body is compressed on this thread, above it on the libuv pool. One
+// call either way, what changes is who waits. Measured with gzip at the default level: sync wins by
+// 43% at 1.4KB and by 22% at 16KB, and loses by 32% at 32KB and by 90% at 78KB.
 const SYNC_LIMIT = 24 * 1024;
 
 const noop = () => {};
 
 /**
  * A whole-body compressor that keeps one stream instead of letting zlib build and throw one away
- * per call, which on a body under the sync limit costs more than the compression does. Same bytes,
- * a third of the time.
+ * per call, which under the sync limit costs more than the compression does. Same bytes, a third
+ * of the time.
  *
- * It is private node, and two things have to be held in place for it: close, because the FINISH
- * that ends the member would otherwise take the binding with it, and the handle, which that same
- * FINISH drops off the stream before returning. The probe then compresses each body twice and
- * gives the whole thing up unless every answer matches `oneShot` exactly, so a node that does any
- * of this differently gets the public API back and loses nothing but the speed.
+ * It is private node, and two things have to be held in place: close, because the FINISH that ends
+ * the member would take the binding with it, and the handle, which the same FINISH drops off the
+ * stream. The probe compresses each body twice and gives up unless every answer matches `oneShot`,
+ * so a node that does this differently gets the public API back.
  *
- * Only for the deflate formats. A brotli stream carries context across a reset and answers the
- * second body with bytes that depend on the first.
+ * Only for the deflate formats. A brotli stream carries context across a reset.
  *
- * @param {() => any} create
+ * @param {() => any} create makes the stream. Loose because what is checked below is node's zlib
+ *   internals, which its typings do not declare
  * @param {number} finishFlag
  * @param {(body: Buffer) => Buffer} oneShot
  * @returns {(body: Buffer) => Buffer}
@@ -200,8 +202,8 @@ function reusableCompressor(create, finishFlag, oneShot) {
  * The default filter: whether the content type is worth compressing at all. A response with no
  * type is left alone, since nothing says what its bytes are.
  *
- * @param {any} req
- * @param {any} res
+ * @param {Request} req
+ * @param {Response} res
  * @returns {boolean}
  */
 function shouldCompress(req, res) {
@@ -219,7 +221,7 @@ const isCompressible = memoizeByString((type) => compressible(type) === true);
 /**
  * How many bytes a chunk is, which is what the threshold is compared against.
  *
- * @param {any} chunk
+ * @param {any} chunk a body piece, in whatever shape the caller wrote it
  * @param {BufferEncoding} [encoding]
  * @returns {number}
  */
@@ -233,7 +235,7 @@ function chunkLength(chunk, encoding) {
 /**
  * The bytes of a chunk, whatever it arrived as.
  *
- * @param {any} chunk
+ * @param {any} chunk a body piece, in whatever shape the caller wrote it
  * @param {BufferEncoding} [encoding]
  * @returns {Buffer}
  */
@@ -255,7 +257,7 @@ function toBuffer(chunk, encoding) {
  * @param {object} [options]
  * @param {number|string} [options.threshold] the smallest body worth compressing, bytes or "1kb".
  *   Default 1024. A response whose size is not known in advance is compressed whatever its size.
- * @param {(req: any, res: any) => boolean} [options.filter] whether this response should be
+ * @param {(req: Request, res: Response) => boolean} [options.filter] whether this response should be
  *   compressed at all. The default says yes to any compressible content type.
  * @param {string} [options.enforceEncoding] what to use when the request carries no
  *   Accept-Encoding at all. Default "identity", which is to say nothing is compressed.
@@ -263,26 +265,26 @@ function toBuffer(chunk, encoding) {
  * @param {object} [options.zstd] zstd options, `params` included, node's own defaults otherwise.
  * @param {string[]} [options.encodings] the encodings this middleware may answer with, out of
  *   "br", "zstd", "gzip" and "deflate". What is not named is never used, however the client ranks
- *   it: a server that prefers cheap gzip over brotli passes ["gzip", "deflate"], one that would
- *   rather answer zstd than brotli passes ["zstd", "gzip"]. An uncompressed answer is always on
- *   offer, and enforceEncoding stays its own explicit choice, outside this list. This option is
- *   fulmine's own, the compression module has no equivalent.
+ *   it. An uncompressed answer is always on offer, and enforceEncoding is outside this list. This
+ *   option is fulmine's own, the compression module has no equivalent.
  * @param {number} [options.level] zlib compression level, for gzip and deflate.
  * @param {number} [options.chunkSize] zlib chunk size.
  * @param {number} [options.memLevel] zlib memory level.
  * @param {number} [options.strategy] zlib strategy.
  * @param {number} [options.windowBits] zlib window size.
- * @returns {(req: any, res: any, next: (err?: any) => void) => void} the middleware
+ * @returns {(req: any, res: any, next: (err?: unknown) => void) => void} the middleware. The pair is
+ *   loose because this is written against node's end() and write() shapes, which this project's
+ *   own narrow
  */
 function compression(options) {
     const opts = options || {};
     // the whole bag goes to zlib, as the compression module does: level, memLevel, strategy,
     // windowBits and chunkSize arrive under their own names and zlib ignores the rest
-    const zlibOptions = /** @type {any} */ (opts);
+    const zlibOptions = /** @type {import("zlib").ZlibOptions} */ (opts);
     const brotliOptions = { ...opts.brotli };
     brotliOptions.params = {
         [zlib.constants.BROTLI_PARAM_QUALITY]: 4,
-        ...(opts.brotli && /** @type {any} */ (opts.brotli).params)
+        ...(opts.brotli && /** @type {import("zlib").BrotliOptions} */ (opts.brotli).params)
     };
     // node's default level, unlike brotli above: zstd at its default is already in the band where
     // this middleware wants to be, and dropping it further buys nothing worth the ratio
@@ -291,7 +293,7 @@ function compression(options) {
     const enforceEncoding = opts.enforceEncoding || "identity";
     // bytes.parse reads "1kb" and hands back null for anything it cannot, an absent option
     // included, which is where the default comes in
-    const threshold = bytes.parse(/** @type {any} */ (opts.threshold)) ?? 1024;
+    const threshold = bytes.parse(/** @type {string|number} */ (opts.threshold)) ?? 1024;
     // the mask handed to the negotiation, built once here: a name nobody knows is a config
     // mistake and throws now rather than serving the wrong bytes later
     let allowed = ENCODING_DEFAULT;
@@ -368,7 +370,8 @@ function compression(options) {
 
     /**
      * @param {string} method
-     * @returns {any} the transform stream for a body that arrives in pieces
+     * @returns {import("stream").Transform & import("zlib").Zlib} the transform stream for a body that
+     *   arrives in pieces
      */
     function compressStream(method) {
         if (method === "gzip") {
@@ -384,14 +387,10 @@ function compression(options) {
     }
 
     return function compression(req, res, next) {
-        // Negotiated here rather than when the body arrives, because the answer to "could this
-        // request take a compressed body at all" decides how much of this middleware the response
-        // has to carry. Most requests to most routes cannot: a client that sent no Accept-Encoding,
-        // one that refused everything, a HEAD. Those get the Vary and nothing else, since the
-        // answer still depends on the header even when this particular client did not ask.
-        // straight from the raw entries where this request keeps them: reading req.headers here
-        // built the whole object for one name. Folded, so a repeated Accept-Encoding still reads
-        // as the joined list the headers object would have shown
+        // Negotiated here rather than when the body arrives: whether this request could take a
+        // compressed body at all decides how much of this middleware the response has to carry.
+        // Most requests cannot, and those get the Vary and nothing else. Read straight from the raw
+        // entries, folded: reading req.headers here built the whole object for one name
         const accept =
             typeof req._foldedHeader === "function"
                 ? req._foldedHeader("accept-encoding")
@@ -403,19 +402,32 @@ function compression(options) {
         if (!chosen || chosen === "identity" || req.method === "HEAD") {
             res.flush = noFlush;
             const _plainEnd = res.end;
+            const _plainWriteHead = res.writeHead;
             let varied = false;
-            res.end = function end(chunk, encoding, callback) {
-                if (!varied) {
-                    varied = true;
-                    const cacheControl = res.headersSent ? undefined : res.getHeader("Cache-Control");
-                    if (
-                        !res.headersSent &&
-                        filter(req, res) &&
-                        !(cacheControl && NO_TRANSFORM.test(String(cacheControl)))
-                    ) {
-                        addVary(res);
-                    }
+            /** Says the answer varies, once, before the head is settled. */
+            const vary = () => {
+                if (varied) {
+                    return;
+                }
+                varied = true;
+                const cacheControl = res.headersSent ? undefined : res.getHeader("Cache-Control");
+                if (
+                    !res.headersSent &&
+                    filter(req, res) &&
+                    !(cacheControl && NO_TRANSFORM.test(String(cacheControl)))
+                ) {
+                    addVary(res);
                 }
+            };
+            // writeHead settles the head, so a handler that calls it is answered there, with the
+            // headers it carries applied first, as on-headers orders it for the compression module
+            res.writeHead = function writeHead(statusCode, statusMessage, headers) {
+                const reason = applyWriteHead(this, statusMessage, headers);
+                vary();
+                return _plainWriteHead.call(this, statusCode, reason);
+            };
+            res.end = function end(chunk, encoding, callback) {
+                vary();
                 return _plainEnd.call(this, chunk, encoding, callback);
             };
             return next();
@@ -424,15 +436,18 @@ function compression(options) {
         const _write = res.write;
         const _end = res.end;
         const _on = res.on;
+        const _writeHead = res.writeHead;
 
         /** drain listeners parked until there is a compressor to hang them on, see res.on below */
-        let listeners = /** @type {any[][]|null} */ ([]);
-        /** @type {any} */
+        let listeners = /** @type {OnArgs[]|null} */ ([]);
+        /** @type {(import("stream").Transform & import("zlib").Zlib)|null} */
         let stream = null;
         let decided = false;
+        // the encoding decided on, "" for none; the compressor itself starts with the first byte
+        let method = "";
         let ended = false;
         /** what end() was given to call back, held until the compressor has finished */
-        let endCallback = /** @type {any} */ (undefined);
+        let endCallback = /** @type {(() => void)|undefined} */ (undefined);
 
         // the compression module adds this, and code written against it calls it: an SSE feed
         // pushes its event out with res.flush(). Nothing to flush before there is a compressor
@@ -458,10 +473,9 @@ function compression(options) {
         }
 
         /**
-         * Whether this response is compressed, and how. Taken once, when the first byte of the
-         * body arrives, which is also when the headers are decided: everything read here is set
-         * by then. The order is the compression module's, and so is the Vary, which is added even
-         * when the answer goes out uncompressed because the answer still depends on the header.
+         * Whether this response is compressed, and how. Taken once, when the first byte of body
+         * arrives, which is also when the headers are decided. The order is the compression
+         * module's, and so is the Vary, added even when the answer goes out uncompressed.
          *
          * @param {number} [length] the size of the body, when end() already has all of it
          * @returns {string} the encoding chosen, "" to send the body as it is
@@ -508,28 +522,39 @@ function compression(options) {
          * @param {string} method
          */
         function startStream(method) {
-            stream = compressStream(method);
+            // the closures below read the local: inside them the checker forgets the field is set
+            const compressor = (stream = compressStream(method));
             // The parked listeners, and the list itself stays rather than being emptied: res.on
-            // reads it to know that a drain listener belongs on the compressor from here on. That
-            // matters because a pipe registers its own the first time write() tells it to slow
-            // down, which is after this, and from here on the compressor is what fills up.
-            for (const listener of /** @type {any[][]} */ (listeners)) {
-                stream.on(listener[0], listener[1]);
+            // reads it to know a drain listener belongs on the compressor from here on. A pipe
+            // registers its own the first time write() says to slow down, which is after this
+            for (const listener of /** @type {OnArgs[]} */ (listeners)) {
+                compressor.on(listener[0], listener[1]);
             }
-            stream.on("data", (chunk) => {
+            compressor.on("data", (chunk) => {
                 if (_write.call(res, chunk) === false) {
-                    stream.pause();
+                    compressor.pause();
                 }
             });
-            stream.on("end", () => {
+            compressor.on("end", () => {
                 _end.call(res, endCallback);
             });
-            _on.call(res, "drain", () => stream.resume());
+            _on.call(res, "drain", () => compressor.resume());
             // an aborted response never reaches the end of the stream, and the zlib context behind
             // it is native memory that a garbage collector is in no hurry to reach
-            _on.call(res, "close", () => stream.destroy());
+            _on.call(res, "close", () => compressor.destroy());
         }
 
+        // writeHead settles the head, so the decision is taken there when a handler calls it, as
+        // on-headers takes it for the compression module: with the headers it carries applied
+        // first, since a Content-Length among them is what the decision removes
+        res.writeHead = function writeHead(statusCode, statusMessage, headers) {
+            const reason = applyWriteHead(this, statusMessage, headers);
+            if (!decided) {
+                method = decide();
+            }
+            return _writeHead.call(this, statusCode, reason);
+        };
+
         res.write = function write(chunk, encoding, callback) {
             if (typeof encoding === "function") {
                 callback = encoding;
@@ -539,10 +564,10 @@ function compression(options) {
                 return false;
             }
             if (!decided) {
-                const method = decide();
-                if (method) {
-                    startStream(method);
-                }
+                method = decide();
+            }
+            if (method && !stream) {
+                startStream(method);
             }
             if (stream) {
                 return stream.write(toBuffer(chunk, encoding), callback);
@@ -551,8 +576,7 @@ function compression(options) {
         };
 
         res.end = function end(chunk, encoding, callback) {
-            // node's shapes, of which this project's own end() takes (data, cb): the third
-            // argument only arrives from code written against node's ServerResponse
+            // node's shapes: the callback may sit in either position
             if (typeof chunk === "function") {
                 callback = chunk;
                 chunk = undefined;
@@ -564,6 +588,14 @@ function compression(options) {
             if (ended) {
                 return this;
             }
+            if (!decided) {
+                method = decide(chunkLength(chunk, encoding));
+            }
+            // a head settled by writeHead can no longer take the length the whole-body answer
+            // below sets, so the body goes out in pieces, as node's does after one
+            if (method && !stream && res.headersSent) {
+                startStream(method);
+            }
             if (stream) {
                 ended = true;
                 endCallback = callback;
@@ -574,32 +606,29 @@ function compression(options) {
                 }
                 return this;
             }
-            if (!decided) {
-                const method = decide(chunkLength(chunk, encoding));
-                if (method) {
-                    // the whole answer is here, so it is compressed in one call rather than
-                    // through a stream, and goes out with the length it ended up being
-                    ended = true;
-                    const input = toBuffer(chunk, encoding);
-                    if (input.length <= SYNC_LIMIT) {
-                        const body = compressWhole(method, input);
-                        res.setHeader("Content-Length", String(body.length));
-                        return _end.call(this, body, callback);
-                    }
-                    compressWholeAsync(method, input, (err, body) => {
-                        // the client can leave while the pool is working, and writing to a
-                        // response that is already gone is not something uWS survives
-                        if (res.aborted || res.finished) {
-                            return;
-                        }
-                        if (err) {
-                            return res.destroy(err);
-                        }
-                        res.setHeader("Content-Length", String(body.length));
-                        _end.call(res, body, callback);
-                    });
-                    return this;
+            if (method) {
+                // the whole answer is here, so it is compressed in one call rather than through a
+                // stream, and goes out with the length it ended up being
+                ended = true;
+                const input = toBuffer(chunk, encoding);
+                if (input.length <= SYNC_LIMIT) {
+                    const body = compressWhole(method, input);
+                    res.setHeader("Content-Length", String(body.length));
+                    return _end.call(this, body, callback);
                 }
+                compressWholeAsync(method, input, (err, body) => {
+                    // the client can leave while the pool is working, and writing to a response
+                    // that is already gone is not something uWS survives
+                    if (res.aborted || res.finished) {
+                        return;
+                    }
+                    if (err) {
+                        return res.destroy(err);
+                    }
+                    res.setHeader("Content-Length", String(body.length));
+                    _end.call(res, body, callback);
+                });
+                return this;
             }
             ended = true;
             return _end.call(this, chunk, callback);