@routr/location 2.0.8-alpha.2 → 2.0.8-alpha.22

package/dist/client.d.ts

@@ -31,8 +31,8 @@ export default class Location implements ILocationService {
      *
      * @param {FindRoutesResponse} request - Request to find routes
      * @param {string} request.aor - AOR of the route
-     * @param {Map<string, string>} request.labels - Optional Route labels
-     * @param {string} request.sessionAffinityRef - Optiona session affinity ref
+     * @param {Map<string, string>} request.labels - Optional Route labels (reserved for future use)
+     * @param {object} request.backend - Optional Route backend (reserved for future use)
      * @return {Promise<void>}
      */
     findRoutes(request: FindRoutesRequest): Promise<Route[]>;

package/dist/client.js

@@ -38,7 +38,7 @@ const 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(self.config.addr));
+                return reject(new common_1.CommonErrors.ServiceUnavailableError(self.config.addr));
             }
             resolve(response);
         });
@@ -75,8 +75,8 @@ class Location {
      *
      * @param {FindRoutesResponse} request - Request to find routes
      * @param {string} request.aor - AOR of the route
-     * @param {Map<string, string>} request.labels - Optional Route labels
-     * @param {string} request.sessionAffinityRef - Optiona session affinity ref
+     * @param {Map<string, string>} request.labels - Optional Route labels (reserved for future use)
+     * @param {object} request.backend - Optional Route backend (reserved for future use)
      * @return {Promise<void>}
      */
     findRoutes(request) {

package/dist/config/get_config.d.ts

@@ -1,4 +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>;
+import { InvalidSchemaConfiguration } from "../errors";
+export declare const getConfig: (path: string) => E.Either<InvalidSchemaConfiguration, LocationConfig>;

package/dist/config/get_config.js

@@ -46,47 +46,29 @@ exports.getConfig = void 0;
  * limitations under the License.
  */
 const types_1 = require("../types");
-const fs_1 = __importDefault(require("fs"));
+const common_1 = require("@routr/common");
 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.withSessionAffinity);
-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"));
+    const c = common_1.Helper.readConfigFile(path);
     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)) {
+    if (!((_a = config.cache) === null || _a === void 0 ? void 0 : _a.provider)) {
         config.cache = {
-            provider: types_1.CACHE_PROVIDER.MEMORY
+            provider: types_1.CacheProvider.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)) {
+    if (((_b = config.cache) === null || _b === void 0 ? void 0 : _b.provider) === types_1.CacheProvider.REDIS &&
+        !((_c = config.cache) === null || _c === void 0 ? void 0 : _c.parameters)) {
         config.cache = {
-            provider: types_1.CACHE_PROVIDER.REDIS,
+            provider: types_1.CacheProvider.REDIS,
             parameters: "host=localhost,port=6379"
         };
     }

package/dist/config/schema.d.ts

@@ -34,26 +34,6 @@ export declare const schema: {
                     };
                     required: string[];
                 };
-                backends: {
-                    description: string;
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    properties: {
-                        ref: {
-                            type: string;
-                        };
-                        balancingAlgorithm: {
-                            enum: string[];
-                        };
-                        withSessionAffinity: {
-                            description: string;
-                            type: string;
-                        };
-                    };
-                    required: string[];
-                };
             };
         };
     };

package/dist/config/schema.js

@@ -29,7 +29,7 @@ exports.schema = {
             enum: ["Location", "location"]
         },
         apiVersion: {
-            enum: ["v2draft1"]
+            enum: ["v2draft1", "v2"]
         },
         metadata: {
             description: "Resource metadata",
@@ -47,36 +47,16 @@ exports.schema = {
                     type: "object",
                     properties: {
                         provider: {
-                            enum: ["memory", "redis"]
+                            enum: ["Memory", "Redis", "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"]
-                        },
-                        withSessionAffinity: {
-                            description: "Optional session affinity",
-                            type: "boolean"
-                        }
-                    },
-                    required: ["ref"]
                 }
             }
         }
     },
-    required: ["kind", "spec", "apiVersion"]
+    required: ["apiVersion", "kind", "metadata", "spec"]
 };

package/dist/errors.d.ts

@@ -1,6 +1,5 @@
 import * as grpc from "@grpc/grpc-js";
 export type LocationError = UnsupportedSchema | NotRoutesFoundForAOR;
-export type InvalidConfiguration = BadAlgorithmAndAffinityCombination | InvalidSchemaConfiguration;
 /**
  * Error thrown when the location service returns an unsupported schema.
  */
@@ -37,23 +36,3 @@ export declare class InvalidSchemaConfiguration extends Error {
      */
     constructor(msg: string);
 }
-/**
- * Error thrown when the location finds incompatible algorithm and session affinity.
- */
-export declare class BadAlgorithmAndAffinityCombination extends Error {
-    code: grpc.status;
-    /**
-     * Create a new BadAlgorithmAndAffinityCombination error.
-     */
-    constructor();
-}
-/**
- * Error thrown when the location finds an invalid balancing algorithm.
- */
-export declare class InvalidLoadBalancerAlgorithm extends Error {
-    code: grpc.status;
-    /**
-     * Create a new InvalidLoadBalancerAlgorithm error.
-     */
-    constructor();
-}

package/dist/errors.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidLoadBalancerAlgorithm = exports.BadAlgorithmAndAffinityCombination = exports.InvalidSchemaConfiguration = exports.NotRoutesFoundForAOR = exports.UnsupportedSchema = void 0;
+exports.InvalidSchemaConfiguration = exports.NotRoutesFoundForAOR = exports.UnsupportedSchema = void 0;
 /*
  * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/routr
@@ -92,29 +92,3 @@ class InvalidSchemaConfiguration extends Error {
     }
 }
 exports.InvalidSchemaConfiguration = InvalidSchemaConfiguration;
-/**
- * Error thrown when the location finds incompatible algorithm and session affinity.
- */
-class BadAlgorithmAndAffinityCombination extends Error {
-    /**
-     * Create a new BadAlgorithmAndAffinityCombination error.
-     */
-    constructor() {
-        super("session affinity can not be combined with round-robin load balancing");
-        Object.setPrototypeOf(this, BadAlgorithmAndAffinityCombination.prototype);
-    }
-}
-exports.BadAlgorithmAndAffinityCombination = BadAlgorithmAndAffinityCombination;
-/**
- * Error thrown when the location finds an invalid balancing algorithm.
- */
-class InvalidLoadBalancerAlgorithm extends Error {
-    /**
-     * Create a new InvalidLoadBalancerAlgorithm 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.js

@@ -28,21 +28,23 @@ const processor_1 = require("@routr/processor");
 // 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) => {
+    var _a;
     const uri = request.message.contact.address.uri;
     const sessionCount = processor_1.Extensions.getHeaderValue(request, common_1.CommonTypes.ExtraHeader.SESSION_COUNT)
         ? parseInt(processor_1.Extensions.getHeaderValue(request, common_1.CommonTypes.ExtraHeader.SESSION_COUNT))
         : -1;
-    const egressListeningPoint = common_1.Helper.getListeningPoint(request, uri.transportParam.toLowerCase());
     return {
         edgePortRef: request.edgePortRef,
         user: uri.user,
         host: uri.host,
         port: uri.port,
-        transport: uri.transportParam.toLowerCase(),
+        transport: (_a = uri.transportParam) === null || _a === void 0 ? void 0 : _a.toUpperCase(),
         registeredOn: Date.now(),
         sessionCount,
         expires: processor_1.Target.getTargetExpires(request),
-        egressListeningPoint
+        listeningPoints: request.listeningPoints,
+        localnets: request.localnets,
+        externalAddrs: request.externalAddrs
     };
 };
 exports.createRoute = createRoute;

package/dist/location.d.ts

@@ -1,20 +1,18 @@
-import { AddRouteRequest, Backend, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRoutesRequest } from "./types";
+import { AddRouteRequest, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRoutesRequest } from "./types";
 import { Route } from "@routr/common";
 /**
  * A locator store that uses the location service to find routes for AORs.
  */
 export default class Location implements ILocationService {
     private store;
-    private backends;
     private rrCount;
-    private affinityStore;
     /**
      * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
      *
      * @param {ILocatorStore} store - The store to use for the location service
      * @param {Map<string, Backend>} backends - The backends to use for the location service
      */
-    constructor(store: ILocatorStore, backends?: Map<string, Backend>);
+    constructor(store: ILocatorStore);
     /** @inheritdoc */
     addRoute(request: AddRouteRequest): Promise<void>;
     /** @inheritdoc */

package/dist/location.js

@@ -28,7 +28,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * limitations under the License.
  */
 const errors_1 = require("./errors");
-const types_1 = require("./types");
+const common_1 = require("@routr/common");
 const utils_1 = require("./utils");
 var AOR_SCHEME;
 (function (AOR_SCHEME) {
@@ -45,12 +45,9 @@ class Location {
      * @param {ILocatorStore} store - The store to use for the location service
      * @param {Map<string, Backend>} backends - The backends to use for the location service
      */
-    constructor(store, backends = new Map()) {
+    constructor(store) {
         this.store = store;
-        this.backends = backends;
         this.rrCount = new Map();
-        this.affinityStore = new Map();
-        this.backends.forEach((value, key) => this.rrCount.set(key, 0));
     }
     /** @inheritdoc */
     addRoute(request) {
@@ -64,21 +61,29 @@ class Location {
     findRoutes(request) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const routes = request.labels
+            let routes = yield this.store.get(request.callId);
+            if (routes.length > 0) {
+                return routes;
+            }
+            routes = request.labels
                 ? (yield this.store.get(request.aor)).filter((0, utils_1.filterOnlyMatchingLabels)(request.labels))
                 : (_a = (yield this.store.get(request.aor))) !== null && _a !== void 0 ? _a : [];
             if (request.aor.startsWith(AOR_SCHEME.SIP)) {
+                // Set call to the last route
+                this.store.put(request.callId, routes[0]);
                 return routes;
             }
             else if (request.aor.startsWith(AOR_SCHEME.BACKEND)) {
-                const backend = this.backends.get(request.aor);
-                if (!backend) {
-                    throw new errors_1.NotRoutesFoundForAOR(request.aor);
-                }
+                const { backend } = request;
                 // If it has not affinity sesssion then get next
-                return backend.withSessionAffinity
-                    ? [this.nextWithAffinity(routes, request.sessionAffinityRef)]
+                const r = 
+                // Falls back to round-robin if no session affinity ref is provided
+                backend.withSessionAffinity && request.sessionAffinityRef
+                    ? [yield this.nextWithAffinity(routes, request.sessionAffinityRef)]
                     : [this.next(routes, backend)];
+                // Next time we will get the route with callId
+                this.store.put(request.callId, r[0]);
+                return r;
             }
             throw new errors_1.UnsupportedSchema(request.aor);
         });
@@ -89,11 +94,12 @@ class Location {
     }
     // eslint-disable-next-line require-jsdoc
     next(routes, backend) {
-        if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
+        var _a;
+        if (backend.balancingAlgorithm === common_1.CommonTypes.LoadBalancingAlgorithm.LEAST_SESSIONS) {
             return routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
         }
         // Continues using round-robin
-        const nextPosition = this.rrCount.get(`${AOR_SCHEME.BACKEND}${backend.ref}`);
+        const nextPosition = (_a = this.rrCount.get(`${AOR_SCHEME.BACKEND}${backend.ref}`)) !== null && _a !== void 0 ? _a : 0;
         const result = routes[nextPosition];
         if (nextPosition >= routes.length - 1) {
             // Restarting round-robin counter
@@ -106,14 +112,16 @@ class Location {
     }
     // Backend with session affinity does not support round-robin
     // eslint-disable-next-line require-jsdoc
-    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;
+    nextWithAffinity(routes, sessionAffinityHeader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const route = yield this.store.get(sessionAffinityHeader);
+            if (route.length > 0) {
+                return route[0];
+            }
+            const r = routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
+            this.store.put(sessionAffinityHeader, r);
+            return r;
+        });
     }
 }
 exports.default = Location;

package/dist/service.js

@@ -36,17 +36,16 @@ const allowedParameters = ["host", "port", "username", "password", "secure"];
  * @param {LocationConfig} config - Service configuration
  */
 function LocationService(config) {
+    var _a;
     const { bindAddr, cache } = config;
     let store;
-    if (cache.provider === types_1.CACHE_PROVIDER.REDIS) {
+    if (((_a = cache.provider) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === types_1.CacheProvider.REDIS) {
         store = new redis_store_1.default((0, 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));
-    (0, common_1.createService)((0, utils_1.getServiceInfo)(bindAddr, new location_1.default(store, backends)));
+    (0, common_1.createService)((0, utils_1.getServiceInfo)(bindAddr, new location_1.default(store)));
     logger.info(`using ${cache.provider} as cache provider`);
 }
 exports.default = LocationService;

package/dist/types.d.ts

@@ -1,12 +1,4 @@
-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"
-}
+import { Route, CommonTypes as CT } from "@routr/common";
 export interface ILocationService {
     addRoute(request: AddRouteRequest): Promise<void>;
     findRoutes(request: FindRoutesRequest): Promise<Route[]>;
@@ -23,8 +15,10 @@ export interface AddRouteRequest {
 }
 export interface FindRoutesRequest {
     aor: string;
-    labels?: Map<string, string>;
+    callId: string;
     sessionAffinityRef?: string;
+    backend?: Backend;
+    labels?: Map<string, string>;
 }
 export interface FindRoutesResponse {
     routes: Array<Route>;
@@ -34,14 +28,17 @@ export interface RemoveRoutesRequest {
 }
 export interface Backend {
     ref: string;
-    balancingAlgorithm?: LB_ALGORITHM;
-    withSessionAffinity?: boolean;
+    balancingAlgorithm: CT.LoadBalancingAlgorithm;
+    withSessionAffinity: boolean;
+}
+export declare enum CacheProvider {
+    MEMORY = "MEMORY",
+    REDIS = "REDIS"
 }
 export interface LocationConfig {
     bindAddr: string;
-    backends?: Backend[];
     cache?: {
-        provider: CACHE_PROVIDER;
+        provider: CacheProvider;
         parameters?: string;
     };
 }

package/dist/types.js

@@ -1,13 +1,8 @@
 "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 = {}));
+exports.CacheProvider = void 0;
+var CacheProvider;
+(function (CacheProvider) {
+    CacheProvider["MEMORY"] = "MEMORY";
+    CacheProvider["REDIS"] = "REDIS";
+})(CacheProvider = exports.CacheProvider || (exports.CacheProvider = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/location",
-  "version": "2.0.8-alpha.2",
+  "version": "2.0.8-alpha.22",
   "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",
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@fonoster/logger": "0.3.18",
-    "@grpc/grpc-js": "^1.5.9",
+    "@grpc/grpc-js": "^1.8.4",
     "@opentelemetry/api": "^1.0.4",
     "@opentelemetry/exporter-jaeger": "^1.0.4",
     "@opentelemetry/instrumentation": "^0.27.0",
@@ -35,8 +35,8 @@
     "@opentelemetry/sdk-trace-base": "^1.0.4",
     "@opentelemetry/sdk-trace-node": "^1.0.4",
     "@opentelemetry/semantic-conventions": "^1.0.4",
-    "@routr/common": "^2.0.8-alpha.2",
-    "@routr/processor": "^2.0.8-alpha.2",
+    "@routr/common": "^2.0.8-alpha.22",
+    "@routr/processor": "^2.0.8-alpha.22",
     "ajv": "^6.12.6",
     "fp-ts": "^2.11.8",
     "redis": "^4.0.4"
@@ -48,5 +48,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "28ab976b0ef8b5cd34e278ea6fda13c518d7d052"
+  "gitHead": "7c1e14c20e077f817605be62cf61a68904583bb8"
 }