@dashevo/dapi-client 0.23.0-dev.9 → 0.23.0

package/lib/transport/ReconnectableStream.js

@@ -0,0 +1,180 @@
+const EventEmitter = require('events');
+const GrpcErrorCodes = require('@dashevo/grpc-common/lib/server/error/GrpcErrorCodes');
+const wait = require('../utils/wait');
+
+const defaultOptions = {
+  // TODO: manage timeout according to the Nginx setting of the node
+  reconnectTimeoutDelay: 50000,
+  maxRetriesOnError: 10,
+  retryOnErrorDelay: 1000,
+};
+
+const EVENTS = {
+  DATA: 'data',
+  ERROR: 'error',
+  END: 'end',
+  BEFORE_RECONNECT: 'beforeReconnect',
+};
+
+/**
+ * Stream that provides auto-reconnect functionality
+ */
+class ReconnectableStream extends EventEmitter {
+  static create(fn, options) {
+    return async (...args) => {
+      const reconnectableStream = new ReconnectableStream(fn, options);
+      await reconnectableStream.connect(...args);
+      return reconnectableStream;
+    };
+  }
+
+  constructor(streamFunction, options = {}) {
+    super();
+    this.stream = null;
+    this.streamFunction = streamFunction;
+    this.reconnectTimeout = null;
+
+    const opts = { ...defaultOptions, ...options };
+    this.reconnectTimeoutDelay = opts.reconnectTimeoutDelay;
+    this.maxRetriesOnError = opts.maxRetriesOnError;
+    this.retryOnErrorDelay = opts.retryOnErrorDelay;
+    // Assign setTimeout and clearTimeout as class method for tests
+    this.setTimeout = (callback, delay) => setTimeout(callback, delay);
+
+    this.clearTimeout = (reference) => clearTimeout(reference);
+
+    /**
+     * Stream function arguments
+     */
+    this.args = null;
+
+    this.connect = this.connect.bind(this);
+    this.reconnect = this.reconnect.bind(this);
+    this.cancel = this.cancel.bind(this);
+    this.destroy = this.destroy.bind(this);
+    this.errorHandler = this.errorHandler.bind(this);
+    this.dataHandler = this.dataHandler.bind(this);
+    this.endHandler = this.endHandler.bind(this);
+    this.addListeners = this.addListeners.bind(this);
+
+    // Manages retry attempts when error happens
+    this.retriesOnError = 0;
+  }
+
+  async connect(...args) {
+    this.args = args;
+    this.stream = await this.streamFunction(...this.args);
+    this.addListeners();
+
+    if (this.reconnectTimeoutDelay > 0) {
+      this.reconnectTimeout = this.setTimeout(
+        this.reconnect,
+        this.reconnectTimeoutDelay,
+      );
+    }
+  }
+
+  reconnect() {
+    if (this.reconnectTimeout) {
+      this.reconnectTimeout = null;
+      this.stream.cancel();
+
+      let newArgs = this.args;
+      const updateArgs = (...args) => {
+        newArgs = args;
+      };
+
+      this.emit(EVENTS.BEFORE_RECONNECT, updateArgs);
+      this.connect(...newArgs)
+        .catch((connectError) => this.emit(EVENTS.ERROR, connectError));
+    }
+  }
+
+  /**
+   * @private
+   */
+  addListeners() {
+    this.stream.on(EVENTS.DATA, this.dataHandler);
+    this.stream.on(EVENTS.ERROR, this.errorHandler);
+    this.stream.on(EVENTS.END, this.endHandler);
+
+    const { cancel } = this.stream;
+
+    this.stream.cancel = () => {
+      this.stream.removeListener(EVENTS.DATA, this.dataHandler);
+      this.stream.removeListener(EVENTS.END, this.endHandler);
+      cancel.call(this.stream);
+    };
+  }
+
+  dataHandler(data) {
+    this.emit(EVENTS.DATA, data);
+  }
+
+  /**
+   * @private
+   */
+  endHandler() {
+    this.stopReconnectTimeout();
+    this.stream = null;
+    this.emit(EVENTS.END);
+  }
+
+  /**
+   * @private
+   * @param e
+   */
+  errorHandler(e) {
+    this.stream.removeListener(EVENTS.ERROR, this.errorHandler);
+    if (e.code === GrpcErrorCodes.CANCELLED) {
+      return;
+    }
+    this.stopReconnectTimeout();
+
+    if (
+      this.maxRetriesOnError === -1 // Infinite retries
+      || this.retriesOnError < this.maxRetriesOnError // Limited retries
+    ) {
+      let newArgs = this.args;
+      const updateArgs = (...args) => {
+        newArgs = args;
+      };
+
+      this.emit(EVENTS.BEFORE_RECONNECT, updateArgs);
+
+      wait(this.retryOnErrorDelay)
+        .then(() => this.connect(...newArgs))
+        .then(() => {
+          this.retriesOnError += 1;
+        })
+        .catch((connectError) => {
+          this.emit(EVENTS.ERROR, connectError);
+        });
+    } else {
+      this.emit(EVENTS.ERROR, e);
+    }
+  }
+
+  /**
+   * @private
+   */
+  stopReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      this.clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+
+  cancel() {
+    this.stopReconnectTimeout();
+    return this.stream.cancel();
+  }
+
+  destroy(e) {
+    this.stream.destroy(e);
+  }
+}
+
+ReconnectableStream.EVENTS = EVENTS;
+
+module.exports = ReconnectableStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/dapi-client",
-  "version": "0.23.0-dev.9",
+  "version": "0.23.0",
   "description": "Client library used to access Dash DAPI endpoints",
   "main": "lib/index.js",
   "contributors": [
@@ -26,17 +26,18 @@
     }
   ],
   "dependencies": {
-    "@dashevo/dapi-grpc": "~0.23.0-dev.9",
-    "@dashevo/dash-spv": "~1.1.7-6",
-    "@dashevo/dashcore-lib": "~0.19.41",
-    "@dashevo/dpp": "~0.23.0-dev.9",
-    "@dashevo/grpc-common": "~0.23.0-dev.9",
+    "@dashevo/dapi-grpc": "0.23.0",
+    "@dashevo/dash-spv": "0.23.0",
+    "@dashevo/dashcore-lib": "~0.19.44",
+    "@dashevo/dpp": "0.23.0",
+    "@dashevo/grpc-common": "0.23.0",
     "@grpc/grpc-js": "^1.3.7",
-    "axios": "^0.21.1",
+    "axios": "^0.27.2",
     "bs58": "^4.0.1",
     "cbor": "^8.0.0",
     "lodash.sample": "^4.2.1",
-    "node-inspect-extracted": "^1.0.8"
+    "node-inspect-extracted": "^1.0.8",
+    "wasm-x11-hash": "~0.0.2"
   },
   "devDependencies": {
     "@babel/core": "^7.15.5",
@@ -54,7 +55,7 @@
     "eslint-plugin-import": "^2.24.2",
     "eslint-plugin-jsdoc": "^27.0.0",
     "events": "^3.3.0",
-    "karma": "^6.3.4",
+    "karma": "^6.4.1",
     "karma-chai": "^0.1.0",
     "karma-chrome-launcher": "^3.1.0",
     "karma-firefox-launcher": "^2.1.1",