@routr/location 2.0.5-alpha.2 → 2.0.5-alpha.3

package/dist/config/get_config.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -52,41 +41,50 @@ exports.getConfig = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var types_1 = require("../types");
-var fs_1 = __importDefault(require("fs"));
-var schema_1 = require("./schema");
-var ajv_1 = __importDefault(require("ajv"));
-var E = __importStar(require("fp-ts/Either"));
-var errors_1 = require("../errors");
-var ajv = new ajv_1.default();
-var validate = ajv.compile(schema_1.schema);
-var getConfig = function (path) {
-    var c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
-    if (!validate(__assign({}, c))) {
+const types_1 = require("../types");
+const fs_1 = __importDefault(require("fs"));
+const schema_1 = require("./schema");
+const ajv_1 = __importDefault(require("ajv"));
+const E = __importStar(require("fp-ts/Either"));
+const errors_1 = require("../errors");
+const ajv = new ajv_1.default();
+const validate = ajv.compile(schema_1.schema);
+const hasBadCombiniation = (backends) => backends.some((b) => b.balancingAlgorithm === types_1.LB_ALGORITHM.ROUND_ROBIN && b.sessionAffinity);
+const hasBadAlgorithm = (backends) => backends.some((b) => b.balancingAlgorithm !== types_1.LB_ALGORITHM.ROUND_ROBIN
+    && b.balancingAlgorithm !== types_1.LB_ALGORITHM.LEAST_SESSIONS);
+const getConfig = (path) => {
+    var _a, _b, _c;
+    const c = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
+    if (!validate(Object.assign({}, c))) {
         return E.left(new errors_1.InvalidSchemaConfiguration(JSON.stringify(validate.errors[0].message)));
     }
-    var config = c.spec;
+    const config = c.spec;
     if (config.backends) {
-        config.backends.map(function (b) {
+        config.backends.map((b) => {
             // Setting round-robin by default
             b.balancingAlgorithm = b.balancingAlgorithm
                 ? b.balancingAlgorithm : types_1.LB_ALGORITHM.ROUND_ROBIN;
             return b;
         });
-        var hasBadCombiniation = config.backends.some(function (b) {
-            return b.balancingAlgorithm === types_1.LB_ALGORITHM.ROUND_ROBIN && b.sessionAffinity;
-        });
-        var hasBadAlgorithm = config.backends.some(function (b) {
-            return b.balancingAlgorithm !== types_1.LB_ALGORITHM.ROUND_ROBIN
-                && b.balancingAlgorithm !== types_1.LB_ALGORITHM.LEAST_SESSIONS;
-        });
-        if (hasBadCombiniation) {
+        if (hasBadCombiniation(config.backends)) {
             return E.left(new errors_1.BadAlgorithmAndAffinityCombination());
         }
-        if (hasBadAlgorithm) {
+        if (hasBadAlgorithm(config.backends)) {
             return E.left(new errors_1.InvalidLoadBalancerAlgorithm());
         }
     }
+    if (!((_a = config === null || config === void 0 ? void 0 : config.cache) === null || _a === void 0 ? void 0 : _a.provider)) {
+        config.cache = {
+            provider: types_1.CACHE_PROVIDER.MEMORY
+        };
+    }
+    if (((_b = config === null || config === void 0 ? void 0 : config.cache) === null || _b === void 0 ? void 0 : _b.provider) === types_1.CACHE_PROVIDER.REDIS &&
+        !((_c = config === null || config === void 0 ? void 0 : config.cache) === null || _c === void 0 ? void 0 : _c.parameters)) {
+        config.cache = {
+            provider: types_1.CACHE_PROVIDER.REDIS,
+            parameters: "host=localhost,port=6379"
+        };
+    }
     return E.right(config);
 };
 exports.getConfig = getConfig;

package/dist/config/schema.d.ts

@@ -22,6 +22,18 @@ export declare const schema: {
                     description: string;
                     type: string;
                 };
+                cache: {
+                    type: string;
+                    properties: {
+                        provider: {
+                            enum: string[];
+                        };
+                        parameters: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
                 backends: {
                     description: string;
                     type: string;

package/dist/config/schema.js

@@ -43,6 +43,18 @@ exports.schema = {
                     "description": "Ipv4 interface to accept request on",
                     "type": "string"
                 },
+                "cache": {
+                    "type": "object",
+                    "properties": {
+                        "provider": {
+                            "enum": ["memory", "redis"]
+                        },
+                        "parameters": {
+                            "type": "string"
+                        },
+                    },
+                    "required": ["provider"]
+                },
                 "backends": {
                     "description": "Optional SIP backends",
                     "type": "array",
@@ -54,7 +66,7 @@ exports.schema = {
                             "type": "string"
                         },
                         "balancingAlgorithm": {
-                            "enum": ["ROUND_ROBIN", "LEAST_SESSIONS"]
+                            "enum": ["round-robin", "least-sessions"]
                         },
                         "sessionAffinity": {
                             "description": "Optional session affinity",

package/dist/errors.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidLoadBalancerAlgorithm = exports.BadAlgorithmAndAffinityCombination = exports.InvalidSchemaConfiguration = exports.NotRoutesFoundForAOR = exports.UnsupportedSchema = void 0;
 /*
@@ -34,58 +19,43 @@ exports.InvalidLoadBalancerAlgorithm = exports.BadAlgorithmAndAffinityCombinatio
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var grpc = require("@grpc/grpc-js");
-var UnsupportedSchema = /** @class */ (function (_super) {
-    __extends(UnsupportedSchema, _super);
-    function UnsupportedSchema(aor) {
-        var _this = _super.call(this, "aor " + aor + " has an invalid schema, only \"sip:\" or \"backend:\" are allowed") || this;
-        _this.code = grpc.status.INVALID_ARGUMENT;
+const grpc = require("@grpc/grpc-js");
+class UnsupportedSchema extends Error {
+    constructor(aor) {
+        super(`aor ${aor} has an invalid schema, only "sip:" or "backend:" are allowed`);
+        this.code = grpc.status.INVALID_ARGUMENT;
         // Set the prototype explicitly.
-        Object.setPrototypeOf(_this, UnsupportedSchema.prototype);
-        return _this;
+        Object.setPrototypeOf(this, UnsupportedSchema.prototype);
     }
-    return UnsupportedSchema;
-}(Error));
+}
 exports.UnsupportedSchema = UnsupportedSchema;
-var NotRoutesFoundForAOR = /** @class */ (function (_super) {
-    __extends(NotRoutesFoundForAOR, _super);
-    function NotRoutesFoundForAOR(aor) {
-        var _this = _super.call(this, "no routes found for aor " + aor) || this;
-        _this.code = grpc.status.NOT_FOUND;
-        Object.setPrototypeOf(_this, NotRoutesFoundForAOR.prototype);
-        return _this;
+class NotRoutesFoundForAOR extends Error {
+    constructor(aor) {
+        super(`no routes found for aor ${aor}`);
+        this.code = grpc.status.NOT_FOUND;
+        Object.setPrototypeOf(this, NotRoutesFoundForAOR.prototype);
     }
-    return NotRoutesFoundForAOR;
-}(Error));
+}
 exports.NotRoutesFoundForAOR = NotRoutesFoundForAOR;
-var InvalidSchemaConfiguration = /** @class */ (function (_super) {
-    __extends(InvalidSchemaConfiguration, _super);
-    function InvalidSchemaConfiguration(msg) {
-        var _this = _super.call(this, msg) || this;
-        _this.code = grpc.status.INVALID_ARGUMENT;
-        Object.setPrototypeOf(_this, InvalidSchemaConfiguration.prototype);
-        return _this;
+class InvalidSchemaConfiguration extends Error {
+    constructor(msg) {
+        super(msg);
+        this.code = grpc.status.INVALID_ARGUMENT;
+        Object.setPrototypeOf(this, InvalidSchemaConfiguration.prototype);
     }
-    return InvalidSchemaConfiguration;
-}(Error));
+}
 exports.InvalidSchemaConfiguration = InvalidSchemaConfiguration;
-var BadAlgorithmAndAffinityCombination = /** @class */ (function (_super) {
-    __extends(BadAlgorithmAndAffinityCombination, _super);
-    function BadAlgorithmAndAffinityCombination() {
-        var _this = _super.call(this, "session affinity can not be combined with round-robin load balancing") || this;
-        Object.setPrototypeOf(_this, BadAlgorithmAndAffinityCombination.prototype);
-        return _this;
+class BadAlgorithmAndAffinityCombination extends Error {
+    constructor() {
+        super("session affinity can not be combined with round-robin load balancing");
+        Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
     }
-    return BadAlgorithmAndAffinityCombination;
-}(Error));
+}
 exports.BadAlgorithmAndAffinityCombination = BadAlgorithmAndAffinityCombination;
-var InvalidLoadBalancerAlgorithm = /** @class */ (function (_super) {
-    __extends(InvalidLoadBalancerAlgorithm, _super);
-    function InvalidLoadBalancerAlgorithm() {
-        var _this = _super.call(this, "found invalid load balancing algorithm. must be round-robin or least-sessions") || this;
-        Object.setPrototypeOf(_this, BadAlgorithmAndAffinityCombination.prototype);
-        return _this;
+class InvalidLoadBalancerAlgorithm extends Error {
+    constructor() {
+        super("found invalid load balancing algorithm. must be round-robin or least-sessions");
+        Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
     }
-    return InvalidLoadBalancerAlgorithm;
-}(Error));
+}
 exports.InvalidLoadBalancerAlgorithm = InvalidLoadBalancerAlgorithm;

package/dist/locator.js

@@ -8,33 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 /*
  * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
@@ -54,99 +27,75 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var errors_1 = require("./errors");
-var types_1 = require("./types");
-var utils_1 = require("./utils");
-var Locator = /** @class */ (function () {
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class Locator {
     // Should fail if any backend has sessionAffinity and round-robin
-    function Locator(store, backends) {
-        var _this = this;
-        if (backends === void 0) { backends = new Map(); }
+    constructor(store, backends = new Map()) {
         this.store = store;
         this.backends = backends;
         this.rrCount = new Map();
         this.affinityStore = new Map();
-        this.backends.forEach(function (value, key) { return _this.rrCount.set(key, 0); });
+        this.backends.forEach((value, key) => this.rrCount.set(key, 0));
     }
-    Locator.prototype.addRoute = function (request) {
+    addRoute(request) {
         if (!request.aor.startsWith('sip:') &&
             !request.aor.startsWith('backend:')) {
             throw new errors_1.UnsupportedSchema(request.aor);
         }
         return this.store.put(request.aor, request.route);
-    };
-    Locator.prototype.findRoutes = function (request) {
-        return __awaiter(this, void 0, void 0, function () {
-            var routes, _a, backend, _b, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!request.labels) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.store.get(request.aor)];
-                    case 1:
-                        _a = (_d.sent())
-                            .filter(utils_1.filterOnlyMatchingLabels(request.labels));
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.store.get(request.aor)];
-                    case 3:
-                        _a = (_d.sent()) || [];
-                        _d.label = 4;
-                    case 4:
-                        routes = _a;
-                        if (!request.aor.startsWith('sip:')) return [3 /*break*/, 5];
-                        return [2 /*return*/, routes];
-                    case 5:
-                        if (!request.aor.startsWith('backend:')) return [3 /*break*/, 9];
-                        backend = this.backends.get(request.aor);
-                        if (!backend) {
-                            throw new errors_1.NotRoutesFoundForAOR(request.aor);
-                        }
-                        if (!!utils_1.hasAffinitySession(backend)) return [3 /*break*/, 6];
-                        _b = [this.next(routes, backend)];
-                        return [3 /*break*/, 8];
-                    case 6:
-                        _c = this.nextWithAffinity;
-                        return [4 /*yield*/, routes];
-                    case 7:
-                        _b = [_c.apply(this, [_d.sent(), backend.sessionAffinity.ref])];
-                        _d.label = 8;
-                    case 8: 
-                    // If it has not affinity sesssion then get next
-                    return [2 /*return*/, _b];
-                    case 9: throw new errors_1.UnsupportedSchema(request.aor);
+    }
+    findRoutes(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = request.labels
+                ? (yield this.store.get(request.aor))
+                    .filter(utils_1.filterOnlyMatchingLabels(request.labels))
+                : (yield this.store.get(request.aor)) || [];
+            if (request.aor.startsWith('sip:')) {
+                return routes;
+            }
+            else if (request.aor.startsWith('backend:')) {
+                const backend = this.backends.get(request.aor);
+                if (!backend) {
+                    throw new errors_1.NotRoutesFoundForAOR(request.aor);
                 }
-            });
+                // If it has not affinity sesssion then get next
+                return !utils_1.hasAffinitySession(backend)
+                    ? [this.next(routes, backend)]
+                    : [this.nextWithAffinity(yield routes, backend.sessionAffinity.ref)];
+            }
+            throw new errors_1.UnsupportedSchema(request.aor);
         });
-    };
-    Locator.prototype.removeRoutes = function (request) {
+    }
+    removeRoutes(request) {
         return this.store.delete(request.aor);
-    };
-    Locator.prototype.next = function (routes, backend) {
+    }
+    next(routes, backend) {
         if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
-            return routes.sort(function (r1, r2) { return r1.sessionCount - r2.sessionCount; })[0];
+            return routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
         }
         // Continues using round-robin
-        var nextPosition = this.rrCount.get("backend:" + backend.ref);
-        var result = routes[nextPosition];
+        const nextPosition = this.rrCount.get(`backend:${backend.ref}`);
+        const result = routes[nextPosition];
         if (nextPosition >= (routes.length - 1)) {
             // Restarting round-robin counter
-            this.rrCount.set("backend:" + backend.ref, 0);
+            this.rrCount.set(`backend:${backend.ref}`, 0);
         }
         else {
-            this.rrCount.set("backend:" + backend.ref, nextPosition + 1);
+            this.rrCount.set(`backend:${backend.ref}`, nextPosition + 1);
         }
         return result;
-    };
+    }
     // Backend with session affinity does not support round-robin
-    Locator.prototype.nextWithAffinity = function (routes, sessionAffinityRef) {
-        var route = this.affinityStore.get(sessionAffinityRef);
+    nextWithAffinity(routes, sessionAffinityRef) {
+        let route = this.affinityStore.get(sessionAffinityRef);
         if (route) {
             return route;
         }
-        route = routes.sort(function (r1, r2) { return r1.sessionCount - r2.sessionCount; })[0];
+        route = routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
         this.affinityStore.set(sessionAffinityRef, route);
         return route;
-    };
-    return Locator;
-}());
+    }
+}
 exports.default = Locator;

package/dist/memory_store.js

@@ -1,49 +1,27 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var utils_1 = require("./utils");
-var MAX_CYCLES_BEFORE_CLEANUP = 10000;
-var MemoryStore = /** @class */ (function () {
-    function MemoryStore(maxCyclesBeforeCleanup) {
-        if (maxCyclesBeforeCleanup === void 0) { maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP; }
+const utils_1 = require("./utils");
+const MAX_CYCLES_BEFORE_CLEANUP = 10000;
+class MemoryStore {
+    constructor(maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP) {
         this.collections = new Map();
         this.maxCyclesBeforeCleanup = maxCyclesBeforeCleanup;
     }
-    MemoryStore.prototype.put = function (key, route) {
-        var routes = __spreadArray([], __read(this.collections.get(key) || []));
+    put(key, route) {
+        const routes = [...this.collections.get(key) || []];
         // Avoids duplicate or expired routes
-        var filteredRoutes = routes
+        const filteredRoutes = routes
             .filter(utils_1.expiredFilter)
-            .filter(function (r) { return utils_1.duplicateFilter(r, route); });
+            .filter(r => utils_1.duplicateFilter(r, route));
         if (filteredRoutes.length > 0) {
-            this.collections.set(key, __spreadArray([route], __read(filteredRoutes)));
+            this.collections.set(key, [route, ...filteredRoutes]);
         }
         else {
             this.collections.set(key, [route]);
         }
         return;
-    };
-    MemoryStore.prototype.get = function (key) {
+    }
+    get(key) {
         // Cleanup every so often to avoid memory build up
         this.cleanupCount++;
         if (this.cleanupCount >= this.maxCyclesBeforeCleanup) {
@@ -51,27 +29,25 @@ var MemoryStore = /** @class */ (function () {
             this.cleanup();
         }
         return Promise.resolve(this.collections.get(key) || []);
-    };
-    MemoryStore.prototype.delete = function (key) {
+    }
+    delete(key) {
         this.collections.delete(key);
         return;
-    };
-    MemoryStore.prototype.size = function () {
+    }
+    size() {
         return this.collections.size;
-    };
-    MemoryStore.prototype.cleanup = function () {
-        var _this = this;
+    }
+    cleanup() {
         // Remove any expired route from collection
-        this.collections.forEach(function (routes, key) {
-            var filteredRoutes = routes.filter(utils_1.expiredFilter);
+        this.collections.forEach((routes, key) => {
+            const filteredRoutes = routes.filter(utils_1.expiredFilter);
             if (filteredRoutes.length > 0) {
-                _this.collections.set(key, filteredRoutes);
+                this.collections.set(key, filteredRoutes);
             }
             else {
-                _this.collections.delete(key);
+                this.collections.delete(key);
             }
         });
-    };
-    return MemoryStore;
-}());
+    }
+}
 exports.default = MemoryStore;

package/dist/redis_store.d.ts

@@ -0,0 +1,8 @@
+import { ILocatorStore, RedisStoreConfig, Route } from "./types";
+export default class RedisStore implements ILocatorStore {
+    client: any;
+    constructor(config?: RedisStoreConfig);
+    put(key: string, route: Route): Promise<void>;
+    get(key: string): Promise<Route[]>;
+    delete(key: string): Promise<void>;
+}

package/dist/redis_store.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("redis");
+const utils_1 = require("./utils");
+const logger_1 = __importDefault(require("@fonoster/logger"));
+class RedisStore {
+    constructor(config) {
+        this.client = config ? redis_1.createClient({ url: utils_1.getUrlString(config) }) : redis_1.createClient();
+        this.client.connect();
+        this.client.on('error', (err) => logger_1.default.error('redis client error: ', err));
+    }
+    put(key, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Formatted the key to ensure it is unique
+            logger_1.default.verbose(`${key}:${route.user}${route.host}${route.port}`);
+            yield this.client.set(`${key}:${route.user}${route.host}${route.port}`, JSON.stringify(route), {
+                EX: route.expires
+            });
+            return;
+        });
+    }
+    get(key) {
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = [];
+            try {
+                for (var _b = __asyncValues(yield this.client.scanIterator({
+                    CURSOR: 0,
+                    MATCH: `${key}:*`
+                })), _c; _c = yield _b.next(), !_c.done;) {
+                    const k = _c.value;
+                    routes.push(JSON.parse(yield this.client.get(k)));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return routes;
+        });
+    }
+    delete(key) {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (var _b = __asyncValues(yield this.client.scanIterator({
+                    CURSOR: 0,
+                    MATCH: `${key}:*`
+                })), _c; _c = yield _b.next(), !_c.done;) {
+                    const k = _c.value;
+                    yield this.client.del(k);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return;
+        });
+    }
+}
+exports.default = RedisStore;

package/dist/runner.js

@@ -22,10 +22,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logger_1 = __importDefault(require("@fonoster/logger"));
-var service_1 = __importDefault(require("./service"));
-var get_config_1 = require("./config/get_config");
-var result = get_config_1.getConfig(process.env.CONFIG_PATH);
+const logger_1 = __importDefault(require("@fonoster/logger"));
+const service_1 = __importDefault(require("./service"));
+const get_config_1 = require("./config/get_config");
+const result = get_config_1.getConfig(process.env.CONFIG_PATH);
 if (result._tag === 'Right') {
     service_1.default(result.right);
 }

package/dist/service.js

@@ -3,12 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("@routr/common");
-var utils_1 = require("./utils");
-var locator_1 = __importDefault(require("./locator"));
-var memory_store_1 = __importDefault(require("./memory_store"));
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * 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.
+ */
+const types_1 = require("./types");
+const common_1 = require("@routr/common");
+const utils_1 = require("./utils");
+const locator_1 = __importDefault(require("./locator"));
+const memory_store_1 = __importDefault(require("./memory_store"));
+const redis_store_1 = __importDefault(require("./redis_store"));
+const logger_1 = __importDefault(require("@fonoster/logger"));
+const allowedParameters = ["host", "port", "username", "password", "secure"];
 function LocationService(config) {
-    var bindAddr = config.bindAddr;
-    common_1.createService(utils_1.getServiceInfo(bindAddr, new locator_1.default(new memory_store_1.default())));
+    const { bindAddr, cache } = config;
+    let store;
+    if (cache.provider === types_1.CACHE_PROVIDER.REDIS) {
+        store = new redis_store_1.default(utils_1.configFromString(cache.parameters, allowedParameters));
+    }
+    else {
+        store = new memory_store_1.default();
+    }
+    const backends = new Map();
+    config.backends.forEach(b => backends.set(`backend:${b.ref}`, b));
+    common_1.createService(utils_1.getServiceInfo(bindAddr, new locator_1.default(store, backends)));
+    logger_1.default.info(`using ${cache.provider} as cache provider`);
 }
 exports.default = LocationService;

package/dist/types.d.ts

@@ -2,6 +2,10 @@ export declare enum LB_ALGORITHM {
     ROUND_ROBIN = "round-robin",
     LEAST_SESSIONS = "least-sessions"
 }
+export declare enum CACHE_PROVIDER {
+    MEMORY = "memory",
+    REDIS = "redis"
+}
 export interface ILocationService {
     addRoute(request: AddRouteRequest): Promise<void>;
     findRoutes(request: FindRoutesRequest): Promise<Route[]>;
@@ -49,4 +53,15 @@ export interface Backend {
 export interface LocationConfig {
     bindAddr: string;
     backends?: Backend[];
+    cache?: {
+        provider: CACHE_PROVIDER;
+        parameters: string;
+    };
+}
+export interface RedisStoreConfig {
+    username?: string;
+    password?: string;
+    host: string;
+    port: number;
+    secure?: boolean;
 }

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LB_ALGORITHM = void 0;
+exports.CACHE_PROVIDER = exports.LB_ALGORITHM = void 0;
 /*
  * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/routr
@@ -24,3 +24,8 @@ var LB_ALGORITHM;
     LB_ALGORITHM["ROUND_ROBIN"] = "round-robin";
     LB_ALGORITHM["LEAST_SESSIONS"] = "least-sessions";
 })(LB_ALGORITHM = exports.LB_ALGORITHM || (exports.LB_ALGORITHM = {}));
+var CACHE_PROVIDER;
+(function (CACHE_PROVIDER) {
+    CACHE_PROVIDER["MEMORY"] = "memory";
+    CACHE_PROVIDER["REDIS"] = "redis";
+})(CACHE_PROVIDER = exports.CACHE_PROVIDER || (exports.CACHE_PROVIDER = {}));

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { Backend, ILocationService, Route } from "./types";
+import { Backend, ILocationService, RedisStoreConfig, Route } from "./types";
 import { ServiceInfo } from "@routr/common";
 export declare const expiredFilter: (r: Route) => boolean;
 export declare const duplicateFilter: (r1: Route, r2: Route) => boolean;
@@ -7,3 +7,5 @@ export declare const compareArrays: (arr: string[], target: string[]) => boolean
 export declare const filterOnlyMatchingLabels: (requestLabels: Map<string, string>) => (route: Route) => boolean;
 export declare const hasAffinitySession: (backend: Backend) => boolean;
 export declare function getServiceInfo(bindAddr: string, locator: ILocationService): ServiceInfo;
+export declare const configFromString: (params: string, allowedKeys: string[]) => Record<string, string | boolean>;
+export declare const getUrlString: (config: RedisStoreConfig) => string;

package/dist/utils.js

@@ -8,67 +8,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServiceInfo = exports.hasAffinitySession = exports.filterOnlyMatchingLabels = exports.compareArrays = exports.mergeKeyValue = exports.duplicateFilter = exports.expiredFilter = void 0;
-var common_1 = require("@routr/common");
-var errors_1 = require("./errors");
-var expiredFilter = function (r) {
-    return (r.expires - (Date.now() - r.registeredOn) / 1000) > 0;
-};
+exports.getUrlString = exports.configFromString = exports.getServiceInfo = exports.hasAffinitySession = exports.filterOnlyMatchingLabels = exports.compareArrays = exports.mergeKeyValue = exports.duplicateFilter = exports.expiredFilter = void 0;
+const common_1 = require("@routr/common");
+const errors_1 = require("./errors");
+const expiredFilter = (r) => (r.expires - (Date.now() - r.registeredOn) / 1000) > 0;
 exports.expiredFilter = expiredFilter;
-var duplicateFilter = function (r1, r2) {
-    return !(r1.host === r2.host && r1.port === r2.port);
-};
+const duplicateFilter = (r1, r2) => !(r1.host === r2.host && r1.port === r2.port);
 exports.duplicateFilter = duplicateFilter;
-var mergeKeyValue = function (map) { return Array.from(map).map(function (l) { return l[0] + l[1]; }); };
+const mergeKeyValue = (map) => Array.from(map).map(l => l[0] + l[1]);
 exports.mergeKeyValue = mergeKeyValue;
-var compareArrays = function (arr, target) {
-    return target.every(function (v) { return arr.includes(v); }) && arr.length === target.length;
-};
+const compareArrays = (arr, target) => target.every(v => arr.includes(v)) && arr.length === target.length;
 exports.compareArrays = compareArrays;
-var filterOnlyMatchingLabels = function (requestLabels) {
-    return function (route) { return route.labels
-        ? exports.compareArrays(exports.mergeKeyValue(requestLabels), exports.mergeKeyValue(route.labels))
-        : false; };
-};
+const filterOnlyMatchingLabels = (requestLabels) => (route) => route.labels
+    ? exports.compareArrays(exports.mergeKeyValue(requestLabels), exports.mergeKeyValue(route.labels))
+    : false;
 exports.filterOnlyMatchingLabels = filterOnlyMatchingLabels;
-var hasAffinitySession = function (backend) { var _a; return (_a = backend === null || backend === void 0 ? void 0 : backend.sessionAffinity) === null || _a === void 0 ? void 0 : _a.enabled; };
+const hasAffinitySession = (backend) => { var _a; return (_a = backend === null || backend === void 0 ? void 0 : backend.sessionAffinity) === null || _a === void 0 ? void 0 : _a.enabled; };
 exports.hasAffinitySession = hasAffinitySession;
 function getServiceInfo(bindAddr, locator) {
-    var _this = this;
     return {
         name: "location",
-        bindAddr: bindAddr,
+        bindAddr,
         service: common_1.LOCATION_OBJECT_PROTO.Location.service,
         handlers: {
-            addRoute: function (call, callback) {
+            addRoute: (call, callback) => {
                 try {
                     locator.addRoute(call.request);
                     callback(null, {});
@@ -77,53 +41,59 @@ function getServiceInfo(bindAddr, locator) {
                     callback(e, null);
                 }
             },
-            findRoutes: function (call, callback) { return __awaiter(_this, void 0, void 0, function () {
-                var routes, e_1;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, locator.findRoutes(call.request)];
-                        case 1:
-                            routes = _a.sent();
-                            if (routes.length == 0)
-                                throw new errors_1.NotRoutesFoundForAOR(call.request.aor);
-                            callback(null, {
-                                routes: routes
-                            });
-                            return [3 /*break*/, 3];
-                        case 2:
-                            e_1 = _a.sent();
-                            callback(e_1, null);
-                            return [3 /*break*/, 3];
-                        case 3: return [2 /*return*/];
-                    }
-                });
-            }); },
-            removeRoutes: function (call, callback) { return __awaiter(_this, void 0, void 0, function () {
-                var _a, _b, e_2;
-                var _c;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            _d.trys.push([0, 2, , 3]);
-                            _a = callback;
-                            _b = [null];
-                            _c = {};
-                            return [4 /*yield*/, locator.findRoutes(call.request)];
-                        case 1:
-                            _a.apply(void 0, _b.concat([(_c.routes = _d.sent(),
-                                    _c)]));
-                            return [3 /*break*/, 3];
-                        case 2:
-                            e_2 = _d.sent();
-                            callback(e_2, null);
-                            return [3 /*break*/, 3];
-                        case 3: return [2 /*return*/];
-                    }
-                });
-            }); }
+            findRoutes: (call, callback) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const routes = yield locator.findRoutes(call.request);
+                    if (routes.length == 0)
+                        throw new errors_1.NotRoutesFoundForAOR(call.request.aor);
+                    callback(null, {
+                        routes: routes
+                    });
+                }
+                catch (e) {
+                    callback(e, null);
+                }
+            }),
+            removeRoutes: (call, callback) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    callback(null, {
+                        routes: yield locator.findRoutes(call.request)
+                    });
+                }
+                catch (e) {
+                    callback(e, null);
+                }
+            })
         }
     };
 }
 exports.getServiceInfo = getServiceInfo;
+const configFromString = (params, allowedKeys) => {
+    if (params.length === 0)
+        return {};
+    const parameters = {};
+    params.split(',').forEach(par => {
+        try {
+            const key = par.split('=')[0];
+            const value = par.split('=')[1];
+            if (allowedKeys.indexOf(key) === -1) {
+                throw `invalid parameter: ${key}`;
+            }
+            else {
+                parameters[key] = value === "true" ? true : value;
+            }
+        }
+        catch (e) {
+            throw new Error(`invalid parameters string: ${params}; should be something like 'host=localhost,port=6379'`);
+        }
+    });
+    return parameters;
+};
+exports.configFromString = configFromString;
+const getUrlString = (config) => {
+    return `redis${config.secure ? 's' : ''}`
+        + `://${config.username ? config.username : ''}`
+        + `${config.password ? ':' + config.password + '@' : ''}`
+        + `${config.host}:${config.port}`;
+};
+exports.getUrlString = getUrlString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/location",
-  "version": "2.0.5-alpha.2",
+  "version": "2.0.5-alpha.3",
   "description": "Creates and maintains a list of routes to all registered endpoints",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/routr#readme",
@@ -25,9 +25,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@routr/common": "^2.0.5-alpha.2",
+    "@routr/common": "^2.0.5-alpha.3",
     "ajv": "^6.12.6",
-    "fp-ts": "^2.11.8"
+    "fp-ts": "^2.11.8",
+    "redis": "^4.0.4"
   },
   "repository": {
     "type": "git",
@@ -36,5 +37,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "3570106be9a96cb6672de4a850a377bfa7d9bb3e"
+  "gitHead": "7d942466133a03f4bcfe0dc100f1a922b3ed14ad"
 }