http: add writeFile to OutgoingMessage

[ronag]

Provide an optimized path for sending files over HTTP. Removes the entire memory and processing overhead of creating and operating an intermediate Readable.

[nodejs-github-bot]

Review requested:

• @nodejs/crypto
• @nodejs/http
• @nodejs/net
• @nodejs/startup
• @nodejs/streams

[ronag]

@nodejs/performance Could I maybe get some help with creating a relevant benchmark?

[rluvaton]

Also I'm not on Linux.

You can use docker and I'm pretty sure you can can also find the fd in Mac

Also, I'm pretty sure that we save file descriptors references in the fs file

[ronag]

Sorry, that kind of test is beyond me. If we have some existing test I can use as a reference I'm happy to add it. Otherwise, a follow-up PR is welcome. There are many other places that are similar that could also use such a test, e.g. file streams.

[RafaelGSS]

Can you add a test to the permission model? Just in case someone changes this implementation for a function that doesn't handle permissions.

[ronag]

Do you have any good tests I can look at for reference?

[anonrig]

I think this implementation should be done in C++. Performance wise this is not looking good.

[anonrig]

Suggested change

	### `outgoingMessage.sendFile(pahtOrFd, optsOrCallback, callbackOrNil)`
	### `outgoingMessage.sendFile(pathOrFd, optsOrCallback, callbackOrNil)`

[anonrig]

This line has missing toNamespacedPath

[ronag]

What's that? Also fs streams don't have any reference to toNamespacedPath? Is it missing there as well?

[anonrig]

I think this function should be implemented in C++. There are too many JS -> C++ boundary calls.

[ronag]

Follow up PR welcome 🙏

[jasnell]

There may be a challenge implementing this in c++ given how much of the implementation of OutgoingMessage is in JavaScript.

[anonrig]

The order of types and the descriptions are not same.

[jasnell]

Probably worthwhile for this to support FileHandle also.

[ronag]

There are some issues with filehandle I'd like to sort out before that.

[ronag]

I would recommend against using that api in general due to issue with how the reference counting behaves.

[jasnell]

This should also include tests verifying the function of start and end as well as input argument validation

[ronag]

I might have been a bit naive in how much effort this would take. Tests is half the job.

At this stage with no native implementation this is possible to just add in user space. Which is good enough for our use case.

[ronag]

Here is the user space implementation for those that want it:

function writeFile(fd, res, start, end, callback) {
  const hwm = res.writableHighWaterMark;

  let reading = false;
  let pos = start;
  let resume = null;
  let bytesWritten = 0;

  const finish = (err) => {
    if (resume != null) {
      res
        .off('drain', resume)
        .off('close', resume);
    }
    callback(err, bytesWritten);
  }

  const next = (err, bytesRead, buf) => {
    reading = false;
    if (pos !== undefined) {
      pos += bytesRead;
    }
    bytesWritten += bytesRead;

    buf = bytesRead === 0 ? null : bytesRead < buf.byteLength ? buf.subarray(0, bytesRead) : buf;

    const wState = res.socket && res.socket._writableState;

    if (res.destroyed) {
      finish(null);
    } else if (err && err.code === 'EAGAIN') {
      setImmediate(read);
    } else if (err || buf === null) {
      finish(err);
    } else if (res.write(buf)) {
      read();
    } else if (wState && wState.length - wState.writelen < hwm) {
      // In order to ensure we don't stall we need to continue
      // reading the file while the socket is writing.
      read();
    } else if (resume == null) {
      resume = read;
      res
        .on('drain', resume)
        .on('close', resume);
    }
  };

  const read = () => {
    if (reading) {
      return;
    }
    reading = true;

    const n = pos !== undefined ?
      Math.min(end - pos + 1, hwm) :
      Math.min(end - bytesWritten + 1, hwm);

    assert(n >= 0);

    if (res.destroyed) {
      finish(null);
    } else if (n === 0) {
      next(null, 0, null);
    } else {
      fs.read(fd, Buffer.allocUnsafe(n), 0, n, pos, next);
    }
  };

  read();
}