@routr/registry 2.0.5-alpha.16

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 { RegistryConfig } from "../types";
+import * as E from "fp-ts/Either";
+import { InvalidConfiguration } from "../errors";
+export declare const getConfig: (path: string) => E.Either<InvalidConfiguration, RegistryConfig>;

package/dist/config/get_config.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 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 (!((_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,77 @@
+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;
+                };
+                requesterAddr: {
+                    description: string;
+                    type: string;
+                };
+                apiAddr: {
+                    description: string;
+                    type: string;
+                };
+                registerInterval: {
+                    description: string;
+                    type: string;
+                };
+                cache: {
+                    type: string;
+                    properties: {
+                        provider: {
+                            enum: string[];
+                        };
+                        parameters: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+                methods: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    uniqueItems: boolean;
+                };
+                edgePorts: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    properties: {
+                        address: {
+                            type: string;
+                        };
+                        region: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+        };
+    };
+    required: string[];
+};

package/dist/config/schema.js

@@ -0,0 +1,98 @@
+"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: "Registry Service configuration",
+    description: "Configuration for an instance of the Registry Service",
+    type: "object",
+    properties: {
+        kind: {
+            enum: ["Registry", "registry"]
+        },
+        apiVersion: {
+            enum: ["v2draft1"]
+        },
+        metadata: {
+            description: "Resource metadata",
+            type: "object"
+        },
+        spec: {
+            description: "Operations spec for Registry",
+            type: "object",
+            properties: {
+                bindAddr: {
+                    description: "Ipv4 interface to accept request on",
+                    type: "string"
+                },
+                requesterAddr: {
+                    description: "Address of service to send requests to",
+                    type: "string"
+                },
+                apiAddr: {
+                    description: "Address of API service",
+                    type: "string"
+                },
+                registerInterval: {
+                    description: "Interval to send registration requests",
+                    type: "number"
+                },
+                cache: {
+                    type: "object",
+                    properties: {
+                        provider: {
+                            enum: ["memory", "redis"]
+                        },
+                        parameters: {
+                            type: "string"
+                        }
+                    },
+                    required: ["provider"]
+                },
+                methods: {
+                    description: "Acceptable SIP Methods",
+                    type: "array",
+                    items: {
+                        type: "string"
+                    },
+                    uniqueItems: true
+                },
+                edgePorts: {
+                    description: "List of EdgePorts for outbound registrations",
+                    type: "array",
+                    items: {
+                        type: "object"
+                    },
+                    properties: {
+                        address: {
+                            type: "string"
+                        },
+                        region: {
+                            type: "string"
+                        }
+                    },
+                    required: ["address"]
+                }
+            }
+        }
+    },
+    required: ["kind", "spec", "apiVersion"]
+};

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import * as grpc from "@grpc/grpc-js";
+export declare type InvalidConfiguration = InvalidSchemaConfiguration;
+/**
+ * Error thrown when the Registry service finds a bad configuration.
+ */
+export declare class InvalidSchemaConfiguration extends Error {
+    code: grpc.status;
+    /**
+     * Create a new InvalidSchemaConfiguration error.
+     *
+     * @param {string} msg - Message from the validation error
+     */
+    constructor(msg: string);
+}

package/dist/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSchemaConfiguration = 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 = __importStar(require("@grpc/grpc-js"));
+/**
+ * Error thrown when the Registry service finds a bad configuration.
+ */
+class InvalidSchemaConfiguration extends Error {
+    /**
+     * Create a new InvalidSchemaConfiguration error.
+     *
+     * @param {string} msg - Message from the validation error
+     */
+    constructor(msg) {
+        super(msg);
+        this.code = grpc.status.INVALID_ARGUMENT;
+        Object.setPrototypeOf(this, InvalidSchemaConfiguration.prototype);
+    }
+}
+exports.InvalidSchemaConfiguration = InvalidSchemaConfiguration;

package/dist/grpc_client.d.ts

@@ -0,0 +1 @@
+export declare const requester: any;

package/dist/grpc_client.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requester = 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 = __importStar(require("@grpc/grpc-js"));
+const protoLoader = require("@grpc/proto-loader");
+const packageDefinition = protoLoader.loadSync(__dirname + "../../../common/src/protos/requester.proto", {
+    keepCase: false,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
+exports.requester = protoDescriptor.fonoster.routr.requester;

package/dist/memory_store.d.ts

@@ -0,0 +1,25 @@
+import { IRegistryStore, RegistrationEntry } from "./types";
+/**
+ * In-memory store for the registry service.
+ */
+export default class MemoryStore implements IRegistryStore {
+    private collections;
+    private cleanupCount;
+    private maxCyclesBeforeCleanup;
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
+    constructor(maxCyclesBeforeCleanup?: number);
+    /** @inheritdoc */
+    put(key: string, entry: RegistrationEntry): Promise<void>;
+    /** @inheritdoc */
+    list(): Promise<RegistrationEntry[]>;
+    /** @inheritdoc */
+    get(key: string): Promise<RegistrationEntry>;
+    /** @inheritdoc */
+    delete(key: string): Promise<void>;
+    /** @inheritdoc */
+    cleanup(): void;
+}

package/dist/memory_store.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MAX_CYCLES_BEFORE_CLEANUP = 10000;
+/**
+ * In-memory store for the registry service.
+ */
+class MemoryStore {
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
+    constructor(maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP) {
+        this.collections = new Map();
+        this.maxCyclesBeforeCleanup = maxCyclesBeforeCleanup;
+    }
+    /** @inheritdoc */
+    put(key, entry) {
+        this.collections.set(key, entry);
+        return;
+    }
+    /** @inheritdoc */
+    list() {
+        return Promise.resolve(this.collections.values ? Array.from(this.collections.values()) : []);
+    }
+    /** @inheritdoc */
+    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));
+    }
+    /** @inheritdoc */
+    delete(key) {
+        this.collections.delete(key);
+        return;
+    }
+    /** @inheritdoc */
+    cleanup() {
+        // Remove all expired registration entries
+        this.collections.forEach((entry, key) => {
+            const timeElapsed = (Date.now() - entry.timeOfEntry) / 1000;
+            if (timeElapsed > entry.retentionTimeInSeconds)
+                this.collections.delete(key);
+        });
+    }
+}
+exports.default = MemoryStore;

package/dist/redis_store.d.ts

@@ -0,0 +1,22 @@
+import { IRegistryStore, RegistrationEntry } from "./types";
+import { Redis } from "@routr/common";
+/**
+ * Redis store for the registry service.
+ */
+export default class RedisStore implements IRegistryStore {
+    client: any;
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
+    constructor(config?: Redis.RedisStoreConfig);
+    /** @inheritdoc */
+    put(key: string, entry: RegistrationEntry): Promise<void>;
+    /** @inheritdoc */
+    list(): Promise<RegistrationEntry[]>;
+    /** @inheritdoc */
+    get(key: string): Promise<RegistrationEntry>;
+    /** @inheritdoc */
+    delete(key: string): Promise<void>;
+}

package/dist/redis_store.js

@@ -0,0 +1,89 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("redis");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const KEY_PREFIX = "registry";
+const logger = (0, logger_1.getLogger)({ service: "registry", filePath: __filename });
+/**
+ * Redis store for the registry service.
+ */
+class RedisStore {
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
+    constructor(config) {
+        this.client = config
+            ? (0, redis_1.createClient)({ url: common_1.Redis.getRedisUrlFromConfig(config) })
+            : (0, redis_1.createClient)();
+        this.client.connect();
+        this.client.on("error", (err) => logger.error("redis client error: ", err));
+    }
+    /** @inheritdoc */
+    put(key, entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Formatted the key to ensure it is unique
+            yield this.client.set(`${KEY_PREFIX}:${key}`, JSON.stringify(entry), {
+                EX: entry.retentionTimeInSeconds
+            });
+            return;
+        });
+    }
+    /** @inheritdoc */
+    list() {
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = [];
+            try {
+                // eslint-disable-next-line no-loops/no-loops
+                for (var _b = __asyncValues(yield this.client.scanIterator({
+                    CURSOR: 0,
+                    MATCH: `${KEY_PREFIX}:*`
+                })), _c; _c = yield _b.next(), !_c.done;) {
+                    const k = _c.value;
+                    entries.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 entries;
+        });
+    }
+    /** @inheritdoc */
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rawEntry = yield this.client.get(`${KEY_PREFIX}:${key}`);
+            return rawEntry ? JSON.parse(rawEntry) : null;
+        });
+    }
+    /** @inheritdoc */
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client.delete(`${KEY_PREFIX}:${key}`);
+        });
+    }
+}
+exports.default = RedisStore;

package/dist/request.d.ts

@@ -0,0 +1,10 @@
+import { RegistrationRequest, RequestParams } from "./types";
+/**
+ * Creates a new Registration request.
+ *
+ * @param {RequestParams} params - The parameters to build the request
+ * @return {RegistrationRequest}
+ */
+export default function createRegistrationRequest(params: RequestParams): RegistrationRequest;
+export declare const getHostFromAddress: (address: string) => string;
+export declare const getPortFromAddress: (address: string) => number;