@arcblock/event-hub 1.6.10

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018-2019 ArcBlock
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,55 @@
+# Event Hub
+
+A module for local and remote Inter Process Event
+
+![image](./docs/event-hub.svg)
+
+## Usage
+
+Install
+
+```shell
+yarn add @arcblock/event-hub
+```
+
+Server
+
+```javascript
+process.env.ABT_NODE_EVENT_PORT=8888;
+
+require('@arcblock/event-hub/lib/server.js);
+```
+
+Client
+
+```javascript
+// process 1
+
+const Client = require('@arcblock/event-hub/lib/client');
+
+const port = ''; // event-hub server port
+const did = ''; // your did
+const sk = ''; // your sk
+
+const client = new Client({ port, did, sk, autoConnect: true });
+
+const data = { foo: bar };
+
+client.broadcast('my-event', data);
+```
+
+```javascript
+// process 2
+
+const Client = require('@arcblock/event-hub/lib/client');
+
+const port = ''; // event-hub server port
+const did = ''; // your did
+const sk = ''; // your sk
+
+const client = new Client({ port, did, sk, autoConnect: true });
+
+client.on('my-event', (data) => {
+  // handle data
+});
+```

package/lib/client-fallback.js

@@ -0,0 +1,13 @@
+const { EventEmitter } = require('events');
+
+class Client extends EventEmitter {
+  broadcast(...args) {
+    return this.emit(...args);
+  }
+
+  off(event) {
+    this.removeAllListeners(event);
+  }
+}
+
+module.exports = Client;

package/lib/client.js

@@ -0,0 +1,116 @@
+// eslint-disable-next-line max-classes-per-file
+const { EventEmitter } = require('events');
+const axon = require('axon');
+const roundrobin = require('axon/lib/plugins/round-robin');
+const queue = require('axon/lib/plugins/queue');
+const { fromSecretKey } = require('@ocap/wallet');
+const JWT = require('@arcblock/jwt');
+const { toTypeInfo } = require('@arcblock/did');
+
+const { RESERVED_EVENT_PREFIX, EVENT_AUTH, EVENT_AUTH_FAIL } = require('./constant');
+
+const checkEvent = (event) => {
+  if (event.startsWith(RESERVED_EVENT_PREFIX)) {
+    throw new Error(`event cannot start with ${RESERVED_EVENT_PREFIX}`);
+  }
+};
+
+const defaultOpts = {
+  port: undefined,
+  hostname: '0.0.0.0',
+  autoConnect: false,
+  did: undefined,
+  pk: undefined,
+  sk: undefined,
+};
+
+class Socket extends axon.SubEmitterSocket {
+  constructor(opts) {
+    super();
+
+    this.sock.use((sock) => {
+      sock.on('connect', () => {
+        const { did, pk, sk } = opts;
+        sock.send(EVENT_AUTH, {
+          pk,
+          token: JWT.sign(did, sk),
+        });
+
+        sock.on(EVENT_AUTH_FAIL, ({ msg } = {}) => {
+          this.emit('error', { msg });
+          sock.close();
+        });
+      });
+    });
+
+    this.sock.use(queue());
+    this.sock.use(roundrobin({ fallback: this.sock.enqueue }));
+    this.send = this.sock.send.bind(this.sock);
+  }
+}
+
+class Client extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+
+    if (!opts.port) {
+      throw new Error('port should not be empty');
+    }
+
+    if (!opts.did || !opts.sk) {
+      throw new Error('did, sk should not be empty');
+    }
+
+    const wallet = fromSecretKey(opts.sk, toTypeInfo(opts.did));
+
+    if (wallet.address !== opts.did) {
+      throw new Error('did, sk does not match');
+    }
+
+    this.opts = Object.assign({}, defaultOpts, opts, { pk: wallet.publicKey });
+    this._client = new Socket(this.opts);
+
+    this._bindEvent();
+
+    if (this.opts.autoConnect) {
+      this.connect();
+    }
+  }
+
+  connect() {
+    const { port, hostname } = this.opts;
+    this._client.connect(port, hostname);
+  }
+
+  close() {
+    this._client.close();
+  }
+
+  broadcast(event, data) {
+    checkEvent(event);
+    this._client.send(event, data);
+  }
+
+  on(name, fn) {
+    checkEvent(name);
+    super.on(name, fn);
+    this._client.on(name, fn);
+  }
+
+  off(name, fn) {
+    checkEvent(name);
+    this._client.off(name);
+
+    if (fn) {
+      super.off(name, fn);
+    } else {
+      super.removeAllListeners(name);
+    }
+  }
+
+  _bindEvent() {
+    this._client.on('error', this.emit.bind(this, 'error'));
+  }
+}
+
+module.exports = Client;

package/lib/constant.js

@@ -0,0 +1,5 @@
+module.exports = {
+  RESERVED_EVENT_PREFIX: 'EVENT_HUB:',
+  EVENT_AUTH: 'EVENT_HUB:AUTH',
+  EVENT_AUTH_FAIL: 'EVENT_HUB:AUTH_FAIL',
+};

package/lib/index.js

@@ -0,0 +1,23 @@
+const Client = require('./client');
+const ClientFallback = require('./client-fallback');
+
+const port = Number(process.env.ABT_NODE_EVENT_PORT);
+const hostname = Number(process.env.ABT_NODE_EVENT_HOSTNAME) || '127.0.0.1';
+
+let did;
+let sk;
+
+if (process.env.BLOCKLET_APP_SK && process.env.BLOCKLET_APP_ID) {
+  sk = process.env.BLOCKLET_APP_SK;
+  did = process.env.BLOCKLET_APP_ID;
+} else if (process.env.ABT_NODE_SK && process.env.ABT_NODE_DID) {
+  sk = process.env.ABT_NODE_SK;
+  did = process.env.ABT_NODE_DID;
+}
+
+if (port && did && sk) {
+  module.exports = new Client({ port, hostname, did, sk, autoConnect: true });
+} else {
+  // export fallback Client because missing any of port / did / sk
+  module.exports = new ClientFallback();
+}

package/lib/server-abtnode.js

@@ -0,0 +1,10 @@
+/* eslint-disable no-console */
+const Server = require('./server');
+
+const port = Number(process.env.ABT_NODE_EVENT_PORT);
+const hostname = Number(process.env.ABT_NODE_EVENT_HOSTNAME) || '127.0.0.1';
+
+const server = new Server();
+server.bind(port, hostname);
+
+module.exports = server;

package/lib/server.js

@@ -0,0 +1,83 @@
+/* eslint-disable no-console */
+const axon = require('axon');
+const Message = require('amp-message');
+
+const JWT = require('@arcblock/jwt');
+
+const { EVENT_AUTH, EVENT_AUTH_FAIL } = require('./constant');
+
+const getDid = (jwt) => jwt.iss.replace(/^did:abt:/, '');
+
+class Server extends axon.Socket {
+  constructor() {
+    super();
+    this.on('message', (event, data, sock) => {
+      const { channel } = sock;
+      if (!sock.channel) {
+        console.error('skip message of unauthenticated socket');
+        return;
+      }
+      this.send(event, data, channel);
+    });
+
+    this.on('connect', (socket) => {
+      console.log('event-hub client connected', socket._peername);
+    });
+    this.on('reconnect attempt', (socket) => {
+      console.log('event-hub client reconnect', socket._peername);
+    });
+    this.on('disconnect', (socket) => {
+      console.log('event-hub client disconnected', socket._peername);
+    });
+    this.on('drop', (args) => {
+      console.log('event-hub server drop message', args);
+    });
+    this.on('error', (err) => {
+      console.log('event-hub server error', err);
+    });
+  }
+
+  onmessage(sock) {
+    return (buf) => {
+      const msg = new Message(buf);
+      const [event, data] = msg.args;
+      if (event === EVENT_AUTH) {
+        try {
+          // verify
+          const { pk, token } = data;
+          if (!JWT.verify(token, pk)) {
+            throw new Error('token verify failed');
+          }
+
+          // set channel as did
+          const did = getDid(JWT.decode(token));
+          sock.channel = did;
+        } catch (err) {
+          console.error(err);
+          const resBuf = this.pack([EVENT_AUTH_FAIL, { msg: err.message }]);
+          sock.write(resBuf);
+        }
+        return;
+      }
+
+      this.emit('message', event, data, sock);
+    };
+  }
+
+  send(event, data, channel) {
+    const { socks } = this;
+
+    const buf = this.pack([event, data]);
+
+    for (let i = 0; i < socks.length; i++) {
+      const sock = socks[i];
+      if (sock.channel === channel) {
+        if (sock.writable) sock.write(buf);
+      }
+    }
+
+    return this;
+  }
+}
+
+module.exports = Server;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@arcblock/event-hub",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.6.10",
+  "description": "A nodejs module for local and remote Inter Process Event",
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "single.js"
+  ],
+  "scripts": {
+    "lint": "eslint tests lib",
+    "lint:fix": "eslint --fix tests lib",
+    "test": "jest --forceExit --detectOpenHandles",
+    "coverage": "npm run test -- --coverage"
+  },
+  "keywords": [],
+  "author": "arcblock <engineer@arcblock.io>",
+  "contributors": [
+    "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@arcblock/did": "1.6.10",
+    "@arcblock/jwt": "1.6.10",
+    "@ocap/wallet": "1.6.10",
+    "amp-message": "~0.1.1",
+    "axon": "^2.0.3"
+  },
+  "devDependencies": {
+    "jest": "^27.3.1"
+  },
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
+}

package/single.js

@@ -0,0 +1,3 @@
+const Client = require('./lib/client-fallback');
+
+module.exports = new Client();