ali-skills 0.0.21 → 0.0.22

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

@@ -0,0 +1,74 @@
+'use strict';
+
+const cluster = require('./');
+const utils = require('./utils');
+const Base = require('sdk-base');
+const is = require('is-type-of');
+
+class APIClientBase extends Base {
+  constructor(options) {
+    options = options || {};
+    super(options);
+
+    const wrapper = (options.cluster || cluster)(
+      this.DataClient, this.clusterOptions
+    );
+    for (const from in this.delegates) {
+      const to = this.delegates[from];
+      wrapper.delegate(from, to);
+    }
+    this._client = wrapper.create(options);
+    utils.delegateEvents(this._client, this);
+
+    if (!options.initMethod) {
+      this._client.ready(err => {
+        this.ready(err ? err : true);
+      });
+    }
+  }
+
+  get isClusterClientLeader() {
+    return this._client.isClusterClientLeader;
+  }
+
+  close() {
+    if (is.function(this._client.close)) {
+      return this._client.close().then(() => cluster.close(this._client));
+    }
+    return cluster.close(this._client);
+  }
+
+  get DataClient() {
+    /* istanbul ignore  next */
+    throw new Error('[APIClient] DataClient is required');
+  }
+
+  /**
+   * the cluster options
+   *
+   * @property {Object} APIClientBase#clusterOptions
+   */
+  get clusterOptions() {
+    /* istanbul ignore  next */
+    return {};
+  }
+
+  /**
+   * the delegates map
+   *
+   * @example
+   * ---------------------------
+   * delegates => {
+   *    subscribe: 'subscribe',
+   *    foo: 'invoke',
+   * }
+   *
+   * @property {Object} APIClientBase#delegates
+   */
+  get delegates() {
+    /* istanbul ignore  next */
+    return {};
+  }
+}
+
+module.exports = APIClientBase;

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

@@ -0,0 +1,180 @@
+'use strict';
+
+const is = require('is-type-of');
+const Base = require('sdk-base');
+const Packet = require('./protocol/packet');
+const Response = require('./protocol/response');
+
+class Connection extends Base {
+  /**
+   * Socket Connection among Leader and Follower
+   *
+   * @param {Object} options
+   *  - {Socket} socket - the socket instance
+   *  - {Number} responseTimeout - the response timeout
+   *  - {Transcode} transcode - serialze / deserialze methods
+   * @class
+   */
+  constructor(options) {
+    super(options);
+    this._socket = options.socket;
+    this._invokes = new Map();
+    this.key = this._socket.remotePort;
+    this._lastActiveTime = Date.now();
+    this._transcode = options.transcode;
+    this._lastError = null;
+
+    // listen socket events
+    this._socket.on('readable', () => { this._handleReadable(); });
+    this._socket.on('error', err => { this._handleSocketError(err); });
+    this._socket.on('close', () => { this._handleClose(); });
+
+    // try read data from buffer at first
+    this._handleReadable();
+  }
+
+  get isOk() {
+    return this._socket && this._socket.writable;
+  }
+
+  get logger() {
+    return this.options.logger;
+  }
+
+  get lastActiveTime() {
+    return this._lastActiveTime;
+  }
+
+  set lastActiveTime(val) {
+    this._lastActiveTime = val;
+  }
+
+  /**
+   * send packet
+   *
+   * @param {Packet} packet - the packet
+   * @param {Function} [callback] - callback function
+   * @return {void}
+   */
+  send(packet, callback) {
+    this._write(packet.encode());
+    if (!packet.isResponse) {
+      const id = packet.id;
+      const timeout = packet.timeout;
+      this._invokes.set(id, {
+        id,
+        timer: setTimeout(() => {
+          const err = new Error(`[ClusterClient] no response in ${timeout}ms, remotePort#${this.key}`);
+          err.name = 'ClusterConnectionResponseTimeoutError';
+          callback(err, timeout);
+          this._invokes.delete(id);
+        }, timeout),
+        callback,
+      });
+    }
+  }
+
+  close(err) {
+    if (!this._socket) {
+      return Promise.resolve();
+    }
+    this._socket.destroy(err);
+    return this.await('close');
+  }
+
+  _handleReadable() {
+    try {
+      let remaining = false;
+      do {
+        remaining = this._readPacket();
+      }
+      while (remaining);
+    } catch (err) {
+      this.close(err);
+    }
+  }
+
+  _handleSocketError(err) {
+    this._lastError = err;
+    if (err.code === 'ECONNRESET') {
+      this.logger.warn('[ClusterClient:Connection] socket is closed by other side while there were still unhandled data in the socket buffer');
+    } else {
+      this.emit('error', err);
+    }
+  }
+
+  _handleClose() {
+    this._cleanInvokes(this._lastError);
+    this.emit('close');
+  }
+
+  _cleanInvokes(err) {
+    if (!err) {
+      err = new Error('The socket was closed.');
+      err.name = 'ClusterSocketCloseError';
+    }
+    for (const req of this._invokes.values()) {
+      clearTimeout(req.timer);
+      req.callback(err);
+    }
+    this._invokes.clear();
+  }
+
+  _read(n) {
+    return this._socket.read(n);
+  }
+
+  _write(bytes) {
+    if (!this.isOk) {
+      return false;
+    }
+    return this._socket.write(bytes);
+  }
+
+  _getHeader() {
+    return this._read(24);
+  }
+
+  _getBodyLength(header) {
+    return header.readInt32BE(16) + header.readInt32BE(20);
+  }
+
+  _readPacket() {
+    if (is.nullOrUndefined(this._bodyLength)) {
+      this._header = this._getHeader();
+      if (!this._header) {
+        return false;
+      }
+      this._bodyLength = this._getBodyLength(this._header);
+    }
+
+    let body;
+    // body may be emtry
+    if (this._bodyLength > 0) {
+      body = this._read(this._bodyLength);
+      if (!body) {
+        return false;
+      }
+    }
+    this._bodyLength = null;
+    const packet = Packet.decode(Buffer.concat([ this._header, body ]));
+    const id = packet.id;
+
+    if (packet.isResponse) {
+      const info = this._invokes.get(id);
+      if (info) {
+        clearTimeout(info.timer);
+        info.callback(null, packet.data);
+        this._invokes.delete(id);
+      }
+    } else {
+      process.nextTick(() => this.emit('request', packet, new Response({
+        id,
+        timeout: packet.timeout,
+      })));
+    }
+    return true;
+  }
+}
+
+module.exports = Connection;

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

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.VERSION = 1;
+exports.REQUEST = 0;
+exports.RESPONSE = 1;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+const { Logger, ConsoleTransport } = require('egg-logger');
+const { consoleFormatter } = require('egg-logger/lib/utils');
+const logger = new Logger();
+logger.set('console', new ConsoleTransport({
+  level: 'INFO',
+  formatter: consoleFormatter,
+}));
+
+module.exports = logger;

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

@@ -0,0 +1,6 @@
+'use strict';
+
+const S_JSON = require('serialize-json');
+
+exports.encode = S_JSON.encode;
+exports.decode = S_JSON.decode;

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

@@ -0,0 +1,331 @@
+'use strict';
+
+const debug = require('util').debuglog('cluster-client#follower');
+const is = require('is-type-of');
+const Base = require('tcp-base');
+const Packet = require('./protocol/packet');
+const Request = require('./protocol/request');
+const Response = require('./protocol/response');
+
+class Follower extends Base {
+  /**
+   * "Fake" Client, forward request to leader
+   *
+   * @param {Object} options
+   *  - {Number} port - the port
+   *  - {Map} descriptors - interface descriptors
+   *  - {Transcode} transcode - serialze / deserialze methods
+   *  - {Number} responseTimeout - the timeout
+   *  - {Number} subscribeTimeout - the first subscribe callback timeout
+   * @class
+   */
+  constructor(options) {
+    // local address
+    options.host = '127.0.0.1';
+    super(options);
+    this._publishMethodName = this._findMethodName('publish');
+    this._subInfo = new Set();
+    this._subData = new Map();
+    this._transcode = options.transcode;
+    this._closeByUser = false;
+    this._subscribeTimeoutListeners = new Map();
+
+    this.on('request', req => this._handleRequest(req));
+    // avoid warning message
+    this.setMaxListeners(100);
+  }
+  get isLeader() {
+    return false;
+  }
+
+  get logger() {
+    return this.options.logger;
+  }
+
+  get heartBeatPacket() {
+    const heartbeat = new Request({
+      connObj: {
+        type: 'heartbeat',
+      },
+      timeout: this.options.responseTimeout,
+    });
+    return heartbeat.encode();
+  }
+
+  getHeader() {
+    return this.read(24);
+  }
+
+  getBodyLength(header) {
+    return header.readInt32BE(16) + header.readInt32BE(20);
+  }
+
+  close(err) {
+    this._closeByUser = true;
+    return super.close(err);
+  }
+
+  decode(body, header) {
+    const buf = Buffer.concat([ header, body ]);
+    const packet = Packet.decode(buf);
+    const connObj = packet.connObj;
+    if (connObj && connObj.type === 'invoke_result') {
+      let data;
+      if (packet.data) {
+        data = this.options.transcode.decode(packet.data);
+      }
+      if (connObj.success) {
+        return {
+          id: packet.id,
+          isResponse: packet.isResponse,
+          data,
+        };
+      }
+      const error = new Error(data.message);
+      Object.assign(error, data);
+      return {
+        id: packet.id,
+        isResponse: packet.isResponse,
+        error,
+      };
+    }
+    return {
+      id: packet.id,
+      isResponse: packet.isResponse,
+      connObj: packet.connObj,
+      data: packet.data,
+    };
+  }
+
+  send(...args) {
+    // just ignore after close
+    if (this._closeByUser) {
+      return;
+    }
+    return super.send(...args);
+  }
+
+  formatKey(reg) {
+    return '$$inner$$__' + this.options.formatKey(reg);
+  }
+
+  _clearSubscribeTimeout(key) {
+    if (!this._subscribeTimeoutListeners.has(key)) {
+      return;
+    }
+    const timeout = this._subscribeTimeoutListeners.get(key);
+    clearTimeout(timeout);
+    this._subscribeTimeoutListeners.delete(key);
+  }
+
+  _setSubscribeTimeout(key) {
+    this._clearSubscribeTimeout(key);
+    const start = Date.now();
+    const subscribeTimeout = this.options.subscribeTimeout;
+    const timeout = setTimeout(() => {
+      const error = new Error(`subscribe timeout for ${key}, cost: ${Date.now() - start}ms, expect is ${subscribeTimeout}ms`);
+      this.emit('error', error);
+    }, subscribeTimeout);
+    this._subscribeTimeoutListeners.set(key, timeout);
+  }
+
+  _listenSubscribeTimeout(key) {
+    this._setSubscribeTimeout(key);
+    const dataListener = () => {
+      this.removeListener(key, dataListener);
+      this._clearSubscribeTimeout(key);
+    };
+    this.on(key, dataListener);
+  }
+
+  subscribe(reg, listener) {
+    const key = this.formatKey(reg);
+    this.on(key, listener);
+    if (this.options.subscribeTimeout && !this._subData.has(key)) {
+      this._listenSubscribeTimeout(key);
+    }
+
+    // no need duplicate subscribe
+    if (!this._subInfo.has(key)) {
+      debug('[Follower:%s] subscribe %j for first time', this.options.name, reg);
+      const req = new Request({
+        connObj: { type: 'subscribe', key, reg },
+        timeout: this.options.responseTimeout,
+      });
+
+      // send subscription
+      this.send({
+        id: req.id,
+        oneway: true,
+        data: req.encode(),
+        tips: `subscribe key: ${key}`,
+      });
+      this._subInfo.add(key);
+    } else if (this._subData.has(key)) {
+      debug('[Follower:%s] subscribe %j', this.options.name, reg);
+      process.nextTick(() => {
+        listener(this._subData.get(key));
+      });
+    }
+    return this;
+  }
+
+  unSubscribe(reg, listener) {
+    const key = this.formatKey(reg);
+    if (listener) {
+      this.removeListener(key, listener);
+    } else {
+      this.removeAllListeners(key);
+    }
+    if (this.listeners(key).length === 0) {
+      debug('[Follower:%s] no more subscriber for %j, send unSubscribe req to leader', this.options.name, reg);
+      this._subInfo.delete(key);
+
+      const req = new Request({
+        connObj: { type: 'unSubscribe', key, reg },
+        timeout: this.options.responseTimeout,
+      });
+      // send subscription
+      this.send({
+        id: req.id,
+        oneway: true,
+        data: req.encode(),
+        tips: `unSubscribe key ${key}`,
+      });
+    }
+  }
+
+  publish(reg) {
+    this.invoke(this._publishMethodName, [ reg ]);
+    return this;
+  }
+
+  invoke(method, args, callback) {
+    const oneway = !is.function(callback); // if no callback, means oneway
+    const argLength = args.length;
+    let data;
+    // data:
+    // +-----+---------------+-----+---------------+
+    // | len |   arg1 body   | len |   arg2 body   |  ...
+    // +-----+---------------+-----+---------------+
+    if (argLength > 0) {
+      let argsBufLength = 0;
+      const arr = [];
+      for (const arg of args) {
+        const argBuf = this._transcode.encode(arg);
+        const len = argBuf.length;
+        const buf = Buffer.alloc(4 + len);
+        buf.writeInt32BE(len, 0);
+        argBuf.copy(buf, 4, 0, len);
+        arr.push(buf);
+        argsBufLength += (len + 4);
+      }
+      data = Buffer.concat(arr, argsBufLength);
+    }
+    const req = new Request({
+      connObj: {
+        type: 'invoke',
+        method,
+        argLength,
+        oneway,
+      },
+      data,
+      timeout: this.options.responseTimeout,
+    });
+    // send invoke request
+    this.send({
+      id: req.id,
+      oneway,
+      data: req.encode(),
+      tips: `invoke method:${method}, oneway:${oneway}, argLength:${argLength}`,
+    }, callback);
+  }
+
+  _registerChannel() {
+    const channelName = this.options.name;
+    const req = new Request({
+      connObj: {
+        type: 'register_channel',
+        channelName,
+      },
+      timeout: this.options.responseTimeout,
+    });
+    // send invoke request
+    this.send({
+      id: req.id,
+      oneway: false,
+      data: req.encode(),
+      tips: `register_channel channelName:${channelName}`,
+    }, (err, data) => {
+      if (err) {
+        // if socket alive, do retry
+        if (this._socket) {
+          err.message = `register to channel: ${channelName} failed, will retry after 3s, ${err.message}`;
+          this.logger.warn(err);
+          // if exception, retry after 3s
+          setTimeout(() => this._registerChannel(), 3000);
+        } else {
+          this.ready(err);
+        }
+        return;
+      }
+      const res = this._transcode.decode(data);
+      if (res.success) {
+        debug('[Follower:%s] register to channel: %s success', this.options.name, this.options.name);
+        this.ready(true);
+      } else {
+        const error = new Error(res.error.message);
+        Object.assign(error, res.error);
+        this.ready(error);
+      }
+    });
+  }
+
+  _findMethodName(type) {
+    for (const method of this.options.descriptors.keys()) {
+      const descriptor = this.options.descriptors.get(method);
+      if (descriptor.type === 'delegate' && descriptor.to === type) {
+        return method;
+      }
+    }
+    return null;
+  }
+
+  _handleRequest(req) {
+    debug('[Follower:%s] receive req: %j from leader', this.options.name, req);
+    const connObj = req.connObj || {};
+    if (connObj.type === 'subscribe_result') {
+      const result = this._transcode.decode(req.data);
+      this.emit(connObj.key, result);
+      this._subData.set(connObj.key, result);
+      // feedback
+      const res = new Response({
+        id: req.id,
+        timeout: req.timeout,
+        connObj: { type: 'subscribe_result_res' },
+      });
+      this.send({
+        id: req.id,
+        oneway: true,
+        data: res.encode(),
+        tips: `subscribe_result_res key:${connObj.key}`,
+      });
+    }
+  }
+
+  _connect(done) {
+    if (!done) {
+      done = err => {
+        if (err) {
+          this.ready(err);
+        } else {
+          // register to proper channel, difference type of client into difference channel
+          this._registerChannel();
+        }
+      };
+    }
+    super._connect(done);
+  }
+}
+
+module.exports = Follower;