function message(pattern, channel, message) {
if (stream.destroyed) return;
try {
message = JSON.parse(message);
} catch (e) {
return stream.emit('error',
new Error('Could not parse: "' + message + '".'));
}
stream.emit('log', message);
}
(function testMaxDataSize() {
var source = new Stream();
var delayedStream = DelayedStream.create(source, {maxDataSize: 1024, pauseStream: false});
source.emit('data', new Buffer(1024));
fake
.expect(delayedStream, 'emit')
.withArg(1, 'error');
source.emit('data', new Buffer(1));
fake.verify();
})();
return fs.read(fd, buffer, 0, buffer.length, pos, function(err, bytes) {
if (err) {
if (!callback) {
stream.emit('error', err);
} else {
callback(err);
}
stream.destroy();
return;
}
if (!bytes) {
if (buff) {
if (options.start == null || row > options.start) {
if (!callback) {
stream.emit('line', buff);
} else {
callback(null, buff);
}
}
row++;
buff = '';
}
return setTimeout(read, 1000);
}
var data = decode.write(buffer.slice(0, bytes));
if (!callback) {
stream.emit('data', data);
}
var data = (buff + data).split(/\n+/)
, l = data.length - 1
, i = 0;
for (; i < l; i++) {
if (options.start == null || row > options.start) {
if (!callback) {
stream.emit('line', data[i]);
} else {
callback(null, data[i]);
}
}
row++;
}
buff = data[l];
pos += bytes;
return read();
});
stream.destroy = common.tailFile(tail, function (err, line) {
if (err) {
return stream.emit('error', err);
}
try {
stream.emit('data', line);
line = JSON.parse(line);
stream.emit('log', line);
} catch (e) {
stream.emit('error', e);
}
});
req.on('data', function (data) {
var data = (buff + data).split(/\n+/),
l = data.length - 1,
i = 0;
for (; i < l; i++) {
try {
stream.emit('log', JSON.parse(data[i]));
} catch (e) {
stream.emit('error', e);
}
}
buff = data[l];
});
measurement.chrome.on('message', function(message) {
if (!running) return
message = JSON.parse(message)
if (!message.method || message.method.indexOf('Network.') !== 0) return
if (first) {
first = false
} else {
output.emit('data', ',\n')
}
output.emit('data', JSON.stringify(message))
})
req.on('data', data => {
data = (buff + data).split(/\n+/);
const l = data.length - 1;
let i = 0;
for (; i < l; i++) {
try {
stream.emit('log', JSON.parse(data[i]));
} catch (e) {
stream.emit('error', e);
}
}
buff = data[l];
});
this._pdfimages(function (pdfimages) {
if (!pdfimages[i]) {
stream.emit('error', new Error('Image ' + i + ' out of bounds.'));
return;
}
proxyStream(fs.createReadStream(pdfimages[i]), stream);
});
dtp.aggwalk(function (id, key, val) {
var data = {};
data.id = id;
data.key = key;
data.val = val;
stream.emit('data', JSON.stringify(data));
});
e.on('end', function () {
if(ended) return
ended = true
endCount ++
if(endCount == toMerge.length)
stream.emit('end')
})
// event emit function
function sendGCodeBlockData (igcodedata) {
//console.log("sendGCodeBlockData");
// checks if all queue lines were sent
if (igcodedata.sp_queue_current == igcodedata.sp_queue_total) {
igcodedata.sp_queue_total = 0,
igcodedata.sp_queue_current = 0;
//console.log('GCode ReadStream Resume\r\n');
//igcodedata.readablestream.resume();
//console.log('INPUTSTREAM->EMITDRAIN');
inputStream.emit('drain');
return;
}
//console.log('sendGCodeBlockData WriteSP: ', igcodedata.array_block[igcodedata.sp_queue_current]);
spWrite(igcodedata.array_block[igcodedata.sp_queue_current]);
igcodedata.sp_queue_current += 1;
// normal conditions: serialport (cnc/reprap/3dprinter) will responde 'ok' and sp.on("data"...) is triggered
// special condition: /dev/null needs to emulate serialport callback (using setTimeout for additional delay)
if (config.serialport.toUpperCase() === '/DEV/NULL') {
setTimeout(function () {
outputStream.emit('data', '<-ok\r\n\r\n');
console.log('SerialPort simulated callback response (/dev/null): ok\r\n');
// send event to trigger sendGCodeBlockData(..) function
evnt.emit('sendGCodeBlockData', igcodedata);
}, 10 /*250*/);
}
};
req.on('data', function (data) {
data = (buff + data).split(/\n+/)
var l = data.length - 1
var i = 0
for (; i < l; i++) {
try {
stream.emit('log', JSON.parse(data[i]))
} catch (e) {
stream.emit('error', e)
}
}
buff = data[l]
})
thepipe[func] = function () {
thepipe.emit(func)
if(reader[func])
return reader[func].apply(reader, arguments)
else
reader.emit(func)
}
}, function(err, results) {
if (stream.destroyed) return;
if (err) {
stream.emit('error', err);
return setTimeout(check, 2000);
}
var result = res[res.length-1];
if (result && result.timestamp) {
if (last == null) {
last = result.timestamp;
return;
}
last = result.timestamp;
} else {
return func();
}
results.forEach(function(log) {
if (start == null || row > start) {
stream.emit('log', log);
}
row++;
});
setTimeout(check, 2000);
});
setTimeout(function () {
outputStream.emit('data', '<-ok\r\n\r\n');
console.log('SerialPort simulated callback response (/dev/null): ok\r\n');
}, 10 );
connections[i].events.on('data', function(eventdata) {
if (newstream.impl.reading == true) {
newstream.emit('data', eventdata);
} else {
newstream.impl.queue.push(eventdata);
}
});
function(err, res)
{
if (err)
console.log('file.s3.write',err);
wstream.emit('close');
});
measurement.on('started', function() {
measurement.chrome.send({
method: 'Network.enable',
}, function(response) {
if (response.error) throw new Error('Couldn\'t enable network tracking.')
})
output.emit('data', '[\n')
measurement.chrome.on('message', function(message) {
if (!running) return
message = JSON.parse(message)
if (!message.method || message.method.indexOf('Network.') !== 0) return
if (first) {
first = false
} else {
output.emit('data', ',\n')
}
output.emit('data', JSON.stringify(message))
})
})
function queueData (data, number) {
var nextToWrite = lastWritten + 1
if (number === nextToWrite) {
// If it's next, and its not undefined write it
if (data !== undefined) {
stream.emit.apply(stream, ['data', data])
}
lastWritten ++
nextToWrite ++
} else {
// Otherwise queue it for later.
writeQueue[number] = data
}
// If the next value is in the queue, write it
if (writeQueue.hasOwnProperty(nextToWrite)) {
var dataToWrite = writeQueue[nextToWrite]
delete writeQueue[nextToWrite]
return queueData(dataToWrite, nextToWrite)
}
outputs ++
if(inputs === outputs) {
if(paused) paused = false, stream.emit('drain') //written all the incoming events
if(ended) end()
}
}
e.on('end', function() {
if (ended)
return;
ended = true;
endCount++;
if (endCount == toMerge.length)
stream.emit('end');
});
stream.destroy = function () {
if(destroyed) return
destroyed = true
ended = true
buffer.length = 0
stream.writable = stream.readable = false
stream.emit('close')
}
spawned.stdout.on("data", function(data) {
var len = data.length;
if (oddByte != null) {
sampleStream.emit("data", ((data.readInt8(i++, true) << 8) | oddByte) / 32767.0, channel);
channel = ++channel % channels;
}
for (var i = 0; i < len; i += 2) {
sampleStream.emit("data", data.readInt16LE(i, true) / 32767.0, channel);
channel = ++channel % channels;
}
oddByte = (i < len) ? data.readUInt8(i, true) : null;
});
tape('piping to a request object with invalid uri', function(t) {
var mybodydata = new stream.Stream()
mybodydata.readable = true
var r2 = request.put({
url: '/bad-uri',
json: true
}, function(err, res, body) {
t.ok(err instanceof Error)
t.equal(err.message, 'Invalid URI "/bad-uri"')
t.end()
})
mybodydata.pipe(r2)
mybodydata.emit('data', JSON.stringify({ foo: 'bar' }))
mybodydata.emit('end')
})
doHeader.call(this, tBuf, function (err, data, rOffset) {
if (err) {
if (rOffset === 0) {
return;
}
return this.cb(err);
}
// update total; rOffset should always be 512
totalRead += rOffset;
buffer = tBuf.slice(rOffset);
fileStream = new Stream();
if (this.fileTypes.indexOf(data.typeflag) >= 0) {
// we'll let the user know if they want this type of file
if (data.prefix) {
data.name = path.join(data.prefix, data.name);
}
data.typeflag = utils.getFileType(data.typeflag);
this.cb(err, data, fileStream);
}
if (buffer.length >= data.size) {
if (data.size > 0) {
fileStream.emit('data', buffer.slice(0, data.size));
totalRead += data.size;
buffer = buffer.slice(data.size);
}
fileStream.emit('end');
fileStream = undefined;
// recurse, we still have data
return write.call(this);
}
leftToRead = data.size - buffer.length;
if (buffer.length > 0) {
fileStream.emit('data', buffer);
totalRead += buffer.length;
}
buffer = undefined;
});
stream.raw = function (s) {
selectors.forEach(function (sel) {
sel.pending.forEach(function (p) {
p.buffered += s;
});
});
if (!updating) stream.emit('data', s);
};
function end (data) {
//if end was called with args, write it,
ended = true //write will emit 'end' if ended is true
stream.writable = false
if(data !== undefined)
return stream.write(data)
else if (inputs == outputs) //wait for processing
stream.readable = false, stream.emit('end'), stream.destroy()
}
}).on('end', function () {
if (str) {
stream.emit('data', {
type: 'string', x: (first || cmd).x, y: (first || cmd).y,
string: str, font: font, color: color
});
str = '';
}
});
this._send("UID FETCH " + uid + " BODY.PEEK["+section+"]", (function(status){
this._collectMailList = false;
this._literalStreaming = false;
if(!this._mailList.length){
if(status == "OK"){
stream.emit("error", new Error("Selected message not found: "+uid+"; "+this.port+"; "+this.host+"; "+JSON.stringify(this._selectedMailbox)));
}else{
stream.emit("error", new Error("Error fetching message: "+uid+"; "+this.port+"; "+this.host+"; "+JSON.stringify(this._selectedMailbox)));
}
}
this._messageStream.emit("end");
this._messageStream.removeAllListeners();
this._messageStream = null;
}).bind(this),
setTimeout(function () {
outputStream.emit('data', '<-ok\r\n\r\n');
console.log('SerialPort simulated callback response (/dev/null): ok\r\n');
// send event to trigger sendGCodeBlockData(..) function
evnt.emit('sendGCodeBlockData', igcodedata);
}, 10 /*250*/);
connections[i].events.on('end', function(eventdata) {
if (newstream.impl.queue.length > 0) {
for (var x = 0; x < newstream.impl.queue.length; x++) {
newstream.emit('data', newstream.impl.queue[x]);
}
newstream.impl.queue.length = 0;
}
newstream.emit('end');
newstream.impl.active = false;
newstream.impl.reading = false;
connections[i].reserved = false;
if (connections[i].terminate) {
map.emit(vocabulary.log, {timestamp: new Date(),
category: 'LOG',
message: 'Connection scheduled for termination, closing on completed stream.'});
library.closeconnection(i);
}
});