@brimble/consul 0.0.1

package/lib/query.js

@@ -0,0 +1,244 @@
+const errors = require("./errors");
+const utils = require("./utils");
+
+class Query {
+  constructor(consul) {
+    this.consul = consul;
+  }
+
+  /**
+   * Lists all queries
+   */
+  async list(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.list",
+      path: "/query",
+    };
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Create a new query
+   */
+  async create(opts) {
+    if (typeof opts === "string") {
+      opts = { service: { service: opts } };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.create",
+      path: "/query",
+      query: {},
+      type: "json",
+    };
+
+    this._params(req, opts);
+
+    if (!req.body.Service || !req.body.Service.Service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts, { near: true });
+
+    return await this.consul._post(req, utils.body);
+  }
+
+  /**
+   * Gets a given query
+   */
+  async get(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.get",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.bodyItem);
+  }
+
+  /**
+   * Update existing query
+   */
+  async update(opts) {
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.update",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+      type: "json",
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    this._params(req, opts);
+
+    if (!req.body.Service || !req.body.Service.Service) {
+      throw this.consul._err(errors.Validation("service required"), req);
+    }
+
+    utils.options(req, opts, { near: true });
+
+    return await this.consul._put(req, utils.empty);
+  }
+
+  /**
+   * Destroys a given query
+   */
+  async destroy(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.destroy",
+      path: "/query/{query}",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._delete(req, utils.empty);
+  }
+
+  /**
+   * Executes a given query
+   */
+  async execute(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.execute",
+      path: "/query/{query}/execute",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.body);
+  }
+
+  /**
+   * Explain a given query
+   */
+  async explain(opts) {
+    if (typeof opts === "string") {
+      opts = { query: opts };
+    }
+
+    opts = utils.normalizeKeys(opts);
+    opts = utils.defaults(opts, this.consul._defaults);
+
+    const req = {
+      name: "query.explain",
+      path: "/query/{query}/explain",
+      params: { query: opts.query },
+      query: {},
+    };
+
+    if (!opts.query) {
+      throw this.consul._err(errors.Validation("query required"), req);
+    }
+
+    utils.options(req, opts);
+
+    return await this.consul._get(req, utils.bodyItem);
+  }
+
+  /**
+   * Generate body for query create and update
+   */
+  _params(req, opts) {
+    const body = req.body || {};
+
+    if (opts.name) body.Name = opts.name;
+    if (opts.session) body.Session = opts.session;
+    if (opts.token) {
+      body.Token = opts.token;
+      delete opts.token;
+    }
+    if (opts.near) body.Near = opts.near;
+    if (opts.template) {
+      const template = utils.normalizeKeys(opts.template);
+      if (template.type || template.regexp) {
+        body.Template = {};
+        if (template.type) body.Template.Type = template.type;
+        if (template.regexp) body.Template.Regexp = template.regexp;
+      }
+    }
+    if (opts.service) {
+      const service = utils.normalizeKeys(opts.service);
+      body.Service = {};
+      if (service.service) body.Service.Service = service.service;
+      if (service.failover) {
+        const failover = utils.normalizeKeys(service.failover);
+        if (typeof failover.nearestn === "number" || failover.datacenters) {
+          body.Service.Failover = {};
+          if (typeof failover.nearestn === "number") {
+            body.Service.Failover.NearestN = failover.nearestn;
+          }
+          if (failover.datacenters) {
+            body.Service.Failover.Datacenters = failover.datacenters;
+          }
+        }
+      }
+      if (typeof service.onlypassing === "boolean") {
+        body.Service.OnlyPassing = service.onlypassing;
+      }
+      if (service.tags) body.Service.Tags = service.tags;
+    }
+    if (opts.dns) {
+      const dns = utils.normalizeKeys(opts.dns);
+      if (dns.ttl) body.DNS = { TTL: dns.ttl };
+    }
+
+    req.body = body;
+  }
+}
+
+exports.Query = Query;

package/lib/resolver/algorithms.js

@@ -0,0 +1,127 @@
+"use strict";
+
+function roundRobinSelection(services, currentIndex) {
+  const healthyServices = services.filter((service) =>
+    service.Checks.every((check) => check.Status === "passing"),
+  );
+
+  if (healthyServices.length === 0) {
+    throw new Error("No healthy services available");
+  }
+
+  const service = healthyServices[currentIndex % healthyServices.length];
+  const nextIndex = (currentIndex + 1) % healthyServices.length;
+
+  return {
+    id: service.Service.ID,
+    service,
+    nextIndex,
+  };
+}
+
+function leastConnectionSelection(services, metrics, defaultMetrics) {
+  const healthyServices = services
+    .filter((service) =>
+      service.Checks.every((check) => check.Status === "passing"),
+    )
+    .map((service) => {
+      const serviceMetrics = metrics.get(service.Service.ID) || defaultMetrics;
+      return {
+        service,
+        connections: serviceMetrics.activeConnections || 0,
+      };
+    });
+
+  if (healthyServices.length === 0) {
+    throw new Error("No healthy services available");
+  }
+
+  const selectedService = healthyServices.reduce((min, current) =>
+    current.connections < min.connections ? current : min,
+  );
+
+  return {
+    id: selectedService.service.Service.ID,
+    service: selectedService.service,
+  };
+}
+
+function weightedRandomSelection(rankedServices) {
+  if (rankedServices.length === 0) {
+    throw new Error("No services available for selection");
+  }
+
+  const totalScore = rankedServices.reduce(
+    (sum, service) => sum + service.score,
+    0,
+  );
+
+  if (totalScore <= 0) {
+    return {
+      id: rankedServices[0].id,
+      service: rankedServices[0].service,
+    };
+  }
+
+  let random = Math.random() * totalScore;
+
+  for (const service of rankedServices) {
+    random -= service.score;
+    if (random <= 0) {
+      return {
+        id: service.id,
+        service: service.service,
+      };
+    }
+  }
+
+  return {
+    id: rankedServices[0].id,
+    service: rankedServices[0].service,
+  };
+}
+
+function roundRobinSrvSelection(records, currentIndex) {
+  if (!records || records.length === 0) {
+    return null;
+  }
+
+  const selected = records[currentIndex % records.length];
+  const nextIndex = (currentIndex + 1) % records.length;
+
+  return { selected, nextIndex };
+}
+
+function weightedSrvRecordSelection(records, currentIndex) {
+  if (!records || records.length === 0) {
+    return null;
+  }
+
+  const hasNonZeroWeights = records.some((record) => (record.weight || 0) > 0);
+
+  if (!hasNonZeroWeights) {
+    return roundRobinSrvSelection(records, currentIndex);
+  }
+
+  const totalWeight = records.reduce(
+    (sum, record) => sum + (record.weight || 1),
+    0,
+  );
+
+  let random = Math.random() * totalWeight;
+
+  for (const record of records) {
+    random -= record.weight || 1;
+    if (random <= 0) {
+      return { selected: record, nextIndex: currentIndex };
+    }
+  }
+
+  return { selected: records[0], nextIndex: currentIndex };
+}
+
+exports.roundRobinSelection = roundRobinSelection;
+exports.leastConnectionSelection = leastConnectionSelection;
+exports.weightedRandomSelection = weightedRandomSelection;
+exports.roundRobinSrvSelection = roundRobinSrvSelection;
+exports.weightedSrvRecordSelection = weightedSrvRecordSelection;

package/lib/resolver/dns.js

@@ -0,0 +1,182 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+const { query } = require("dns-query");
+const {
+  roundRobinSrvSelection,
+  weightedSrvRecordSelection,
+} = require("./algorithms");
+const { SelectionAlgorithm } = require("./types");
+
+class DNSManager {
+  constructor(
+    redis,
+    cachePrefix,
+    cacheTTL,
+    cacheEnabled,
+    debug,
+    dnsEndpoints,
+    dnsTimeout,
+    dnsRetries,
+  ) {
+    this.redis = redis;
+    this.cachePrefix = cachePrefix;
+    this.cacheTTL = cacheTTL;
+    this.cacheEnabled = cacheEnabled;
+    this.debug = debug;
+    this.dnsEndpoints = dnsEndpoints;
+    this.dnsTimeout = dnsTimeout;
+    this.dnsRetries = dnsRetries;
+  }
+
+  getDNSCacheKey(service) {
+    return `${this.cachePrefix}:dns:${service}`;
+  }
+
+  async resolveDNS(service) {
+    const cacheKey = this.getDNSCacheKey(service);
+
+    if (this.cacheEnabled) {
+      try {
+        const cachedData = await Promise.race([
+          this.redis?.get(cacheKey),
+          new Promise((_, reject) =>
+            setTimeout(() => reject(new Error("Redis get timeout")), 200),
+          ),
+        ]);
+        if (cachedData) {
+          if (this.debug) {
+            log.debug(`DNS cache hit for ${service}`);
+          }
+          return JSON.parse(cachedData);
+        }
+      } catch (e) {
+        if (this.debug) log.error("Redis get error or timeout:", e);
+      }
+    }
+
+    try {
+      const result = await query(
+        {
+          question: {
+            type: "SRV",
+            name: service,
+          },
+        },
+        {
+          endpoints: this.dnsEndpoints,
+          timeout: this.dnsTimeout ?? 1500,
+          retries: this.dnsRetries ?? 2,
+        },
+      );
+
+      if (this.debug) {
+        log.debug("DNS QUERY RESULT", result);
+      }
+
+      if (!result.answers || result.answers.length === 0) {
+        if (this.debug) {
+          log.debug(`No SRV records found for ${service}`);
+        }
+        return [];
+      }
+
+      const additionalsByName = {};
+      if (result.additionals) {
+        for (const additional of result.additionals) {
+          if (additional.type === "A") {
+            additionalsByName[additional.name] = additional;
+          }
+        }
+      }
+      const records = result.answers
+        .map((answer) => {
+          const target = answer.data.target;
+          const aRecord = additionalsByName[target];
+          return {
+            name: target,
+            ip: aRecord?.data || "",
+            port: answer.data.port,
+            priority: answer.data.priority,
+            weight: answer.data.weight,
+          };
+        })
+        .filter((record) => record.ip);
+
+      if (this.cacheEnabled) {
+        try {
+          await Promise.race([
+            this.redis?.set(
+              cacheKey,
+              JSON.stringify(records),
+              "EX",
+              this.cacheTTL,
+            ),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error("Redis set timeout")), 200),
+            ),
+          ]);
+        } catch (e) {
+          if (this.debug) log.error("Redis set error or timeout:", e);
+        }
+      }
+
+      return records;
+    } catch (error) {
+      if (this.debug) {
+        log.error("DNS resolution error:", error);
+      }
+      return [];
+    }
+  }
+
+  sortByPriority(records) {
+    return [...records].sort((a, b) => (a.priority || 0) - (b.priority || 0));
+  }
+
+  selectFromSrvRecords(records, algorithm, currentIndex) {
+    if (!records || records.length === 0) {
+      return { selected: null, nextIndex: currentIndex };
+    }
+
+    switch (algorithm) {
+      case SelectionAlgorithm.RoundRobin: {
+        const rrResult = roundRobinSrvSelection(records, currentIndex);
+        if (!rrResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: rrResult.selected,
+          nextIndex: rrResult.nextIndex,
+        };
+      }
+
+      case SelectionAlgorithm.WeightedRoundRobin: {
+        const wrResult = weightedSrvRecordSelection(records, currentIndex);
+        if (!wrResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: wrResult.selected,
+          nextIndex: wrResult.nextIndex,
+        };
+      }
+
+      case SelectionAlgorithm.LeastConnection: {
+        const lcResult = roundRobinSrvSelection(records, currentIndex);
+        if (!lcResult) {
+          return { selected: null, nextIndex: currentIndex };
+        }
+        return {
+          selected: lcResult.selected,
+          nextIndex: lcResult.nextIndex,
+        };
+      }
+
+      default:
+        return { selected: records[0], nextIndex: currentIndex };
+    }
+  }
+}
+
+exports.DNSManager = DNSManager;

package/lib/resolver/health.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const { log } = require("@brimble/utils");
+
+class HealthCheckManager {
+  constructor(consul, redis, cachePrefix, cacheTTL, cacheEnabled, debug) {
+    this.consul = consul;
+    this.redis = redis;
+    this.cachePrefix = cachePrefix;
+    this.cacheTTL = cacheTTL;
+    this.cacheEnabled = cacheEnabled;
+    this.debug = debug;
+  }
+
+  getHealthCacheKey(service) {
+    return `${this.cachePrefix}:health:${service}`;
+  }
+
+  async getHealthChecks(service) {
+    const cacheKey = this.getHealthCacheKey(service);
+
+    if (this.cacheEnabled) {
+      const cachedHealth = await this.redis?.get(cacheKey);
+      if (cachedHealth) {
+        return JSON.parse(cachedHealth);
+      }
+    }
+
+    try {
+      const healthChecks = await this.consul.health.service(service);
+
+      if (this.cacheEnabled) {
+        await this.redis?.set(
+          cacheKey,
+          JSON.stringify(healthChecks),
+          "EX",
+          this.cacheTTL,
+        );
+      }
+
+      return healthChecks;
+    } catch (error) {
+      if (this.debug) {
+        log.error(`Error fetching health checks for ${service}:`, error);
+      }
+      return [];
+    }
+  }
+}
+
+exports.HealthCheckManager = HealthCheckManager;