@routr/registry 2.0.5-alpha.16

package/dist/request.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortFromAddress = exports.getHostFromAddress = 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 common_1 = require("@routr/common");
+const types_1 = require("./types");
+const uniqid_1 = __importDefault(require("uniqid"));
+// Global count for Registry CSEQ
+let cseq = 1;
+/**
+ * Creates a new Registration request.
+ *
+ * @param {RequestParams} params - The parameters to build the request
+ * @return {RegistrationRequest}
+ */
+function createRegistrationRequest(params) {
+    var _a;
+    const credentials = params.auth
+        ? {
+            name: "X-Gateway-Auth",
+            value: Buffer.from(`${params.auth.username}:${params.auth.secret}`).toString("base64")
+        }
+        : undefined;
+    return {
+        target: params.targetAddress,
+        method: common_1.Method.REGISTER,
+        transport: params.transport,
+        trunkRef: params.trunkRef,
+        user: params.user,
+        message: {
+            extensions: [
+                ...(((_a = params.methods) === null || _a === void 0 ? void 0 : _a.map((value) => {
+                    return { name: "Allow", value };
+                })) || []),
+                {
+                    name: "CSeq",
+                    value: `${cseq++} ${common_1.Method.REGISTER}`
+                },
+                {
+                    name: "User-Agent",
+                    // TODO: Take from central location (commons?)
+                    value: params.userAgent || "Routr Connect v2"
+                },
+                // TODO: Q. Should this be in the registry configuration?
+                {
+                    name: "Allow-Events",
+                    value: "presence"
+                },
+                {
+                    name: "Proxy-Require",
+                    value: "gin"
+                },
+                {
+                    name: "Require",
+                    value: "gin"
+                },
+                {
+                    name: "Supported",
+                    value: "path"
+                },
+                credentials
+            ],
+            route: [
+                {
+                    address: {
+                        uri: {
+                            host: (0, exports.getHostFromAddress)(params.proxyAddress),
+                            port: (0, exports.getPortFromAddress)(params.proxyAddress),
+                            transportParam: params.transport,
+                            lrParam: true
+                        }
+                    }
+                }
+            ],
+            from: {
+                address: {
+                    uri: {
+                        user: params.user,
+                        host: params.targetDomain,
+                        port: -1,
+                        transportParam: params.transport,
+                        secure: params.secure
+                    }
+                },
+                tag: uniqid_1.default.time()
+            },
+            to: {
+                address: {
+                    uri: {
+                        user: params.user,
+                        host: params.targetDomain,
+                        port: -1,
+                        transportParam: params.transport,
+                        secure: params.secure
+                    }
+                }
+            },
+            callId: {
+                callId: (0, uniqid_1.default)()
+            },
+            contentLength: {
+                contentLength: 0
+            },
+            expires: {
+                expires: params.expires || types_1.DEFAULT_EXPIRES
+            },
+            maxForwards: {
+                maxForwards: params.maxForwards || types_1.DEFAULT_MAX_FORWARDS
+            },
+            requestUri: {
+                user: params.user,
+                host: (0, exports.getHostFromAddress)(params.targetAddress),
+                port: (0, exports.getPortFromAddress)(params.targetAddress),
+                transportParam: params.transport,
+                methodParam: common_1.Method.REGISTER,
+                secure: params.secure
+            },
+            messageType: "requestUri"
+        }
+    };
+}
+exports.default = createRegistrationRequest;
+const getHostFromAddress = (address) => {
+    if (address.split(":").length != 2) {
+        throw new Error("malformated address; must be ${host}:${port}");
+    }
+    return address.split(":")[0];
+};
+exports.getHostFromAddress = getHostFromAddress;
+const getPortFromAddress = (address) => {
+    if (address.split(":").length != 2) {
+        throw new Error("malformated address; must be ${host}:${port}");
+    }
+    try {
+        return parseInt(address.split(":")[1]);
+    }
+    catch (e) {
+        throw new Error("expects port to be a number");
+    }
+};
+exports.getPortFromAddress = getPortFromAddress;

package/dist/runner.d.ts

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

package/dist/runner.js

@@ -0,0 +1,39 @@
+#!/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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("./tracer").init("dispatcher");
+const service_1 = __importDefault(require("./service"));
+const get_config_1 = require("./config/get_config");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "simpleauth", filePath: __filename });
+common_1.Assertions.assertEnvsAreSet(["CONFIG_PATH"]);
+const config = (0, get_config_1.getConfig)(process.env.CONFIG_PATH);
+if (config._tag === "Right") {
+    (0, service_1.default)(config.right);
+}
+else {
+    logger.error(config.left);
+}

package/dist/sender.d.ts

@@ -0,0 +1,3 @@
+import { ServiceUnavailableError } from "@routr/common";
+import { RegistrationRequest, SendMessageResponse } from "./types";
+export declare const sendRegisterMessage: (requesterAddr: string) => (request: RegistrationRequest) => Promise<ServiceUnavailableError | SendMessageResponse>;

package/dist/sender.js

@@ -0,0 +1,64 @@
+"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.sendRegisterMessage = 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 common_1 = require("@routr/common");
+const grpc_client_1 = require("./grpc_client");
+const sendRegisterMessage = (requesterAddr) => {
+    return (request) => {
+        const client = new grpc_client_1.requester.v2draft1.Requester(requesterAddr, grpc.credentials.createInsecure());
+        return new Promise((resolve, reject) => {
+            client.sendMessage(request, (err, response) => {
+                if ((err === null || err === void 0 ? void 0 : err.code) === 14) {
+                    return reject(new common_1.ServiceUnavailableError(requesterAddr));
+                }
+                else if (err) {
+                    return reject(err);
+                }
+                resolve(Object.assign({ trunkRef: request.trunkRef }, response));
+            });
+        });
+    };
+};
+exports.sendRegisterMessage = sendRegisterMessage;

package/dist/service.d.ts

@@ -0,0 +1,7 @@
+import { RegistryConfig } from "./types";
+/**
+ * Loops through all the services and register them with the registry.
+ *
+ * @param {RegistryConfig} config
+ */
+export default function registryService(config: RegistryConfig): void;

package/dist/service.js

@@ -0,0 +1,103 @@
+"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 __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 sender_1 = require("./sender");
+const request_1 = __importDefault(require("./request"));
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const common_2 = require("@routr/common");
+const logger = (0, logger_1.getLogger)({ service: "registry", filePath: __filename });
+const DEFAULT_REGISTRATION_INTERVAL = 60 * 1000;
+const DEFAULT_RETENTION_TIME = 600 * 1000;
+// TODO:
+//  - We need to filter quarentine trunks from final list of trunks
+/**
+ * Loops through all the services and register them with the registry.
+ *
+ * @param {RegistryConfig} config
+ */
+function registryService(config) {
+    logger.info("starting registry service");
+    const store = (0, utils_1.buildStore)(config);
+    // Creates internval to send registration request every X seconds
+    setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        logger.verbose("starting registration process");
+        let resources = [];
+        const dataAPI = common_1.CommonConnect.dataAPI(config.apiAddr);
+        try {
+            resources = yield (0, utils_1.findTrunks)(dataAPI);
+        }
+        catch (err) {
+            logger.error("failed to retrieve trunks from API", err);
+            return;
+        }
+        const registryInvocations = resources.map((resource) => __awaiter(this, void 0, void 0, function* () {
+            const registrationRequestInput = (0, utils_1.registrationRequestInputFromTrunk)(yield (0, utils_1.convertResourceToTrunk)(dataAPI, resource), config);
+            const request = (0, request_1.default)(registrationRequestInput);
+            return (0, sender_1.sendRegisterMessage)(config.requesterAddr)(request);
+        }));
+        const results = yield Promise.allSettled(registryInvocations);
+        results === null || results === void 0 ? void 0 : results.forEach((result) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.verbose("processing registration result", { result });
+            if (result.status === "rejected") {
+                logger.error("request rejected", result.reason);
+                return;
+            }
+            if (result.value instanceof common_2.ServiceUnavailableError) {
+                logger.error("service unavailable", result.value);
+                return;
+            }
+            const message = result.value.message;
+            const retentionTime = ((_a = message.expires) === null || _a === void 0 ? void 0 : _a.expires) || DEFAULT_RETENTION_TIME;
+            // TODO: Refactor to use ResponseType instead of string
+            const status = message.responseType.toString() == "OK"
+                ? types_1.RegistrationEntryStatus.REGISTERED
+                : types_1.RegistrationEntryStatus.QUARANTINE;
+            // Storing trunk in registry with status and retention time
+            logger.verbose("storing trunk in registry", {
+                trunkRef: result.value.trunkRef,
+                status,
+                retentionTime
+            });
+            store.put(result.value.trunkRef, {
+                trunkRef: result.value.trunkRef,
+                timeOfEntry: new Date().getTime(),
+                retentionTimeInSeconds: retentionTime,
+                status
+            });
+        }));
+    }), config.registerInterval * 1000 || DEFAULT_REGISTRATION_INTERVAL);
+}
+exports.default = registryService;

package/dist/tracer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+export declare function init(serviceName: string): import("@opentelemetry/api").Tracer;

package/dist/tracer.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = 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 api_1 = __importDefault(require("@opentelemetry/api"));
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const exporter_jaeger_1 = require("@opentelemetry/exporter-jaeger");
+const instrumentation_grpc_1 = require("@opentelemetry/instrumentation-grpc");
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+function init(serviceName) {
+    const provider = new sdk_trace_node_1.NodeTracerProvider({
+        resource: new resources_1.Resource({
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName
+        })
+    });
+    const exporter = new exporter_jaeger_1.JaegerExporter();
+    provider.addSpanProcessor(new sdk_trace_base_1.SimpleSpanProcessor(exporter));
+    provider.register();
+    (0, instrumentation_1.registerInstrumentations)({
+        instrumentations: [new instrumentation_grpc_1.GrpcInstrumentation()]
+    });
+    return api_1.default.trace.getTracer("routr-tracer");
+}
+exports.init = init;

package/dist/types.d.ts

@@ -0,0 +1,89 @@
+import { Method, Transport } from "@routr/common";
+import { SIPMessage } from "@routr/common/src/types";
+export declare const DEFAULT_MAX_FORWARDS = 70;
+export declare const DEFAULT_EXPIRES = 600;
+export declare enum CACHE_PROVIDER {
+    MEMORY = "memory",
+    REDIS = "redis"
+}
+export declare enum RegistrationEntryStatus {
+    REGISTERED = "registered",
+    QUARANTINE = "quarantine"
+}
+export interface EdgePort {
+    address: string;
+    region: string;
+}
+export interface RegistryConfig {
+    bindAddr: string;
+    requesterAddr: string;
+    apiAddr: string;
+    edgePorts: EdgePort[];
+    registerInterval: number;
+    methods: Method[];
+    cache?: {
+        provider: CACHE_PROVIDER;
+        parameters?: string;
+    };
+}
+export interface RegistrationRequest {
+    trunkRef: string;
+    target: string;
+    user: string;
+    method: Method;
+    transport: Transport;
+    message: SIPMessage;
+}
+export interface SendMessageResponse {
+    trunkRef: string;
+    message: SIPMessage;
+}
+export interface RedisStoreConfig {
+    username?: string;
+    password?: string;
+    host: string;
+    port: number;
+    secure?: boolean;
+}
+export interface RequestParams {
+    user: string;
+    trunkRef: string;
+    targetDomain: string;
+    targetAddress: string;
+    proxyAddress: string;
+    transport: Transport;
+    userAgent?: string;
+    methods?: Method[];
+    maxForwards?: number;
+    expires?: number;
+    secure?: boolean;
+    auth?: {
+        username: string;
+        secret: string;
+    };
+}
+export interface RegistrationEntry {
+    trunkRef: string;
+    timeOfEntry: number;
+    retentionTimeInSeconds: number;
+    status: RegistrationEntryStatus;
+}
+export interface IRegistryStore {
+    put(key: string, entry: RegistrationEntry): Promise<void>;
+    get(key: string): Promise<RegistrationEntry>;
+    delete(key: string): Promise<void>;
+    list(): Promise<RegistrationEntry[]>;
+}
+export interface Trunk {
+    ref: string;
+    name: string;
+    region: string;
+    host: string;
+    port: number;
+    user: string;
+    credentials?: {
+        username: string;
+        secret: string;
+    };
+    transport: Transport;
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationEntryStatus = exports.CACHE_PROVIDER = exports.DEFAULT_EXPIRES = exports.DEFAULT_MAX_FORWARDS = void 0;
+exports.DEFAULT_MAX_FORWARDS = 70;
+exports.DEFAULT_EXPIRES = 600;
+var CACHE_PROVIDER;
+(function (CACHE_PROVIDER) {
+    CACHE_PROVIDER["MEMORY"] = "memory";
+    CACHE_PROVIDER["REDIS"] = "redis";
+})(CACHE_PROVIDER = exports.CACHE_PROVIDER || (exports.CACHE_PROVIDER = {}));
+var RegistrationEntryStatus;
+(function (RegistrationEntryStatus) {
+    RegistrationEntryStatus["REGISTERED"] = "registered";
+    RegistrationEntryStatus["QUARANTINE"] = "quarantine";
+})(RegistrationEntryStatus = exports.RegistrationEntryStatus || (exports.RegistrationEntryStatus = {}));

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+import { Transport } from "@routr/common";
+import { CommonConnect as CC } from "@routr/common";
+import MemoryStore from "./memory_store";
+import RedisStore from "./redis_store";
+import { IRegistryStore, RegistryConfig, Trunk } from "./types";
+export declare function getUnregisteredTrunks(store: IRegistryStore): (trunks: Trunk[]) => Promise<Trunk[]>;
+export declare function findTrunks(dataAPI: CC.DataAPI): Promise<CC.Resource[]>;
+export declare const configFromString: (params: string, allowedKeys: string[]) => Record<string, string | boolean>;
+export declare const buildStore: (config: RegistryConfig) => MemoryStore | RedisStore;
+export declare const convertResourceToTrunk: (dataAPI: CC.DataAPI, resource: CC.Resource) => Promise<Trunk>;
+export declare const registrationRequestInputFromTrunk: (trunk: Trunk, config: RegistryConfig) => {
+    trunkRef: string;
+    user: string;
+    targetDomain: string;
+    targetAddress: string;
+    proxyAddress: string;
+    transport: Transport;
+    auth: {
+        username: string;
+        secret: string;
+    };
+    methods: import("@routr/common").Method[];
+};