Port manager

constants/ports.ts

@@ -0,0 +1,4 @@
+export const MIN_PORT_NUMBER = 1024;
+export const MAX_PORT_NUMBER = 65535;
+
+export const PORT_MANAGER_SERVER_PORT = 8080;

lang/en.json

@@ -321,6 +321,24 @@
       "modules": {
         "throwInvalidPathInput": "Expected Path Input"
       }
+    },
+    "detectPort": {
+      "errors": {
+        "invalidPort": "Port must be between {{ minPort }} and {{ maxPort }}"
+      }
+    },
+    "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": {
+        "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 {{ minPort }} and {{ maxPort }}."
+      }
     }
   },
   "http": {

lib/portManager.ts

@@ -0,0 +1,62 @@
+import axios from 'axios';
+
+import PortManagerServer from '../utils/PortManagerServer';
+import { detectPort } from '../utils/detectPort';
+import { PORT_MANAGER_SERVER_PORT } from '../constants/ports';
+
+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`);
+  }
+}
+
+type RequestPortsData = {
+  instanceId: string;
+  port?: number;
+};
+
+export async function requestPorts(
+  portData: Array<RequestPortsData>
+): Promise<{ [instanceId: string]: number }> {
+  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,191 @@
+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}.errors.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(
+          `${i18nKey}.errors.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: BaseError) => {
+        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}.deletedPort`, {
+      instanceId,
+      port: this.serverPortMap[instanceId],
+    });
+    delete this.serverPortMap[instanceId];
+  }
+
+  send404(res: Response, instanceId: string) {
+    res
+      .status(404)
+      .send(i18n(`${i18nKey}.errors.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<{ [instanceId: string]: number }>> = [];
+
+    portData.forEach(data => {
+      const { port, instanceId } = data;
+      if (this.serverPortMap[instanceId]) {
+        res.status(409).send(
+          i18n(`${i18nKey}.errors.409`, {
+            instanceId,
+            port: this.serverPortMap[instanceId],
+          })
+        );
+        return;
+      } else if (port && (port < MIN_PORT_NUMBER || port > MAX_PORT_NUMBER)) {
+        res.status(400).send(
+          i18n(`${i18nKey}.errors.400`, {
+            minPort: MIN_PORT_NUMBER,
+            maxPort: MAX_PORT_NUMBER,
+          })
+        );
+        return;
+      } else {
+        const promise = new Promise<{ [instanceId: string]: number }>(
+          resolve => {
+            detectPort(port).then(resolvedPort => {
+              resolve({
+                [instanceId]: resolvedPort,
+              });
+            });
+          }
+        );
+        portPromises.push(promise);
+      }
+    });
+
+    const portList = await Promise.all(portPromises);
+    const ports = portList.reduce((a, c) => Object.assign(a, c));
+
+    for (const instanceId in ports) {
+      this.setPort(instanceId, ports[instanceId]);
+    }
+
+    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();