Add some more node modules for dev/testsing
This commit is contained in:
parent
57a7462772
commit
93870118cf
|
|
@ -0,0 +1,6 @@
|
|||
benchmark/
|
||||
coverage/
|
||||
lib-cov/
|
||||
test/
|
||||
tool/
|
||||
.travis.yml
|
||||
|
|
@ -0,0 +1,360 @@
|
|||
# Changes
|
||||
|
||||
This file is a manually maintained list of changes for each release. Feel free
|
||||
to add your changes here when sending pull requests. Also send corrections if
|
||||
you spot any mistakes.
|
||||
|
||||
## v2.5.2 (2014-10-10)
|
||||
|
||||
* Fix receiving large text fields #922
|
||||
|
||||
## v2.5.1 (2014-09-22)
|
||||
|
||||
* Fix `pool.end` race conditions #915
|
||||
* Fix `pool.getConnection` race conditions
|
||||
|
||||
## v2.5.0 (2014-09-07)
|
||||
|
||||
* Add code `POOL_ENQUEUELIMIT` to error reaching `queueLimit`
|
||||
* Add `enqueue` event to pool #716
|
||||
* Add `enqueue` event to protocol and connection #381
|
||||
* Blacklist unsupported connection flags #881
|
||||
* Make only column names enumerable in `RowDataPacket` #549 #895
|
||||
* Support Node.js 0.6 #718
|
||||
|
||||
## v2.4.3 (2014-08-25)
|
||||
|
||||
* Fix `pool.query` to use `typeCast` configuration
|
||||
|
||||
## v2.4.2 (2014-08-03)
|
||||
|
||||
* Fix incorrect sequence packet errors to be catchable #867
|
||||
* Fix stray protocol packet errors to be catchable #867
|
||||
* Fix timing of fatal protocol errors bubbling to user #879
|
||||
|
||||
## v2.4.1 (2014-07-17)
|
||||
|
||||
* Fix `pool.query` not invoking callback on connection error #872
|
||||
|
||||
## v2.4.0 (2014-07-13)
|
||||
|
||||
* Add code `POOL_NOEXIST` in PoolCluster error #846
|
||||
* Add `acquireTimeout` pool option to specify a timeout for acquiring a connection #821 #854
|
||||
* Add `connection.escapeId`
|
||||
* Add `pool.escapeId`
|
||||
* Add `timeout` option to all sequences #855 #863
|
||||
* Default `connectTimeout` to 10 seconds
|
||||
* Fix domain binding with `conn.connect`
|
||||
* Fix `packet.default` to actually be a string
|
||||
* Fix `PARSER_*` errors to be catchable
|
||||
* Fix `PROTOCOL_PACKETS_OUT_OF_ORDER` error to be catchable #844
|
||||
* Include packets that failed parsing under `debug`
|
||||
* Return `Query` object from `pool.query` like `conn.query` #830
|
||||
* Use `EventEmitter.listenerCount` when possible for faster counting
|
||||
|
||||
## v2.3.2 (2014-05-29)
|
||||
|
||||
* Fix pool leaking connections after `conn.changeUser` #833
|
||||
|
||||
## v2.3.1 (2014-05-26)
|
||||
|
||||
* Add database errors to error constants
|
||||
* Add global errors to error constants
|
||||
* Throw when calling `conn.release` multiple times #824 #827
|
||||
* Update known error codes
|
||||
|
||||
## v2.3.0 (2014-05-16)
|
||||
|
||||
* Accept MySQL charset (like `UTF8` or `UTF8MB4`) in `charset` option #808
|
||||
* Accept pool options in connection string to `mysql.createPool` #811
|
||||
* Clone connection config for new pool connections
|
||||
* Default `connectTimeout` to 2 minutes
|
||||
* Reject unauthorized SSL connections (use `ssl.rejectUnauthorized` to override) #816
|
||||
* Return last error when PoolCluster exhausts connection retries #818
|
||||
* Remove connection from pool after `conn.changeUser` is released #806
|
||||
* Throw on unknown SSL profile name #817
|
||||
* User newer TLS functions when available #809
|
||||
|
||||
## v2.2.0 (2014-04-27)
|
||||
|
||||
* Use indexOf instead of for loops removing conn from pool #611
|
||||
* Make callback to `pool.query` optional like `conn.query` #585
|
||||
* Prevent enqueuing sequences after fatal error #400
|
||||
* Fix geometry parser for empty fields #742
|
||||
* Accept lower-case charset option
|
||||
* Throw on unknown charset option #789
|
||||
* Update known charsets
|
||||
* Remove console.warn from PoolCluster #744
|
||||
* Fix `pool.end` to handle queued connections #797
|
||||
* Fix `pool.releaseConnection` to keep connection queue flowing #797
|
||||
* Fix SSL handshake error to be catchable #800
|
||||
* Add `connection.threadId` to get MySQL connection ID #602
|
||||
* Ensure `pool.getConnection` retrieves good connections #434 #557 #778
|
||||
* Fix pool cluster wildcard matching #627
|
||||
* Pass query values through to `SqlString.format` #590
|
||||
|
||||
## v2.1.1 (2014-03-13)
|
||||
|
||||
* fix authentication w/password failure for node.js 0.10.5 #746 #752
|
||||
* fix authentication w/password TypeError exception for node.js 0.10.0-0.10.4 #747
|
||||
* fix specifying `values` in `conn.query({...}).on(...)` pattern #755
|
||||
* fix long stack trace to include the `pool.query(...)` call #715
|
||||
|
||||
## v2.1.0 (2014-02-20)
|
||||
|
||||
* crypto.createHash fix for node.js < 11 #735
|
||||
* Add `connectTimeout` option to specify a timeout for establishing a connection #726
|
||||
* SSL support #481
|
||||
|
||||
## v2.0.1
|
||||
|
||||
* internal parser speed improvement #702
|
||||
* domains support
|
||||
* 'trace' connection option to control if long stack traces are generated #713 #710 #439
|
||||
|
||||
## v2.0.0 (2014-01-09)
|
||||
|
||||
* stream improvements:
|
||||
- node 0.8 support #692
|
||||
- Emit 'close' events from query streams #688
|
||||
* encoding fix in streaming LOAD DATA LOCAL INFILE #670
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-rc2 (2013-12-07)
|
||||
|
||||
* Streaming LOAD DATA LOCAL INFILE #668
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-rc1 (2013-11-30)
|
||||
|
||||
* Transaction support
|
||||
* Expose SqlString.format as mysql.format()
|
||||
* Many bug fixes
|
||||
* Better support for dates in local time zone
|
||||
* Doc improvements
|
||||
|
||||
## v2.0.0-alpha9 (2013-08-27)
|
||||
|
||||
* Add query to pool to execute queries directly using the pool
|
||||
* Pool option to set queue limit
|
||||
* Pool sends 'connection' event when it opens a new connection
|
||||
* Added stringifyObjects option to treat input as strings rather than objects (#501)
|
||||
* Support for poolClusters
|
||||
* Datetime improvements
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha8 (2013-04-30)
|
||||
|
||||
* Switch to old mode for Streams 2 (Node.js v 0.10.x)
|
||||
* Add stream method to Query Wraps events from the query object into a node v0.10.x Readable stream
|
||||
* DECIMAL should also be treated as big number
|
||||
* Removed slow unnecessary stack access
|
||||
* Added charsets
|
||||
* Added bigNumberStrings option for forcing BIGINT columns as strings
|
||||
* Changes date parsing to return String if not a valid JS Date
|
||||
* Adds support for ?? escape sequence to escape identifiers
|
||||
* Changes Auth.token() to force password to be in binary, not utf8 (#378)
|
||||
* Restrict debugging by packet types
|
||||
* Add 'multipleStatements' option tracking to ConnectionConfig. Fixes GH-408
|
||||
* Changes Pool to handle 'error' events and dispose connection
|
||||
* Allows db.query({ sql: "..." }, [ val1, ... ], cb); (#390)
|
||||
* Improved documentation
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha7 (2013-02-03)
|
||||
|
||||
* Add connection pooling (#351)
|
||||
|
||||
## v2.0.0-alpha6 (2013-01-31)
|
||||
|
||||
* Add supportBigNumbers option (#381, #382)
|
||||
* Accept prebuilt Query object in connection.query
|
||||
* Bug fixes
|
||||
|
||||
## v2.0.0-alpha5 (2012-12-03)
|
||||
|
||||
* Add mysql.escapeId to escape identifiers (closes #342)
|
||||
* Allow custom escaping mode (config.queryFormat)
|
||||
* Convert DATE columns to configured timezone instead of UTC (#332)
|
||||
* Convert LONGLONG and NEWDECIMAL to numbers (#333)
|
||||
* Fix Connection.escape() (fixes #330)
|
||||
* Changed Readme ambiguity about custom type cast fallback
|
||||
* Change typeCast to receive Connection instead of Connection.config.timezone
|
||||
* Fix drain event having useless err parameter
|
||||
* Add Connection.statistics() back from v0.9
|
||||
* Add Connection.ping() back from v0.9
|
||||
|
||||
## v2.0.0-alpha4 (2012-10-03)
|
||||
|
||||
* Fix some OOB errors on resume()
|
||||
* Fix quick pause() / resume() usage
|
||||
* Properly parse host denied / similar errors
|
||||
* Add Connection.ChangeUser functionality
|
||||
* Make sure changeUser errors are fatal
|
||||
* Enable formatting nested arrays for bulk inserts
|
||||
* Add Connection.escape functionality
|
||||
* Renamed 'close' to 'end' event
|
||||
* Return parsed object instead of Buffer for GEOMETRY types
|
||||
* Allow nestTables inline (using a string instead of a boolean)
|
||||
* Check for ZEROFILL_FLAG and format number accordingly
|
||||
* Add timezone support (default: local)
|
||||
* Add custom typeCast functionality
|
||||
* Export mysql column types
|
||||
* Add connection flags functionality (#237)
|
||||
* Exports drain event when queue finishes processing (#272, #271, #306)
|
||||
|
||||
## v2.0.0-alpha3 (2012-06-12)
|
||||
|
||||
* Implement support for `LOAD DATA LOCAL INFILE` queries (#182).
|
||||
* Support OLD\_PASSWORD() accounts like 0.9.x did. You should still upgrade any
|
||||
user accounts in your your MySQL user table that has short (16 byte) Password
|
||||
values. Connecting to those accounts is not secure. (#204)
|
||||
* Ignore function values when escaping objects, allows to use RowDataPacket
|
||||
objects as query arguments. (Alex Gorbatchev, #213)
|
||||
* Handle initial error packets from server such as `ER_HOST_NOT_PRIVILEGED`.
|
||||
* Treat `utf8\_bin` as a String, not Buffer. (#214)
|
||||
* Handle empty strings in first row column value. (#222)
|
||||
* Honor Connection#nestTables setting for queries. (#221)
|
||||
* Remove `CLIENT_INTERACTIVE` flag from config. Improves #225.
|
||||
* Improve docs for connections settings.
|
||||
* Implement url string support for Connection configs.
|
||||
|
||||
## v2.0.0-alpha2 (2012-05-31)
|
||||
|
||||
* Specify escaping before for NaN / Infinity (they are as unquoted constants).
|
||||
* Support for unix domain socket connections (use: {socketPath: '...'}).
|
||||
* Fix type casting for NULL values for Date/Number fields
|
||||
* Add `fields` argument to `query()` as well as `'fields'` event. This is
|
||||
similar to what was available in 0.9.x.
|
||||
* Support connecting to the sphinx searchd daemon as well as MariaDB (#199).
|
||||
* Implement long stack trace support, will be removed / disabled if the node
|
||||
core ever supports it natively.
|
||||
* Implement `nestTables` option for queries, allows fetching JOIN result sets
|
||||
with overlapping column names.
|
||||
* Fix ? placeholder mechanism for values containing '?' characters (#205).
|
||||
* Detect when `connect()` is called more than once on a connection and provide
|
||||
the user with a good error message for it (#204).
|
||||
* Switch to `UTF8_GENERAL_CI` (previously `UTF8_UNICODE_CI`) as the default
|
||||
charset for all connections to avoid strange MySQL performance issues (#200),
|
||||
and also make the charset user configurable.
|
||||
* Fix BLOB type casting for `TINY_BLOB`, `MEDIUM_BLOB` and `LONG_BLOB`.
|
||||
* Add support for sending and receiving large (> 16 MB) packets.
|
||||
|
||||
## v2.0.0-alpha (2012-05-15)
|
||||
|
||||
This release is a rewrite. You should carefully test your application after
|
||||
upgrading to avoid problems. This release features many improvements, most
|
||||
importantly:
|
||||
|
||||
* ~5x faster than v0.9.x for parsing query results
|
||||
* Support for pause() / resume() (for streaming rows)
|
||||
* Support for multiple statement queries
|
||||
* Support for stored procedures
|
||||
* Support for transactions
|
||||
* Support for binary columns (as blobs)
|
||||
* Consistent & well documented error handling
|
||||
* A new Connection class that has well defined semantics (unlike the old Client class).
|
||||
* Convenient escaping of objects / arrays that allows for simpler query construction
|
||||
* A significantly simpler code base
|
||||
* Many bug fixes & other small improvements (Closed 62 out of 66 GitHub issues)
|
||||
|
||||
Below are a few notes on the upgrade process itself:
|
||||
|
||||
The first thing you will run into is that the old `Client` class is gone and
|
||||
has been replaced with a less ambitious `Connection` class. So instead of
|
||||
`mysql.createClient()`, you now have to:
|
||||
|
||||
```js
|
||||
var mysql = require('mysql');
|
||||
var connection = mysql.createConnection({
|
||||
host : 'localhost',
|
||||
user : 'me',
|
||||
password : 'secret',
|
||||
});
|
||||
|
||||
connection.query('SELECT 1', function(err, rows) {
|
||||
if (err) throw err;
|
||||
|
||||
console.log('Query result: ', rows);
|
||||
});
|
||||
|
||||
connection.end();
|
||||
```
|
||||
|
||||
The new `Connection` class does not try to handle re-connects, please study the
|
||||
`Server disconnects` section in the new Readme.
|
||||
|
||||
Other than that, the interface has stayed very similar. Here are a few things
|
||||
to check out so:
|
||||
|
||||
* BIGINT's are now cast into strings
|
||||
* Binary data is now cast to buffers
|
||||
* The `'row'` event on the `Query` object is now called `'result'` and will
|
||||
also be emitted for queries that produce an OK/Error response.
|
||||
* Error handling is consistently defined now, check the Readme
|
||||
* Escaping has become more powerful which may break your code if you are
|
||||
currently using objects to fill query placeholders.
|
||||
* Connections can now be established explicitly again, so you may wish to do so
|
||||
if you want to handle connection errors specifically.
|
||||
|
||||
That should be most of it, if you run into anything else, please send a patch
|
||||
or open an issue to improve this document.
|
||||
|
||||
## v0.9.6 (2012-03-12)
|
||||
|
||||
* Escape array values so they produce sql arrays (Roger Castells, Colin Smith)
|
||||
* docs: mention mysql transaction stop gap solution (Blake Miner)
|
||||
* docs: Mention affectedRows in FAQ (Michael Baldwin)
|
||||
|
||||
## v0.9.5 (2011-11-26)
|
||||
|
||||
* Fix #142 Driver stalls upon reconnect attempt that's immediately closed
|
||||
* Add travis build
|
||||
* Switch to urun as a test runner
|
||||
* Switch to utest for unit tests
|
||||
* Remove fast-or-slow dependency for tests
|
||||
* Split integration tests into individual files again
|
||||
|
||||
## v0.9.4 (2011-08-31)
|
||||
|
||||
* Expose package.json as `mysql.PACKAGE` (#104)
|
||||
|
||||
## v0.9.3 (2011-08-22)
|
||||
|
||||
* Set default `client.user` to root
|
||||
* Fix #91: Client#format should not mutate params array
|
||||
* Fix #94: TypeError in client.js
|
||||
* Parse decimals as string (vadimg)
|
||||
|
||||
## v0.9.2 (2011-08-07)
|
||||
|
||||
* The underlaying socket connection is now managed implicitly rather than explicitly.
|
||||
* Check the [upgrading guide][] for a full list of changes.
|
||||
|
||||
## v0.9.1 (2011-02-20)
|
||||
|
||||
* Fix issue #49 / `client.escape()` throwing exceptions on objects. (Nick Payne)
|
||||
* Drop < v0.4.x compatibility. From now on you need node v0.4.x to use this module.
|
||||
|
||||
## Older releases
|
||||
|
||||
These releases were done before maintaining this file:
|
||||
|
||||
* [v0.9.0](https://github.com/felixge/node-mysql/compare/v0.8.0...v0.9.0)
|
||||
(2011-01-04)
|
||||
* [v0.8.0](https://github.com/felixge/node-mysql/compare/v0.7.0...v0.8.0)
|
||||
(2010-10-30)
|
||||
* [v0.7.0](https://github.com/felixge/node-mysql/compare/v0.6.0...v0.7.0)
|
||||
(2010-10-14)
|
||||
* [v0.6.0](https://github.com/felixge/node-mysql/compare/v0.5.0...v0.6.0)
|
||||
(2010-09-28)
|
||||
* [v0.5.0](https://github.com/felixge/node-mysql/compare/v0.4.0...v0.5.0)
|
||||
(2010-09-17)
|
||||
* [v0.4.0](https://github.com/felixge/node-mysql/compare/v0.3.0...v0.4.0)
|
||||
(2010-09-02)
|
||||
* [v0.3.0](https://github.com/felixge/node-mysql/compare/v0.2.0...v0.3.0)
|
||||
(2010-08-25)
|
||||
* [v0.2.0](https://github.com/felixge/node-mysql/compare/v0.1.0...v0.2.0)
|
||||
(2010-08-22)
|
||||
* [v0.1.0](https://github.com/felixge/node-mysql/commits/v0.1.0)
|
||||
(2010-08-22)
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Copyright (c) 2012 Felix Geisendörfer (felix@debuggable.com) and contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,5 @@
|
|||
{
|
||||
"Amazon RDS": {
|
||||
"ca": "-----BEGIN CERTIFICATE-----\nMIIDQzCCAqygAwIBAgIJAOd1tlfiGoEoMA0GCSqGSIb3DQEBBQUAMHUxCzAJBgNV\nBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMRMw\nEQYDVQQKEwpBbWF6b24uY29tMQwwCgYDVQQLEwNSRFMxHDAaBgNVBAMTE2F3cy5h\nbWF6b24uY29tL3Jkcy8wHhcNMTAwNDA1MjI0NDMxWhcNMTUwNDA0MjI0NDMxWjB1\nMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHU2Vh\ndHRsZTETMBEGA1UEChMKQW1hem9uLmNvbTEMMAoGA1UECxMDUkRTMRwwGgYDVQQD\nExNhd3MuYW1hem9uLmNvbS9yZHMvMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\ngQDKhXGU7tizxUR5WaFoMTFcxNxa05PEjZaIOEN5ctkWrqYSRov0/nOMoZjqk8bC\nmed9vPFoQGD0OTakPs0jVe3wwmR735hyVwmKIPPsGlaBYj1O6llIpZeQVyupNx56\nUzqtiLaDzh1KcmfqP3qP2dInzBfJQKjiRudo1FWnpPt33QIDAQABo4HaMIHXMB0G\nA1UdDgQWBBT/H3x+cqSkR/ePSIinPtc4yWKe3DCBpwYDVR0jBIGfMIGcgBT/H3x+\ncqSkR/ePSIinPtc4yWKe3KF5pHcwdTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldh\nc2hpbmd0b24xEDAOBgNVBAcTB1NlYXR0bGUxEzARBgNVBAoTCkFtYXpvbi5jb20x\nDDAKBgNVBAsTA1JEUzEcMBoGA1UEAxMTYXdzLmFtYXpvbi5jb20vcmRzL4IJAOd1\ntlfiGoEoMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAvguZy/BDT66x\nGfgnJlyQwnFSeVLQm9u/FIvz4huGjbq9dqnD6h/Gm56QPFdyMEyDiZWaqY6V08lY\nLTBNb4kcIc9/6pc0/ojKciP5QJRm6OiZ4vgG05nF4fYjhU7WClUx7cxq1fKjNc2J\nUCmmYqgiVkAGWRETVo+byOSDZ4swb10=\n-----END CERTIFICATE-----\n"
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
var Connection = require('./lib/Connection');
|
||||
var ConnectionConfig = require('./lib/ConnectionConfig');
|
||||
var Types = require('./lib/protocol/constants/types');
|
||||
var SqlString = require('./lib/protocol/SqlString');
|
||||
var Pool = require('./lib/Pool');
|
||||
var PoolConfig = require('./lib/PoolConfig');
|
||||
var PoolCluster = require('./lib/PoolCluster');
|
||||
|
||||
exports.createConnection = function(config) {
|
||||
return new Connection({config: new ConnectionConfig(config)});
|
||||
};
|
||||
|
||||
exports.createPool = function(config) {
|
||||
return new Pool({config: new PoolConfig(config)});
|
||||
};
|
||||
|
||||
exports.createPoolCluster = function(config) {
|
||||
return new PoolCluster(config);
|
||||
};
|
||||
|
||||
exports.createQuery = Connection.createQuery;
|
||||
|
||||
exports.Types = Types;
|
||||
exports.escape = SqlString.escape;
|
||||
exports.escapeId = SqlString.escapeId;
|
||||
exports.format = SqlString.format;
|
||||
|
|
@ -0,0 +1,389 @@
|
|||
var Crypto = require('crypto');
|
||||
var Net = require('net');
|
||||
var tls = require('tls');
|
||||
var ConnectionConfig = require('./ConnectionConfig');
|
||||
var Protocol = require('./protocol/Protocol');
|
||||
var SqlString = require('./protocol/SqlString');
|
||||
var Query = require('./protocol/sequences/Query');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var Util = require('util');
|
||||
|
||||
module.exports = Connection;
|
||||
Util.inherits(Connection, EventEmitter);
|
||||
function Connection(options) {
|
||||
EventEmitter.call(this);
|
||||
|
||||
this.config = options.config;
|
||||
|
||||
this._socket = options.socket;
|
||||
this._protocol = new Protocol({config: this.config, connection: this});
|
||||
this._connectCalled = false;
|
||||
this.state = "disconnected";
|
||||
this.threadId = null;
|
||||
}
|
||||
|
||||
function bindToCurrentDomain(callback) {
|
||||
if (!callback) return;
|
||||
|
||||
var domain = process.domain;
|
||||
|
||||
return domain
|
||||
? domain.bind(callback)
|
||||
: callback;
|
||||
}
|
||||
|
||||
Connection.createQuery = function(sql, values, cb) {
|
||||
if (sql instanceof Query) {
|
||||
return sql;
|
||||
}
|
||||
|
||||
var options = {};
|
||||
|
||||
if (typeof sql === 'object') {
|
||||
// query(options, cb)
|
||||
options = sql;
|
||||
if (typeof values === 'function') {
|
||||
cb = values;
|
||||
} else if (typeof values !== 'undefined') {
|
||||
options.values = values;
|
||||
}
|
||||
} else if (typeof values === 'function') {
|
||||
// query(sql, cb)
|
||||
cb = values;
|
||||
options.sql = sql;
|
||||
options.values = undefined;
|
||||
} else {
|
||||
// query(sql, values, cb)
|
||||
options.sql = sql;
|
||||
options.values = values;
|
||||
}
|
||||
return new Query(options, bindToCurrentDomain(cb));
|
||||
};
|
||||
|
||||
Connection.prototype.connect = function connect(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
if (!this._connectCalled) {
|
||||
this._connectCalled = true;
|
||||
|
||||
// Connect either via a UNIX domain socket or a TCP socket.
|
||||
this._socket = (this.config.socketPath)
|
||||
? Net.createConnection(this.config.socketPath)
|
||||
: Net.createConnection(this.config.port, this.config.host);
|
||||
|
||||
var connection = this;
|
||||
this._protocol.on('data', function(data) {
|
||||
connection._socket.write(data);
|
||||
});
|
||||
this._socket.on('data', function(data) {
|
||||
connection._protocol.write(data);
|
||||
});
|
||||
this._protocol.on('end', function() {
|
||||
connection._socket.end()
|
||||
});
|
||||
this._socket.on('end', function(err) {
|
||||
connection._protocol.end();
|
||||
});
|
||||
|
||||
this._socket.on('error', this._handleNetworkError.bind(this));
|
||||
this._socket.on('connect', this._handleProtocolConnect.bind(this));
|
||||
this._protocol.on('handshake', this._handleProtocolHandshake.bind(this));
|
||||
this._protocol.on('unhandledError', this._handleProtocolError.bind(this));
|
||||
this._protocol.on('drain', this._handleProtocolDrain.bind(this));
|
||||
this._protocol.on('end', this._handleProtocolEnd.bind(this));
|
||||
this._protocol.on('enqueue', this._handleProtocolEnqueue.bind(this));
|
||||
|
||||
if (this.config.connectTimeout) {
|
||||
var handleConnectTimeout = this._handleConnectTimeout.bind(this);
|
||||
|
||||
this._socket.setTimeout(this.config.connectTimeout, handleConnectTimeout);
|
||||
this._socket.once('connect', function() {
|
||||
this.setTimeout(0, handleConnectTimeout);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
this._protocol.handshake(options, bindToCurrentDomain(callback));
|
||||
};
|
||||
|
||||
Connection.prototype.changeUser = function changeUser(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
|
||||
var charsetNumber = (options.charset)
|
||||
? ConnectionConfig.getCharsetNumber(options.charset)
|
||||
: this.config.charsetNumber;
|
||||
|
||||
return this._protocol.changeUser({
|
||||
user : options.user || this.config.user,
|
||||
password : options.password || this.config.password,
|
||||
database : options.database || this.config.database,
|
||||
timeout : options.timeout,
|
||||
charsetNumber : charsetNumber,
|
||||
currentConfig : this.config
|
||||
}, bindToCurrentDomain(callback));
|
||||
};
|
||||
|
||||
Connection.prototype.beginTransaction = function beginTransaction(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'START TRANSACTION';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.commit = function commit(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'COMMIT';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.rollback = function rollback(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.sql = 'ROLLBACK';
|
||||
options.values = null;
|
||||
|
||||
return this.query(options, callback);
|
||||
};
|
||||
|
||||
Connection.prototype.query = function(sql, values, cb) {
|
||||
this._implyConnect();
|
||||
|
||||
var query = Connection.createQuery(sql, values, cb);
|
||||
query._connection = this;
|
||||
|
||||
if (!(typeof sql == 'object' && 'typeCast' in sql)) {
|
||||
query.typeCast = this.config.typeCast;
|
||||
}
|
||||
|
||||
query.sql = this.format(query.sql, query.values);
|
||||
|
||||
return this._protocol._enqueue(query);
|
||||
};
|
||||
|
||||
Connection.prototype.ping = function ping(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.ping(options, bindToCurrentDomain(callback));
|
||||
};
|
||||
|
||||
Connection.prototype.statistics = function statistics(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.stats(options, bindToCurrentDomain(callback));
|
||||
};
|
||||
|
||||
Connection.prototype.end = function end(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
this._implyConnect();
|
||||
this._protocol.quit(options, bindToCurrentDomain(callback));
|
||||
};
|
||||
|
||||
Connection.prototype.destroy = function() {
|
||||
this.state = "disconnected";
|
||||
this._implyConnect();
|
||||
this._socket.destroy();
|
||||
this._protocol.destroy();
|
||||
};
|
||||
|
||||
Connection.prototype.pause = function() {
|
||||
this._socket.pause();
|
||||
this._protocol.pause();
|
||||
};
|
||||
|
||||
Connection.prototype.resume = function() {
|
||||
this._socket.resume();
|
||||
this._protocol.resume();
|
||||
};
|
||||
|
||||
Connection.prototype.escape = function(value) {
|
||||
return SqlString.escape(value, false, this.config.timezone);
|
||||
};
|
||||
|
||||
Connection.prototype.escapeId = function escapeId(value) {
|
||||
return SqlString.escapeId(value, false);
|
||||
};
|
||||
|
||||
Connection.prototype.format = function(sql, values) {
|
||||
if (typeof this.config.queryFormat == "function") {
|
||||
return this.config.queryFormat.call(this, sql, values, this.config.timezone);
|
||||
}
|
||||
return SqlString.format(sql, values, this.config.stringifyObjects, this.config.timezone);
|
||||
};
|
||||
|
||||
if (tls.TLSSocket) {
|
||||
// 0.11+ environment
|
||||
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
||||
var secureContext = tls.createSecureContext({
|
||||
key : this.config.ssl.key,
|
||||
cert : this.config.ssl.cert,
|
||||
passphrase : this.config.ssl.passphrase,
|
||||
ca : this.config.ssl.ca
|
||||
});
|
||||
|
||||
// "unpipe"
|
||||
this._socket.removeAllListeners('data');
|
||||
this._protocol.removeAllListeners('data');
|
||||
|
||||
// socket <-> encrypted
|
||||
var rejectUnauthorized = this.config.ssl.rejectUnauthorized;
|
||||
var secureSocket = new tls.TLSSocket(this._socket, {
|
||||
rejectUnauthorized : rejectUnauthorized,
|
||||
requestCert : true,
|
||||
secureContext : secureContext,
|
||||
isServer : false
|
||||
});
|
||||
|
||||
// cleartext <-> protocol
|
||||
secureSocket.pipe(this._protocol);
|
||||
this._protocol.on('data', function(data) {
|
||||
secureSocket.write(data);
|
||||
});
|
||||
|
||||
secureSocket.on('secure', function() {
|
||||
onSecure(rejectUnauthorized ? this.ssl.verifyError() : null);
|
||||
});
|
||||
|
||||
// start TLS communications
|
||||
secureSocket._start();
|
||||
};
|
||||
} else {
|
||||
// pre-0.11 environment
|
||||
Connection.prototype._startTLS = function _startTLS(onSecure) {
|
||||
// before TLS:
|
||||
// _socket <-> _protocol
|
||||
// after:
|
||||
// _socket <-> securePair.encrypted <-> securePair.cleartext <-> _protocol
|
||||
|
||||
var credentials = Crypto.createCredentials({
|
||||
key : this.config.ssl.key,
|
||||
cert : this.config.ssl.cert,
|
||||
passphrase : this.config.ssl.passphrase,
|
||||
ca : this.config.ssl.ca
|
||||
});
|
||||
|
||||
var rejectUnauthorized = this.config.ssl.rejectUnauthorized;
|
||||
var securePair = tls.createSecurePair(credentials, false, true, rejectUnauthorized);
|
||||
|
||||
// "unpipe"
|
||||
this._socket.removeAllListeners('data');
|
||||
this._protocol.removeAllListeners('data');
|
||||
|
||||
// socket <-> encrypted
|
||||
securePair.encrypted.pipe(this._socket);
|
||||
this._socket.on('data', function(data) {
|
||||
securePair.encrypted.write(data);
|
||||
});
|
||||
|
||||
// cleartext <-> protocol
|
||||
securePair.cleartext.pipe(this._protocol);
|
||||
this._protocol.on('data', function(data) {
|
||||
securePair.cleartext.write(data);
|
||||
});
|
||||
|
||||
securePair.on('secure', function() {
|
||||
if (!rejectUnauthorized) {
|
||||
onSecure();
|
||||
return;
|
||||
}
|
||||
|
||||
var verifyError = this.ssl.verifyError();
|
||||
var err = verifyError;
|
||||
|
||||
// node.js 0.6 support
|
||||
if (typeof err === 'string') {
|
||||
err = new Error(verifyError);
|
||||
err.code = verifyError;
|
||||
}
|
||||
|
||||
onSecure(err);
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
Connection.prototype._handleConnectTimeout = function() {
|
||||
if (this._socket) {
|
||||
this._socket.setTimeout(0);
|
||||
this._socket.destroy();
|
||||
}
|
||||
|
||||
var err = new Error('connect ETIMEDOUT');
|
||||
err.errorno = 'ETIMEDOUT';
|
||||
err.code = 'ETIMEDOUT';
|
||||
err.syscall = 'connect';
|
||||
|
||||
this._handleNetworkError(err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleNetworkError = function(err) {
|
||||
this._protocol.handleNetworkError(err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolError = function(err) {
|
||||
this.state = "protocol_error";
|
||||
this.emit('error', err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolDrain = function() {
|
||||
this.emit('drain');
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolConnect = function() {
|
||||
this.state = "connected";
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolHandshake = function _handleProtocolHandshake(packet) {
|
||||
this.state = "authenticated";
|
||||
this.threadId = packet.threadId;
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolEnd = function(err) {
|
||||
this.state = "disconnected";
|
||||
this.emit('end', err);
|
||||
};
|
||||
|
||||
Connection.prototype._handleProtocolEnqueue = function _handleProtocolEnqueue(sequence) {
|
||||
this.emit('enqueue', sequence);
|
||||
};
|
||||
|
||||
Connection.prototype._implyConnect = function() {
|
||||
if (!this._connectCalled) {
|
||||
this.connect();
|
||||
}
|
||||
};
|
||||
|
|
@ -0,0 +1,201 @@
|
|||
var urlParse = require('url').parse;
|
||||
var ClientConstants = require('./protocol/constants/client');
|
||||
var Charsets = require('./protocol/constants/charsets');
|
||||
var SSLProfiles = null;
|
||||
|
||||
module.exports = ConnectionConfig;
|
||||
function ConnectionConfig(options) {
|
||||
if (typeof options === 'string') {
|
||||
options = ConnectionConfig.parseUrl(options);
|
||||
}
|
||||
|
||||
this.host = options.host || 'localhost';
|
||||
this.port = options.port || 3306;
|
||||
this.localAddress = options.localAddress;
|
||||
this.socketPath = options.socketPath;
|
||||
this.user = options.user || undefined;
|
||||
this.password = options.password || undefined;
|
||||
this.database = options.database;
|
||||
this.connectTimeout = (options.connectTimeout === undefined)
|
||||
? (10 * 1000)
|
||||
: options.connectTimeout;
|
||||
this.insecureAuth = options.insecureAuth || false;
|
||||
this.supportBigNumbers = options.supportBigNumbers || false;
|
||||
this.bigNumberStrings = options.bigNumberStrings || false;
|
||||
this.dateStrings = options.dateStrings || false;
|
||||
this.debug = options.debug;
|
||||
this.trace = options.trace !== false;
|
||||
this.stringifyObjects = options.stringifyObjects || false;
|
||||
this.timezone = options.timezone || 'local';
|
||||
this.flags = options.flags || '';
|
||||
this.queryFormat = options.queryFormat;
|
||||
this.pool = options.pool || undefined;
|
||||
this.ssl = (typeof options.ssl === 'string')
|
||||
? ConnectionConfig.getSSLProfile(options.ssl)
|
||||
: (options.ssl || false);
|
||||
this.multipleStatements = options.multipleStatements || false;
|
||||
this.typeCast = (options.typeCast === undefined)
|
||||
? true
|
||||
: options.typeCast;
|
||||
|
||||
if (this.timezone[0] == " ") {
|
||||
// "+" is a url encoded char for space so it
|
||||
// gets translated to space when giving a
|
||||
// connection string..
|
||||
this.timezone = "+" + this.timezone.substr(1);
|
||||
}
|
||||
|
||||
if (this.ssl) {
|
||||
// Default rejectUnauthorized to true
|
||||
this.ssl.rejectUnauthorized = this.ssl.rejectUnauthorized !== false;
|
||||
}
|
||||
|
||||
this.maxPacketSize = 0;
|
||||
this.charsetNumber = (options.charset)
|
||||
? ConnectionConfig.getCharsetNumber(options.charset)
|
||||
: options.charsetNumber||Charsets.UTF8_GENERAL_CI;
|
||||
|
||||
// Set the client flags
|
||||
var defaultFlags = ConnectionConfig.getDefaultFlags(options);
|
||||
this.clientFlags = ConnectionConfig.mergeFlags(defaultFlags, options.flags)
|
||||
}
|
||||
|
||||
ConnectionConfig.mergeFlags = function mergeFlags(defaultFlags, userFlags) {
|
||||
var allFlags = ConnectionConfig.parseFlagList(defaultFlags);
|
||||
var newFlags = ConnectionConfig.parseFlagList(userFlags);
|
||||
|
||||
// Merge the new flags
|
||||
for (var flag in newFlags) {
|
||||
if (allFlags[flag] !== false) {
|
||||
allFlags[flag] = newFlags[flag];
|
||||
}
|
||||
}
|
||||
|
||||
// Build flags
|
||||
var flags = 0x0;
|
||||
for (var flag in allFlags) {
|
||||
if (allFlags[flag]) {
|
||||
// TODO: Throw here on some future release
|
||||
flags |= ClientConstants['CLIENT_' + flag] || 0x0;
|
||||
}
|
||||
}
|
||||
|
||||
return flags;
|
||||
};
|
||||
|
||||
ConnectionConfig.getCharsetNumber = function getCharsetNumber(charset) {
|
||||
var num = Charsets[charset.toUpperCase()];
|
||||
|
||||
if (num === undefined) {
|
||||
throw new TypeError('Unknown charset \'' + charset + '\'');
|
||||
}
|
||||
|
||||
return num;
|
||||
};
|
||||
|
||||
ConnectionConfig.getDefaultFlags = function getDefaultFlags(options) {
|
||||
var defaultFlags = [
|
||||
'-COMPRESS', // Compression protocol *NOT* supported
|
||||
'-CONNECT_ATTRS', // Does *NOT* send connection attributes in Protocol::HandshakeResponse41
|
||||
'+CONNECT_WITH_DB', // One can specify db on connect in Handshake Response Packet
|
||||
'+FOUND_ROWS', // Send found rows instead of affected rows
|
||||
'+IGNORE_SIGPIPE', // Don't issue SIGPIPE if network failures
|
||||
'+IGNORE_SPACE', // Let the parser ignore spaces before '('
|
||||
'+LOCAL_FILES', // Can use LOAD DATA LOCAL
|
||||
'+LONG_FLAG', // Longer flags in Protocol::ColumnDefinition320
|
||||
'+LONG_PASSWORD', // Use the improved version of Old Password Authentication
|
||||
'+MULTI_RESULTS', // Can handle multiple resultsets for COM_QUERY
|
||||
'+ODBC', // Special handling of ODBC behaviour
|
||||
'-PLUGIN_AUTH', // Does *NOT* support auth plugins
|
||||
'+PROTOCOL_41', // Uses the 4.1 protocol
|
||||
'+PS_MULTI_RESULTS', // Can handle multiple resultsets for COM_STMT_EXECUTE
|
||||
'+RESERVED', // Unused
|
||||
'+SECURE_CONNECTION', // Supports Authentication::Native41
|
||||
'+TRANSACTIONS' // Expects status flags
|
||||
];
|
||||
|
||||
if (options && options.multipleStatements) {
|
||||
// May send multiple statements per COM_QUERY and COM_STMT_PREPARE
|
||||
defaultFlags.push('+MULTI_STATEMENTS');
|
||||
}
|
||||
|
||||
return defaultFlags;
|
||||
};
|
||||
|
||||
ConnectionConfig.getSSLProfile = function getSSLProfile(name) {
|
||||
if (!SSLProfiles) {
|
||||
SSLProfiles = require('./../fixtures/ssl-profiles.json');
|
||||
}
|
||||
|
||||
var ssl = SSLProfiles[name];
|
||||
|
||||
if (ssl === undefined) {
|
||||
throw new TypeError('Unknown SSL profile \'' + name + '\'');
|
||||
}
|
||||
|
||||
return ssl;
|
||||
};
|
||||
|
||||
ConnectionConfig.parseFlagList = function parseFlagList(flagList) {
|
||||
var allFlags = Object.create(null);
|
||||
|
||||
if (!flagList) {
|
||||
return allFlags;
|
||||
}
|
||||
|
||||
var flags = !Array.isArray(flagList)
|
||||
? String(flagList || '').toUpperCase().split(/\s*,+\s*/)
|
||||
: flagList;
|
||||
|
||||
for (var i = 0; i < flags.length; i++) {
|
||||
var flag = flags[i];
|
||||
var offset = 1;
|
||||
var state = flag[0];
|
||||
|
||||
if (state === undefined) {
|
||||
// TODO: throw here on some future release
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state !== '-' && state !== '+') {
|
||||
offset = 0;
|
||||
state = '+';
|
||||
}
|
||||
|
||||
allFlags[flag.substr(offset)] = state === '+';
|
||||
}
|
||||
|
||||
return allFlags;
|
||||
};
|
||||
|
||||
ConnectionConfig.parseUrl = function(url) {
|
||||
url = urlParse(url, true);
|
||||
|
||||
var options = {
|
||||
host : url.hostname,
|
||||
port : url.port,
|
||||
database : url.pathname.substr(1),
|
||||
};
|
||||
|
||||
if (url.auth) {
|
||||
var auth = url.auth.split(':');
|
||||
options.user = auth[0];
|
||||
options.password = auth[1];
|
||||
}
|
||||
|
||||
if (url.query) {
|
||||
for (var key in url.query) {
|
||||
var value = url.query[key];
|
||||
|
||||
try {
|
||||
// Try to parse this as a JSON expression first
|
||||
options[key] = JSON.parse(value);
|
||||
} catch (err) {
|
||||
// Otherwise assume it is a plain string
|
||||
options[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return options;
|
||||
};
|
||||
|
|
@ -0,0 +1,264 @@
|
|||
var mysql = require('../');
|
||||
var Connection = require('./Connection');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var Util = require('util');
|
||||
var PoolConnection = require('./PoolConnection');
|
||||
|
||||
module.exports = Pool;
|
||||
|
||||
Util.inherits(Pool, EventEmitter);
|
||||
function Pool(options) {
|
||||
EventEmitter.call(this);
|
||||
this.config = options.config;
|
||||
this.config.connectionConfig.pool = this;
|
||||
|
||||
this._acquiringConnections = [];
|
||||
this._allConnections = [];
|
||||
this._freeConnections = [];
|
||||
this._connectionQueue = [];
|
||||
this._closed = false;
|
||||
}
|
||||
|
||||
Pool.prototype.getConnection = function (cb) {
|
||||
|
||||
if (this._closed) {
|
||||
return process.nextTick(function(){
|
||||
return cb(new Error('Pool is closed.'));
|
||||
});
|
||||
}
|
||||
|
||||
var connection;
|
||||
var pool = this;
|
||||
|
||||
if (this._freeConnections.length > 0) {
|
||||
connection = this._freeConnections.shift();
|
||||
|
||||
return this.acquireConnection(connection, cb);
|
||||
}
|
||||
|
||||
if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) {
|
||||
connection = new PoolConnection(this, { config: this.config.newConnectionConfig() });
|
||||
|
||||
this._acquiringConnections.push(connection);
|
||||
this._allConnections.push(connection);
|
||||
|
||||
return connection.connect({timeout: this.config.acquireTimeout}, function onConnect(err) {
|
||||
spliceConnection(pool._acquiringConnections, connection);
|
||||
|
||||
if (pool._closed) {
|
||||
err = new Error('Pool is closed.');
|
||||
}
|
||||
|
||||
if (err) {
|
||||
pool._purgeConnection(connection);
|
||||
cb(err);
|
||||
return;
|
||||
}
|
||||
|
||||
pool.emit('connection', connection);
|
||||
cb(null, connection);
|
||||
});
|
||||
}
|
||||
|
||||
if (!this.config.waitForConnections) {
|
||||
return process.nextTick(function(){
|
||||
return cb(new Error('No connections available.'));
|
||||
});
|
||||
}
|
||||
|
||||
this._enqueueCallback(cb);
|
||||
};
|
||||
|
||||
Pool.prototype.acquireConnection = function acquireConnection(connection, cb) {
|
||||
if (connection._pool !== this) {
|
||||
throw new Error('Connection acquired from wrong pool.');
|
||||
}
|
||||
|
||||
var pool = this;
|
||||
|
||||
this._acquiringConnections.push(connection);
|
||||
|
||||
connection.ping({timeout: this.config.acquireTimeout}, function onPing(err) {
|
||||
spliceConnection(pool._acquiringConnections, connection);
|
||||
|
||||
if (pool._closed) {
|
||||
err = new Error('Pool is closed.');
|
||||
}
|
||||
|
||||
if (err) {
|
||||
pool._connectionQueue.unshift(cb);
|
||||
pool._purgeConnection(connection);
|
||||
return;
|
||||
}
|
||||
|
||||
cb(null, connection);
|
||||
});
|
||||
};
|
||||
|
||||
Pool.prototype.releaseConnection = function releaseConnection(connection) {
|
||||
var cb;
|
||||
|
||||
if (this._acquiringConnections.indexOf(connection) !== -1) {
|
||||
// connection is being acquired
|
||||
return;
|
||||
}
|
||||
|
||||
if (connection._pool) {
|
||||
if (connection._pool !== this) {
|
||||
throw new Error('Connection released to wrong pool');
|
||||
}
|
||||
|
||||
if (connection._purge) {
|
||||
// purge connection from pool
|
||||
this._purgeConnection(connection);
|
||||
return;
|
||||
} else if (this._freeConnections.indexOf(connection) !== -1) {
|
||||
// connection already in free connection pool
|
||||
// this won't catch all double-release cases
|
||||
throw new Error('Connection already released');
|
||||
} else {
|
||||
// add connection to end of free queue
|
||||
this._freeConnections.push(connection);
|
||||
}
|
||||
}
|
||||
|
||||
while (this._closed && this._connectionQueue.length) {
|
||||
// empty the connection queue
|
||||
cb = this._connectionQueue.shift();
|
||||
|
||||
process.nextTick(cb.bind(null, new Error('Pool is closed.')));
|
||||
}
|
||||
|
||||
if (this._connectionQueue.length) {
|
||||
cb = this._connectionQueue.shift();
|
||||
|
||||
this.getConnection(cb);
|
||||
}
|
||||
};
|
||||
|
||||
Pool.prototype.end = function (cb) {
|
||||
this._closed = true;
|
||||
|
||||
if (typeof cb != "function") {
|
||||
cb = function (err) {
|
||||
if (err) throw err;
|
||||
};
|
||||
}
|
||||
|
||||
var calledBack = false;
|
||||
var waitingClose = this._allConnections.length;
|
||||
|
||||
function onEnd(err) {
|
||||
if (calledBack) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (err || --waitingClose === 0) {
|
||||
calledBack = true;
|
||||
return cb(err);
|
||||
}
|
||||
}
|
||||
|
||||
if (waitingClose === 0) {
|
||||
return process.nextTick(cb);
|
||||
}
|
||||
|
||||
while (this._allConnections.length !== 0) {
|
||||
this._purgeConnection(this._allConnections[0], onEnd);
|
||||
}
|
||||
};
|
||||
|
||||
Pool.prototype.query = function (sql, values, cb) {
|
||||
var query = Connection.createQuery(sql, values, cb);
|
||||
|
||||
if (!(typeof sql === 'object' && 'typeCast' in sql)) {
|
||||
query.typeCast = this.config.connectionConfig.typeCast;
|
||||
}
|
||||
|
||||
if (this.config.connectionConfig.trace) {
|
||||
// Long stack trace support
|
||||
query._callSite = new Error;
|
||||
}
|
||||
|
||||
this.getConnection(function (err, conn) {
|
||||
if (err) {
|
||||
var cb = query._callback;
|
||||
cb && cb(err);
|
||||
return;
|
||||
}
|
||||
|
||||
// Release connection based off event
|
||||
query.once('end', function() {
|
||||
conn.release();
|
||||
});
|
||||
|
||||
conn.query(query);
|
||||
});
|
||||
|
||||
return query;
|
||||
};
|
||||
|
||||
Pool.prototype._enqueueCallback = function _enqueueCallback(callback) {
|
||||
|
||||
if (this.config.queueLimit && this._connectionQueue.length >= this.config.queueLimit) {
|
||||
process.nextTick(function () {
|
||||
var err = new Error('Queue limit reached.');
|
||||
err.code = 'POOL_ENQUEUELIMIT';
|
||||
callback(err);
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
// Bind to domain, as dequeue will likely occur in a different domain
|
||||
var cb = process.domain
|
||||
? process.domain.bind(callback)
|
||||
: callback;
|
||||
|
||||
this._connectionQueue.push(cb);
|
||||
this.emit('enqueue');
|
||||
};
|
||||
|
||||
Pool.prototype._purgeConnection = function _purgeConnection(connection, callback) {
|
||||
var cb = callback || function () {};
|
||||
|
||||
if (connection.state === 'disconnected') {
|
||||
connection.destroy();
|
||||
}
|
||||
|
||||
this._removeConnection(connection);
|
||||
|
||||
if (connection.state !== 'disconnected' && !connection._protocol._quitSequence) {
|
||||
connection._realEnd(cb);
|
||||
return;
|
||||
}
|
||||
|
||||
process.nextTick(cb);
|
||||
};
|
||||
|
||||
Pool.prototype._removeConnection = function(connection) {
|
||||
connection._pool = null;
|
||||
|
||||
// Remove connection from all connections
|
||||
spliceConnection(this._allConnections, connection);
|
||||
|
||||
// Remove connection from free connections
|
||||
spliceConnection(this._freeConnections, connection);
|
||||
|
||||
this.releaseConnection(connection);
|
||||
};
|
||||
|
||||
Pool.prototype.escape = function(value) {
|
||||
return mysql.escape(value, this.config.connectionConfig.stringifyObjects, this.config.connectionConfig.timezone);
|
||||
};
|
||||
|
||||
Pool.prototype.escapeId = function escapeId(value) {
|
||||
return mysql.escapeId(value, false);
|
||||
};
|
||||
|
||||
function spliceConnection(array, connection) {
|
||||
var index;
|
||||
if ((index = array.indexOf(connection)) !== -1) {
|
||||
// Remove connection from all connections
|
||||
array.splice(index, 1);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,256 @@
|
|||
var Pool = require('./Pool');
|
||||
var PoolConfig = require('./PoolConfig');
|
||||
var Util = require('util');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
|
||||
module.exports = PoolCluster;
|
||||
|
||||
/**
|
||||
* PoolCluster
|
||||
*/
|
||||
function PoolCluster(config) {
|
||||
EventEmitter.call(this);
|
||||
|
||||
config = config || {};
|
||||
this._canRetry = typeof config.canRetry === 'undefined' ? true : config.canRetry;
|
||||
this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
|
||||
this._defaultSelector = config.defaultSelector || 'RR';
|
||||
|
||||
this._closed = false;
|
||||
this._lastId = 0;
|
||||
this._nodes = {};
|
||||
this._serviceableNodeIds = [];
|
||||
this._namespaces = {};
|
||||
this._findCaches = {};
|
||||
}
|
||||
|
||||
Util.inherits(PoolCluster, EventEmitter);
|
||||
|
||||
PoolCluster.prototype.of = function(pattern, selector) {
|
||||
pattern = pattern || '*';
|
||||
|
||||
selector = selector || this._defaultSelector;
|
||||
selector = selector.toUpperCase();
|
||||
if (typeof Selector[selector] === 'undefined') {
|
||||
selector = this._defaultSelector;
|
||||
}
|
||||
|
||||
var key = pattern + selector;
|
||||
|
||||
if (typeof this._namespaces[key] === 'undefined') {
|
||||
this._namespaces[key] = new PoolNamespace(this, pattern, selector);
|
||||
}
|
||||
|
||||
return this._namespaces[key];
|
||||
};
|
||||
|
||||
PoolCluster.prototype.add = function(id, config) {
|
||||
if (typeof id === 'object') {
|
||||
config = id;
|
||||
id = 'CLUSTER::' + (++this._lastId);
|
||||
}
|
||||
|
||||
if (typeof this._nodes[id] === 'undefined') {
|
||||
this._nodes[id] = {
|
||||
id: id,
|
||||
errorCount: 0,
|
||||
pool: new Pool({config: new PoolConfig(config)})
|
||||
};
|
||||
|
||||
this._serviceableNodeIds.push(id);
|
||||
|
||||
this._clearFindCaches();
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype.getConnection = function(pattern, selector, cb) {
|
||||
var namespace;
|
||||
if (typeof pattern === 'function') {
|
||||
cb = pattern;
|
||||
namespace = this.of();
|
||||
} else {
|
||||
if (typeof selector === 'function') {
|
||||
cb = selector;
|
||||
selector = this._defaultSelector;
|
||||
}
|
||||
|
||||
namespace = this.of(pattern, selector);
|
||||
}
|
||||
|
||||
namespace.getConnection(cb);
|
||||
};
|
||||
|
||||
PoolCluster.prototype.end = function() {
|
||||
if (this._closed) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._closed = true;
|
||||
|
||||
for (var id in this._nodes) {
|
||||
this._nodes[id].pool.end();
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype._findNodeIds = function(pattern) {
|
||||
if (typeof this._findCaches[pattern] !== 'undefined') {
|
||||
return this._findCaches[pattern];
|
||||
}
|
||||
|
||||
var foundNodeIds;
|
||||
|
||||
if (pattern === '*') { // all
|
||||
foundNodeIds = this._serviceableNodeIds;
|
||||
} else if (this._serviceableNodeIds.indexOf(pattern) != -1) { // one
|
||||
foundNodeIds = [pattern];
|
||||
} else if (pattern[pattern.length - 1] === '*') {
|
||||
// wild matching
|
||||
var keyword = pattern.substring(pattern.length - 1, 0);
|
||||
|
||||
foundNodeIds = this._serviceableNodeIds.filter(function (id) {
|
||||
return id.indexOf(keyword) === 0;
|
||||
});
|
||||
} else {
|
||||
foundNodeIds = [];
|
||||
}
|
||||
|
||||
this._findCaches[pattern] = foundNodeIds;
|
||||
|
||||
return foundNodeIds;
|
||||
};
|
||||
|
||||
PoolCluster.prototype._getNode = function(id) {
|
||||
return this._nodes[id] || null;
|
||||
};
|
||||
|
||||
PoolCluster.prototype._increaseErrorCount = function(node) {
|
||||
if (++node.errorCount >= this._removeNodeErrorCount) {
|
||||
var index = this._serviceableNodeIds.indexOf(node.id);
|
||||
if (index !== -1) {
|
||||
this._serviceableNodeIds.splice(index, 1);
|
||||
delete this._nodes[node.id];
|
||||
|
||||
this._clearFindCaches();
|
||||
|
||||
node.pool.end();
|
||||
|
||||
this.emit('remove', node.id);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype._decreaseErrorCount = function(node) {
|
||||
if (node.errorCount > 0) {
|
||||
--node.errorCount;
|
||||
}
|
||||
};
|
||||
|
||||
PoolCluster.prototype._getConnection = function(node, cb) {
|
||||
var self = this;
|
||||
|
||||
node.pool.getConnection(function (err, connection) {
|
||||
if (err) {
|
||||
self._increaseErrorCount(node);
|
||||
cb(err);
|
||||
return;
|
||||
} else {
|
||||
self._decreaseErrorCount(node);
|
||||
}
|
||||
|
||||
connection._clusterId = node.id;
|
||||
|
||||
cb(null, connection);
|
||||
});
|
||||
};
|
||||
|
||||
PoolCluster.prototype._clearFindCaches = function() {
|
||||
this._findCaches = {};
|
||||
};
|
||||
|
||||
/**
|
||||
* PoolNamespace
|
||||
*/
|
||||
function PoolNamespace(cluster, pattern, selector) {
|
||||
this._cluster = cluster;
|
||||
this._pattern = pattern;
|
||||
this._selector = new Selector[selector]();
|
||||
}
|
||||
|
||||
PoolNamespace.prototype.getConnection = function(cb) {
|
||||
var clusterNode = this._getClusterNode();
|
||||
var cluster = this._cluster;
|
||||
var namespace = this;
|
||||
|
||||
if (clusterNode === null) {
|
||||
var err = new Error('Pool does not exist.')
|
||||
err.code = 'POOL_NOEXIST';
|
||||
return cb(err);
|
||||
}
|
||||
|
||||
cluster._getConnection(clusterNode, function(err, connection) {
|
||||
var retry = err && cluster._canRetry
|
||||
&& cluster._findNodeIds(namespace._pattern).length !== 0;
|
||||
|
||||
if (retry) {
|
||||
return namespace.getConnection(cb);
|
||||
}
|
||||
|
||||
if (err) {
|
||||
return cb(err);
|
||||
}
|
||||
|
||||
cb(null, connection);
|
||||
});
|
||||
};
|
||||
|
||||
PoolNamespace.prototype._getClusterNode = function _getClusterNode() {
|
||||
var foundNodeIds = this._cluster._findNodeIds(this._pattern);
|
||||
var nodeId;
|
||||
|
||||
switch (foundNodeIds.length) {
|
||||
case 0:
|
||||
nodeId = null;
|
||||
break;
|
||||
case 1:
|
||||
nodeId = foundNodeIds[0];
|
||||
break;
|
||||
default:
|
||||
nodeId = this._selector(foundNodeIds);
|
||||
break;
|
||||
}
|
||||
|
||||
return nodeId !== null
|
||||
? this._cluster._getNode(nodeId)
|
||||
: null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Selector
|
||||
*/
|
||||
var Selector = {};
|
||||
|
||||
Selector.RR = function () {
|
||||
var index = 0;
|
||||
|
||||
return function(clusterIds) {
|
||||
if (index >= clusterIds.length) {
|
||||
index = 0;
|
||||
}
|
||||
|
||||
var clusterId = clusterIds[index++];
|
||||
|
||||
return clusterId;
|
||||
};
|
||||
};
|
||||
|
||||
Selector.RANDOM = function () {
|
||||
return function(clusterIds) {
|
||||
return clusterIds[Math.floor(Math.random() * clusterIds.length)];
|
||||
};
|
||||
};
|
||||
|
||||
Selector.ORDER = function () {
|
||||
return function(clusterIds) {
|
||||
return clusterIds[0];
|
||||
};
|
||||
};
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
|
||||
var ConnectionConfig = require('./ConnectionConfig');
|
||||
|
||||
module.exports = PoolConfig;
|
||||
function PoolConfig(options) {
|
||||
if (typeof options === 'string') {
|
||||
options = ConnectionConfig.parseUrl(options);
|
||||
}
|
||||
|
||||
this.acquireTimeout = (options.acquireTimeout === undefined)
|
||||
? 10 * 1000
|
||||
: Number(options.acquireTimeout);
|
||||
this.connectionConfig = new ConnectionConfig(options);
|
||||
this.waitForConnections = (options.waitForConnections === undefined)
|
||||
? true
|
||||
: Boolean(options.waitForConnections);
|
||||
this.connectionLimit = (options.connectionLimit === undefined)
|
||||
? 10
|
||||
: Number(options.connectionLimit);
|
||||
this.queueLimit = (options.queueLimit === undefined)
|
||||
? 0
|
||||
: Number(options.queueLimit);
|
||||
}
|
||||
|
||||
PoolConfig.prototype.newConnectionConfig = function newConnectionConfig() {
|
||||
var connectionConfig = new ConnectionConfig(this.connectionConfig);
|
||||
|
||||
connectionConfig.clientFlags = this.connectionConfig.clientFlags;
|
||||
connectionConfig.maxPacketSize = this.connectionConfig.maxPacketSize;
|
||||
|
||||
return connectionConfig;
|
||||
};
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
var inherits = require('util').inherits;
|
||||
var Connection = require('./Connection')
|
||||
var __changeUser = Connection.prototype.changeUser;
|
||||
|
||||
module.exports = PoolConnection;
|
||||
inherits(PoolConnection, Connection);
|
||||
|
||||
function PoolConnection(pool, options) {
|
||||
Connection.call(this, options);
|
||||
this._pool = pool;
|
||||
this._purge = false
|
||||
|
||||
// When a fatal error occurs the connection's protocol ends, which will cause
|
||||
// the connection to end as well, thus we only need to watch for the end event
|
||||
// and we will be notified of disconnects.
|
||||
this.on('end', this._removeFromPool);
|
||||
this.on('error', this._removeFromPool);
|
||||
}
|
||||
|
||||
PoolConnection.prototype.changeUser = function changeUser(options, callback) {
|
||||
this._purge = true;
|
||||
|
||||
return __changeUser.apply(this, arguments);
|
||||
};
|
||||
|
||||
PoolConnection.prototype.release = function release() {
|
||||
var pool = this._pool;
|
||||
|
||||
if (!pool || pool._closed) {
|
||||
return;
|
||||
}
|
||||
|
||||
return pool.releaseConnection(this);
|
||||
};
|
||||
|
||||
// TODO: Remove this when we are removing PoolConnection#end
|
||||
PoolConnection.prototype._realEnd = Connection.prototype.end;
|
||||
|
||||
PoolConnection.prototype.end = function () {
|
||||
console.warn( 'Calling conn.end() to release a pooled connection is '
|
||||
+ 'deprecated. In next version calling conn.end() will be '
|
||||
+ 'restored to default conn.end() behavior. Use '
|
||||
+ 'conn.release() instead.'
|
||||
);
|
||||
this.release();
|
||||
};
|
||||
|
||||
PoolConnection.prototype.destroy = function () {
|
||||
this._removeFromPool(this);
|
||||
return Connection.prototype.destroy.apply(this, arguments);
|
||||
};
|
||||
|
||||
PoolConnection.prototype._removeFromPool = function(connection) {
|
||||
if (!this._pool || this._pool._closed) {
|
||||
return;
|
||||
}
|
||||
|
||||
var pool = this._pool;
|
||||
this._pool = null;
|
||||
|
||||
pool._removeConnection(this);
|
||||
};
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
var Buffer = require('buffer').Buffer;
|
||||
var Crypto = require('crypto');
|
||||
var Auth = exports;
|
||||
|
||||
function sha1(msg) {
|
||||
var hash = Crypto.createHash('sha1');
|
||||
hash.update(msg, 'binary');
|
||||
return hash.digest('binary');
|
||||
}
|
||||
Auth.sha1 = sha1;
|
||||
|
||||
function xor(a, b) {
|
||||
a = new Buffer(a, 'binary');
|
||||
b = new Buffer(b, 'binary');
|
||||
var result = new Buffer(a.length);
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
result[i] = (a[i] ^ b[i]);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
Auth.xor = xor;
|
||||
|
||||
Auth.token = function(password, scramble) {
|
||||
if (!password) {
|
||||
return new Buffer(0);
|
||||
}
|
||||
|
||||
// password must be in binary format, not utf8
|
||||
var stage1 = sha1((new Buffer(password, "utf8")).toString("binary"));
|
||||
var stage2 = sha1(stage1);
|
||||
var stage3 = sha1(scramble.toString('binary') + stage2);
|
||||
return xor(stage3, stage1);
|
||||
};
|
||||
|
||||
// This is a port of sql/password.c:hash_password which needs to be used for
|
||||
// pre-4.1 passwords.
|
||||
Auth.hashPassword = function(password) {
|
||||
var nr = [0x5030, 0x5735],
|
||||
add = 7,
|
||||
nr2 = [0x1234, 0x5671],
|
||||
result = new Buffer(8);
|
||||
|
||||
if (typeof password == 'string'){
|
||||
password = new Buffer(password);
|
||||
}
|
||||
|
||||
for (var i = 0; i < password.length; i++) {
|
||||
var c = password[i];
|
||||
if (c == 32 || c == 9) {
|
||||
// skip space in password
|
||||
continue;
|
||||
}
|
||||
|
||||
// nr^= (((nr & 63)+add)*c)+ (nr << 8);
|
||||
// nr = xor(nr, add(mul(add(and(nr, 63), add), c), shl(nr, 8)))
|
||||
nr = this.xor32(nr, this.add32(this.mul32(this.add32(this.and32(nr, [0,63]), [0,add]), [0,c]), this.shl32(nr, 8)));
|
||||
|
||||
// nr2+=(nr2 << 8) ^ nr;
|
||||
// nr2 = add(nr2, xor(shl(nr2, 8), nr))
|
||||
nr2 = this.add32(nr2, this.xor32(this.shl32(nr2, 8), nr));
|
||||
|
||||
// add+=tmp;
|
||||
add += c;
|
||||
}
|
||||
|
||||
this.int31Write(result, nr, 0);
|
||||
this.int31Write(result, nr2, 4);
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
Auth.randomInit = function(seed1, seed2) {
|
||||
return {
|
||||
max_value: 0x3FFFFFFF,
|
||||
max_value_dbl: 0x3FFFFFFF,
|
||||
seed1: seed1 % 0x3FFFFFFF,
|
||||
seed2: seed2 % 0x3FFFFFFF
|
||||
};
|
||||
};
|
||||
|
||||
Auth.myRnd = function(r){
|
||||
r.seed1 = (r.seed1 * 3 + r.seed2) % r.max_value;
|
||||
r.seed2 = (r.seed1 + r.seed2 + 33) % r.max_value;
|
||||
|
||||
return r.seed1 / r.max_value_dbl;
|
||||
};
|
||||
|
||||
Auth.scramble323 = function(message, password) {
|
||||
var to = new Buffer(8),
|
||||
hashPass = this.hashPassword(password),
|
||||
hashMessage = this.hashPassword(message.slice(0, 8)),
|
||||
seed1 = this.int32Read(hashPass, 0) ^ this.int32Read(hashMessage, 0),
|
||||
seed2 = this.int32Read(hashPass, 4) ^ this.int32Read(hashMessage, 4),
|
||||
r = this.randomInit(seed1, seed2);
|
||||
|
||||
for (var i = 0; i < 8; i++){
|
||||
to[i] = Math.floor(this.myRnd(r) * 31) + 64;
|
||||
}
|
||||
var extra = (Math.floor(this.myRnd(r) * 31));
|
||||
|
||||
for (var i = 0; i < 8; i++){
|
||||
to[i] ^= extra;
|
||||
}
|
||||
|
||||
return to;
|
||||
};
|
||||
|
||||
Auth.fmt32 = function(x){
|
||||
var a = x[0].toString(16),
|
||||
b = x[1].toString(16);
|
||||
|
||||
if (a.length == 1) a = '000'+a;
|
||||
if (a.length == 2) a = '00'+a;
|
||||
if (a.length == 3) a = '0'+a;
|
||||
if (b.length == 1) b = '000'+b;
|
||||
if (b.length == 2) b = '00'+b;
|
||||
if (b.length == 3) b = '0'+b;
|
||||
return '' + a + '/' + b;
|
||||
};
|
||||
|
||||
Auth.xor32 = function(a,b){
|
||||
return [a[0] ^ b[0], a[1] ^ b[1]];
|
||||
};
|
||||
|
||||
Auth.add32 = function(a,b){
|
||||
var w1 = a[1] + b[1],
|
||||
w2 = a[0] + b[0] + ((w1 & 0xFFFF0000) >> 16);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.mul32 = function(a,b){
|
||||
// based on this example of multiplying 32b ints using 16b
|
||||
// http://www.dsprelated.com/showmessage/89790/1.php
|
||||
var w1 = a[1] * b[1],
|
||||
w2 = (((a[1] * b[1]) >> 16) & 0xFFFF) + ((a[0] * b[1]) & 0xFFFF) + (a[1] * b[0] & 0xFFFF);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.and32 = function(a,b){
|
||||
return [a[0] & b[0], a[1] & b[1]];
|
||||
};
|
||||
|
||||
Auth.shl32 = function(a,b){
|
||||
// assume b is 16 or less
|
||||
var w1 = a[1] << b,
|
||||
w2 = (a[0] << b) | ((w1 & 0xFFFF0000) >> 16);
|
||||
|
||||
return [w2 & 0xFFFF, w1 & 0xFFFF];
|
||||
};
|
||||
|
||||
Auth.int31Write = function(buffer, number, offset) {
|
||||
buffer[offset] = (number[0] >> 8) & 0x7F;
|
||||
buffer[offset + 1] = (number[0]) & 0xFF;
|
||||
buffer[offset + 2] = (number[1] >> 8) & 0xFF;
|
||||
buffer[offset + 3] = (number[1]) & 0xFF;
|
||||
};
|
||||
|
||||
Auth.int32Read = function(buffer, offset){
|
||||
return (buffer[offset] << 24)
|
||||
+ (buffer[offset+1] << 16)
|
||||
+ (buffer[offset+2] << 8)
|
||||
+ (buffer[offset+3]);
|
||||
};
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
module.exports = PacketHeader;
|
||||
function PacketHeader(length, number) {
|
||||
this.length = length;
|
||||
this.number = number;
|
||||
}
|
||||
|
|
@ -0,0 +1,197 @@
|
|||
var BIT_16 = Math.pow(2, 16);
|
||||
var BIT_24 = Math.pow(2, 24);
|
||||
// The maximum precision JS Numbers can hold precisely
|
||||
// Don't panic: Good enough to represent byte values up to 8192 TB
|
||||
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
||||
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
||||
|
||||
module.exports = PacketWriter;
|
||||
function PacketWriter() {
|
||||
this._buffer = new Buffer(0);
|
||||
this._offset = 0;
|
||||
}
|
||||
|
||||
PacketWriter.prototype.toBuffer = function(parser) {
|
||||
var packets = Math.floor(this._buffer.length / MAX_PACKET_LENGTH) + 1;
|
||||
var buffer = this._buffer;
|
||||
this._buffer = new Buffer(this._buffer.length + packets * 4);
|
||||
|
||||
for (var packet = 0; packet < packets; packet++) {
|
||||
this._offset = packet * (MAX_PACKET_LENGTH + 4);
|
||||
|
||||
var isLast = (packet + 1 === packets);
|
||||
var packetLength = (isLast)
|
||||
? buffer.length % MAX_PACKET_LENGTH
|
||||
: MAX_PACKET_LENGTH;
|
||||
|
||||
var packetNumber = parser.incrementPacketNumber();
|
||||
|
||||
this.writeUnsignedNumber(3, packetLength);
|
||||
this.writeUnsignedNumber(1, packetNumber);
|
||||
|
||||
var start = packet * MAX_PACKET_LENGTH;
|
||||
var end = start + packetLength;
|
||||
|
||||
this.writeBuffer(buffer.slice(start, end));
|
||||
}
|
||||
|
||||
return this._buffer;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeUnsignedNumber = function(bytes, value) {
|
||||
this._allocate(bytes);
|
||||
|
||||
for (var i = 0; i < bytes; i++) {
|
||||
this._buffer[this._offset++] = (value >> (i * 8)) & 0xff;
|
||||
}
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeFiller = function(bytes) {
|
||||
this._allocate(bytes);
|
||||
|
||||
for (var i = 0; i < bytes; i++) {
|
||||
this._buffer[this._offset++] = 0x00;
|
||||
}
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeNullTerminatedString = function(value, encoding) {
|
||||
// Typecast undefined into '' and numbers into strings
|
||||
value = value || '';
|
||||
value = value + '';
|
||||
|
||||
var bytes = Buffer.byteLength(value, encoding || 'utf-8') + 1;
|
||||
this._allocate(bytes);
|
||||
|
||||
this._buffer.write(value, this._offset, encoding);
|
||||
this._buffer[this._offset + bytes - 1] = 0x00;
|
||||
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeString = function(value) {
|
||||
// Typecast undefined into '' and numbers into strings
|
||||
value = value || '';
|
||||
value = value + '';
|
||||
|
||||
var bytes = Buffer.byteLength(value, 'utf-8');
|
||||
this._allocate(bytes);
|
||||
|
||||
this._buffer.write(value, this._offset, 'utf-8');
|
||||
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeBuffer = function(value) {
|
||||
var bytes = value.length;
|
||||
|
||||
this._allocate(bytes);
|
||||
value.copy(this._buffer, this._offset);
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedNumber = function(value) {
|
||||
if (value === null) {
|
||||
this._allocate(1);
|
||||
this._buffer[this._offset++] = 251;
|
||||
return;
|
||||
}
|
||||
|
||||
if (value <= 250) {
|
||||
this._allocate(1);
|
||||
this._buffer[this._offset++] = value;
|
||||
return;
|
||||
}
|
||||
|
||||
if (value > IEEE_754_BINARY_64_PRECISION) {
|
||||
throw new Error(
|
||||
'writeLengthCodedNumber: JS precision range exceeded, your ' +
|
||||
'number is > 53 bit: "' + value + '"'
|
||||
);
|
||||
}
|
||||
|
||||
if (value <= BIT_16) {
|
||||
this._allocate(3)
|
||||
this._buffer[this._offset++] = 252;
|
||||
} else if (value <= BIT_24) {
|
||||
this._allocate(4)
|
||||
this._buffer[this._offset++] = 253;
|
||||
} else {
|
||||
this._allocate(9);
|
||||
this._buffer[this._offset++] = 254;
|
||||
}
|
||||
|
||||
// 16 Bit
|
||||
this._buffer[this._offset++] = value & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 8) & 0xff;
|
||||
|
||||
if (value <= BIT_16) return;
|
||||
|
||||
// 24 Bit
|
||||
this._buffer[this._offset++] = (value >> 16) & 0xff;
|
||||
|
||||
if (value <= BIT_24) return;
|
||||
|
||||
this._buffer[this._offset++] = (value >> 24) & 0xff;
|
||||
|
||||
// Hack: Get the most significant 32 bit (JS bitwise operators are 32 bit)
|
||||
value = value.toString(2);
|
||||
value = value.substr(0, value.length - 32);
|
||||
value = parseInt(value, 2);
|
||||
|
||||
this._buffer[this._offset++] = value & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 8) & 0xff;
|
||||
this._buffer[this._offset++] = (value >> 16) & 0xff;
|
||||
|
||||
// Set last byte to 0, as we can only support 53 bits in JS (see above)
|
||||
this._buffer[this._offset++] = 0;
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedBuffer = function(value) {
|
||||
var bytes = value.length;
|
||||
this.writeLengthCodedNumber(bytes);
|
||||
this.writeBuffer(value);
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeNullTerminatedBuffer = function(value) {
|
||||
this.writeBuffer(value);
|
||||
this.writeFiller(1); // 0x00 terminator
|
||||
};
|
||||
|
||||
PacketWriter.prototype.writeLengthCodedString = function(value) {
|
||||
if (value === null) {
|
||||
this.writeLengthCodedNumber(null);
|
||||
return;
|
||||
}
|
||||
|
||||
value = (value === undefined)
|
||||
? ''
|
||||
: String(value);
|
||||
|
||||
var bytes = Buffer.byteLength(value, 'utf-8');
|
||||
this.writeLengthCodedNumber(bytes);
|
||||
|
||||
if (!bytes) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._allocate(bytes);
|
||||
this._buffer.write(value, this._offset, 'utf-8');
|
||||
this._offset += bytes;
|
||||
};
|
||||
|
||||
PacketWriter.prototype._allocate = function(bytes) {
|
||||
if (!this._buffer) {
|
||||
this._buffer = new Buffer(bytes);
|
||||
return;
|
||||
}
|
||||
|
||||
var bytesRemaining = this._buffer.length - this._offset;
|
||||
if (bytesRemaining >= bytes) {
|
||||
return;
|
||||
}
|
||||
|
||||
var oldBuffer = this._buffer;
|
||||
|
||||
this._buffer = new Buffer(oldBuffer.length + bytes);
|
||||
oldBuffer.copy(this._buffer);
|
||||
};
|
||||
|
|
@ -0,0 +1,423 @@
|
|||
var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
|
||||
var MUL_32BIT = Math.pow(2, 32);
|
||||
var PacketHeader = require('./PacketHeader');
|
||||
var BigNumber = require('bignumber.js');
|
||||
|
||||
module.exports = Parser;
|
||||
function Parser(options) {
|
||||
options = options || {};
|
||||
|
||||
this._supportBigNumbers = options.config && options.config.supportBigNumbers;
|
||||
this._buffer = new Buffer(0);
|
||||
this._longPacketBuffers = [];
|
||||
this._offset = 0;
|
||||
this._packetEnd = null;
|
||||
this._packetHeader = null;
|
||||
this._packetOffset = null;
|
||||
this._onError = options.onError || function(err) { throw err; };
|
||||
this._onPacket = options.onPacket || function() {};
|
||||
this._nextPacketNumber = 0;
|
||||
this._encoding = 'utf-8';
|
||||
this._paused = false;
|
||||
}
|
||||
|
||||
Parser.prototype.write = function(buffer) {
|
||||
this.append(buffer);
|
||||
|
||||
while (true) {
|
||||
if (this._paused) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!this._packetHeader) {
|
||||
if (this._bytesRemaining() < 4) {
|
||||
break;
|
||||
}
|
||||
|
||||
this._packetHeader = new PacketHeader(
|
||||
this.parseUnsignedNumber(3),
|
||||
this.parseUnsignedNumber(1)
|
||||
);
|
||||
|
||||
if (this._packetHeader.number !== this._nextPacketNumber) {
|
||||
var err = new Error(
|
||||
'Packets out of order. Got: ' + this._packetHeader.number + ' ' +
|
||||
'Expected: ' + this._nextPacketNumber
|
||||
);
|
||||
|
||||
err.code = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
|
||||
err.fatal = true;
|
||||
|
||||
this._onError(err);
|
||||
}
|
||||
|
||||
this.incrementPacketNumber();
|
||||
}
|
||||
|
||||
if (this._bytesRemaining() < this._packetHeader.length) {
|
||||
break;
|
||||
}
|
||||
|
||||
this._packetEnd = this._offset + this._packetHeader.length;
|
||||
this._packetOffset = this._offset;
|
||||
|
||||
if (this._packetHeader.length === MAX_PACKET_LENGTH) {
|
||||
this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
|
||||
|
||||
this._advanceToNextPacket();
|
||||
continue;
|
||||
}
|
||||
|
||||
this._combineLongPacketBuffers();
|
||||
|
||||
// Try...finally to ensure exception safety. Unfortunately this is costing
|
||||
// us up to ~10% performance in some benchmarks.
|
||||
var hadException = true;
|
||||
try {
|
||||
this._onPacket(this._packetHeader);
|
||||
hadException = false;
|
||||
} catch (err) {
|
||||
if (typeof err.code !== 'string' || err.code.substr(0, 7) !== 'PARSER_') {
|
||||
// Rethrow unknown errors
|
||||
throw err;
|
||||
}
|
||||
|
||||
// Pass down parser errors
|
||||
this._onError(err);
|
||||
hadException = false;
|
||||
} finally {
|
||||
this._advanceToNextPacket();
|
||||
|
||||
// If we had an exception, the parser while loop will be broken out
|
||||
// of after the finally block. So we need to make sure to re-enter it
|
||||
// to continue parsing any bytes that may already have been received.
|
||||
if (hadException) {
|
||||
process.nextTick(this.write.bind(this));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Parser.prototype.append = function append(chunk) {
|
||||
if (!chunk || chunk.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
var buffer = chunk;
|
||||
var sliceEnd = this._buffer.length;
|
||||
var sliceStart = this._packetOffset === null
|
||||
? this._offset
|
||||
: this._packetOffset;
|
||||
var sliceLength = sliceEnd - sliceStart;
|
||||
|
||||
if (sliceLength !== 0) {
|
||||
// Create a new Buffer
|
||||
buffer = new Buffer(sliceLength + chunk.length);
|
||||
|
||||
// Copy data
|
||||
this._buffer.copy(buffer, 0, sliceStart, sliceEnd);
|
||||
chunk.copy(buffer, sliceLength);
|
||||
}
|
||||
|
||||
// Adjust data-tracking pointers
|
||||
this._buffer = buffer;
|
||||
this._offset = this._offset - sliceStart;
|
||||
this._packetEnd = this._packetEnd !== null
|
||||
? this._packetEnd - sliceStart
|
||||
: null;
|
||||
this._packetOffset = this._packetOffset !== null
|
||||
? this._packetOffset - sliceStart
|
||||
: null;
|
||||
};
|
||||
|
||||
Parser.prototype.pause = function() {
|
||||
this._paused = true;
|
||||
};
|
||||
|
||||
Parser.prototype.resume = function() {
|
||||
this._paused = false;
|
||||
|
||||
// nextTick() to avoid entering write() multiple times within the same stack
|
||||
// which would cause problems as write manipulates the state of the object.
|
||||
process.nextTick(this.write.bind(this));
|
||||
};
|
||||
|
||||
Parser.prototype.peak = function() {
|
||||
return this._buffer[this._offset];
|
||||
};
|
||||
|
||||
Parser.prototype.parseUnsignedNumber = function(bytes) {
|
||||
if (bytes === 1) {
|
||||
return this._buffer[this._offset++];
|
||||
}
|
||||
|
||||
var buffer = this._buffer;
|
||||
var offset = this._offset + bytes - 1;
|
||||
var value = 0;
|
||||
|
||||
if (bytes > 4) {
|
||||
var err = new Error('parseUnsignedNumber: Supports only up to 4 bytes');
|
||||
err.offset = (this._offset - this._packetOffset - 1);
|
||||
err.code = 'PARSER_UNSIGNED_TOO_LONG';
|
||||
throw err;
|
||||
}
|
||||
|
||||
while (offset >= this._offset) {
|
||||
value = ((value << 8) | buffer[offset]) >>> 0;
|
||||
offset--;
|
||||
}
|
||||
|
||||
this._offset += bytes;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedString = function() {
|
||||
var length = this.parseLengthCodedNumber();
|
||||
|
||||
if (length === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this.parseString(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedBuffer = function() {
|
||||
var length = this.parseLengthCodedNumber();
|
||||
|
||||
if (length === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return this.parseBuffer(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
|
||||
if (this._offset >= this._buffer.length) {
|
||||
var err = new Error('Parser: read past end');
|
||||
err.offset = (this._offset - this._packetOffset);
|
||||
err.code = 'PARSER_READ_PAST_END';
|
||||
throw err;
|
||||
}
|
||||
|
||||
var bits = this._buffer[this._offset++];
|
||||
|
||||
if (bits <= 250) {
|
||||
return bits;
|
||||
}
|
||||
|
||||
switch (bits) {
|
||||
case 251:
|
||||
return null;
|
||||
case 252:
|
||||
return this.parseUnsignedNumber(2);
|
||||
case 253:
|
||||
return this.parseUnsignedNumber(3);
|
||||
case 254:
|
||||
break;
|
||||
default:
|
||||
var err = new Error('Unexpected first byte' + (bits ? ': 0x' + bits.toString(16) : ''));
|
||||
err.offset = (this._offset - this._packetOffset - 1);
|
||||
err.code = 'PARSER_BAD_LENGTH_BYTE';
|
||||
throw err;
|
||||
}
|
||||
|
||||
var low = this.parseUnsignedNumber(4);
|
||||
var high = this.parseUnsignedNumber(4);
|
||||
var value;
|
||||
|
||||
if (high >>> 21) {
|
||||
value = (new BigNumber(low)).plus((new BigNumber(MUL_32BIT)).times(high)).toString();
|
||||
|
||||
if (this._supportBigNumbers) {
|
||||
return value;
|
||||
}
|
||||
|
||||
var err = new Error(
|
||||
'parseLengthCodedNumber: JS precision range exceeded, ' +
|
||||
'number is >= 53 bit: "' + value + '"'
|
||||
);
|
||||
err.offset = (this._offset - this._packetOffset - 8);
|
||||
err.code = 'PARSER_JS_PRECISION_RANGE_EXCEEDED';
|
||||
throw err;
|
||||
}
|
||||
|
||||
value = low + (MUL_32BIT * high);
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseFiller = function(length) {
|
||||
return this.parseBuffer(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseNullTerminatedBuffer = function() {
|
||||
var end = this._nullByteOffset();
|
||||
var value = this._buffer.slice(this._offset, end);
|
||||
this._offset = end + 1;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseNullTerminatedString = function() {
|
||||
var end = this._nullByteOffset();
|
||||
var value = this._buffer.toString(this._encoding, this._offset, end);
|
||||
this._offset = end + 1;
|
||||
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype._nullByteOffset = function() {
|
||||
var offset = this._offset;
|
||||
|
||||
while (this._buffer[offset] !== 0x00) {
|
||||
offset++;
|
||||
|
||||
if (offset >= this._buffer.length) {
|
||||
var err = new Error('Offset of null terminated string not found.');
|
||||
err.offset = (this._offset - this._packetOffset);
|
||||
err.code = 'PARSER_MISSING_NULL_BYTE';
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
return offset;
|
||||
};
|
||||
|
||||
Parser.prototype.parsePacketTerminatedString = function() {
|
||||
var length = this._packetEnd - this._offset;
|
||||
return this.parseString(length);
|
||||
};
|
||||
|
||||
Parser.prototype.parseBuffer = function(length) {
|
||||
var response = new Buffer(length);
|
||||
this._buffer.copy(response, 0, this._offset, this._offset + length);
|
||||
|
||||
this._offset += length;
|
||||
return response;
|
||||
};
|
||||
|
||||
Parser.prototype.parseString = function(length) {
|
||||
var offset = this._offset;
|
||||
var end = offset + length;
|
||||
var value = this._buffer.toString(this._encoding, offset, end);
|
||||
|
||||
this._offset = end;
|
||||
return value;
|
||||
};
|
||||
|
||||
Parser.prototype.parseGeometryValue = function() {
|
||||
var buffer = this.parseLengthCodedBuffer();
|
||||
var offset = 4;
|
||||
|
||||
if (buffer === null || !buffer.length) {
|
||||
return null;
|
||||
}
|
||||
|
||||
function parseGeometry() {
|
||||
var result = null;
|
||||
var byteOrder = buffer.readUInt8(offset); offset += 1;
|
||||
var wkbType = byteOrder? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
switch(wkbType) {
|
||||
case 1: // WKBPoint
|
||||
var x = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
result = {x: x, y: y};
|
||||
break;
|
||||
case 2: // WKBLineString
|
||||
var numPoints = byteOrder? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
result = [];
|
||||
for(var i=numPoints;i>0;i--) {
|
||||
var x = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
result.push({x: x, y: y});
|
||||
}
|
||||
break;
|
||||
case 3: // WKBPolygon
|
||||
var numRings = byteOrder? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
result = [];
|
||||
for(var i=numRings;i>0;i--) {
|
||||
var numPoints = byteOrder? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
var line = [];
|
||||
for(var j=numPoints;j>0;j--) {
|
||||
var x = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
var y = byteOrder? buffer.readDoubleLE(offset) : buffer.readDoubleBE(offset); offset += 8;
|
||||
line.push({x: x, y: y});
|
||||
}
|
||||
result.push(line);
|
||||
}
|
||||
break;
|
||||
case 4: // WKBMultiPoint
|
||||
case 5: // WKBMultiLineString
|
||||
case 6: // WKBMultiPolygon
|
||||
case 7: // WKBGeometryCollection
|
||||
var num = byteOrder? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset); offset += 4;
|
||||
var result = [];
|
||||
for(var i=num;i>0;i--) {
|
||||
result.push(parseGeometry());
|
||||
}
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return parseGeometry();
|
||||
};
|
||||
|
||||
Parser.prototype.reachedPacketEnd = function() {
|
||||
return this._offset === this._packetEnd;
|
||||
};
|
||||
|
||||
Parser.prototype._bytesRemaining = function() {
|
||||
return this._buffer.length - this._offset;
|
||||
};
|
||||
|
||||
Parser.prototype.incrementPacketNumber = function() {
|
||||
var currentPacketNumber = this._nextPacketNumber;
|
||||
this._nextPacketNumber = (this._nextPacketNumber + 1) % 256;
|
||||
|
||||
return currentPacketNumber;
|
||||
};
|
||||
|
||||
Parser.prototype.resetPacketNumber = function() {
|
||||
this._nextPacketNumber = 0;
|
||||
};
|
||||
|
||||
Parser.prototype.packetLength = function() {
|
||||
return this._longPacketBuffers.reduce(function(length, buffer) {
|
||||
return length + buffer.length;
|
||||
}, this._packetHeader.length);
|
||||
};
|
||||
|
||||
Parser.prototype._combineLongPacketBuffers = function() {
|
||||
if (!this._longPacketBuffers.length) {
|
||||
return;
|
||||
}
|
||||
|
||||
var trailingPacketBytes = this._buffer.length - this._packetEnd;
|
||||
|
||||
var length = this._longPacketBuffers.reduce(function(length, buffer) {
|
||||
return length + buffer.length;
|
||||
}, this._bytesRemaining());
|
||||
|
||||
var combinedBuffer = new Buffer(length);
|
||||
|
||||
var offset = this._longPacketBuffers.reduce(function(offset, buffer) {
|
||||
buffer.copy(combinedBuffer, offset);
|
||||
return offset + buffer.length;
|
||||
}, 0);
|
||||
|
||||
this._buffer.copy(combinedBuffer, offset, this._offset);
|
||||
|
||||
this._buffer = combinedBuffer;
|
||||
this._longPacketBuffers = [];
|
||||
this._offset = 0;
|
||||
this._packetEnd = this._buffer.length - trailingPacketBytes;
|
||||
this._packetOffset = 0;
|
||||
};
|
||||
|
||||
Parser.prototype._advanceToNextPacket = function() {
|
||||
this._offset = this._packetEnd;
|
||||
this._packetHeader = null;
|
||||
this._packetEnd = null;
|
||||
this._packetOffset = null;
|
||||
};
|
||||
|
|
@ -0,0 +1,446 @@
|
|||
var Parser = require('./Parser');
|
||||
var Sequences = require('./sequences');
|
||||
var Packets = require('./packets');
|
||||
var Timers = require('timers');
|
||||
var Stream = require('stream').Stream;
|
||||
var Util = require('util');
|
||||
var PacketWriter = require('./PacketWriter');
|
||||
|
||||
module.exports = Protocol;
|
||||
Util.inherits(Protocol, Stream);
|
||||
function Protocol(options) {
|
||||
Stream.call(this);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this.readable = true;
|
||||
this.writable = true;
|
||||
|
||||
this._config = options.config || {};
|
||||
this._connection = options.connection;
|
||||
this._callback = null;
|
||||
this._fatalError = null;
|
||||
this._quitSequence = null;
|
||||
this._handshakeSequence = null;
|
||||
this._handshaked = false;
|
||||
this._ended = false;
|
||||
this._destroyed = false;
|
||||
this._queue = [];
|
||||
this._handshakeInitializationPacket = null;
|
||||
|
||||
this._parser = new Parser({
|
||||
onError : this.handleParserError.bind(this),
|
||||
onPacket : this._parsePacket.bind(this),
|
||||
config : this._config
|
||||
});
|
||||
}
|
||||
|
||||
Protocol.prototype.write = function(buffer) {
|
||||
this._parser.write(buffer);
|
||||
return true;
|
||||
};
|
||||
|
||||
Protocol.prototype.handshake = function handshake(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
options.config = this._config;
|
||||
|
||||
return this._handshakeSequence = this._enqueue(new Sequences.Handshake(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.query = function query(options, callback) {
|
||||
return this._enqueue(new Sequences.Query(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.changeUser = function changeUser(options, callback) {
|
||||
return this._enqueue(new Sequences.ChangeUser(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.ping = function ping(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
return this._enqueue(new Sequences.Ping(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.stats = function stats(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
return this._enqueue(new Sequences.Statistics(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.quit = function quit(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
return this._quitSequence = this._enqueue(new Sequences.Quit(options, callback));
|
||||
};
|
||||
|
||||
Protocol.prototype.end = function() {
|
||||
if(this._ended) {
|
||||
return;
|
||||
}
|
||||
this._ended = true;
|
||||
|
||||
var expected = (this._quitSequence && this._queue[0] === this._quitSequence);
|
||||
if (expected) {
|
||||
this._quitSequence.end();
|
||||
this.emit('end');
|
||||
return;
|
||||
}
|
||||
|
||||
var err = new Error('Connection lost: The server closed the connection.');
|
||||
err.fatal = true;
|
||||
err.code = 'PROTOCOL_CONNECTION_LOST';
|
||||
|
||||
this._delegateError(err);
|
||||
};
|
||||
|
||||
Protocol.prototype.pause = function() {
|
||||
this._parser.pause();
|
||||
// Since there is a file stream in query, we must transmit pause/resume event to current sequence.
|
||||
var seq = this._queue[0];
|
||||
if (seq && seq.emit) {
|
||||
seq.emit('pause');
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.resume = function() {
|
||||
this._parser.resume();
|
||||
// Since there is a file stream in query, we must transmit pause/resume event to current sequence.
|
||||
var seq = this._queue[0];
|
||||
if (seq && seq.emit) {
|
||||
seq.emit('resume');
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._enqueue = function(sequence) {
|
||||
if (!this._validateEnqueue(sequence)) {
|
||||
return sequence;
|
||||
}
|
||||
|
||||
if (this._config.trace) {
|
||||
// Long stack trace support
|
||||
sequence._callSite = sequence._callSite || new Error;
|
||||
}
|
||||
|
||||
this._queue.push(sequence);
|
||||
this.emit('enqueue', sequence);
|
||||
|
||||
var self = this;
|
||||
sequence
|
||||
.on('error', function(err) {
|
||||
self._delegateError(err, sequence);
|
||||
})
|
||||
.on('packet', function(packet) {
|
||||
Timers.active(sequence);
|
||||
self._emitPacket(packet);
|
||||
})
|
||||
.on('end', function() {
|
||||
self._dequeue(sequence);
|
||||
})
|
||||
.on('timeout', function() {
|
||||
var err = new Error(sequence.constructor.name + ' inactivity timeout');
|
||||
|
||||
err.code = 'PROTOCOL_SEQUENCE_TIMEOUT';
|
||||
err.fatal = true;
|
||||
err.timeout = sequence._timeout;
|
||||
|
||||
self._delegateError(err, sequence);
|
||||
})
|
||||
.on('start-tls', function() {
|
||||
Timers.active(sequence);
|
||||
self._connection._startTLS(function(err) {
|
||||
if (err) {
|
||||
// SSL negotiation error are fatal
|
||||
err.code = 'HANDSHAKE_SSL_ERROR';
|
||||
err.fatal = true;
|
||||
sequence.end(err);
|
||||
return
|
||||
}
|
||||
|
||||
Timers.active(sequence);
|
||||
sequence._tlsUpgradeCompleteHandler();
|
||||
})
|
||||
});
|
||||
|
||||
if (this._queue.length === 1) {
|
||||
this._parser.resetPacketNumber();
|
||||
this._startSequence(sequence);
|
||||
}
|
||||
|
||||
return sequence;
|
||||
};
|
||||
|
||||
Protocol.prototype._validateEnqueue = function(sequence) {
|
||||
var err;
|
||||
var prefix = 'Cannot enqueue ' + sequence.constructor.name;
|
||||
var prefixBefore = prefix + ' before ';
|
||||
var prefixAfter = prefix + ' after ';
|
||||
|
||||
if (this._fatalError) {
|
||||
err = new Error(prefixAfter + 'fatal error.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR';
|
||||
} else if (this._quitSequence) {
|
||||
err = new Error(prefixAfter + 'invoking quit.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_QUIT';
|
||||
} else if (this._destroyed) {
|
||||
err = new Error(prefixAfter + 'being destroyed.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_AFTER_DESTROY';
|
||||
} else if (this._handshakeSequence && sequence.constructor === Sequences.Handshake) {
|
||||
err = new Error(prefixAfter + 'already enqueuing a Handshake.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_HANDSHAKE_TWICE';
|
||||
} else if (!this._handshakeSequence && sequence.constructor === Sequences.ChangeUser) {
|
||||
err = new Error(prefixBefore + 'a Handshake.');
|
||||
err.code = 'PROTOCOL_ENQUEUE_BEFORE_HANDSHAKE';
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
|
||||
var self = this;
|
||||
err.fatal = false;
|
||||
|
||||
sequence
|
||||
.on('error', function(err) {
|
||||
self._delegateError(err, sequence);
|
||||
})
|
||||
.end(err);
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
Protocol.prototype._parsePacket = function() {
|
||||
var sequence = this._queue[0];
|
||||
|
||||
if (!sequence) {
|
||||
var err = new Error('Received packet with no active sequence.');
|
||||
err.code = 'PROTOCOL_STRAY_PACKET';
|
||||
err.fatal = true;
|
||||
|
||||
this._delegateError(err);
|
||||
return;
|
||||
}
|
||||
|
||||
var Packet = this._determinePacket(sequence);
|
||||
var packet = new Packet({protocol41: this._config.protocol41});
|
||||
var packetName = Packet.name;
|
||||
|
||||
// Special case: Faster dispatch, and parsing done inside sequence
|
||||
if (Packet === Packets.RowDataPacket) {
|
||||
sequence.RowDataPacket(packet, this._parser, this._connection);
|
||||
|
||||
if (this._config.debug) {
|
||||
this._debugPacket(true, packet);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._config.debug) {
|
||||
this._parsePacketDebug(packet);
|
||||
} else {
|
||||
packet.parse(this._parser);
|
||||
}
|
||||
|
||||
if (Packet === Packets.HandshakeInitializationPacket) {
|
||||
this._handshakeInitializationPacket = packet;
|
||||
}
|
||||
|
||||
Timers.active(sequence);
|
||||
|
||||
if (!sequence[packetName]) {
|
||||
var err = new Error('Received packet in the wrong sequence.');
|
||||
err.code = 'PROTOCOL_INCORRECT_PACKET_SEQUENCE';
|
||||
err.fatal = true;
|
||||
|
||||
this._delegateError(err);
|
||||
return;
|
||||
}
|
||||
|
||||
sequence[packetName](packet);
|
||||
};
|
||||
|
||||
Protocol.prototype._parsePacketDebug = function _parsePacketDebug(packet) {
|
||||
try {
|
||||
packet.parse(this._parser);
|
||||
} finally {
|
||||
this._debugPacket(true, packet);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._emitPacket = function(packet) {
|
||||
var packetWriter = new PacketWriter();
|
||||
packet.write(packetWriter);
|
||||
this.emit('data', packetWriter.toBuffer(this._parser));
|
||||
|
||||
if (this._config.debug) {
|
||||
this._debugPacket(false, packet);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._determinePacket = function(sequence) {
|
||||
var firstByte = this._parser.peak();
|
||||
|
||||
if (sequence.determinePacket) {
|
||||
var Packet = sequence.determinePacket(firstByte, this._parser);
|
||||
if (Packet) {
|
||||
return Packet;
|
||||
}
|
||||
}
|
||||
|
||||
switch (firstByte) {
|
||||
case 0x00:
|
||||
if (!this._handshaked) {
|
||||
this._handshaked = true;
|
||||
this.emit('handshake', this._handshakeInitializationPacket);
|
||||
}
|
||||
return Packets.OkPacket;
|
||||
case 0xfe: return Packets.EofPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
}
|
||||
|
||||
throw new Error('Could not determine packet, firstByte = ' + firstByte);
|
||||
};
|
||||
|
||||
Protocol.prototype._dequeue = function(sequence) {
|
||||
Timers.unenroll(sequence);
|
||||
|
||||
// No point in advancing the queue, we are dead
|
||||
if (this._fatalError) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._queue.shift();
|
||||
|
||||
var sequence = this._queue[0];
|
||||
if (!sequence) {
|
||||
this.emit('drain');
|
||||
return;
|
||||
}
|
||||
|
||||
this._parser.resetPacketNumber();
|
||||
|
||||
this._startSequence(sequence);
|
||||
};
|
||||
|
||||
Protocol.prototype._startSequence = function(sequence) {
|
||||
if (sequence._timeout > 0 && isFinite(sequence._timeout)) {
|
||||
Timers.enroll(sequence, sequence._timeout);
|
||||
Timers.active(sequence);
|
||||
}
|
||||
|
||||
if (sequence.constructor === Sequences.ChangeUser) {
|
||||
sequence.start(this._handshakeInitializationPacket);
|
||||
} else {
|
||||
sequence.start();
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.handleNetworkError = function(err) {
|
||||
err.fatal = true;
|
||||
|
||||
var sequence = this._queue[0];
|
||||
if (sequence) {
|
||||
sequence.end(err);
|
||||
} else {
|
||||
this._delegateError(err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype.handleParserError = function handleParserError(err) {
|
||||
var sequence = this._queue[0];
|
||||
if (sequence) {
|
||||
sequence.end(err);
|
||||
} else {
|
||||
this._delegateError(err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._delegateError = function(err, sequence) {
|
||||
// Stop delegating errors after the first fatal error
|
||||
if (this._fatalError) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (err.fatal) {
|
||||
this._fatalError = err;
|
||||
}
|
||||
|
||||
if (this._shouldErrorBubbleUp(err, sequence)) {
|
||||
// Can't use regular 'error' event here as that always destroys the pipe
|
||||
// between socket and protocol which is not what we want (unless the
|
||||
// exception was fatal).
|
||||
this.emit('unhandledError', err);
|
||||
} else if (err.fatal) {
|
||||
// Send fatal error to all sequences in the queue
|
||||
var queue = this._queue;
|
||||
process.nextTick(function () {
|
||||
queue.forEach(function (sequence) {
|
||||
sequence.end(err);
|
||||
});
|
||||
queue.length = 0;
|
||||
});
|
||||
}
|
||||
|
||||
// Make sure the stream we are piping to is getting closed
|
||||
if (err.fatal) {
|
||||
this.emit('end', err);
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._shouldErrorBubbleUp = function(err, sequence) {
|
||||
if (sequence) {
|
||||
if (sequence.hasErrorHandler()) {
|
||||
return false;
|
||||
} else if (!err.fatal) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return (err.fatal && !this._hasPendingErrorHandlers());
|
||||
};
|
||||
|
||||
Protocol.prototype._hasPendingErrorHandlers = function() {
|
||||
return this._queue.some(function(sequence) {
|
||||
return sequence.hasErrorHandler();
|
||||
});
|
||||
};
|
||||
|
||||
Protocol.prototype.destroy = function() {
|
||||
this._destroyed = true;
|
||||
this._parser.pause();
|
||||
|
||||
if (this._connection.state !== "disconnected") {
|
||||
if(!this._ended) {
|
||||
this.end();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Protocol.prototype._debugPacket = function(incoming, packet) {
|
||||
var headline = (incoming)
|
||||
? '<-- '
|
||||
: '--> ';
|
||||
|
||||
headline = headline + packet.constructor.name;
|
||||
|
||||
// check for debug packet restriction
|
||||
if (Array.isArray(this._config.debug) && this._config.debug.indexOf(packet.constructor.name) === -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(headline);
|
||||
console.log(packet);
|
||||
console.log('');
|
||||
};
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
module.exports = ResultSet;
|
||||
function ResultSet(resultSetHeaderPacket) {
|
||||
this.resultSetHeaderPacket = resultSetHeaderPacket;
|
||||
this.fieldPackets = [];
|
||||
this.eofPackets = [];
|
||||
this.rows = [];
|
||||
}
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
var SqlString = exports;
|
||||
|
||||
SqlString.escapeId = function (val, forbidQualified) {
|
||||
if (Array.isArray(val)) {
|
||||
return val.map(function(v) {
|
||||
return SqlString.escapeId(v, forbidQualified);
|
||||
}).join(', ');
|
||||
}
|
||||
|
||||
if (forbidQualified) {
|
||||
return '`' + val.replace(/`/g, '``') + '`';
|
||||
}
|
||||
return '`' + val.replace(/`/g, '``').replace(/\./g, '`.`') + '`';
|
||||
};
|
||||
|
||||
SqlString.escape = function(val, stringifyObjects, timeZone) {
|
||||
if (val === undefined || val === null) {
|
||||
return 'NULL';
|
||||
}
|
||||
|
||||
switch (typeof val) {
|
||||
case 'boolean': return (val) ? 'true' : 'false';
|
||||
case 'number': return val+'';
|
||||
}
|
||||
|
||||
if (val instanceof Date) {
|
||||
val = SqlString.dateToString(val, timeZone || 'local');
|
||||
}
|
||||
|
||||
if (Buffer.isBuffer(val)) {
|
||||
return SqlString.bufferToString(val);
|
||||
}
|
||||
|
||||
if (Array.isArray(val)) {
|
||||
return SqlString.arrayToList(val, timeZone);
|
||||
}
|
||||
|
||||
if (typeof val === 'object') {
|
||||
if (stringifyObjects) {
|
||||
val = val.toString();
|
||||
} else {
|
||||
return SqlString.objectToValues(val, timeZone);
|
||||
}
|
||||
}
|
||||
|
||||
val = val.replace(/[\0\n\r\b\t\\\'\"\x1a]/g, function(s) {
|
||||
switch(s) {
|
||||
case "\0": return "\\0";
|
||||
case "\n": return "\\n";
|
||||
case "\r": return "\\r";
|
||||
case "\b": return "\\b";
|
||||
case "\t": return "\\t";
|
||||
case "\x1a": return "\\Z";
|
||||
default: return "\\"+s;
|
||||
}
|
||||
});
|
||||
return "'"+val+"'";
|
||||
};
|
||||
|
||||
SqlString.arrayToList = function(array, timeZone) {
|
||||
return array.map(function(v) {
|
||||
if (Array.isArray(v)) return '(' + SqlString.arrayToList(v, timeZone) + ')';
|
||||
return SqlString.escape(v, true, timeZone);
|
||||
}).join(', ');
|
||||
};
|
||||
|
||||
SqlString.format = function(sql, values, stringifyObjects, timeZone) {
|
||||
values = values == null ? [] : [].concat(values);
|
||||
|
||||
return sql.replace(/\?\??/g, function(match) {
|
||||
if (!values.length) {
|
||||
return match;
|
||||
}
|
||||
|
||||
if (match == "??") {
|
||||
return SqlString.escapeId(values.shift());
|
||||
}
|
||||
return SqlString.escape(values.shift(), stringifyObjects, timeZone);
|
||||
});
|
||||
};
|
||||
|
||||
SqlString.dateToString = function(date, timeZone) {
|
||||
var dt = new Date(date);
|
||||
|
||||
if (timeZone != 'local') {
|
||||
var tz = convertTimezone(timeZone);
|
||||
|
||||
dt.setTime(dt.getTime() + (dt.getTimezoneOffset() * 60000));
|
||||
if (tz !== false) {
|
||||
dt.setTime(dt.getTime() + (tz * 60000));
|
||||
}
|
||||
}
|
||||
|
||||
var year = dt.getFullYear();
|
||||
var month = zeroPad(dt.getMonth() + 1, 2);
|
||||
var day = zeroPad(dt.getDate(), 2);
|
||||
var hour = zeroPad(dt.getHours(), 2);
|
||||
var minute = zeroPad(dt.getMinutes(), 2);
|
||||
var second = zeroPad(dt.getSeconds(), 2);
|
||||
var millisecond = zeroPad(dt.getMilliseconds(), 3);
|
||||
|
||||
return year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second + '.' + millisecond;
|
||||
};
|
||||
|
||||
SqlString.bufferToString = function bufferToString(buffer) {
|
||||
return "X'" + buffer.toString('hex') + "'";
|
||||
};
|
||||
|
||||
SqlString.objectToValues = function(object, timeZone) {
|
||||
var values = [];
|
||||
for (var key in object) {
|
||||
var value = object[key];
|
||||
if(typeof value === 'function') {
|
||||
continue;
|
||||
}
|
||||
|
||||
values.push(this.escapeId(key) + ' = ' + SqlString.escape(value, true, timeZone));
|
||||
}
|
||||
|
||||
return values.join(', ');
|
||||
};
|
||||
|
||||
function zeroPad(number, length) {
|
||||
number = number.toString();
|
||||
while (number.length < length) {
|
||||
number = '0' + number;
|
||||
}
|
||||
|
||||
return number;
|
||||
}
|
||||
|
||||
function convertTimezone(tz) {
|
||||
if (tz == "Z") return 0;
|
||||
|
||||
var m = tz.match(/([\+\-\s])(\d\d):?(\d\d)?/);
|
||||
if (m) {
|
||||
return (m[1] == '-' ? -1 : 1) * (parseInt(m[2], 10) + ((m[3] ? parseInt(m[3], 10) : 0) / 60)) * 60;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
@ -0,0 +1,262 @@
|
|||
exports.BIG5_CHINESE_CI = 1;
|
||||
exports.LATIN2_CZECH_CS = 2;
|
||||
exports.DEC8_SWEDISH_CI = 3;
|
||||
exports.CP850_GENERAL_CI = 4;
|
||||
exports.LATIN1_GERMAN1_CI = 5;
|
||||
exports.HP8_ENGLISH_CI = 6;
|
||||
exports.KOI8R_GENERAL_CI = 7;
|
||||
exports.LATIN1_SWEDISH_CI = 8;
|
||||
exports.LATIN2_GENERAL_CI = 9;
|
||||
exports.SWE7_SWEDISH_CI = 10;
|
||||
exports.ASCII_GENERAL_CI = 11;
|
||||
exports.UJIS_JAPANESE_CI = 12;
|
||||
exports.SJIS_JAPANESE_CI = 13;
|
||||
exports.CP1251_BULGARIAN_CI = 14;
|
||||
exports.LATIN1_DANISH_CI = 15;
|
||||
exports.HEBREW_GENERAL_CI = 16;
|
||||
exports.TIS620_THAI_CI = 18;
|
||||
exports.EUCKR_KOREAN_CI = 19;
|
||||
exports.LATIN7_ESTONIAN_CS = 20;
|
||||
exports.LATIN2_HUNGARIAN_CI = 21;
|
||||
exports.KOI8U_GENERAL_CI = 22;
|
||||
exports.CP1251_UKRAINIAN_CI = 23;
|
||||
exports.GB2312_CHINESE_CI = 24;
|
||||
exports.GREEK_GENERAL_CI = 25;
|
||||
exports.CP1250_GENERAL_CI = 26;
|
||||
exports.LATIN2_CROATIAN_CI = 27;
|
||||
exports.GBK_CHINESE_CI = 28;
|
||||
exports.CP1257_LITHUANIAN_CI = 29;
|
||||
exports.LATIN5_TURKISH_CI = 30;
|
||||
exports.LATIN1_GERMAN2_CI = 31;
|
||||
exports.ARMSCII8_GENERAL_CI = 32;
|
||||
exports.UTF8_GENERAL_CI = 33;
|
||||
exports.CP1250_CZECH_CS = 34;
|
||||
exports.UCS2_GENERAL_CI = 35;
|
||||
exports.CP866_GENERAL_CI = 36;
|
||||
exports.KEYBCS2_GENERAL_CI = 37;
|
||||
exports.MACCE_GENERAL_CI = 38;
|
||||
exports.MACROMAN_GENERAL_CI = 39;
|
||||
exports.CP852_GENERAL_CI = 40;
|
||||
exports.LATIN7_GENERAL_CI = 41;
|
||||
exports.LATIN7_GENERAL_CS = 42;
|
||||
exports.MACCE_BIN = 43;
|
||||
exports.CP1250_CROATIAN_CI = 44;
|
||||
exports.UTF8MB4_GENERAL_CI = 45;
|
||||
exports.UTF8MB4_BIN = 46;
|
||||
exports.LATIN1_BIN = 47;
|
||||
exports.LATIN1_GENERAL_CI = 48;
|
||||
exports.LATIN1_GENERAL_CS = 49;
|
||||
exports.CP1251_BIN = 50;
|
||||
exports.CP1251_GENERAL_CI = 51;
|
||||
exports.CP1251_GENERAL_CS = 52;
|
||||
exports.MACROMAN_BIN = 53;
|
||||
exports.UTF16_GENERAL_CI = 54;
|
||||
exports.UTF16_BIN = 55;
|
||||
exports.UTF16LE_GENERAL_CI = 56;
|
||||
exports.CP1256_GENERAL_CI = 57;
|
||||
exports.CP1257_BIN = 58;
|
||||
exports.CP1257_GENERAL_CI = 59;
|
||||
exports.UTF32_GENERAL_CI = 60;
|
||||
exports.UTF32_BIN = 61;
|
||||
exports.UTF16LE_BIN = 62;
|
||||
exports.BINARY = 63;
|
||||
exports.ARMSCII8_BIN = 64;
|
||||
exports.ASCII_BIN = 65;
|
||||
exports.CP1250_BIN = 66;
|
||||
exports.CP1256_BIN = 67;
|
||||
exports.CP866_BIN = 68;
|
||||
exports.DEC8_BIN = 69;
|
||||
exports.GREEK_BIN = 70;
|
||||
exports.HEBREW_BIN = 71;
|
||||
exports.HP8_BIN = 72;
|
||||
exports.KEYBCS2_BIN = 73;
|
||||
exports.KOI8R_BIN = 74;
|
||||
exports.KOI8U_BIN = 75;
|
||||
exports.LATIN2_BIN = 77;
|
||||
exports.LATIN5_BIN = 78;
|
||||
exports.LATIN7_BIN = 79;
|
||||
exports.CP850_BIN = 80;
|
||||
exports.CP852_BIN = 81;
|
||||
exports.SWE7_BIN = 82;
|
||||
exports.UTF8_BIN = 83;
|
||||
exports.BIG5_BIN = 84;
|
||||
exports.EUCKR_BIN = 85;
|
||||
exports.GB2312_BIN = 86;
|
||||
exports.GBK_BIN = 87;
|
||||
exports.SJIS_BIN = 88;
|
||||
exports.TIS620_BIN = 89;
|
||||
exports.UCS2_BIN = 90;
|
||||
exports.UJIS_BIN = 91;
|
||||
exports.GEOSTD8_GENERAL_CI = 92;
|
||||
exports.GEOSTD8_BIN = 93;
|
||||
exports.LATIN1_SPANISH_CI = 94;
|
||||
exports.CP932_JAPANESE_CI = 95;
|
||||
exports.CP932_BIN = 96;
|
||||
exports.EUCJPMS_JAPANESE_CI = 97;
|
||||
exports.EUCJPMS_BIN = 98;
|
||||
exports.CP1250_POLISH_CI = 99;
|
||||
exports.UTF16_UNICODE_CI = 101;
|
||||
exports.UTF16_ICELANDIC_CI = 102;
|
||||
exports.UTF16_LATVIAN_CI = 103;
|
||||
exports.UTF16_ROMANIAN_CI = 104;
|
||||
exports.UTF16_SLOVENIAN_CI = 105;
|
||||
exports.UTF16_POLISH_CI = 106;
|
||||
exports.UTF16_ESTONIAN_CI = 107;
|
||||
exports.UTF16_SPANISH_CI = 108;
|
||||
exports.UTF16_SWEDISH_CI = 109;
|
||||
exports.UTF16_TURKISH_CI = 110;
|
||||
exports.UTF16_CZECH_CI = 111;
|
||||
exports.UTF16_DANISH_CI = 112;
|
||||
exports.UTF16_LITHUANIAN_CI = 113;
|
||||
exports.UTF16_SLOVAK_CI = 114;
|
||||
exports.UTF16_SPANISH2_CI = 115;
|
||||
exports.UTF16_ROMAN_CI = 116;
|
||||
exports.UTF16_PERSIAN_CI = 117;
|
||||
exports.UTF16_ESPERANTO_CI = 118;
|
||||
exports.UTF16_HUNGARIAN_CI = 119;
|
||||
exports.UTF16_SINHALA_CI = 120;
|
||||
exports.UTF16_GERMAN2_CI = 121;
|
||||
exports.UTF16_CROATIAN_MYSQL561_CI = 122;
|
||||
exports.UTF16_UNICODE_520_CI = 123;
|
||||
exports.UTF16_VIETNAMESE_CI = 124;
|
||||
exports.UCS2_UNICODE_CI = 128;
|
||||
exports.UCS2_ICELANDIC_CI = 129;
|
||||
exports.UCS2_LATVIAN_CI = 130;
|
||||
exports.UCS2_ROMANIAN_CI = 131;
|
||||
exports.UCS2_SLOVENIAN_CI = 132;
|
||||
exports.UCS2_POLISH_CI = 133;
|
||||
exports.UCS2_ESTONIAN_CI = 134;
|
||||
exports.UCS2_SPANISH_CI = 135;
|
||||
exports.UCS2_SWEDISH_CI = 136;
|
||||
exports.UCS2_TURKISH_CI = 137;
|
||||
exports.UCS2_CZECH_CI = 138;
|
||||
exports.UCS2_DANISH_CI = 139;
|
||||
exports.UCS2_LITHUANIAN_CI = 140;
|
||||
exports.UCS2_SLOVAK_CI = 141;
|
||||
exports.UCS2_SPANISH2_CI = 142;
|
||||
exports.UCS2_ROMAN_CI = 143;
|
||||
exports.UCS2_PERSIAN_CI = 144;
|
||||
exports.UCS2_ESPERANTO_CI = 145;
|
||||
exports.UCS2_HUNGARIAN_CI = 146;
|
||||
exports.UCS2_SINHALA_CI = 147;
|
||||
exports.UCS2_GERMAN2_CI = 148;
|
||||
exports.UCS2_CROATIAN_MYSQL561_CI = 149;
|
||||
exports.UCS2_UNICODE_520_CI = 150;
|
||||
exports.UCS2_VIETNAMESE_CI = 151;
|
||||
exports.UCS2_GENERAL_MYSQL500_CI = 159;
|
||||
exports.UTF32_UNICODE_CI = 160;
|
||||
exports.UTF32_ICELANDIC_CI = 161;
|
||||
exports.UTF32_LATVIAN_CI = 162;
|
||||
exports.UTF32_ROMANIAN_CI = 163;
|
||||
exports.UTF32_SLOVENIAN_CI = 164;
|
||||
exports.UTF32_POLISH_CI = 165;
|
||||
exports.UTF32_ESTONIAN_CI = 166;
|
||||
exports.UTF32_SPANISH_CI = 167;
|
||||
exports.UTF32_SWEDISH_CI = 168;
|
||||
exports.UTF32_TURKISH_CI = 169;
|
||||
exports.UTF32_CZECH_CI = 170;
|
||||
exports.UTF32_DANISH_CI = 171;
|
||||
exports.UTF32_LITHUANIAN_CI = 172;
|
||||
exports.UTF32_SLOVAK_CI = 173;
|
||||
exports.UTF32_SPANISH2_CI = 174;
|
||||
exports.UTF32_ROMAN_CI = 175;
|
||||
exports.UTF32_PERSIAN_CI = 176;
|
||||
exports.UTF32_ESPERANTO_CI = 177;
|
||||
exports.UTF32_HUNGARIAN_CI = 178;
|
||||
exports.UTF32_SINHALA_CI = 179;
|
||||
exports.UTF32_GERMAN2_CI = 180;
|
||||
exports.UTF32_CROATIAN_MYSQL561_CI = 181;
|
||||
exports.UTF32_UNICODE_520_CI = 182;
|
||||
exports.UTF32_VIETNAMESE_CI = 183;
|
||||
exports.UTF8_UNICODE_CI = 192;
|
||||
exports.UTF8_ICELANDIC_CI = 193;
|
||||
exports.UTF8_LATVIAN_CI = 194;
|
||||
exports.UTF8_ROMANIAN_CI = 195;
|
||||
exports.UTF8_SLOVENIAN_CI = 196;
|
||||
exports.UTF8_POLISH_CI = 197;
|
||||
exports.UTF8_ESTONIAN_CI = 198;
|
||||
exports.UTF8_SPANISH_CI = 199;
|
||||
exports.UTF8_SWEDISH_CI = 200;
|
||||
exports.UTF8_TURKISH_CI = 201;
|
||||
exports.UTF8_CZECH_CI = 202;
|
||||
exports.UTF8_DANISH_CI = 203;
|
||||
exports.UTF8_LITHUANIAN_CI = 204;
|
||||
exports.UTF8_SLOVAK_CI = 205;
|
||||
exports.UTF8_SPANISH2_CI = 206;
|
||||
exports.UTF8_ROMAN_CI = 207;
|
||||
exports.UTF8_PERSIAN_CI = 208;
|
||||
exports.UTF8_ESPERANTO_CI = 209;
|
||||
exports.UTF8_HUNGARIAN_CI = 210;
|
||||
exports.UTF8_SINHALA_CI = 211;
|
||||
exports.UTF8_GERMAN2_CI = 212;
|
||||
exports.UTF8_CROATIAN_MYSQL561_CI = 213;
|
||||
exports.UTF8_UNICODE_520_CI = 214;
|
||||
exports.UTF8_VIETNAMESE_CI = 215;
|
||||
exports.UTF8_GENERAL_MYSQL500_CI = 223;
|
||||
exports.UTF8MB4_UNICODE_CI = 224;
|
||||
exports.UTF8MB4_ICELANDIC_CI = 225;
|
||||
exports.UTF8MB4_LATVIAN_CI = 226;
|
||||
exports.UTF8MB4_ROMANIAN_CI = 227;
|
||||
exports.UTF8MB4_SLOVENIAN_CI = 228;
|
||||
exports.UTF8MB4_POLISH_CI = 229;
|
||||
exports.UTF8MB4_ESTONIAN_CI = 230;
|
||||
exports.UTF8MB4_SPANISH_CI = 231;
|
||||
exports.UTF8MB4_SWEDISH_CI = 232;
|
||||
exports.UTF8MB4_TURKISH_CI = 233;
|
||||
exports.UTF8MB4_CZECH_CI = 234;
|
||||
exports.UTF8MB4_DANISH_CI = 235;
|
||||
exports.UTF8MB4_LITHUANIAN_CI = 236;
|
||||
exports.UTF8MB4_SLOVAK_CI = 237;
|
||||
exports.UTF8MB4_SPANISH2_CI = 238;
|
||||
exports.UTF8MB4_ROMAN_CI = 239;
|
||||
exports.UTF8MB4_PERSIAN_CI = 240;
|
||||
exports.UTF8MB4_ESPERANTO_CI = 241;
|
||||
exports.UTF8MB4_HUNGARIAN_CI = 242;
|
||||
exports.UTF8MB4_SINHALA_CI = 243;
|
||||
exports.UTF8MB4_GERMAN2_CI = 244;
|
||||
exports.UTF8MB4_CROATIAN_MYSQL561_CI = 245;
|
||||
exports.UTF8MB4_UNICODE_520_CI = 246;
|
||||
exports.UTF8MB4_VIETNAMESE_CI = 247;
|
||||
exports.UTF8_GENERAL50_CI = 253;
|
||||
|
||||
// short aliases
|
||||
exports.ARMSCII8 = exports.ARMSCII8_GENERAL_CI;
|
||||
exports.ASCII = exports.ASCII_GENERAL_CI;
|
||||
exports.BIG5 = exports.BIG5_CHINESE_CI;
|
||||
exports.BINARY = exports.BINARY;
|
||||
exports.CP1250 = exports.CP1250_GENERAL_CI;
|
||||
exports.CP1251 = exports.CP1251_GENERAL_CI;
|
||||
exports.CP1256 = exports.CP1256_GENERAL_CI;
|
||||
exports.CP1257 = exports.CP1257_GENERAL_CI;
|
||||
exports.CP866 = exports.CP866_GENERAL_CI;
|
||||
exports.CP850 = exports.CP850_GENERAL_CI;
|
||||
exports.CP852 = exports.CP852_GENERAL_CI;
|
||||
exports.CP932 = exports.CP932_JAPANESE_CI;
|
||||
exports.DEC8 = exports.DEC8_SWEDISH_CI;
|
||||
exports.EUCJPMS = exports.EUCJPMS_JAPANESE_CI;
|
||||
exports.EUCKR = exports.EUCKR_KOREAN_CI;
|
||||
exports.GB2312 = exports.GB2312_CHINESE_CI;
|
||||
exports.GBK = exports.GBK_CHINESE_CI;
|
||||
exports.GEOSTD8 = exports.GEOSTD8_GENERAL_CI;
|
||||
exports.GREEK = exports.GREEK_GENERAL_CI;
|
||||
exports.HEBREW = exports.HEBREW_GENERAL_CI;
|
||||
exports.HP8 = exports.HP8_ENGLISH_CI;
|
||||
exports.KEYBCS2 = exports.KEYBCS2_GENERAL_CI;
|
||||
exports.KOI8R = exports.KOI8R_GENERAL_CI;
|
||||
exports.KOI8U = exports.KOI8U_GENERAL_CI;
|
||||
exports.LATIN1 = exports.LATIN1_SWEDISH_CI;
|
||||
exports.LATIN2 = exports.LATIN2_GENERAL_CI;
|
||||
exports.LATIN5 = exports.LATIN5_TURKISH_CI;
|
||||
exports.LATIN7 = exports.LATIN7_GENERAL_CI;
|
||||
exports.MACCE = exports.MACCE_GENERAL_CI;
|
||||
exports.MACROMAN = exports.MACROMAN_GENERAL_CI;
|
||||
exports.SJIS = exports.SJIS_JAPANESE_CI;
|
||||
exports.SWE7 = exports.SWE7_SWEDISH_CI;
|
||||
exports.TIS620 = exports.TIS620_THAI_CI;
|
||||
exports.UCS2 = exports.UCS2_GENERAL_CI;
|
||||
exports.UJIS = exports.UJIS_JAPANESE_CI;
|
||||
exports.UTF16 = exports.UTF16_GENERAL_CI;
|
||||
exports.UTF16LE = exports.UTF16LE_GENERAL_CI;
|
||||
exports.UTF8 = exports.UTF8_GENERAL_CI;
|
||||
exports.UTF8MB4 = exports.UTF8MB4_GENERAL_CI;
|
||||
exports.UTF32 = exports.UTF32_GENERAL_CI;
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
exports.CLIENT_LONG_PASSWORD = 1; /* new more secure passwords */
|
||||
exports.CLIENT_FOUND_ROWS = 2; /* Found instead of affected rows */
|
||||
exports.CLIENT_LONG_FLAG = 4; /* Get all column flags */
|
||||
exports.CLIENT_CONNECT_WITH_DB = 8; /* One can specify db on connect */
|
||||
exports.CLIENT_NO_SCHEMA = 16; /* Don't allow database.table.column */
|
||||
exports.CLIENT_COMPRESS = 32; /* Can use compression protocol */
|
||||
exports.CLIENT_ODBC = 64; /* Odbc client */
|
||||
exports.CLIENT_LOCAL_FILES = 128; /* Can use LOAD DATA LOCAL */
|
||||
exports.CLIENT_IGNORE_SPACE = 256; /* Ignore spaces before '(' */
|
||||
exports.CLIENT_PROTOCOL_41 = 512; /* New 4.1 protocol */
|
||||
exports.CLIENT_INTERACTIVE = 1024; /* This is an interactive client */
|
||||
exports.CLIENT_SSL = 2048; /* Switch to SSL after handshake */
|
||||
exports.CLIENT_IGNORE_SIGPIPE = 4096; /* IGNORE sigpipes */
|
||||
exports.CLIENT_TRANSACTIONS = 8192; /* Client knows about transactions */
|
||||
exports.CLIENT_RESERVED = 16384; /* Old flag for 4.1 protocol */
|
||||
exports.CLIENT_SECURE_CONNECTION = 32768; /* New 4.1 authentication */
|
||||
|
||||
exports.CLIENT_MULTI_STATEMENTS = 65536; /* Enable/disable multi-stmt support */
|
||||
exports.CLIENT_MULTI_RESULTS = 131072; /* Enable/disable multi-results */
|
||||
exports.CLIENT_PS_MULTI_RESULTS = 262144; /* Multi-results in PS-protocol */
|
||||
|
||||
exports.CLIENT_PLUGIN_AUTH = 524288; /* Client supports plugin authentication */
|
||||
|
||||
exports.CLIENT_SSL_VERIFY_SERVER_CERT = 1073741824;
|
||||
exports.CLIENT_REMEMBER_OPTIONS = 2147483648;
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,18 @@
|
|||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
exports.NOT_NULL_FLAG = 1; /* Field can't be NULL */
|
||||
exports.PRI_KEY_FLAG = 2; /* Field is part of a primary key */
|
||||
exports.UNIQUE_KEY_FLAG = 4; /* Field is part of a unique key */
|
||||
exports.MULTIPLE_KEY_FLAG = 8; /* Field is part of a key */
|
||||
exports.BLOB_FLAG = 16; /* Field is a blob */
|
||||
exports.UNSIGNED_FLAG = 32; /* Field is unsigned */
|
||||
exports.ZEROFILL_FLAG = 64; /* Field is zerofill */
|
||||
exports.BINARY_FLAG = 128; /* Field is binary */
|
||||
|
||||
/* The following are only sent to new clients */
|
||||
exports.ENUM_FLAG = 256; /* field is an enum */
|
||||
exports.AUTO_INCREMENT_FLAG = 512; /* field is a autoincrement field */
|
||||
exports.TIMESTAMP_FLAG = 1024; /* Field is a timestamp */
|
||||
exports.SET_FLAG = 2048; /* field is a set */
|
||||
exports.NO_DEFAULT_VALUE_FLAG = 4096; /* Field doesn't have default value */
|
||||
exports.ON_UPDATE_NOW_FLAG = 8192; /* Field is set to NOW on UPDATE */
|
||||
exports.NUM_FLAG = 32768; /* Field is num (for clients) */
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
|
||||
/**
|
||||
Is raised when a multi-statement transaction
|
||||
has been started, either explicitly, by means
|
||||
of BEGIN or COMMIT AND CHAIN, or
|
||||
implicitly, by the first transactional
|
||||
statement, when autocommit=off.
|
||||
*/
|
||||
exports.SERVER_STATUS_IN_TRANS = 1;
|
||||
exports.SERVER_STATUS_AUTOCOMMIT = 2; /* Server in auto_commit mode */
|
||||
exports.SERVER_MORE_RESULTS_EXISTS = 8; /* Multi query - next query exists */
|
||||
exports.SERVER_QUERY_NO_GOOD_INDEX_USED = 16;
|
||||
exports.SERVER_QUERY_NO_INDEX_USED = 32;
|
||||
/**
|
||||
The server was able to fulfill the clients request and opened a
|
||||
read-only non-scrollable cursor for a query. This flag comes
|
||||
in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
|
||||
*/
|
||||
exports.SERVER_STATUS_CURSOR_EXISTS = 64;
|
||||
/**
|
||||
This flag is sent when a read-only cursor is exhausted, in reply to
|
||||
COM_STMT_FETCH command.
|
||||
*/
|
||||
exports.SERVER_STATUS_LAST_ROW_SENT = 128;
|
||||
exports.SERVER_STATUS_DB_DROPPED = 256; /* A database was dropped */
|
||||
exports.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512;
|
||||
/**
|
||||
Sent to the client if after a prepared statement reprepare
|
||||
we discovered that the new statement returns a different
|
||||
number of result set columns.
|
||||
*/
|
||||
exports.SERVER_STATUS_METADATA_CHANGED = 1024;
|
||||
exports.SERVER_QUERY_WAS_SLOW = 2048;
|
||||
|
||||
/**
|
||||
To mark ResultSet containing output parameter values.
|
||||
*/
|
||||
exports.SERVER_PS_OUT_PARAMS = 4096;
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
// Manually extracted from mysql-5.5.23/include/mysql_com.h
|
||||
// some more info here: http://dev.mysql.com/doc/refman/5.5/en/c-api-prepared-statement-type-codes.html
|
||||
exports.DECIMAL = 0x00; // aka DECIMAL (http://dev.mysql.com/doc/refman/5.0/en/precision-math-decimal-changes.html)
|
||||
exports.TINY = 0x01; // aka TINYINT, 1 byte
|
||||
exports.SHORT = 0x02; // aka SMALLINT, 2 bytes
|
||||
exports.LONG = 0x03; // aka INT, 4 bytes
|
||||
exports.FLOAT = 0x04; // aka FLOAT, 4-8 bytes
|
||||
exports.DOUBLE = 0x05; // aka DOUBLE, 8 bytes
|
||||
exports.NULL = 0x06; // NULL (used for prepared statements, I think)
|
||||
exports.TIMESTAMP = 0x07; // aka TIMESTAMP
|
||||
exports.LONGLONG = 0x08; // aka BIGINT, 8 bytes
|
||||
exports.INT24 = 0x09; // aka MEDIUMINT, 3 bytes
|
||||
exports.DATE = 0x0a; // aka DATE
|
||||
exports.TIME = 0x0b; // aka TIME
|
||||
exports.DATETIME = 0x0c; // aka DATETIME
|
||||
exports.YEAR = 0x0d; // aka YEAR, 1 byte (don't ask)
|
||||
exports.NEWDATE = 0x0e; // aka ?
|
||||
exports.VARCHAR = 0x0f; // aka VARCHAR (?)
|
||||
exports.BIT = 0x10; // aka BIT, 1-8 byte
|
||||
exports.NEWDECIMAL = 0xf6; // aka DECIMAL
|
||||
exports.ENUM = 0xf7; // aka ENUM
|
||||
exports.SET = 0xf8; // aka SET
|
||||
exports.TINY_BLOB = 0xf9; // aka TINYBLOB, TINYTEXT
|
||||
exports.MEDIUM_BLOB = 0xfa; // aka MEDIUMBLOB, MEDIUMTEXT
|
||||
exports.LONG_BLOB = 0xfb; // aka LONGBLOG, LONGTEXT
|
||||
exports.BLOB = 0xfc; // aka BLOB, TEXT
|
||||
exports.VAR_STRING = 0xfd; // aka VARCHAR, VARBINARY
|
||||
exports.STRING = 0xfe; // aka CHAR, BINARY
|
||||
exports.GEOMETRY = 0xff; // aka GEOMETRY
|
||||
52
node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js
generated
vendored
Normal file
52
node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js
generated
vendored
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
module.exports = ClientAuthenticationPacket;
|
||||
function ClientAuthenticationPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.clientFlags = options.clientFlags;
|
||||
this.maxPacketSize = options.maxPacketSize;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
this.filler = undefined;
|
||||
this.user = options.user;
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
this.database = options.database;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
ClientAuthenticationPacket.prototype.parse = function(parser) {
|
||||
if (this.protocol41) {
|
||||
this.clientFlags = parser.parseUnsignedNumber(4);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
this.filler = parser.parseFiller(23);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
||||
this.database = parser.parseNullTerminatedString();
|
||||
} else {
|
||||
this.clientFlags = parser.parseUnsignedNumber(2);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(3);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseBuffer(8);
|
||||
this.database = parser.parseLengthCodedBuffer();
|
||||
}
|
||||
};
|
||||
|
||||
ClientAuthenticationPacket.prototype.write = function(writer) {
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(4, this.clientFlags);
|
||||
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
||||
writer.writeUnsignedNumber(1, this.charsetNumber);
|
||||
writer.writeFiller(23);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
||||
writer.writeNullTerminatedString(this.database);
|
||||
} else {
|
||||
writer.writeUnsignedNumber(2, this.clientFlags);
|
||||
writer.writeUnsignedNumber(3, this.maxPacketSize);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeBuffer(this.scrambleBuff);
|
||||
if (this.database && this.database.length) {
|
||||
writer.writeFiller(1);
|
||||
writer.writeBuffer(new Buffer(this.database));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
module.exports = ComChangeUserPacket;
|
||||
function ComChangeUserPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.command = 0x11;
|
||||
this.user = options.user;
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
this.database = options.database;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
}
|
||||
|
||||
ComChangeUserPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
this.user = parser.parseNullTerminatedString();
|
||||
this.scrambleBuff = parser.parseLengthCodedBuffer();
|
||||
this.database = parser.parseNullTerminatedString();
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
ComChangeUserPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
writer.writeNullTerminatedString(this.user);
|
||||
writer.writeLengthCodedBuffer(this.scrambleBuff);
|
||||
writer.writeNullTerminatedString(this.database);
|
||||
writer.writeUnsignedNumber(2, this.charsetNumber);
|
||||
};
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
module.exports = ComPingPacket;
|
||||
function ComPingPacket(sql) {
|
||||
this.command = 0x0e;
|
||||
}
|
||||
|
||||
ComPingPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
|
||||
ComPingPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
module.exports = ComQueryPacket;
|
||||
function ComQueryPacket(sql) {
|
||||
this.command = 0x03;
|
||||
this.sql = sql;
|
||||
}
|
||||
|
||||
ComQueryPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
writer.writeString(this.sql);
|
||||
};
|
||||
|
||||
ComQueryPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
this.sql = parser.parsePacketTerminatedString();
|
||||
};
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
module.exports = ComQuitPacket;
|
||||
function ComQuitPacket(sql) {
|
||||
this.command = 0x01;
|
||||
}
|
||||
|
||||
ComQuitPacket.prototype.parse = function parse(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
ComQuitPacket.prototype.write = function write(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
module.exports = ComStatisticsPacket;
|
||||
function ComStatisticsPacket(sql) {
|
||||
this.command = 0x09;
|
||||
}
|
||||
|
||||
ComStatisticsPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.command);
|
||||
};
|
||||
|
||||
ComStatisticsPacket.prototype.parse = function(parser) {
|
||||
this.command = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
module.exports = EmptyPacket;
|
||||
function EmptyPacket() {
|
||||
}
|
||||
|
||||
EmptyPacket.prototype.write = function(writer) {
|
||||
};
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
module.exports = EofPacket;
|
||||
function EofPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = undefined;
|
||||
this.warningCount = options.warningCount;
|
||||
this.serverStatus = options.serverStatus;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
EofPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
if (this.protocol41) {
|
||||
this.warningCount = parser.parseUnsignedNumber(2);
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
}
|
||||
};
|
||||
|
||||
EofPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0xfe);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.warningCount);
|
||||
writer.writeUnsignedNumber(2, this.serverStatus);
|
||||
}
|
||||
};
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
module.exports = ErrorPacket;
|
||||
function ErrorPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = options.fieldCount;
|
||||
this.errno = options.errno;
|
||||
this.sqlStateMarker = options.sqlStateMarker;
|
||||
this.sqlState = options.sqlState;
|
||||
this.message = options.message;
|
||||
}
|
||||
|
||||
ErrorPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
this.errno = parser.parseUnsignedNumber(2);
|
||||
|
||||
// sqlStateMarker ('#' = 0x23) indicates error packet format
|
||||
if (parser.peak() === 0x23) {
|
||||
this.sqlStateMarker = parser.parseString(1);
|
||||
this.sqlState = parser.parseString(5);
|
||||
}
|
||||
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
};
|
||||
|
||||
ErrorPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0xff);
|
||||
writer.writeUnsignedNumber(2, this.errno);
|
||||
|
||||
if (this.sqlStateMarker) {
|
||||
writer.writeString(this.sqlStateMarker);
|
||||
writer.writeString(this.sqlState);
|
||||
}
|
||||
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
var Types = require('../constants/types');
|
||||
|
||||
module.exports = Field;
|
||||
function Field(options) {
|
||||
options = options || {};
|
||||
|
||||
this.parser = options.parser;
|
||||
this.packet = options.packet;
|
||||
this.db = options.packet.db;
|
||||
this.table = options.packet.table;
|
||||
this.name = options.packet.name;
|
||||
this.type = typeToString(options.packet.type);
|
||||
this.length = options.packet.length;
|
||||
}
|
||||
|
||||
Field.prototype.string = function () {
|
||||
return this.parser.parseLengthCodedString();
|
||||
};
|
||||
|
||||
Field.prototype.buffer = function () {
|
||||
return this.parser.parseLengthCodedBuffer();
|
||||
};
|
||||
|
||||
Field.prototype.geometry = function () {
|
||||
return this.parser.parseGeometryValue();
|
||||
};
|
||||
|
||||
function typeToString(t) {
|
||||
for (var k in Types) {
|
||||
if (Types[k] == t) return k;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
module.exports = FieldPacket;
|
||||
function FieldPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.catalog = options.catalog;
|
||||
this.db = options.db;
|
||||
this.table = options.table;
|
||||
this.orgTable = options.orgTable;
|
||||
this.name = options.name;
|
||||
this.orgName = options.orgName;
|
||||
this.charsetNr = options.charsetNr;
|
||||
this.length = options.length;
|
||||
this.type = options.type;
|
||||
this.flags = options.flags;
|
||||
this.decimals = options.decimals;
|
||||
this.default = options.default;
|
||||
this.zeroFill = options.zeroFill;
|
||||
this.protocol41 = options.protocol41
|
||||
}
|
||||
|
||||
FieldPacket.prototype.parse = function(parser) {
|
||||
if (this.protocol41) {
|
||||
this.catalog = parser.parseLengthCodedString();
|
||||
this.db = parser.parseLengthCodedString();
|
||||
this.table = parser.parseLengthCodedString();
|
||||
this.orgTable = parser.parseLengthCodedString();
|
||||
this.name = parser.parseLengthCodedString();
|
||||
this.orgName = parser.parseLengthCodedString();
|
||||
|
||||
if (parser.parseLengthCodedNumber() !== 0x0c) {
|
||||
var err = new TypeError('Received invalid field length');
|
||||
err.code = 'PARSER_INVALID_FIELD_LENGTH';
|
||||
throw err;
|
||||
}
|
||||
|
||||
this.charsetNr = parser.parseUnsignedNumber(2);
|
||||
this.length = parser.parseUnsignedNumber(4);
|
||||
this.type = parser.parseUnsignedNumber(1);
|
||||
this.flags = parser.parseUnsignedNumber(2);
|
||||
this.decimals = parser.parseUnsignedNumber(1);
|
||||
|
||||
var filler = parser.parseBuffer(2);
|
||||
if (filler[0] !== 0x0 || filler[1] !== 0x0) {
|
||||
var err = new TypeError('Received invalid filler');
|
||||
err.code = 'PARSER_INVALID_FILLER';
|
||||
throw err;
|
||||
}
|
||||
|
||||
// parsed flags
|
||||
this.zeroFill = (this.flags & 0x0040 ? true : false);
|
||||
|
||||
if (parser.reachedPacketEnd()) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.default = parser.parseLengthCodedString();
|
||||
} else {
|
||||
this.table = parser.parseLengthCodedString();
|
||||
this.name = parser.parseLengthCodedString();
|
||||
this.length = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
||||
this.type = parser.parseUnsignedNumber(parser.parseUnsignedNumber(1));
|
||||
}
|
||||
};
|
||||
|
||||
FieldPacket.prototype.write = function(writer) {
|
||||
if (this.protocol41) {
|
||||
writer.writeLengthCodedString(this.catalog);
|
||||
writer.writeLengthCodedString(this.db);
|
||||
writer.writeLengthCodedString(this.table);
|
||||
writer.writeLengthCodedString(this.orgTable);
|
||||
writer.writeLengthCodedString(this.name);
|
||||
writer.writeLengthCodedString(this.orgName);
|
||||
|
||||
writer.writeLengthCodedNumber(0x0c);
|
||||
writer.writeUnsignedNumber(2, this.charsetNr || 0);
|
||||
writer.writeUnsignedNumber(4, this.length || 0);
|
||||
writer.writeUnsignedNumber(1, this.type || 0);
|
||||
writer.writeUnsignedNumber(2, this.flags || 0);
|
||||
writer.writeUnsignedNumber(1, this.decimals || 0);
|
||||
writer.writeFiller(2);
|
||||
|
||||
if (this.default !== undefined) {
|
||||
writer.writeLengthCodedString(this.default);
|
||||
}
|
||||
} else {
|
||||
writer.writeLengthCodedString(this.table);
|
||||
writer.writeLengthCodedString(this.name);
|
||||
writer.writeUnsignedNumber(1, 0x01);
|
||||
writer.writeUnsignedNumber(1, this.length);
|
||||
writer.writeUnsignedNumber(1, 0x01);
|
||||
writer.writeUnsignedNumber(1, this.type);
|
||||
}
|
||||
};
|
||||
100
node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js
generated
vendored
Normal file
100
node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js
generated
vendored
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
var Client = require('../constants/client');
|
||||
|
||||
module.exports = HandshakeInitializationPacket;
|
||||
function HandshakeInitializationPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.protocolVersion = options.protocolVersion;
|
||||
this.serverVersion = options.serverVersion;
|
||||
this.threadId = options.threadId;
|
||||
this.scrambleBuff1 = options.scrambleBuff1;
|
||||
this.filler1 = options.filler1;
|
||||
this.serverCapabilities1 = options.serverCapabilities1;
|
||||
this.serverLanguage = options.serverLanguage;
|
||||
this.serverStatus = options.serverStatus;
|
||||
this.serverCapabilities2 = options.serverCapabilities2;
|
||||
this.scrambleLength = options.scrambleLength;
|
||||
this.filler2 = options.filler2;
|
||||
this.scrambleBuff2 = options.scrambleBuff2;
|
||||
this.filler3 = options.filler3;
|
||||
this.pluginData = options.pluginData;
|
||||
this.protocol41 = options.protocol41;
|
||||
|
||||
if (this.protocol41) {
|
||||
// force set the bit in serverCapabilities1
|
||||
this.serverCapabilities1 |= Client.CLIENT_PROTOCOL_41;
|
||||
}
|
||||
}
|
||||
|
||||
HandshakeInitializationPacket.prototype.parse = function(parser) {
|
||||
this.protocolVersion = parser.parseUnsignedNumber(1);
|
||||
this.serverVersion = parser.parseNullTerminatedString();
|
||||
this.threadId = parser.parseUnsignedNumber(4);
|
||||
this.scrambleBuff1 = parser.parseBuffer(8);
|
||||
this.filler1 = parser.parseFiller(1);
|
||||
this.serverCapabilities1 = parser.parseUnsignedNumber(2);
|
||||
this.serverLanguage = parser.parseUnsignedNumber(1);
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
|
||||
this.protocol41 = (this.serverCapabilities1 & (1 << 9)) > 0;
|
||||
|
||||
if (this.protocol41) {
|
||||
this.serverCapabilities2 = parser.parseUnsignedNumber(2);
|
||||
this.scrambleLength = parser.parseUnsignedNumber(1);
|
||||
this.filler2 = parser.parseFiller(10);
|
||||
// scrambleBuff2 should be 0x00 terminated, but sphinx does not do this
|
||||
// so we assume scrambleBuff2 to be 12 byte and treat the next byte as a
|
||||
// filler byte.
|
||||
this.scrambleBuff2 = parser.parseBuffer(12);
|
||||
this.filler3 = parser.parseFiller(1);
|
||||
} else {
|
||||
this.filler2 = parser.parseFiller(13);
|
||||
}
|
||||
|
||||
if (parser.reachedPacketEnd()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// According to the docs this should be 0x00 terminated, but MariaDB does
|
||||
// not do this, so we assume this string to be packet terminated.
|
||||
this.pluginData = parser.parsePacketTerminatedString();
|
||||
|
||||
// However, if there is a trailing '\0', strip it
|
||||
var lastChar = this.pluginData.length - 1;
|
||||
if (this.pluginData[lastChar] === '\0') {
|
||||
this.pluginData = this.pluginData.substr(0, lastChar);
|
||||
}
|
||||
};
|
||||
|
||||
HandshakeInitializationPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.protocolVersion);
|
||||
writer.writeNullTerminatedString(this.serverVersion);
|
||||
writer.writeUnsignedNumber(4, this.threadId);
|
||||
writer.writeBuffer(this.scrambleBuff1);
|
||||
writer.writeFiller(1);
|
||||
writer.writeUnsignedNumber(2, this.serverCapabilities1);
|
||||
writer.writeUnsignedNumber(1, this.serverLanguage);
|
||||
writer.writeUnsignedNumber(2, this.serverStatus);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.serverCapabilities2);
|
||||
writer.writeUnsignedNumber(1, this.scrambleLength);
|
||||
writer.writeFiller(10);
|
||||
}
|
||||
writer.writeNullTerminatedBuffer(this.scrambleBuff2);
|
||||
|
||||
if (this.pluginData !== undefined) {
|
||||
writer.writeNullTerminatedString(this.pluginData);
|
||||
}
|
||||
};
|
||||
|
||||
HandshakeInitializationPacket.prototype.scrambleBuff = function() {
|
||||
var buffer = new Buffer(this.scrambleBuff1.length +
|
||||
(typeof this.scrambleBuff2 != "undefined" ? this.scrambleBuff2.length : 0));
|
||||
|
||||
this.scrambleBuff1.copy(buffer);
|
||||
if (typeof this.scrambleBuff2 != "undefined") {
|
||||
this.scrambleBuff2.copy(buffer, this.scrambleBuff1.length);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
};
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
module.exports = LocalDataFilePacket;
|
||||
/**
|
||||
* @param {Buffer} data
|
||||
*/
|
||||
function LocalDataFilePacket(data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
LocalDataFilePacket.prototype.write = function(writer) {
|
||||
writer.writeBuffer(this.data);
|
||||
};
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
module.exports = OkPacket;
|
||||
function OkPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = undefined;
|
||||
this.affectedRows = undefined;
|
||||
this.insertId = undefined;
|
||||
this.serverStatus = undefined;
|
||||
this.warningCount = undefined;
|
||||
this.message = undefined;
|
||||
this.protocol41 = options.protocol41;
|
||||
}
|
||||
|
||||
OkPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseUnsignedNumber(1);
|
||||
this.affectedRows = parser.parseLengthCodedNumber();
|
||||
this.insertId = parser.parseLengthCodedNumber();
|
||||
if (this.protocol41) {
|
||||
this.serverStatus = parser.parseUnsignedNumber(2);
|
||||
this.warningCount = parser.parseUnsignedNumber(2);
|
||||
}
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
this.changedRows = 0;
|
||||
|
||||
var m = this.message.match(/\schanged:\s*(\d+)/i);
|
||||
|
||||
if (m !== null) {
|
||||
this.changedRows = parseInt(m[1], 10);
|
||||
}
|
||||
};
|
||||
|
||||
OkPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, 0x00);
|
||||
writer.writeLengthCodedNumber(this.affectedRows || 0);
|
||||
writer.writeLengthCodedNumber(this.insertId || 0);
|
||||
if (this.protocol41) {
|
||||
writer.writeUnsignedNumber(2, this.serverStatus || 0);
|
||||
writer.writeUnsignedNumber(2, this.warningCount || 0);
|
||||
}
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
module.exports = OldPasswordPacket;
|
||||
function OldPasswordPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.scrambleBuff = options.scrambleBuff;
|
||||
}
|
||||
|
||||
OldPasswordPacket.prototype.parse = function(parser) {
|
||||
this.scrambleBuff = parser.parseNullTerminatedBuffer();
|
||||
};
|
||||
|
||||
OldPasswordPacket.prototype.write = function(writer) {
|
||||
writer.writeBuffer(this.scrambleBuff);
|
||||
writer.writeFiller(1);
|
||||
};
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
module.exports = ResultSetHeaderPacket;
|
||||
function ResultSetHeaderPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.fieldCount = options.fieldCount;
|
||||
this.extra = options.extra;
|
||||
}
|
||||
|
||||
ResultSetHeaderPacket.prototype.parse = function(parser) {
|
||||
this.fieldCount = parser.parseLengthCodedNumber();
|
||||
|
||||
if (parser.reachedPacketEnd()) return;
|
||||
|
||||
this.extra = (this.fieldCount === null)
|
||||
? parser.parsePacketTerminatedString()
|
||||
: parser.parseLengthCodedNumber();
|
||||
};
|
||||
|
||||
ResultSetHeaderPacket.prototype.write = function(writer) {
|
||||
writer.writeLengthCodedNumber(this.fieldCount);
|
||||
|
||||
if (this.extra !== undefined) {
|
||||
writer.writeLengthCodedNumber(this.extra);
|
||||
}
|
||||
};
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
var Types = require('../constants/types');
|
||||
var Charsets = require('../constants/charsets');
|
||||
var Field = require('./Field');
|
||||
var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
|
||||
|
||||
module.exports = RowDataPacket;
|
||||
function RowDataPacket() {
|
||||
}
|
||||
|
||||
Object.defineProperty(RowDataPacket.prototype, 'parse', {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value: parse
|
||||
});
|
||||
|
||||
Object.defineProperty(RowDataPacket.prototype, '_typeCast', {
|
||||
configurable: true,
|
||||
enumerable: false,
|
||||
value: typeCast
|
||||
});
|
||||
|
||||
function parse(parser, fieldPackets, typeCast, nestTables, connection) {
|
||||
var self = this;
|
||||
var next = function () {
|
||||
return self._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings);
|
||||
};
|
||||
|
||||
for (var i = 0; i < fieldPackets.length; i++) {
|
||||
var fieldPacket = fieldPackets[i];
|
||||
var value;
|
||||
|
||||
if (typeof typeCast == "function") {
|
||||
value = typeCast.apply(connection, [ new Field({ packet: fieldPacket, parser: parser }), next ]);
|
||||
} else {
|
||||
value = (typeCast)
|
||||
? this._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers, connection.config.bigNumberStrings, connection.config.dateStrings)
|
||||
: ( (fieldPacket.charsetNr === Charsets.BINARY)
|
||||
? parser.parseLengthCodedBuffer()
|
||||
: parser.parseLengthCodedString() );
|
||||
}
|
||||
|
||||
if (typeof nestTables == "string" && nestTables.length) {
|
||||
this[fieldPacket.table + nestTables + fieldPacket.name] = value;
|
||||
} else if (nestTables) {
|
||||
this[fieldPacket.table] = this[fieldPacket.table] || {};
|
||||
this[fieldPacket.table][fieldPacket.name] = value;
|
||||
} else {
|
||||
this[fieldPacket.name] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function typeCast(field, parser, timeZone, supportBigNumbers, bigNumberStrings, dateStrings) {
|
||||
var numberString;
|
||||
|
||||
switch (field.type) {
|
||||
case Types.TIMESTAMP:
|
||||
case Types.DATE:
|
||||
case Types.DATETIME:
|
||||
case Types.NEWDATE:
|
||||
var dateString = parser.parseLengthCodedString();
|
||||
if (dateStrings) {
|
||||
return dateString;
|
||||
}
|
||||
var dt;
|
||||
|
||||
if (dateString === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var originalString = dateString;
|
||||
if (field.type === Types.DATE) {
|
||||
dateString += ' 00:00:00';
|
||||
}
|
||||
|
||||
if (timeZone !== 'local') {
|
||||
dateString += ' ' + timeZone;
|
||||
}
|
||||
|
||||
dt = new Date(dateString);
|
||||
if (isNaN(dt.getTime())) {
|
||||
return originalString;
|
||||
}
|
||||
|
||||
return dt;
|
||||
case Types.TINY:
|
||||
case Types.SHORT:
|
||||
case Types.LONG:
|
||||
case Types.INT24:
|
||||
case Types.YEAR:
|
||||
case Types.FLOAT:
|
||||
case Types.DOUBLE:
|
||||
numberString = parser.parseLengthCodedString();
|
||||
return (numberString === null || (field.zeroFill && numberString[0] == "0"))
|
||||
? numberString : Number(numberString);
|
||||
case Types.NEWDECIMAL:
|
||||
case Types.LONGLONG:
|
||||
numberString = parser.parseLengthCodedString();
|
||||
return (numberString === null || (field.zeroFill && numberString[0] == "0"))
|
||||
? numberString
|
||||
: ((supportBigNumbers && (bigNumberStrings || (Number(numberString) > IEEE_754_BINARY_64_PRECISION)))
|
||||
? numberString
|
||||
: Number(numberString));
|
||||
case Types.BIT:
|
||||
return parser.parseLengthCodedBuffer();
|
||||
case Types.STRING:
|
||||
case Types.VAR_STRING:
|
||||
case Types.TINY_BLOB:
|
||||
case Types.MEDIUM_BLOB:
|
||||
case Types.LONG_BLOB:
|
||||
case Types.BLOB:
|
||||
return (field.charsetNr === Charsets.BINARY)
|
||||
? parser.parseLengthCodedBuffer()
|
||||
: parser.parseLengthCodedString();
|
||||
case Types.GEOMETRY:
|
||||
return parser.parseGeometryValue();
|
||||
default:
|
||||
return parser.parseLengthCodedString();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
// http://dev.mysql.com/doc/internals/en/ssl.html
|
||||
// http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::SSLRequest
|
||||
|
||||
var ClientConstants = require('../constants/client');
|
||||
|
||||
module.exports = SSLRequestPacket;
|
||||
|
||||
function SSLRequestPacket(options) {
|
||||
options = options || {};
|
||||
this.clientFlags = options.clientFlags | ClientConstants.CLIENT_SSL;
|
||||
this.maxPacketSize = options.maxPacketSize;
|
||||
this.charsetNumber = options.charsetNumber;
|
||||
}
|
||||
|
||||
SSLRequestPacket.prototype.parse = function(parser) {
|
||||
// TODO: check SSLRequest packet v41 vs pre v41
|
||||
this.clientFlags = parser.parseUnsignedNumber(4);
|
||||
this.maxPacketSize = parser.parseUnsignedNumber(4);
|
||||
this.charsetNumber = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
SSLRequestPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(4, this.clientFlags);
|
||||
writer.writeUnsignedNumber(4, this.maxPacketSize);
|
||||
writer.writeUnsignedNumber(1, this.charsetNumber);
|
||||
writer.writeFiller(23);
|
||||
};
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
module.exports = StatisticsPacket;
|
||||
function StatisticsPacket() {
|
||||
this.message = undefined;
|
||||
}
|
||||
|
||||
StatisticsPacket.prototype.parse = function(parser) {
|
||||
this.message = parser.parsePacketTerminatedString();
|
||||
|
||||
var items = this.message.split(/\s\s/);
|
||||
for (var i = 0; i < items.length; i++) {
|
||||
var m = items[i].match(/^(.+)\:\s+(.+)$/);
|
||||
if (m !== null) {
|
||||
this[m[1].toLowerCase().replace(/\s/g, '_')] = Number(m[2]);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
StatisticsPacket.prototype.write = function(writer) {
|
||||
writer.writeString(this.message);
|
||||
};
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
module.exports = UseOldPasswordPacket;
|
||||
function UseOldPasswordPacket(options) {
|
||||
options = options || {};
|
||||
|
||||
this.firstByte = options.firstByte || 0xfe;
|
||||
}
|
||||
|
||||
UseOldPasswordPacket.prototype.parse = function(parser) {
|
||||
this.firstByte = parser.parseUnsignedNumber(1);
|
||||
};
|
||||
|
||||
UseOldPasswordPacket.prototype.write = function(writer) {
|
||||
writer.writeUnsignedNumber(1, this.firstByte);
|
||||
};
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
var Elements = module.exports = require('require-all')({
|
||||
dirname : __dirname,
|
||||
filter : /([A-Z].+)\.js$/,
|
||||
});
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
var Auth = require('../Auth');
|
||||
|
||||
module.exports = ChangeUser;
|
||||
Util.inherits(ChangeUser, Sequence);
|
||||
function ChangeUser(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
this._user = options.user;
|
||||
this._password = options.password;
|
||||
this._database = options.database;
|
||||
this._charsetNumber = options.charsetNumber;
|
||||
this._currentConfig = options.currentConfig;
|
||||
}
|
||||
|
||||
ChangeUser.prototype.start = function(handshakeInitializationPacket) {
|
||||
var scrambleBuff = handshakeInitializationPacket.scrambleBuff();
|
||||
scrambleBuff = Auth.token(this._password, scrambleBuff);
|
||||
|
||||
var packet = new Packets.ComChangeUserPacket({
|
||||
user : this._user,
|
||||
scrambleBuff : scrambleBuff,
|
||||
database : this._database,
|
||||
charsetNumber : this._charsetNumber,
|
||||
});
|
||||
|
||||
this._currentConfig.user = this._user;
|
||||
this._currentConfig.password = this._password;
|
||||
this._currentConfig.database = this._database;
|
||||
this._currentConfig.charsetNumber = this._charsetNumber;
|
||||
|
||||
this.emit('packet', packet);
|
||||
};
|
||||
|
||||
ChangeUser.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet);
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
};
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
var Auth = require('../Auth');
|
||||
var ClientConstants = require('../constants/client');
|
||||
|
||||
module.exports = Handshake;
|
||||
Util.inherits(Handshake, Sequence);
|
||||
function Handshake(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this._config = options.config;
|
||||
this._handshakeInitializationPacket = null;
|
||||
}
|
||||
|
||||
Handshake.prototype.determinePacket = function(firstByte) {
|
||||
if (firstByte === 0xff) {
|
||||
return Packets.ErrorPacket;
|
||||
}
|
||||
|
||||
if (!this._handshakeInitializationPacket) {
|
||||
return Packets.HandshakeInitializationPacket;
|
||||
}
|
||||
|
||||
if (firstByte === 0xfe) {
|
||||
return Packets.UseOldPasswordPacket;
|
||||
}
|
||||
};
|
||||
|
||||
Handshake.prototype['HandshakeInitializationPacket'] = function(packet) {
|
||||
this._handshakeInitializationPacket = packet;
|
||||
|
||||
this._config.protocol41 = packet.protocol41;
|
||||
|
||||
var serverSSLSupport = packet.serverCapabilities1 & ClientConstants.CLIENT_SSL;
|
||||
|
||||
if (this._config.ssl) {
|
||||
if (!serverSSLSupport) {
|
||||
var err = new Error('Server does not support secure connnection');
|
||||
|
||||
err.code = 'HANDSHAKE_NO_SSL_SUPPORT';
|
||||
err.fatal = true;
|
||||
|
||||
this.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
this._config.clientFlags |= ClientConstants.CLIENT_SSL;
|
||||
this.emit('packet', new Packets.SSLRequestPacket({
|
||||
clientFlags : this._config.clientFlags,
|
||||
maxPacketSize : this._config.maxPacketSize,
|
||||
charsetNumber : this._config.charsetNumber
|
||||
}));
|
||||
this.emit('start-tls');
|
||||
} else {
|
||||
this._sendCredentials();
|
||||
}
|
||||
};
|
||||
|
||||
Handshake.prototype._tlsUpgradeCompleteHandler = function() {
|
||||
this._sendCredentials();
|
||||
};
|
||||
|
||||
Handshake.prototype._sendCredentials = function(serverHello) {
|
||||
var packet = this._handshakeInitializationPacket;
|
||||
this.emit('packet', new Packets.ClientAuthenticationPacket({
|
||||
clientFlags : this._config.clientFlags,
|
||||
maxPacketSize : this._config.maxPacketSize,
|
||||
charsetNumber : this._config.charsetNumber,
|
||||
user : this._config.user,
|
||||
scrambleBuff : (packet.protocol41)
|
||||
? Auth.token(this._config.password, packet.scrambleBuff())
|
||||
: Auth.scramble323(packet.scrambleBuff(), this._config.password),
|
||||
database : this._config.database,
|
||||
protocol41 : packet.protocol41
|
||||
}));
|
||||
};
|
||||
|
||||
Handshake.prototype['UseOldPasswordPacket'] = function(packet) {
|
||||
if (!this._config.insecureAuth) {
|
||||
var err = new Error(
|
||||
'MySQL server is requesting the old and insecure pre-4.1 auth mechanism.' +
|
||||
'Upgrade the user password or use the {insecureAuth: true} option.'
|
||||
);
|
||||
|
||||
err.code = 'HANDSHAKE_INSECURE_AUTH';
|
||||
err.fatal = true;
|
||||
|
||||
this.end(err);
|
||||
return;
|
||||
}
|
||||
|
||||
this.emit('packet', new Packets.OldPasswordPacket({
|
||||
scrambleBuff : Auth.scramble323(this._handshakeInitializationPacket.scrambleBuff(), this._config.password),
|
||||
}));
|
||||
};
|
||||
|
||||
Handshake.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet, true);
|
||||
err.fatal = true;
|
||||
this.end(err);
|
||||
};
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Ping;
|
||||
Util.inherits(Ping, Sequence);
|
||||
|
||||
function Ping(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
}
|
||||
|
||||
Ping.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComPingPacket);
|
||||
};
|
||||
|
|
@ -0,0 +1,218 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
var ResultSet = require('../ResultSet');
|
||||
var ServerStatus = require('../constants/server_status');
|
||||
var fs = require('fs');
|
||||
var Readable = require('readable-stream');
|
||||
|
||||
module.exports = Query;
|
||||
Util.inherits(Query, Sequence);
|
||||
function Query(options, callback) {
|
||||
Sequence.call(this, options, callback);
|
||||
|
||||
this.sql = options.sql;
|
||||
this.values = options.values;
|
||||
this.typeCast = (options.typeCast === undefined)
|
||||
? true
|
||||
: options.typeCast;
|
||||
this.nestTables = options.nestTables || false;
|
||||
|
||||
this._resultSet = null;
|
||||
this._results = [];
|
||||
this._fields = [];
|
||||
this._index = 0;
|
||||
this._loadError = null;
|
||||
}
|
||||
|
||||
Query.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComQueryPacket(this.sql));
|
||||
};
|
||||
|
||||
Query.prototype.determinePacket = function(firstByte, parser) {
|
||||
if (firstByte === 0) {
|
||||
// If we have a resultSet and got one eofPacket
|
||||
if (this._resultSet && this._resultSet.eofPackets.length === 1) {
|
||||
// Then this is a RowDataPacket with an empty string in the first column.
|
||||
// See: https://github.com/felixge/node-mysql/issues/222
|
||||
} else if (this._resultSet && this._resultSet.resultSetHeaderPacket
|
||||
&& this._resultSet.resultSetHeaderPacket.fieldCount !== null) {
|
||||
return Packets.FieldPacket;
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (firstByte === 255) {
|
||||
return;
|
||||
}
|
||||
|
||||
// EofPacket's are 5 bytes in mysql >= 4.1
|
||||
// This is the only / best way to differentiate their firstByte from a 9
|
||||
// byte length coded binary.
|
||||
if (firstByte === 0xfe && parser.packetLength() < 9) {
|
||||
return Packets.EofPacket;
|
||||
}
|
||||
|
||||
if (!this._resultSet) {
|
||||
return Packets.ResultSetHeaderPacket;
|
||||
}
|
||||
|
||||
return (this._resultSet.eofPackets.length === 0)
|
||||
? Packets.FieldPacket
|
||||
: Packets.RowDataPacket;
|
||||
};
|
||||
|
||||
Query.prototype['OkPacket'] = function(packet) {
|
||||
// try...finally for exception safety
|
||||
try {
|
||||
if (!this._callback) {
|
||||
this.emit('result', packet, this._index);
|
||||
} else {
|
||||
this._results.push(packet);
|
||||
this._fields.push(undefined);
|
||||
}
|
||||
} finally {
|
||||
this._index++;
|
||||
this._handleFinalResultPacket(packet);
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype['ErrorPacket'] = function(packet) {
|
||||
var err = this._packetToError(packet);
|
||||
|
||||
var results = (this._results.length > 0)
|
||||
? this._results
|
||||
: undefined;
|
||||
|
||||
var fields = (this._fields.length > 0)
|
||||
? this._fields
|
||||
: undefined;
|
||||
|
||||
err.index = this._index;
|
||||
this.end(err, results, fields);
|
||||
};
|
||||
|
||||
Query.prototype['ResultSetHeaderPacket'] = function(packet) {
|
||||
this._resultSet = new ResultSet(packet);
|
||||
|
||||
// used by LOAD DATA LOCAL INFILE queries
|
||||
if (packet.fieldCount === null) {
|
||||
this._sendLocalDataFile(packet.extra);
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype['FieldPacket'] = function(packet) {
|
||||
this._resultSet.fieldPackets.push(packet);
|
||||
};
|
||||
|
||||
Query.prototype['EofPacket'] = function(packet) {
|
||||
this._resultSet.eofPackets.push(packet);
|
||||
|
||||
if (this._resultSet.eofPackets.length === 1 && !this._callback) {
|
||||
this.emit('fields', this._resultSet.fieldPackets, this._index);
|
||||
}
|
||||
|
||||
if (this._resultSet.eofPackets.length !== 2) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._callback) {
|
||||
this._results.push(this._resultSet.rows);
|
||||
this._fields.push(this._resultSet.fieldPackets);
|
||||
}
|
||||
|
||||
this._index++;
|
||||
this._resultSet = null;
|
||||
this._handleFinalResultPacket(packet);
|
||||
};
|
||||
|
||||
Query.prototype._handleFinalResultPacket = function(packet) {
|
||||
if (packet.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) {
|
||||
return;
|
||||
}
|
||||
|
||||
var results = (this._results.length > 1)
|
||||
? this._results
|
||||
: this._results[0];
|
||||
|
||||
var fields = (this._fields.length > 1)
|
||||
? this._fields
|
||||
: this._fields[0];
|
||||
|
||||
this.end(this._loadError, results, fields);
|
||||
};
|
||||
|
||||
Query.prototype['RowDataPacket'] = function(packet, parser, connection) {
|
||||
packet.parse(parser, this._resultSet.fieldPackets, this.typeCast, this.nestTables, connection);
|
||||
|
||||
if (this._callback) {
|
||||
this._resultSet.rows.push(packet);
|
||||
} else {
|
||||
this.emit('result', packet, this._index);
|
||||
}
|
||||
};
|
||||
|
||||
Query.prototype._sendLocalDataFile = function(path) {
|
||||
var self = this;
|
||||
var localStream = fs.createReadStream(path, {
|
||||
'flag': 'r',
|
||||
'encoding': null,
|
||||
'autoClose': true
|
||||
});
|
||||
|
||||
|
||||
this.on('pause', function () {
|
||||
localStream.pause();
|
||||
});
|
||||
|
||||
this.on('resume', function () {
|
||||
localStream.resume();
|
||||
});
|
||||
|
||||
localStream.on('data', function (data) {
|
||||
self.emit('packet', new Packets.LocalDataFilePacket(data));
|
||||
});
|
||||
|
||||
localStream.on('error', function (err) {
|
||||
self._loadError = err;
|
||||
localStream.emit('end');
|
||||
});
|
||||
|
||||
localStream.on('end', function () {
|
||||
self.emit('packet', new Packets.EmptyPacket());
|
||||
});
|
||||
};
|
||||
|
||||
Query.prototype.stream = function(options) {
|
||||
var self = this,
|
||||
stream;
|
||||
|
||||
options = options || {};
|
||||
options.objectMode = true;
|
||||
stream = new Readable(options);
|
||||
|
||||
stream._read = function() {
|
||||
self._connection && self._connection.resume();
|
||||
};
|
||||
|
||||
this.on('result',function(row,i) {
|
||||
if (!stream.push(row)) self._connection.pause();
|
||||
stream.emit('result',row,i); // replicate old emitter
|
||||
});
|
||||
|
||||
this.on('error',function(err) {
|
||||
stream.emit('error',err); // Pass on any errors
|
||||
});
|
||||
|
||||
this.on('end', function() {
|
||||
stream.emit('close'); // notify readers that query has completed
|
||||
stream.push(null); // pushing null, indicating EOF
|
||||
});
|
||||
|
||||
this.on('fields',function(fields,i) {
|
||||
stream.emit('fields',fields,i); // replicate old emitter
|
||||
});
|
||||
|
||||
return stream;
|
||||
};
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Quit;
|
||||
Util.inherits(Quit, Sequence);
|
||||
function Quit(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
}
|
||||
|
||||
Quit.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComQuitPacket);
|
||||
};
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
var Util = require('util');
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var Packets = require('../packets');
|
||||
var ErrorConstants = require('../constants/errors');
|
||||
|
||||
var listenerCount = EventEmitter.listenerCount
|
||||
|| function(emitter, type){ return emitter.listeners(type).length; };
|
||||
|
||||
module.exports = Sequence;
|
||||
Util.inherits(Sequence, EventEmitter);
|
||||
function Sequence(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
EventEmitter.call(this);
|
||||
|
||||
options = options || {};
|
||||
|
||||
this._callback = callback;
|
||||
this._callSite = null;
|
||||
this._ended = false;
|
||||
this._timeout = options.timeout;
|
||||
|
||||
// For Timers
|
||||
this._idleNext = null;
|
||||
this._idlePrev = null;
|
||||
this._idleStart = null;
|
||||
this._idleTimeout = undefined;
|
||||
this._repeat = null;
|
||||
}
|
||||
|
||||
Sequence.determinePacket = function(byte) {
|
||||
switch (byte) {
|
||||
case 0x00: return Packets.OkPacket;
|
||||
case 0xfe: return Packets.EofPacket;
|
||||
case 0xff: return Packets.ErrorPacket;
|
||||
}
|
||||
};
|
||||
|
||||
Sequence.prototype.hasErrorHandler = function() {
|
||||
return Boolean(this._callback) || listenerCount(this, 'error') > 1;
|
||||
};
|
||||
|
||||
Sequence.prototype._packetToError = function(packet) {
|
||||
var code = ErrorConstants[packet.errno] || 'UNKNOWN_CODE_PLEASE_REPORT';
|
||||
var err = new Error(code + ': ' + packet.message);
|
||||
err.code = code;
|
||||
err.errno = packet.errno;
|
||||
err.sqlState = packet.sqlState;
|
||||
|
||||
return err;
|
||||
};
|
||||
|
||||
Sequence.prototype._addLongStackTrace = function(err) {
|
||||
if (!this._callSite) {
|
||||
return;
|
||||
}
|
||||
|
||||
var delimiter = '\n --------------------\n' ;
|
||||
|
||||
if (err.stack.indexOf(delimiter) > -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
err.stack += delimiter + this._callSite.stack.replace(/.+\n/, '');
|
||||
};
|
||||
|
||||
Sequence.prototype.end = function(err) {
|
||||
if (this._ended) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._ended = true;
|
||||
|
||||
if (err) {
|
||||
this._addLongStackTrace(err);
|
||||
}
|
||||
|
||||
// Without this we are leaking memory. This problem was introduced in
|
||||
// 8189925374e7ce3819bbe88b64c7b15abac96b16. I suspect that the error object
|
||||
// causes a cyclic reference that the GC does not detect properly, but I was
|
||||
// unable to produce a standalone version of this leak. This would be a great
|
||||
// challenge for somebody interested in difficult problems : )!
|
||||
this._callSite = null;
|
||||
|
||||
// try...finally for exception safety
|
||||
try {
|
||||
if (err) {
|
||||
this.emit('error', err);
|
||||
}
|
||||
} finally {
|
||||
try {
|
||||
if (this._callback) {
|
||||
this._callback.apply(this, arguments);
|
||||
}
|
||||
} finally {
|
||||
this.emit('end');
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Sequence.prototype['OkPacket'] = function(packet) {
|
||||
this.end(null, packet);
|
||||
};
|
||||
|
||||
Sequence.prototype['ErrorPacket'] = function(packet) {
|
||||
this.end(this._packetToError(packet));
|
||||
};
|
||||
|
||||
// Implemented by child classes
|
||||
Sequence.prototype.start = function() {};
|
||||
|
||||
Sequence.prototype._onTimeout = function _onTimeout() {
|
||||
this.emit('timeout');
|
||||
};
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
var Sequence = require('./Sequence');
|
||||
var Util = require('util');
|
||||
var Packets = require('../packets');
|
||||
|
||||
module.exports = Statistics;
|
||||
Util.inherits(Statistics, Sequence);
|
||||
function Statistics(options, callback) {
|
||||
if (!callback && typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
|
||||
Sequence.call(this, options, callback);
|
||||
}
|
||||
|
||||
Statistics.prototype.start = function() {
|
||||
this.emit('packet', new Packets.ComStatisticsPacket);
|
||||
};
|
||||
|
||||
Statistics.prototype['StatisticsPacket'] = function (packet) {
|
||||
this.end(null, packet);
|
||||
};
|
||||
|
||||
Statistics.prototype.determinePacket = function(firstByte, parser) {
|
||||
if (firstByte === 0x55) {
|
||||
return Packets.StatisticsPacket;
|
||||
}
|
||||
};
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
var Elements = module.exports = require('require-all')({
|
||||
dirname : __dirname,
|
||||
filter : /([A-Z].+)\.js$/,
|
||||
});
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
test
|
||||
perf
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
language: node_js
|
||||
node_js:
|
||||
- "0.11"
|
||||
- "0.10"
|
||||
- "0.8"
|
||||
- "0.6"
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
The MIT Expat Licence.
|
||||
|
||||
Copyright (c) 2012 Michael Mclaughlin
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
'Software'), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
|
@ -0,0 +1,242 @@
|
|||
[](https://travis-ci.org/MikeMcl/bignumber.js)
|
||||
|
||||
# bignumber.js #
|
||||
|
||||
A JavaScript library for arbitrary-precision decimal and non-decimal arithmetic.
|
||||
|
||||
## Features
|
||||
|
||||
- Faster, smaller, and perhaps easier to use than JavaScript versions of Java's BigDecimal
|
||||
- 5 KB minified and gzipped
|
||||
- Simple API but full-featured
|
||||
- Works with numbers with or without fraction digits in bases from 2 to 64 inclusive
|
||||
- Replicates the `toExponential`, `toFixed`, `toPrecision` and `toString` methods of JavaScript's Number type
|
||||
- Includes a `toFraction` and a correctly-rounded `squareRoot` method
|
||||
- Stores values in an accessible decimal floating point format
|
||||
- No dependencies
|
||||
- Comprehensive [documentation](http://mikemcl.github.io/bignumber.js/) and test set
|
||||
|
||||
If an even smaller and simpler library is required see [big.js](https://github.com/MikeMcl/big.js/).
|
||||
It's half the size but only works with decimal numbers and only has half the methods.
|
||||
It also does not allow `NaN` or `Infinity`, or have the configuration options of this library.
|
||||
See also [decimal.js](https://github.com/MikeMcl/decimal.js/).
|
||||
|
||||
## Load
|
||||
|
||||
The library is the single JavaScript file *bignumber.js* (or minified, *bignumber.min.js*).
|
||||
|
||||
It can be loaded via a script tag in an HTML document for the browser
|
||||
|
||||
<script src='./relative/path/to/bignumber.js'></script>
|
||||
|
||||
or as a CommonJS, [Node.js](http://nodejs.org) or AMD module using `require`.
|
||||
|
||||
For Node, put the *bignumber.js* file into the same directory as the file that is requiring it and use
|
||||
|
||||
var BigNumber = require('./bignumber.js');
|
||||
|
||||
or put it in a *node_modules* directory within the directory and use `require('bignumber.js')`.
|
||||
|
||||
The library is also available from the [npm](https://npmjs.org/) registry, so
|
||||
|
||||
$ npm install bignumber.js
|
||||
|
||||
will install this directory in a *node_modules* directory within the current directory.
|
||||
|
||||
To load with AMD loader libraries such as [requireJS](http://requirejs.org/):
|
||||
|
||||
require(['path/to/bignumber'], function(BigNumber) {
|
||||
// Use BigNumber here in local scope. No global BigNumber.
|
||||
});
|
||||
|
||||
## Use
|
||||
|
||||
*In all examples below, `var`, semicolons and `toString` calls are not shown.
|
||||
If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*
|
||||
|
||||
The library exports a single function: BigNumber, the constructor of BigNumber instances.
|
||||
It accepts a value of type Number *(up to 15 significant digits only)*, String or BigNumber Object,
|
||||
|
||||
x = new BigNumber(123.4567)
|
||||
y = BigNumber('123456.7e-3') // 'new' is optional
|
||||
z = new BigNumber(x)
|
||||
x.equals(y) && y.equals(z) && x.equals(z) // true
|
||||
|
||||
and a base from 2 to 64 inclusive can be specified.
|
||||
|
||||
x = new BigNumber(1011, 2) // "11"
|
||||
y = new BigNumber('zz.9', 36) // "1295.25"
|
||||
z = x.plus(y) // "1306.25"
|
||||
|
||||
A BigNumber is immutable in the sense that it is not changed by its methods.
|
||||
|
||||
0.3 - 0.1 // 0.19999999999999998
|
||||
x = new BigNumber(0.3)
|
||||
x.minus(0.1) // "0.2"
|
||||
x // "0.3"
|
||||
|
||||
The methods that return a BigNumber can be chained.
|
||||
|
||||
x.dividedBy(y).plus(z).times(9).floor()
|
||||
x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4444562598.111772').ceil()
|
||||
|
||||
Method names over 5 letters in length have a shorter alias.
|
||||
|
||||
x.squareRoot().dividedBy(y).toPower(3).equals(x.sqrt().div(y).pow(3)) // true
|
||||
x.cmp(y.mod(z).neg()) == 1 && x.comparedTo(y.modulo(z).negated()) == 1 // true
|
||||
|
||||
Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods
|
||||
|
||||
x = new BigNumber(255.5)
|
||||
x.toExponential(5) // "2.55500e+2"
|
||||
x.toFixed(5) // "255.50000"
|
||||
x.toPrecision(5) // "255.50"
|
||||
x.toNumber() // 255.5
|
||||
|
||||
and a base can be specified for `toString`.
|
||||
|
||||
x.toString(16) // "ff.8"
|
||||
|
||||
The maximum number of decimal places of, and the rounding mode applied to, the results of operations involving division (i.e. division, square root, base conversion, and negative power operations) is set by a configuration object passed to the `config` method of the `BigNumber` constructor.
|
||||
The other arithmetic operations always give the exact result.
|
||||
|
||||
BigNumber.config({ DECIMAL_PLACES: 10, ROUNDING_MODE: 4 })
|
||||
// Alternatively, BigNumber.config( 10, 4 );
|
||||
|
||||
x = new BigNumber(2);
|
||||
y = new BigNumber(3);
|
||||
z = x.div(y) // "0.6666666667"
|
||||
z.sqrt() // "0.8164965809"
|
||||
z.pow(-3) // "3.3749999995"
|
||||
z.toString(2) // "0.1010101011"
|
||||
z.times(z) // "0.44444444448888888889"
|
||||
z.times(z).round(10) // "0.4444444445"
|
||||
|
||||
There is a `toFraction` method with an optional *maximum denominator* argument
|
||||
|
||||
y = new BigNumber(355)
|
||||
pi = y.dividedBy(113) // "3.1415929204"
|
||||
pi.toFraction() // [ "7853982301", "2500000000" ]
|
||||
pi.toFraction(1000) // [ "355", "113" ]
|
||||
|
||||
and `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `BigNumber` values.
|
||||
|
||||
x = new BigNumber(NaN) // "NaN"
|
||||
y = new BigNumber(Infinity) // "Infinity"
|
||||
x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite() // true
|
||||
|
||||
The value of a BigNumber is stored in a decimal floating point format in terms of a coefficient, exponent and sign.
|
||||
|
||||
x = new BigNumber(-123.456);
|
||||
x.c // "1,2,3,4,5,6" coefficient (i.e. significand)
|
||||
x.e // 2 exponent
|
||||
x.s // -1 sign
|
||||
|
||||
For futher information see the [API](http://mikemcl.github.io/bignumber.js/) reference from the *doc* folder.
|
||||
|
||||
## Test
|
||||
|
||||
The *test* directory contains the test scripts for each method.
|
||||
|
||||
The tests can be run with Node or a browser.
|
||||
|
||||
For a quick test of all the methods, from a command-line shell at the *test/* directory
|
||||
|
||||
$ node quick-test
|
||||
|
||||
To test a single method in more depth, e.g.
|
||||
|
||||
$ node toFraction
|
||||
|
||||
To test all the methods in more depth
|
||||
|
||||
$ node every-test
|
||||
|
||||
For the browser, see *quick-test.html*, *single-test.html* and *every-test.html* in the *test/browser* directory.
|
||||
|
||||
*bignumber-vs-number.html* enables some of the methods of bignumber.js to be compared with those of JavaScript's Number type.
|
||||
|
||||
## Performance
|
||||
|
||||
The *perf* directory contains two applications and a *lib* directory containing the BigDecimal libraries used by both.
|
||||
|
||||
*bignumber-vs-bigdecimal.html* tests the performance of bignumber.js against the JavaScript translations of two versions of BigDecimal, its use should be more or less self-explanatory.
|
||||
(The GWT version doesn't work in IE 6.)
|
||||
|
||||
* GWT: java.math.BigDecimal
|
||||
<https://github.com/iriscouch/bigdecimal.js>
|
||||
* ICU4J: com.ibm.icu.math.BigDecimal
|
||||
<https://github.com/dtrebbien/BigDecimal.js>
|
||||
|
||||
The BigDecimal in Node's npm registry is the GWT version. Despite its seeming popularity I have found it to have some serious bugs, see the Node script *perf/lib/bigdecimal_GWT/bugs.js* for examples of flaws in its *remainder*, *divide* and *compareTo* methods.
|
||||
|
||||
*bigtime.js* is a Node command-line application which tests the performance of bignumber.js against the GWT version of BigDecimal from the npm registry.
|
||||
|
||||
For example, to compare the time taken by the bignumber.js `plus` method and the BigDecimal `add` method:
|
||||
|
||||
$ node bigtime plus 10000 40
|
||||
|
||||
This will time 10000 calls to each, using operands of up to 40 random digits and will check that the results match.
|
||||
|
||||
For help:
|
||||
|
||||
$ node bigtime -h
|
||||
|
||||
See the README in the directory for more information.
|
||||
|
||||
## Build
|
||||
|
||||
I.e. minify.
|
||||
|
||||
For Node, if uglify-js is installed globally ( `npm install uglify-js -g` ) then
|
||||
|
||||
npm run build
|
||||
|
||||
will create *bignumber.min.js*.
|
||||
|
||||
## Feedback
|
||||
|
||||
Open an issue, or email
|
||||
|
||||
Michael
|
||||
<a href="mailto:M8ch88l@gmail.com">M8ch88l@gmail.com</a>
|
||||
|
||||
Bitcoin donation to:
|
||||
**1CauoGYrEoJFhcyxGVaiLTE6f3WCaSUjnm**
|
||||
Thank you
|
||||
|
||||
## Licence
|
||||
|
||||
MIT.
|
||||
|
||||
See LICENCE.
|
||||
|
||||
## Change Log
|
||||
|
||||
####1.4.1
|
||||
* 08/06/2014 Amend README.
|
||||
|
||||
####1.4.0
|
||||
* 08/05/2014 Added `toNumber`.
|
||||
|
||||
####1.3.0
|
||||
* 08/11/2013 Ensure correct rounding of `sqrt` in all, rather than almost all, cases.
|
||||
* Maximum radix to 64.
|
||||
|
||||
####1.2.1
|
||||
* 17/10/2013 Sign of zero when x < 0 and x + (-x) = 0.
|
||||
|
||||
####1.2.0
|
||||
* 19/9/2013 Throw Error objects for stack.
|
||||
|
||||
####1.1.1
|
||||
* 22/8/2013 Show original value in constructor error message.
|
||||
|
||||
####1.1.0
|
||||
* 1/8/2013 Allow numbers with trailing radix point.
|
||||
|
||||
####1.0.1
|
||||
* Bugfix: error messages with incorrect method name
|
||||
|
||||
####1.0.0
|
||||
* 8/11/2012 Initial release
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,61 @@
|
|||
{
|
||||
"name": "bignumber.js",
|
||||
"description": "A library for arbitrary-precision decimal and non-decimal arithmetic",
|
||||
"version": "1.4.1",
|
||||
"keywords": [
|
||||
"arbitrary",
|
||||
"precision",
|
||||
"arithmetic",
|
||||
"big",
|
||||
"number",
|
||||
"decimal",
|
||||
"float",
|
||||
"biginteger",
|
||||
"bigdecimal",
|
||||
"bignumber",
|
||||
"bigint",
|
||||
"bignum"
|
||||
],
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/MikeMcl/bignumber.js.git"
|
||||
},
|
||||
"main": "bignumber",
|
||||
"author": {
|
||||
"name": "Michael Mclaughlin",
|
||||
"email": "M8ch88l@gmail.com"
|
||||
},
|
||||
"engines": {
|
||||
"node": "*"
|
||||
},
|
||||
"license": "MIT",
|
||||
"scripts": {
|
||||
"test": "node ./test/every-test.js",
|
||||
"build": "uglifyjs bignumber.js -c -m -o bignumber.min.js --preamble '/* bignumber.js v1.4.1 https://github.com/MikeMcl/bignumber.js/LICENCE */'"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/MikeMcl/bignumber.js/issues"
|
||||
},
|
||||
"homepage": "https://github.com/MikeMcl/bignumber.js",
|
||||
"_id": "bignumber.js@1.4.1",
|
||||
"dist": {
|
||||
"shasum": "3d19ac321f8db4ba07aace23ebd4ac976fae6bfa",
|
||||
"tarball": "http://registry.npmjs.org/bignumber.js/-/bignumber.js-1.4.1.tgz"
|
||||
},
|
||||
"_from": "bignumber.js@1.4.1",
|
||||
"_npmVersion": "1.4.6",
|
||||
"_npmUser": {
|
||||
"name": "mikemcl",
|
||||
"email": "M8ch88l@gmail.com"
|
||||
},
|
||||
"maintainers": [
|
||||
{
|
||||
"name": "mikemcl",
|
||||
"email": "M8ch88l@gmail.com"
|
||||
}
|
||||
],
|
||||
"directories": {},
|
||||
"_shasum": "3d19ac321f8db4ba07aace23ebd4ac976fae6bfa",
|
||||
"_resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-1.4.1.tgz",
|
||||
"readme": "ERROR: No README data found!"
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
build/
|
||||
test/
|
||||
examples/
|
||||
fs.js
|
||||
zlib.js
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to
|
||||
deal in the Software without restriction, including without limitation the
|
||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
IN THE SOFTWARE.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# readable-stream
|
||||
|
||||
***Node-core streams for userland***
|
||||
|
||||
[](https://nodei.co/npm/readable-stream/)
|
||||
[](https://nodei.co/npm/readable-stream/)
|
||||
|
||||
This package is a mirror of the Streams2 and Streams3 implementations in Node-core.
|
||||
|
||||
If you want to guarantee a stable streams base, regardless of what version of Node you, or the users of your libraries are using, use **readable-stream** *only* and avoid the *"stream"* module in Node-core.
|
||||
|
||||
**readable-stream** comes in two major versions, v1.0.x and v1.1.x. The former tracks the Streams2 implementation in Node 0.10, including bug-fixes and minor improvements as they are added. The latter tracks Streams3 as it develops in Node 0.11; we will likely see a v1.2.x branch for Node 0.12.
|
||||
|
||||
**readable-stream** uses proper patch-level versioning so if you pin to `"~1.0.0"` you’ll get the latest Node 0.10 Streams2 implementation, including any fixes and minor non-breaking improvements. The patch-level versions of 1.0.x and 1.1.x should mirror the patch-level versions of Node-core releases. You should prefer the **1.0.x** releases for now and when you’re ready to start using Streams3, pin to `"~1.1.0"`
|
||||
|
||||
|
|
@ -0,0 +1 @@
|
|||
module.exports = require("./lib/_stream_duplex.js")
|
||||
|
|
@ -0,0 +1,923 @@
|
|||
diff --git a/lib/_stream_duplex.js b/lib/_stream_duplex.js
|
||||
index c5a741c..a2e0d8e 100644
|
||||
--- a/lib/_stream_duplex.js
|
||||
+++ b/lib/_stream_duplex.js
|
||||
@@ -26,8 +26,8 @@
|
||||
|
||||
module.exports = Duplex;
|
||||
var util = require('util');
|
||||
-var Readable = require('_stream_readable');
|
||||
-var Writable = require('_stream_writable');
|
||||
+var Readable = require('./_stream_readable');
|
||||
+var Writable = require('./_stream_writable');
|
||||
|
||||
util.inherits(Duplex, Readable);
|
||||
|
||||
diff --git a/lib/_stream_passthrough.js b/lib/_stream_passthrough.js
|
||||
index a5e9864..330c247 100644
|
||||
--- a/lib/_stream_passthrough.js
|
||||
+++ b/lib/_stream_passthrough.js
|
||||
@@ -25,7 +25,7 @@
|
||||
|
||||
module.exports = PassThrough;
|
||||
|
||||
-var Transform = require('_stream_transform');
|
||||
+var Transform = require('./_stream_transform');
|
||||
var util = require('util');
|
||||
util.inherits(PassThrough, Transform);
|
||||
|
||||
diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
|
||||
index 0c3fe3e..90a8298 100644
|
||||
--- a/lib/_stream_readable.js
|
||||
+++ b/lib/_stream_readable.js
|
||||
@@ -23,10 +23,34 @@ module.exports = Readable;
|
||||
Readable.ReadableState = ReadableState;
|
||||
|
||||
var EE = require('events').EventEmitter;
|
||||
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
|
||||
+ return emitter.listeners(type).length;
|
||||
+};
|
||||
+
|
||||
+if (!global.setImmediate) global.setImmediate = function setImmediate(fn) {
|
||||
+ return setTimeout(fn, 0);
|
||||
+};
|
||||
+if (!global.clearImmediate) global.clearImmediate = function clearImmediate(i) {
|
||||
+ return clearTimeout(i);
|
||||
+};
|
||||
+
|
||||
var Stream = require('stream');
|
||||
var util = require('util');
|
||||
+if (!util.isUndefined) {
|
||||
+ var utilIs = require('core-util-is');
|
||||
+ for (var f in utilIs) {
|
||||
+ util[f] = utilIs[f];
|
||||
+ }
|
||||
+}
|
||||
var StringDecoder;
|
||||
-var debug = util.debuglog('stream');
|
||||
+var debug;
|
||||
+if (util.debuglog)
|
||||
+ debug = util.debuglog('stream');
|
||||
+else try {
|
||||
+ debug = require('debuglog')('stream');
|
||||
+} catch (er) {
|
||||
+ debug = function() {};
|
||||
+}
|
||||
|
||||
util.inherits(Readable, Stream);
|
||||
|
||||
@@ -380,7 +404,7 @@ function chunkInvalid(state, chunk) {
|
||||
|
||||
|
||||
function onEofChunk(stream, state) {
|
||||
- if (state.decoder && !state.ended) {
|
||||
+ if (state.decoder && !state.ended && state.decoder.end) {
|
||||
var chunk = state.decoder.end();
|
||||
if (chunk && chunk.length) {
|
||||
state.buffer.push(chunk);
|
||||
diff --git a/lib/_stream_transform.js b/lib/_stream_transform.js
|
||||
index b1f9fcc..b0caf57 100644
|
||||
--- a/lib/_stream_transform.js
|
||||
+++ b/lib/_stream_transform.js
|
||||
@@ -64,8 +64,14 @@
|
||||
|
||||
module.exports = Transform;
|
||||
|
||||
-var Duplex = require('_stream_duplex');
|
||||
+var Duplex = require('./_stream_duplex');
|
||||
var util = require('util');
|
||||
+if (!util.isUndefined) {
|
||||
+ var utilIs = require('core-util-is');
|
||||
+ for (var f in utilIs) {
|
||||
+ util[f] = utilIs[f];
|
||||
+ }
|
||||
+}
|
||||
util.inherits(Transform, Duplex);
|
||||
|
||||
|
||||
diff --git a/lib/_stream_writable.js b/lib/_stream_writable.js
|
||||
index ba2e920..f49288b 100644
|
||||
--- a/lib/_stream_writable.js
|
||||
+++ b/lib/_stream_writable.js
|
||||
@@ -27,6 +27,12 @@ module.exports = Writable;
|
||||
Writable.WritableState = WritableState;
|
||||
|
||||
var util = require('util');
|
||||
+if (!util.isUndefined) {
|
||||
+ var utilIs = require('core-util-is');
|
||||
+ for (var f in utilIs) {
|
||||
+ util[f] = utilIs[f];
|
||||
+ }
|
||||
+}
|
||||
var Stream = require('stream');
|
||||
|
||||
util.inherits(Writable, Stream);
|
||||
@@ -119,7 +125,7 @@ function WritableState(options, stream) {
|
||||
function Writable(options) {
|
||||
// Writable ctor is applied to Duplexes, though they're not
|
||||
// instanceof Writable, they're instanceof Readable.
|
||||
- if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
|
||||
+ if (!(this instanceof Writable) && !(this instanceof require('./_stream_duplex')))
|
||||
return new Writable(options);
|
||||
|
||||
this._writableState = new WritableState(options, this);
|
||||
diff --git a/test/simple/test-stream-big-push.js b/test/simple/test-stream-big-push.js
|
||||
index e3787e4..8cd2127 100644
|
||||
--- a/test/simple/test-stream-big-push.js
|
||||
+++ b/test/simple/test-stream-big-push.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var str = 'asdfasdfasdfasdfasdf';
|
||||
|
||||
var r = new stream.Readable({
|
||||
diff --git a/test/simple/test-stream-end-paused.js b/test/simple/test-stream-end-paused.js
|
||||
index bb73777..d40efc7 100644
|
||||
--- a/test/simple/test-stream-end-paused.js
|
||||
+++ b/test/simple/test-stream-end-paused.js
|
||||
@@ -25,7 +25,7 @@ var gotEnd = false;
|
||||
|
||||
// Make sure we don't miss the end event for paused 0-length streams
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
var stream = new Readable();
|
||||
var calledRead = false;
|
||||
stream._read = function() {
|
||||
diff --git a/test/simple/test-stream-pipe-after-end.js b/test/simple/test-stream-pipe-after-end.js
|
||||
index b46ee90..0be8366 100644
|
||||
--- a/test/simple/test-stream-pipe-after-end.js
|
||||
+++ b/test/simple/test-stream-pipe-after-end.js
|
||||
@@ -22,8 +22,8 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('_stream_readable');
|
||||
-var Writable = require('_stream_writable');
|
||||
+var Readable = require('../../lib/_stream_readable');
|
||||
+var Writable = require('../../lib/_stream_writable');
|
||||
var util = require('util');
|
||||
|
||||
util.inherits(TestReadable, Readable);
|
||||
diff --git a/test/simple/test-stream-pipe-cleanup.js b/test/simple/test-stream-pipe-cleanup.js
|
||||
deleted file mode 100644
|
||||
index f689358..0000000
|
||||
--- a/test/simple/test-stream-pipe-cleanup.js
|
||||
+++ /dev/null
|
||||
@@ -1,122 +0,0 @@
|
||||
-// Copyright Joyent, Inc. and other Node contributors.
|
||||
-//
|
||||
-// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
-// copy of this software and associated documentation files (the
|
||||
-// "Software"), to deal in the Software without restriction, including
|
||||
-// without limitation the rights to use, copy, modify, merge, publish,
|
||||
-// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
-// persons to whom the Software is furnished to do so, subject to the
|
||||
-// following conditions:
|
||||
-//
|
||||
-// The above copyright notice and this permission notice shall be included
|
||||
-// in all copies or substantial portions of the Software.
|
||||
-//
|
||||
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
-
|
||||
-// This test asserts that Stream.prototype.pipe does not leave listeners
|
||||
-// hanging on the source or dest.
|
||||
-
|
||||
-var common = require('../common');
|
||||
-var stream = require('stream');
|
||||
-var assert = require('assert');
|
||||
-var util = require('util');
|
||||
-
|
||||
-function Writable() {
|
||||
- this.writable = true;
|
||||
- this.endCalls = 0;
|
||||
- stream.Stream.call(this);
|
||||
-}
|
||||
-util.inherits(Writable, stream.Stream);
|
||||
-Writable.prototype.end = function() {
|
||||
- this.endCalls++;
|
||||
-};
|
||||
-
|
||||
-Writable.prototype.destroy = function() {
|
||||
- this.endCalls++;
|
||||
-};
|
||||
-
|
||||
-function Readable() {
|
||||
- this.readable = true;
|
||||
- stream.Stream.call(this);
|
||||
-}
|
||||
-util.inherits(Readable, stream.Stream);
|
||||
-
|
||||
-function Duplex() {
|
||||
- this.readable = true;
|
||||
- Writable.call(this);
|
||||
-}
|
||||
-util.inherits(Duplex, Writable);
|
||||
-
|
||||
-var i = 0;
|
||||
-var limit = 100;
|
||||
-
|
||||
-var w = new Writable();
|
||||
-
|
||||
-var r;
|
||||
-
|
||||
-for (i = 0; i < limit; i++) {
|
||||
- r = new Readable();
|
||||
- r.pipe(w);
|
||||
- r.emit('end');
|
||||
-}
|
||||
-assert.equal(0, r.listeners('end').length);
|
||||
-assert.equal(limit, w.endCalls);
|
||||
-
|
||||
-w.endCalls = 0;
|
||||
-
|
||||
-for (i = 0; i < limit; i++) {
|
||||
- r = new Readable();
|
||||
- r.pipe(w);
|
||||
- r.emit('close');
|
||||
-}
|
||||
-assert.equal(0, r.listeners('close').length);
|
||||
-assert.equal(limit, w.endCalls);
|
||||
-
|
||||
-w.endCalls = 0;
|
||||
-
|
||||
-r = new Readable();
|
||||
-
|
||||
-for (i = 0; i < limit; i++) {
|
||||
- w = new Writable();
|
||||
- r.pipe(w);
|
||||
- w.emit('close');
|
||||
-}
|
||||
-assert.equal(0, w.listeners('close').length);
|
||||
-
|
||||
-r = new Readable();
|
||||
-w = new Writable();
|
||||
-var d = new Duplex();
|
||||
-r.pipe(d); // pipeline A
|
||||
-d.pipe(w); // pipeline B
|
||||
-assert.equal(r.listeners('end').length, 2); // A.onend, A.cleanup
|
||||
-assert.equal(r.listeners('close').length, 2); // A.onclose, A.cleanup
|
||||
-assert.equal(d.listeners('end').length, 2); // B.onend, B.cleanup
|
||||
-assert.equal(d.listeners('close').length, 3); // A.cleanup, B.onclose, B.cleanup
|
||||
-assert.equal(w.listeners('end').length, 0);
|
||||
-assert.equal(w.listeners('close').length, 1); // B.cleanup
|
||||
-
|
||||
-r.emit('end');
|
||||
-assert.equal(d.endCalls, 1);
|
||||
-assert.equal(w.endCalls, 0);
|
||||
-assert.equal(r.listeners('end').length, 0);
|
||||
-assert.equal(r.listeners('close').length, 0);
|
||||
-assert.equal(d.listeners('end').length, 2); // B.onend, B.cleanup
|
||||
-assert.equal(d.listeners('close').length, 2); // B.onclose, B.cleanup
|
||||
-assert.equal(w.listeners('end').length, 0);
|
||||
-assert.equal(w.listeners('close').length, 1); // B.cleanup
|
||||
-
|
||||
-d.emit('end');
|
||||
-assert.equal(d.endCalls, 1);
|
||||
-assert.equal(w.endCalls, 1);
|
||||
-assert.equal(r.listeners('end').length, 0);
|
||||
-assert.equal(r.listeners('close').length, 0);
|
||||
-assert.equal(d.listeners('end').length, 0);
|
||||
-assert.equal(d.listeners('close').length, 0);
|
||||
-assert.equal(w.listeners('end').length, 0);
|
||||
-assert.equal(w.listeners('close').length, 0);
|
||||
diff --git a/test/simple/test-stream-pipe-error-handling.js b/test/simple/test-stream-pipe-error-handling.js
|
||||
index c5d724b..c7d6b7d 100644
|
||||
--- a/test/simple/test-stream-pipe-error-handling.js
|
||||
+++ b/test/simple/test-stream-pipe-error-handling.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
-var Stream = require('stream').Stream;
|
||||
+var Stream = require('../../').Stream;
|
||||
|
||||
(function testErrorListenerCatches() {
|
||||
var source = new Stream();
|
||||
diff --git a/test/simple/test-stream-pipe-event.js b/test/simple/test-stream-pipe-event.js
|
||||
index cb9d5fe..56f8d61 100644
|
||||
--- a/test/simple/test-stream-pipe-event.js
|
||||
+++ b/test/simple/test-stream-pipe-event.js
|
||||
@@ -20,7 +20,7 @@
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var common = require('../common');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var assert = require('assert');
|
||||
var util = require('util');
|
||||
|
||||
diff --git a/test/simple/test-stream-push-order.js b/test/simple/test-stream-push-order.js
|
||||
index f2e6ec2..a5c9bf9 100644
|
||||
--- a/test/simple/test-stream-push-order.js
|
||||
+++ b/test/simple/test-stream-push-order.js
|
||||
@@ -20,7 +20,7 @@
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var common = require('../common.js');
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
var assert = require('assert');
|
||||
|
||||
var s = new Readable({
|
||||
diff --git a/test/simple/test-stream-push-strings.js b/test/simple/test-stream-push-strings.js
|
||||
index 06f43dc..1701a9a 100644
|
||||
--- a/test/simple/test-stream-push-strings.js
|
||||
+++ b/test/simple/test-stream-push-strings.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
var util = require('util');
|
||||
|
||||
util.inherits(MyStream, Readable);
|
||||
diff --git a/test/simple/test-stream-readable-event.js b/test/simple/test-stream-readable-event.js
|
||||
index ba6a577..a8e6f7b 100644
|
||||
--- a/test/simple/test-stream-readable-event.js
|
||||
+++ b/test/simple/test-stream-readable-event.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
|
||||
(function first() {
|
||||
// First test, not reading when the readable is added.
|
||||
diff --git a/test/simple/test-stream-readable-flow-recursion.js b/test/simple/test-stream-readable-flow-recursion.js
|
||||
index 2891ad6..11689ba 100644
|
||||
--- a/test/simple/test-stream-readable-flow-recursion.js
|
||||
+++ b/test/simple/test-stream-readable-flow-recursion.js
|
||||
@@ -27,7 +27,7 @@ var assert = require('assert');
|
||||
// more data continuously, but without triggering a nextTick
|
||||
// warning or RangeError.
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
|
||||
// throw an error if we trigger a nextTick warning.
|
||||
process.throwDeprecation = true;
|
||||
diff --git a/test/simple/test-stream-unshift-empty-chunk.js b/test/simple/test-stream-unshift-empty-chunk.js
|
||||
index 0c96476..7827538 100644
|
||||
--- a/test/simple/test-stream-unshift-empty-chunk.js
|
||||
+++ b/test/simple/test-stream-unshift-empty-chunk.js
|
||||
@@ -24,7 +24,7 @@ var assert = require('assert');
|
||||
|
||||
// This test verifies that stream.unshift(Buffer(0)) or
|
||||
// stream.unshift('') does not set state.reading=false.
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
|
||||
var r = new Readable();
|
||||
var nChunks = 10;
|
||||
diff --git a/test/simple/test-stream-unshift-read-race.js b/test/simple/test-stream-unshift-read-race.js
|
||||
index 83fd9fa..17c18aa 100644
|
||||
--- a/test/simple/test-stream-unshift-read-race.js
|
||||
+++ b/test/simple/test-stream-unshift-read-race.js
|
||||
@@ -29,7 +29,7 @@ var assert = require('assert');
|
||||
// 3. push() after the EOF signaling null is an error.
|
||||
// 4. _read() is not called after pushing the EOF null chunk.
|
||||
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var hwm = 10;
|
||||
var r = stream.Readable({ highWaterMark: hwm });
|
||||
var chunks = 10;
|
||||
@@ -51,7 +51,14 @@ r._read = function(n) {
|
||||
|
||||
function push(fast) {
|
||||
assert(!pushedNull, 'push() after null push');
|
||||
- var c = pos >= data.length ? null : data.slice(pos, pos + n);
|
||||
+ var c;
|
||||
+ if (pos >= data.length)
|
||||
+ c = null;
|
||||
+ else {
|
||||
+ if (n + pos > data.length)
|
||||
+ n = data.length - pos;
|
||||
+ c = data.slice(pos, pos + n);
|
||||
+ }
|
||||
pushedNull = c === null;
|
||||
if (fast) {
|
||||
pos += n;
|
||||
diff --git a/test/simple/test-stream-writev.js b/test/simple/test-stream-writev.js
|
||||
index 5b49e6e..b5321f3 100644
|
||||
--- a/test/simple/test-stream-writev.js
|
||||
+++ b/test/simple/test-stream-writev.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
|
||||
var queue = [];
|
||||
for (var decode = 0; decode < 2; decode++) {
|
||||
diff --git a/test/simple/test-stream2-basic.js b/test/simple/test-stream2-basic.js
|
||||
index 3814bf0..248c1be 100644
|
||||
--- a/test/simple/test-stream2-basic.js
|
||||
+++ b/test/simple/test-stream2-basic.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
|
||||
var common = require('../common.js');
|
||||
-var R = require('_stream_readable');
|
||||
+var R = require('../../lib/_stream_readable');
|
||||
var assert = require('assert');
|
||||
|
||||
var util = require('util');
|
||||
diff --git a/test/simple/test-stream2-compatibility.js b/test/simple/test-stream2-compatibility.js
|
||||
index 6cdd4e9..f0fa84b 100644
|
||||
--- a/test/simple/test-stream2-compatibility.js
|
||||
+++ b/test/simple/test-stream2-compatibility.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
|
||||
var common = require('../common.js');
|
||||
-var R = require('_stream_readable');
|
||||
+var R = require('../../lib/_stream_readable');
|
||||
var assert = require('assert');
|
||||
|
||||
var util = require('util');
|
||||
diff --git a/test/simple/test-stream2-finish-pipe.js b/test/simple/test-stream2-finish-pipe.js
|
||||
index 39b274f..006a19b 100644
|
||||
--- a/test/simple/test-stream2-finish-pipe.js
|
||||
+++ b/test/simple/test-stream2-finish-pipe.js
|
||||
@@ -20,7 +20,7 @@
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var common = require('../common.js');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var Buffer = require('buffer').Buffer;
|
||||
|
||||
var r = new stream.Readable();
|
||||
diff --git a/test/simple/test-stream2-fs.js b/test/simple/test-stream2-fs.js
|
||||
deleted file mode 100644
|
||||
index e162406..0000000
|
||||
--- a/test/simple/test-stream2-fs.js
|
||||
+++ /dev/null
|
||||
@@ -1,72 +0,0 @@
|
||||
-// Copyright Joyent, Inc. and other Node contributors.
|
||||
-//
|
||||
-// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
-// copy of this software and associated documentation files (the
|
||||
-// "Software"), to deal in the Software without restriction, including
|
||||
-// without limitation the rights to use, copy, modify, merge, publish,
|
||||
-// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
-// persons to whom the Software is furnished to do so, subject to the
|
||||
-// following conditions:
|
||||
-//
|
||||
-// The above copyright notice and this permission notice shall be included
|
||||
-// in all copies or substantial portions of the Software.
|
||||
-//
|
||||
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
-
|
||||
-
|
||||
-var common = require('../common.js');
|
||||
-var R = require('_stream_readable');
|
||||
-var assert = require('assert');
|
||||
-
|
||||
-var fs = require('fs');
|
||||
-var FSReadable = fs.ReadStream;
|
||||
-
|
||||
-var path = require('path');
|
||||
-var file = path.resolve(common.fixturesDir, 'x1024.txt');
|
||||
-
|
||||
-var size = fs.statSync(file).size;
|
||||
-
|
||||
-var expectLengths = [1024];
|
||||
-
|
||||
-var util = require('util');
|
||||
-var Stream = require('stream');
|
||||
-
|
||||
-util.inherits(TestWriter, Stream);
|
||||
-
|
||||
-function TestWriter() {
|
||||
- Stream.apply(this);
|
||||
- this.buffer = [];
|
||||
- this.length = 0;
|
||||
-}
|
||||
-
|
||||
-TestWriter.prototype.write = function(c) {
|
||||
- this.buffer.push(c.toString());
|
||||
- this.length += c.length;
|
||||
- return true;
|
||||
-};
|
||||
-
|
||||
-TestWriter.prototype.end = function(c) {
|
||||
- if (c) this.buffer.push(c.toString());
|
||||
- this.emit('results', this.buffer);
|
||||
-}
|
||||
-
|
||||
-var r = new FSReadable(file);
|
||||
-var w = new TestWriter();
|
||||
-
|
||||
-w.on('results', function(res) {
|
||||
- console.error(res, w.length);
|
||||
- assert.equal(w.length, size);
|
||||
- var l = 0;
|
||||
- assert.deepEqual(res.map(function (c) {
|
||||
- return c.length;
|
||||
- }), expectLengths);
|
||||
- console.log('ok');
|
||||
-});
|
||||
-
|
||||
-r.pipe(w);
|
||||
diff --git a/test/simple/test-stream2-httpclient-response-end.js b/test/simple/test-stream2-httpclient-response-end.js
|
||||
deleted file mode 100644
|
||||
index 15cffc2..0000000
|
||||
--- a/test/simple/test-stream2-httpclient-response-end.js
|
||||
+++ /dev/null
|
||||
@@ -1,52 +0,0 @@
|
||||
-// Copyright Joyent, Inc. and other Node contributors.
|
||||
-//
|
||||
-// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
-// copy of this software and associated documentation files (the
|
||||
-// "Software"), to deal in the Software without restriction, including
|
||||
-// without limitation the rights to use, copy, modify, merge, publish,
|
||||
-// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
-// persons to whom the Software is furnished to do so, subject to the
|
||||
-// following conditions:
|
||||
-//
|
||||
-// The above copyright notice and this permission notice shall be included
|
||||
-// in all copies or substantial portions of the Software.
|
||||
-//
|
||||
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
-
|
||||
-var common = require('../common.js');
|
||||
-var assert = require('assert');
|
||||
-var http = require('http');
|
||||
-var msg = 'Hello';
|
||||
-var readable_event = false;
|
||||
-var end_event = false;
|
||||
-var server = http.createServer(function(req, res) {
|
||||
- res.writeHead(200, {'Content-Type': 'text/plain'});
|
||||
- res.end(msg);
|
||||
-}).listen(common.PORT, function() {
|
||||
- http.get({port: common.PORT}, function(res) {
|
||||
- var data = '';
|
||||
- res.on('readable', function() {
|
||||
- console.log('readable event');
|
||||
- readable_event = true;
|
||||
- data += res.read();
|
||||
- });
|
||||
- res.on('end', function() {
|
||||
- console.log('end event');
|
||||
- end_event = true;
|
||||
- assert.strictEqual(msg, data);
|
||||
- server.close();
|
||||
- });
|
||||
- });
|
||||
-});
|
||||
-
|
||||
-process.on('exit', function() {
|
||||
- assert(readable_event);
|
||||
- assert(end_event);
|
||||
-});
|
||||
-
|
||||
diff --git a/test/simple/test-stream2-large-read-stall.js b/test/simple/test-stream2-large-read-stall.js
|
||||
index 2fbfbca..667985b 100644
|
||||
--- a/test/simple/test-stream2-large-read-stall.js
|
||||
+++ b/test/simple/test-stream2-large-read-stall.js
|
||||
@@ -30,7 +30,7 @@ var PUSHSIZE = 20;
|
||||
var PUSHCOUNT = 1000;
|
||||
var HWM = 50;
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
var r = new Readable({
|
||||
highWaterMark: HWM
|
||||
});
|
||||
@@ -39,23 +39,23 @@ var rs = r._readableState;
|
||||
r._read = push;
|
||||
|
||||
r.on('readable', function() {
|
||||
- console.error('>> readable');
|
||||
+ //console.error('>> readable');
|
||||
do {
|
||||
- console.error(' > read(%d)', READSIZE);
|
||||
+ //console.error(' > read(%d)', READSIZE);
|
||||
var ret = r.read(READSIZE);
|
||||
- console.error(' < %j (%d remain)', ret && ret.length, rs.length);
|
||||
+ //console.error(' < %j (%d remain)', ret && ret.length, rs.length);
|
||||
} while (ret && ret.length === READSIZE);
|
||||
|
||||
- console.error('<< after read()',
|
||||
- ret && ret.length,
|
||||
- rs.needReadable,
|
||||
- rs.length);
|
||||
+ //console.error('<< after read()',
|
||||
+ // ret && ret.length,
|
||||
+ // rs.needReadable,
|
||||
+ // rs.length);
|
||||
});
|
||||
|
||||
var endEmitted = false;
|
||||
r.on('end', function() {
|
||||
endEmitted = true;
|
||||
- console.error('end');
|
||||
+ //console.error('end');
|
||||
});
|
||||
|
||||
var pushes = 0;
|
||||
@@ -64,11 +64,11 @@ function push() {
|
||||
return;
|
||||
|
||||
if (pushes++ === PUSHCOUNT) {
|
||||
- console.error(' push(EOF)');
|
||||
+ //console.error(' push(EOF)');
|
||||
return r.push(null);
|
||||
}
|
||||
|
||||
- console.error(' push #%d', pushes);
|
||||
+ //console.error(' push #%d', pushes);
|
||||
if (r.push(new Buffer(PUSHSIZE)))
|
||||
setTimeout(push);
|
||||
}
|
||||
diff --git a/test/simple/test-stream2-objects.js b/test/simple/test-stream2-objects.js
|
||||
index 3e6931d..ff47d89 100644
|
||||
--- a/test/simple/test-stream2-objects.js
|
||||
+++ b/test/simple/test-stream2-objects.js
|
||||
@@ -21,8 +21,8 @@
|
||||
|
||||
|
||||
var common = require('../common.js');
|
||||
-var Readable = require('_stream_readable');
|
||||
-var Writable = require('_stream_writable');
|
||||
+var Readable = require('../../lib/_stream_readable');
|
||||
+var Writable = require('../../lib/_stream_writable');
|
||||
var assert = require('assert');
|
||||
|
||||
// tiny node-tap lookalike.
|
||||
diff --git a/test/simple/test-stream2-pipe-error-handling.js b/test/simple/test-stream2-pipe-error-handling.js
|
||||
index cf7531c..e3f3e4e 100644
|
||||
--- a/test/simple/test-stream2-pipe-error-handling.js
|
||||
+++ b/test/simple/test-stream2-pipe-error-handling.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
|
||||
(function testErrorListenerCatches() {
|
||||
var count = 1000;
|
||||
diff --git a/test/simple/test-stream2-pipe-error-once-listener.js b/test/simple/test-stream2-pipe-error-once-listener.js
|
||||
index 5e8e3cb..53b2616 100755
|
||||
--- a/test/simple/test-stream2-pipe-error-once-listener.js
|
||||
+++ b/test/simple/test-stream2-pipe-error-once-listener.js
|
||||
@@ -24,7 +24,7 @@ var common = require('../common.js');
|
||||
var assert = require('assert');
|
||||
|
||||
var util = require('util');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
|
||||
|
||||
var Read = function() {
|
||||
diff --git a/test/simple/test-stream2-push.js b/test/simple/test-stream2-push.js
|
||||
index b63edc3..eb2b0e9 100644
|
||||
--- a/test/simple/test-stream2-push.js
|
||||
+++ b/test/simple/test-stream2-push.js
|
||||
@@ -20,7 +20,7 @@
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var common = require('../common.js');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var Readable = stream.Readable;
|
||||
var Writable = stream.Writable;
|
||||
var assert = require('assert');
|
||||
diff --git a/test/simple/test-stream2-read-sync-stack.js b/test/simple/test-stream2-read-sync-stack.js
|
||||
index e8a7305..9740a47 100644
|
||||
--- a/test/simple/test-stream2-read-sync-stack.js
|
||||
+++ b/test/simple/test-stream2-read-sync-stack.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
var r = new Readable();
|
||||
var N = 256 * 1024;
|
||||
|
||||
diff --git a/test/simple/test-stream2-readable-empty-buffer-no-eof.js b/test/simple/test-stream2-readable-empty-buffer-no-eof.js
|
||||
index cd30178..4b1659d 100644
|
||||
--- a/test/simple/test-stream2-readable-empty-buffer-no-eof.js
|
||||
+++ b/test/simple/test-stream2-readable-empty-buffer-no-eof.js
|
||||
@@ -22,10 +22,9 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('stream').Readable;
|
||||
+var Readable = require('../../').Readable;
|
||||
|
||||
test1();
|
||||
-test2();
|
||||
|
||||
function test1() {
|
||||
var r = new Readable();
|
||||
@@ -88,31 +87,3 @@ function test1() {
|
||||
console.log('ok');
|
||||
});
|
||||
}
|
||||
-
|
||||
-function test2() {
|
||||
- var r = new Readable({ encoding: 'base64' });
|
||||
- var reads = 5;
|
||||
- r._read = function(n) {
|
||||
- if (!reads--)
|
||||
- return r.push(null); // EOF
|
||||
- else
|
||||
- return r.push(new Buffer('x'));
|
||||
- };
|
||||
-
|
||||
- var results = [];
|
||||
- function flow() {
|
||||
- var chunk;
|
||||
- while (null !== (chunk = r.read()))
|
||||
- results.push(chunk + '');
|
||||
- }
|
||||
- r.on('readable', flow);
|
||||
- r.on('end', function() {
|
||||
- results.push('EOF');
|
||||
- });
|
||||
- flow();
|
||||
-
|
||||
- process.on('exit', function() {
|
||||
- assert.deepEqual(results, [ 'eHh4', 'eHg=', 'EOF' ]);
|
||||
- console.log('ok');
|
||||
- });
|
||||
-}
|
||||
diff --git a/test/simple/test-stream2-readable-from-list.js b/test/simple/test-stream2-readable-from-list.js
|
||||
index 7c96ffe..04a96f5 100644
|
||||
--- a/test/simple/test-stream2-readable-from-list.js
|
||||
+++ b/test/simple/test-stream2-readable-from-list.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var assert = require('assert');
|
||||
var common = require('../common.js');
|
||||
-var fromList = require('_stream_readable')._fromList;
|
||||
+var fromList = require('../../lib/_stream_readable')._fromList;
|
||||
|
||||
// tiny node-tap lookalike.
|
||||
var tests = [];
|
||||
diff --git a/test/simple/test-stream2-readable-legacy-drain.js b/test/simple/test-stream2-readable-legacy-drain.js
|
||||
index 675da8e..51fd3d5 100644
|
||||
--- a/test/simple/test-stream2-readable-legacy-drain.js
|
||||
+++ b/test/simple/test-stream2-readable-legacy-drain.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Stream = require('stream');
|
||||
+var Stream = require('../../');
|
||||
var Readable = Stream.Readable;
|
||||
|
||||
var r = new Readable();
|
||||
diff --git a/test/simple/test-stream2-readable-non-empty-end.js b/test/simple/test-stream2-readable-non-empty-end.js
|
||||
index 7314ae7..c971898 100644
|
||||
--- a/test/simple/test-stream2-readable-non-empty-end.js
|
||||
+++ b/test/simple/test-stream2-readable-non-empty-end.js
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
var assert = require('assert');
|
||||
var common = require('../common.js');
|
||||
-var Readable = require('_stream_readable');
|
||||
+var Readable = require('../../lib/_stream_readable');
|
||||
|
||||
var len = 0;
|
||||
var chunks = new Array(10);
|
||||
diff --git a/test/simple/test-stream2-readable-wrap-empty.js b/test/simple/test-stream2-readable-wrap-empty.js
|
||||
index 2e5cf25..fd8a3dc 100644
|
||||
--- a/test/simple/test-stream2-readable-wrap-empty.js
|
||||
+++ b/test/simple/test-stream2-readable-wrap-empty.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('_stream_readable');
|
||||
+var Readable = require('../../lib/_stream_readable');
|
||||
var EE = require('events').EventEmitter;
|
||||
|
||||
var oldStream = new EE();
|
||||
diff --git a/test/simple/test-stream2-readable-wrap.js b/test/simple/test-stream2-readable-wrap.js
|
||||
index 90eea01..6b177f7 100644
|
||||
--- a/test/simple/test-stream2-readable-wrap.js
|
||||
+++ b/test/simple/test-stream2-readable-wrap.js
|
||||
@@ -22,8 +22,8 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var Readable = require('_stream_readable');
|
||||
-var Writable = require('_stream_writable');
|
||||
+var Readable = require('../../lib/_stream_readable');
|
||||
+var Writable = require('../../lib/_stream_writable');
|
||||
var EE = require('events').EventEmitter;
|
||||
|
||||
var testRuns = 0, completedRuns = 0;
|
||||
diff --git a/test/simple/test-stream2-set-encoding.js b/test/simple/test-stream2-set-encoding.js
|
||||
index 5d2c32a..685531b 100644
|
||||
--- a/test/simple/test-stream2-set-encoding.js
|
||||
+++ b/test/simple/test-stream2-set-encoding.js
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
var common = require('../common.js');
|
||||
var assert = require('assert');
|
||||
-var R = require('_stream_readable');
|
||||
+var R = require('../../lib/_stream_readable');
|
||||
var util = require('util');
|
||||
|
||||
// tiny node-tap lookalike.
|
||||
diff --git a/test/simple/test-stream2-transform.js b/test/simple/test-stream2-transform.js
|
||||
index 9c9ddd8..a0cacc6 100644
|
||||
--- a/test/simple/test-stream2-transform.js
|
||||
+++ b/test/simple/test-stream2-transform.js
|
||||
@@ -21,8 +21,8 @@
|
||||
|
||||
var assert = require('assert');
|
||||
var common = require('../common.js');
|
||||
-var PassThrough = require('_stream_passthrough');
|
||||
-var Transform = require('_stream_transform');
|
||||
+var PassThrough = require('../../').PassThrough;
|
||||
+var Transform = require('../../').Transform;
|
||||
|
||||
// tiny node-tap lookalike.
|
||||
var tests = [];
|
||||
diff --git a/test/simple/test-stream2-unpipe-drain.js b/test/simple/test-stream2-unpipe-drain.js
|
||||
index d66dc3c..365b327 100644
|
||||
--- a/test/simple/test-stream2-unpipe-drain.js
|
||||
+++ b/test/simple/test-stream2-unpipe-drain.js
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
var common = require('../common.js');
|
||||
var assert = require('assert');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var crypto = require('crypto');
|
||||
|
||||
var util = require('util');
|
||||
diff --git a/test/simple/test-stream2-unpipe-leak.js b/test/simple/test-stream2-unpipe-leak.js
|
||||
index 99f8746..17c92ae 100644
|
||||
--- a/test/simple/test-stream2-unpipe-leak.js
|
||||
+++ b/test/simple/test-stream2-unpipe-leak.js
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
var common = require('../common.js');
|
||||
var assert = require('assert');
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
|
||||
var chunk = new Buffer('hallo');
|
||||
|
||||
diff --git a/test/simple/test-stream2-writable.js b/test/simple/test-stream2-writable.js
|
||||
index 704100c..209c3a6 100644
|
||||
--- a/test/simple/test-stream2-writable.js
|
||||
+++ b/test/simple/test-stream2-writable.js
|
||||
@@ -20,8 +20,8 @@
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var common = require('../common.js');
|
||||
-var W = require('_stream_writable');
|
||||
-var D = require('_stream_duplex');
|
||||
+var W = require('../../').Writable;
|
||||
+var D = require('../../').Duplex;
|
||||
var assert = require('assert');
|
||||
|
||||
var util = require('util');
|
||||
diff --git a/test/simple/test-stream3-pause-then-read.js b/test/simple/test-stream3-pause-then-read.js
|
||||
index b91bde3..2f72c15 100644
|
||||
--- a/test/simple/test-stream3-pause-then-read.js
|
||||
+++ b/test/simple/test-stream3-pause-then-read.js
|
||||
@@ -22,7 +22,7 @@
|
||||
var common = require('../common');
|
||||
var assert = require('assert');
|
||||
|
||||
-var stream = require('stream');
|
||||
+var stream = require('../../');
|
||||
var Readable = stream.Readable;
|
||||
var Writable = stream.Writable;
|
||||
|
||||
89
node_modules/mysql/node_modules/readable-stream/lib/_stream_duplex.js
generated
vendored
Normal file
89
node_modules/mysql/node_modules/readable-stream/lib/_stream_duplex.js
generated
vendored
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
// a duplex stream is just a stream that is both readable and writable.
|
||||
// Since JS doesn't have multiple prototypal inheritance, this class
|
||||
// prototypally inherits from Readable, and then parasitically from
|
||||
// Writable.
|
||||
|
||||
module.exports = Duplex;
|
||||
|
||||
/*<replacement>*/
|
||||
var objectKeys = Object.keys || function (obj) {
|
||||
var keys = [];
|
||||
for (var key in obj) keys.push(key);
|
||||
return keys;
|
||||
}
|
||||
/*</replacement>*/
|
||||
|
||||
|
||||
/*<replacement>*/
|
||||
var util = require('core-util-is');
|
||||
util.inherits = require('inherits');
|
||||
/*</replacement>*/
|
||||
|
||||
var Readable = require('./_stream_readable');
|
||||
var Writable = require('./_stream_writable');
|
||||
|
||||
util.inherits(Duplex, Readable);
|
||||
|
||||
forEach(objectKeys(Writable.prototype), function(method) {
|
||||
if (!Duplex.prototype[method])
|
||||
Duplex.prototype[method] = Writable.prototype[method];
|
||||
});
|
||||
|
||||
function Duplex(options) {
|
||||
if (!(this instanceof Duplex))
|
||||
return new Duplex(options);
|
||||
|
||||
Readable.call(this, options);
|
||||
Writable.call(this, options);
|
||||
|
||||
if (options && options.readable === false)
|
||||
this.readable = false;
|
||||
|
||||
if (options && options.writable === false)
|
||||
this.writable = false;
|
||||
|
||||
this.allowHalfOpen = true;
|
||||
if (options && options.allowHalfOpen === false)
|
||||
this.allowHalfOpen = false;
|
||||
|
||||
this.once('end', onend);
|
||||
}
|
||||
|
||||
// the no-half-open enforcer
|
||||
function onend() {
|
||||
// if we allow half-open state, or if the writable side ended,
|
||||
// then we're ok.
|
||||
if (this.allowHalfOpen || this._writableState.ended)
|
||||
return;
|
||||
|
||||
// no more data can be written.
|
||||
// But allow more writes to happen in this tick.
|
||||
process.nextTick(this.end.bind(this));
|
||||
}
|
||||
|
||||
function forEach (xs, f) {
|
||||
for (var i = 0, l = xs.length; i < l; i++) {
|
||||
f(xs[i], i);
|
||||
}
|
||||
}
|
||||
46
node_modules/mysql/node_modules/readable-stream/lib/_stream_passthrough.js
generated
vendored
Normal file
46
node_modules/mysql/node_modules/readable-stream/lib/_stream_passthrough.js
generated
vendored
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
// a passthrough stream.
|
||||
// basically just the most minimal sort of Transform stream.
|
||||
// Every written chunk gets output as-is.
|
||||
|
||||
module.exports = PassThrough;
|
||||
|
||||
var Transform = require('./_stream_transform');
|
||||
|
||||
/*<replacement>*/
|
||||
var util = require('core-util-is');
|
||||
util.inherits = require('inherits');
|
||||
/*</replacement>*/
|
||||
|
||||
util.inherits(PassThrough, Transform);
|
||||
|
||||
function PassThrough(options) {
|
||||
if (!(this instanceof PassThrough))
|
||||
return new PassThrough(options);
|
||||
|
||||
Transform.call(this, options);
|
||||
}
|
||||
|
||||
PassThrough.prototype._transform = function(chunk, encoding, cb) {
|
||||
cb(null, chunk);
|
||||
};
|
||||
951
node_modules/mysql/node_modules/readable-stream/lib/_stream_readable.js
generated
vendored
Normal file
951
node_modules/mysql/node_modules/readable-stream/lib/_stream_readable.js
generated
vendored
Normal file
|
|
@ -0,0 +1,951 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
module.exports = Readable;
|
||||
|
||||
/*<replacement>*/
|
||||
var isArray = require('isarray');
|
||||
/*</replacement>*/
|
||||
|
||||
|
||||
/*<replacement>*/
|
||||
var Buffer = require('buffer').Buffer;
|
||||
/*</replacement>*/
|
||||
|
||||
Readable.ReadableState = ReadableState;
|
||||
|
||||
var EE = require('events').EventEmitter;
|
||||
|
||||
/*<replacement>*/
|
||||
if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
|
||||
return emitter.listeners(type).length;
|
||||
};
|
||||
/*</replacement>*/
|
||||
|
||||
var Stream = require('stream');
|
||||
|
||||
/*<replacement>*/
|
||||
var util = require('core-util-is');
|
||||
util.inherits = require('inherits');
|
||||
/*</replacement>*/
|
||||
|
||||
var StringDecoder;
|
||||
|
||||
|
||||
/*<replacement>*/
|
||||
var debug = require('util');
|
||||
if (debug && debug.debuglog) {
|
||||
debug = debug.debuglog('stream');
|
||||
} else {
|
||||
debug = function () {};
|
||||
}
|
||||
/*</replacement>*/
|
||||
|
||||
|
||||
util.inherits(Readable, Stream);
|
||||
|
||||
function ReadableState(options, stream) {
|
||||
var Duplex = require('./_stream_duplex');
|
||||
|
||||
options = options || {};
|
||||
|
||||
// the point at which it stops calling _read() to fill the buffer
|
||||
// Note: 0 is a valid value, means "don't call _read preemptively ever"
|
||||
var hwm = options.highWaterMark;
|
||||
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
|
||||
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
|
||||
|
||||
// cast to ints.
|
||||
this.highWaterMark = ~~this.highWaterMark;
|
||||
|
||||
this.buffer = [];
|
||||
this.length = 0;
|
||||
this.pipes = null;
|
||||
this.pipesCount = 0;
|
||||
this.flowing = null;
|
||||
this.ended = false;
|
||||
this.endEmitted = false;
|
||||
this.reading = false;
|
||||
|
||||
// a flag to be able to tell if the onwrite cb is called immediately,
|
||||
// or on a later tick. We set this to true at first, because any
|
||||
// actions that shouldn't happen until "later" should generally also
|
||||
// not happen before the first write call.
|
||||
this.sync = true;
|
||||
|
||||
// whenever we return null, then we set a flag to say
|
||||
// that we're awaiting a 'readable' event emission.
|
||||
this.needReadable = false;
|
||||
this.emittedReadable = false;
|
||||
this.readableListening = false;
|
||||
|
||||
|
||||
// object stream flag. Used to make read(n) ignore n and to
|
||||
// make all the buffer merging and length checks go away
|
||||
this.objectMode = !!options.objectMode;
|
||||
|
||||
if (stream instanceof Duplex)
|
||||
this.objectMode = this.objectMode || !!options.readableObjectMode;
|
||||
|
||||
// Crypto is kind of old and crusty. Historically, its default string
|
||||
// encoding is 'binary' so we have to make this configurable.
|
||||
// Everything else in the universe uses 'utf8', though.
|
||||
this.defaultEncoding = options.defaultEncoding || 'utf8';
|
||||
|
||||
// when piping, we only care about 'readable' events that happen
|
||||
// after read()ing all the bytes and not getting any pushback.
|
||||
this.ranOut = false;
|
||||
|
||||
// the number of writers that are awaiting a drain event in .pipe()s
|
||||
this.awaitDrain = 0;
|
||||
|
||||
// if true, a maybeReadMore has been scheduled
|
||||
this.readingMore = false;
|
||||
|
||||
this.decoder = null;
|
||||
this.encoding = null;
|
||||
if (options.encoding) {
|
||||
if (!StringDecoder)
|
||||
StringDecoder = require('string_decoder/').StringDecoder;
|
||||
this.decoder = new StringDecoder(options.encoding);
|
||||
this.encoding = options.encoding;
|
||||
}
|
||||
}
|
||||
|
||||
function Readable(options) {
|
||||
var Duplex = require('./_stream_duplex');
|
||||
|
||||
if (!(this instanceof Readable))
|
||||
return new Readable(options);
|
||||
|
||||
this._readableState = new ReadableState(options, this);
|
||||
|
||||
// legacy
|
||||
this.readable = true;
|
||||
|
||||
Stream.call(this);
|
||||
}
|
||||
|
||||
// Manually shove something into the read() buffer.
|
||||
// This returns true if the highWaterMark has not been hit yet,
|
||||
// similar to how Writable.write() returns true if you should
|
||||
// write() some more.
|
||||
Readable.prototype.push = function(chunk, encoding) {
|
||||
var state = this._readableState;
|
||||
|
||||
if (util.isString(chunk) && !state.objectMode) {
|
||||
encoding = encoding || state.defaultEncoding;
|
||||
if (encoding !== state.encoding) {
|
||||
chunk = new Buffer(chunk, encoding);
|
||||
encoding = '';
|
||||
}
|
||||
}
|
||||
|
||||
return readableAddChunk(this, state, chunk, encoding, false);
|
||||
};
|
||||
|
||||
// Unshift should *always* be something directly out of read()
|
||||
Readable.prototype.unshift = function(chunk) {
|
||||
var state = this._readableState;
|
||||
return readableAddChunk(this, state, chunk, '', true);
|
||||
};
|
||||
|
||||
function readableAddChunk(stream, state, chunk, encoding, addToFront) {
|
||||
var er = chunkInvalid(state, chunk);
|
||||
if (er) {
|
||||
stream.emit('error', er);
|
||||
} else if (util.isNullOrUndefined(chunk)) {
|
||||
state.reading = false;
|
||||
if (!state.ended)
|
||||
onEofChunk(stream, state);
|
||||
} else if (state.objectMode || chunk && chunk.length > 0) {
|
||||
if (state.ended && !addToFront) {
|
||||
var e = new Error('stream.push() after EOF');
|
||||
stream.emit('error', e);
|
||||
} else if (state.endEmitted && addToFront) {
|
||||
var e = new Error('stream.unshift() after end event');
|
||||
stream.emit('error', e);
|
||||
} else {
|
||||
if (state.decoder && !addToFront && !encoding)
|
||||
chunk = state.decoder.write(chunk);
|
||||
|
||||
if (!addToFront)
|
||||
state.reading = false;
|
||||
|
||||
// if we want the data now, just emit it.
|
||||
if (state.flowing && state.length === 0 && !state.sync) {
|
||||
stream.emit('data', chunk);
|
||||
stream.read(0);
|
||||
} else {
|
||||
// update the buffer info.
|
||||
state.length += state.objectMode ? 1 : chunk.length;
|
||||
if (addToFront)
|
||||
state.buffer.unshift(chunk);
|
||||
else
|
||||
state.buffer.push(chunk);
|
||||
|
||||
if (state.needReadable)
|
||||
emitReadable(stream);
|
||||
}
|
||||
|
||||
maybeReadMore(stream, state);
|
||||
}
|
||||
} else if (!addToFront) {
|
||||
state.reading = false;
|
||||
}
|
||||
|
||||
return needMoreData(state);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// if it's past the high water mark, we can push in some more.
|
||||
// Also, if we have no data yet, we can stand some
|
||||
// more bytes. This is to work around cases where hwm=0,
|
||||
// such as the repl. Also, if the push() triggered a
|
||||
// readable event, and the user called read(largeNumber) such that
|
||||
// needReadable was set, then we ought to push more, so that another
|
||||
// 'readable' event will be triggered.
|
||||
function needMoreData(state) {
|
||||
return !state.ended &&
|
||||
(state.needReadable ||
|
||||
state.length < state.highWaterMark ||
|
||||
state.length === 0);
|
||||
}
|
||||
|
||||
// backwards compatibility.
|
||||
Readable.prototype.setEncoding = function(enc) {
|
||||
if (!StringDecoder)
|
||||
StringDecoder = require('string_decoder/').StringDecoder;
|
||||
this._readableState.decoder = new StringDecoder(enc);
|
||||
this._readableState.encoding = enc;
|
||||
return this;
|
||||
};
|
||||
|
||||
// Don't raise the hwm > 128MB
|
||||
var MAX_HWM = 0x800000;
|
||||
function roundUpToNextPowerOf2(n) {
|
||||
if (n >= MAX_HWM) {
|
||||
n = MAX_HWM;
|
||||
} else {
|
||||
// Get the next highest power of 2
|
||||
n--;
|
||||
for (var p = 1; p < 32; p <<= 1) n |= n >> p;
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
function howMuchToRead(n, state) {
|
||||
if (state.length === 0 && state.ended)
|
||||
return 0;
|
||||
|
||||
if (state.objectMode)
|
||||
return n === 0 ? 0 : 1;
|
||||
|
||||
if (isNaN(n) || util.isNull(n)) {
|
||||
// only flow one buffer at a time
|
||||
if (state.flowing && state.buffer.length)
|
||||
return state.buffer[0].length;
|
||||
else
|
||||
return state.length;
|
||||
}
|
||||
|
||||
if (n <= 0)
|
||||
return 0;
|
||||
|
||||
// If we're asking for more than the target buffer level,
|
||||
// then raise the water mark. Bump up to the next highest
|
||||
// power of 2, to prevent increasing it excessively in tiny
|
||||
// amounts.
|
||||
if (n > state.highWaterMark)
|
||||
state.highWaterMark = roundUpToNextPowerOf2(n);
|
||||
|
||||
// don't have that much. return null, unless we've ended.
|
||||
if (n > state.length) {
|
||||
if (!state.ended) {
|
||||
state.needReadable = true;
|
||||
return 0;
|
||||
} else
|
||||
return state.length;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
// you can override either this method, or the async _read(n) below.
|
||||
Readable.prototype.read = function(n) {
|
||||
debug('read', n);
|
||||
var state = this._readableState;
|
||||
var nOrig = n;
|
||||
|
||||
if (!util.isNumber(n) || n > 0)
|
||||
state.emittedReadable = false;
|
||||
|
||||
// if we're doing read(0) to trigger a readable event, but we
|
||||
// already have a bunch of data in the buffer, then just trigger
|
||||
// the 'readable' event and move on.
|
||||
if (n === 0 &&
|
||||
state.needReadable &&
|
||||
(state.length >= state.highWaterMark || state.ended)) {
|
||||
debug('read: emitReadable', state.length, state.ended);
|
||||
if (state.length === 0 && state.ended)
|
||||
endReadable(this);
|
||||
else
|
||||
emitReadable(this);
|
||||
return null;
|
||||
}
|
||||
|
||||
n = howMuchToRead(n, state);
|
||||
|
||||
// if we've ended, and we're now clear, then finish it up.
|
||||
if (n === 0 && state.ended) {
|
||||
if (state.length === 0)
|
||||
endReadable(this);
|
||||
return null;
|
||||
}
|
||||
|
||||
// All the actual chunk generation logic needs to be
|
||||
// *below* the call to _read. The reason is that in certain
|
||||
// synthetic stream cases, such as passthrough streams, _read
|
||||
// may be a completely synchronous operation which may change
|
||||
// the state of the read buffer, providing enough data when
|
||||
// before there was *not* enough.
|
||||
//
|
||||
// So, the steps are:
|
||||
// 1. Figure out what the state of things will be after we do
|
||||
// a read from the buffer.
|
||||
//
|
||||
// 2. If that resulting state will trigger a _read, then call _read.
|
||||
// Note that this may be asynchronous, or synchronous. Yes, it is
|
||||
// deeply ugly to write APIs this way, but that still doesn't mean
|
||||
// that the Readable class should behave improperly, as streams are
|
||||
// designed to be sync/async agnostic.
|
||||
// Take note if the _read call is sync or async (ie, if the read call
|
||||
// has returned yet), so that we know whether or not it's safe to emit
|
||||
// 'readable' etc.
|
||||
//
|
||||
// 3. Actually pull the requested chunks out of the buffer and return.
|
||||
|
||||
// if we need a readable event, then we need to do some reading.
|
||||
var doRead = state.needReadable;
|
||||
debug('need readable', doRead);
|
||||
|
||||
// if we currently have less than the highWaterMark, then also read some
|
||||
if (state.length === 0 || state.length - n < state.highWaterMark) {
|
||||
doRead = true;
|
||||
debug('length less than watermark', doRead);
|
||||
}
|
||||
|
||||
// however, if we've ended, then there's no point, and if we're already
|
||||
// reading, then it's unnecessary.
|
||||
if (state.ended || state.reading) {
|
||||
doRead = false;
|
||||
debug('reading or ended', doRead);
|
||||
}
|
||||
|
||||
if (doRead) {
|
||||
debug('do read');
|
||||
state.reading = true;
|
||||
state.sync = true;
|
||||
// if the length is currently zero, then we *need* a readable event.
|
||||
if (state.length === 0)
|
||||
state.needReadable = true;
|
||||
// call internal read method
|
||||
this._read(state.highWaterMark);
|
||||
state.sync = false;
|
||||
}
|
||||
|
||||
// If _read pushed data synchronously, then `reading` will be false,
|
||||
// and we need to re-evaluate how much data we can return to the user.
|
||||
if (doRead && !state.reading)
|
||||
n = howMuchToRead(nOrig, state);
|
||||
|
||||
var ret;
|
||||
if (n > 0)
|
||||
ret = fromList(n, state);
|
||||
else
|
||||
ret = null;
|
||||
|
||||
if (util.isNull(ret)) {
|
||||
state.needReadable = true;
|
||||
n = 0;
|
||||
}
|
||||
|
||||
state.length -= n;
|
||||
|
||||
// If we have nothing in the buffer, then we want to know
|
||||
// as soon as we *do* get something into the buffer.
|
||||
if (state.length === 0 && !state.ended)
|
||||
state.needReadable = true;
|
||||
|
||||
// If we tried to read() past the EOF, then emit end on the next tick.
|
||||
if (nOrig !== n && state.ended && state.length === 0)
|
||||
endReadable(this);
|
||||
|
||||
if (!util.isNull(ret))
|
||||
this.emit('data', ret);
|
||||
|
||||
return ret;
|
||||
};
|
||||
|
||||
function chunkInvalid(state, chunk) {
|
||||
var er = null;
|
||||
if (!util.isBuffer(chunk) &&
|
||||
!util.isString(chunk) &&
|
||||
!util.isNullOrUndefined(chunk) &&
|
||||
!state.objectMode) {
|
||||
er = new TypeError('Invalid non-string/buffer chunk');
|
||||
}
|
||||
return er;
|
||||
}
|
||||
|
||||
|
||||
function onEofChunk(stream, state) {
|
||||
if (state.decoder && !state.ended) {
|
||||
var chunk = state.decoder.end();
|
||||
if (chunk && chunk.length) {
|
||||
state.buffer.push(chunk);
|
||||
state.length += state.objectMode ? 1 : chunk.length;
|
||||
}
|
||||
}
|
||||
state.ended = true;
|
||||
|
||||
// emit 'readable' now to make sure it gets picked up.
|
||||
emitReadable(stream);
|
||||
}
|
||||
|
||||
// Don't emit readable right away in sync mode, because this can trigger
|
||||
// another read() call => stack overflow. This way, it might trigger
|
||||
// a nextTick recursion warning, but that's not so bad.
|
||||
function emitReadable(stream) {
|
||||
var state = stream._readableState;
|
||||
state.needReadable = false;
|
||||
if (!state.emittedReadable) {
|
||||
debug('emitReadable', state.flowing);
|
||||
state.emittedReadable = true;
|
||||
if (state.sync)
|
||||
process.nextTick(function() {
|
||||
emitReadable_(stream);
|
||||
});
|
||||
else
|
||||
emitReadable_(stream);
|
||||
}
|
||||
}
|
||||
|
||||
function emitReadable_(stream) {
|
||||
debug('emit readable');
|
||||
stream.emit('readable');
|
||||
flow(stream);
|
||||
}
|
||||
|
||||
|
||||
// at this point, the user has presumably seen the 'readable' event,
|
||||
// and called read() to consume some data. that may have triggered
|
||||
// in turn another _read(n) call, in which case reading = true if
|
||||
// it's in progress.
|
||||
// However, if we're not ended, or reading, and the length < hwm,
|
||||
// then go ahead and try to read some more preemptively.
|
||||
function maybeReadMore(stream, state) {
|
||||
if (!state.readingMore) {
|
||||
state.readingMore = true;
|
||||
process.nextTick(function() {
|
||||
maybeReadMore_(stream, state);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function maybeReadMore_(stream, state) {
|
||||
var len = state.length;
|
||||
while (!state.reading && !state.flowing && !state.ended &&
|
||||
state.length < state.highWaterMark) {
|
||||
debug('maybeReadMore read 0');
|
||||
stream.read(0);
|
||||
if (len === state.length)
|
||||
// didn't get any data, stop spinning.
|
||||
break;
|
||||
else
|
||||
len = state.length;
|
||||
}
|
||||
state.readingMore = false;
|
||||
}
|
||||
|
||||
// abstract method. to be overridden in specific implementation classes.
|
||||
// call cb(er, data) where data is <= n in length.
|
||||
// for virtual (non-string, non-buffer) streams, "length" is somewhat
|
||||
// arbitrary, and perhaps not very meaningful.
|
||||
Readable.prototype._read = function(n) {
|
||||
this.emit('error', new Error('not implemented'));
|
||||
};
|
||||
|
||||
Readable.prototype.pipe = function(dest, pipeOpts) {
|
||||
var src = this;
|
||||
var state = this._readableState;
|
||||
|
||||
switch (state.pipesCount) {
|
||||
case 0:
|
||||
state.pipes = dest;
|
||||
break;
|
||||
case 1:
|
||||
state.pipes = [state.pipes, dest];
|
||||
break;
|
||||
default:
|
||||
state.pipes.push(dest);
|
||||
break;
|
||||
}
|
||||
state.pipesCount += 1;
|
||||
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
|
||||
|
||||
var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
|
||||
dest !== process.stdout &&
|
||||
dest !== process.stderr;
|
||||
|
||||
var endFn = doEnd ? onend : cleanup;
|
||||
if (state.endEmitted)
|
||||
process.nextTick(endFn);
|
||||
else
|
||||
src.once('end', endFn);
|
||||
|
||||
dest.on('unpipe', onunpipe);
|
||||
function onunpipe(readable) {
|
||||
debug('onunpipe');
|
||||
if (readable === src) {
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
function onend() {
|
||||
debug('onend');
|
||||
dest.end();
|
||||
}
|
||||
|
||||
// when the dest drains, it reduces the awaitDrain counter
|
||||
// on the source. This would be more elegant with a .once()
|
||||
// handler in flow(), but adding and removing repeatedly is
|
||||
// too slow.
|
||||
var ondrain = pipeOnDrain(src);
|
||||
dest.on('drain', ondrain);
|
||||
|
||||
function cleanup() {
|
||||
debug('cleanup');
|
||||
// cleanup event handlers once the pipe is broken
|
||||
dest.removeListener('close', onclose);
|
||||
dest.removeListener('finish', onfinish);
|
||||
dest.removeListener('drain', ondrain);
|
||||
dest.removeListener('error', onerror);
|
||||
dest.removeListener('unpipe', onunpipe);
|
||||
src.removeListener('end', onend);
|
||||
src.removeListener('end', cleanup);
|
||||
src.removeListener('data', ondata);
|
||||
|
||||
// if the reader is waiting for a drain event from this
|
||||
// specific writer, then it would cause it to never start
|
||||
// flowing again.
|
||||
// So, if this is awaiting a drain, then we just call it now.
|
||||
// If we don't know, then assume that we are waiting for one.
|
||||
if (state.awaitDrain &&
|
||||
(!dest._writableState || dest._writableState.needDrain))
|
||||
ondrain();
|
||||
}
|
||||
|
||||
src.on('data', ondata);
|
||||
function ondata(chunk) {
|
||||
debug('ondata');
|
||||
var ret = dest.write(chunk);
|
||||
if (false === ret) {
|
||||
debug('false write response, pause',
|
||||
src._readableState.awaitDrain);
|
||||
src._readableState.awaitDrain++;
|
||||
src.pause();
|
||||
}
|
||||
}
|
||||
|
||||
// if the dest has an error, then stop piping into it.
|
||||
// however, don't suppress the throwing behavior for this.
|
||||
function onerror(er) {
|
||||
debug('onerror', er);
|
||||
unpipe();
|
||||
dest.removeListener('error', onerror);
|
||||
if (EE.listenerCount(dest, 'error') === 0)
|
||||
dest.emit('error', er);
|
||||
}
|
||||
// This is a brutally ugly hack to make sure that our error handler
|
||||
// is attached before any userland ones. NEVER DO THIS.
|
||||
if (!dest._events || !dest._events.error)
|
||||
dest.on('error', onerror);
|
||||
else if (isArray(dest._events.error))
|
||||
dest._events.error.unshift(onerror);
|
||||
else
|
||||
dest._events.error = [onerror, dest._events.error];
|
||||
|
||||
|
||||
|
||||
// Both close and finish should trigger unpipe, but only once.
|
||||
function onclose() {
|
||||
dest.removeListener('finish', onfinish);
|
||||
unpipe();
|
||||
}
|
||||
dest.once('close', onclose);
|
||||
function onfinish() {
|
||||
debug('onfinish');
|
||||
dest.removeListener('close', onclose);
|
||||
unpipe();
|
||||
}
|
||||
dest.once('finish', onfinish);
|
||||
|
||||
function unpipe() {
|
||||
debug('unpipe');
|
||||
src.unpipe(dest);
|
||||
}
|
||||
|
||||
// tell the dest that it's being piped to
|
||||
dest.emit('pipe', src);
|
||||
|
||||
// start the flow if it hasn't been started already.
|
||||
if (!state.flowing) {
|
||||
debug('pipe resume');
|
||||
src.resume();
|
||||
}
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
function pipeOnDrain(src) {
|
||||
return function() {
|
||||
var state = src._readableState;
|
||||
debug('pipeOnDrain', state.awaitDrain);
|
||||
if (state.awaitDrain)
|
||||
state.awaitDrain--;
|
||||
if (state.awaitDrain === 0 && EE.listenerCount(src, 'data')) {
|
||||
state.flowing = true;
|
||||
flow(src);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
Readable.prototype.unpipe = function(dest) {
|
||||
var state = this._readableState;
|
||||
|
||||
// if we're not piping anywhere, then do nothing.
|
||||
if (state.pipesCount === 0)
|
||||
return this;
|
||||
|
||||
// just one destination. most common case.
|
||||
if (state.pipesCount === 1) {
|
||||
// passed in one, but it's not the right one.
|
||||
if (dest && dest !== state.pipes)
|
||||
return this;
|
||||
|
||||
if (!dest)
|
||||
dest = state.pipes;
|
||||
|
||||
// got a match.
|
||||
state.pipes = null;
|
||||
state.pipesCount = 0;
|
||||
state.flowing = false;
|
||||
if (dest)
|
||||
dest.emit('unpipe', this);
|
||||
return this;
|
||||
}
|
||||
|
||||
// slow case. multiple pipe destinations.
|
||||
|
||||
if (!dest) {
|
||||
// remove all.
|
||||
var dests = state.pipes;
|
||||
var len = state.pipesCount;
|
||||
state.pipes = null;
|
||||
state.pipesCount = 0;
|
||||
state.flowing = false;
|
||||
|
||||
for (var i = 0; i < len; i++)
|
||||
dests[i].emit('unpipe', this);
|
||||
return this;
|
||||
}
|
||||
|
||||
// try to find the right one.
|
||||
var i = indexOf(state.pipes, dest);
|
||||
if (i === -1)
|
||||
return this;
|
||||
|
||||
state.pipes.splice(i, 1);
|
||||
state.pipesCount -= 1;
|
||||
if (state.pipesCount === 1)
|
||||
state.pipes = state.pipes[0];
|
||||
|
||||
dest.emit('unpipe', this);
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
// set up data events if they are asked for
|
||||
// Ensure readable listeners eventually get something
|
||||
Readable.prototype.on = function(ev, fn) {
|
||||
var res = Stream.prototype.on.call(this, ev, fn);
|
||||
|
||||
// If listening to data, and it has not explicitly been paused,
|
||||
// then call resume to start the flow of data on the next tick.
|
||||
if (ev === 'data' && false !== this._readableState.flowing) {
|
||||
this.resume();
|
||||
}
|
||||
|
||||
if (ev === 'readable' && this.readable) {
|
||||
var state = this._readableState;
|
||||
if (!state.readableListening) {
|
||||
state.readableListening = true;
|
||||
state.emittedReadable = false;
|
||||
state.needReadable = true;
|
||||
if (!state.reading) {
|
||||
var self = this;
|
||||
process.nextTick(function() {
|
||||
debug('readable nexttick read 0');
|
||||
self.read(0);
|
||||
});
|
||||
} else if (state.length) {
|
||||
emitReadable(this, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
};
|
||||
Readable.prototype.addListener = Readable.prototype.on;
|
||||
|
||||
// pause() and resume() are remnants of the legacy readable stream API
|
||||
// If the user uses them, then switch into old mode.
|
||||
Readable.prototype.resume = function() {
|
||||
var state = this._readableState;
|
||||
if (!state.flowing) {
|
||||
debug('resume');
|
||||
state.flowing = true;
|
||||
if (!state.reading) {
|
||||
debug('resume read 0');
|
||||
this.read(0);
|
||||
}
|
||||
resume(this, state);
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
function resume(stream, state) {
|
||||
if (!state.resumeScheduled) {
|
||||
state.resumeScheduled = true;
|
||||
process.nextTick(function() {
|
||||
resume_(stream, state);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function resume_(stream, state) {
|
||||
state.resumeScheduled = false;
|
||||
stream.emit('resume');
|
||||
flow(stream);
|
||||
if (state.flowing && !state.reading)
|
||||
stream.read(0);
|
||||
}
|
||||
|
||||
Readable.prototype.pause = function() {
|
||||
debug('call pause flowing=%j', this._readableState.flowing);
|
||||
if (false !== this._readableState.flowing) {
|
||||
debug('pause');
|
||||
this._readableState.flowing = false;
|
||||
this.emit('pause');
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
function flow(stream) {
|
||||
var state = stream._readableState;
|
||||
debug('flow', state.flowing);
|
||||
if (state.flowing) {
|
||||
do {
|
||||
var chunk = stream.read();
|
||||
} while (null !== chunk && state.flowing);
|
||||
}
|
||||
}
|
||||
|
||||
// wrap an old-style stream as the async data source.
|
||||
// This is *not* part of the readable stream interface.
|
||||
// It is an ugly unfortunate mess of history.
|
||||
Readable.prototype.wrap = function(stream) {
|
||||
var state = this._readableState;
|
||||
var paused = false;
|
||||
|
||||
var self = this;
|
||||
stream.on('end', function() {
|
||||
debug('wrapped end');
|
||||
if (state.decoder && !state.ended) {
|
||||
var chunk = state.decoder.end();
|
||||
if (chunk && chunk.length)
|
||||
self.push(chunk);
|
||||
}
|
||||
|
||||
self.push(null);
|
||||
});
|
||||
|
||||
stream.on('data', function(chunk) {
|
||||
debug('wrapped data');
|
||||
if (state.decoder)
|
||||
chunk = state.decoder.write(chunk);
|
||||
if (!chunk || !state.objectMode && !chunk.length)
|
||||
return;
|
||||
|
||||
var ret = self.push(chunk);
|
||||
if (!ret) {
|
||||
paused = true;
|
||||
stream.pause();
|
||||
}
|
||||
});
|
||||
|
||||
// proxy all the other methods.
|
||||
// important when wrapping filters and duplexes.
|
||||
for (var i in stream) {
|
||||
if (util.isFunction(stream[i]) && util.isUndefined(this[i])) {
|
||||
this[i] = function(method) { return function() {
|
||||
return stream[method].apply(stream, arguments);
|
||||
}}(i);
|
||||
}
|
||||
}
|
||||
|
||||
// proxy certain important events.
|
||||
var events = ['error', 'close', 'destroy', 'pause', 'resume'];
|
||||
forEach(events, function(ev) {
|
||||
stream.on(ev, self.emit.bind(self, ev));
|
||||
});
|
||||
|
||||
// when we try to consume some more bytes, simply unpause the
|
||||
// underlying stream.
|
||||
self._read = function(n) {
|
||||
debug('wrapped _read', n);
|
||||
if (paused) {
|
||||
paused = false;
|
||||
stream.resume();
|
||||
}
|
||||
};
|
||||
|
||||
return self;
|
||||
};
|
||||
|
||||
|
||||
|
||||
// exposed for testing purposes only.
|
||||
Readable._fromList = fromList;
|
||||
|
||||
// Pluck off n bytes from an array of buffers.
|
||||
// Length is the combined lengths of all the buffers in the list.
|
||||
function fromList(n, state) {
|
||||
var list = state.buffer;
|
||||
var length = state.length;
|
||||
var stringMode = !!state.decoder;
|
||||
var objectMode = !!state.objectMode;
|
||||
var ret;
|
||||
|
||||
// nothing in the list, definitely empty.
|
||||
if (list.length === 0)
|
||||
return null;
|
||||
|
||||
if (length === 0)
|
||||
ret = null;
|
||||
else if (objectMode)
|
||||
ret = list.shift();
|
||||
else if (!n || n >= length) {
|
||||
// read it all, truncate the array.
|
||||
if (stringMode)
|
||||
ret = list.join('');
|
||||
else
|
||||
ret = Buffer.concat(list, length);
|
||||
list.length = 0;
|
||||
} else {
|
||||
// read just some of it.
|
||||
if (n < list[0].length) {
|
||||
// just take a part of the first list item.
|
||||
// slice is the same for buffers and strings.
|
||||
var buf = list[0];
|
||||
ret = buf.slice(0, n);
|
||||
list[0] = buf.slice(n);
|
||||
} else if (n === list[0].length) {
|
||||
// first list is a perfect match
|
||||
ret = list.shift();
|
||||
} else {
|
||||
// complex case.
|
||||
// we have enough to cover it, but it spans past the first buffer.
|
||||
if (stringMode)
|
||||
ret = '';
|
||||
else
|
||||
ret = new Buffer(n);
|
||||
|
||||
var c = 0;
|
||||
for (var i = 0, l = list.length; i < l && c < n; i++) {
|
||||
var buf = list[0];
|
||||
var cpy = Math.min(n - c, buf.length);
|
||||
|
||||
if (stringMode)
|
||||
ret += buf.slice(0, cpy);
|
||||
else
|
||||
buf.copy(ret, c, 0, cpy);
|
||||
|
||||
if (cpy < buf.length)
|
||||
list[0] = buf.slice(cpy);
|
||||
else
|
||||
list.shift();
|
||||
|
||||
c += cpy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
function endReadable(stream) {
|
||||
var state = stream._readableState;
|
||||
|
||||
// If we get here before consuming all the bytes, then that is a
|
||||
// bug in node. Should never happen.
|
||||
if (state.length > 0)
|
||||
throw new Error('endReadable called on non-empty stream');
|
||||
|
||||
if (!state.endEmitted) {
|
||||
state.ended = true;
|
||||
process.nextTick(function() {
|
||||
// Check that we didn't get one last unshift.
|
||||
if (!state.endEmitted && state.length === 0) {
|
||||
state.endEmitted = true;
|
||||
stream.readable = false;
|
||||
stream.emit('end');
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function forEach (xs, f) {
|
||||
for (var i = 0, l = xs.length; i < l; i++) {
|
||||
f(xs[i], i);
|
||||
}
|
||||
}
|
||||
|
||||
function indexOf (xs, x) {
|
||||
for (var i = 0, l = xs.length; i < l; i++) {
|
||||
if (xs[i] === x) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
209
node_modules/mysql/node_modules/readable-stream/lib/_stream_transform.js
generated
vendored
Normal file
209
node_modules/mysql/node_modules/readable-stream/lib/_stream_transform.js
generated
vendored
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
// a transform stream is a readable/writable stream where you do
|
||||
// something with the data. Sometimes it's called a "filter",
|
||||
// but that's not a great name for it, since that implies a thing where
|
||||
// some bits pass through, and others are simply ignored. (That would
|
||||
// be a valid example of a transform, of course.)
|
||||
//
|
||||
// While the output is causally related to the input, it's not a
|
||||
// necessarily symmetric or synchronous transformation. For example,
|
||||
// a zlib stream might take multiple plain-text writes(), and then
|
||||
// emit a single compressed chunk some time in the future.
|
||||
//
|
||||
// Here's how this works:
|
||||
//
|
||||
// The Transform stream has all the aspects of the readable and writable
|
||||
// stream classes. When you write(chunk), that calls _write(chunk,cb)
|
||||
// internally, and returns false if there's a lot of pending writes
|
||||
// buffered up. When you call read(), that calls _read(n) until
|
||||
// there's enough pending readable data buffered up.
|
||||
//
|
||||
// In a transform stream, the written data is placed in a buffer. When
|
||||
// _read(n) is called, it transforms the queued up data, calling the
|
||||
// buffered _write cb's as it consumes chunks. If consuming a single
|
||||
// written chunk would result in multiple output chunks, then the first
|
||||
// outputted bit calls the readcb, and subsequent chunks just go into
|
||||
// the read buffer, and will cause it to emit 'readable' if necessary.
|
||||
//
|
||||
// This way, back-pressure is actually determined by the reading side,
|
||||
// since _read has to be called to start processing a new chunk. However,
|
||||
// a pathological inflate type of transform can cause excessive buffering
|
||||
// here. For example, imagine a stream where every byte of input is
|
||||
// interpreted as an integer from 0-255, and then results in that many
|
||||
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
|
||||
// 1kb of data being output. In this case, you could write a very small
|
||||
// amount of input, and end up with a very large amount of output. In
|
||||
// such a pathological inflating mechanism, there'd be no way to tell
|
||||
// the system to stop doing the transform. A single 4MB write could
|
||||
// cause the system to run out of memory.
|
||||
//
|
||||
// However, even in such a pathological case, only a single written chunk
|
||||
// would be consumed, and then the rest would wait (un-transformed) until
|
||||
// the results of the previous transformed chunk were consumed.
|
||||
|
||||
module.exports = Transform;
|
||||
|
||||
var Duplex = require('./_stream_duplex');
|
||||
|
||||
/*<replacement>*/
|
||||
var util = require('core-util-is');
|
||||
util.inherits = require('inherits');
|
||||
/*</replacement>*/
|
||||
|
||||
util.inherits(Transform, Duplex);
|
||||
|
||||
|
||||
function TransformState(options, stream) {
|
||||
this.afterTransform = function(er, data) {
|
||||
return afterTransform(stream, er, data);
|
||||
};
|
||||
|
||||
this.needTransform = false;
|
||||
this.transforming = false;
|
||||
this.writecb = null;
|
||||
this.writechunk = null;
|
||||
}
|
||||
|
||||
function afterTransform(stream, er, data) {
|
||||
var ts = stream._transformState;
|
||||
ts.transforming = false;
|
||||
|
||||
var cb = ts.writecb;
|
||||
|
||||
if (!cb)
|
||||
return stream.emit('error', new Error('no writecb in Transform class'));
|
||||
|
||||
ts.writechunk = null;
|
||||
ts.writecb = null;
|
||||
|
||||
if (!util.isNullOrUndefined(data))
|
||||
stream.push(data);
|
||||
|
||||
if (cb)
|
||||
cb(er);
|
||||
|
||||
var rs = stream._readableState;
|
||||
rs.reading = false;
|
||||
if (rs.needReadable || rs.length < rs.highWaterMark) {
|
||||
stream._read(rs.highWaterMark);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function Transform(options) {
|
||||
if (!(this instanceof Transform))
|
||||
return new Transform(options);
|
||||
|
||||
Duplex.call(this, options);
|
||||
|
||||
this._transformState = new TransformState(options, this);
|
||||
|
||||
// when the writable side finishes, then flush out anything remaining.
|
||||
var stream = this;
|
||||
|
||||
// start out asking for a readable event once data is transformed.
|
||||
this._readableState.needReadable = true;
|
||||
|
||||
// we have implemented the _read method, and done the other things
|
||||
// that Readable wants before the first _read call, so unset the
|
||||
// sync guard flag.
|
||||
this._readableState.sync = false;
|
||||
|
||||
this.once('prefinish', function() {
|
||||
if (util.isFunction(this._flush))
|
||||
this._flush(function(er) {
|
||||
done(stream, er);
|
||||
});
|
||||
else
|
||||
done(stream);
|
||||
});
|
||||
}
|
||||
|
||||
Transform.prototype.push = function(chunk, encoding) {
|
||||
this._transformState.needTransform = false;
|
||||
return Duplex.prototype.push.call(this, chunk, encoding);
|
||||
};
|
||||
|
||||
// This is the part where you do stuff!
|
||||
// override this function in implementation classes.
|
||||
// 'chunk' is an input chunk.
|
||||
//
|
||||
// Call `push(newChunk)` to pass along transformed output
|
||||
// to the readable side. You may call 'push' zero or more times.
|
||||
//
|
||||
// Call `cb(err)` when you are done with this chunk. If you pass
|
||||
// an error, then that'll put the hurt on the whole operation. If you
|
||||
// never call cb(), then you'll never get another chunk.
|
||||
Transform.prototype._transform = function(chunk, encoding, cb) {
|
||||
throw new Error('not implemented');
|
||||
};
|
||||
|
||||
Transform.prototype._write = function(chunk, encoding, cb) {
|
||||
var ts = this._transformState;
|
||||
ts.writecb = cb;
|
||||
ts.writechunk = chunk;
|
||||
ts.writeencoding = encoding;
|
||||
if (!ts.transforming) {
|
||||
var rs = this._readableState;
|
||||
if (ts.needTransform ||
|
||||
rs.needReadable ||
|
||||
rs.length < rs.highWaterMark)
|
||||
this._read(rs.highWaterMark);
|
||||
}
|
||||
};
|
||||
|
||||
// Doesn't matter what the args are here.
|
||||
// _transform does all the work.
|
||||
// That we got here means that the readable side wants more data.
|
||||
Transform.prototype._read = function(n) {
|
||||
var ts = this._transformState;
|
||||
|
||||
if (!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming) {
|
||||
ts.transforming = true;
|
||||
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
|
||||
} else {
|
||||
// mark that we need a transform, so that any data that comes in
|
||||
// will get processed, now that we've asked for it.
|
||||
ts.needTransform = true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
function done(stream, er) {
|
||||
if (er)
|
||||
return stream.emit('error', er);
|
||||
|
||||
// if there's nothing in the write buffer, then that means
|
||||
// that nothing more will ever be provided
|
||||
var ws = stream._writableState;
|
||||
var ts = stream._transformState;
|
||||
|
||||
if (ws.length)
|
||||
throw new Error('calling transform done when ws.length != 0');
|
||||
|
||||
if (ts.transforming)
|
||||
throw new Error('calling transform done when still transforming');
|
||||
|
||||
return stream.push(null);
|
||||
}
|
||||
477
node_modules/mysql/node_modules/readable-stream/lib/_stream_writable.js
generated
vendored
Normal file
477
node_modules/mysql/node_modules/readable-stream/lib/_stream_writable.js
generated
vendored
Normal file
|
|
@ -0,0 +1,477 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
// A bit simpler than readable streams.
|
||||
// Implement an async ._write(chunk, cb), and it'll handle all
|
||||
// the drain event emission and buffering.
|
||||
|
||||
module.exports = Writable;
|
||||
|
||||
/*<replacement>*/
|
||||
var Buffer = require('buffer').Buffer;
|
||||
/*</replacement>*/
|
||||
|
||||
Writable.WritableState = WritableState;
|
||||
|
||||
|
||||
/*<replacement>*/
|
||||
var util = require('core-util-is');
|
||||
util.inherits = require('inherits');
|
||||
/*</replacement>*/
|
||||
|
||||
var Stream = require('stream');
|
||||
|
||||
util.inherits(Writable, Stream);
|
||||
|
||||
function WriteReq(chunk, encoding, cb) {
|
||||
this.chunk = chunk;
|
||||
this.encoding = encoding;
|
||||
this.callback = cb;
|
||||
}
|
||||
|
||||
function WritableState(options, stream) {
|
||||
var Duplex = require('./_stream_duplex');
|
||||
|
||||
options = options || {};
|
||||
|
||||
// the point at which write() starts returning false
|
||||
// Note: 0 is a valid value, means that we always return false if
|
||||
// the entire buffer is not flushed immediately on write()
|
||||
var hwm = options.highWaterMark;
|
||||
var defaultHwm = options.objectMode ? 16 : 16 * 1024;
|
||||
this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm;
|
||||
|
||||
// object stream flag to indicate whether or not this stream
|
||||
// contains buffers or objects.
|
||||
this.objectMode = !!options.objectMode;
|
||||
|
||||
if (stream instanceof Duplex)
|
||||
this.objectMode = this.objectMode || !!options.writableObjectMode;
|
||||
|
||||
// cast to ints.
|
||||
this.highWaterMark = ~~this.highWaterMark;
|
||||
|
||||
this.needDrain = false;
|
||||
// at the start of calling end()
|
||||
this.ending = false;
|
||||
// when end() has been called, and returned
|
||||
this.ended = false;
|
||||
// when 'finish' is emitted
|
||||
this.finished = false;
|
||||
|
||||
// should we decode strings into buffers before passing to _write?
|
||||
// this is here so that some node-core streams can optimize string
|
||||
// handling at a lower level.
|
||||
var noDecode = options.decodeStrings === false;
|
||||
this.decodeStrings = !noDecode;
|
||||
|
||||
// Crypto is kind of old and crusty. Historically, its default string
|
||||
// encoding is 'binary' so we have to make this configurable.
|
||||
// Everything else in the universe uses 'utf8', though.
|
||||
this.defaultEncoding = options.defaultEncoding || 'utf8';
|
||||
|
||||
// not an actual buffer we keep track of, but a measurement
|
||||
// of how much we're waiting to get pushed to some underlying
|
||||
// socket or file.
|
||||
this.length = 0;
|
||||
|
||||
// a flag to see when we're in the middle of a write.
|
||||
this.writing = false;
|
||||
|
||||
// when true all writes will be buffered until .uncork() call
|
||||
this.corked = 0;
|
||||
|
||||
// a flag to be able to tell if the onwrite cb is called immediately,
|
||||
// or on a later tick. We set this to true at first, because any
|
||||
// actions that shouldn't happen until "later" should generally also
|
||||
// not happen before the first write call.
|
||||
this.sync = true;
|
||||
|
||||
// a flag to know if we're processing previously buffered items, which
|
||||
// may call the _write() callback in the same tick, so that we don't
|
||||
// end up in an overlapped onwrite situation.
|
||||
this.bufferProcessing = false;
|
||||
|
||||
// the callback that's passed to _write(chunk,cb)
|
||||
this.onwrite = function(er) {
|
||||
onwrite(stream, er);
|
||||
};
|
||||
|
||||
// the callback that the user supplies to write(chunk,encoding,cb)
|
||||
this.writecb = null;
|
||||
|
||||
// the amount that is being written when _write is called.
|
||||
this.writelen = 0;
|
||||
|
||||
this.buffer = [];
|
||||
|
||||
// number of pending user-supplied write callbacks
|
||||
// this must be 0 before 'finish' can be emitted
|
||||
this.pendingcb = 0;
|
||||
|
||||
// emit prefinish if the only thing we're waiting for is _write cbs
|
||||
// This is relevant for synchronous Transform streams
|
||||
this.prefinished = false;
|
||||
|
||||
// True if the error was already emitted and should not be thrown again
|
||||
this.errorEmitted = false;
|
||||
}
|
||||
|
||||
function Writable(options) {
|
||||
var Duplex = require('./_stream_duplex');
|
||||
|
||||
// Writable ctor is applied to Duplexes, though they're not
|
||||
// instanceof Writable, they're instanceof Readable.
|
||||
if (!(this instanceof Writable) && !(this instanceof Duplex))
|
||||
return new Writable(options);
|
||||
|
||||
this._writableState = new WritableState(options, this);
|
||||
|
||||
// legacy.
|
||||
this.writable = true;
|
||||
|
||||
Stream.call(this);
|
||||
}
|
||||
|
||||
// Otherwise people can pipe Writable streams, which is just wrong.
|
||||
Writable.prototype.pipe = function() {
|
||||
this.emit('error', new Error('Cannot pipe. Not readable.'));
|
||||
};
|
||||
|
||||
|
||||
function writeAfterEnd(stream, state, cb) {
|
||||
var er = new Error('write after end');
|
||||
// TODO: defer error events consistently everywhere, not just the cb
|
||||
stream.emit('error', er);
|
||||
process.nextTick(function() {
|
||||
cb(er);
|
||||
});
|
||||
}
|
||||
|
||||
// If we get something that is not a buffer, string, null, or undefined,
|
||||
// and we're not in objectMode, then that's an error.
|
||||
// Otherwise stream chunks are all considered to be of length=1, and the
|
||||
// watermarks determine how many objects to keep in the buffer, rather than
|
||||
// how many bytes or characters.
|
||||
function validChunk(stream, state, chunk, cb) {
|
||||
var valid = true;
|
||||
if (!util.isBuffer(chunk) &&
|
||||
!util.isString(chunk) &&
|
||||
!util.isNullOrUndefined(chunk) &&
|
||||
!state.objectMode) {
|
||||
var er = new TypeError('Invalid non-string/buffer chunk');
|
||||
stream.emit('error', er);
|
||||
process.nextTick(function() {
|
||||
cb(er);
|
||||
});
|
||||
valid = false;
|
||||
}
|
||||
return valid;
|
||||
}
|
||||
|
||||
Writable.prototype.write = function(chunk, encoding, cb) {
|
||||
var state = this._writableState;
|
||||
var ret = false;
|
||||
|
||||
if (util.isFunction(encoding)) {
|
||||
cb = encoding;
|
||||
encoding = null;
|
||||
}
|
||||
|
||||
if (util.isBuffer(chunk))
|
||||
encoding = 'buffer';
|
||||
else if (!encoding)
|
||||
encoding = state.defaultEncoding;
|
||||
|
||||
if (!util.isFunction(cb))
|
||||
cb = function() {};
|
||||
|
||||
if (state.ended)
|
||||
writeAfterEnd(this, state, cb);
|
||||
else if (validChunk(this, state, chunk, cb)) {
|
||||
state.pendingcb++;
|
||||
ret = writeOrBuffer(this, state, chunk, encoding, cb);
|
||||
}
|
||||
|
||||
return ret;
|
||||
};
|
||||
|
||||
Writable.prototype.cork = function() {
|
||||
var state = this._writableState;
|
||||
|
||||
state.corked++;
|
||||
};
|
||||
|
||||
Writable.prototype.uncork = function() {
|
||||
var state = this._writableState;
|
||||
|
||||
if (state.corked) {
|
||||
state.corked--;
|
||||
|
||||
if (!state.writing &&
|
||||
!state.corked &&
|
||||
!state.finished &&
|
||||
!state.bufferProcessing &&
|
||||
state.buffer.length)
|
||||
clearBuffer(this, state);
|
||||
}
|
||||
};
|
||||
|
||||
function decodeChunk(state, chunk, encoding) {
|
||||
if (!state.objectMode &&
|
||||
state.decodeStrings !== false &&
|
||||
util.isString(chunk)) {
|
||||
chunk = new Buffer(chunk, encoding);
|
||||
}
|
||||
return chunk;
|
||||
}
|
||||
|
||||
// if we're already writing something, then just put this
|
||||
// in the queue, and wait our turn. Otherwise, call _write
|
||||
// If we return false, then we need a drain event, so set that flag.
|
||||
function writeOrBuffer(stream, state, chunk, encoding, cb) {
|
||||
chunk = decodeChunk(state, chunk, encoding);
|
||||
if (util.isBuffer(chunk))
|
||||
encoding = 'buffer';
|
||||
var len = state.objectMode ? 1 : chunk.length;
|
||||
|
||||
state.length += len;
|
||||
|
||||
var ret = state.length < state.highWaterMark;
|
||||
// we must ensure that previous needDrain will not be reset to false.
|
||||
if (!ret)
|
||||
state.needDrain = true;
|
||||
|
||||
if (state.writing || state.corked)
|
||||
state.buffer.push(new WriteReq(chunk, encoding, cb));
|
||||
else
|
||||
doWrite(stream, state, false, len, chunk, encoding, cb);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
|
||||
state.writelen = len;
|
||||
state.writecb = cb;
|
||||
state.writing = true;
|
||||
state.sync = true;
|
||||
if (writev)
|
||||
stream._writev(chunk, state.onwrite);
|
||||
else
|
||||
stream._write(chunk, encoding, state.onwrite);
|
||||
state.sync = false;
|
||||
}
|
||||
|
||||
function onwriteError(stream, state, sync, er, cb) {
|
||||
if (sync)
|
||||
process.nextTick(function() {
|
||||
state.pendingcb--;
|
||||
cb(er);
|
||||
});
|
||||
else {
|
||||
state.pendingcb--;
|
||||
cb(er);
|
||||
}
|
||||
|
||||
stream._writableState.errorEmitted = true;
|
||||
stream.emit('error', er);
|
||||
}
|
||||
|
||||
function onwriteStateUpdate(state) {
|
||||
state.writing = false;
|
||||
state.writecb = null;
|
||||
state.length -= state.writelen;
|
||||
state.writelen = 0;
|
||||
}
|
||||
|
||||
function onwrite(stream, er) {
|
||||
var state = stream._writableState;
|
||||
var sync = state.sync;
|
||||
var cb = state.writecb;
|
||||
|
||||
onwriteStateUpdate(state);
|
||||
|
||||
if (er)
|
||||
onwriteError(stream, state, sync, er, cb);
|
||||
else {
|
||||
// Check if we're actually ready to finish, but don't emit yet
|
||||
var finished = needFinish(stream, state);
|
||||
|
||||
if (!finished &&
|
||||
!state.corked &&
|
||||
!state.bufferProcessing &&
|
||||
state.buffer.length) {
|
||||
clearBuffer(stream, state);
|
||||
}
|
||||
|
||||
if (sync) {
|
||||
process.nextTick(function() {
|
||||
afterWrite(stream, state, finished, cb);
|
||||
});
|
||||
} else {
|
||||
afterWrite(stream, state, finished, cb);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function afterWrite(stream, state, finished, cb) {
|
||||
if (!finished)
|
||||
onwriteDrain(stream, state);
|
||||
state.pendingcb--;
|
||||
cb();
|
||||
finishMaybe(stream, state);
|
||||
}
|
||||
|
||||
// Must force callback to be called on nextTick, so that we don't
|
||||
// emit 'drain' before the write() consumer gets the 'false' return
|
||||
// value, and has a chance to attach a 'drain' listener.
|
||||
function onwriteDrain(stream, state) {
|
||||
if (state.length === 0 && state.needDrain) {
|
||||
state.needDrain = false;
|
||||
stream.emit('drain');
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// if there's something in the buffer waiting, then process it
|
||||
function clearBuffer(stream, state) {
|
||||
state.bufferProcessing = true;
|
||||
|
||||
if (stream._writev && state.buffer.length > 1) {
|
||||
// Fast case, write everything using _writev()
|
||||
var cbs = [];
|
||||
for (var c = 0; c < state.buffer.length; c++)
|
||||
cbs.push(state.buffer[c].callback);
|
||||
|
||||
// count the one we are adding, as well.
|
||||
// TODO(isaacs) clean this up
|
||||
state.pendingcb++;
|
||||
doWrite(stream, state, true, state.length, state.buffer, '', function(err) {
|
||||
for (var i = 0; i < cbs.length; i++) {
|
||||
state.pendingcb--;
|
||||
cbs[i](err);
|
||||
}
|
||||
});
|
||||
|
||||
// Clear buffer
|
||||
state.buffer = [];
|
||||
} else {
|
||||
// Slow case, write chunks one-by-one
|
||||
for (var c = 0; c < state.buffer.length; c++) {
|
||||
var entry = state.buffer[c];
|
||||
var chunk = entry.chunk;
|
||||
var encoding = entry.encoding;
|
||||
var cb = entry.callback;
|
||||
var len = state.objectMode ? 1 : chunk.length;
|
||||
|
||||
doWrite(stream, state, false, len, chunk, encoding, cb);
|
||||
|
||||
// if we didn't call the onwrite immediately, then
|
||||
// it means that we need to wait until it does.
|
||||
// also, that means that the chunk and cb are currently
|
||||
// being processed, so move the buffer counter past them.
|
||||
if (state.writing) {
|
||||
c++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (c < state.buffer.length)
|
||||
state.buffer = state.buffer.slice(c);
|
||||
else
|
||||
state.buffer.length = 0;
|
||||
}
|
||||
|
||||
state.bufferProcessing = false;
|
||||
}
|
||||
|
||||
Writable.prototype._write = function(chunk, encoding, cb) {
|
||||
cb(new Error('not implemented'));
|
||||
|
||||
};
|
||||
|
||||
Writable.prototype._writev = null;
|
||||
|
||||
Writable.prototype.end = function(chunk, encoding, cb) {
|
||||
var state = this._writableState;
|
||||
|
||||
if (util.isFunction(chunk)) {
|
||||
cb = chunk;
|
||||
chunk = null;
|
||||
encoding = null;
|
||||
} else if (util.isFunction(encoding)) {
|
||||
cb = encoding;
|
||||
encoding = null;
|
||||
}
|
||||
|
||||
if (!util.isNullOrUndefined(chunk))
|
||||
this.write(chunk, encoding);
|
||||
|
||||
// .end() fully uncorks
|
||||
if (state.corked) {
|
||||
state.corked = 1;
|
||||
this.uncork();
|
||||
}
|
||||
|
||||
// ignore unnecessary end() calls.
|
||||
if (!state.ending && !state.finished)
|
||||
endWritable(this, state, cb);
|
||||
};
|
||||
|
||||
|
||||
function needFinish(stream, state) {
|
||||
return (state.ending &&
|
||||
state.length === 0 &&
|
||||
!state.finished &&
|
||||
!state.writing);
|
||||
}
|
||||
|
||||
function prefinish(stream, state) {
|
||||
if (!state.prefinished) {
|
||||
state.prefinished = true;
|
||||
stream.emit('prefinish');
|
||||
}
|
||||
}
|
||||
|
||||
function finishMaybe(stream, state) {
|
||||
var need = needFinish(stream, state);
|
||||
if (need) {
|
||||
if (state.pendingcb === 0) {
|
||||
prefinish(stream, state);
|
||||
state.finished = true;
|
||||
stream.emit('finish');
|
||||
} else
|
||||
prefinish(stream, state);
|
||||
}
|
||||
return need;
|
||||
}
|
||||
|
||||
function endWritable(stream, state, cb) {
|
||||
state.ending = true;
|
||||
finishMaybe(stream, state);
|
||||
if (cb) {
|
||||
if (state.finished)
|
||||
process.nextTick(cb);
|
||||
else
|
||||
stream.once('finish', cb);
|
||||
}
|
||||
state.ended = true;
|
||||
}
|
||||
3
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/README.md
generated
vendored
Normal file
3
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
# core-util-is
|
||||
|
||||
The `util.is*` functions introduced in Node v0.12.
|
||||
604
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/float.patch
generated
vendored
Normal file
604
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/float.patch
generated
vendored
Normal file
|
|
@ -0,0 +1,604 @@
|
|||
diff --git a/lib/util.js b/lib/util.js
|
||||
index a03e874..9074e8e 100644
|
||||
--- a/lib/util.js
|
||||
+++ b/lib/util.js
|
||||
@@ -19,430 +19,6 @@
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
-var formatRegExp = /%[sdj%]/g;
|
||||
-exports.format = function(f) {
|
||||
- if (!isString(f)) {
|
||||
- var objects = [];
|
||||
- for (var i = 0; i < arguments.length; i++) {
|
||||
- objects.push(inspect(arguments[i]));
|
||||
- }
|
||||
- return objects.join(' ');
|
||||
- }
|
||||
-
|
||||
- var i = 1;
|
||||
- var args = arguments;
|
||||
- var len = args.length;
|
||||
- var str = String(f).replace(formatRegExp, function(x) {
|
||||
- if (x === '%%') return '%';
|
||||
- if (i >= len) return x;
|
||||
- switch (x) {
|
||||
- case '%s': return String(args[i++]);
|
||||
- case '%d': return Number(args[i++]);
|
||||
- case '%j':
|
||||
- try {
|
||||
- return JSON.stringify(args[i++]);
|
||||
- } catch (_) {
|
||||
- return '[Circular]';
|
||||
- }
|
||||
- default:
|
||||
- return x;
|
||||
- }
|
||||
- });
|
||||
- for (var x = args[i]; i < len; x = args[++i]) {
|
||||
- if (isNull(x) || !isObject(x)) {
|
||||
- str += ' ' + x;
|
||||
- } else {
|
||||
- str += ' ' + inspect(x);
|
||||
- }
|
||||
- }
|
||||
- return str;
|
||||
-};
|
||||
-
|
||||
-
|
||||
-// Mark that a method should not be used.
|
||||
-// Returns a modified function which warns once by default.
|
||||
-// If --no-deprecation is set, then it is a no-op.
|
||||
-exports.deprecate = function(fn, msg) {
|
||||
- // Allow for deprecating things in the process of starting up.
|
||||
- if (isUndefined(global.process)) {
|
||||
- return function() {
|
||||
- return exports.deprecate(fn, msg).apply(this, arguments);
|
||||
- };
|
||||
- }
|
||||
-
|
||||
- if (process.noDeprecation === true) {
|
||||
- return fn;
|
||||
- }
|
||||
-
|
||||
- var warned = false;
|
||||
- function deprecated() {
|
||||
- if (!warned) {
|
||||
- if (process.throwDeprecation) {
|
||||
- throw new Error(msg);
|
||||
- } else if (process.traceDeprecation) {
|
||||
- console.trace(msg);
|
||||
- } else {
|
||||
- console.error(msg);
|
||||
- }
|
||||
- warned = true;
|
||||
- }
|
||||
- return fn.apply(this, arguments);
|
||||
- }
|
||||
-
|
||||
- return deprecated;
|
||||
-};
|
||||
-
|
||||
-
|
||||
-var debugs = {};
|
||||
-var debugEnviron;
|
||||
-exports.debuglog = function(set) {
|
||||
- if (isUndefined(debugEnviron))
|
||||
- debugEnviron = process.env.NODE_DEBUG || '';
|
||||
- set = set.toUpperCase();
|
||||
- if (!debugs[set]) {
|
||||
- if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
|
||||
- var pid = process.pid;
|
||||
- debugs[set] = function() {
|
||||
- var msg = exports.format.apply(exports, arguments);
|
||||
- console.error('%s %d: %s', set, pid, msg);
|
||||
- };
|
||||
- } else {
|
||||
- debugs[set] = function() {};
|
||||
- }
|
||||
- }
|
||||
- return debugs[set];
|
||||
-};
|
||||
-
|
||||
-
|
||||
-/**
|
||||
- * Echos the value of a value. Trys to print the value out
|
||||
- * in the best way possible given the different types.
|
||||
- *
|
||||
- * @param {Object} obj The object to print out.
|
||||
- * @param {Object} opts Optional options object that alters the output.
|
||||
- */
|
||||
-/* legacy: obj, showHidden, depth, colors*/
|
||||
-function inspect(obj, opts) {
|
||||
- // default options
|
||||
- var ctx = {
|
||||
- seen: [],
|
||||
- stylize: stylizeNoColor
|
||||
- };
|
||||
- // legacy...
|
||||
- if (arguments.length >= 3) ctx.depth = arguments[2];
|
||||
- if (arguments.length >= 4) ctx.colors = arguments[3];
|
||||
- if (isBoolean(opts)) {
|
||||
- // legacy...
|
||||
- ctx.showHidden = opts;
|
||||
- } else if (opts) {
|
||||
- // got an "options" object
|
||||
- exports._extend(ctx, opts);
|
||||
- }
|
||||
- // set default options
|
||||
- if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
||||
- if (isUndefined(ctx.depth)) ctx.depth = 2;
|
||||
- if (isUndefined(ctx.colors)) ctx.colors = false;
|
||||
- if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
||||
- if (ctx.colors) ctx.stylize = stylizeWithColor;
|
||||
- return formatValue(ctx, obj, ctx.depth);
|
||||
-}
|
||||
-exports.inspect = inspect;
|
||||
-
|
||||
-
|
||||
-// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
||||
-inspect.colors = {
|
||||
- 'bold' : [1, 22],
|
||||
- 'italic' : [3, 23],
|
||||
- 'underline' : [4, 24],
|
||||
- 'inverse' : [7, 27],
|
||||
- 'white' : [37, 39],
|
||||
- 'grey' : [90, 39],
|
||||
- 'black' : [30, 39],
|
||||
- 'blue' : [34, 39],
|
||||
- 'cyan' : [36, 39],
|
||||
- 'green' : [32, 39],
|
||||
- 'magenta' : [35, 39],
|
||||
- 'red' : [31, 39],
|
||||
- 'yellow' : [33, 39]
|
||||
-};
|
||||
-
|
||||
-// Don't use 'blue' not visible on cmd.exe
|
||||
-inspect.styles = {
|
||||
- 'special': 'cyan',
|
||||
- 'number': 'yellow',
|
||||
- 'boolean': 'yellow',
|
||||
- 'undefined': 'grey',
|
||||
- 'null': 'bold',
|
||||
- 'string': 'green',
|
||||
- 'date': 'magenta',
|
||||
- // "name": intentionally not styling
|
||||
- 'regexp': 'red'
|
||||
-};
|
||||
-
|
||||
-
|
||||
-function stylizeWithColor(str, styleType) {
|
||||
- var style = inspect.styles[styleType];
|
||||
-
|
||||
- if (style) {
|
||||
- return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
||||
- '\u001b[' + inspect.colors[style][1] + 'm';
|
||||
- } else {
|
||||
- return str;
|
||||
- }
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function stylizeNoColor(str, styleType) {
|
||||
- return str;
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function arrayToHash(array) {
|
||||
- var hash = {};
|
||||
-
|
||||
- array.forEach(function(val, idx) {
|
||||
- hash[val] = true;
|
||||
- });
|
||||
-
|
||||
- return hash;
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function formatValue(ctx, value, recurseTimes) {
|
||||
- // Provide a hook for user-specified inspect functions.
|
||||
- // Check that value is an object with an inspect function on it
|
||||
- if (ctx.customInspect &&
|
||||
- value &&
|
||||
- isFunction(value.inspect) &&
|
||||
- // Filter out the util module, it's inspect function is special
|
||||
- value.inspect !== exports.inspect &&
|
||||
- // Also filter out any prototype objects using the circular check.
|
||||
- !(value.constructor && value.constructor.prototype === value)) {
|
||||
- var ret = value.inspect(recurseTimes, ctx);
|
||||
- if (!isString(ret)) {
|
||||
- ret = formatValue(ctx, ret, recurseTimes);
|
||||
- }
|
||||
- return ret;
|
||||
- }
|
||||
-
|
||||
- // Primitive types cannot have properties
|
||||
- var primitive = formatPrimitive(ctx, value);
|
||||
- if (primitive) {
|
||||
- return primitive;
|
||||
- }
|
||||
-
|
||||
- // Look up the keys of the object.
|
||||
- var keys = Object.keys(value);
|
||||
- var visibleKeys = arrayToHash(keys);
|
||||
-
|
||||
- if (ctx.showHidden) {
|
||||
- keys = Object.getOwnPropertyNames(value);
|
||||
- }
|
||||
-
|
||||
- // Some type of object without properties can be shortcutted.
|
||||
- if (keys.length === 0) {
|
||||
- if (isFunction(value)) {
|
||||
- var name = value.name ? ': ' + value.name : '';
|
||||
- return ctx.stylize('[Function' + name + ']', 'special');
|
||||
- }
|
||||
- if (isRegExp(value)) {
|
||||
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
||||
- }
|
||||
- if (isDate(value)) {
|
||||
- return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
||||
- }
|
||||
- if (isError(value)) {
|
||||
- return formatError(value);
|
||||
- }
|
||||
- }
|
||||
-
|
||||
- var base = '', array = false, braces = ['{', '}'];
|
||||
-
|
||||
- // Make Array say that they are Array
|
||||
- if (isArray(value)) {
|
||||
- array = true;
|
||||
- braces = ['[', ']'];
|
||||
- }
|
||||
-
|
||||
- // Make functions say that they are functions
|
||||
- if (isFunction(value)) {
|
||||
- var n = value.name ? ': ' + value.name : '';
|
||||
- base = ' [Function' + n + ']';
|
||||
- }
|
||||
-
|
||||
- // Make RegExps say that they are RegExps
|
||||
- if (isRegExp(value)) {
|
||||
- base = ' ' + RegExp.prototype.toString.call(value);
|
||||
- }
|
||||
-
|
||||
- // Make dates with properties first say the date
|
||||
- if (isDate(value)) {
|
||||
- base = ' ' + Date.prototype.toUTCString.call(value);
|
||||
- }
|
||||
-
|
||||
- // Make error with message first say the error
|
||||
- if (isError(value)) {
|
||||
- base = ' ' + formatError(value);
|
||||
- }
|
||||
-
|
||||
- if (keys.length === 0 && (!array || value.length == 0)) {
|
||||
- return braces[0] + base + braces[1];
|
||||
- }
|
||||
-
|
||||
- if (recurseTimes < 0) {
|
||||
- if (isRegExp(value)) {
|
||||
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
||||
- } else {
|
||||
- return ctx.stylize('[Object]', 'special');
|
||||
- }
|
||||
- }
|
||||
-
|
||||
- ctx.seen.push(value);
|
||||
-
|
||||
- var output;
|
||||
- if (array) {
|
||||
- output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
||||
- } else {
|
||||
- output = keys.map(function(key) {
|
||||
- return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
||||
- });
|
||||
- }
|
||||
-
|
||||
- ctx.seen.pop();
|
||||
-
|
||||
- return reduceToSingleString(output, base, braces);
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function formatPrimitive(ctx, value) {
|
||||
- if (isUndefined(value))
|
||||
- return ctx.stylize('undefined', 'undefined');
|
||||
- if (isString(value)) {
|
||||
- var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
||||
- .replace(/'/g, "\\'")
|
||||
- .replace(/\\"/g, '"') + '\'';
|
||||
- return ctx.stylize(simple, 'string');
|
||||
- }
|
||||
- if (isNumber(value)) {
|
||||
- // Format -0 as '-0'. Strict equality won't distinguish 0 from -0,
|
||||
- // so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 .
|
||||
- if (value === 0 && 1 / value < 0)
|
||||
- return ctx.stylize('-0', 'number');
|
||||
- return ctx.stylize('' + value, 'number');
|
||||
- }
|
||||
- if (isBoolean(value))
|
||||
- return ctx.stylize('' + value, 'boolean');
|
||||
- // For some reason typeof null is "object", so special case here.
|
||||
- if (isNull(value))
|
||||
- return ctx.stylize('null', 'null');
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function formatError(value) {
|
||||
- return '[' + Error.prototype.toString.call(value) + ']';
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
||||
- var output = [];
|
||||
- for (var i = 0, l = value.length; i < l; ++i) {
|
||||
- if (hasOwnProperty(value, String(i))) {
|
||||
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
||||
- String(i), true));
|
||||
- } else {
|
||||
- output.push('');
|
||||
- }
|
||||
- }
|
||||
- keys.forEach(function(key) {
|
||||
- if (!key.match(/^\d+$/)) {
|
||||
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
||||
- key, true));
|
||||
- }
|
||||
- });
|
||||
- return output;
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
||||
- var name, str, desc;
|
||||
- desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
||||
- if (desc.get) {
|
||||
- if (desc.set) {
|
||||
- str = ctx.stylize('[Getter/Setter]', 'special');
|
||||
- } else {
|
||||
- str = ctx.stylize('[Getter]', 'special');
|
||||
- }
|
||||
- } else {
|
||||
- if (desc.set) {
|
||||
- str = ctx.stylize('[Setter]', 'special');
|
||||
- }
|
||||
- }
|
||||
- if (!hasOwnProperty(visibleKeys, key)) {
|
||||
- name = '[' + key + ']';
|
||||
- }
|
||||
- if (!str) {
|
||||
- if (ctx.seen.indexOf(desc.value) < 0) {
|
||||
- if (isNull(recurseTimes)) {
|
||||
- str = formatValue(ctx, desc.value, null);
|
||||
- } else {
|
||||
- str = formatValue(ctx, desc.value, recurseTimes - 1);
|
||||
- }
|
||||
- if (str.indexOf('\n') > -1) {
|
||||
- if (array) {
|
||||
- str = str.split('\n').map(function(line) {
|
||||
- return ' ' + line;
|
||||
- }).join('\n').substr(2);
|
||||
- } else {
|
||||
- str = '\n' + str.split('\n').map(function(line) {
|
||||
- return ' ' + line;
|
||||
- }).join('\n');
|
||||
- }
|
||||
- }
|
||||
- } else {
|
||||
- str = ctx.stylize('[Circular]', 'special');
|
||||
- }
|
||||
- }
|
||||
- if (isUndefined(name)) {
|
||||
- if (array && key.match(/^\d+$/)) {
|
||||
- return str;
|
||||
- }
|
||||
- name = JSON.stringify('' + key);
|
||||
- if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
||||
- name = name.substr(1, name.length - 2);
|
||||
- name = ctx.stylize(name, 'name');
|
||||
- } else {
|
||||
- name = name.replace(/'/g, "\\'")
|
||||
- .replace(/\\"/g, '"')
|
||||
- .replace(/(^"|"$)/g, "'");
|
||||
- name = ctx.stylize(name, 'string');
|
||||
- }
|
||||
- }
|
||||
-
|
||||
- return name + ': ' + str;
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function reduceToSingleString(output, base, braces) {
|
||||
- var numLinesEst = 0;
|
||||
- var length = output.reduce(function(prev, cur) {
|
||||
- numLinesEst++;
|
||||
- if (cur.indexOf('\n') >= 0) numLinesEst++;
|
||||
- return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
||||
- }, 0);
|
||||
-
|
||||
- if (length > 60) {
|
||||
- return braces[0] +
|
||||
- (base === '' ? '' : base + '\n ') +
|
||||
- ' ' +
|
||||
- output.join(',\n ') +
|
||||
- ' ' +
|
||||
- braces[1];
|
||||
- }
|
||||
-
|
||||
- return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
||||
-}
|
||||
-
|
||||
-
|
||||
// NOTE: These type checking functions intentionally don't use `instanceof`
|
||||
// because it is fragile and can be easily faked with `Object.create()`.
|
||||
function isArray(ar) {
|
||||
@@ -522,166 +98,10 @@ function isPrimitive(arg) {
|
||||
exports.isPrimitive = isPrimitive;
|
||||
|
||||
function isBuffer(arg) {
|
||||
- return arg instanceof Buffer;
|
||||
+ return Buffer.isBuffer(arg);
|
||||
}
|
||||
exports.isBuffer = isBuffer;
|
||||
|
||||
function objectToString(o) {
|
||||
return Object.prototype.toString.call(o);
|
||||
-}
|
||||
-
|
||||
-
|
||||
-function pad(n) {
|
||||
- return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
||||
-}
|
||||
-
|
||||
-
|
||||
-var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
||||
- 'Oct', 'Nov', 'Dec'];
|
||||
-
|
||||
-// 26 Feb 16:19:34
|
||||
-function timestamp() {
|
||||
- var d = new Date();
|
||||
- var time = [pad(d.getHours()),
|
||||
- pad(d.getMinutes()),
|
||||
- pad(d.getSeconds())].join(':');
|
||||
- return [d.getDate(), months[d.getMonth()], time].join(' ');
|
||||
-}
|
||||
-
|
||||
-
|
||||
-// log is just a thin wrapper to console.log that prepends a timestamp
|
||||
-exports.log = function() {
|
||||
- console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
||||
-};
|
||||
-
|
||||
-
|
||||
-/**
|
||||
- * Inherit the prototype methods from one constructor into another.
|
||||
- *
|
||||
- * The Function.prototype.inherits from lang.js rewritten as a standalone
|
||||
- * function (not on Function.prototype). NOTE: If this file is to be loaded
|
||||
- * during bootstrapping this function needs to be rewritten using some native
|
||||
- * functions as prototype setup using normal JavaScript does not work as
|
||||
- * expected during bootstrapping (see mirror.js in r114903).
|
||||
- *
|
||||
- * @param {function} ctor Constructor function which needs to inherit the
|
||||
- * prototype.
|
||||
- * @param {function} superCtor Constructor function to inherit prototype from.
|
||||
- */
|
||||
-exports.inherits = function(ctor, superCtor) {
|
||||
- ctor.super_ = superCtor;
|
||||
- ctor.prototype = Object.create(superCtor.prototype, {
|
||||
- constructor: {
|
||||
- value: ctor,
|
||||
- enumerable: false,
|
||||
- writable: true,
|
||||
- configurable: true
|
||||
- }
|
||||
- });
|
||||
-};
|
||||
-
|
||||
-exports._extend = function(origin, add) {
|
||||
- // Don't do anything if add isn't an object
|
||||
- if (!add || !isObject(add)) return origin;
|
||||
-
|
||||
- var keys = Object.keys(add);
|
||||
- var i = keys.length;
|
||||
- while (i--) {
|
||||
- origin[keys[i]] = add[keys[i]];
|
||||
- }
|
||||
- return origin;
|
||||
-};
|
||||
-
|
||||
-function hasOwnProperty(obj, prop) {
|
||||
- return Object.prototype.hasOwnProperty.call(obj, prop);
|
||||
-}
|
||||
-
|
||||
-
|
||||
-// Deprecated old stuff.
|
||||
-
|
||||
-exports.p = exports.deprecate(function() {
|
||||
- for (var i = 0, len = arguments.length; i < len; ++i) {
|
||||
- console.error(exports.inspect(arguments[i]));
|
||||
- }
|
||||
-}, 'util.p: Use console.error() instead');
|
||||
-
|
||||
-
|
||||
-exports.exec = exports.deprecate(function() {
|
||||
- return require('child_process').exec.apply(this, arguments);
|
||||
-}, 'util.exec is now called `child_process.exec`.');
|
||||
-
|
||||
-
|
||||
-exports.print = exports.deprecate(function() {
|
||||
- for (var i = 0, len = arguments.length; i < len; ++i) {
|
||||
- process.stdout.write(String(arguments[i]));
|
||||
- }
|
||||
-}, 'util.print: Use console.log instead');
|
||||
-
|
||||
-
|
||||
-exports.puts = exports.deprecate(function() {
|
||||
- for (var i = 0, len = arguments.length; i < len; ++i) {
|
||||
- process.stdout.write(arguments[i] + '\n');
|
||||
- }
|
||||
-}, 'util.puts: Use console.log instead');
|
||||
-
|
||||
-
|
||||
-exports.debug = exports.deprecate(function(x) {
|
||||
- process.stderr.write('DEBUG: ' + x + '\n');
|
||||
-}, 'util.debug: Use console.error instead');
|
||||
-
|
||||
-
|
||||
-exports.error = exports.deprecate(function(x) {
|
||||
- for (var i = 0, len = arguments.length; i < len; ++i) {
|
||||
- process.stderr.write(arguments[i] + '\n');
|
||||
- }
|
||||
-}, 'util.error: Use console.error instead');
|
||||
-
|
||||
-
|
||||
-exports.pump = exports.deprecate(function(readStream, writeStream, callback) {
|
||||
- var callbackCalled = false;
|
||||
-
|
||||
- function call(a, b, c) {
|
||||
- if (callback && !callbackCalled) {
|
||||
- callback(a, b, c);
|
||||
- callbackCalled = true;
|
||||
- }
|
||||
- }
|
||||
-
|
||||
- readStream.addListener('data', function(chunk) {
|
||||
- if (writeStream.write(chunk) === false) readStream.pause();
|
||||
- });
|
||||
-
|
||||
- writeStream.addListener('drain', function() {
|
||||
- readStream.resume();
|
||||
- });
|
||||
-
|
||||
- readStream.addListener('end', function() {
|
||||
- writeStream.end();
|
||||
- });
|
||||
-
|
||||
- readStream.addListener('close', function() {
|
||||
- call();
|
||||
- });
|
||||
-
|
||||
- readStream.addListener('error', function(err) {
|
||||
- writeStream.end();
|
||||
- call(err);
|
||||
- });
|
||||
-
|
||||
- writeStream.addListener('error', function(err) {
|
||||
- readStream.destroy();
|
||||
- call(err);
|
||||
- });
|
||||
-}, 'util.pump(): Use readableStream.pipe() instead');
|
||||
-
|
||||
-
|
||||
-var uv;
|
||||
-exports._errnoException = function(err, syscall) {
|
||||
- if (isUndefined(uv)) uv = process.binding('uv');
|
||||
- var errname = uv.errname(err);
|
||||
- var e = new Error(syscall + ' ' + errname);
|
||||
- e.code = errname;
|
||||
- e.errno = errname;
|
||||
- e.syscall = syscall;
|
||||
- return e;
|
||||
-};
|
||||
+}
|
||||
107
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/lib/util.js
generated
vendored
Normal file
107
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/lib/util.js
generated
vendored
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
// NOTE: These type checking functions intentionally don't use `instanceof`
|
||||
// because it is fragile and can be easily faked with `Object.create()`.
|
||||
function isArray(ar) {
|
||||
return Array.isArray(ar);
|
||||
}
|
||||
exports.isArray = isArray;
|
||||
|
||||
function isBoolean(arg) {
|
||||
return typeof arg === 'boolean';
|
||||
}
|
||||
exports.isBoolean = isBoolean;
|
||||
|
||||
function isNull(arg) {
|
||||
return arg === null;
|
||||
}
|
||||
exports.isNull = isNull;
|
||||
|
||||
function isNullOrUndefined(arg) {
|
||||
return arg == null;
|
||||
}
|
||||
exports.isNullOrUndefined = isNullOrUndefined;
|
||||
|
||||
function isNumber(arg) {
|
||||
return typeof arg === 'number';
|
||||
}
|
||||
exports.isNumber = isNumber;
|
||||
|
||||
function isString(arg) {
|
||||
return typeof arg === 'string';
|
||||
}
|
||||
exports.isString = isString;
|
||||
|
||||
function isSymbol(arg) {
|
||||
return typeof arg === 'symbol';
|
||||
}
|
||||
exports.isSymbol = isSymbol;
|
||||
|
||||
function isUndefined(arg) {
|
||||
return arg === void 0;
|
||||
}
|
||||
exports.isUndefined = isUndefined;
|
||||
|
||||
function isRegExp(re) {
|
||||
return isObject(re) && objectToString(re) === '[object RegExp]';
|
||||
}
|
||||
exports.isRegExp = isRegExp;
|
||||
|
||||
function isObject(arg) {
|
||||
return typeof arg === 'object' && arg !== null;
|
||||
}
|
||||
exports.isObject = isObject;
|
||||
|
||||
function isDate(d) {
|
||||
return isObject(d) && objectToString(d) === '[object Date]';
|
||||
}
|
||||
exports.isDate = isDate;
|
||||
|
||||
function isError(e) {
|
||||
return isObject(e) &&
|
||||
(objectToString(e) === '[object Error]' || e instanceof Error);
|
||||
}
|
||||
exports.isError = isError;
|
||||
|
||||
function isFunction(arg) {
|
||||
return typeof arg === 'function';
|
||||
}
|
||||
exports.isFunction = isFunction;
|
||||
|
||||
function isPrimitive(arg) {
|
||||
return arg === null ||
|
||||
typeof arg === 'boolean' ||
|
||||
typeof arg === 'number' ||
|
||||
typeof arg === 'string' ||
|
||||
typeof arg === 'symbol' || // ES6 symbol
|
||||
typeof arg === 'undefined';
|
||||
}
|
||||
exports.isPrimitive = isPrimitive;
|
||||
|
||||
function isBuffer(arg) {
|
||||
return Buffer.isBuffer(arg);
|
||||
}
|
||||
exports.isBuffer = isBuffer;
|
||||
|
||||
function objectToString(o) {
|
||||
return Object.prototype.toString.call(o);
|
||||
}
|
||||
35
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/package.json
generated
vendored
Normal file
35
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
{
|
||||
"name": "core-util-is",
|
||||
"version": "1.0.1",
|
||||
"description": "The `util.is*` functions introduced in Node v0.12.",
|
||||
"main": "lib/util.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/isaacs/core-util-is"
|
||||
},
|
||||
"keywords": [
|
||||
"util",
|
||||
"isBuffer",
|
||||
"isArray",
|
||||
"isNumber",
|
||||
"isString",
|
||||
"isRegExp",
|
||||
"isThis",
|
||||
"isThat",
|
||||
"polyfill"
|
||||
],
|
||||
"author": {
|
||||
"name": "Isaac Z. Schlueter",
|
||||
"email": "i@izs.me",
|
||||
"url": "http://blog.izs.me/"
|
||||
},
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/isaacs/core-util-is/issues"
|
||||
},
|
||||
"readme": "# core-util-is\n\nThe `util.is*` functions introduced in Node v0.12.\n",
|
||||
"readmeFilename": "README.md",
|
||||
"homepage": "https://github.com/isaacs/core-util-is",
|
||||
"_id": "core-util-is@1.0.1",
|
||||
"_from": "core-util-is@>=1.0.0 <1.1.0"
|
||||
}
|
||||
106
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/util.js
generated
vendored
Normal file
106
node_modules/mysql/node_modules/readable-stream/node_modules/core-util-is/util.js
generated
vendored
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
// NOTE: These type checking functions intentionally don't use `instanceof`
|
||||
// because it is fragile and can be easily faked with `Object.create()`.
|
||||
function isArray(ar) {
|
||||
return Array.isArray(ar);
|
||||
}
|
||||
exports.isArray = isArray;
|
||||
|
||||
function isBoolean(arg) {
|
||||
return typeof arg === 'boolean';
|
||||
}
|
||||
exports.isBoolean = isBoolean;
|
||||
|
||||
function isNull(arg) {
|
||||
return arg === null;
|
||||
}
|
||||
exports.isNull = isNull;
|
||||
|
||||
function isNullOrUndefined(arg) {
|
||||
return arg == null;
|
||||
}
|
||||
exports.isNullOrUndefined = isNullOrUndefined;
|
||||
|
||||
function isNumber(arg) {
|
||||
return typeof arg === 'number';
|
||||
}
|
||||
exports.isNumber = isNumber;
|
||||
|
||||
function isString(arg) {
|
||||
return typeof arg === 'string';
|
||||
}
|
||||
exports.isString = isString;
|
||||
|
||||
function isSymbol(arg) {
|
||||
return typeof arg === 'symbol';
|
||||
}
|
||||
exports.isSymbol = isSymbol;
|
||||
|
||||
function isUndefined(arg) {
|
||||
return arg === void 0;
|
||||
}
|
||||
exports.isUndefined = isUndefined;
|
||||
|
||||
function isRegExp(re) {
|
||||
return isObject(re) && objectToString(re) === '[object RegExp]';
|
||||
}
|
||||
exports.isRegExp = isRegExp;
|
||||
|
||||
function isObject(arg) {
|
||||
return typeof arg === 'object' && arg !== null;
|
||||
}
|
||||
exports.isObject = isObject;
|
||||
|
||||
function isDate(d) {
|
||||
return isObject(d) && objectToString(d) === '[object Date]';
|
||||
}
|
||||
exports.isDate = isDate;
|
||||
|
||||
function isError(e) {
|
||||
return isObject(e) && objectToString(e) === '[object Error]';
|
||||
}
|
||||
exports.isError = isError;
|
||||
|
||||
function isFunction(arg) {
|
||||
return typeof arg === 'function';
|
||||
}
|
||||
exports.isFunction = isFunction;
|
||||
|
||||
function isPrimitive(arg) {
|
||||
return arg === null ||
|
||||
typeof arg === 'boolean' ||
|
||||
typeof arg === 'number' ||
|
||||
typeof arg === 'string' ||
|
||||
typeof arg === 'symbol' || // ES6 symbol
|
||||
typeof arg === 'undefined';
|
||||
}
|
||||
exports.isPrimitive = isPrimitive;
|
||||
|
||||
function isBuffer(arg) {
|
||||
return arg instanceof Buffer;
|
||||
}
|
||||
exports.isBuffer = isBuffer;
|
||||
|
||||
function objectToString(o) {
|
||||
return Object.prototype.toString.call(o);
|
||||
}
|
||||
16
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/LICENSE
generated
vendored
Normal file
16
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
The ISC License
|
||||
|
||||
Copyright (c) Isaac Z. Schlueter
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
42
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/README.md
generated
vendored
Normal file
42
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
Browser-friendly inheritance fully compatible with standard node.js
|
||||
[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
|
||||
|
||||
This package exports standard `inherits` from node.js `util` module in
|
||||
node environment, but also provides alternative browser-friendly
|
||||
implementation through [browser
|
||||
field](https://gist.github.com/shtylman/4339901). Alternative
|
||||
implementation is a literal copy of standard one located in standalone
|
||||
module to avoid requiring of `util`. It also has a shim for old
|
||||
browsers with no `Object.create` support.
|
||||
|
||||
While keeping you sure you are using standard `inherits`
|
||||
implementation in node.js environment, it allows bundlers such as
|
||||
[browserify](https://github.com/substack/node-browserify) to not
|
||||
include full `util` package to your client code if all you need is
|
||||
just `inherits` function. It worth, because browser shim for `util`
|
||||
package is large and `inherits` is often the single function you need
|
||||
from it.
|
||||
|
||||
It's recommended to use this package instead of
|
||||
`require('util').inherits` for any code that has chances to be used
|
||||
not only in node.js but in browser too.
|
||||
|
||||
## usage
|
||||
|
||||
```js
|
||||
var inherits = require('inherits');
|
||||
// then use exactly as the standard one
|
||||
```
|
||||
|
||||
## note on version ~1.0
|
||||
|
||||
Version ~1.0 had completely different motivation and is not compatible
|
||||
neither with 2.0 nor with standard node.js `inherits`.
|
||||
|
||||
If you are using version ~1.0 and planning to switch to ~2.0, be
|
||||
careful:
|
||||
|
||||
* new version uses `super_` instead of `super` for referencing
|
||||
superclass
|
||||
* new version overwrites current prototype while old one preserves any
|
||||
existing fields on it
|
||||
1
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/inherits.js
generated
vendored
Normal file
1
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/inherits.js
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
module.exports = require('util').inherits
|
||||
23
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/inherits_browser.js
generated
vendored
Normal file
23
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/inherits_browser.js
generated
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
if (typeof Object.create === 'function') {
|
||||
// implementation from standard node.js 'util' module
|
||||
module.exports = function inherits(ctor, superCtor) {
|
||||
ctor.super_ = superCtor
|
||||
ctor.prototype = Object.create(superCtor.prototype, {
|
||||
constructor: {
|
||||
value: ctor,
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
configurable: true
|
||||
}
|
||||
});
|
||||
};
|
||||
} else {
|
||||
// old school shim for old browsers
|
||||
module.exports = function inherits(ctor, superCtor) {
|
||||
ctor.super_ = superCtor
|
||||
var TempCtor = function () {}
|
||||
TempCtor.prototype = superCtor.prototype
|
||||
ctor.prototype = new TempCtor()
|
||||
ctor.prototype.constructor = ctor
|
||||
}
|
||||
}
|
||||
33
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/package.json
generated
vendored
Normal file
33
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
{
|
||||
"name": "inherits",
|
||||
"description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
|
||||
"version": "2.0.1",
|
||||
"keywords": [
|
||||
"inheritance",
|
||||
"class",
|
||||
"klass",
|
||||
"oop",
|
||||
"object-oriented",
|
||||
"inherits",
|
||||
"browser",
|
||||
"browserify"
|
||||
],
|
||||
"main": "./inherits.js",
|
||||
"browser": "./inherits_browser.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/isaacs/inherits"
|
||||
},
|
||||
"license": "ISC",
|
||||
"scripts": {
|
||||
"test": "node test"
|
||||
},
|
||||
"readme": "Browser-friendly inheritance fully compatible with standard node.js\n[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).\n\nThis package exports standard `inherits` from node.js `util` module in\nnode environment, but also provides alternative browser-friendly\nimplementation through [browser\nfield](https://gist.github.com/shtylman/4339901). Alternative\nimplementation is a literal copy of standard one located in standalone\nmodule to avoid requiring of `util`. It also has a shim for old\nbrowsers with no `Object.create` support.\n\nWhile keeping you sure you are using standard `inherits`\nimplementation in node.js environment, it allows bundlers such as\n[browserify](https://github.com/substack/node-browserify) to not\ninclude full `util` package to your client code if all you need is\njust `inherits` function. It worth, because browser shim for `util`\npackage is large and `inherits` is often the single function you need\nfrom it.\n\nIt's recommended to use this package instead of\n`require('util').inherits` for any code that has chances to be used\nnot only in node.js but in browser too.\n\n## usage\n\n```js\nvar inherits = require('inherits');\n// then use exactly as the standard one\n```\n\n## note on version ~1.0\n\nVersion ~1.0 had completely different motivation and is not compatible\nneither with 2.0 nor with standard node.js `inherits`.\n\nIf you are using version ~1.0 and planning to switch to ~2.0, be\ncareful:\n\n* new version uses `super_` instead of `super` for referencing\n superclass\n* new version overwrites current prototype while old one preserves any\n existing fields on it\n",
|
||||
"readmeFilename": "README.md",
|
||||
"bugs": {
|
||||
"url": "https://github.com/isaacs/inherits/issues"
|
||||
},
|
||||
"homepage": "https://github.com/isaacs/inherits",
|
||||
"_id": "inherits@2.0.1",
|
||||
"_from": "inherits@>=2.0.1 <2.1.0"
|
||||
}
|
||||
25
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/test.js
generated
vendored
Normal file
25
node_modules/mysql/node_modules/readable-stream/node_modules/inherits/test.js
generated
vendored
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
var inherits = require('./inherits.js')
|
||||
var assert = require('assert')
|
||||
|
||||
function test(c) {
|
||||
assert(c.constructor === Child)
|
||||
assert(c.constructor.super_ === Parent)
|
||||
assert(Object.getPrototypeOf(c) === Child.prototype)
|
||||
assert(Object.getPrototypeOf(Object.getPrototypeOf(c)) === Parent.prototype)
|
||||
assert(c instanceof Child)
|
||||
assert(c instanceof Parent)
|
||||
}
|
||||
|
||||
function Child() {
|
||||
Parent.call(this)
|
||||
test(this)
|
||||
}
|
||||
|
||||
function Parent() {}
|
||||
|
||||
inherits(Child, Parent)
|
||||
|
||||
var c = new Child
|
||||
test(c)
|
||||
|
||||
console.log('ok')
|
||||
54
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/README.md
generated
vendored
Normal file
54
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
|
||||
# isarray
|
||||
|
||||
`Array#isArray` for older browsers.
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
var isArray = require('isarray');
|
||||
|
||||
console.log(isArray([])); // => true
|
||||
console.log(isArray({})); // => false
|
||||
```
|
||||
|
||||
## Installation
|
||||
|
||||
With [npm](http://npmjs.org) do
|
||||
|
||||
```bash
|
||||
$ npm install isarray
|
||||
```
|
||||
|
||||
Then bundle for the browser with
|
||||
[browserify](https://github.com/substack/browserify).
|
||||
|
||||
With [component](http://component.io) do
|
||||
|
||||
```bash
|
||||
$ component install juliangruber/isarray
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
(MIT)
|
||||
|
||||
Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
209
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/build/build.js
generated
vendored
Normal file
209
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/build/build.js
generated
vendored
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
|
||||
/**
|
||||
* Require the given path.
|
||||
*
|
||||
* @param {String} path
|
||||
* @return {Object} exports
|
||||
* @api public
|
||||
*/
|
||||
|
||||
function require(path, parent, orig) {
|
||||
var resolved = require.resolve(path);
|
||||
|
||||
// lookup failed
|
||||
if (null == resolved) {
|
||||
orig = orig || path;
|
||||
parent = parent || 'root';
|
||||
var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
|
||||
err.path = orig;
|
||||
err.parent = parent;
|
||||
err.require = true;
|
||||
throw err;
|
||||
}
|
||||
|
||||
var module = require.modules[resolved];
|
||||
|
||||
// perform real require()
|
||||
// by invoking the module's
|
||||
// registered function
|
||||
if (!module.exports) {
|
||||
module.exports = {};
|
||||
module.client = module.component = true;
|
||||
module.call(this, module.exports, require.relative(resolved), module);
|
||||
}
|
||||
|
||||
return module.exports;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registered modules.
|
||||
*/
|
||||
|
||||
require.modules = {};
|
||||
|
||||
/**
|
||||
* Registered aliases.
|
||||
*/
|
||||
|
||||
require.aliases = {};
|
||||
|
||||
/**
|
||||
* Resolve `path`.
|
||||
*
|
||||
* Lookup:
|
||||
*
|
||||
* - PATH/index.js
|
||||
* - PATH.js
|
||||
* - PATH
|
||||
*
|
||||
* @param {String} path
|
||||
* @return {String} path or null
|
||||
* @api private
|
||||
*/
|
||||
|
||||
require.resolve = function(path) {
|
||||
if (path.charAt(0) === '/') path = path.slice(1);
|
||||
var index = path + '/index.js';
|
||||
|
||||
var paths = [
|
||||
path,
|
||||
path + '.js',
|
||||
path + '.json',
|
||||
path + '/index.js',
|
||||
path + '/index.json'
|
||||
];
|
||||
|
||||
for (var i = 0; i < paths.length; i++) {
|
||||
var path = paths[i];
|
||||
if (require.modules.hasOwnProperty(path)) return path;
|
||||
}
|
||||
|
||||
if (require.aliases.hasOwnProperty(index)) {
|
||||
return require.aliases[index];
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Normalize `path` relative to the current path.
|
||||
*
|
||||
* @param {String} curr
|
||||
* @param {String} path
|
||||
* @return {String}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
require.normalize = function(curr, path) {
|
||||
var segs = [];
|
||||
|
||||
if ('.' != path.charAt(0)) return path;
|
||||
|
||||
curr = curr.split('/');
|
||||
path = path.split('/');
|
||||
|
||||
for (var i = 0; i < path.length; ++i) {
|
||||
if ('..' == path[i]) {
|
||||
curr.pop();
|
||||
} else if ('.' != path[i] && '' != path[i]) {
|
||||
segs.push(path[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return curr.concat(segs).join('/');
|
||||
};
|
||||
|
||||
/**
|
||||
* Register module at `path` with callback `definition`.
|
||||
*
|
||||
* @param {String} path
|
||||
* @param {Function} definition
|
||||
* @api private
|
||||
*/
|
||||
|
||||
require.register = function(path, definition) {
|
||||
require.modules[path] = definition;
|
||||
};
|
||||
|
||||
/**
|
||||
* Alias a module definition.
|
||||
*
|
||||
* @param {String} from
|
||||
* @param {String} to
|
||||
* @api private
|
||||
*/
|
||||
|
||||
require.alias = function(from, to) {
|
||||
if (!require.modules.hasOwnProperty(from)) {
|
||||
throw new Error('Failed to alias "' + from + '", it does not exist');
|
||||
}
|
||||
require.aliases[to] = from;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return a require function relative to the `parent` path.
|
||||
*
|
||||
* @param {String} parent
|
||||
* @return {Function}
|
||||
* @api private
|
||||
*/
|
||||
|
||||
require.relative = function(parent) {
|
||||
var p = require.normalize(parent, '..');
|
||||
|
||||
/**
|
||||
* lastIndexOf helper.
|
||||
*/
|
||||
|
||||
function lastIndexOf(arr, obj) {
|
||||
var i = arr.length;
|
||||
while (i--) {
|
||||
if (arr[i] === obj) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* The relative require() itself.
|
||||
*/
|
||||
|
||||
function localRequire(path) {
|
||||
var resolved = localRequire.resolve(path);
|
||||
return require(resolved, parent, path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve relative to the parent.
|
||||
*/
|
||||
|
||||
localRequire.resolve = function(path) {
|
||||
var c = path.charAt(0);
|
||||
if ('/' == c) return path.slice(1);
|
||||
if ('.' == c) return require.normalize(p, path);
|
||||
|
||||
// resolve deps by returning
|
||||
// the dep in the nearest "deps"
|
||||
// directory
|
||||
var segs = parent.split('/');
|
||||
var i = lastIndexOf(segs, 'deps') + 1;
|
||||
if (!i) i = 0;
|
||||
path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
|
||||
return path;
|
||||
};
|
||||
|
||||
/**
|
||||
* Check if module is defined at `path`.
|
||||
*/
|
||||
|
||||
localRequire.exists = function(path) {
|
||||
return require.modules.hasOwnProperty(localRequire.resolve(path));
|
||||
};
|
||||
|
||||
return localRequire;
|
||||
};
|
||||
require.register("isarray/index.js", function(exports, require, module){
|
||||
module.exports = Array.isArray || function (arr) {
|
||||
return Object.prototype.toString.call(arr) == '[object Array]';
|
||||
};
|
||||
|
||||
});
|
||||
require.alias("isarray/index.js", "isarray/index.js");
|
||||
|
||||
19
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/component.json
generated
vendored
Normal file
19
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/component.json
generated
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
{
|
||||
"name" : "isarray",
|
||||
"description" : "Array#isArray for older browsers",
|
||||
"version" : "0.0.1",
|
||||
"repository" : "juliangruber/isarray",
|
||||
"homepage": "https://github.com/juliangruber/isarray",
|
||||
"main" : "index.js",
|
||||
"scripts" : [
|
||||
"index.js"
|
||||
],
|
||||
"dependencies" : {},
|
||||
"keywords": ["browser","isarray","array"],
|
||||
"author": {
|
||||
"name": "Julian Gruber",
|
||||
"email": "mail@juliangruber.com",
|
||||
"url": "http://juliangruber.com"
|
||||
},
|
||||
"license": "MIT"
|
||||
}
|
||||
3
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/index.js
generated
vendored
Normal file
3
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
module.exports = Array.isArray || function (arr) {
|
||||
return Object.prototype.toString.call(arr) == '[object Array]';
|
||||
};
|
||||
54
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/package.json
generated
vendored
Normal file
54
node_modules/mysql/node_modules/readable-stream/node_modules/isarray/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
{
|
||||
"name": "isarray",
|
||||
"description": "Array#isArray for older browsers",
|
||||
"version": "0.0.1",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/juliangruber/isarray.git"
|
||||
},
|
||||
"homepage": "https://github.com/juliangruber/isarray",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"test": "tap test/*.js"
|
||||
},
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"tap": "*"
|
||||
},
|
||||
"keywords": [
|
||||
"browser",
|
||||
"isarray",
|
||||
"array"
|
||||
],
|
||||
"author": {
|
||||
"name": "Julian Gruber",
|
||||
"email": "mail@juliangruber.com",
|
||||
"url": "http://juliangruber.com"
|
||||
},
|
||||
"license": "MIT",
|
||||
"readme": "\n# isarray\n\n`Array#isArray` for older browsers.\n\n## Usage\n\n```js\nvar isArray = require('isarray');\n\nconsole.log(isArray([])); // => true\nconsole.log(isArray({})); // => false\n```\n\n## Installation\n\nWith [npm](http://npmjs.org) do\n\n```bash\n$ npm install isarray\n```\n\nThen bundle for the browser with\n[browserify](https://github.com/substack/browserify).\n\nWith [component](http://component.io) do\n\n```bash\n$ component install juliangruber/isarray\n```\n\n## License\n\n(MIT)\n\nCopyright (c) 2013 Julian Gruber <julian@juliangruber.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n",
|
||||
"readmeFilename": "README.md",
|
||||
"_id": "isarray@0.0.1",
|
||||
"dist": {
|
||||
"shasum": "8a18acfca9a8f4177e09abfc6038939b05d1eedf",
|
||||
"tarball": "http://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
|
||||
},
|
||||
"_from": "isarray@0.0.1",
|
||||
"_npmVersion": "1.2.18",
|
||||
"_npmUser": {
|
||||
"name": "juliangruber",
|
||||
"email": "julian@juliangruber.com"
|
||||
},
|
||||
"maintainers": [
|
||||
{
|
||||
"name": "juliangruber",
|
||||
"email": "julian@juliangruber.com"
|
||||
}
|
||||
],
|
||||
"directories": {},
|
||||
"_shasum": "8a18acfca9a8f4177e09abfc6038939b05d1eedf",
|
||||
"_resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
|
||||
"bugs": {
|
||||
"url": "https://github.com/juliangruber/isarray/issues"
|
||||
}
|
||||
}
|
||||
2
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/.npmignore
generated
vendored
Normal file
2
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/.npmignore
generated
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
build
|
||||
test
|
||||
20
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/LICENSE
generated
vendored
Normal file
20
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/LICENSE
generated
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
Copyright Joyent, Inc. and other Node contributors.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a
|
||||
copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
persons to whom the Software is furnished to do so, subject to the
|
||||
following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
7
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/README.md
generated
vendored
Normal file
7
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/README.md
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
**string_decoder.js** (`require('string_decoder')`) from Node.js core
|
||||
|
||||
Copyright Joyent, Inc. and other Node contributors. See LICENCE file for details.
|
||||
|
||||
Version numbers match the versions found in Node core, e.g. 0.10.24 matches Node 0.10.24, likewise 0.11.10 matches Node 0.11.10. **Prefer the stable version over the unstable.**
|
||||
|
||||
The *build/* directory contains a build script that will scrape the source from the [joyent/node](https://github.com/joyent/node) repo given a specific Node version.
|
||||
221
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/index.js
generated
vendored
Normal file
221
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,221 @@
|
|||
// Copyright Joyent, Inc. and other Node contributors.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||||
// copy of this software and associated documentation files (the
|
||||
// "Software"), to deal in the Software without restriction, including
|
||||
// without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||||
// persons to whom the Software is furnished to do so, subject to the
|
||||
// following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included
|
||||
// in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
var Buffer = require('buffer').Buffer;
|
||||
|
||||
var isBufferEncoding = Buffer.isEncoding
|
||||
|| function(encoding) {
|
||||
switch (encoding && encoding.toLowerCase()) {
|
||||
case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function assertEncoding(encoding) {
|
||||
if (encoding && !isBufferEncoding(encoding)) {
|
||||
throw new Error('Unknown encoding: ' + encoding);
|
||||
}
|
||||
}
|
||||
|
||||
// StringDecoder provides an interface for efficiently splitting a series of
|
||||
// buffers into a series of JS strings without breaking apart multi-byte
|
||||
// characters. CESU-8 is handled as part of the UTF-8 encoding.
|
||||
//
|
||||
// @TODO Handling all encodings inside a single object makes it very difficult
|
||||
// to reason about this code, so it should be split up in the future.
|
||||
// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
|
||||
// points as used by CESU-8.
|
||||
var StringDecoder = exports.StringDecoder = function(encoding) {
|
||||
this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
|
||||
assertEncoding(encoding);
|
||||
switch (this.encoding) {
|
||||
case 'utf8':
|
||||
// CESU-8 represents each of Surrogate Pair by 3-bytes
|
||||
this.surrogateSize = 3;
|
||||
break;
|
||||
case 'ucs2':
|
||||
case 'utf16le':
|
||||
// UTF-16 represents each of Surrogate Pair by 2-bytes
|
||||
this.surrogateSize = 2;
|
||||
this.detectIncompleteChar = utf16DetectIncompleteChar;
|
||||
break;
|
||||
case 'base64':
|
||||
// Base-64 stores 3 bytes in 4 chars, and pads the remainder.
|
||||
this.surrogateSize = 3;
|
||||
this.detectIncompleteChar = base64DetectIncompleteChar;
|
||||
break;
|
||||
default:
|
||||
this.write = passThroughWrite;
|
||||
return;
|
||||
}
|
||||
|
||||
// Enough space to store all bytes of a single character. UTF-8 needs 4
|
||||
// bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
|
||||
this.charBuffer = new Buffer(6);
|
||||
// Number of bytes received for the current incomplete multi-byte character.
|
||||
this.charReceived = 0;
|
||||
// Number of bytes expected for the current incomplete multi-byte character.
|
||||
this.charLength = 0;
|
||||
};
|
||||
|
||||
|
||||
// write decodes the given buffer and returns it as JS string that is
|
||||
// guaranteed to not contain any partial multi-byte characters. Any partial
|
||||
// character found at the end of the buffer is buffered up, and will be
|
||||
// returned when calling write again with the remaining bytes.
|
||||
//
|
||||
// Note: Converting a Buffer containing an orphan surrogate to a String
|
||||
// currently works, but converting a String to a Buffer (via `new Buffer`, or
|
||||
// Buffer#write) will replace incomplete surrogates with the unicode
|
||||
// replacement character. See https://codereview.chromium.org/121173009/ .
|
||||
StringDecoder.prototype.write = function(buffer) {
|
||||
var charStr = '';
|
||||
// if our last write ended with an incomplete multibyte character
|
||||
while (this.charLength) {
|
||||
// determine how many remaining bytes this buffer has to offer for this char
|
||||
var available = (buffer.length >= this.charLength - this.charReceived) ?
|
||||
this.charLength - this.charReceived :
|
||||
buffer.length;
|
||||
|
||||
// add the new bytes to the char buffer
|
||||
buffer.copy(this.charBuffer, this.charReceived, 0, available);
|
||||
this.charReceived += available;
|
||||
|
||||
if (this.charReceived < this.charLength) {
|
||||
// still not enough chars in this buffer? wait for more ...
|
||||
return '';
|
||||
}
|
||||
|
||||
// remove bytes belonging to the current character from the buffer
|
||||
buffer = buffer.slice(available, buffer.length);
|
||||
|
||||
// get the character that was split
|
||||
charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
|
||||
|
||||
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
|
||||
var charCode = charStr.charCodeAt(charStr.length - 1);
|
||||
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
|
||||
this.charLength += this.surrogateSize;
|
||||
charStr = '';
|
||||
continue;
|
||||
}
|
||||
this.charReceived = this.charLength = 0;
|
||||
|
||||
// if there are no more bytes in this buffer, just emit our char
|
||||
if (buffer.length === 0) {
|
||||
return charStr;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// determine and set charLength / charReceived
|
||||
this.detectIncompleteChar(buffer);
|
||||
|
||||
var end = buffer.length;
|
||||
if (this.charLength) {
|
||||
// buffer the incomplete character bytes we got
|
||||
buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
|
||||
end -= this.charReceived;
|
||||
}
|
||||
|
||||
charStr += buffer.toString(this.encoding, 0, end);
|
||||
|
||||
var end = charStr.length - 1;
|
||||
var charCode = charStr.charCodeAt(end);
|
||||
// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
|
||||
if (charCode >= 0xD800 && charCode <= 0xDBFF) {
|
||||
var size = this.surrogateSize;
|
||||
this.charLength += size;
|
||||
this.charReceived += size;
|
||||
this.charBuffer.copy(this.charBuffer, size, 0, size);
|
||||
buffer.copy(this.charBuffer, 0, 0, size);
|
||||
return charStr.substring(0, end);
|
||||
}
|
||||
|
||||
// or just emit the charStr
|
||||
return charStr;
|
||||
};
|
||||
|
||||
// detectIncompleteChar determines if there is an incomplete UTF-8 character at
|
||||
// the end of the given buffer. If so, it sets this.charLength to the byte
|
||||
// length that character, and sets this.charReceived to the number of bytes
|
||||
// that are available for this character.
|
||||
StringDecoder.prototype.detectIncompleteChar = function(buffer) {
|
||||
// determine how many bytes we have to check at the end of this buffer
|
||||
var i = (buffer.length >= 3) ? 3 : buffer.length;
|
||||
|
||||
// Figure out if one of the last i bytes of our buffer announces an
|
||||
// incomplete char.
|
||||
for (; i > 0; i--) {
|
||||
var c = buffer[buffer.length - i];
|
||||
|
||||
// See http://en.wikipedia.org/wiki/UTF-8#Description
|
||||
|
||||
// 110XXXXX
|
||||
if (i == 1 && c >> 5 == 0x06) {
|
||||
this.charLength = 2;
|
||||
break;
|
||||
}
|
||||
|
||||
// 1110XXXX
|
||||
if (i <= 2 && c >> 4 == 0x0E) {
|
||||
this.charLength = 3;
|
||||
break;
|
||||
}
|
||||
|
||||
// 11110XXX
|
||||
if (i <= 3 && c >> 3 == 0x1E) {
|
||||
this.charLength = 4;
|
||||
break;
|
||||
}
|
||||
}
|
||||
this.charReceived = i;
|
||||
};
|
||||
|
||||
StringDecoder.prototype.end = function(buffer) {
|
||||
var res = '';
|
||||
if (buffer && buffer.length)
|
||||
res = this.write(buffer);
|
||||
|
||||
if (this.charReceived) {
|
||||
var cr = this.charReceived;
|
||||
var buf = this.charBuffer;
|
||||
var enc = this.encoding;
|
||||
res += buf.slice(0, cr).toString(enc);
|
||||
}
|
||||
|
||||
return res;
|
||||
};
|
||||
|
||||
function passThroughWrite(buffer) {
|
||||
return buffer.toString(this.encoding);
|
||||
}
|
||||
|
||||
function utf16DetectIncompleteChar(buffer) {
|
||||
this.charReceived = buffer.length % 2;
|
||||
this.charLength = this.charReceived ? 2 : 0;
|
||||
}
|
||||
|
||||
function base64DetectIncompleteChar(buffer) {
|
||||
this.charReceived = buffer.length % 3;
|
||||
this.charLength = this.charReceived ? 3 : 0;
|
||||
}
|
||||
54
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/package.json
generated
vendored
Normal file
54
node_modules/mysql/node_modules/readable-stream/node_modules/string_decoder/package.json
generated
vendored
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
{
|
||||
"name": "string_decoder",
|
||||
"version": "0.10.31",
|
||||
"description": "The string_decoder module from Node core",
|
||||
"main": "index.js",
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"tap": "~0.4.8"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "tap test/simple/*.js"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/rvagg/string_decoder.git"
|
||||
},
|
||||
"homepage": "https://github.com/rvagg/string_decoder",
|
||||
"keywords": [
|
||||
"string",
|
||||
"decoder",
|
||||
"browser",
|
||||
"browserify"
|
||||
],
|
||||
"license": "MIT",
|
||||
"gitHead": "d46d4fd87cf1d06e031c23f1ba170ca7d4ade9a0",
|
||||
"bugs": {
|
||||
"url": "https://github.com/rvagg/string_decoder/issues"
|
||||
},
|
||||
"_id": "string_decoder@0.10.31",
|
||||
"_shasum": "62e203bc41766c6c28c9fc84301dab1c5310fa94",
|
||||
"_from": "string_decoder@>=0.10.0 <0.11.0",
|
||||
"_npmVersion": "1.4.23",
|
||||
"_npmUser": {
|
||||
"name": "rvagg",
|
||||
"email": "rod@vagg.org"
|
||||
},
|
||||
"maintainers": [
|
||||
{
|
||||
"name": "substack",
|
||||
"email": "mail@substack.net"
|
||||
},
|
||||
{
|
||||
"name": "rvagg",
|
||||
"email": "rod@vagg.org"
|
||||
}
|
||||
],
|
||||
"dist": {
|
||||
"shasum": "62e203bc41766c6c28c9fc84301dab1c5310fa94",
|
||||
"tarball": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz"
|
||||
},
|
||||
"directories": {},
|
||||
"_resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
|
||||
"readme": "ERROR: No README data found!"
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
{
|
||||
"name": "readable-stream",
|
||||
"version": "1.1.13",
|
||||
"description": "Streams3, a user-land copy of the stream library from Node.js v0.11.x",
|
||||
"main": "readable.js",
|
||||
"dependencies": {
|
||||
"core-util-is": "~1.0.0",
|
||||
"isarray": "0.0.1",
|
||||
"string_decoder": "~0.10.x",
|
||||
"inherits": "~2.0.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"tap": "~0.2.6"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "tap test/simple/*.js"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/isaacs/readable-stream"
|
||||
},
|
||||
"keywords": [
|
||||
"readable",
|
||||
"stream",
|
||||
"pipe"
|
||||
],
|
||||
"browser": {
|
||||
"util": false
|
||||
},
|
||||
"author": {
|
||||
"name": "Isaac Z. Schlueter",
|
||||
"email": "i@izs.me",
|
||||
"url": "http://blog.izs.me/"
|
||||
},
|
||||
"license": "MIT",
|
||||
"gitHead": "3b672fd7ae92acf5b4ffdbabf74b372a0a56b051",
|
||||
"bugs": {
|
||||
"url": "https://github.com/isaacs/readable-stream/issues"
|
||||
},
|
||||
"homepage": "https://github.com/isaacs/readable-stream",
|
||||
"_id": "readable-stream@1.1.13",
|
||||
"_shasum": "f6eef764f514c89e2b9e23146a75ba106756d23e",
|
||||
"_from": "readable-stream@>=1.1.13 <1.2.0",
|
||||
"_npmVersion": "1.4.23",
|
||||
"_npmUser": {
|
||||
"name": "rvagg",
|
||||
"email": "rod@vagg.org"
|
||||
},
|
||||
"maintainers": [
|
||||
{
|
||||
"name": "isaacs",
|
||||
"email": "i@izs.me"
|
||||
},
|
||||
{
|
||||
"name": "tootallnate",
|
||||
"email": "nathan@tootallnate.net"
|
||||
},
|
||||
{
|
||||
"name": "rvagg",
|
||||
"email": "rod@vagg.org"
|
||||
}
|
||||
],
|
||||
"dist": {
|
||||
"shasum": "f6eef764f514c89e2b9e23146a75ba106756d23e",
|
||||
"tarball": "http://registry.npmjs.org/readable-stream/-/readable-stream-1.1.13.tgz"
|
||||
},
|
||||
"directories": {},
|
||||
"_resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.13.tgz",
|
||||
"readme": "ERROR: No README data found!"
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
module.exports = require("./lib/_stream_passthrough.js")
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
exports = module.exports = require('./lib/_stream_readable.js');
|
||||
exports.Stream = require('stream');
|
||||
exports.Readable = exports;
|
||||
exports.Writable = require('./lib/_stream_writable.js');
|
||||
exports.Duplex = require('./lib/_stream_duplex.js');
|
||||
exports.Transform = require('./lib/_stream_transform.js');
|
||||
exports.PassThrough = require('./lib/_stream_passthrough.js');
|
||||
|
|
@ -0,0 +1 @@
|
|||
module.exports = require("./lib/_stream_transform.js")
|
||||
|
|
@ -0,0 +1 @@
|
|||
module.exports = require("./lib/_stream_writable.js")
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
*.un~
|
||||
node_modules/
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Copyright (c) 2012 Felix Geisendörfer (felix@debuggable.com) and contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue