feat: find free port for gui server automatically (#718)

Co-authored-by: shadowusr

Author: annamyamikova

lib/gui/index.ts

@@ -1,9 +1,7 @@
 import type {CommanderStatic} from '@gemini-testing/commander';
-import chalk from 'chalk';
 import opener from 'opener';
 
 import * as server from './server';
-import {logger} from '../common-utils';
 import * as utils from '../server-utils';
 
 import type {ToolAdapter} from '../adapters/tool';
@@ -29,7 +27,6 @@ export interface ServerArgs {
 export default (args: ServerArgs): void => {
     server.start(args)
         .then(({url}: { url: string }) => {
-            logger.log(`GUI is running at ${chalk.cyan(url)}`);
             args.cli.options.open && opener(url);
         })
         .catch((err: any) => { // eslint-disable-line @typescript-eslint/no-explicit-any

lib/gui/listen-with-fallback.ts

@@ -0,0 +1,78 @@
+import type {Server as HttpServer} from 'http';
+import type {Express} from 'express';
+import {HEADERS_TIMEOUT, KEEP_ALIVE_TIMEOUT} from './constants';
+
+interface ListenOptions {
+    server: Express;
+    hostname?: string;
+    requestedPort?: number;
+}
+
+interface ListenResult {
+    actualPort: number;
+    hostnameForUrl: string;
+}
+
+const MAX_PORT_NUMBER = 65_535;
+const DEFAULT_PORT = 3000;
+
+const listenOnPort = (server: Express, portToTry: number, hostname?: string): Promise<void> => {
+    return new Promise((resolve, reject) => {
+        // eslint-disable-next-line prefer-const
+        let httpServer: HttpServer;
+
+        const handleError = (error: NodeJS.ErrnoException): void => {
+            httpServer.removeListener('error', handleError);
+            reject(error);
+        };
+
+        const onListen = (): void => {
+            resolve();
+        };
+
+        httpServer = hostname
+            ? server.listen(portToTry, hostname, onListen)
+            : server.listen(portToTry, onListen);
+        httpServer.keepAliveTimeout = KEEP_ALIVE_TIMEOUT;
+        httpServer.headersTimeout = HEADERS_TIMEOUT;
+
+        httpServer.once('error', handleError);
+    });
+};
+
+export const listenWithFallback = async ({server, hostname, requestedPort}: ListenOptions): Promise<ListenResult> => {
+    const hostnameForUrl = hostname ?? 'localhost';
+    const startPort = requestedPort ?? DEFAULT_PORT;
+
+    let currentPort = startPort;
+    let isSuccess = false;
+
+    while (currentPort <= MAX_PORT_NUMBER) {
+        try {
+            await listenOnPort(server, currentPort, hostname);
+            isSuccess = true;
+            break;
+        } catch (error) {
+            const err = error as NodeJS.ErrnoException;
+
+            if (err.code !== 'EADDRINUSE') {
+                throw err;
+            }
+
+            if (currentPort >= MAX_PORT_NUMBER) {
+                throw new Error(`Unable to find an available port to start GUI server: ${err.message}`);
+            }
+
+            currentPort += 1;
+        }
+    }
+
+    if (!isSuccess) {
+        throw new Error(`Unable to find an available port (tried all variants between ${startPort} and ${MAX_PORT_NUMBER})`);
+    }
+
+    return {
+        actualPort: currentPort,
+        hostnameForUrl
+    };
+};

lib/gui/server.ts

@@ -1,13 +1,13 @@
 import path from 'path';
 import express from 'express';
 import {onExit} from 'signal-exit';
-import BluebirdPromise from 'bluebird';
 import bodyParser from 'body-parser';
 import {INTERNAL_SERVER_ERROR, OK} from 'http-codes';
 import type {Config} from 'testplane';
+import {listenWithFallback} from './listen-with-fallback';
 
 import {App} from './app';
-import {MAX_REQUEST_SIZE, KEEP_ALIVE_TIMEOUT, HEADERS_TIMEOUT} from './constants';
+import {MAX_REQUEST_SIZE} from './constants';
 import {logger} from '../common-utils';
 import {initPluginsRoutes} from './routes/plugins';
 import {BrowserFeature, Feature, ToolName} from '../constants';
@@ -19,6 +19,7 @@ import type {TestplaneToolAdapter} from '../adapters/tool/testplane';
 import type {ToolRunnerTree} from './tool-runner';
 import type {TestplaneConfigAdapter} from '../adapters/config/testplane';
 import type {UpdateTimeTravelSettingsRequest, UpdateTimeTravelSettingsResponse} from '../types';
+import chalk from 'chalk';
 
 interface CustomGuiError {
     response: {
@@ -275,14 +276,23 @@ export const start = async (args: ServerArgs): Promise<ServerReadyData> => {
 
     await app.initialize();
 
-    const {port, hostname} = args.cli.options;
-    await BluebirdPromise.fromCallback((callback) => {
-        const httpServer = server.listen(port, hostname, callback as () => void);
-        httpServer.keepAliveTimeout = KEEP_ALIVE_TIMEOUT;
-        httpServer.headersTimeout = HEADERS_TIMEOUT;
+    const {port: requestedPort, hostname} = args.cli.options;
+
+    const {actualPort, hostnameForUrl} = await listenWithFallback({
+        server,
+        hostname,
+        requestedPort
     });
 
-    const data = {url: `http://${hostname}:${port}`};
+    const listeningMessage = `GUI is running at ${chalk.cyan(`http://${hostnameForUrl}:${actualPort}`)}`;
+
+    if (requestedPort !== undefined && actualPort !== requestedPort) {
+        logger.log(`${listeningMessage}. This port was chosen because ${hostnameForUrl}:${requestedPort} is busy.`);
+    } else {
+        logger.log(listeningMessage);
+    }
+
+    const data = {url: `http://${hostnameForUrl}:${actualPort}`};
 
     await guiApi.serverReady(data);