diff --git a/lib/internal/streams/writable.js b/lib/internal/streams/writable.js index f8c61f819615..3f62489c0f70 100644 --- a/lib/internal/streams/writable.js +++ b/lib/internal/streams/writable.js @@ -503,14 +503,16 @@ function _write(stream, chunk, encoding, cb) { return writeOrBuffer(stream, state, chunk, encoding, cb); } -Writable.prototype.write = function(chunk, encoding, cb) { +function write(chunk, encoding, cb) { if (encoding != null && typeof encoding === 'function') { cb = encoding; encoding = null; } return _write(this, chunk, encoding, cb) === true; -}; +} + +Writable.prototype.write = write; Writable.prototype.cork = function() { const state = this._writableState; @@ -587,8 +589,10 @@ function writeOrBuffer(stream, state, chunk, encoding, callback) { } // Steady state of a flowing pipe into a byte-mode Writable: one Buffer, -// nothing queued, and no user write callback. Returns undefined when the -// caller must use write() instead. Otherwise the same boolean as write(). +// nothing queued, no user write callback, and write() not replaced. pipe() +// calls dest.write(), so a write() set on the instance, a subclass or the +// prototype has to run. Returns undefined when the caller must use write() +// instead. Otherwise the same boolean as write(). const kWriteFlowBlock = kObjectMode | kDestroyed | kErrored | kSync | kEnding | kFinished | kWriting | kCorked | kBuffered | kEnded | kNeedDrain | kWriteCb | kExpectWriteCb | kBufferProcessing | @@ -596,7 +600,8 @@ const kWriteFlowBlock = kObjectMode | kDestroyed | kErrored | kSync | function writeKnownBuffer(stream, chunk) { const state = stream._writableState; - if (state == null || state.length !== 0 || !(chunk instanceof Buffer)) + if (state == null || state.length !== 0 || !(chunk instanceof Buffer) || + stream.write !== write) return undefined; const bits = state[kState]; diff --git a/test/parallel/test-stream-pipe-replaced-write.js b/test/parallel/test-stream-pipe-replaced-write.js new file mode 100644 index 000000000000..ef65d453a486 --- /dev/null +++ b/test/parallel/test-stream-pipe-replaced-write.js @@ -0,0 +1,81 @@ +'use strict'; + +// pipe() calls dest.write(). The fast path of a flowing pipe must not go +// around a write() replaced on the instance, overridden in a subclass, as +// compression middleware does to the response it wraps, or patched on +// Writable.prototype, as APM tools do. + +const common = require('../common'); +const assert = require('assert'); +const { Readable, Writable } = require('stream'); + +const CHUNKS = 64; + +// Pushes from inside _read(), which is what lets the fast path take over. +function source() { + const data = Buffer.alloc(CHUNKS * 1024, 'a'); + let offset = 0; + return new Readable({ + read() { + if (offset >= data.length) { + this.push(null); + return; + } + this.push(data.subarray(offset, offset += 1024)); + }, + }); +} + +{ + const dest = new Writable({ + write(chunk, encoding, callback) { + callback(); + }, + }); + let calls = 0; + const write = dest.write; + dest.write = function(chunk, encoding, callback) { + calls++; + return write.call(this, chunk, encoding, callback); + }; + source().pipe(dest).on('finish', common.mustCall(() => { + assert.strictEqual(calls, CHUNKS); + })); +} + +{ + class Counting extends Writable { + calls = 0; + + write(chunk, encoding, callback) { + this.calls++; + return super.write(chunk, encoding, callback); + } + + _write(chunk, encoding, callback) { + callback(); + } + } + const dest = new Counting(); + source().pipe(dest).on('finish', common.mustCall(() => { + assert.strictEqual(dest.calls, CHUNKS); + })); +} + +{ + const dest = new Writable({ + write(chunk, encoding, callback) { + callback(); + }, + }); + const write = Writable.prototype.write; + let calls = 0; + Writable.prototype.write = function(chunk, encoding, callback) { + if (this === dest) calls++; + return write.call(this, chunk, encoding, callback); + }; + source().pipe(dest).on('finish', common.mustCall(() => { + Writable.prototype.write = write; + assert.strictEqual(calls, CHUNKS); + })); +}