stream: do not flush destroyed writable

It doesn't make much sense to flush a stream which has been destroyed.
PR-URL: #29028
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

Author: ronag

lib/_stream_writable.js

@@ -299,9 +299,13 @@ Writable.prototype.write = function(chunk, encoding, cb) {
 if(typeofcb!=='function')
 cb=nop;
 
-if(state.ending)
+if(state.ending){
 writeAfterEnd(this,cb);
-elseif(isBuf||validChunk(this,state,chunk,cb)){
+}elseif(state.destroyed){
+consterr=newERR_STREAM_DESTROYED('write');
+process.nextTick(cb,err);
+errorOrDestroy(this,err);
+}elseif(isBuf||validChunk(this,state,chunk,cb)){
 state.pendingcb++;
 ret=writeOrBuffer(this,state,isBuf,chunk,encoding,cb);
 }
@@ -733,7 +737,21 @@ Object.defineProperty(Writable.prototype, 'writableFinished', {
 }
 });
 
-Writable.prototype.destroy=destroyImpl.destroy;
+constdestroy=destroyImpl.destroy;
+Writable.prototype.destroy=function(err,cb){
+conststate=this._writableState;
+if(!state.destroyed){
+for(letentry=state.bufferedRequest;entry;entry=entry.next){
+process.nextTick(entry.callback,newERR_STREAM_DESTROYED('write'));
+}
+state.bufferedRequest=null;
+state.lastBufferedRequest=null;
+state.bufferedRequestCount=0;
+}
+destroy.call(this,err,cb);
+returnthis;
+};
+
 Writable.prototype._undestroy=destroyImpl.undestroy;
 Writable.prototype._destroy=function(err,cb){
 cb(err);

test/parallel/test-http2-server-stream-session-destroy.js

@@ -39,7 +39,11 @@ server.on('stream', common.mustCall((stream) => {
 code: 'ERR_STREAM_WRITE_AFTER_END',
 message: 'write after end'
 }));
-assert.strictEqual(stream.write('data'),false);
+assert.strictEqual(stream.write('data',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_WRITE_AFTER_END',
+message: 'write after end'
+})),false);
 }));
 
 server.listen(0,common.mustCall(()=>{

test/parallel/test-stream-writable-destroy.js

@@ -232,3 +232,49 @@ const assert = require('assert');
 write._undestroy();
 write.end();
 }
+
+{
+constwrite=newWritable();
+
+write.destroy();
+write.on('error',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_DESTROYED',
+message: 'Cannot call write after a stream was destroyed'
+}));
+write.write('asd',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_DESTROYED',
+message: 'Cannot call write after a stream was destroyed'
+}));
+}
+
+{
+constwrite=newWritable({
+write(chunk,enc,cb){cb();}
+});
+
+write.on('error',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_DESTROYED',
+message: 'Cannot call write after a stream was destroyed'
+}));
+
+write.cork();
+write.write('asd',common.mustCall());
+write.uncork();
+
+write.cork();
+write.write('asd',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_DESTROYED',
+message: 'Cannot call write after a stream was destroyed'
+}));
+write.destroy();
+write.write('asd',common.expectsError({
+type: Error,
+code: 'ERR_STREAM_DESTROYED',
+message: 'Cannot call write after a stream was destroyed'
+}));
+write.uncork();
+}

test/parallel/test-stream-write-destroy.js

@@ -24,7 +24,16 @@ for (const withPendingData of [ false, true ]) {
 w.on('drain',()=>drains++);
 w.on('finish',()=>finished=true);
 
-w.write('abc',()=>chunksWritten++);
+functiononWrite(err){
+if(err){
+assert.strictEqual(w.destroyed,true);
+assert.strictEqual(err.code,'ERR_STREAM_DESTROYED');
+}else{
+chunksWritten++;
+}
+}
+
+w.write('abc',onWrite);
 assert.strictEqual(chunksWritten,0);
 assert.strictEqual(drains,0);
 callbacks.shift()();
@@ -34,14 +43,14 @@ for (const withPendingData of [ false, true ]) {
 if(withPendingData){
 // Test 2 cases: There either is or is not data still in the write queue.
 // (The second write will never actually get executed either way.)
-w.write('def',()=>chunksWritten++);
+w.write('def',onWrite);
 }
 if(useEnd){
 // Again, test 2 cases: Either we indicate that we want to end the
 // writable or not.
-w.end('ghi',()=>chunksWritten++);
+w.end('ghi',onWrite);
 }else{
-w.write('ghi',()=>chunksWritten++);
+w.write('ghi',onWrite);
 }
 
 assert.strictEqual(chunksWritten,1);