ali-skills 0.0.21 → 0.0.23

package/node_modules/cluster-client/lib/protocol/packet.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const Constant = require('../const');
+const byteBuffer = require('./byte_buffer');
+const Long = require('long');
+
+/**
+ * 0         1         2                   4                                                                              12
+ * +---------+---------+-------------------+-------------------------------------------------------------------------------+
+ * | version | req/res |      reserved     |                                 request id                                    |
+ * +---------------------------------------+---------------------------------------+---------------------------------------+
+ * |                timeout                |       connection object length        |       application object length       |
+ * +---------------------------------------+-------------------+-------------------+---------------------------------------+
+ * |         conn object (JSON format)  ...                    |                        app object                         |
+ * +-----------------------------------------------------------+                                                           |
+ * |                                                                  ...                                                  |
+ * +-----------------------------------------------------------------------------------------------------------------------+
+ *
+ * packet protocol:
+ *   (1B): protocol version
+ *   (1B): req/res
+ *   (2B): reserved
+ *   (8B): request id
+ *   (4B): timeout
+ *   (4B): connection object length
+ *   (4B): application object length
+ *   --------------------------------
+ *   conn object (JSON format)
+ *   --------------------------------
+ *   app object
+ */
+class Packet {
+  /**
+   * cluster protocol packet
+   *
+   * @param {Object} options
+   *   - @param {Number} id - The identifier
+   *   - @param {Number} type - req/res
+   *   - @param {Number} timeout - The timeout
+   *   - @param {Object} connObj - connection object
+   *   - @param {Buffer} data - app data
+   * @class
+   */
+  constructor(options) {
+    this.id = options.id;
+    this.type = options.type;
+    this.timeout = options.timeout;
+    this.connObj = options.connObj;
+    this.data = typeof options.data === 'string' ? Buffer.from(options.data) : options.data;
+  }
+
+  get isResponse() {
+    return this.type === Constant.RESPONSE;
+  }
+
+  encode() {
+    const header = Buffer.from([ Constant.VERSION, this.type, 0, 0 ]);
+    const connBuf = Buffer.from(JSON.stringify(this.connObj));
+    const appLen = this.data ? this.data.length : 0;
+
+    byteBuffer.reset();
+    byteBuffer.put(header);
+    byteBuffer.putLong(this.id);
+    byteBuffer.putInt(this.timeout);
+    byteBuffer.putInt(connBuf.length);
+    byteBuffer.putInt(appLen);
+    byteBuffer.put(connBuf);
+    if (appLen) {
+      byteBuffer.put(this.data);
+    }
+    return byteBuffer.array();
+  }
+
+  static decode(buf) {
+    const isResponse = buf[1] === Constant.RESPONSE;
+    const id = new Long(
+      buf.readInt32BE(8), // low, high
+      buf.readInt32BE(4)
+    ).toNumber();
+    const timeout = buf.readInt32BE(12);
+    const connLength = buf.readInt32BE(16);
+    const appLength = buf.readInt32BE(20);
+
+    const connBuf = Buffer.alloc(connLength);
+    buf.copy(connBuf, 0, 24, 24 + connLength);
+    const connObj = JSON.parse(connBuf);
+
+    let data;
+    if (appLength) {
+      data = Buffer.alloc(appLength);
+      buf.copy(data, 0, 24 + connLength, 24 + connLength + appLength);
+    }
+    return {
+      id,
+      isResponse,
+      timeout,
+      connObj,
+      data,
+    };
+  }
+}
+
+module.exports = Packet;

package/node_modules/cluster-client/lib/protocol/request.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const utils = require('../utils');
+const Packet = require('./packet');
+const Constant = require('../const');
+
+class Request extends Packet {
+  constructor(options) {
+    const id = utils.nextId();
+    super(Object.assign({
+      id,
+      type: Constant.REQUEST,
+    }, options));
+  }
+}
+
+module.exports = Request;

package/node_modules/cluster-client/lib/protocol/response.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const Packet = require('./packet');
+const Constant = require('../const');
+
+class Response extends Packet {
+  constructor(options) {
+    super(Object.assign({
+      type: Constant.RESPONSE,
+    }, options));
+  }
+}
+
+module.exports = Response;

package/node_modules/cluster-client/lib/server.js

@@ -0,0 +1,256 @@
+const debug = require('util').debuglog('cluster-client:lib:server');
+const net = require('net');
+const Base = require('sdk-base');
+const { sleep } = require('./utils');
+const Packet = require('./protocol/packet');
+
+// share memory in current process
+let serverMap;
+if (global.serverMap) {
+  serverMap = global.serverMap;
+} else {
+  global.serverMap = serverMap = new Map();
+}
+let typeSet;
+if (global.typeSet) {
+  typeSet = global.typeSet;
+} else {
+  global.typeSet = typeSet = new Set();
+}
+
+function claimServer(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen({
+      port,
+      host: '127.0.0.1',
+      // When exclusive is true, the handle is not shared, and attempted port sharing results in an error.
+      exclusive: true,
+    });
+
+    function onError(err) {
+      debug('listen %s error: %s', port, err);
+      reject(err);
+    }
+
+    server.on('error', onError);
+    server.on('listening', () => {
+      server.removeListener('error', onError);
+      debug('listen %s success', port);
+      resolve(server);
+    });
+  });
+}
+
+function tryToConnect(port) {
+  return new Promise(resolve => {
+    debug('try to connecting port:%j', port);
+    const socket = net.connect(port, '127.0.0.1');
+    let success = false;
+    socket.on('connect', () => {
+      success = true;
+      resolve(true);
+      // disconnect
+      socket.end();
+      debug('test connected %s success, end now', port);
+    });
+    socket.on('error', err => {
+      debug('test connect %s error: %s, success: %s', port, err, success);
+      // if success before, ignore it
+      if (success) return;
+      resolve(false);
+    });
+  });
+}
+
+class ClusterServer extends Base {
+  /**
+   * Manage all TCP Connections，assign them to proper channel
+   *
+   * @class
+   * @param {Object} options
+   * @param {net.Server} options.server - the server
+   * @param {Number} options.port - the port
+   * @param {Number} [options.maxListeners] maximum of listeners, default is 20
+   */
+  constructor(options) {
+    super();
+    debug('new ClusterServer(%j)', options);
+    this._sockets = new Map();
+    this._server = options.server;
+    this._port = options.port;
+    this._isClosed = false;
+    this._server.on('connection', socket => this._handleSocket(socket));
+    this._server.once('close', () => {
+      this._isClosed = true;
+      serverMap.delete(this._port);
+      this.emit('close');
+    });
+    this._server.once('error', err => {
+      this.emit('error', err);
+    });
+    this.setMaxListeners(options.maxListeners || 20);
+  }
+
+  get isClosed() {
+    return this._isClosed;
+  }
+
+  close() {
+    return new Promise((resolve, reject) => {
+      if (this.isClosed) return resolve();
+
+      this._server.close(err => {
+        if (err) return reject(err);
+        resolve();
+      });
+
+      // sockets must be closed manually, otherwise server.close callback will never be called
+      for (const socket of this._sockets.values()) {
+        socket.destroy();
+      }
+    });
+  }
+
+  _handleSocket(socket) {
+    let header;
+    let bodyLength;
+    let body;
+    const server = this;
+    const key = socket.remotePort;
+    this._sockets.set(key, socket);
+
+    function onReadable() {
+      if (!header) {
+        header = socket.read(24);
+        if (!header) {
+          return;
+        }
+      }
+      if (!bodyLength) {
+        bodyLength = header.readInt32BE(16) + header.readInt32BE(20);
+      }
+      body = socket.read(bodyLength);
+      if (!body) {
+        return;
+      }
+      // first packet to register to channel
+      const packet = Packet.decode(Buffer.concat([ header, body ], 24 + bodyLength));
+      header = null;
+      bodyLength = null;
+      body = null;
+      if (packet.connObj && packet.connObj.type === 'register_channel') {
+        const channelName = packet.connObj.channelName;
+        const eventKey = `${channelName}_connection`;
+
+        // that means leader already there
+        if (server.listenerCount(eventKey)) {
+          socket.removeListener('readable', onReadable);
+          // assign to proper channel
+          debug('new %s_connection %s connected', channelName, socket.remotePort);
+          server.emit(`${channelName}_connection`, socket, packet);
+        }
+      }
+    }
+
+    socket.on('readable', onReadable);
+    socket.once('close', () => {
+      debug('socket %s close', key);
+      this._sockets.delete(key);
+    });
+    debug('new socket %s from follower', socket.remotePort);
+  }
+
+  /**
+   * Occupy the port
+   *
+   * @param {String} name - the client name
+   * @param {Number} port - the port
+   * @param {Object} [options] - create instance options
+   * @param {Number} [options.maxListeners] maximum of listeners, default is 20
+   * @return {ClusterServer} server
+   */
+  static async create(name, port, options) {
+    const key = `${name}@${port}`;
+    if (typeof port !== 'number') {
+      throw new Error(`[ClusterClient.server.create:${name}] port should be a number, but got ${JSON.stringify(port)}`);
+    }
+    let instance = serverMap.get(port);
+    if (instance && !instance.isClosed) {
+      debug('create %j instance exists', key);
+      if (typeSet.has(key)) {
+        debug('%j instance in typeSet', key);
+        return null;
+      }
+      typeSet.add(key);
+      return instance;
+    }
+    debug('create %j instance not exists, try to create a new one with port: %j', key, port);
+    // compete for the local port, if got => leader, otherwise follower
+    try {
+      const server = await claimServer(port);
+      instance = new ClusterServer({ server, port, ...options });
+      typeSet.add(key);
+      serverMap.set(port, instance);
+      return instance;
+    } catch (err) {
+      debug('create %j instance error: %s', key, err);
+      // if exception, that mean compete for port failed, then double check
+      instance = serverMap.get(port);
+      if (instance && !instance.isClosed) {
+        if (typeSet.has(key)) {
+          return null;
+        }
+        typeSet.add(key);
+        return instance;
+      }
+      return null;
+    }
+  }
+
+  static async close(name, server) {
+    const port = server._port;
+
+    // remove from typeSet, so other client can occupy
+    typeSet.delete(`${name}@${port}`);
+
+    let listening = false;
+    for (const key of typeSet.values()) {
+      if (key.endsWith(`@${port}`)) {
+        listening = true;
+        break;
+      }
+    }
+
+    // close server if no one is listening on this port any more
+    if (!listening) {
+      const server = serverMap.get(port);
+      if (server) await server.close();
+    }
+  }
+
+  /**
+   * Wait for Leader Startup
+   *
+   * @param {Number} port - the port
+   * @param {Number} timeout - the max wait time
+   * @return {void}
+   */
+  static async waitFor(port, timeout) {
+    const start = Date.now();
+    let connect = false;
+    while (!connect) {
+      connect = await tryToConnect(port);
+
+      // if timeout, throw error
+      if (Date.now() - start > timeout) {
+        throw new Error(`[ClusterClient] leader does not be active in ${timeout}ms on port:${port}`);
+      }
+      if (!connect) {
+        await sleep(3000);
+      }
+    }
+  }
+}
+
+module.exports = ClusterServer;

package/node_modules/cluster-client/lib/symbol.js

@@ -0,0 +1,20 @@
+'use strict';
+
+exports.init = Symbol.for('ClusterClient#init');
+exports.logger = Symbol.for('ClusterClient#logger');
+exports.isReady = Symbol.for('ClusterClient#isReady');
+exports.innerClient = Symbol.for('ClusterClient#innerClient');
+exports.subscribe = Symbol.for('ClusterClient#subscribe');
+exports.unSubscribe = Symbol.for('ClusterClient#unSubscribe');
+exports.publish = Symbol.for('ClusterClient#publish');
+exports.invoke = Symbol.for('ClusterClient#invoke');
+exports.subInfo = Symbol.for('ClusterClient#subInfo');
+exports.pubInfo = Symbol.for('ClusterClient#pubInfo');
+exports.closeHandler = Symbol.for('ClusterClient#closeHandler');
+exports.close = Symbol.for('ClusterClient#close');
+exports.subscribeMethodName = Symbol.for('ClusterClient#subscribeMethodName');
+exports.unSubscribeMethodName = Symbol.for('ClusterClient#unSubscribeMethodName');
+exports.publishMethodName = Symbol.for('ClusterClient#publishMethodName');
+exports.closeByUser = Symbol.for('ClusterClient#closeByUser');
+exports.singleMode = Symbol.for('ClusterClient#singleMode');
+exports.createClient = Symbol.for('ClusterClient#createClient');

package/node_modules/cluster-client/lib/utils.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const co = require('co');
+const is = require('is-type-of');
+const stringify = require('json-stringify-safe');
+
+const MAX_REQUEST_ID = Math.pow(2, 30); // avoid write big integer
+const empty = () => {};
+
+let id = 0;
+
+function nextId() {
+  id += 1;
+  if (id >= MAX_REQUEST_ID) {
+    id = 1;
+  }
+  return id;
+}
+
+/**
+ * generate requestId
+ *
+ * @return {Number} requestId
+ */
+exports.nextId = nextId;
+
+// for unittest
+exports.setId = val => {
+  id = val;
+};
+
+/**
+ * event delegate
+ *
+ * @param {EventEmitter} from - from object
+ * @param {EventEmitter} to - to object
+ * @return {void}
+ */
+exports.delegateEvents = (from, to) => {
+  // ignore the sdk-base defaultErrorHandler
+  // https://github.com/node-modules/sdk-base/blob/master/index.js#L131
+  if (from.listeners('error').length <= 1) {
+    from.on('error', empty);
+  }
+
+  from.emit = new Proxy(from.emit, {
+    apply(target, thisArg, args) {
+      target.apply(from, args);
+      to.emit.apply(to, args);
+      return thisArg;
+    },
+  });
+};
+
+function formatKey(reg) {
+  return stringify(reg);
+}
+
+/**
+ * normalize object to string
+ *
+ * @param {Object} reg - reg object
+ * @return {String} key
+ */
+exports.formatKey = formatKey;
+
+/**
+ * call a function, support common function, generator function, or a function returning promise
+ *
+ * @param {Function} fn - common function, generator function, or a function returning promise
+ * @param {Array} args - args as fn() paramaters
+ * @return {*} data returned by fn
+ */
+exports.callFn = async function(fn, args) {
+  args = args || [];
+  if (!is.function(fn)) return;
+  if (is.generatorFunction(fn)) {
+    return await co(function* () {
+      return yield fn(...args);
+    });
+  }
+  const r = fn(...args);
+  if (is.promise(r)) {
+    return await r;
+  }
+  return r;
+};
+
+exports.findMethodName = (descriptors, type) => {
+  for (const method of descriptors.keys()) {
+    const descriptor = descriptors.get(method);
+    if (descriptor.type === 'delegate' && descriptor.to === type) {
+      return method;
+    }
+  }
+  return null;
+};
+
+exports.sleep = ms => {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+};