@kapeta/local-cluster-service 0.64.0 → 0.64.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.64.2](https://github.com/kapetacom/local-cluster-service/compare/v0.64.1...v0.64.2) (2024-08-22)
+
+
+### Bug Fixes
+
+* handle port detection on multiple interfaces ([#222](https://github.com/kapetacom/local-cluster-service/issues/222)) ([6635cc2](https://github.com/kapetacom/local-cluster-service/commit/6635cc207355b2083edbb380f0ba83227c6a16e1))
+
+## [0.64.1](https://github.com/kapetacom/local-cluster-service/compare/v0.64.0...v0.64.1) (2024-08-21)
+
+
+### Bug Fixes
+
+* tweak port detection code ([#221](https://github.com/kapetacom/local-cluster-service/issues/221)) ([84000ea](https://github.com/kapetacom/local-cluster-service/commit/84000eae5eaec0d7ca975029b6cb7fcefcb87340))
+
 # [0.64.0](https://github.com/kapetacom/local-cluster-service/compare/v0.63.1...v0.64.0) (2024-08-21)
 
 

package/dist/cjs/src/clusterService.d.ts

@@ -16,7 +16,7 @@ declare class ClusterService {
      * Gets next available port
      */
     getNextAvailablePort(startPort?: number): Promise<number>;
-    _checkIfPortIsUsed(port: number, host?: string): Promise<unknown>;
+    private resolveWithAvailablePort;
     /**
      * The port of this local cluster service itself
      */

package/dist/cjs/src/clusterService.js

@@ -3,10 +3,13 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clusterService = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const net = require('net');
+const net_1 = __importDefault(require("net"));
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
 const DEFAULT_HOST = '127.0.0.1';
@@ -38,56 +41,51 @@ class ClusterService {
         await this._findClusterServicePort();
     }
     async _findClusterServicePort() {
-        while (true) {
-            const isUsed = await this._checkIfPortIsUsed(this._port);
-            if (!isUsed) {
-                break;
+        for (; this._port <= 65535; this._port++) {
+            try {
+                await this.resolveWithAvailablePort(this._port);
+                return;
+            }
+            catch (e) {
+                // try again
             }
-            this._port++;
         }
+        throw new Error('No available ports');
     }
     /**
      * Gets next available port
      */
     async getNextAvailablePort(startPort = -1) {
-        let receivedStartPort = startPort > 0;
-        if (!receivedStartPort) {
-            startPort = this._currentPort;
-        }
-        while (true) {
-            while (this._reservedPorts.indexOf(startPort) > -1) {
-                startPort++;
-                if (!receivedStartPort) {
-                    this._currentPort = startPort;
-                }
-            }
-            const nextPort = startPort++;
-            if (!receivedStartPort) {
-                this._currentPort = startPort;
+        for (let nextPort = startPort > 0 ? startPort : this._currentPort; nextPort <= 65535; nextPort++) {
+            if (this._reservedPorts.indexOf(nextPort) > -1) {
+                continue;
             }
-            const isUsed = await this._checkIfPortIsUsed(nextPort);
-            if (!isUsed) {
+            try {
+                // Try both IPv4 and IPv6 addresses
+                await this.resolveWithAvailablePort(nextPort);
+                await this.resolveWithAvailablePort(nextPort, '0.0.0.0');
+                // Save the state if we're looking for a system port for the cluster itself
+                if (startPort <= 0) {
+                    this._currentPort = nextPort;
+                }
                 return nextPort;
             }
+            catch (e) {
+                // try again  }
+            }
         }
+        throw new Error('No available ports');
     }
-    _checkIfPortIsUsed(port, host = this._host) {
+    async resolveWithAvailablePort(port, host = this._host) {
         return new Promise((resolve, reject) => {
-            const server = net.createServer();
-            server.once('error', function (err) {
-                if (err.code === 'EADDRINUSE') {
-                    server.close();
-                    resolve(true);
-                    return;
-                }
-                server.close();
-                reject(err);
-            });
-            server.once('listening', function () {
-                server.close();
-                resolve(false);
+            const server = net_1.default.createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({ port, host }, (...args) => {
+                server.close(() => {
+                    resolve(port);
+                });
             });
-            server.listen(port, host);
         });
     }
     /**

package/dist/cjs/src/storm/UIServer.d.ts

@@ -1,13 +1,5 @@
-/// <reference types="node" />
-import { Server } from 'http';
 import { StormEventPage } from './events';
-declare module 'express-serve-static-core' {
-    interface Application {
-        listen(port: number, callback?: (err?: Error) => void): Server;
-    }
-}
 export declare class UIServer {
-    private readonly express;
     private readonly systemId;
     private port;
     private server;

package/dist/cjs/src/storm/UIServer.js

@@ -11,34 +11,31 @@ exports.UIServer = void 0;
 const express_1 = __importDefault(require("express"));
 const page_utils_1 = require("./page-utils");
 const clusterService_1 = require("../clusterService");
+const http_1 = require("http");
 class UIServer {
-    express;
     systemId;
     port = 50000;
     server;
     constructor(systemId) {
         this.systemId = systemId;
-        this.express = (0, express_1.default)();
     }
     async start() {
-        this.port = await clusterService_1.clusterService.getNextAvailablePort(this.port);
-        this.express.get('/_reset', (req, res) => {
+        const app = (0, express_1.default)();
+        app.get('/_reset', (req, res) => {
             res.send(`
                 <script>
                     window.localStorage.clear();
                     window.sessionStorage.clear();
                 </script>`);
         });
-        this.express.all('/*', (req, res) => {
+        app.all('/*', (req, res) => {
             (0, page_utils_1.readPageFromDisk)(this.systemId, req.params[0], req.method, res);
         });
+        this.port = await clusterService_1.clusterService.getNextAvailablePort(this.port);
         return new Promise((resolve, reject) => {
-            this.server = this.express.listen(this.port, (err) => {
-                if (err) {
-                    console.error('Failed to start UI server', err);
-                    reject(err);
-                    return;
-                }
+            this.server = (0, http_1.createServer)(app);
+            this.server.on('error', reject);
+            this.server.listen(this.port, () => {
                 console.log(`UI Server started on port ${this.port}`);
                 resolve();
             });

package/dist/esm/src/clusterService.d.ts

@@ -16,7 +16,7 @@ declare class ClusterService {
      * Gets next available port
      */
     getNextAvailablePort(startPort?: number): Promise<number>;
-    _checkIfPortIsUsed(port: number, host?: string): Promise<unknown>;
+    private resolveWithAvailablePort;
     /**
      * The port of this local cluster service itself
      */

package/dist/esm/src/clusterService.js

@@ -3,10 +3,13 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clusterService = void 0;
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const net = require('net');
+const net_1 = __importDefault(require("net"));
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
 const DEFAULT_HOST = '127.0.0.1';
@@ -38,56 +41,51 @@ class ClusterService {
         await this._findClusterServicePort();
     }
     async _findClusterServicePort() {
-        while (true) {
-            const isUsed = await this._checkIfPortIsUsed(this._port);
-            if (!isUsed) {
-                break;
+        for (; this._port <= 65535; this._port++) {
+            try {
+                await this.resolveWithAvailablePort(this._port);
+                return;
+            }
+            catch (e) {
+                // try again
             }
-            this._port++;
         }
+        throw new Error('No available ports');
     }
     /**
      * Gets next available port
      */
     async getNextAvailablePort(startPort = -1) {
-        let receivedStartPort = startPort > 0;
-        if (!receivedStartPort) {
-            startPort = this._currentPort;
-        }
-        while (true) {
-            while (this._reservedPorts.indexOf(startPort) > -1) {
-                startPort++;
-                if (!receivedStartPort) {
-                    this._currentPort = startPort;
-                }
-            }
-            const nextPort = startPort++;
-            if (!receivedStartPort) {
-                this._currentPort = startPort;
+        for (let nextPort = startPort > 0 ? startPort : this._currentPort; nextPort <= 65535; nextPort++) {
+            if (this._reservedPorts.indexOf(nextPort) > -1) {
+                continue;
             }
-            const isUsed = await this._checkIfPortIsUsed(nextPort);
-            if (!isUsed) {
+            try {
+                // Try both IPv4 and IPv6 addresses
+                await this.resolveWithAvailablePort(nextPort);
+                await this.resolveWithAvailablePort(nextPort, '0.0.0.0');
+                // Save the state if we're looking for a system port for the cluster itself
+                if (startPort <= 0) {
+                    this._currentPort = nextPort;
+                }
                 return nextPort;
             }
+            catch (e) {
+                // try again  }
+            }
         }
+        throw new Error('No available ports');
     }
-    _checkIfPortIsUsed(port, host = this._host) {
+    async resolveWithAvailablePort(port, host = this._host) {
         return new Promise((resolve, reject) => {
-            const server = net.createServer();
-            server.once('error', function (err) {
-                if (err.code === 'EADDRINUSE') {
-                    server.close();
-                    resolve(true);
-                    return;
-                }
-                server.close();
-                reject(err);
-            });
-            server.once('listening', function () {
-                server.close();
-                resolve(false);
+            const server = net_1.default.createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({ port, host }, (...args) => {
+                server.close(() => {
+                    resolve(port);
+                });
             });
-            server.listen(port, host);
         });
     }
     /**

package/dist/esm/src/storm/UIServer.d.ts

@@ -1,13 +1,5 @@
-/// <reference types="node" />
-import { Server } from 'http';
 import { StormEventPage } from './events';
-declare module 'express-serve-static-core' {
-    interface Application {
-        listen(port: number, callback?: (err?: Error) => void): Server;
-    }
-}
 export declare class UIServer {
-    private readonly express;
     private readonly systemId;
     private port;
     private server;

package/dist/esm/src/storm/UIServer.js

@@ -11,34 +11,31 @@ exports.UIServer = void 0;
 const express_1 = __importDefault(require("express"));
 const page_utils_1 = require("./page-utils");
 const clusterService_1 = require("../clusterService");
+const http_1 = require("http");
 class UIServer {
-    express;
     systemId;
     port = 50000;
     server;
     constructor(systemId) {
         this.systemId = systemId;
-        this.express = (0, express_1.default)();
     }
     async start() {
-        this.port = await clusterService_1.clusterService.getNextAvailablePort(this.port);
-        this.express.get('/_reset', (req, res) => {
+        const app = (0, express_1.default)();
+        app.get('/_reset', (req, res) => {
             res.send(`
                 <script>
                     window.localStorage.clear();
                     window.sessionStorage.clear();
                 </script>`);
         });
-        this.express.all('/*', (req, res) => {
+        app.all('/*', (req, res) => {
             (0, page_utils_1.readPageFromDisk)(this.systemId, req.params[0], req.method, res);
         });
+        this.port = await clusterService_1.clusterService.getNextAvailablePort(this.port);
         return new Promise((resolve, reject) => {
-            this.server = this.express.listen(this.port, (err) => {
-                if (err) {
-                    console.error('Failed to start UI server', err);
-                    reject(err);
-                    return;
-                }
+            this.server = (0, http_1.createServer)(app);
+            this.server.on('error', reject);
+            this.server.listen(this.port, () => {
                 console.log(`UI Server started on port ${this.port}`);
                 resolve();
             });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.64.0",
+    "version": "0.64.2",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/clusterService.ts

@@ -5,7 +5,7 @@
 
 import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
 
-const net = require('net');
+import net from 'net';
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
 const DEFAULT_HOST = '127.0.0.1';
@@ -44,64 +44,53 @@ class ClusterService {
     }
 
     async _findClusterServicePort() {
-        while (true) {
-            const isUsed = await this._checkIfPortIsUsed(this._port);
-            if (!isUsed) {
-                break;
+        for (; this._port <= 65535; this._port++) {
+            try {
+                await this.resolveWithAvailablePort(this._port);
+                return;
+            } catch (e) {
+                // try again
             }
-
-            this._port++;
         }
+        throw new Error('No available ports');
     }
 
     /**
      * Gets next available port
      */
     public async getNextAvailablePort(startPort: number = -1) {
-        let receivedStartPort = startPort > 0;
-        if (!receivedStartPort) {
-            startPort = this._currentPort;
-        }
-        while (true) {
-            while (this._reservedPorts.indexOf(startPort) > -1) {
-                startPort++;
-                if (!receivedStartPort) {
-                    this._currentPort = startPort;
-                }
+        for (let nextPort = startPort > 0 ? startPort : this._currentPort; nextPort <= 65535; nextPort++) {
+            if (this._reservedPorts.indexOf(nextPort) > -1) {
+                continue;
             }
 
-            const nextPort = startPort++;
-            if (!receivedStartPort) {
-                this._currentPort = startPort;
-            }
-            const isUsed = await this._checkIfPortIsUsed(nextPort);
-            if (!isUsed) {
+            try {
+                // Try both IPv4 and IPv6 addresses
+                await this.resolveWithAvailablePort(nextPort);
+                await this.resolveWithAvailablePort(nextPort, '0.0.0.0');
+                // Save the state if we're looking for a system port for the cluster itself
+                if (startPort <= 0) {
+                    this._currentPort = nextPort;
+                }
                 return nextPort;
+            } catch (e) {
+                // try again  }
             }
         }
+        throw new Error('No available ports');
     }
 
-    _checkIfPortIsUsed(port: number, host: string = this._host) {
+    private async resolveWithAvailablePort(port: number, host: string = this._host) {
         return new Promise((resolve, reject) => {
             const server = net.createServer();
+            server.unref();
+            server.on('error', reject);
 
-            server.once('error', function (err: any) {
-                if (err.code === 'EADDRINUSE') {
-                    server.close();
-                    resolve(true);
-                    return;
-                }
-
-                server.close();
-                reject(err);
+            server.listen({ port, host }, (...args) => {
+                server.close(() => {
+                    resolve(port);
+                });
             });
-
-            server.once('listening', function () {
-                server.close();
-                resolve(false);
-            });
-
-            server.listen(port, host);
         });
     }
 

package/src/storm/UIServer.ts

@@ -5,20 +5,10 @@
 import express, { Express, Request, Response } from 'express';
 import { readPageFromDisk } from './page-utils';
 import { clusterService } from '../clusterService';
-import { Server } from 'http';
+import { createServer, Server } from 'http';
 import { StormEventPage } from './events';
 
-declare module 'express-serve-static-core' {
-    interface Application {
-        // Adds error callback support
-        // From the docs:
-        // All the forms of Node’s http.Server.listen() method are in fact actually supported.
-        listen(port: number, callback?: (err?: Error) => void): Server;
-    }
-}
-
 export class UIServer {
-    private readonly express: Express;
     private readonly systemId: string;
 
     private port: number = 50000;
@@ -26,13 +16,11 @@ export class UIServer {
 
     constructor(systemId: string) {
         this.systemId = systemId;
-        this.express = express();
     }
 
     public async start() {
-        this.port = await clusterService.getNextAvailablePort(this.port);
-
-        this.express.get('/_reset', (req: Request, res: Response) => {
+        const app = express();
+        app.get('/_reset', (req: Request, res: Response) => {
             res.send(
                 `
                 <script>
@@ -42,17 +30,16 @@ export class UIServer {
             );
         });
 
-        this.express.all('/*', (req: Request, res: Response) => {
+        app.all('/*', (req: Request, res: Response) => {
             readPageFromDisk(this.systemId, req.params[0], req.method, res);
         });
 
+        this.port = await clusterService.getNextAvailablePort(this.port);
         return new Promise<void>((resolve, reject) => {
-            this.server = this.express.listen(this.port, (err) => {
-                if (err) {
-                    console.error('Failed to start UI server', err);
-                    reject(err);
-                    return;
-                }
+            this.server = createServer(app);
+            this.server.on('error', reject);
+
+            this.server.listen(this.port, () => {
                 console.log(`UI Server started on port ${this.port}`);
                 resolve();
             });

package/src/storm/routes.ts

@@ -440,7 +440,7 @@ router.post('/ui/edit', async (req: KapetaBodyRequest, res: Response) => {
 
         sendDone(res);
     } catch (err: any) {
-        sendError(err, res);
+        sendError(err as Error, res);
         if (!res.closed) {
             res.end();
         }