mybase 1.1.9 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/funcs/randomIP6.js

@@ -11,6 +11,6 @@ const ip6_1 = __importDefault(require("ip6"));
 function randomIP6() {
     var _a;
     const bytes = (0, crypto_1.randomBytes)(16);
-    return ip6_1.default.normalize(((_a = bytes.toString('hex').match(/.{1,4}/g)) === null || _a === void 0 ? void 0 : _a.join(':')) || '0000:0000:0000:0000:0000:0000:0000:0000');
+    return ip6_1.default.abbreviate(ip6_1.default.normalize(((_a = bytes.toString('hex').match(/.{1,4}/g)) === null || _a === void 0 ? void 0 : _a.join(':')) || '0000:0000:0000:0000:0000:0000:0000:0000'));
 }
 exports.randomIP6 = randomIP6;

package/ts/funcs/randomIP6.ts

@@ -5,7 +5,7 @@ import ip6 from 'ip6'
 
 export function randomIP6() : string {
     const bytes = randomBytes(16)
-    return ip6.normalize(bytes.toString('hex').match(/.{1,4}/g)?.join(':') || '0000:0000:0000:0000:0000:0000:0000:0000')
+    return ip6.abbreviate(ip6.normalize(bytes.toString('hex').match(/.{1,4}/g)?.join(':') || '0000:0000:0000:0000:0000:0000:0000:0000'))
 }
 
 

package/ts/funcs/randomTCPPort.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 25400
+ * @param untilPort the last port number to check defaults to 26400
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+export declare function randomTCPPort(timeout?: number, fromPort?: number, untilPort?: number, tries?: number, host?: string): Promise<number | false>;

package/ts/funcs/randomTCPPort.js

@@ -0,0 +1,84 @@
+"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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomTCPPort = void 0;
+const net = __importStar(require("net"));
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 25400
+ * @param untilPort the last port number to check defaults to 26400
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+function randomTCPPort(timeout = 1000, fromPort = 25400, untilPort = 26400, tries = 1000, host = '127.0.0.1') {
+    return __awaiter(this, void 0, void 0, function* () {
+        // check if the given port range is valid
+        if (fromPort > untilPort)
+            return false;
+        // check if the given port range is valid
+        if (fromPort < 0 || untilPort < 0)
+            return false;
+        // check if the given port range is valid
+        if (fromPort > 65535 || untilPort > 65535)
+            return false;
+        // this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+        // this port number immediately
+        // this function should be used for testing purposes only
+        // this function is not suitable for production use
+        for (let i = 0; i < tries; i++) {
+            let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort);
+            let server = net.createServer();
+            let checkPort = new Promise((resolve, reject) => {
+                server.on('error', (err) => {
+                    // any error should raise problem
+                    resolve(false);
+                });
+                server.on('listening', () => {
+                    server.close();
+                    resolve(true);
+                });
+            });
+            server.listen(port, host);
+            let result = yield checkPort;
+            if (result)
+                return port;
+        }
+        return false;
+    });
+}
+exports.randomTCPPort = randomTCPPort;

package/ts/funcs/randomTCPPort.test.ts

@@ -0,0 +1,62 @@
+import { wait } from "./wait";
+import { randomTCPPort } from "./randomTCPPort";
+
+
+describe("randomTCPPort", () => {
+  let fromPort = 15000;
+  let untilPort = fromPort+1000;
+  let hostToBind="127.0.0.1"
+
+  beforeEach(() => {
+    untilPort = fromPort+1000;
+  })
+
+  test("should return a random port number within the given range", async () => {
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port).toBeGreaterThanOrEqual(fromPort);
+    expect(port).toBeLessThanOrEqual(untilPort);
+  });
+
+  test("should return false if no available port is found", async () => {
+    untilPort = fromPort+1;
+    // listen to the port 15000 and 15001 to simulate that these ports are in use
+    const server1 = require("net").createServer();
+    const server2 = require("net").createServer();
+    server1.listen(fromPort, hostToBind);
+    server2.listen(untilPort, hostToBind);
+    // try to find a port within the range
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port).toBe(false);
+    server1.close();
+    server2.close();
+    await wait(1/100)
+    const port2 = await randomTCPPort(1000, fromPort, untilPort, 1000, hostToBind);
+    expect(port2===fromPort || port2===untilPort).toBe(true);
+  });
+
+  test("should handle errors when trying to listen to a port", async () => {
+    const port = await randomTCPPort(1000, fromPort, untilPort, 1000, "invalid-host");
+    expect(port).toBe(false);
+  })
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, untilPort, fromPort, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, -1, untilPort, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, fromPort, -1, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+  test("should return false if the given port range is invalid", async () => {
+    const port = await randomTCPPort(1000, fromPort, 65536, 1000, hostToBind);
+    expect(port).toBe(false);
+  });
+
+});

package/ts/funcs/randomTCPPort.ts

@@ -0,0 +1,44 @@
+import * as net from 'net'
+
+/**
+ * This function returns a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+ * this port number immediately
+ * This function should be used for testing purposes only
+ * This function is not suitable for production use
+ * @param timeout the timeout for each port check
+ * @param fromPort the first port number to check defaults to 25400
+ * @param untilPort the last port number to check defaults to 26400
+ * @param tries the number of tries to find a port number
+ * @param host the host to bind to
+ */
+export async function randomTCPPort(timeout:number=1000,fromPort:number=25400,untilPort:number=26400,tries=1000,host='127.0.0.1') : Promise<number|false> {
+    // check if the given port range is valid
+    if (fromPort>untilPort) return false
+    // check if the given port range is valid
+    if (fromPort<0 || untilPort<0) return false
+    // check if the given port range is valid
+    if (fromPort>65535 || untilPort>65535) return false
+
+	// this function shall return a random port number that is not in use and we should validate this port number by trying to listen to it and releasing
+    // this port number immediately
+    // this function should be used for testing purposes only
+    // this function is not suitable for production use
+    for(let i=0; i<tries; i++) {
+        let port = Math.floor(Math.random() * (untilPort - fromPort + 1) + fromPort)
+        let server = net.createServer()
+        let checkPort = new Promise((resolve,reject) => {
+            server.on('error', (err) => {
+                // any error should raise problem
+                resolve(false)
+            })
+            server.on('listening', () => {
+                server.close()
+                resolve(true)
+            })
+        })
+        server.listen(port,host)
+        let result = await checkPort
+        if (result) return port
+    }
+    return false
+}

package/ts/index.d.ts

@@ -14,3 +14,4 @@ export * from "./funcs/randomIP";
 export * from "./funcs/ip2int";
 export * from "./funcs/int2ip";
 export * from "./funcs/randomIP6";
+export * from "./funcs/randomTCPPort";

package/ts/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./funcs/randomIP"), exports);
 __exportStar(require("./funcs/ip2int"), exports);
 __exportStar(require("./funcs/int2ip"), exports);
 __exportStar(require("./funcs/randomIP6"), exports);
+__exportStar(require("./funcs/randomTCPPort"), exports);

package/ts/index.ts

@@ -14,4 +14,5 @@ export * from "./funcs/randomIP"
 export * from "./funcs/ip2int"
 export * from "./funcs/int2ip"
 export * from "./funcs/randomIP6"
+export * from "./funcs/randomTCPPort"