@routr/edgeport 2.0.3

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

@@ -0,0 +1,5 @@
+import { EdgePortConfig, Transport } from "./types";
+export declare const isSecureProto: (proto: string) => boolean;
+export declare const assertHasSecurityContext: (config: EdgePortConfig) => void;
+export declare const assertNoDuplicatedProto: (transports: Array<Transport>) => void;
+export declare const assertNoDuplicatedPort: (transports: Array<Transport>) => void;

package/dist/assertions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoDuplicatedPort = exports.assertNoDuplicatedProto = exports.assertHasSecurityContext = exports.isSecureProto = void 0;
+// We need to have the spec.securityContext for all secure protocol
+var isSecureProto = function (proto) { return proto === 'wss' || proto === 'tls'; };
+exports.isSecureProto = isSecureProto;
+// We need to have the spec.securityContext for all secure protocol
+var assertHasSecurityContext = function (config) {
+    var hasSecureProto = config.spec.transport.some(function (t1) { return exports.isSecureProto(t1.protocol); });
+    if (hasSecureProto && !config.spec.securityContext) {
+        throw new Error('found at least one secure protocol which requires setting the .spec.securityContext');
+    }
+};
+exports.assertHasSecurityContext = assertHasSecurityContext;
+// Only one entry per protocol is allowed
+var assertNoDuplicatedProto = function (transports) {
+    if (transports.some(function (t1) {
+        return transports.filter(function (t2) { return t1.protocol === t2.protocol; }).length > 1;
+    })) {
+        throw new Error('found duplicated entries at .spec.transport');
+    }
+};
+exports.assertNoDuplicatedProto = assertNoDuplicatedProto;
+// The only protocol that can accept the same port twice are udp and tcp
+var assertNoDuplicatedPort = function (transports) {
+    var duplicateCondition = function (t1, t2) {
+        return (t1.port === t2.port &&
+            t1.protocol !== 'udp' &&
+            t1.protocol !== 'tcp');
+    };
+    if (transports.some(function (t1) {
+        return transports.filter(function (t2) { return duplicateCondition(t1, t2); }).length > 1;
+    })) {
+        throw new Error("found the same port on more that one entry at .spec.transport");
+    }
+};
+exports.assertNoDuplicatedPort = assertNoDuplicatedPort;

package/dist/config/fs.d.ts

@@ -0,0 +1,2 @@
+export declare const readFile: (path: string) => any;
+export declare const writeFile: (path: string, text: string) => void;

package/dist/config/fs.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFile = exports.readFile = void 0;
+var BufferedWriter = Java.type('java.io.BufferedWriter');
+var FileWriter = Java.type('java.io.FileWriter');
+var JFile = Java.type('java.io.File');
+var Files = Java.type('java.nio.file.Files');
+var Paths = Java.type('java.nio.file.Paths');
+var readFile = function (path) {
+    var lines = Files.readAllLines(Paths.get(path), Java.type('java.nio.charset.StandardCharsets').UTF_8);
+    var data = [];
+    lines.forEach(function (line) {
+        data.push(line);
+    });
+    return data.join('\n').trim();
+};
+exports.readFile = readFile;
+var writeFile = function (path, text) {
+    var file = new JFile(path);
+    var out = new BufferedWriter(new FileWriter(file));
+    out.write(text);
+    out.close();
+};
+exports.writeFile = writeFile;

package/dist/config/get_config.d.ts

@@ -0,0 +1,5 @@
+import * as J from 'fp-ts/Json';
+import * as E from 'fp-ts/Either';
+export declare const readFile: (path: string) => E.Either<Error, string>;
+export declare const validateConfig: (j: J.Json) => E.Either<Error, J.Json>;
+export declare const getConfig: <C>(path: string) => E.Either<Error, C>;

package/dist/config/get_config.js

@@ -0,0 +1,53 @@
+"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 = exports.validateConfig = exports.readFile = void 0;
+var E = __importStar(require("fp-ts/Either"));
+var F = __importStar(require("./fs"));
+var function_1 = require("fp-ts/function");
+var schema_1 = require("./schema");
+var ajv_1 = __importDefault(require("ajv"));
+var ajv = new ajv_1.default();
+var validate = ajv.compile(schema_1.schema);
+// Reads a file a returns as a string
+var readFile = function (path) {
+    return E.tryCatch(function () { return F.readFile(path); }, E.toError);
+};
+exports.readFile = readFile;
+// Validate Json with Ajv
+var validateConfig = function (j) {
+    return E.tryCatch(function () {
+        if (validate(j))
+            return j;
+        throw new Error(validate.errors[0].message);
+    }, E.toError);
+};
+exports.validateConfig = validateConfig;
+// Read a file and validate its content with Ajv
+var getConfig = function (path) {
+    return function_1.pipe(path, exports.readFile, E.chain(function (value) {
+        return function_1.pipe(E.tryCatch(function () { return JSON.parse(value); }, E.toError), E.chain(exports.validateConfig));
+    }), E.map(function (v) { return v; }));
+};
+exports.getConfig = getConfig;

package/dist/config/schema.d.ts

@@ -0,0 +1,96 @@
+export declare const schema: {
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    properties: {
+        kind: {
+            description: string;
+            type: string;
+        };
+        apiVersion: {
+            enum: string[];
+        };
+        metadata: {
+            description: string;
+            type: string;
+            properties: {
+                ref: {
+                    description: string;
+                    type: string;
+                };
+                region: {
+                    description: string;
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+        spec: {
+            description: string;
+            type: string;
+            properties: {
+                bindAddr: {
+                    description: string;
+                    type: string;
+                };
+                advertisedAddrs: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    uniqueItems: boolean;
+                    minItems: number;
+                };
+                localnets: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    uniqueItems: boolean;
+                    minItems: number;
+                };
+                methods: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    uniqueItems: boolean;
+                };
+                transport: {
+                    description: string;
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    properties: {
+                        protocol: {
+                            type: string;
+                        };
+                        bindAddr: {
+                            type: string;
+                        };
+                        port: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+                messageRouter: {
+                    description: string;
+                    type: string;
+                    properties: {
+                        addr: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            required: string[];
+        };
+    };
+    required: string[];
+};

package/dist/config/schema.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+/*
+ * Copyright (C) 2021 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": "EdgPort configuration",
+    "description": "Configuration for an EdgePort instance",
+    "type": "object",
+    "properties": {
+        "kind": {
+            "description": "Resouce type",
+            "type": "string"
+        },
+        "apiVersion": {
+            "enum": ["v2draft1", "v2.0", "v2"]
+        },
+        "metadata": {
+            "description": "Resource metadata",
+            "type": "object",
+            "properties": {
+                "ref": {
+                    "description": "EdgePort reference",
+                    "type": "string"
+                },
+                "region": {
+                    "description": "Optional region where the EdgePort is operating",
+                    "type": "string"
+                }
+            },
+            "required": ["ref"]
+        },
+        "spec": {
+            "description": "Operation spec for the EdgePort",
+            "type": "object",
+            "properties": {
+                "bindAddr": {
+                    "description": "Ipv4 interface to accept request on",
+                    "type": "string"
+                },
+                "advertisedAddrs": {
+                    "description": "EdgePort external addresses. Might be Ipv4, Hostname",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true,
+                    "minItems": 1,
+                },
+                "localnets": {
+                    "description": "Networks considered to be in the same local network",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true,
+                    "minItems": 1,
+                },
+                "methods": {
+                    "description": "Acceptable SIP Methods",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "uniqueItems": true
+                },
+                "transport": {
+                    "description": "Acceptable Transport Protocols",
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    },
+                    "properties": {
+                        "protocol": {
+                            "type": "string"
+                        },
+                        "bindAddr": {
+                            "type": "string"
+                        },
+                        "port": {
+                            "type": "integer"
+                        }
+                    },
+                    "required": ["port", "protocol"]
+                },
+                "messageRouter": {
+                    "description": "Adjacent service for message routing",
+                    "type": "object",
+                    "properties": {
+                        "addr": {
+                            "type": "string"
+                        }
+                    }
+                }
+            },
+            "required": ["methods", "transport", "messageRouter"]
+        },
+    },
+    "required": ["kind", "metadata", "spec", "apiVersion"]
+};

package/dist/create_listening_points.d.ts

@@ -0,0 +1,2 @@
+import { EdgePortConfig, ListeningPoint, SipStack } from "./types";
+export default function createListeningPoints(sipStack: SipStack, config: EdgePortConfig): Array<ListeningPoint>;

package/dist/create_listening_points.js

@@ -0,0 +1,44 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Creates LPs for all of the given transport and throws if upstream function fails
+function createListeningPoints(sipStack, config) {
+    var e_1, _a;
+    var listeningPoints = [];
+    try {
+        for (var _b = __values(config.spec.transport), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var trans = _c.value;
+            var proto = trans.protocol.toLowerCase();
+            // If none was found we use the global bindAddr
+            if (trans.bindAddr === undefined) {
+                trans.bindAddr = config.spec.bindAddr;
+            }
+            try {
+                var lp = sipStack.createListeningPoint(trans.bindAddr, trans.port, proto);
+                listeningPoints.push(lp);
+            }
+            catch (e) {
+                throw new Error("unable to bind " + proto + "://" + trans.bindAddr + ":" + trans.port);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return listeningPoints;
+}
+exports.default = createListeningPoints;

package/dist/create_sip_provider.d.ts

@@ -0,0 +1,2 @@
+import { SipStack, ListeningPoint, SipProvider } from "./types";
+export default function createSipProvider(sipStack: SipStack, listeningPoints: Array<ListeningPoint>): SipProvider;

package/dist/create_sip_provider.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createSipProvider(sipStack, listeningPoints) {
+    var _a;
+    var sipProvider = sipStack.createSipProvider(listeningPoints[0]);
+    (_a = listeningPoints === null || listeningPoints === void 0 ? void 0 : listeningPoints.filter((function (lp, index) { return index > 0; }))) === null || _a === void 0 ? void 0 : _a.forEach(function (lp) { return sipProvider.addListeningPoint(lp); });
+    return sipProvider;
+}
+exports.default = createSipProvider;

package/dist/create_sip_stack.d.ts

@@ -0,0 +1,6 @@
+import { SipStack } from "./types";
+/**
+ * Takes a properties map and returns an instance of the
+ * Java object SipStack
+ */
+export default function createSipStack(props: Map<string, string>): SipStack;

package/dist/create_sip_stack.js

@@ -0,0 +1,40 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var SipFactory = Java.type('javax.sip.SipFactory');
+var Properties = Java.type('java.util.Properties');
+/**
+ * Takes a properties map and returns an instance of the
+ * Java object SipStack
+ */
+function createSipStack(props) {
+    var e_1, _a;
+    var properties = new Properties();
+    try {
+        for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
+            var entry = props_1_1.value;
+            properties.setProperty(entry[0], entry[1]);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var sipFactory = SipFactory.getInstance();
+    sipFactory.setPathName('gov.nist');
+    return sipFactory.createSipStack(properties);
+}
+exports.default = createSipStack;

package/dist/edgeport.d.ts

@@ -0,0 +1,2 @@
+import { EdgePortConfig } from "./types";
+export default function EdgePort(config: EdgePortConfig): void;

package/dist/edgeport.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var assertions_1 = require("./assertions");
+var create_listening_points_1 = __importDefault(require("./create_listening_points"));
+var create_sip_provider_1 = __importDefault(require("./create_sip_provider"));
+var create_sip_stack_1 = __importDefault(require("./create_sip_stack"));
+var server_properties_1 = __importDefault(require("./server_properties"));
+var GRPCSipListener = Java.type("io.routr.GRPCSipListener");
+function EdgePort(config) {
+    assertions_1.assertNoDuplicatedProto(config.spec.transport);
+    assertions_1.assertNoDuplicatedPort(config.spec.transport);
+    assertions_1.assertHasSecurityContext(config);
+    var sipStack = create_sip_stack_1.default(server_properties_1.default(config));
+    var sipProvider = create_sip_provider_1.default(sipStack, create_listening_points_1.default(sipStack, config));
+    sipProvider.addSipListener(new GRPCSipListener());
+}
+exports.default = EdgePort;

package/dist/runner.d.ts

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

package/dist/runner.js

@@ -0,0 +1,15 @@
+#!/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 });
+var edgeport_1 = __importDefault(require("./edgeport"));
+var get_config_1 = require("./config/get_config");
+var config = get_config_1.getConfig(System.getenv('CONFIG_DIR'));
+if (config._tag === 'Right') {
+    edgeport_1.default(config.right);
+}
+else {
+    console.log(config.left);
+}

package/dist/server_properties.d.ts

@@ -0,0 +1,7 @@
+import { EdgePortConfig } from "./types";
+/**
+ * Returns a Map object with the properties for the server's SipStack.
+ * For more options see:
+ *  https://github.com/RestComm/jain-sip/blob/master/src/gov/nist/javax/sip/SipStackImpl.java
+ */
+export default function getServerProperties(config: EdgePortConfig): Map<string, string>;

package/dist/server_properties.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Returns a Map object with the properties for the server's SipStack.
+ * For more options see:
+ *  https://github.com/RestComm/jain-sip/blob/master/src/gov/nist/javax/sip/SipStackImpl.java
+ */
+function getServerProperties(config) {
+    var properties = new Map();
+    properties.set('javax.sip.STACK_NAME', 'routr');
+    properties.set('javax.sip.AUTOMATIC_DIALOG_SUPPORT', 'OFF');
+    properties.set('gov.nist.javax.sip.MESSAGE_PROCESSOR_FACTORY', 'gov.nist.javax.sip.stack.NioMessageProcessorFactory');
+    properties.set('gov.nist.javax.sip.PATCH_SIP_WEBSOCKETS_HEADERS', 'false');
+    properties.set('gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS', 'true');
+    properties.set('gov.nist.javax.sip.REENTRANT_LISTENER', 'false');
+    properties.set('gov.nist.javax.sip.THREAD_POOL_SIZE', '16');
+    properties.set('gov.nist.javax.sip.NIO_BLOCKING_MODE', 'NONBLOCKING');
+    // Guard against denial of service attack.
+    properties.set('gov.nist.javax.sip.MAX_MESSAGE_SIZE', '1048576');
+    properties.set('gov.nist.javax.sip.LOG_MESSAGE_CONTENT', 'true');
+    // Default host
+    properties.set('javax.sip.IP_ADDRESS', config.spec.bindAddr);
+    if (config.spec.securityContext) {
+        properties.set('gov.nist.javax.sip.TLS_CLIENT_PROTOCOLS', config.spec.securityContext.client.protocols.join());
+        // This must be set to 'Disabled' when using WSS
+        properties.set('gov.nist.javax.sip.TLS_CLIENT_AUTH_TYPE', config.spec.securityContext.client.authType);
+        properties.set('javax.net.ssl.keyStore', config.spec.securityContext.keyStore);
+        properties.set('javax.net.ssl.trustStore', config.spec.securityContext.trustStore);
+        properties.set('javax.net.ssl.keyStorePassword', config.spec.securityContext.keyStorePassword);
+        properties.set('javax.net.ssl.trustStorePassword', config.spec.securityContext.trustStorePassword);
+        properties.set('javax.net.ssl.keyStoreType', config.spec.securityContext.keyStoreType);
+    }
+    return properties;
+}
+exports.default = getServerProperties;

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+export interface Transport {
+    protocol: string;
+    bindAddr?: string;
+    port: number;
+}
+export interface EdgePortConfig {
+    spec: {
+        bindAddr: string;
+        transport: Array<Transport>;
+        securityContext?: {
+            debugging: boolean;
+            keyStore: string;
+            trustStore: string;
+            trustStorePassword: string;
+            keyStorePassword: string;
+            keyStoreType: string;
+            client: {
+                authType: string;
+                protocols: Array<string>;
+            };
+        };
+    };
+}
+export declare interface SipStack {
+    createListeningPoint: (bindAddr: string, port: number, proto: string) => unknown;
+    createSipProvider: (lp: ListeningPoint) => SipProvider;
+    getClass: () => any;
+}
+export declare interface ListeningPoint {
+}
+export declare interface SipProvider {
+    addListeningPoint: (lp: ListeningPoint) => void;
+    addSipListener: (lp: unknown) => void;
+}
+export declare interface Java {
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@routr/edgeport",
+  "version": "2.0.3",
+  "description": "SIP endpoint at the edge of the network",
+  "author": "Pedro Sanders <psanders@fonoster.com>",
+  "homepage": "https://github.com/fonoster/routr#readme",
+  "license": "MIT",
+  "main": "dist/edgeport",
+  "types": "dist/edgeport",
+  "directories": {
+    "src": "src",
+    "test": "test"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/routr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/routr/issues"
+  },
+  "gitHead": "aaacb51da7787d678a89e34a64655fa9a1990364"
+}