@routr/location 2.0.5-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Fonoster Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/config/get_config.d.ts

@@ -0,0 +1,4 @@
+import { LocationConfig } from "../types";
+import * as E from 'fp-ts/Either';
+import { InvalidConfiguration } from "../errors";
+export declare const getConfig: (path: string) => E.Either<InvalidConfiguration, LocationConfig>;

package/dist/config/get_config.js

@@ -0,0 +1,92 @@
+"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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+/*
+ * 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.
+ */
+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))) {
+        return E.left(new errors_1.InvalidSchemaConfiguration(JSON.stringify(validate.errors[0].message)));
+    }
+    var config = c.spec;
+    if (config.backends) {
+        config.backends.map(function (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) {
+            return E.left(new errors_1.BadAlgorithmAndAffinityCombination());
+        }
+        if (hasBadAlgorithm) {
+            return E.left(new errors_1.InvalidLoadBalancerAlgorithm());
+        }
+    }
+    return E.right(config);
+};
+exports.getConfig = getConfig;

package/dist/config/schema.d.ts

@@ -0,0 +1,58 @@
+export declare const schema: {
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    properties: {
+        kind: {
+            enum: string[];
+        };
+        apiVersion: {
+            enum: string[];
+        };
+        metadata: {
+            description: string;
+            type: string;
+        };
+        spec: {
+            description: string;
+            type: string;
+            properties: {
+                bindAddr: {
+                    description: string;
+                    type: string;
+                };
+                backends: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    properties: {
+                        ref: {
+                            type: string;
+                        };
+                        balancingAlgorithm: {
+                            enum: string[];
+                        };
+                        sessionAffinity: {
+                            description: string;
+                            type: string;
+                            properties: {
+                                enabled: {
+                                    type: string;
+                                };
+                                ref: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+    };
+    required: string[];
+};

package/dist/config/schema.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+/*
+ * 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.
+ */
+exports.schema = {
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "title": "Location Service configuration",
+    "description": "Configuration for an instance of the Location Service",
+    "type": "object",
+    "properties": {
+        "kind": {
+            "enum": ["Location", "location"]
+        },
+        "apiVersion": {
+            "enum": ["v2draft1"]
+        },
+        "metadata": {
+            "description": "Resource metadata",
+            "type": "object"
+        },
+        "spec": {
+            "description": "Operations spec for Location",
+            "type": "object",
+            "properties": {
+                "bindAddr": {
+                    "description": "Ipv4 interface to accept request on",
+                    "type": "string"
+                },
+                "backends": {
+                    "description": "Optional SIP backends",
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    },
+                    "properties": {
+                        "ref": {
+                            "type": "string"
+                        },
+                        "balancingAlgorithm": {
+                            "enum": ["ROUND_ROBIN", "LEAST_SESSIONS"]
+                        },
+                        "sessionAffinity": {
+                            "description": "Optional session affinity",
+                            "type": "object",
+                            "properties": {
+                                "enabled": {
+                                    "type": "boolean"
+                                },
+                                "ref": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": ["ref"]
+                        },
+                    },
+                    "required": ["ref"]
+                },
+            }
+        }
+    },
+    "required": ["kind", "metadata", "spec", "apiVersion"]
+};

package/dist/errors.d.ts

@@ -0,0 +1,23 @@
+import grpc = require("@grpc/grpc-js");
+export declare type LocationError = UnsupportedSchema | NotRoutesFoundForAOR;
+export declare type InvalidConfiguration = BadAlgorithmAndAffinityCombination | InvalidSchemaConfiguration;
+export declare class UnsupportedSchema extends Error {
+    code: grpc.status;
+    constructor(aor: string);
+}
+export declare class NotRoutesFoundForAOR extends Error {
+    code: number;
+    constructor(aor: string);
+}
+export declare class InvalidSchemaConfiguration extends Error {
+    code: grpc.status;
+    constructor(msg: string);
+}
+export declare class BadAlgorithmAndAffinityCombination extends Error {
+    code: grpc.status;
+    constructor();
+}
+export declare class InvalidLoadBalancerAlgorithm extends Error {
+    code: grpc.status;
+    constructor();
+}

package/dist/errors.js

@@ -0,0 +1,91 @@
+"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;
+/*
+ * 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.
+ */
+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;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(_this, UnsupportedSchema.prototype);
+        return _this;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    return InvalidLoadBalancerAlgorithm;
+}(Error));
+exports.InvalidLoadBalancerAlgorithm = InvalidLoadBalancerAlgorithm;

package/dist/locator.d.ts

@@ -0,0 +1,13 @@
+import { AddRouteRequest, Backend, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRouteRequest, Route } from "./types";
+export default class Locator implements ILocationService {
+    private store;
+    private backends;
+    private rrCount;
+    private affinityStore;
+    constructor(store: ILocatorStore, backends?: Map<string, Backend>);
+    addRoute(request: AddRouteRequest): Promise<void>;
+    findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    removeRoutes(request: RemoveRouteRequest): Promise<void>;
+    private next;
+    private nextWithAffinity;
+}

package/dist/locator.js

@@ -0,0 +1,152 @@
+"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 __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)
+ * 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.
+ */
+var errors_1 = require("./errors");
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var Locator = /** @class */ (function () {
+    // Should fail if any backend has sessionAffinity and round-robin
+    function Locator(store, backends) {
+        var _this = this;
+        if (backends === void 0) { 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); });
+    }
+    Locator.prototype.addRoute = function (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);
+                }
+            });
+        });
+    };
+    Locator.prototype.removeRoutes = function (request) {
+        return this.store.delete(request.aor);
+    };
+    Locator.prototype.next = function (routes, backend) {
+        if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
+            return routes.sort(function (r1, r2) { return r1.sessionCount - r2.sessionCount; })[0];
+        }
+        // Continues using round-robin
+        var nextPosition = this.rrCount.get("backend:" + backend.ref);
+        var result = routes[nextPosition];
+        if (nextPosition >= (routes.length - 1)) {
+            // Restarting round-robin counter
+            this.rrCount.set("backend:" + backend.ref, 0);
+        }
+        else {
+            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);
+        if (route) {
+            return route;
+        }
+        route = routes.sort(function (r1, r2) { return r1.sessionCount - r2.sessionCount; })[0];
+        this.affinityStore.set(sessionAffinityRef, route);
+        return route;
+    };
+    return Locator;
+}());
+exports.default = Locator;

package/dist/memory_store.d.ts

@@ -0,0 +1,12 @@
+import { ILocatorStore, Route } from "./types";
+export default class MemoryStore implements ILocatorStore {
+    private collections;
+    private cleanupCount;
+    private maxCyclesBeforeCleanup;
+    constructor(maxCyclesBeforeCleanup?: number);
+    put(key: string, route: Route): Promise<void>;
+    get(key: string): Promise<Route[]>;
+    delete(key: string): Promise<void>;
+    size(): number;
+    cleanup(): void;
+}

package/dist/memory_store.js

@@ -0,0 +1,77 @@
+"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; }
+        this.collections = new Map();
+        this.maxCyclesBeforeCleanup = maxCyclesBeforeCleanup;
+    }
+    MemoryStore.prototype.put = function (key, route) {
+        var routes = __spreadArray([], __read(this.collections.get(key) || []));
+        // Avoids duplicate or expired routes
+        var filteredRoutes = routes
+            .filter(utils_1.expiredFilter)
+            .filter(function (r) { return utils_1.duplicateFilter(r, route); });
+        if (filteredRoutes.length > 0) {
+            this.collections.set(key, __spreadArray([route], __read(filteredRoutes)));
+        }
+        else {
+            this.collections.set(key, [route]);
+        }
+        return;
+    };
+    MemoryStore.prototype.get = function (key) {
+        // Cleanup every so often to avoid memory build up
+        this.cleanupCount++;
+        if (this.cleanupCount >= this.maxCyclesBeforeCleanup) {
+            this.cleanupCount = 0;
+            this.cleanup();
+        }
+        return Promise.resolve(this.collections.get(key) || []);
+    };
+    MemoryStore.prototype.delete = function (key) {
+        this.collections.delete(key);
+        return;
+    };
+    MemoryStore.prototype.size = function () {
+        return this.collections.size;
+    };
+    MemoryStore.prototype.cleanup = function () {
+        var _this = this;
+        // Remove any expired route from collection
+        this.collections.forEach(function (routes, key) {
+            var filteredRoutes = routes.filter(utils_1.expiredFilter);
+            if (filteredRoutes.length > 0) {
+                _this.collections.set(key, filteredRoutes);
+            }
+            else {
+                _this.collections.delete(key);
+            }
+        });
+    };
+    return MemoryStore;
+}());
+exports.default = MemoryStore;

package/dist/runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/runner.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * 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.
+ */
+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);
+if (result._tag === 'Right') {
+    service_1.default(result.right);
+}
+else {
+    logger_1.default.error(result.left);
+}

package/dist/service.d.ts

@@ -0,0 +1,2 @@
+import { LocationConfig } from "./types";
+export default function LocationService(config: LocationConfig): void;

package/dist/service.js

@@ -0,0 +1,14 @@
+"use strict";
+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"));
+function LocationService(config) {
+    var bindAddr = config.bindAddr;
+    common_1.createService(utils_1.getServiceInfo(bindAddr, new locator_1.default(new memory_store_1.default())));
+}
+exports.default = LocationService;

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export declare enum LB_ALGORITHM {
+    ROUND_ROBIN = "round-robin",
+    LEAST_SESSIONS = "least-sessions"
+}
+export interface ILocationService {
+    addRoute(request: AddRouteRequest): Promise<void>;
+    findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    removeRoutes(request: RemoveRouteRequest): Promise<void>;
+}
+export interface ILocatorStore {
+    put(key: string, route: Route): Promise<void>;
+    get(key: string): Promise<Route[]>;
+    delete(key: string): Promise<void>;
+}
+export interface Route {
+    user: string;
+    host: string;
+    port: number;
+    transport: string;
+    registeredOn: number;
+    sessionCount?: number;
+    expires: number;
+    edgePortRef: string;
+    labels?: Map<string, string>;
+}
+export interface AddRouteRequest {
+    aor: string;
+    route: Route;
+}
+export interface FindRoutesRequest {
+    aor: string;
+    labels?: Map<string, string>;
+    sessionAffinityRef?: string;
+}
+export interface FindRoutesResponse {
+    routes: Array<Route>;
+}
+export interface RemoveRouteRequest {
+    aor: string;
+}
+export interface Backend {
+    ref: string;
+    balancingAlgorithm?: LB_ALGORITHM;
+    sessionAffinity?: {
+        enabled: boolean;
+        ref: string;
+    };
+}
+export interface LocationConfig {
+    bindAddr: string;
+    backends?: Backend[];
+}

package/dist/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LB_ALGORITHM = void 0;
+/*
+ * 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.
+ */
+var LB_ALGORITHM;
+(function (LB_ALGORITHM) {
+    LB_ALGORITHM["ROUND_ROBIN"] = "round-robin";
+    LB_ALGORITHM["LEAST_SESSIONS"] = "least-sessions";
+})(LB_ALGORITHM = exports.LB_ALGORITHM || (exports.LB_ALGORITHM = {}));

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import { Backend, ILocationService, Route } from "./types";
+import { ServiceInfo } from "@routr/common";
+export declare const expiredFilter: (r: Route) => boolean;
+export declare const duplicateFilter: (r1: Route, r2: Route) => boolean;
+export declare const mergeKeyValue: (map: Map<string, string>) => string[];
+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;

package/dist/utils.js

@@ -0,0 +1,129 @@
+"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 __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.expiredFilter = expiredFilter;
+var duplicateFilter = function (r1, r2) {
+    return !(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]; }); };
+exports.mergeKeyValue = mergeKeyValue;
+var compareArrays = function (arr, target) {
+    return target.every(function (v) { return 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; };
+};
+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; };
+exports.hasAffinitySession = hasAffinitySession;
+function getServiceInfo(bindAddr, locator) {
+    var _this = this;
+    return {
+        name: "location",
+        bindAddr: bindAddr,
+        service: common_1.LOCATION_OBJECT_PROTO.Location.service,
+        handlers: {
+            addRoute: function (call, callback) {
+                try {
+                    locator.addRoute(call.request);
+                    callback(null, {});
+                }
+                catch (e) {
+                    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*/];
+                    }
+                });
+            }); }
+        }
+    };
+}
+exports.getServiceInfo = getServiceInfo;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@routr/location",
+  "version": "2.0.5-alpha.2",
+  "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",
+  "license": "MIT",
+  "main": "dist/location",
+  "types": "dist/location",
+  "scripts": {
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json"
+  },
+  "bin": {
+    "run_location": "dist/runner.js"
+  },
+  "directories": {
+    "src": "src",
+    "test": "test"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@routr/common": "^2.0.5-alpha.2",
+    "ajv": "^6.12.6",
+    "fp-ts": "^2.11.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/routr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/routr/issues"
+  },
+  "gitHead": "3570106be9a96cb6672de4a850a377bfa7d9bb3e"
+}