Socket
Socket
Sign inDemoInstall

handle-thing

Package Overview
Dependencies
0
Maintainers
2
Versions
11
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 1.2.5 to 2.0.0

536

lib/handle.js

@@ -1,437 +0,243 @@

var assert = require('assert');
var util = require('util');
var assert = require('assert')
var util = require('util')
var EventEmitter = require('events').EventEmitter;
var Buffer = require('buffer').Buffer;
var EventEmitter = require('events').EventEmitter
var Buffer = require('buffer').Buffer
var Queue = require('./queue');
var Queue = require('./queue')
// Node.js version
var mode = /^v0\.8\./.test(process.version) ? 'rusty' :
/^v0\.(9|10)\./.test(process.version) ? 'old' :
'modern';
var mode = 'modern'
function Handle(stream, options) {
EventEmitter.call(this);
function Handle (stream, options) {
EventEmitter.call(this)
this._stream = stream;
this._flowing = false;
this._reading = false;
this._options = options || {};
this._stream = stream
this._flowing = false
this._reading = false
this._options = options || {}
this.onread = null;
this.onread = null
// Pending requests
this.pending = new Queue();
this.pending = new Queue()
}
util.inherits(Handle, EventEmitter)
module.exports = Handle
// Start handle once `onread` is set
if (mode === 'rusty') {
var self = this;
Object.defineProperty(this, 'onread', {
set: function(value) {
Object.defineProperty(self, 'onread', {
value: value
});
process.nextTick(function() {
self.readStart();
});
}
});
}
Handle.mode = mode
// NOTE: v0.8 has some odd .pause()/.resume() semantics in http.js
if (mode === 'rusty')
this.writeQueueSize = 0;
else if (mode !== 'modern')
this.writeQueueSize = 1;
Handle.create = function create (stream, options) {
return new Handle(stream, options)
}
if (mode === 'rusty') {
if (this._stream)
this._rustyInit();
else
this.once('stream', this._rustyInit);
}
Handle.prototype._queueReq = function _queueReq (type, req) {
return this.pending.append(type, req)
}
util.inherits(Handle, EventEmitter);
module.exports = Handle;
Handle.mode = mode;
Handle.prototype._pendingList = function _pendingList () {
var list = []
while (!this.pending.isEmpty()) { list.push(this.pending.first().dequeue()) }
return list
}
Handle.create = function create(stream, options) {
return new Handle(stream, options);
};
Handle.prototype.setStream = function setStream (stream) {
assert(this._stream === null, 'Can\'t set stream two times')
this._stream = stream
Handle.prototype._queueReq = function _queueReq(type, req) {
return this.pending.append(type, req);
};
this.emit('stream', stream)
}
Handle.prototype._pendingList = function _pendingList() {
var list = [];
while (!this.pending.isEmpty())
list.push(this.pending.first().dequeue());
return list;
};
Handle.prototype.readStart = function readStart () {
this._reading = true
Handle.prototype.setStream = function setStream(stream) {
assert(this._stream === null, 'Can\'t set stream two times');
this._stream = stream;
this.emit('stream', stream);
};
Handle.prototype.readStart = function readStart() {
this._reading = true;
if (!this._stream) {
this.once('stream', this.readStart);
return 0;
this.once('stream', this.readStart)
return 0
}
if (!this._flowing) {
this._flowing = true;
this._flow();
this._flowing = true
this._flow()
}
this._stream.resume();
return 0;
};
this._stream.resume()
return 0
}
Handle.prototype.readStop = function readStop() {
this._reading = false;
Handle.prototype.readStop = function readStop () {
this._reading = false
if (!this._stream) {
this.once('stream', this.readStop);
return 0;
this.once('stream', this.readStop)
return 0
}
this._stream.pause();
return 0;
};
this._stream.pause()
return 0
}
if (mode === 'modern') {
var uv = process.binding('uv');
var uv = process.binding('uv')
Handle.prototype._flow = function flow() {
var self = this;
this._stream.on('data', function(chunk) {
self.onread(chunk.length, chunk);
});
Handle.prototype._flow = function flow () {
var self = this
this._stream.on('data', function (chunk) {
self.onread(chunk.length, chunk)
})
this._stream.on('end', function() {
self.onread(uv.UV_EOF, new Buffer(0));
});
this._stream.on('end', function () {
self.onread(uv.UV_EOF, Buffer.alloc(0))
})
this._stream.on('close', function() {
setImmediate(function() {
if (self._reading)
self.onread(uv.UV_ECONNRESET, new Buffer(0));
});
});
};
Handle.prototype._close = function _close() {
var list = this._pendingList();
var self = this;
setImmediate(function() {
for (var i = 0; i < list.length; i++) {
var req = list[i];
req.oncomplete(uv.UV_ECANCELED, self, req);
this._stream.on('close', function () {
setImmediate(function () {
if (self._reading) {
self.onread(uv.UV_ECONNRESET, Buffer.alloc(0))
}
});
this.readStop();
};
} else if (mode === 'old') {
Handle.prototype._flow = function flow() {
var self = this;
this._stream.on('data', function(chunk) {
self.onread(chunk, 0, chunk.length);
});
this._stream.on('end', function() {
var errno = process._errno;
process._errno = 'EOF';
self.onread(null, 0, 0);
if (process._errno === 'EOF')
process._errno = errno;
});
this._stream.on('close', function() {
setImmediate(function() {
if (!self._reading)
return;
var errno = process._errno;
process._errno = 'ECONNRESET';
self.onread(null, 0, 0);
if (process._errno === 'ECONNRESET')
process._errno = errno;
});
});
};
Handle.prototype._close = function _close() {
var list = this._pendingList();
var self = this;
setImmediate(function() {
for (var i = 0; i < list.length; i++) {
process._errno = 'CANCELED';
var req = list[i];
req.oncomplete(-1, self, req);
}
});
this.readStop();
};
} else {
Handle.prototype._rustyInit = function _rustyInit() {
var self = this;
this._stream.on('close', function() {
process.nextTick(function() {
if (!self._reading)
return;
var errno = global.errno;
global.errno = 'ECONNRESET';
self.onread(null, 0, 0);
if (global.errno === 'ECONNRESET')
global.errno = errno;
});
});
};
Handle.prototype._flow = function flow() {
var self = this;
this._stream.on('data', function(chunk) {
self.onread(chunk, 0, chunk.length);
});
this._stream.on('end', function() {
var errno = global.errno;
global.errno = 'EOF';
self.onread(null, 0, 0);
if (global.errno === 'EOF')
global.errno = errno;
});
};
Handle.prototype._close = function _close() {
var list = this._pendingList();
var self = this;
process.nextTick(function() {
for (var i = 0; i < list.length; i++) {
var req = list[i];
global.errno = 'CANCELED';
req.oncomplete(-1, self, req);
}
});
this.readStop();
};
})
})
}
if (mode === 'modern') {
Handle.prototype.shutdown = function shutdown(req) {
var wrap = this._queueReq('shutdown', req);
Handle.prototype._close = function _close () {
var list = this._pendingList()
if (!this._stream) {
this.once('stream', function() {
this._shutdown(wrap);
});
return 0;
var self = this
setImmediate(function () {
for (var i = 0; i < list.length; i++) {
var req = list[i]
req.oncomplete(uv.UV_ECANCELED, self, req)
}
})
return this._shutdown(wrap);
};
this.readStop()
}
Handle.prototype._shutdown = function _shutdown(wrap) {
var self = this;
this._stream.end(function() {
var req = wrap.dequeue();
if (!req)
return;
Handle.prototype.shutdown = function shutdown (req) {
var wrap = this._queueReq('shutdown', req)
req.oncomplete(0, self, req);
});
return 0;
};
} else {
Handle.prototype.shutdown = function shutdown(req) {
if (!req)
req = {};
if (!this._stream) {
this.once('stream', function () {
this._shutdown(wrap)
})
return 0
}
var wrap = this._queueReq('shutdown', req);
return this._shutdown(wrap)
}
if (!this._stream) {
this.once('stream', function() {
this._shutdown(wrap);
});
return req;
}
Handle.prototype._shutdown = function _shutdown (wrap) {
var self = this
this._stream.end(function () {
var req = wrap.dequeue()
if (!req) { return }
this._shutdown(wrap);
return req;
};
Handle.prototype._shutdown = function _shutdown(wrap) {
var self = this;
this._stream.end(function() {
var req = wrap.dequeue();
if (!req)
return;
req.oncomplete(0, self, req);
});
};
req.oncomplete(0, self, req)
})
return 0
}
if (mode !== 'rusty') {
Handle.prototype.close = function close(callback) {
this._close();
Handle.prototype.close = function close (callback) {
this._close()
if (!this._stream) {
this.once('stream', function() {
this.close(callback);
});
return 0;
}
if (!this._stream) {
this.once('stream', function () {
this.close(callback)
})
return 0
}
if (this._options.close)
this._options.close(callback);
else
process.nextTick(callback);
if (this._options.close) {
this._options.close(callback)
} else {
process.nextTick(callback)
}
return 0;
};
} else {
Handle.prototype.close = function close() {
this._close();
if (!this._stream)
this.once('stream', this.close);
else if (this._options.close)
this._options.close(function() {});
return 0;
};
return 0
}
if (mode === 'modern') {
Handle.prototype.writeEnc = function writeEnc(req, data, enc) {
var wrap = this._queueReq('write', req);
Handle.prototype.writeEnc = function writeEnc (req, data, enc) {
var wrap = this._queueReq('write', req)
if (!this._stream) {
this.once('stream', function() {
this._writeEnc(wrap, req, data, enc);
});
if (!this._stream) {
this.once('stream', function () {
this._writeEnc(wrap, req, data, enc)
})
return 0;
}
return 0
}
return this._writeEnc(wrap, req, data, enc);
};
return this._writeEnc(wrap, req, data, enc)
}
Handle.prototype._writeEnc = function _writeEnc(wrap, req, data, enc) {
var self = this;
Handle.prototype._writeEnc = function _writeEnc (wrap, req, data, enc) {
var self = this
req.async = true;
req.bytes = data.length;
req.async = true
req.bytes = data.length
if (wrap.isEmpty())
return 0;
if (wrap.isEmpty()) {
return 0
}
this._stream.write(data, enc, function() {
var req = wrap.dequeue();
if (!req)
return;
req.oncomplete(0, self, req);
});
this._stream.write(data, enc, function () {
var req = wrap.dequeue()
if (!req) { return }
req.oncomplete(0, self, req)
})
return 0;
};
} else {
Handle.prototype.writeEnc = function writeEnc(data, ignored, enc, req) {
if (!req)
req = { bytes: data.length };
return 0
}
var wrap = this._queueReq('write', req);
/**
* @param {WriteWrap} req
* @param {string[]} chunks
* @param {Boolean} allBuffers
*/
Handle.prototype.writev = function _writev (req, chunks, allBuffers) {
while (chunks.length > 0) {
this._stream.write(chunks.shift(), chunks.shift())
}
return 0
}
if (!this._stream) {
this.once('stream', function() {
this._writeEnc(data, ignored, enc, wrap);
});
return req;
}
Handle.prototype.writeBuffer = function writeBuffer (req, data) {
return this.writeEnc(req, data, null)
}
this._writeEnc(data, ignored, enc, wrap);
return req;
};
Handle.prototype.writeAsciiString = function writeAsciiString (req, data) {
return this.writeEnc(req, data, 'ascii')
}
Handle.prototype._writeEnc = function _writeEnc(data, ignored, enc, wrap) {
var self = this;
var buffer = new Buffer(data, enc);
Handle.prototype.writeUtf8String = function writeUtf8String (req, data) {
return this.writeEnc(req, data, 'utf8')
}
if (wrap.isEmpty())
return;
Handle.prototype.writeUcs2String = function writeUcs2String (req, data) {
return this.writeEnc(req, data, 'ucs2')
}
this._stream.write(buffer, function() {
var req = wrap.dequeue();
if (!req)
return;
req.oncomplete(0, self, req);
});
};
Handle.prototype.writeBinaryString = function writeBinaryString (req, data) {
return this.writeEnc(req, data, 'binary')
}
Handle.prototype.writeBuffer = function writeBuffer(req, data) {
return this.writeEnc(req, data, null);
};
Handle.prototype.writeLatin1String = function writeLatin1String (req, data) {
return this.writeEnc(req, data, 'binary')
}
Handle.prototype.writeAsciiString = function writeAsciiString(req, data) {
return this.writeEnc(req, data, 'ascii');
};
Handle.prototype.writeUtf8String = function writeUtf8String(req, data) {
return this.writeEnc(req, data, 'utf8');
};
Handle.prototype.writeUcs2String = function writeUcs2String(req, data) {
return this.writeEnc(req, data, 'ucs2');
};
Handle.prototype.writeBinaryString = function writeBinaryString(req, data) {
return this.writeEnc(req, data, 'binary');
};
Handle.prototype.writeLatin1String = function writeLatin1String(req, data) {
return this.writeEnc(req, data, 'binary');
};
// v0.8
Handle.prototype.getsockname = function getsockname() {
if (this._options.getPeerName)
return this._options.getPeerName();
return null;
};
Handle.prototype.getsockname = function getsockname () {
if (this._options.getPeerName) {
return this._options.getPeerName()
}
return null
}
if (mode === 'modern') {
Handle.prototype.getpeername = function getpeername(out) {
var res = this.getsockname();
if (!res)
return -1;
Handle.prototype.getpeername = function getpeername (out) {
var res = this.getsockname()
if (!res) { return -1 }
Object.keys(res).forEach(function(key) {
out[key] = res[key];
});
Object.keys(res).forEach(function (key) {
out[key] = res[key]
})
return 0;
};
} else {
// v0.10
Handle.prototype.getpeername = function getpeername() {
return this.getsockname();
};
return 0
}

74

lib/queue.js

@@ -1,48 +0,48 @@

function Queue() {
this.head = new Item('head', null);
function Queue () {
this.head = new Item('head', null)
}
module.exports = Queue;
module.exports = Queue
Queue.prototype.append = function append(kind, value) {
var item = new Item(kind, value);
this.head.prepend(item);
return item;
};
Queue.prototype.append = function append (kind, value) {
var item = new Item(kind, value)
this.head.prepend(item)
return item
}
Queue.prototype.isEmpty = function isEmpty() {
return this.head.prev === this.head;
};
Queue.prototype.isEmpty = function isEmpty () {
return this.head.prev === this.head
}
Queue.prototype.first = function first() {
return this.head.next;
};
Queue.prototype.first = function first () {
return this.head.next
}
function Item(kind, value) {
this.prev = this;
this.next = this;
this.kind = kind;
this.value = value;
function Item (kind, value) {
this.prev = this
this.next = this
this.kind = kind
this.value = value
}
Item.prototype.prepend = function prepend(other) {
other.prev = this.prev;
other.next = this;
other.prev.next = other;
other.next.prev = other;
};
Item.prototype.prepend = function prepend (other) {
other.prev = this.prev
other.next = this
other.prev.next = other
other.next.prev = other
}
Item.prototype.dequeue = function dequeue() {
var prev = this.prev;
var next = this.next;
Item.prototype.dequeue = function dequeue () {
var prev = this.prev
var next = this.next
prev.next = next;
next.prev = prev;
this.prev = this;
this.next = this;
prev.next = next
next.prev = prev
this.prev = this
this.next = this
return this.value;
};
return this.value
}
Item.prototype.isEmpty = function isEmpty() {
return this.prev === this;
};
Item.prototype.isEmpty = function isEmpty () {
return this.prev === this
}

23

package.json
{
"name": "handle-thing",
"version": "1.2.5",
"version": "2.0.0",
"description": "Wrap Streams2 instance into a HandleWrap",
"main": "lib/handle.js",
"scripts": {
"test": "mocha --reporter=spec test/*-test.js"
"lint": "standard",
"test": "mocha --reporter=spec test/*-test.js",
"coverage": "istanbul cover node_modules/.bin/_mocha -- --reporter=spec test/**/*-test.js"
},
"pre-commit": [
"lint",
"test"
],
"repository": {

@@ -21,10 +27,13 @@ "type": "git",

"bugs": {
"url": "https://github.com/indutny/handle-thing/issues"
"url": "https://github.com/spdy-http2/handle-thing/issues"
},
"homepage": "https://github.com/indutny/handle-thing#readme",
"homepage": "https://github.com/spdy-http2/handle-thing#readme",
"devDependencies": {
"mocha": "^2.2.5",
"readable-stream": "^2.0.1",
"stream-pair": "^1.0.0"
"istanbul": "^0.4.5",
"mocha": "^5.2.0",
"pre-commit": "^1.2.2",
"readable-stream": "^3.0.6",
"standard": "^12.0.1",
"stream-pair": "^1.0.3"
}
}

17

README.md
# Handle Thing
[![Build Status](https://secure.travis-ci.org/indutny/handle-thing.png)](http://travis-ci.org/indutny/handle-thing)
[![Build Status](https://travis-ci.org/spdy-http2/handle-thing.svg?branch=master)](http://travis-ci.org/spdy-http2/handle-thing)
[![NPM version](https://badge.fury.io/js/handle-thing.svg)](http://badge.fury.io/js/handle-thing)
[![dependencies Status](https://david-dm.org/spdy-http2/handle-thing/status.svg?style=flat-square)](https://david-dm.org/spdy-http2/handle-thing)
[![Standard - JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](http://standardjs.com/)
[![Waffle](https://img.shields.io/badge/track-waffle-blue.svg?style=flat-square)](https://waffle.io/spdy-http2/node-spdy)
The right thing when you need it
> Wrap Streams2 instance into a HandleWrap. The right thing when you need it
## Usage
### Examples
`soon™`
### API
`soon™`
## LICENSE

@@ -9,0 +22,0 @@

176

test/api-test.js

@@ -1,116 +0,110 @@

var assert = require('assert');
var net = require('net');
var streamPair = require('stream-pair');
/* eslint-env mocha */
var thing = require('../');
var assert = require('assert')
var net = require('net')
var streamPair = require('stream-pair')
describe('Handle Thing', function() {
var handle;
var pair;
var thing = require('../')
describe('Handle Thing', function () {
var handle
var pair
var socket;
[ 'normal', 'lazy' ].forEach(function(mode) {
describe(mode, function() {
beforeEach(function() {
pair = streamPair.create();
handle = thing.create(mode === 'normal' ? pair.other : null);
socket = new net.Socket({ handle: handle });
[ 'normal', 'lazy' ].forEach(function (mode) {
describe(mode, function () {
beforeEach(function () {
pair = streamPair.create()
handle = thing.create(mode === 'normal' ? pair.other : null)
socket = new net.Socket({
handle: handle,
readable: true,
writable: true
})
if (mode === 'lazy') {
setTimeout(function() {
handle.setStream(pair.other);
}, 50);
setTimeout(function () {
handle.setStream(pair.other)
}, 50)
}
})
// For v0.8
socket.readable = true;
socket.writable = true;
});
afterEach(function () {
assert(handle._stream)
})
afterEach(function() {
assert(handle._stream);
});
it('should write data to Socket', function (done) {
pair.write('hello')
pair.write(' world')
pair.end('... ok')
it('should write data to Socket', function(done) {
pair.write('hello');
pair.write(' world');
pair.end('... ok');
var chunks = ''
socket.on('data', function (chunk) {
chunks += chunk
})
socket.on('end', function () {
assert.strictEqual(chunks, 'hello world... ok')
var chunks = '';
socket.on('data', function(chunk) {
chunks += chunk;
});
socket.on('end', function() {
assert.equal(chunks, 'hello world... ok');
// allowHalfOpen is `false`, so the `end` should be followed by `close`
socket.once('close', function() {
done();
});
});
});
socket.once('close', function () {
done()
})
})
})
it('should read data from Socket', function(done) {
socket.write('hello');
socket.write(' world');
socket.end('... ok');
it('should read data from Socket', function (done) {
socket.write('hello')
socket.write(' world')
socket.end('... ok')
var chunks = '';
pair.on('data', function(chunk) {
chunks += chunk;
});
pair.on('end', function() {
assert.equal(chunks, 'hello world... ok');
var chunks = ''
pair.on('data', function (chunk) {
chunks += chunk
})
pair.on('end', function () {
assert.strictEqual(chunks, 'hello world... ok')
done();
});
});
done()
})
})
it('should invoke `close` callback', function(done) {
handle._options.close = function(callback) {
done();
process.nextTick(callback);
};
it('should invoke `close` callback', function (done) {
handle._options.close = function (callback) {
done()
process.nextTick(callback)
}
pair.end('hello');
socket.resume();
});
pair.end('hello')
socket.resume()
})
it('should kill pending requests', function(done) {
handle._options.close = function() {
setTimeout(done, 75);
};
it('should kill pending requests', function (done) {
handle._options.close = function () {
setTimeout(done, 75)
}
socket.write('hello');
socket.destroy();
});
socket.write('hello')
socket.destroy()
})
if (mode === 'normal') {
it('should invoke `getPeerName` callback', function() {
handle._options.getPeerName = function() {
return { address: 'ohai' };
};
it('should invoke `getPeerName` callback', function () {
handle._options.getPeerName = function () {
return { address: 'ohai' }
}
assert.equal(socket.remoteAddress, 'ohai');
});
assert.strictEqual(socket.remoteAddress, 'ohai')
})
it('should emit ECONNRESET at `close` event', function(done) {
pair.other.emit('close');
it('should emit ECONNRESET at `close` event', function (done) {
pair.other.emit('close')
// No error emitted in v0.8
if (thing.mode === 'rusty') {
socket.on('close', function() {
done();
});
return;
}
socket.on('error', function(err) {
assert(/ECONNRESET/.test(err.message));
done();
});
});
socket.on('error', function (err) {
assert(/ECONNRESET/.test(err.message))
done()
})
})
}
});
});
});
})
})
})
.npmignore
.travis.yml

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc