@routr/location 2.0.5-alpha.10

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/client.d.ts

@@ -0,0 +1,14 @@
+import { AddRouteRequest, FindRoutesRequest, ILocationService, RemoveRoutesRequest } from "./types";
+import { Route } from "@routr/common";
+export default class Location implements ILocationService {
+    location: any;
+    config: {
+        addr: string;
+    };
+    constructor(config: {
+        addr: string;
+    });
+    addRoute(request: AddRouteRequest): Promise<void>;
+    findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    removeRoutes(request: RemoveRoutesRequest): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@routr/common");
+const grpc = require("@grpc/grpc-js");
+function container(self, request, name) {
+    return new Promise((resolve, reject) => {
+        self.location[name](request, (err, response) => {
+            if ((err === null || err === void 0 ? void 0 : err.code) === grpc.status.UNAVAILABLE) {
+                return reject(new common_1.ServiceUnavailableError(this.config.addr));
+            }
+            resolve(response);
+        });
+    });
+}
+class Location {
+    constructor(config) {
+        this.config = config;
+        this.location = new common_1.LOCATION_OBJECT_PROTO
+            .Location(config.addr, grpc.credentials.createInsecure());
+    }
+    addRoute(request) {
+        return container(this, request, this.addRoute.name);
+    }
+    findRoutes(request) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return ((_a = (yield container(this, request, this.findRoutes.name))) === null || _a === void 0 ? void 0 : _a.routes) || [];
+        });
+    }
+    removeRoutes(request) {
+        return container(this, request, this.removeRoutes.name);
+    }
+}
+exports.default = Location;

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,90 @@
+"use strict";
+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.
+ */
+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)));
+    }
+    const config = c.spec;
+    if (config.backends) {
+        config.backends.map((b) => {
+            // Setting round-robin by default
+            b.balancingAlgorithm = b.balancingAlgorithm
+                ? b.balancingAlgorithm : types_1.LB_ALGORITHM.ROUND_ROBIN;
+            return b;
+        });
+        if (hasBadCombiniation(config.backends)) {
+            return E.left(new errors_1.BadAlgorithmAndAffinityCombination());
+        }
+        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

@@ -0,0 +1,70 @@
+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;
+                };
+                cache: {
+                    type: string;
+                    properties: {
+                        provider: {
+                            enum: string[];
+                        };
+                        parameters: {
+                            type: string;
+                        };
+                    };
+                    required: 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,91 @@
+"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"
+                },
+                "cache": {
+                    "type": "object",
+                    "properties": {
+                        "provider": {
+                            "enum": ["memory", "redis"]
+                        },
+                        "parameters": {
+                            "type": "string"
+                        },
+                    },
+                    "required": ["provider"]
+                },
+                "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,61 @@
+"use strict";
+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.
+ */
+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);
+    }
+}
+exports.UnsupportedSchema = UnsupportedSchema;
+class NotRoutesFoundForAOR extends Error {
+    constructor(aor) {
+        super(`no routes found for aor ${aor}`);
+        this.code = grpc.status.NOT_FOUND;
+        Object.setPrototypeOf(this, NotRoutesFoundForAOR.prototype);
+    }
+}
+exports.NotRoutesFoundForAOR = NotRoutesFoundForAOR;
+class InvalidSchemaConfiguration extends Error {
+    constructor(msg) {
+        super(msg);
+        this.code = grpc.status.INVALID_ARGUMENT;
+        Object.setPrototypeOf(this, InvalidSchemaConfiguration.prototype);
+    }
+}
+exports.InvalidSchemaConfiguration = InvalidSchemaConfiguration;
+class BadAlgorithmAndAffinityCombination extends Error {
+    constructor() {
+        super("session affinity can not be combined with round-robin load balancing");
+        Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
+    }
+}
+exports.BadAlgorithmAndAffinityCombination = BadAlgorithmAndAffinityCombination;
+class InvalidLoadBalancerAlgorithm extends Error {
+    constructor() {
+        super("found invalid load balancing algorithm. must be round-robin or least-sessions");
+        Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
+    }
+}
+exports.InvalidLoadBalancerAlgorithm = InvalidLoadBalancerAlgorithm;

package/dist/helper.d.ts

@@ -0,0 +1,3 @@
+import { Route } from "@routr/common";
+import { MessageRequest } from "@routr/common";
+export declare const createRoute: (request: MessageRequest) => Route;

package/dist/helper.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoute = void 0;
+const processor_1 = require("@routr/processor");
+const processor_2 = require("@routr/processor");
+// TODO: Before finalizing this, consider using the old approach of saving the rport
+// and received values (like here:
+//    https://github.com/fonoster/routr/blob/59bc98af86078088aede7e658c0d82a19fa18fa4/mod/registrar/utils.js#L87)
+//
+// Also consider: https://github.com/fonoster/routr/blob/ee5d339888344013939d06c734385f17f0cd75c2/mod/registrar/utils.js#L116
+// and https://github.com/fonoster/routr/blob/ee5d339888344013939d06c734385f17f0cd75c2/mod/registrar/utils.js#L131
+const createRoute = (request) => {
+    const uri = request.message.contact.address.uri;
+    return {
+        edgePortRef: request.edgePortRef,
+        user: uri.user,
+        host: uri.host,
+        port: uri.port,
+        transport: uri.transport,
+        registeredOn: Date.now(),
+        sessionCount: processor_1.Extensions.getHeaderValue(request, "x-session-count") || -1,
+        expires: processor_2.Target.getTargetExpires(request),
+        listeningPoint: request.listeningPoint
+    };
+};
+exports.createRoute = createRoute;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import LocationClient from "./client";
+export * as Helper from "./helper";
+export * as Utils from "./utils";
+export { LocationClient };

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+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.LocationClient = exports.Utils = exports.Helper = 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.
+ */
+const client_1 = __importDefault(require("./client"));
+exports.LocationClient = client_1.default;
+exports.Helper = __importStar(require("./helper"));
+exports.Utils = __importStar(require("./utils"));

package/dist/location.d.ts

@@ -0,0 +1,14 @@
+import { AddRouteRequest, Backend, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRoutesRequest } from "./types";
+import { Route } from "@routr/common";
+export default class Location 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: RemoveRoutesRequest): Promise<void>;
+    private next;
+    private nextWithAffinity;
+}

package/dist/location.js

@@ -0,0 +1,101 @@
+"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());
+    });
+};
+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.
+ */
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class Location {
+    // Should fail if any backend has sessionAffinity and round-robin
+    constructor(store, backends = new Map()) {
+        this.store = store;
+        this.backends = backends;
+        this.rrCount = new Map();
+        this.affinityStore = new Map();
+        this.backends.forEach((value, key) => this.rrCount.set(key, 0));
+    }
+    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);
+    }
+    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);
+        });
+    }
+    removeRoutes(request) {
+        return this.store.delete(request.aor);
+    }
+    next(routes, backend) {
+        if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
+            return routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
+        }
+        // Continues using round-robin
+        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);
+        }
+        else {
+            this.rrCount.set(`backend:${backend.ref}`, nextPosition + 1);
+        }
+        return result;
+    }
+    // Backend with session affinity does not support round-robin
+    nextWithAffinity(routes, sessionAffinityRef) {
+        let route = this.affinityStore.get(sessionAffinityRef);
+        if (route) {
+            return route;
+        }
+        route = routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
+        this.affinityStore.set(sessionAffinityRef, route);
+        return route;
+    }
+}
+exports.default = Location;

package/dist/memory_store.d.ts

@@ -0,0 +1,13 @@
+import { Route } from "@routr/common";
+import { ILocatorStore } 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,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+    put(key, route) {
+        const routes = [...this.collections.get(key) || []];
+        // Avoids duplicate or expired routes
+        const filteredRoutes = routes
+            .filter(utils_1.expiredFilter)
+            .filter(r => utils_1.duplicateFilter(r, route));
+        if (filteredRoutes.length > 0) {
+            this.collections.set(key, [route, ...filteredRoutes]);
+        }
+        else {
+            this.collections.set(key, [route]);
+        }
+        return;
+    }
+    get(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) || []).filter(utils_1.expiredFilter));
+    }
+    delete(key) {
+        this.collections.delete(key);
+        return;
+    }
+    size() {
+        return this.collections.size;
+    }
+    cleanup() {
+        // Remove any expired route from collection
+        this.collections.forEach((routes, key) => {
+            const filteredRoutes = routes.filter(utils_1.expiredFilter);
+            if (filteredRoutes.length > 0) {
+                this.collections.set(key, filteredRoutes);
+            }
+            else {
+                this.collections.delete(key);
+            }
+        });
+    }
+}
+exports.default = MemoryStore;

package/dist/redis_store.d.ts

@@ -0,0 +1,9 @@
+import { Route } from "@routr/common";
+import { ILocatorStore, RedisStoreConfig } 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.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.
+ */
+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);
+}
+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,46 @@
+"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.
+ */
+const types_1 = require("./types");
+const common_1 = require("@routr/common");
+const utils_1 = require("./utils");
+const location_1 = __importDefault(require("./location"));
+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) {
+    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 location_1.default(store, backends)));
+    logger_1.default.info(`using ${cache.provider} as cache provider`);
+}
+exports.default = LocationService;

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import { Route } from "@routr/common";
+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[]>;
+    removeRoutes(request: RemoveRoutesRequest): Promise<void>;
+}
+export interface ILocatorStore {
+    put(key: string, route: Route): Promise<void>;
+    get(key: string): Promise<Route[]>;
+    delete(key: string): Promise<void>;
+}
+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 RemoveRoutesRequest {
+    aor: string;
+}
+export interface Backend {
+    ref: string;
+    balancingAlgorithm?: LB_ALGORITHM;
+    sessionAffinity?: {
+        enabled: boolean;
+        ref: string;
+    };
+}
+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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_PROVIDER = exports.LB_ALGORITHM = void 0;
+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 = {}));
+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

@@ -0,0 +1,12 @@
+import { Route } from "@routr/common";
+import { ServiceInfo } from "@routr/common";
+import { Backend, ILocationService, RedisStoreConfig } from "./types";
+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;
+export declare const configFromString: (params: string, allowedKeys: string[]) => Record<string, string | boolean>;
+export declare const getUrlString: (config: RedisStoreConfig) => string;

package/dist/utils.js

@@ -0,0 +1,99 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+const duplicateFilter = (r1, r2) => !(r1.host === r2.host && r1.port === r2.port);
+exports.duplicateFilter = duplicateFilter;
+const mergeKeyValue = (map) => Array.from(map).map(l => l[0] + l[1]);
+exports.mergeKeyValue = mergeKeyValue;
+const compareArrays = (arr, target) => target.every(v => arr.includes(v)) && arr.length === target.length;
+exports.compareArrays = compareArrays;
+const filterOnlyMatchingLabels = (requestLabels) => (route) => route.labels
+    ? exports.compareArrays(exports.mergeKeyValue(requestLabels), exports.mergeKeyValue(route.labels))
+    : false;
+exports.filterOnlyMatchingLabels = filterOnlyMatchingLabels;
+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) {
+    return {
+        name: "location",
+        bindAddr,
+        service: common_1.LOCATION_OBJECT_PROTO.Location.service,
+        handlers: {
+            addRoute: (call, callback) => {
+                try {
+                    locator.addRoute(call.request);
+                    callback(null, {});
+                }
+                catch (e) {
+                    callback(e, null);
+                }
+            },
+            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

@@ -0,0 +1,43 @@
+{
+  "name": "@routr/location",
+  "version": "2.0.5-alpha.10",
+  "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/index",
+  "types": "dist/index",
+  "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": {
+    "@grpc/grpc-js": "^1.5.9",
+    "@routr/common": "^2.0.5-alpha.10",
+    "@routr/processor": "^2.0.5-alpha.10",
+    "ajv": "^6.12.6",
+    "fp-ts": "^2.11.8",
+    "redis": "^4.0.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/routr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/routr/issues"
+  },
+  "gitHead": "10c6ff135a370a4a4634478fdaf5f42c5c13e28c"
+}