@routr/location 2.0.8-alpha.18 → 2.0.8-alpha.19

package/dist/client.d.ts

@@ -32,6 +32,7 @@ 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 (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

@@ -76,6 +76,7 @@ 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 (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

@@ -53,10 +53,6 @@ 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.LoadBalancingAlgorithm.ROUND_ROBIN &&
-    b.withSessionAffinity);
-const hasBadAlgorithm = (backends) => backends.some((b) => b.balancingAlgorithm !== types_1.LoadBalancingAlgorithm.ROUND_ROBIN &&
-    b.balancingAlgorithm !== types_1.LoadBalancingAlgorithm.LEAST_SESSIONS);
 const getConfig = (path) => {
     var _a, _b, _c;
     const c = common_1.Helper.readConfigFile(path);
@@ -64,21 +60,6 @@ const getConfig = (path) => {
         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.LoadBalancingAlgorithm.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.cache) === null || _a === void 0 ? void 0 : _a.provider)) {
         config.cache = {
             provider: types_1.CacheProvider.MEMORY

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,33 +47,13 @@ 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"]
                 }
             }
         }

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

@@ -1,11 +1,10 @@
-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;
     /**
      * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
@@ -13,7 +12,7 @@ export default class Location implements ILocationService {
      * @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,11 +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.backends.forEach((_, key) => this.rrCount.set(key, 0));
     }
     /** @inheritdoc */
     addRoute(request) {
@@ -76,10 +74,7 @@ class Location {
                 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
                 const r = 
                 // Falls back to round-robin if no session affinity ref is provided
@@ -99,11 +94,12 @@ class Location {
     }
     // eslint-disable-next-line require-jsdoc
     next(routes, backend) {
-        if (backend.balancingAlgorithm === types_1.LoadBalancingAlgorithm.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

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.CacheProvider.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 LoadBalancingAlgorithm {
-    ROUND_ROBIN = "round-robin",
-    LEAST_SESSIONS = "least-sessions"
-}
-export declare enum CacheProvider {
-    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[]>;
@@ -25,6 +17,7 @@ export interface FindRoutesRequest {
     aor: string;
     callId: string;
     sessionAffinityRef?: string;
+    backend?: Backend;
     labels?: Map<string, string>;
 }
 export interface FindRoutesResponse {
@@ -35,12 +28,15 @@ export interface RemoveRoutesRequest {
 }
 export interface Backend {
     ref: string;
-    balancingAlgorithm?: LoadBalancingAlgorithm;
-    withSessionAffinity?: boolean;
+    balancingAlgorithm: CT.LoadBalancingAlgorithm;
+    withSessionAffinity: boolean;
+}
+export declare enum CacheProvider {
+    MEMORY = "MEMORY",
+    REDIS = "REDIS"
 }
 export interface LocationConfig {
     bindAddr: string;
-    backends?: Backend[];
     cache?: {
         provider: CacheProvider;
         parameters?: string;

package/dist/types.js

@@ -1,13 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheProvider = exports.LoadBalancingAlgorithm = void 0;
-var LoadBalancingAlgorithm;
-(function (LoadBalancingAlgorithm) {
-    LoadBalancingAlgorithm["ROUND_ROBIN"] = "round-robin";
-    LoadBalancingAlgorithm["LEAST_SESSIONS"] = "least-sessions";
-})(LoadBalancingAlgorithm = exports.LoadBalancingAlgorithm || (exports.LoadBalancingAlgorithm = {}));
+exports.CacheProvider = void 0;
 var CacheProvider;
 (function (CacheProvider) {
-    CacheProvider["MEMORY"] = "memory";
-    CacheProvider["REDIS"] = "redis";
+    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.18",
+  "version": "2.0.8-alpha.19",
   "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",
@@ -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.18",
-    "@routr/processor": "^2.0.8-alpha.18",
+    "@routr/common": "^2.0.8-alpha.19",
+    "@routr/processor": "^2.0.8-alpha.19",
     "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": "66ce6b3ed832bb8c549d344b3367aceed4b6da8f"
+  "gitHead": "ff62abb0ff7704a79f98a8e0b10c0036b949cc11"
 }