elyse-help 1.1.9

package/backend/node_modules/mysql/lib/PoolCluster.js

@@ -0,0 +1,288 @@
+var Pool          = require('./Pool');
+var PoolConfig    = require('./PoolConfig');
+var PoolNamespace = require('./PoolNamespace');
+var PoolSelector  = require('./PoolSelector');
+var Util          = require('util');
+var EventEmitter  = require('events').EventEmitter;
+
+module.exports = PoolCluster;
+
+/**
+ * PoolCluster
+ * @constructor
+ * @param {object} [config] The pool cluster configuration
+ * @public
+ */
+function PoolCluster(config) {
+  EventEmitter.call(this);
+
+  config = config || {};
+  this._canRetry = typeof config.canRetry === 'undefined' ? true : config.canRetry;
+  this._defaultSelector = config.defaultSelector || 'RR';
+  this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
+  this._restoreNodeTimeout = config.restoreNodeTimeout || 0;
+
+  this._closed = false;
+  this._findCaches = Object.create(null);
+  this._lastId = 0;
+  this._namespaces = Object.create(null);
+  this._nodes = Object.create(null);
+}
+
+Util.inherits(PoolCluster, EventEmitter);
+
+PoolCluster.prototype.add = function add(id, config) {
+  if (this._closed) {
+    throw new Error('PoolCluster is closed.');
+  }
+
+  var nodeId = typeof id === 'object'
+    ? 'CLUSTER::' + (++this._lastId)
+    : String(id);
+
+  if (this._nodes[nodeId] !== undefined) {
+    throw new Error('Node ID "' + nodeId + '" is already defined in PoolCluster.');
+  }
+
+  var poolConfig = typeof id !== 'object'
+    ? new PoolConfig(config)
+    : new PoolConfig(id);
+
+  this._nodes[nodeId] = {
+    id            : nodeId,
+    errorCount    : 0,
+    pool          : new Pool({config: poolConfig}),
+    _offlineUntil : 0
+  };
+
+  this._clearFindCaches();
+};
+
+PoolCluster.prototype.end = function end(callback) {
+  var cb = callback !== undefined
+    ? callback
+    : _cb;
+
+  if (typeof cb !== 'function') {
+    throw TypeError('callback argument must be a function');
+  }
+
+  if (this._closed) {
+    process.nextTick(cb);
+    return;
+  }
+
+  this._closed = true;
+
+  var calledBack   = false;
+  var nodeIds      = Object.keys(this._nodes);
+  var waitingClose = 0;
+
+  function onEnd(err) {
+    if (!calledBack && (err || --waitingClose <= 0)) {
+      calledBack = true;
+      cb(err);
+    }
+  }
+
+  for (var i = 0; i < nodeIds.length; i++) {
+    var nodeId = nodeIds[i];
+    var node = this._nodes[nodeId];
+
+    waitingClose++;
+    node.pool.end(onEnd);
+  }
+
+  if (waitingClose === 0) {
+    process.nextTick(onEnd);
+  }
+};
+
+PoolCluster.prototype.of = function(pattern, selector) {
+  pattern = pattern || '*';
+
+  selector = selector || this._defaultSelector;
+  selector = selector.toUpperCase();
+  if (typeof PoolSelector[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.remove = function remove(pattern) {
+  var foundNodeIds = this._findNodeIds(pattern, true);
+
+  for (var i = 0; i < foundNodeIds.length; i++) {
+    var node = this._getNode(foundNodeIds[i]);
+
+    if (node) {
+      this._removeNode(node);
+    }
+  }
+};
+
+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._clearFindCaches = function _clearFindCaches() {
+  this._findCaches = Object.create(null);
+};
+
+PoolCluster.prototype._decreaseErrorCount = function _decreaseErrorCount(node) {
+  var errorCount = node.errorCount;
+
+  if (errorCount > this._removeNodeErrorCount) {
+    errorCount = this._removeNodeErrorCount;
+  }
+
+  if (errorCount < 1) {
+    errorCount = 1;
+  }
+
+  node.errorCount = errorCount - 1;
+
+  if (node._offlineUntil) {
+    node._offlineUntil = 0;
+    this.emit('online', node.id);
+  }
+};
+
+PoolCluster.prototype._findNodeIds = function _findNodeIds(pattern, includeOffline) {
+  var currentTime  = 0;
+  var foundNodeIds = this._findCaches[pattern];
+
+  if (foundNodeIds === undefined) {
+    var expression = patternRegExp(pattern);
+    var nodeIds    = Object.keys(this._nodes);
+
+    foundNodeIds = nodeIds.filter(function (id) {
+      return id.match(expression);
+    });
+
+    this._findCaches[pattern] = foundNodeIds;
+  }
+
+  if (includeOffline) {
+    return foundNodeIds;
+  }
+
+  return foundNodeIds.filter(function (nodeId) {
+    var node = this._getNode(nodeId);
+
+    if (!node._offlineUntil) {
+      return true;
+    }
+
+    if (!currentTime) {
+      currentTime = getMonotonicMilliseconds();
+    }
+
+    return node._offlineUntil <= currentTime;
+  }, this);
+};
+
+PoolCluster.prototype._getNode = function _getNode(id) {
+  return this._nodes[id] || null;
+};
+
+PoolCluster.prototype._increaseErrorCount = function _increaseErrorCount(node) {
+  var errorCount = ++node.errorCount;
+
+  if (this._removeNodeErrorCount > errorCount) {
+    return;
+  }
+
+  if (this._restoreNodeTimeout > 0) {
+    node._offlineUntil = getMonotonicMilliseconds() + this._restoreNodeTimeout;
+    this.emit('offline', node.id);
+    return;
+  }
+
+  this._removeNode(node);
+  this.emit('remove', node.id);
+};
+
+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._removeNode = function _removeNode(node) {
+  delete this._nodes[node.id];
+
+  this._clearFindCaches();
+
+  node.pool.end(_noop);
+};
+
+function getMonotonicMilliseconds() {
+  var ms;
+
+  if (typeof process.hrtime === 'function') {
+    ms = process.hrtime();
+    ms = ms[0] * 1e3 + ms[1] * 1e-6;
+  } else {
+    ms = process.uptime() * 1000;
+  }
+
+  return Math.floor(ms);
+}
+
+function isRegExp(val) {
+  return typeof val === 'object'
+    && Object.prototype.toString.call(val) === '[object RegExp]';
+}
+
+function patternRegExp(pattern) {
+  if (isRegExp(pattern)) {
+    return pattern;
+  }
+
+  var source = pattern
+    .replace(/([.+?^=!:${}()|\[\]\/\\])/g, '\\$1')
+    .replace(/\*/g, '.*');
+
+  return new RegExp('^' + source + '$');
+}
+
+function _cb(err) {
+  if (err) {
+    throw err;
+  }
+}
+
+function _noop() {}

package/backend/node_modules/mysql/lib/PoolConfig.js

@@ -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;
+};

package/backend/node_modules/mysql/lib/PoolConnection.js

@@ -0,0 +1,65 @@
+var inherits   = require('util').inherits;
+var Connection = require('./Connection');
+var Events     = require('events');
+
+module.exports = PoolConnection;
+inherits(PoolConnection, Connection);
+
+function PoolConnection(pool, options) {
+  Connection.call(this, options);
+  this._pool  = pool;
+
+  // Bind connection to pool domain
+  if (Events.usingDomains) {
+    this.domain = pool.domain;
+  }
+
+  // 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', function (err) {
+    if (err.fatal) {
+      this._removeFromPool();
+    }
+  });
+}
+
+PoolConnection.prototype.release = function release() {
+  var pool = this._pool;
+
+  if (!pool || pool._closed) {
+    return undefined;
+  }
+
+  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 () {
+  Connection.prototype.destroy.apply(this, arguments);
+  this._removeFromPool(this);
+};
+
+PoolConnection.prototype._removeFromPool = function _removeFromPool() {
+  if (!this._pool || this._pool._closed) {
+    return;
+  }
+
+  var pool = this._pool;
+  this._pool = null;
+
+  pool._purgeConnection(this);
+};

package/backend/node_modules/mysql/lib/PoolNamespace.js

@@ -0,0 +1,136 @@
+var Connection   = require('./Connection');
+var PoolSelector = require('./PoolSelector');
+
+module.exports = PoolNamespace;
+
+/**
+ * PoolNamespace
+ * @constructor
+ * @param {PoolCluster} cluster The parent cluster for the namespace
+ * @param {string} pattern The selection pattern to use
+ * @param {string} selector The selector name to use
+ * @public
+ */
+function PoolNamespace(cluster, pattern, selector) {
+  this._cluster = cluster;
+  this._pattern = pattern;
+  this._selector = new PoolSelector[selector]();
+}
+
+PoolNamespace.prototype.getConnection = function(cb) {
+  var clusterNode = this._getClusterNode();
+  var cluster     = this._cluster;
+  var namespace   = this;
+
+  if (clusterNode === null) {
+    var err = null;
+
+    if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
+      err = new Error('Pool does not have online node.');
+      err.code = 'POOL_NONEONLINE';
+    } else {
+      err = new Error('Pool does not exist.');
+      err.code = 'POOL_NOEXIST';
+    }
+
+    cb(err);
+    return;
+  }
+
+  cluster._getConnection(clusterNode, function(err, connection) {
+    var retry = err && cluster._canRetry
+      && cluster._findNodeIds(namespace._pattern).length !== 0;
+
+    if (retry) {
+      namespace.getConnection(cb);
+      return;
+    }
+
+    if (err) {
+      cb(err);
+      return;
+    }
+
+    cb(null, connection);
+  });
+};
+
+PoolNamespace.prototype.query = function (sql, values, cb) {
+  var cluster     = this._cluster;
+  var clusterNode = this._getClusterNode();
+  var query       = Connection.createQuery(sql, values, cb);
+  var namespace   = this;
+
+  if (clusterNode === null) {
+    var err = null;
+
+    if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
+      err = new Error('Pool does not have online node.');
+      err.code = 'POOL_NONEONLINE';
+    } else {
+      err = new Error('Pool does not exist.');
+      err.code = 'POOL_NOEXIST';
+    }
+
+    process.nextTick(function () {
+      query.on('error', function () {});
+      query.end(err);
+    });
+    return query;
+  }
+
+  if (!(typeof sql === 'object' && 'typeCast' in sql)) {
+    query.typeCast = clusterNode.pool.config.connectionConfig.typeCast;
+  }
+
+  if (clusterNode.pool.config.connectionConfig.trace) {
+    // Long stack trace support
+    query._callSite = new Error();
+  }
+
+  cluster._getConnection(clusterNode, function (err, conn) {
+    var retry = err && cluster._canRetry
+      && cluster._findNodeIds(namespace._pattern).length !== 0;
+
+    if (retry) {
+      namespace.query(query);
+      return;
+    }
+
+    if (err) {
+      query.on('error', function () {});
+      query.end(err);
+      return;
+    }
+
+    // Release connection based off event
+    query.once('end', function() {
+      conn.release();
+    });
+
+    conn.query(query);
+  });
+
+  return query;
+};
+
+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;
+};

package/backend/node_modules/mysql/lib/PoolSelector.js

@@ -0,0 +1,31 @@
+
+/**
+ * PoolSelector
+ */
+var PoolSelector = module.exports = {};
+
+PoolSelector.RR = function PoolSelectorRoundRobin() {
+  var index = 0;
+
+  return function(clusterIds) {
+    if (index >= clusterIds.length) {
+      index = 0;
+    }
+
+    var clusterId = clusterIds[index++];
+
+    return clusterId;
+  };
+};
+
+PoolSelector.RANDOM = function PoolSelectorRandom() {
+  return function(clusterIds) {
+    return clusterIds[Math.floor(Math.random() * clusterIds.length)];
+  };
+};
+
+PoolSelector.ORDER = function PoolSelectorOrder() {
+  return function(clusterIds) {
+    return clusterIds[0];
+  };
+};

package/backend/node_modules/mysql/lib/protocol/Auth.js

@@ -0,0 +1,168 @@
+var Buffer = require('safe-buffer').Buffer;
+var Crypto = require('crypto');
+var Auth   = exports;
+
+function auth(name, data, options) {
+  options = options || {};
+
+  switch (name) {
+    case 'mysql_native_password':
+      return Auth.token(options.password, data.slice(0, 20));
+    default:
+      return undefined;
+  }
+}
+Auth.auth = auth;
+
+function sha1(msg) {
+  var hash = Crypto.createHash('sha1');
+  hash.update(msg, 'binary');
+  return hash.digest('binary');
+}
+Auth.sha1 = sha1;
+
+function xor(a, b) {
+  a = Buffer.from(a, 'binary');
+  b = Buffer.from(b, 'binary');
+  var result = Buffer.allocUnsafe(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 Buffer.alloc(0);
+  }
+
+  // password must be in binary format, not utf8
+  var stage1 = sha1((Buffer.from(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];
+  var add    = 7;
+  var nr2    = [0x1234, 0x5671];
+  var result = Buffer.alloc(8);
+
+  if (typeof password === 'string'){
+    password = Buffer.from(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) {
+  if (!password) {
+    return Buffer.alloc(0);
+  }
+
+  var to          = Buffer.allocUnsafe(8);
+  var hashPass    = this.hashPassword(password);
+  var hashMessage = this.hashPassword(message.slice(0, 8));
+  var seed1       = this.int32Read(hashPass, 0) ^ this.int32Read(hashMessage, 0);
+  var seed2       = this.int32Read(hashPass, 4) ^ this.int32Read(hashMessage, 4);
+  var 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.xor32 = function(a, b){
+  return [a[0] ^ b[0], a[1] ^ b[1]];
+};
+
+Auth.add32 = function(a, b){
+  var w1 = a[1] + b[1];
+  var 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];
+  var 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;
+  var 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]);
+};