ali-skills 0.0.21 → 0.0.23

package/node_modules/cluster-client/lib/wrapper/base.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const debug = require('util').debuglog('cluster-client:lib:wrapper:base');
+const is = require('is-type-of');
+const Base = require('sdk-base');
+const assert = require('assert');
+const utils = require('../utils');
+// Symbols
+const {
+  init,
+  logger,
+  isReady,
+  innerClient,
+  subscribe,
+  unSubscribe,
+  publish,
+  invoke,
+  subInfo,
+  pubInfo,
+  closeHandler,
+  close,
+  singleMode,
+  createClient,
+} = require('../symbol');
+
+class WrapperBase extends Base {
+  /**
+   * Share Connection among Multi-Process Mode
+   *
+   * @param {Object} options
+   *  - {Number} port - the port
+   *  - {Transcode} transcode - serialze / deseriaze methods
+   *  - {Boolean} isLeader - wehether is leader or follower
+   *  - {Number} maxWaitTime - leader startup max time (ONLY effective on isLeader is true)
+   *  - {Function} createRealClient - to create the real client instance
+   * @class
+   */
+  constructor(options) {
+    super(options);
+    debug('new WrapperBase({ port: %j, isLeader: %j })', options.port, options.isLeader);
+    this[subInfo] = new Map();
+    this[pubInfo] = new Map();
+    this[init]().catch(err => { this.ready(err); });
+  }
+
+  get isClusterClientLeader() {
+    return this[innerClient] && this[innerClient].isLeader;
+  }
+
+  get [singleMode]() {
+    return false;
+  }
+
+  /**
+   * log instance
+   * @property {Logger} ClusterClient#[logger]
+   */
+  get [logger]() {
+    return this.options.logger;
+  }
+
+  async [createClient]() {
+    throw new Error('not implement');
+  }
+
+  /**
+   * initialize, to  leader or follower
+   *
+   * @return {void}
+   */
+  async [init]() {
+    this[innerClient] = await this[createClient]();
+
+    // events delegate
+    utils.delegateEvents(this[innerClient], this);
+
+    // re init when connection is close
+    if (this[closeHandler]) {
+      this[innerClient].on('close', this[closeHandler]);
+    }
+
+    // wait leader/follower ready
+    await this[innerClient].ready();
+
+    // subscribe all
+    for (const registrations of this[subInfo].values()) {
+      for (const args of registrations) {
+        this[innerClient].subscribe(args[0], args[1]);
+      }
+    }
+    // publish all
+    for (const reg of this[pubInfo].values()) {
+      this[innerClient].publish(reg);
+    }
+
+    if (!this[isReady]) {
+      this[isReady] = true;
+      this.ready(true);
+    }
+  }
+
+  /**
+   * do subscribe
+   *
+   * @param {Object} reg - subscription info
+   * @param {Function} listener - callback function
+   * @return {void}
+   */
+  [subscribe](reg, listener) {
+    assert(is.function(listener), `[ClusterClient:${this.options.name}] subscribe(reg, listener) listener should be a function`);
+
+    debug('[ClusterClient:%s] subscribe %j', this.options.name, reg);
+    const key = this.options.formatKey(reg);
+    const registrations = this[subInfo].get(key) || [];
+    registrations.push([ reg, listener ]);
+    this[subInfo].set(key, registrations);
+
+    if (this[isReady]) {
+      this[innerClient].subscribe(reg, listener);
+    }
+  }
+
+  /**
+   * do unSubscribe
+   *
+   * @param {Object} reg - subscription info
+   * @param {Function} listener - callback function
+   * @return {void}
+   */
+  [unSubscribe](reg, listener) {
+    debug('[ClusterClient:%s] unSubscribe %j', this.options.name, reg);
+    const key = this.options.formatKey(reg);
+    const registrations = this[subInfo].get(key) || [];
+    const newRegistrations = [];
+    if (listener) {
+      for (const arr of registrations) {
+        if (arr[1] !== listener) {
+          newRegistrations.push(arr);
+        }
+      }
+    }
+    this[subInfo].set(key, newRegistrations);
+
+    if (this[isReady]) {
+      this[innerClient].unSubscribe(reg, listener);
+    }
+  }
+
+  /**
+   * do publish
+   *
+   * @param {Object} reg - publish info
+   * @return {void}
+   */
+  [publish](reg) {
+    debug('[ClusterClient:%s] publish %j', this.options.name, reg);
+    const key = this.options.formatKey(reg);
+    this[pubInfo].set(key, reg);
+
+    if (this[isReady]) {
+      this[innerClient].publish(reg);
+    }
+  }
+
+  /**
+   * invoke a method asynchronously
+   *
+   * @param {String} method - the method name
+   * @param {Array} args - the arguments list
+   * @param {Function} callback - callback function
+   * @return {void}
+   */
+  [invoke](method, args, callback) {
+    if (!this[isReady]) {
+      this.ready(err => {
+        if (err) {
+          callback && callback(err);
+          return;
+        }
+        this[innerClient].invoke(method, args, callback);
+      });
+      return;
+    }
+
+    debug('[ClusterClient:%s] invoke method: %s, args: %j', this.options.name, method, args);
+    this[innerClient].invoke(method, args, callback);
+  }
+
+  async [close]() {
+    try {
+      // close after ready, in case of innerClient is initializing
+      await this.ready();
+    } catch (err) {
+      // ignore
+    }
+
+    const client = this[innerClient];
+    if (client) {
+      // prevent re-initializing
+      if (this[closeHandler]) {
+        client.removeListener('close', this[closeHandler]);
+      }
+      if (client.close) {
+        await utils.callFn(client.close.bind(client));
+      }
+    }
+  }
+}
+
+module.exports = WrapperBase;

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

@@ -0,0 +1,57 @@
+'use strict';
+
+const debug = require('util').debuglog('cluster-client:lib:wrapper:cluster');
+const Base = require('./base');
+const Leader = require('../leader');
+const Follower = require('../follower');
+const ClusterServer = require('../server');
+
+// Symbol
+const {
+  init,
+  logger,
+  isReady,
+  innerClient,
+  createClient,
+  closeHandler,
+} = require('../symbol');
+
+class ClusterClient extends Base {
+  constructor(options) {
+    super(options);
+
+    this[closeHandler] = () => {
+      this[logger].warn('[ClusterClient:%s] %s closed, and try to init it again', this.options.name, this[innerClient].isLeader ? 'leader' : 'follower');
+      this[isReady] = false;
+      this.ready(false);
+      this[init]().catch(err => { this.ready(err); });
+    };
+  }
+
+  async [createClient]() {
+    const name = this.options.name;
+    const port = this.options.port;
+    let server;
+    if (this.options.isLeader === true) {
+      server = await ClusterServer.create(name, port, { maxListeners: this.options.maxListeners });
+      if (!server) {
+        throw new Error(`create "${name}" leader failed, the port:${port} is occupied by other`);
+      }
+    } else if (this.options.isLeader === false) {
+      // wait for leader active
+      await ClusterServer.waitFor(port, this.options.maxWaitTime);
+    } else {
+      debug('[ClusterClient:%s] init cluster client, try to seize the leader on port:%d', name, port);
+      server = await ClusterServer.create(name, port, { maxListeners: this.options.maxListeners });
+    }
+
+    if (server) {
+      debug('[ClusterClient:%s] has seized port %d, and serves as leader client.', name, port);
+      return new Leader(Object.assign({ server }, this.options));
+    }
+    debug('[ClusterClient:%s] gives up seizing port %d, and serves as follower client.', name, port);
+    return new Follower(this.options);
+  }
+}
+
+module.exports = ClusterClient;

package/node_modules/cluster-client/lib/wrapper/single.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const co = require('co');
+const Base = require('./base');
+const is = require('is-type-of');
+const utils = require('../utils');
+const SdkBase = require('sdk-base');
+const random = require('utility').random;
+
+// Symbol
+const {
+  logger,
+  createClient,
+  singleMode,
+} = require('../symbol');
+const _instances = new Map();
+
+class InnerClient extends SdkBase {
+  constructor(options = {}) {
+    super(options);
+
+    this._subData = new Map(); // <key, data>
+    this._subSet = new Set();
+    this._subListeners = new Map(); // <key, Array<Function>>
+    this._transcode = options.transcode;
+    this._realClient = options.createRealClient();
+    this._closeMethodName = utils.findMethodName(options.descriptors, 'close');
+    this._subscribeMethodName = utils.findMethodName(options.descriptors, 'subscribe');
+    this._publishMethodName = utils.findMethodName(options.descriptors, 'publish');
+    this._isReady = false;
+    this._closeByUser = false;
+    this._refCount = 1;
+
+    // event delegate
+    utils.delegateEvents(this._realClient, this);
+
+    if (is.function(this._realClient.ready)) {
+      this._realClient.ready(err => {
+        if (err) {
+          this.ready(err);
+        } else {
+          this._isReady = true;
+          this.ready(true);
+        }
+      });
+    } else {
+      this._isReady = true;
+      this.ready(true);
+    }
+  }
+
+  ref() {
+    this._refCount++;
+  }
+
+  get isLeader() {
+    return true;
+  }
+
+  formatKey(reg) {
+    return '$$inner$$__' + this.options.formatKey(reg);
+  }
+
+  subscribe(reg, listener) {
+    const key = this.formatKey(reg);
+    const transcode = this._transcode;
+    const isBroadcast = this.options.isBroadcast;
+
+    const listeners = this._subListeners.get(key) || [];
+    listeners.push(listener);
+    this._subListeners.set(key, listeners);
+    this.on(key, listener);
+
+    if (!this._subSet.has(key)) {
+      this._subSet.add(key);
+      this._realClient[this._subscribeMethodName](reg, result => {
+        const data = transcode.encode(result);
+        this._subData.set(key, data);
+
+        let fns = this._subListeners.get(key);
+        if (!fns) {
+          return;
+        }
+
+        const len = fns.length;
+        // if isBroadcast equal to false, random pick one to notify
+        if (!isBroadcast) {
+          fns = [ fns[random(len)] ];
+        }
+
+        for (const fn of fns) {
+          fn(transcode.decode(data));
+        }
+      });
+    } else if (this._subData.has(key) && isBroadcast) {
+      process.nextTick(() => {
+        const data = this._subData.get(key);
+        listener(transcode.decode(data));
+      });
+    }
+  }
+
+  unSubscribe(reg, listener) {
+    const key = this.formatKey(reg);
+
+    if (!listener) {
+      this._subListeners.delete(key);
+    } else {
+      const listeners = this._subListeners.get(key) || [];
+      const newListeners = [];
+
+      for (const fn of listeners) {
+        if (fn === listener) {
+          continue;
+        }
+        newListeners.push(fn);
+      }
+      this._subListeners.set(key, newListeners);
+    }
+  }
+
+  publish(reg) {
+    this._realClient[this._publishMethodName](reg);
+  }
+
+  invoke(methodName, args, callback) {
+    let method = this._realClient[methodName];
+    // compatible with generatorFunction
+    if (is.generatorFunction(method)) {
+      method = co.wrap(method);
+    }
+    args.push(callback);
+    const ret = method.apply(this._realClient, args);
+    if (callback && is.promise(ret)) {
+      ret.then(result => callback(null, result), err => callback(err))
+        // to avoid uncaught exception in callback function, then cause unhandledRejection
+        .catch(err => { this._errorHandler(err); });
+    }
+  }
+
+  // emit error asynchronously
+  _errorHandler(err) {
+    setImmediate(() => {
+      if (!this._closeByUser) {
+        this.emit('error', err);
+      }
+    });
+  }
+
+  async close() {
+    if (this._refCount > 0) {
+      this._refCount--;
+    }
+    if (this._refCount > 0) return;
+
+    this._closeByUser = true;
+
+    if (this._realClient) {
+      if (this._closeMethodName) {
+        // support common function, generatorFunction, and function returning a promise
+        await utils.callFn(this._realClient[this._closeMethodName].bind(this._realClient));
+      }
+    }
+    this.emit('close');
+  }
+}
+
+
+class SingleClient extends Base {
+  get [singleMode]() {
+    return true;
+  }
+
+  async [createClient]() {
+    const options = this.options;
+    let client;
+    if (_instances.has(options.name)) {
+      client = _instances.get(options.name);
+      client.ref();
+      return client;
+    }
+    client = new InnerClient(options);
+    client.once('close', () => {
+      _instances.delete(options.name);
+      this[logger].info('[cluster#SingleClient] %s is closed.', options.name);
+    });
+    _instances.set(options.name, client);
+    return client;
+  }
+}
+
+module.exports = SingleClient;

package/node_modules/cluster-client/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "cluster-client",
+  "version": "3.7.0",
+  "description": "Sharing Connection among Multi-Process Nodejs",
+  "main": "./index.js",
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "scripts": {
+    "lint": "eslint . --ext .js",
+    "test": "npm run lint && npm run test-local",
+    "test-local": "egg-bin test",
+    "ci": "egg-bin cov",
+    "contributor": "git-contributor"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/node-modules/cluster-client.git"
+  },
+  "keywords": [
+    "cluster",
+    "multi-process"
+  ],
+  "author": "gxcsoccer@126.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/node-modules/cluster-client/issues"
+  },
+  "homepage": "https://github.com/node-modules/cluster-client#readme",
+  "dependencies": {
+    "byte": "^2.0.0",
+    "co": "^4.6.0",
+    "egg-logger": "^3.5.0",
+    "is-type-of": "^1.4.0",
+    "json-stringify-safe": "^5.0.1",
+    "long": "^4.0.0",
+    "sdk-base": "^4.2.1",
+    "serialize-json": "^1.0.3",
+    "tcp-base": "^3.2.0",
+    "utility": "^2.1.0"
+  },
+  "devDependencies": {
+    "address": "^1.0.3",
+    "await-event": "^2.1.0",
+    "coffee": "^5.2.1",
+    "detect-port": "^1.3.0",
+    "egg-bin": "^6.4.1",
+    "egg-mock": "^5.4.0",
+    "eslint": "^8.30.0",
+    "eslint-config-egg": "^12.1.0",
+    "git-contributor": "^2.1.5",
+    "mm": "^2.4.1",
+    "pedding": "^1.1.0",
+    "spy": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/node_modules/co/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2014 TJ Holowaychuk <tj@vision-media.ca>
+
+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.