stream: fix end-of-stream for silent .destroy()

[tadjik1]

Each stream can get emitClose option which, when set
in false will prevent stream to emit close event in
case if .destroy() was called without error argument.

If this stream is passed as a last element in streams
aray in .pipeline() method it could lead to a problem
because end-of-stream won't be able to recognize that
stream has been ended.

For example:

const read = new Readable({
  read() {}
});

const write = new Writable({
  emitClose: false,
  write(data, enc, cb) {
    cb();
  }
});

setImmediate(() => read.destroy());

pipeline(read, write, (err) => {
  // this never be called because `write` won't emit 'close'
});

This can be fixed by checking if this option is
specified and overriding _destroy() method in order
to be aware of this method has been called.

Fixes: #26550

Checklist

• make -j4 test (UNIX), or vcbuild test (Windows) passes
• tests are included
• commit message follows commit guidelines

[mcollina]

cc @nodejs/streams

[tadjik1]

Similar to #24926

[mcollina]

I do not think this is the correct fix. We should not monkey patching the incoming stream. If the default implementation of destroy needs a change, let's do it there.

[tadjik1]

@mcollina do you think some private method like _onDestroy would make sense?

Or what you think is the best way to proceed with this and be notified when this silent destroy is happened?

[tadjik1]

I think that the main problem here is that currently it's allowed for stream to be silently destroyed, but we can not change this behaviour now, right?

[mcollina]

The stream should not be tampered with in any form apart from adding events. This is a hard rule, this function is not expected to alter the internals in the streams. We should also not rely on internals as much as possible, as "previous generation" streams could be passed inside these.

[tadjik1]

Ok, I can also think about introducing new “destroy” event which will be always emitted after “.destroy()” method.

Would it be the better way? My initial idea was to touch the smallest piece of code and functionality as possible. Each stream has “.destroy()” method so it seems natural to monkey patch it. In this way we don’t even need to introduce something new.

[mcollina]

end-of-stream cannot catch those because emitClose: false prevent them to be observable. That's the whole reason for that option - it's a "you should handle this yourself if you want to, these are dangerous waters" option. Now, the documentation might be improved..

[sam-github]

why does stdout set emitClose to false?

[mcollina]

net set it to false because it handles emit('close') in its own _destroy method. However in

node/lib/internal/process/stdio.js

Line 17 in 1cdeb9f

stdout._destroy = dummyDestroy;

we override _destroy, and that means 'close' is never emitted.
I have a PR coming.

[mcollina]

Generically a stream that sets emitClose: false is responsible for emitting close in user-logic.

[tadjik1]

yep, that sounds reasonable!

[mcollina]

@tadjik1 I would need to check bug in detail to see how to look for a different fix. It does not look like this should happen, as both finish and end events are emitted that should trigger the whole chain.

[tadjik1]

@mcollina absolutely! I left some tests so you can reproduce this bug.

Unfortunately “end” as well as “finish” events can not help in this case because they both mean that data was fully consumed, which is not the case when “.destroy()” called.

[tadjik1]

@mcollina consider this example:

const { Readable, finished } = require('stream');

const read = new Readable({
  emitClose: false,
  read() {},
  destroy(err, cb) {
    setTimeout(cb, 1000);
  }
});

setImmediate(() => read.destroy());

finished(read, (err) => {
  // this never be called
  console.log('done');
});

is this desired behaviour of finished or not?

[tadjik1]

not needed as of #26638 (comment)