xcraft-core-busclient 5.0.0

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.{js,jsx,json}]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 80

package/.eslintrc.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports = {
+  root: true,
+  parserOptions: {
+    ecmaVersion: 7,
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+  env: {
+    browser: true,
+    mocha: true,
+    node: true,
+    es6: true,
+  },
+  parser: 'babel-eslint',
+  plugins: ['react', 'babel'],
+  extends: ['prettier', 'eslint:recommended', 'plugin:react/recommended'],
+  rules: {
+    // Other rules
+    'no-console': 'off',
+    'valid-jsdoc': ['error', {requireReturn: false}],
+    'eqeqeq': 'error',
+    'react/display-name': 'off',
+  },
+};

package/README.md

@@ -0,0 +1,10 @@
+# xcraft-core-busclient
+
+Client for the Xcraft bus.
+
+This module provides the interfaces in order to connect to a server, send
+commands and send or subscribe to events.
+
+It provides the global busClient too. This handler must be used between the
+modules in order to have always the same connection everywhere. Otherwise
+you can connect to several servers by instancing a new busClient for each one.

package/config.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Retrieve the inquirer definition for xcraft-core-etc
+ */
+module.exports = [
+  {
+    type: 'input',
+    name: 'caPath',
+    message: 'path on a server certificate file (pem)',
+    default: '',
+  },
+];

package/index.js

@@ -0,0 +1,566 @@
+'use strict';
+
+const moduleName = 'busclient';
+
+const {
+  Router,
+  Cache,
+  helpers: {extractIds},
+} = require('xcraft-core-transport');
+const {v4: uuidV4} = require('uuid');
+
+const xLog = require('xcraft-core-log')(moduleName, null);
+const xUtils = require('xcraft-core-utils');
+
+const {EventEmitter} = require('events');
+const Resp = require('./lib/resp.js');
+
+let globalBusClient = null;
+
+class BusClient extends EventEmitter {
+  constructor(busConfig, subscriptions) {
+    super();
+
+    this._busConfig = busConfig; /* can be null */
+
+    const id = uuidV4();
+    this._subSocket = new Router(id, 'sub', xLog);
+    this._pushSocket = new Router(id, 'push', xLog);
+
+    this._eventsRegistry = {};
+    this._commandsRegistry = {};
+    this._eventsCache = new Cache();
+
+    this._token = 'invalid';
+    this._orcName = null;
+    this._autoconnect = false;
+    this._connected = false;
+    this._subClosed = true;
+    this._pushClosed = true;
+
+    const Events = require('./lib/events.js');
+    this.events = new Events(this, this._subSocket);
+
+    const Command = require('./lib/command.js');
+    this.command = new Command(this, this._pushSocket);
+
+    let autoConnectToken = '';
+
+    const subs = subscriptions || [
+      'greathall::*' /* broadcasted by server */,
+      'gameover' /* broadcasted by bus */,
+    ];
+
+    subs.forEach((sub) => this._subSocket.subscribe(sub));
+
+    this._onCloseSubscribers = {};
+    this._onConnectSubscribers = {};
+
+    const onClosed = (err) => {
+      if (!this._subClosed || !this._pushClosed) {
+        return;
+      }
+
+      this.emit('close');
+
+      if (!err) {
+        xLog.verb(`bus stopped for ${this._orcName || 'greathall'}`);
+      }
+
+      Object.keys(this._onCloseSubscribers).forEach((key) =>
+        this._onCloseSubscribers[key].callback(err)
+      );
+    };
+
+    const onConnected = (err) => {
+      if (this._subClosed || this._pushClosed) {
+        return;
+      }
+
+      if (!err) {
+        xLog.verb('Connected');
+      }
+
+      Object.keys(this._onConnectSubscribers).forEach((key) =>
+        this._onConnectSubscribers[key].callback(err)
+      );
+    };
+
+    const onReconnectAttempt = (from) => {
+      if (!this._connected) {
+        return;
+      }
+
+      xLog.warn(`Attempt a reconnect for ${from}`);
+
+      this._connected = false;
+
+      if (from === 'push') {
+        this._subSocket.destroySockets();
+      } else if (from === 'sub') {
+        this._pushSocket.destroySockets();
+      }
+
+      this.emit('reconnect attempt');
+
+      this._registerAutoconnect(() => {
+        this.emit('reconnect');
+      });
+
+      this._autoconnect = true;
+    };
+
+    this._subSocket
+      .on('close', (err) => {
+        this._subClosed = true;
+        onClosed(err);
+      })
+      .on('connect', () => {
+        xLog.verb('Bus client subscribed to notifications bus');
+        this._subClosed = false;
+        onConnected();
+      })
+      .on('error', (err) => {
+        this._subClosed = true;
+        onClosed(err);
+        onConnected(err);
+      })
+      .on('reconnect attempt', () => {
+        this._subClosed = true;
+        onReconnectAttempt('sub');
+      });
+
+    this._pushSocket
+      .on('close', (err) => {
+        this._pushClosed = true;
+        onClosed(err);
+      })
+      .on('connect', () => {
+        xLog.verb('Bus client ready to send on command bus');
+        this._pushClosed = false;
+        onConnected();
+      })
+      .on('error', (err) => {
+        this._pushClosed = true;
+        onClosed(err);
+        onConnected(err);
+      })
+      .on('reconnect attempt', () => {
+        this._pushClosed = true;
+        onReconnectAttempt('push');
+      });
+
+    this._subSocket.on('message', (topic, msg) => {
+      if (topic === 'gameover') {
+        xLog.info('Game Over');
+        this._connected = false;
+        this.stop();
+        return;
+      }
+
+      if (topic.startsWith('greathall::')) {
+        if (topic === 'greathall::heartbeat') {
+          if (this._autoconnect) {
+            this._autoconnect = false;
+            autoConnectToken = xUtils.crypto.genToken();
+            this._subSocket.subscribe(
+              autoConnectToken + '::autoconnect.finished'
+            );
+            this.command.send(
+              'autoconnect',
+              {
+                autoConnectToken,
+                nice: this._busConfig ? this._busConfig.nice : 0,
+                noForwarding: this._busConfig
+                  ? this._busConfig.noForwarding || false
+                  : false,
+              },
+              'greathall'
+            );
+          }
+          return;
+        }
+
+        if (topic === 'greathall::bus.commands.registry') {
+          this._commandsRegistry = msg.data.registry;
+          this._commandsRegistryTime = new Date().toISOString();
+          this.emit('commands.registry', null, {
+            token: msg.data.token,
+            time: this._commandsRegistryTime,
+          });
+          return;
+        }
+
+        if (topic === 'greathall::bus.token.changed') {
+          this.emit('token.changed');
+          return;
+        }
+
+        if (
+          topic === 'greathall::bus.orcname.changed' &&
+          this._token === msg.data.token
+        ) {
+          this.emit(
+            'orcname.changed',
+            msg.data.oldOrcName,
+            msg.data.newOrcName
+          );
+          return;
+        }
+
+        if (topic === 'greathall::bus.reconnect') {
+          switch (msg.data.status) {
+            case 'attempt':
+              this.emit('reconnect attempt');
+              break;
+            case 'done':
+              this.emit('reconnect');
+              break;
+          }
+          return;
+        }
+      }
+
+      if (
+        !this._connected &&
+        topic === autoConnectToken + '::autoconnect.finished'
+      ) {
+        const escapeTopic = xUtils.regex.toXcraftRegExpStr(
+          'autoconnect.finished'
+        );
+        this._connected = true;
+        this._subSocket.unsubscribe(
+          autoConnectToken + '::autoconnect.finished'
+        );
+        this._eventsRegistry[escapeTopic].handler(msg); // FIXME: replace by a getter
+        this.unregisterEvents('autoconnect.finished');
+        return;
+      }
+
+      if (!this._connected) {
+        return;
+      }
+
+      const orcName = this.getOrcName() || 'greathall';
+
+      if (msg.token !== this._token) {
+        xLog.info('invalid token, event discarded');
+        return;
+      }
+
+      const handlers = this._eventsCache.map(
+        topic,
+        (id, key) => this._eventsRegistry[key].handler
+      );
+
+      if (handlers.length) {
+        xLog.verb(`notification received: ${topic} for ${orcName}`);
+        handlers.forEach((handler) => handler(msg));
+      } else if (topic !== 'greathall::heartbeat') {
+        xLog.info(
+          `event sent on ${topic} discarded (no subscriber, current orc: ${orcName})`
+        );
+      }
+    });
+  }
+
+  destroyPushSocket() {
+    this._pushSocket.destroySockets();
+  }
+
+  _registerAutoconnect(callback, err) {
+    this.registerEvents('autoconnect.finished', (msg) => {
+      const isNewOrcName = this._orcName !== msg.data.orcName;
+
+      if (this._token !== 'invalid') {
+        if (this._token !== msg.data.token) {
+          xLog.warn(
+            `reconnecting to the server has provided a new token: ${this._token} -> ${msg.data.token}`
+          );
+          this.emit('token.changed');
+        } else if (this._orcName && isNewOrcName) {
+          xLog.warn(
+            `reconnecting to the server has provided a new orcName: ${this._orcName} -> ${msg.data.orcName}`
+          );
+          this.emit('orcname.changed', this._orcName, msg.data.orcName);
+        }
+      }
+
+      this._token = msg.data.token;
+      if (!this._orcName) {
+        this._orcName = msg.data.orcName;
+      }
+      this._commandsRegistry = msg.data.cmdRegistry;
+      this._commandsRegistryTime = new Date().toISOString();
+      this.emit('commands.registry', null, {
+        token: msg.data.token,
+        time: this._commandsRegistryTime,
+      });
+
+      xLog.info(this._orcName + ' is serving ' + this._token + ' Great Hall');
+
+      if (this._orcName && isNewOrcName) {
+        this._subSocket.subscribe(this._orcName + '::*');
+      }
+
+      if (callback) {
+        callback(err, msg.data.isLoaded);
+      }
+    });
+  }
+
+  _subscribeClose(callback) {
+    const key = uuidV4();
+    this._onCloseSubscribers[key] = {
+      callback,
+      unsubscribe: () => {
+        delete this._onCloseSubscribers[key];
+      },
+    };
+    return this._onCloseSubscribers[key].unsubscribe;
+  }
+
+  _subscribeConnect(callback) {
+    const key = uuidV4();
+    this._onConnectSubscribers[key] = {
+      callback,
+      unsubscribe: () => {
+        delete this._onConnectSubscribers[key];
+      },
+    };
+    return this._onConnectSubscribers[key].unsubscribe;
+  }
+
+  /**
+   * Connect the client to the buses.
+   *
+   * When the busToken is null, the client tries to autoconnect to the server.
+   * It's a trivial mechanism, there is no support for user authentication.
+   *
+   * The busToken must be passed only when BusClient is used on the server
+   * side. In all other cases, the argument _must_ be null.
+   *
+   * @param {string} backend - Transport's backend (ee or axon).
+   * @param {string} busToken - Server's token, or null for autoconnect.
+   * @param {function(err)} callback - Callback.
+   */
+  connect(backend, busToken, callback) {
+    const fs = require('fs');
+    const path = require('path');
+    const xEtc = require('xcraft-core-etc')();
+    const xHost = require('xcraft-core-host');
+
+    const {resourcesPath} = xHost;
+    const appArgs = xHost.appArgs();
+
+    xLog.verb('Connecting...');
+
+    const unsubscribe = this._subscribeConnect((err) => {
+      unsubscribe();
+
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      /* TODO: Explain auto-connect mecha */
+      if (!busToken) {
+        /* Autoconnect is sent when the server is ready (heartbeat). */
+        this._registerAutoconnect(callback, err);
+        this._autoconnect = true;
+        return;
+      }
+
+      this._connected = true;
+      this._token = busToken;
+      xLog.verb('Connected with token: ' + this._token);
+
+      callback();
+    });
+
+    let busConfig = this._busConfig;
+    if (!busConfig) {
+      busConfig = xEtc.load('xcraft-core-bus');
+    }
+
+    /* The TLS certificate is ignored in case of unix socket use */
+    if (
+      appArgs.tls !== false &&
+      !busConfig.noTLS &&
+      !busConfig.unixSocketId &&
+      !busConfig.caPath
+    ) {
+      const resCaPath = path.join(resourcesPath, 'server-cert.pem');
+      if (fs.existsSync(resCaPath)) {
+        busConfig.caPath = resCaPath;
+        xEtc.saveRun('xcraft-core-busclient', busConfig);
+      }
+    }
+
+    const options = {
+      timeout: busConfig.timeout,
+      noForwarding: busConfig.noForwarding,
+    };
+    if (busConfig.caPath) {
+      options.caPath = busConfig.caPath;
+    }
+
+    this._subSocket.connect(backend, {
+      port: parseInt(busConfig.notifierPort),
+      host: busConfig.host,
+      unixSocketId: busConfig.unixSocketId,
+      ...options,
+    });
+    this._pushSocket.connect(backend, {
+      port: parseInt(busConfig.commanderPort),
+      host: busConfig.host,
+      unixSocketId: busConfig.unixSocketId,
+      ...options,
+    });
+  }
+
+  /**
+   * Close the connections on the buses.
+   *
+   * @param {function(err)} callback - Callback.
+   */
+  stop(callback) {
+    xLog.verb(`Stopping for ${this._orcName || 'greathall'}...`);
+
+    const unsubscribe = this._subscribeClose((err) => {
+      unsubscribe();
+      if (callback) {
+        callback(err);
+      }
+    });
+
+    this._connected = false;
+    this._subSocket.stop();
+    this._pushSocket.stop();
+  }
+
+  /**
+   * Return a new empty message for the commands.
+   *
+   * The isNested attribute is set when the command is called from the server
+   * side but with an orc name.
+   *
+   * @param {string} topic - Event's topic or command's name.
+   * @param {string} which - The sender's identity (orcName).
+   * @return {Object} the new message.
+   */
+  newMessage(topic, which) {
+    const id = uuidV4();
+    const isNested =
+      topic &&
+      !topic.includes('::') && // is a command
+      !!(this.isServerSide() && which && which !== 'greathall');
+
+    return {
+      _xcraftMessage: true,
+      token: this.getToken(),
+      orcName: which,
+      id,
+      topic,
+      data: {},
+      isNested,
+      isError: topic && topic.endsWith('.error'),
+    };
+  }
+
+  /**
+   * Patch a message for re-sending to an other server.
+   *
+   * It's especially useful in the case of the Horde when a command must be
+   * forwarded to an other server.
+   *
+   * @param {Object} msg - Xcraft message.
+   */
+  patchMessage(msg) {
+    msg.token = this.getToken();
+  }
+
+  _unregister(id, escapeTopic) {
+    this._eventsCache.del(id, escapeTopic);
+    delete this._eventsRegistry[escapeTopic];
+  }
+
+  registerEvents(topic, handler) {
+    const escapeTopic = xUtils.regex.toXcraftRegExpStr(topic);
+
+    if (this._eventsRegistry[escapeTopic]) {
+      xLog.info(`${topic} already registered, unsub and sub again`);
+      this.unregisterEvents(topic);
+    }
+
+    const re = new RegExp(escapeTopic);
+    const ids = extractIds(topic);
+    const id = ids[ids.length - 1];
+    this._eventsCache.set(id, escapeTopic, re);
+    this._eventsRegistry[escapeTopic] = {
+      topic: re,
+      handler,
+      unregister: () => this._unregister(id, escapeTopic),
+    };
+  }
+
+  unregisterEvents(topic) {
+    const escapeTopic = xUtils.regex.toXcraftRegExpStr(topic);
+    if (this._eventsRegistry[escapeTopic]) {
+      this._eventsRegistry[escapeTopic].unregister();
+    }
+  }
+
+  isServerSide() {
+    return !this._orcName;
+  }
+
+  getToken() {
+    return this._token;
+  }
+
+  getOrcName() {
+    return this._orcName;
+  }
+
+  getCommandsRegistry() {
+    return this._commandsRegistry;
+  }
+
+  getCommandsRegistryTime() {
+    return this._commandsRegistryTime;
+  }
+
+  isConnected() {
+    return this._connected;
+  }
+
+  newResponse() {
+    return exports.newResponse.apply(this, arguments);
+  }
+
+  getNice() {
+    const nice = this._busConfig && this._busConfig.nice;
+    return nice || 0;
+  }
+}
+
+exports.newResponse = function (moduleName, orcName, routing) {
+  let self = null;
+  if (this instanceof BusClient) {
+    self = this;
+  }
+
+  return new Resp(self, moduleName, orcName, routing);
+};
+
+exports.initGlobal = function () {
+  globalBusClient = new BusClient();
+  return globalBusClient;
+};
+
+exports.getGlobal = function () {
+  return globalBusClient;
+};
+
+exports.BusClient = BusClient;

package/lib/command.js

@@ -0,0 +1,148 @@
+'use strict';
+
+var moduleName = 'busclient/command';
+
+const xBus = require('xcraft-core-bus');
+var xLog = require('xcraft-core-log')(moduleName, null);
+
+function Command(busClient, pushSocket) {
+  this._busClient = busClient;
+  this._push = pushSocket;
+}
+
+Command.prototype.connectedWith = function () {
+  return this._push.connectedWith();
+};
+
+Command.prototype.newMessage = function (cmd, which) {
+  if (!which) {
+    which = this._busClient.getOrcName() || 'greathall';
+  }
+
+  return this._busClient.newMessage(cmd, which);
+};
+
+Command.prototype.retry = function (msg) {
+  return this.send(msg.topic, msg);
+};
+
+/**
+ * Send a command on the bus.
+ *
+ * If a callback is specified, the finished topic is automatically
+ * subscribed to the events bus. Then when the callback is called, the
+ * topic is unsubscribed.
+ *
+ * @param {string} cmd - Command's name.
+ * @param {Object} data - Message or map of arguments passed to the command.
+ * @param {string} which - Orc name or greathall.
+ * @param {function(err, results)} [finishHandler] - Callback.
+ * @param {Object} options - Options like forceNested.
+ */
+Command.prototype.send = function (
+  cmd,
+  data,
+  which,
+  finishHandler,
+  options = {}
+) {
+  if (!which) {
+    which = this._busClient.getOrcName() || 'greathall';
+  }
+
+  let busMessage = data;
+  if (!data || !data._xcraftMessage) {
+    busMessage = this.newMessage(cmd, which);
+    busMessage.data = data;
+    busMessage.originRouter = this._push.connectedWith();
+  } else if (data._xcraftMessage) {
+    this._busClient.patchMessage(busMessage);
+  }
+
+  if (!busMessage.arp) {
+    const {appId, appArgs} = require('xcraft-core-host');
+    const {tribe} = appArgs();
+    const routingKey = tribe ? `${appId}-${tribe}` : appId;
+    let token = xBus.getToken();
+    let nodeName = routingKey;
+    let {orcName} = busMessage;
+    let nice = 0;
+    let noForwarding = false;
+    if (cmd === 'autoconnect') {
+      orcName = busMessage.data.autoConnectToken;
+      nice = busMessage.data.nice;
+      noForwarding = busMessage.data.noForwarding;
+      /* `token` can be empty, because it's provided by the autoconnect */
+    } else if (!token) {
+      token = orcName.split('@')[1];
+      nodeName = 'zog';
+      if (!token) {
+        throw new Error(
+          `this ARP entry without token is forbidden; it's seems that your client is using a forbidden orcName or you are not connected properly to the server`
+        );
+      }
+    }
+    busMessage.arp = {
+      [orcName]: {token, nice, noForwarding, nodeName},
+    };
+    busMessage.router = this.connectedWith();
+  }
+
+  if (options && options.forceNested) {
+    busMessage.isNested = true;
+  }
+
+  if (finishHandler) {
+    /* Subscribe to  end and error command notification. */
+    const unsubscribe = this._busClient.events.subscribe(
+      `${which}::${cmd}.${busMessage.id}.(error|finished)`,
+      (msg) => {
+        unsubscribe();
+        if (msg.isError) {
+          // Generator exception handling,
+          // see https://gist.github.com/deepak/e325fa2d1a39984fd3e9
+          setTimeout(() => {
+            try {
+              let err = {};
+              if (msg.data && msg.data.message) {
+                err.message = msg.data.message;
+                if (msg.data.id) {
+                  err.id = msg.data.id;
+                }
+                if (msg.data.code) {
+                  err.code = msg.data.code;
+                }
+                if (msg.data.stack) {
+                  err.stack = msg.data.stack;
+                }
+              } else {
+                err.message = msg.data;
+              }
+              if (!err.topic) {
+                err.topic = msg.topic;
+              }
+              if (!err.code) {
+                err.code = 'XCRAFT_CMD_ERROR';
+              }
+              finishHandler(err);
+            } catch (ex) {
+              console.error(
+                `Unexpected error: ${ex.stack || ex.message || ex}`
+              );
+            }
+          }, 0);
+        } else {
+          finishHandler(null, msg);
+        }
+      },
+      this._push.connectedWith()
+    );
+
+    xLog.verb('finish handler registered for cmd: ' + cmd);
+  }
+
+  xLog.verb("client send '%s' command", cmd);
+  this._push.send(cmd, busMessage);
+};
+
+module.exports = Command;

package/lib/events.js

@@ -0,0 +1,223 @@
+'use strict';
+
+var moduleName = 'busclient/events';
+
+var xLog = require('xcraft-core-log')(moduleName, null);
+var xBus = require('xcraft-core-bus');
+
+function Events(busClient, subSocket) {
+  this._busClient = busClient;
+  this._sub = subSocket;
+  this._prevTopic = '';
+  this._handlers = new Map();
+}
+
+Events.prototype.lastPerf = function () {
+  return this._sub.lastPerf;
+};
+
+Events.prototype.connectedWith = function () {
+  return this._sub.connectedWith();
+};
+
+/**
+ * Catch all events.
+ *
+ * @param {function(topic, msg)} handler - Main messages handler
+ * @param {*} proxy - Enable proxy mode (disable Xcraft serialization)
+ */
+Events.prototype.catchAll = function (handler, proxy = false) {
+  this._sub.on('message', handler, proxy);
+};
+
+/**
+ * Subscribe to a topic, an event.
+ *
+ * @param {string} topic - Event's name.
+ * @param {function(msg)} handler - Handler to attach to this topic.
+ * @param {string} [backend] - Transport backend to use (or null for all).
+ * @param {string} [orcName] - Subscriber orcName (internal use)
+ * @return {function} unsubscribe function.
+ */
+Events.prototype.subscribe = function (topic, handler, backend, orcName) {
+  if (!topic.includes('::')) {
+    xLog.err(new Error().stack);
+    throw new Error('namespace missing');
+  }
+
+  if (topic.includes('undefined')) {
+    xLog.warn(`bad event subscription detected: ${topic}`);
+  }
+
+  xLog.verb('client inserting handler to topic: ' + topic);
+
+  const id = Symbol();
+
+  const unsubscribe = (handleReturn) => {
+    if (!this._handlers.has(topic)) {
+      if (!handleReturn) {
+        xLog.warn(`no unsubscribe because ${topic} is no longer available`);
+      }
+      return false;
+    }
+    const handlers = this._handlers.get(topic);
+    handlers.delete(id);
+    if (handlers.size === 0) {
+      this.unsubscribeAll(topic, backend, orcName);
+    }
+    return true;
+  };
+
+  if (this._handlers.has(topic)) {
+    this._handlers.get(topic).set(id, handler);
+    return unsubscribe;
+  }
+
+  this._handlers.set(topic, new Map([[id, handler]]));
+  this._sub.subscribe(topic, backend, orcName);
+
+  const handlers = this._handlers.get(topic);
+
+  /* register a pre-handler for deserialize object if needed */
+  this._busClient.registerEvents(topic, (msg) => {
+    /* FIXME: it's not safe. */
+    if (msg.serialized) {
+      msg.data = JSON.parse(msg.data, function (key, value) {
+        if (
+          value &&
+          typeof value === 'string' &&
+          value.substr(0, 8) === 'function'
+        ) {
+          var startBody = value.indexOf('{') + 1;
+          var endBody = value.lastIndexOf('}');
+          var startArgs = value.indexOf('(') + 1;
+          var endArgs = value.indexOf(')');
+
+          return new Function(
+            value.substring(startArgs, endArgs) /* jshint ignore:line */,
+            value.substring(startBody, endBody)
+          );
+        }
+
+        return value;
+      });
+    }
+
+    /* finally call user code (with or without deserialized data) */
+    handlers.forEach((handler) => handler(msg));
+  });
+
+  return unsubscribe;
+};
+
+/**
+ * Unsubscribe from a topic, event.
+ *
+ * @param {string} topic - Event's name.
+ * @param {string} [backend] - Transport backend to use (or null for all).
+ * @param {string} [orcName] - Subscriber orcName (internal use)
+ */
+Events.prototype.unsubscribeAll = function (topic, backend, orcName) {
+  if (!topic.includes('::')) {
+    xLog.err(new Error().stack);
+    throw new Error('namespace missing');
+  }
+
+  xLog.verb('client removing handler on topic: ' + topic);
+
+  this._sub.unsubscribe(topic, backend, orcName);
+  this._busClient.unregisterEvents(topic);
+  this._handlers.delete(topic);
+};
+
+Events.prototype.heartbeat = function () {
+  if (!this._busClient.isServerSide()) {
+    const err = new Error('only the server can send heartbeats');
+    xLog.err(err.stack);
+    throw err;
+  }
+
+  const topic = 'greathall::heartbeat';
+  const notifier = xBus.getNotifier();
+
+  notifier.send(topic);
+};
+
+/**
+ * Send an event on the bus.
+ *
+ * The \p data can be stringified for example in the case of a simple
+ * function. Of course, the function must be standalone.
+ *
+ * @param {string} topic - Event's name.
+ * @param {Object} [data] - Payload.
+ * @param {boolean} [serialize] - Stringify the object.
+ * @param {string} [routing] - Router info (ee or axon).
+ */
+Events.prototype.send = function (topic, data, serialize, routing) {
+  if (!this._busClient.isServerSide()) {
+    const err = new Error('only the server can send events');
+    xLog.err(err.stack);
+    throw err;
+  }
+
+  if (!topic.includes('::')) {
+    const err = new Error('namespace missing');
+    xLog.err(err.stack);
+    throw err;
+  }
+
+  const which = topic.split('::', 1)[0];
+
+  var notifier = xBus.getNotifier();
+
+  let busMessage = data;
+  if (!data || !data._xcraftMessage) {
+    busMessage = this._busClient.newMessage(topic, which);
+
+    if (serialize) {
+      busMessage.data = JSON.stringify(data, (key, value) =>
+        typeof value === 'function' ? value.toString() : value
+      );
+
+      busMessage.serialized = true;
+    }
+
+    busMessage.data = data;
+  } else if (data._xcraftMessage) {
+    this._busClient.patchMessage(busMessage);
+  }
+
+  let isActivity = false;
+
+  if (routing) {
+    busMessage.router = routing.router;
+    busMessage.originRouter = routing.originRouter;
+    if (routing.forwarding) {
+      busMessage.forwarding = routing.forwarding;
+    }
+    isActivity = routing.activity;
+  }
+
+  /* Reduce noise... */
+  if (topic !== this._prevTopic) {
+    xLog.verb('client send notification(s) on topic:' + topic);
+    this._prevTopic = topic;
+  }
+
+  notifier.send(topic, busMessage);
+
+  if (isActivity) {
+    topic += '.activity';
+    busMessage = this._busClient.newMessage(topic, which);
+    notifier.send(topic, busMessage);
+  }
+};
+
+Events.prototype.status = {
+  succeeded: 1,
+  failed: 2,
+  canceled: 3,
+};
+
+module.exports = Events;

package/lib/resp.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const watt = require('gigawatts');
+
+class Events {
+  constructor(busClient, log, orcName, routing) {
+    this._busClient = busClient;
+    this._orcName = orcName;
+    this._routing = routing;
+
+    this.status = (this._busClient && this._busClient.events.status) || {};
+  }
+
+  get routing() {
+    return this._routing;
+  }
+
+  _fixTopic(topic) {
+    return topic.includes('::') ? topic : `${this._orcName}::${topic}`;
+  }
+
+  catchAll(handler) {
+    if (!this._busClient) {
+      this._log.err('events.catchAll not available');
+      return;
+    }
+    this._busClient.events.catchAll(handler);
+  }
+
+  subscribe(topic, handler) {
+    if (!this._busClient) {
+      this._log.err('events.subscribe not available');
+      return;
+    }
+
+    return this._busClient.events.subscribe(
+      this._fixTopic(topic),
+      handler,
+      undefined,
+      this._orcName
+    );
+  }
+
+  unsubscribeAll(topic) {
+    if (!this._busClient) {
+      this._log.err('events.unsubscribe not available');
+      return;
+    }
+
+    this._busClient.events.unsubscribe(this._fixTopic(topic));
+  }
+
+  send(topic, data, serialize, forwarding = null) {
+    if (!this._busClient) {
+      this._log.err('events.send not available');
+      return;
+    }
+
+    let routing = this._routing;
+    if (forwarding) {
+      switch (typeof forwarding) {
+        case 'string': {
+          const appId = forwarding;
+          if (appId) {
+            /* FIXME: not sure if it's still used. If yes, we must provide the tribe number
+             * in order to be right.
+             */
+            routing = Object.assign(
+              {forwarding: {router: 'ee', appId}},
+              this._routing
+            );
+          }
+          break;
+        }
+        case 'object': {
+          routing = forwarding;
+          break;
+        }
+      }
+    }
+
+    this._busClient.events.send(
+      this._fixTopic(topic),
+      data,
+      serialize,
+      routing
+    );
+  }
+}
+
+class Command {
+  constructor(busClient, log, orcName) {
+    this._log = log;
+    this._busClient = busClient;
+    this._orcName = orcName;
+  }
+
+  retry(msg) {
+    if (!this._busClient) {
+      this._log.err('command.retry not available');
+      return;
+    }
+
+    this._busClient.command.retry(msg);
+  }
+
+  _send(cmd, data, options, finishHandler) {
+    if (!this._busClient) {
+      this._log.err('command.send not available');
+      return;
+    }
+
+    const orcName = (data && data.$orcName) || this._orcName;
+    this._busClient.command.send(cmd, data, orcName, finishHandler, options);
+  }
+
+  send(cmd, data, finishHandler) {
+    this._send(cmd, data, null, finishHandler);
+  }
+
+  nestedSend(cmd, data, finishHandler) {
+    this._send(cmd, data, {forceNested: true}, finishHandler);
+  }
+}
+
+class Resp {
+  constructor(busClient, moduleName, orcName, routing = null) {
+    this._busClient = busClient;
+    this._cmdNames = {};
+    this._orcName = orcName;
+
+    /* Add a way for sending with the token server instead of an orcName */
+    if (orcName === 'token') {
+      const token = this._busClient.getToken();
+      if (token === 'invalid') {
+        throw new Error(
+          'A Resp cannot be created with a disconnected busClient (invalid token)'
+        );
+      }
+      orcName = 'greathall@' + token;
+    }
+
+    this.log = require('xcraft-core-log')(moduleName, this);
+    this.events = new Events(busClient, this.log, orcName, routing);
+    this.command = new Command(busClient, this.log, orcName);
+
+    watt.wrapAll(this, 'connect', 'stop');
+  }
+
+  _makeCmdNames() {
+    if (!this._busClient) {
+      return {};
+    }
+    this._cmdNames = Object.assign(
+      {},
+      ...Object.entries(this._busClient.getCommandsRegistry()).map(
+        ([key, infos]) => {
+          let value =
+            (infos.questOptions && infos.questOptions.rankingPredictions) ||
+            true;
+          return {[key]: value};
+        }
+      )
+    );
+  }
+
+  get orcName() {
+    return this._orcName;
+  }
+
+  *connect(next) {
+    yield this._busClient.connect('axon', null, next);
+  }
+
+  *stop(next) {
+    yield this._busClient.stop(next);
+  }
+
+  isConnected() {
+    return this._busClient ? this._busClient.isConnected() : false;
+  }
+
+  onTokenChanged(callback) {
+    this._busClient.on('token.changed', callback);
+    return () => this._busClient.removeListener('token.changed', callback);
+  }
+
+  onOrcnameChanged(callback) {
+    this._busClient.on('orcname.changed', callback);
+    return () => this._busClient.removeListener('orcname.changed', callback);
+  }
+
+  /**
+   * @brief Listener for reconnection
+   *
+   * Pass 'attempt' when it tries to reconnect and 'done'
+   * when it's connected again.
+   *
+   * @param {*} callback - Callback
+   * @returns {*} unsub
+   */
+  onReconnect(callback) {
+    this._busClient
+      .on('reconnect', () => callback('done'))
+      .on('reconnect attempt', () => callback('attempt'));
+    return () => {
+      this._busClient.removeListener('reconnect', callback);
+      this._busClient.removeListener('reconnect attempt', callback);
+    };
+  }
+
+  onCommandsRegistry(callback) {
+    const _callback = () => {
+      this._makeCmdNames();
+      callback();
+    };
+    this._busClient.on('commands.registry', _callback);
+    return () => this._busClient.removeListener('commands.registry', _callback);
+  }
+
+  getCommandsRegistry() {
+    return this._busClient ? this._busClient.getCommandsRegistry() : {};
+  }
+
+  getCommandsRegistryTime() {
+    return this._busClient ? this._busClient.getCommandsRegistryTime() : 0;
+  }
+
+  getCommandsNames() {
+    this._makeCmdNames();
+    return this._cmdNames;
+  }
+
+  hasCommand(cmdName) {
+    return this._busClient
+      ? !!this._busClient.getCommandsRegistry()[cmdName]
+      : false;
+  }
+}
+
+module.exports = Resp;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "xcraft-core-busclient",
+  "version": "5.0.0",
+  "description": "Xcraft bus client",
+  "main": "index.js",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "xcraft",
+    "bus",
+    "client"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Xcraft-Inc/xcraft-core-busclient.git"
+  },
+  "dependencies": {
+    "gigawatts": "^4.0.1",
+    "uuid": "^8.3.2",
+    "xcraft-axon": "^2.3.2",
+    "xcraft-core-bus": "^5.0.0",
+    "xcraft-core-host": "^3.0.0",
+    "xcraft-core-etc": "^3.0.0",
+    "xcraft-core-log": "^2.0.0",
+    "xcraft-core-transport": "^4.0.0",
+    "xcraft-core-utils": "^4.0.0"
+  },
+  "author": "Mathieu Schroeter & Samuel Loup",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Xcraft-Inc/xcraft-core-busclient/issues"
+  },
+  "homepage": "https://github.com/Xcraft-Inc/xcraft-core-busclient#readme",
+  "devDependencies": {
+    "prettier": "2.0.4",
+    "xcraft-dev-prettier": "^2.0.0",
+    "xcraft-dev-rules": "^2.0.0"
+  },
+  "prettier": "xcraft-dev-prettier"
+}