Port manager

constants/ports.ts

@@ -0,0 +1,5 @@
+export const MIN_PORT_NUMBER = 1024;
+export const MAX_PORT_NUMBER = 65535;
+
+// TODO: What's a good port for the port manager?
+export const PORT_MANAGER_SERVER_PORT = 8080;

lang/en.lyaml

@@ -136,6 +136,12 @@ en:
     processFieldsJs:
       converting: 'Converting "{{ src }}" to "{{ dest }}".'
       converted: 'Finished converting "{{ src }}" to "{{ dest }}".'
+    utils:
+      PortManagerServer:
+        started: "PortManagerServer running on port {{ port }}"
+        setPort: "Server with instanceId {{ instanceId }} assigned to port {{ port }}"
+        deletedPort: "Server with instanceId {{ instanceId }} unassigned from port {{ port }}"
+        close: "PortManagerServer shutting down."
   errors:
     hubdb:
       invalidJsonPath: "The HubDB table file must be a '.json' file"
@@ -201,6 +207,12 @@ en:
         configIgnore: "Unable to determine if config file is properly ignored by git."
       notify:
         filePath: "Unable to notify file '{{ filePath }}'"
+      PortManagerServer:
+        portInUse: "Failed to start PortManagerServer. Port {{ port }} is already in use."
+        duplicateInstance: "Failed to start PortManagerServer. An instance of PortManagerServer is already running."
+        404: "Could not find a server with instanceId {{ instanceId }}"
+        409: "Failed to assign port. Server with instanceId {{ instanceId }} is already running on port {{ port }}"
+        400: "Invalid port requested. Port must be between 1024 and 65535."
     config:
       cliConfiguration:
         noConfigLoaded: "No config loaded."

lib/portManager.ts

@@ -0,0 +1,58 @@
+import axios from 'axios';
+
+import PortManagerServer from '../utils/PortManagerServer';
+import { detectPort } from '../utils/detectPort';
+import { PORT_MANAGER_SERVER_PORT } from '../constants/ports';
+import { RequestPortsData } from '../types/PortManager';
+
+const BASE_URL = `http://localhost:${PORT_MANAGER_SERVER_PORT}`;
+
+async function isPortManagerServerRunning(): Promise<boolean> {
+  const port = await detectPort(PORT_MANAGER_SERVER_PORT);
+  return port !== PORT_MANAGER_SERVER_PORT;
+}
+
+export async function startPortManagerServer(): Promise<void> {
+  const isRunning = await isPortManagerServerRunning();
+
+  if (!isRunning) {
+    await PortManagerServer.init();
+  }
+}
+
+export async function stopPortManagerServer(): Promise<void> {
+  const isRunning = await isPortManagerServerRunning();
+
+  if (isRunning) {
+    await axios.post(`${BASE_URL}/close`);
+  }
+}
+
+export async function requestPorts(
+  portData: Array<RequestPortsData>
+): Promise<Array<RequestPortsData>> {
+  const { data } = await axios.post(`${BASE_URL}/servers`, {
+    portData: portData,
+  });
+
+  return data.ports;
+}
+
+export async function deleteServerInstance(
+  serverInstanceId: string
+): Promise<void> {
+  await axios.post(`${BASE_URL}/servers/${serverInstanceId}`);
+}
+
+export async function portManagerHasActiveServers() {
+  const { data } = await axios.get(`${BASE_URL}/servers`);
+  return data.count > 0;
+}
+
+function toId(str: string) {
+  return str.replace(/\s+/g, '-').toLowerCase();
+}
+
+export function getServerInstanceId(serverId: string, resourceId: string) {
+  return `${toId(serverId)}__${toId(resourceId)}`;
+}

package.json

@@ -30,7 +30,9 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "@types/content-disposition": "^0.5.5",
+    "@types/cors": "^2.8.15",
     "@types/debounce": "^1.2.1",
+    "@types/express": "^4.17.18",
     "@types/findup-sync": "^4.0.2",
     "@types/fs-extra": "^11.0.1",
     "@types/jest": "^29.5.0",
@@ -56,9 +58,12 @@
     "./logger": "./lib/logging/logger.js"
   },
   "dependencies": {
+    "address": "^2.0.1",
     "axios": "^1.3.5",
     "chokidar": "^3.5.3",
     "content-disposition": "^0.5.4",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
     "extract-zip": "^2.0.1",
     "findup-sync": "^5.0.0",
     "fs-extra": "^11.1.0",

types/PortManager.ts

@@ -0,0 +1,4 @@
+export type RequestPortsData = {
+  instanceId: string;
+  port?: number;
+};

utils/PortManagerServer.ts

@@ -0,0 +1,184 @@
+import express, { Express, Request, Response } from 'express';
+import { Server } from 'http';
+import cors from 'cors';
+
+import { detectPort } from './detectPort';
+import {
+  MIN_PORT_NUMBER,
+  MAX_PORT_NUMBER,
+  PORT_MANAGER_SERVER_PORT,
+} from '../constants/ports';
+import { throwErrorWithMessage } from '../errors/standardErrors';
+import { debug } from './logger';
+import { i18n } from './lang';
+import { BaseError } from '../types/Error';
+import { RequestPortsData } from '../types/PortManager';
+
+type ServerPortMap = {
+  [instanceId: string]: number;
+};
+
+const i18nKey = 'utils.PortManagerServer';
+
+class PortManagerServer {
+  app?: Express;
+  server?: Server;
+  serverPortMap: ServerPortMap;
+
+  constructor() {
+    this.serverPortMap = {};
+  }
+
+  async init(): Promise<void> {
+    if (this.app) {
+      throwErrorWithMessage(`${i18nKey}.duplicateInstance`);
+    }
+    this.app = express();
+    this.app.use(express.json());
+    this.app.use(cors());
+    this.setupRoutes();
+
+    try {
+      this.server = await this.listen();
+    } catch (e) {
+      const error = e as BaseError;
+      if (error.code === 'EADDRINUSE') {
+        throwErrorWithMessage(
+          `${i18n}.portInUse`,
+          {
+            port: PORT_MANAGER_SERVER_PORT,
+          },
+          error
+        );
+      }
+      throw error;
+    }
+  }
+
+  listen(): Promise<Server> {
+    return new Promise<Server>((resolve, reject) => {
+      const server = this.app!.listen(PORT_MANAGER_SERVER_PORT, () => {
+        debug(`${i18nKey}.started`, {
+          port: PORT_MANAGER_SERVER_PORT,
+        });
+        resolve(server);
+      }).on('error', err => {
+        reject(err);
+      });
+    });
+  }
+
+  setupRoutes(): void {
+    if (!this.app) {
+      return;
+    }
+
+    this.app.get('/servers', this.getServers);
+    this.app.get('/servers/:instanceId', this.getServerPortByInstanceId);
+    this.app.post('/servers', this.assignPortsToServers);
+    this.app.delete('/servers/:instanceId', this.deleteServerInstance);
+    this.app.post('/close', this.closeServer);
+  }
+
+  setPort(instanceId: string, port: number) {
+    debug(`${i18nKey}.setPort`, { instanceId, port });
+    this.serverPortMap[instanceId] = port;
+  }
+
+  deletePort(instanceId: string) {
+    debug(`${i18nKey}.deletePort`, {
+      instanceId,
+      port: this.serverPortMap[instanceId],
+    });
+    delete this.serverPortMap[instanceId];
+  }
+
+  send404(res: Response, instanceId: string) {
+    res
+      .status(404)
+      .send(i18n(`errors.${i18nKey}.404`, { instanceId: instanceId }));
+  }
+
+  getServers = async (req: Request, res: Response): Promise<void> => {
+    res.send({
+      servers: this.serverPortMap,
+      count: Object.keys(this.serverPortMap).length,
+    });
+  };
+
+  getServerPortByInstanceId = (req: Request, res: Response): void => {
+    const { instanceId } = req.params;
+    const port = this.serverPortMap[instanceId];
+
+    if (port) {
+      res.send({ port });
+    } else {
+      this.send404(res, instanceId);
+    }
+  };
+
+  assignPortsToServers = async (
+    req: Request<never, never, { portData: Array<RequestPortsData> }>,
+    res: Response
+  ): Promise<void> => {
+    const { portData } = req.body;
+
+    const portPromises: Array<Promise<Required<RequestPortsData>>> = [];
+
+    portData.forEach(data => {
+      const { port, instanceId } = data;
+      if (this.serverPortMap[instanceId]) {
+        res.status(409).send(
+          i18n(`errors.${i18nKey}.409`, {
+            instanceId,
+            port: this.serverPortMap[instanceId],
+          })
+        );
+        return;
+      } else if (port && (port < MIN_PORT_NUMBER || port > MAX_PORT_NUMBER)) {
+        res.status(400).send(i18n(`errors.${i18nKey}.400`));
+        return;
+      } else {
+        const promise = new Promise<Required<RequestPortsData>>(resolve => {
+          detectPort(port).then(resolvedPort => {
+            resolve({
+              instanceId,
+              port: resolvedPort,
+            });
+          });
+        });
+        portPromises.push(promise);
+      }
+    });
+
+    const ports = await Promise.all(portPromises);
+
+    ports.forEach(({ port, instanceId }) => {
+      this.setPort(instanceId, port);
+    });
+
+    res.send({ ports });
+  };
+
+  deleteServerInstance = (req: Request, res: Response): void => {
+    const { instanceId } = req.params;
+    const port = this.serverPortMap[instanceId];
+
+    if (port) {
+      this.deletePort(instanceId);
+      res.send(200);
+    } else {
+      this.send404(res, instanceId);
+    }
+  };
+
+  closeServer = (req: Request, res: Response): void => {
+    if (this.server) {
+      debug(`${i18nKey}.close`);
+      res.send(200);
+      this.server.close();
+    }
+  };
+}
+
+export default new PortManagerServer();

utils/detectPort.ts

@@ -0,0 +1,87 @@
+import net, { AddressInfo } from 'net';
+import { ip } from 'address';
+
+import { MIN_PORT_NUMBER, MAX_PORT_NUMBER } from '../constants/ports';
+
+type NetError = Error & {
+  code: string;
+};
+
+type ListenCallback = (error: NetError | null, port: number) => void;
+
+export function detectPort(port?: number | null): Promise<number> {
+  if (port && (port < MIN_PORT_NUMBER || port > MAX_PORT_NUMBER)) {
+    throw new Error('Port must be between 1024 and 65535');
+  }
+
+  const portToUse = port || 0;
+  const maxPort = Math.min(portToUse + 10, MAX_PORT_NUMBER);
+
+  return new Promise(resolve => {
+    tryListen(portToUse, maxPort, (_, resolvedPort) => {
+      resolve(resolvedPort);
+    });
+  });
+}
+
+function tryListen(port: number, maxPort: number, callback: ListenCallback) {
+  const shouldGiveUp = port >= maxPort;
+  const nextPort = shouldGiveUp ? 0 : port + 1;
+  const nextMaxPort = shouldGiveUp ? 0 : maxPort;
+
+  listen(port, undefined, (err, realPort) => {
+    // ignore random listening
+    if (port === 0) {
+      return callback(err, realPort);
+    }
+
+    if (err) {
+      return tryListen(nextPort, nextMaxPort, callback);
+    }
+
+    // 2. check 0.0.0.0
+    listen(port, '0.0.0.0', err => {
+      if (err) {
+        return tryListen(nextPort, nextMaxPort, callback);
+      }
+
+      // 3. check localhost
+      listen(port, 'localhost', err => {
+        if (err && err.code !== 'EADDRNOTAVAIL') {
+          return tryListen(nextPort, nextMaxPort, callback);
+        }
+
+        // 4. check current ip
+        listen(port, ip(), (err, realPort) => {
+          if (err) {
+            return tryListen(nextPort, nextMaxPort, callback);
+          }
+
+          callback(null, realPort);
+        });
+      });
+    });
+  });
+}
+
+function listen(
+  port: number,
+  hostname: string | undefined,
+  callback: ListenCallback
+): void {
+  const server = new net.Server();
+
+  server.on('error', (err: NetError) => {
+    server.close();
+    if (err.code === 'ENOTFOUND') {
+      return callback(null, port);
+    }
+    return callback(err, 0);
+  });
+
+  server.listen(port, hostname, () => {
+    const addressInfo = server.address() as AddressInfo;
+    server.close();
+    return callback(null, addressInfo.port);
+  });
+}