@brimble/consul 2.0.1

package/lib/watch.js

@@ -0,0 +1,183 @@
+const events = require("events");
+
+const errors = require("./errors");
+const utils = require("./utils");
+
+/**
+ * Initialize a new `Watch` instance.
+ */
+
+class Watch extends events.EventEmitter {
+  constructor(consul, opts) {
+    super();
+
+    this.consul = consul;
+
+    opts = utils.normalizeKeys(opts);
+
+    let options = utils.normalizeKeys(opts.options || {});
+    options = utils.defaults(options, consul._defaults);
+    options.wait = options.wait || "30s";
+    options.index = utils.safeBigInt(options.index || "0");
+
+    if (
+      typeof options.timeout !== "string" &&
+      typeof options.timeout !== "number"
+    ) {
+      const wait = utils.parseDuration(options.wait);
+      // A small random amount of additional wait time is added to the supplied
+      // maximum wait time to spread out the wake up time of any concurrent
+      // requests. This adds up to wait / 16 additional time to the maximum duration.
+      options.timeout = Math.ceil(wait + Math.max(wait * 0.1, 500));
+    }
+
+    let backoffFactor = 100;
+    if (
+      opts.hasOwnProperty("backofffactor") &&
+      typeof opts.backofffactor === "number"
+    ) {
+      backoffFactor = opts.backofffactor;
+    }
+    let backoffMax = 30 * 1000;
+    if (
+      opts.hasOwnProperty("backoffmax") &&
+      typeof opts.backoffmax === "number"
+    ) {
+      backoffMax = opts.backoffmax;
+    }
+    let maxAttempts = -1;
+    if (
+      opts.hasOwnProperty("maxattempts") &&
+      typeof opts.maxattempts === "number"
+    ) {
+      maxAttempts = opts.maxattempts;
+    }
+
+    this._context = { consul: consul };
+    this._options = options;
+    this._attempts = 0;
+    this._maxAttempts = maxAttempts;
+    this._backoffMax = backoffMax;
+    this._backoffFactor = backoffFactor;
+    this._method = opts.method;
+    this.includeResponse = true;
+
+    if (typeof opts.method !== "function") {
+      throw errors.Validation("method required");
+    }
+
+    process.nextTick(() => this._run());
+  }
+
+  /**
+   * Is running
+   */
+  isRunning() {
+    return !this._end;
+  }
+
+  /**
+   * Update time
+   */
+  updateTime() {
+    return this._updateTime;
+  }
+
+  /**
+   * End watch
+   */
+  end() {
+    if (this._end) return;
+    this._end = true;
+
+    this.emit("cancel");
+    this.emit("end");
+  }
+
+  /**
+   * Wait
+   */
+  _wait() {
+    this._attempts += 1;
+    if (this._attemptsMaxed) {
+      return this._backoffMax;
+    }
+    const timeout = Math.pow(2, this._attempts) * this._backoffFactor;
+    if (timeout < this._backoffMax) {
+      return timeout;
+    } else {
+      this._attemptsMaxed = true;
+      return this._backoffMax;
+    }
+  }
+
+  /**
+   * Error helper
+   */
+  _err(err, res) {
+    if (this._end) return;
+
+    this.emit("error", err, res);
+
+    if (err && err.isValidation) return this.end();
+    if (res && res.statusCode === 400) return this.end();
+    if (this._maxAttempts >= 0 && this._attempts >= this._maxAttempts)
+      return this.end();
+
+    utils.setTimeoutContext(
+      () => {
+        this._run();
+      },
+      this,
+      this._wait(),
+    );
+  }
+
+  /**
+   * Run
+   */
+  _run() {
+    if (this._end) return;
+
+    const opts = utils.clone(this._options);
+    opts.ctx = this;
+
+    this._method
+      .call(this._context, opts)
+      .then(([res, data]) => {
+        this._updateTime = +new Date();
+
+        this._attempts = 0;
+        this._attemptsMaxed = false;
+
+        const newIndex = utils.safeBigInt(res.headers["x-consul-index"]);
+        if (newIndex === undefined) {
+          return this._err(errors.Validation("Watch not supported"), res);
+        }
+        if (newIndex === 0n) {
+          return this._err(
+            errors.Consul("Consul returned zero index value"),
+            res,
+          );
+        }
+
+        const prevIndex = this._options.index;
+        const reset = prevIndex !== undefined && newIndex < prevIndex;
+
+        if (reset || utils.hasIndexChanged(newIndex, prevIndex)) {
+          this._options.index = reset ? 0n : newIndex;
+
+          this.emit("change", data, res);
+        }
+
+        process.nextTick(() => {
+          this._run();
+        });
+      })
+      .catch((err) => {
+        this._err(err, err.response);
+      });
+  }
+}
+
+exports.Watch = Watch;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@brimble/consul",
+  "version": "2.0.1",
+  "description": "Consul client",
+  "main": "./lib",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "./lib"
+  ],
+  "dependencies": {
+    "papi": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.6",
+    "async": "^3.2.0",
+    "debug": "^4.3.1",
+    "jshint": "^2.5.5",
+    "mocha": "^10.7.3",
+    "nock": "^13.0.7",
+    "nyc": "^17.1.0",
+    "prettier": "^3.3.3",
+    "should": "^13.2.1",
+    "sinon": "^19.0.2",
+    "temp": "^0.9.4",
+    "tsd": "^0.31.2",
+    "uuid": "^10.0.0"
+  },
+  "keywords": [
+    "consul"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/silas/node-consul.git"
+  },
+  "bugs": {
+    "url": "https://github.com/silas/node-consul/issues"
+  },
+  "author": "Silas Sewell <silas@sewell.org>",
+  "contributors": [
+    "Muritala David"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "format": "prettier -w .",
+    "test": "jshint lib test && prettier -c . && nyc mocha -- --recursive --check-leaks && nyc check-coverage --statements 100 --functions 100 --branches 100 --lines 100",
+    "types": "tsd",
+    "acceptance": "ACCEPTANCE=true nyc mocha -- test/acceptance --recursive --check-leaks --timeout 30000",
+    "acceptanceSetupMacOS": "sudo ifconfig lo0 alias 127.0.0.2 up && sudo ifconfig lo0 alias 127.0.0.3 up"
+  }
+}