mirror of
https://github.com/nodejs/node.git
synced 2024-12-01 16:10:02 +01:00
98de4abae3
OS X has a tiny 1kb hard-coded buffer size for stdout / stderr to
TTYs (terminals). Output larger than that causes chunking, which ends
up having some (very small but existent) delay past the first chunk.
That causes two problems:
1. When output is written to stdout and stderr at similar times, the
two can become mixed together (interleaved). This is especially
problematic when using control characters, such as \r. With
interleaving, chunked output will often have lines or characters erased
unintentionally, or in the wrong spots, leading to broken output.
CLI apps often extensively use such characters for things such as
progress bars.
2. Output can be lost if the process is exited before chunked writes
are finished flushing. This usually happens in applications that use
`process.exit()`, which isn't infrequent.
See https://github.com/nodejs/node/issues/6980 for more info.
This became an issue as result of the Libuv 1.9.0 upgrade. A fix to
an unrelated issue broke a hack previously required for the OS X
implementation. This resulted in an unexpected behavior change in node.
The 1.9.0 upgrade was done in c3cec1eefc,
which was included in v6.0.0.
Full details of the Libuv issue that induced this are at
https://github.com/nodejs/node/issues/6456#issuecomment-219974514
Refs: https://github.com/nodejs/node/pull/1771
Refs: https://github.com/nodejs/node/issues/6456
Refs: https://github.com/nodejs/node/pull/6773
Refs: https://github.com/nodejs/node/pull/6816
PR-URL: https://github.com/nodejs/node/pull/6895
Reviewed-By: Rod Vagg <rod@vagg.org>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
107 lines
2.6 KiB
JavaScript
107 lines
2.6 KiB
JavaScript
'use strict';
|
|
|
|
const util = require('util');
|
|
const net = require('net');
|
|
const TTY = process.binding('tty_wrap').TTY;
|
|
const isTTY = process.binding('tty_wrap').isTTY;
|
|
const inherits = util.inherits;
|
|
const errnoException = util._errnoException;
|
|
|
|
|
|
exports.isatty = function(fd) {
|
|
return isTTY(fd);
|
|
};
|
|
|
|
|
|
function ReadStream(fd, options) {
|
|
if (!(this instanceof ReadStream))
|
|
return new ReadStream(fd, options);
|
|
|
|
options = util._extend({
|
|
highWaterMark: 0,
|
|
readable: true,
|
|
writable: false,
|
|
handle: new TTY(fd, true)
|
|
}, options);
|
|
|
|
net.Socket.call(this, options);
|
|
|
|
this.isRaw = false;
|
|
this.isTTY = true;
|
|
}
|
|
inherits(ReadStream, net.Socket);
|
|
|
|
exports.ReadStream = ReadStream;
|
|
|
|
ReadStream.prototype.setRawMode = function(flag) {
|
|
flag = !!flag;
|
|
this._handle.setRawMode(flag);
|
|
this.isRaw = flag;
|
|
};
|
|
|
|
|
|
function WriteStream(fd) {
|
|
if (!(this instanceof WriteStream)) return new WriteStream(fd);
|
|
net.Socket.call(this, {
|
|
handle: new TTY(fd, false),
|
|
readable: false,
|
|
writable: true
|
|
});
|
|
|
|
// Prevents interleaved stdout/stderr output in OS X terminals.
|
|
// As noted in the following reference, local TTYs tend to be quite fast and
|
|
// this behaviour has become expected due historical functionality on OS X,
|
|
// even though it was originally intended to change in v1.0.2 (Libuv 1.2.1).
|
|
// Ref: https://github.com/nodejs/node/pull/1771#issuecomment-119351671
|
|
if (process.platform === 'darwin') this._handle.setBlocking(true);
|
|
|
|
var winSize = [];
|
|
var err = this._handle.getWindowSize(winSize);
|
|
if (!err) {
|
|
this.columns = winSize[0];
|
|
this.rows = winSize[1];
|
|
}
|
|
}
|
|
inherits(WriteStream, net.Socket);
|
|
exports.WriteStream = WriteStream;
|
|
|
|
|
|
WriteStream.prototype.isTTY = true;
|
|
|
|
|
|
WriteStream.prototype._refreshSize = function() {
|
|
var oldCols = this.columns;
|
|
var oldRows = this.rows;
|
|
var winSize = [];
|
|
var err = this._handle.getWindowSize(winSize);
|
|
if (err) {
|
|
this.emit('error', errnoException(err, 'getWindowSize'));
|
|
return;
|
|
}
|
|
var newCols = winSize[0];
|
|
var newRows = winSize[1];
|
|
if (oldCols !== newCols || oldRows !== newRows) {
|
|
this.columns = newCols;
|
|
this.rows = newRows;
|
|
this.emit('resize');
|
|
}
|
|
};
|
|
|
|
|
|
// backwards-compat
|
|
WriteStream.prototype.cursorTo = function(x, y) {
|
|
require('readline').cursorTo(this, x, y);
|
|
};
|
|
WriteStream.prototype.moveCursor = function(dx, dy) {
|
|
require('readline').moveCursor(this, dx, dy);
|
|
};
|
|
WriteStream.prototype.clearLine = function(dir) {
|
|
require('readline').clearLine(this, dir);
|
|
};
|
|
WriteStream.prototype.clearScreenDown = function() {
|
|
require('readline').clearScreenDown(this);
|
|
};
|
|
WriteStream.prototype.getWindowSize = function() {
|
|
return [this.columns, this.rows];
|
|
};
|