velocious 1.0.107 → 1.0.109

package/dist/src/http-server/client/request-parser.js

@@ -0,0 +1,98 @@
+// @ts-check
+import { digg } from "diggerize";
+import { EventEmitter } from "events";
+import { incorporate } from "incorporator";
+import ParamsToObject from "./params-to-object.js";
+import RequestBuffer from "./request-buffer/index.js";
+export default class VelociousHttpServerClientRequestParser {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        this.configuration = configuration;
+        this.data = [];
+        this.events = new EventEmitter();
+        this.params = {};
+        this.requestBuffer = new RequestBuffer({ configuration });
+        this.requestBuffer.events.on("completed", this.requestDone);
+        this.requestBuffer.events.on("form-data-part", this.onFormDataPart);
+        this.requestBuffer.events.on("request-done", this.requestDone);
+    }
+    destroy() {
+        this.requestBuffer.events.off("completed", this.requestDone);
+        this.requestBuffer.events.off("form-data-part", this.onFormDataPart);
+        this.requestBuffer.events.off("request-done", this.requestDone);
+        this.requestBuffer.destroy();
+    }
+    /**
+     * @param {import("./request-buffer/form-data-part.js").default} formDataPart
+     * @returns {void}
+     */
+    onFormDataPart = (formDataPart) => {
+        /** @type {Record<string, string>} */
+        const unorderedParams = {};
+        unorderedParams[formDataPart.getName()] = formDataPart.getValue();
+        const paramsToObject = new ParamsToObject(unorderedParams);
+        const newParams = paramsToObject.toObject();
+        incorporate(this.params, newParams);
+    };
+    /**
+     * @param {Buffer} data
+     */
+    feed = (data) => this.requestBuffer.feed(data);
+    /**
+     * @param {string} name
+     */
+    getHeader(name) { return this.requestBuffer.getHeader(name)?.value; }
+    getHeaders() { return this.requestBuffer.getHeadersHash(); }
+    /**
+     * @returns {string}
+     */
+    getHttpMethod() { return digg(this, "requestBuffer", "httpMethod"); }
+    /**
+     * @returns {string}
+     */
+    getHttpVersion() { return digg(this, "requestBuffer", "httpVersion"); }
+    _getHostMatch() {
+        const rawHost = this.requestBuffer.getHeader("origin")?.value;
+        if (!rawHost)
+            return null;
+        const match = rawHost.match(/^(.+):\/\/(.+)(|:(\d+))/);
+        if (!match)
+            throw new Error(`Couldn't match host: ${rawHost}`);
+        return {
+            protocol: match[1],
+            host: match[2],
+            port: match[4]
+        };
+    }
+    getHost() {
+        const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":");
+        if (rawHostSplit && rawHostSplit[0])
+            return rawHostSplit[0];
+    }
+    getPath() { return digg(this, "requestBuffer", "path"); }
+    getPort() {
+        const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":");
+        const httpMethod = this.getHttpMethod();
+        if (rawHostSplit && rawHostSplit[1]) {
+            return parseInt(rawHostSplit[1]);
+        }
+        else if (httpMethod == "http") {
+            return 80;
+        }
+        else if (httpMethod == "https") {
+            return 443;
+        }
+    }
+    getProtocol() { return this._getHostMatch()?.protocol; }
+    getRequestBuffer() { return this.requestBuffer; }
+    requestDone = () => {
+        incorporate(this.params, this.requestBuffer.params);
+        this.state = "done";
+        this.events.emit("done");
+    };
+}

package/dist/src/http-server/client/request-runner.d.ts

@@ -0,0 +1,24 @@
+export default class VelociousHttpServerClientRequestRunner {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {import("./request.js").default} args.request
+     */
+    constructor({ configuration, request }: {
+        configuration: import("../../configuration.js").default;
+        request: import("./request.js").default;
+    });
+    events: EventEmitter<[never]>;
+    logger: Logger;
+    configuration: import("../../configuration.js").default;
+    request: import("./request.js").default;
+    response: Response;
+    state: string;
+    getRequest(): import("./request.js").default;
+    getState(): string;
+    run(): Promise<void>;
+}
+import EventEmitter from "events";
+import { Logger } from "../../logger.js";
+import Response from "./response.js";
+//# sourceMappingURL=request-runner.d.ts.map

package/dist/src/http-server/client/request-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-runner.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/request-runner.js"],"names":[],"mappings":"AASA;IAGE;;;;OAIG;IACH,wCAHG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QACH,OAAO,EAA5C,OAAO,cAAc,EAAE,OAAO;KACxC,EAUA;IAhBD,8BAA2B;IAWzB,eAA8B;IAC9B,wDAAkC;IAClC,wCAAsB;IACtB,mBAA6C;IAC7C,cAAsB;IAGxB,6CAAoC;IACpC,mBAAgC;IAEhC,qBAmCC;CACF;yBA/DwB,QAAQ;uBACZ,iBAAiB;qBACjB,eAAe"}

package/dist/src/http-server/client/request-runner.js

@@ -0,0 +1,58 @@
+// @ts-check
+import BacktraceCleaner from "../../utils/backtrace-cleaner.js";
+import ensureError from "../../utils/ensure-error.js";
+import EventEmitter from "events";
+import { Logger } from "../../logger.js";
+import Response from "./response.js";
+import RoutesResolver from "../../routes/resolver.js";
+export default class VelociousHttpServerClientRequestRunner {
+    events = new EventEmitter();
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {import("./request.js").default} args.request
+     */
+    constructor({ configuration, request }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        if (!request)
+            throw new Error("No request given");
+        this.logger = new Logger(this);
+        this.configuration = configuration;
+        this.request = request;
+        this.response = new Response({ configuration });
+        this.state = "running";
+    }
+    getRequest() { return this.request; }
+    getState() { return this.state; }
+    async run() {
+        const { configuration, request, response } = this;
+        if (!request)
+            throw new Error("No request?");
+        try {
+            // Before we checked if the sec-fetch-mode was "cors", but it seems the sec-fetch-mode isn't always present
+            await this.logger.debug(() => ["Run CORS", { httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode") }]);
+            const cors = configuration.getCors();
+            if (cors) {
+                await cors({ request, response });
+            }
+            if (request.httpMethod() == "OPTIONS" && request.header("sec-fetch-mode") == "cors") {
+                response.setStatus(200);
+                response.setBody("");
+            }
+            else {
+                await this.logger.debug("Run request");
+                const routesResolver = new RoutesResolver({ configuration, request, response });
+                await routesResolver.resolve();
+            }
+        }
+        catch (e) {
+            const error = ensureError(e);
+            await this.logger.error(() => [`Error while running request: ${BacktraceCleaner.getCleanedStack(error)}`]);
+            response.setStatus(500);
+            response.setErrorBody(error);
+        }
+        this.state = "done";
+        this.events.emit("done", this);
+    }
+}

package/dist/src/http-server/client/request.d.ts

@@ -0,0 +1,39 @@
+export default class VelociousHttpServerClientRequest {
+    /**
+     * @param {object} args
+     * @param {import("./index.js").default} args.client
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ client, configuration, ...restArgs }: {
+        client: import("./index.js").default;
+        configuration: import("../../configuration.js").default;
+    });
+    client: import("./index.js").default;
+    configuration: import("../../configuration.js").default;
+    requestParser: RequestParser;
+    baseURL(): string;
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    feed(data: Buffer): void;
+    /**
+     * @param {string} headerName
+     * @returns {string | null}
+     */
+    header(headerName: string): string | null;
+    headers(): Record<string, string>;
+    httpMethod(): string;
+    httpVersion(): string;
+    host(): string;
+    hostWithPort(): string;
+    origin(): string;
+    path(): any;
+    params(): any;
+    port(): number;
+    protocol(): string;
+    getRequestBuffer(): import("./request-buffer/index.js").default;
+    getRequestParser(): RequestParser;
+}
+import RequestParser from "./request-parser.js";
+//# sourceMappingURL=request.d.ts.map

package/dist/src/http-server/client/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/request.js"],"names":[],"mappings":"AAMA;IACE;;;;OAIG;IACH,oDAHG;QAA2C,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;QACmB,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAOA;IAHC,qCAAoB;IACpB,wDAAkC;IAClC,6BAAuD;IAGzD,kBAAkE;IAElE;;;OAGG;IACH,WAHW,MAAM,GACJ,IAAI,CAEkC;IAEnD;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAG,IAAI,CAE6D;IACvF,kCAA6D;IAC7D,qBAA0D;IAC1D,sBAA4D;IAC5D,eAA8C;IAE9C,uBAcC;IAED,iBAAyC;IACzC,YAA8C;IAC9C,cAAyD;IACzD,eAA8C;IAC9C,mBAAsD;IAEtD,gEAAwE;IACxE,kCAAgD;CACjD;0BA3DyB,qBAAqB"}

package/dist/src/http-server/client/request.js

@@ -0,0 +1,54 @@
+// @ts-check
+import { digg } from "diggerize";
+import RequestParser from "./request-parser.js";
+import restArgsError from "../../utils/rest-args-error.js";
+export default class VelociousHttpServerClientRequest {
+    /**
+     * @param {object} args
+     * @param {import("./index.js").default} args.client
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ client, configuration, ...restArgs }) {
+        restArgsError(restArgs);
+        this.client = client;
+        this.configuration = configuration;
+        this.requestParser = new RequestParser({ configuration });
+    }
+    baseURL() { return `${this.protocol()}://${this.hostWithPort()}`; }
+    /**
+     * @param {Buffer} data
+     * @returns {void}
+     */
+    feed(data) { return this.requestParser.feed(data); }
+    /**
+     * @param {string} headerName
+     * @returns {string | null}
+     */
+    header(headerName) { return this.getRequestBuffer().getHeader(headerName)?.getValue(); }
+    headers() { return this.getRequestBuffer().getHeadersHash(); }
+    httpMethod() { return this.requestParser.getHttpMethod(); }
+    httpVersion() { return this.requestParser.getHttpVersion(); }
+    host() { return this.requestParser.getHost(); }
+    hostWithPort() {
+        const port = this.port();
+        const protocol = this.protocol();
+        let hostWithPort = `${this.host()}`;
+        if (port == 80 && protocol == "http") {
+            // Do nothing
+        }
+        else if (port == 443 && protocol == "https") {
+            // Do nothing
+        }
+        else if (port) {
+            hostWithPort += `:${port}`;
+        }
+        return hostWithPort;
+    }
+    origin() { return this.header("origin"); }
+    path() { return this.requestParser.getPath(); }
+    params() { return digg(this, "requestParser", "params"); }
+    port() { return this.requestParser.getPort(); }
+    protocol() { return this.requestParser.getProtocol(); }
+    getRequestBuffer() { return this.getRequestParser().getRequestBuffer(); }
+    getRequestParser() { return this.requestParser; }
+}

package/dist/src/http-server/client/response.d.ts

@@ -0,0 +1,56 @@
+export default class VelociousHttpServerClientResponse {
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }: {
+        configuration: import("../../configuration.js").default;
+    });
+    /** @type {string | null} */
+    body: string | null;
+    /** @type {Record<string, string[]>} */
+    headers: Record<string, string[]>;
+    configuration: import("../../configuration.js").default;
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @returns {void}
+     */
+    addHeader(key: string, value: string): void;
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @returns {void}
+     */
+    setHeader(key: string, value: string): void;
+    /**
+     * @returns {string | null}
+     */
+    getBody(): string | null;
+    /**
+     * @returns {number}
+     */
+    getStatusCode(): number;
+    /**
+     * @returns {string}
+     */
+    getStatusMessage(): string;
+    /**
+     * @param {string} value
+     * @returns {void}
+     */
+    setBody(value: string): void;
+    /**
+     * @param {Error} error
+     * @returns {void}
+     */
+    setErrorBody(error: Error): void;
+    /**
+     * @param {number | string} status
+     * @returns {void}
+     */
+    setStatus(status: number | string): void;
+    statusCode: number;
+    statusMessage: string;
+}
+//# sourceMappingURL=response.d.ts.map

package/dist/src/http-server/client/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../../src/http-server/client/response.js"],"names":[],"mappings":"AAEA;IAOE;;;OAGG;IACH,+BAFG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;KAClD,EAGA;IAZD,4BAA4B;IAC5B,MADW,MAAM,GAAG,IAAI,CACb;IAEX,uCAAuC;IACvC,SADW,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CACvB;IAOV,wDAAkC;IAGpC;;;;OAIG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;OAIG;IACH,eAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAIhB;IAED;;OAEG;IACH,WAFa,MAAM,GAAG,IAAI,CAQzB;IAED;;OAEG;IACH,iBAFa,MAAM,CAIlB;IAED;;OAEG;IACH,oBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,oBAHW,KAAK,GACH,IAAI,CAKhB;IAED;;;OAGG;IACH,kBAHW,MAAM,GAAG,MAAM,GACb,IAAI,CAehB;IAXG,mBAAqB;IACrB,sBAAyB;CAW9B"}

package/dist/src/http-server/client/response.js

@@ -0,0 +1,90 @@
+// @ts-check
+export default class VelociousHttpServerClientResponse {
+    /** @type {string | null} */
+    body = null;
+    /** @type {Record<string, string[]>} */
+    headers = {};
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     */
+    constructor({ configuration }) {
+        this.configuration = configuration;
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @returns {void}
+     */
+    addHeader(key, value) {
+        if (!(key in this.headers)) {
+            this.headers[key] = [];
+        }
+        this.headers[key].push(value);
+    }
+    /**
+     * @param {string} key
+     * @param {string} value
+     * @returns {void}
+     */
+    setHeader(key, value) {
+        this.headers[key] = [value];
+    }
+    /**
+     * @returns {string | null}
+     */
+    getBody() {
+        if (this.body !== undefined) {
+            return this.body;
+        }
+        throw new Error("No body has been set");
+    }
+    /**
+     * @returns {number}
+     */
+    getStatusCode() {
+        return this.statusCode || 200;
+    }
+    /**
+     * @returns {string}
+     */
+    getStatusMessage() {
+        return this.statusMessage || "OK";
+    }
+    /**
+     * @param {string} value
+     * @returns {void}
+     */
+    setBody(value) {
+        this.body = value;
+    }
+    /**
+     * @param {Error} error
+     * @returns {void}
+     */
+    setErrorBody(error) {
+        this.setHeader("Content-Type", "text/plain; charset=UTF-8");
+        this.setBody(`${error.message}\n\n${error.stack}`);
+    }
+    /**
+     * @param {number | string} status
+     * @returns {void}
+     */
+    setStatus(status) {
+        if (status == "success" || status == 200) {
+            this.statusCode = 200;
+            this.statusMessage = "OK";
+        }
+        else if (status == "not-found" || status == 404) {
+            this.statusCode = 404;
+            this.statusMessage = "Not Found";
+        }
+        else if (status == "internal-server-error" || status == 500) {
+            this.statusCode = 500;
+            this.statusMessage = "Internal server error";
+        }
+        else {
+            throw new Error(`Unhandled status: ${status}`);
+        }
+    }
+}

package/dist/src/http-server/index.d.ts

@@ -0,0 +1,58 @@
+export default class VelociousHttpServer {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     * @param {number} [args.maxWorkers]
+     */
+    constructor({ configuration, host, maxWorkers, port }: {
+        configuration: import("../configuration.js").default;
+        host?: string;
+        port?: number;
+        maxWorkers?: number;
+    });
+    clientCount: number;
+    /** @type {Record<string, ServerClient>}  */
+    clients: Record<string, ServerClient>;
+    events: EventEmitter<[never]>;
+    workerCount: number;
+    /** @type {WorkerHandler[]} */
+    workerHandlers: WorkerHandler[];
+    configuration: import("../configuration.js").default;
+    logger: Logger;
+    host: string;
+    port: number;
+    maxWorkers: number;
+    /**
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    netServer: Net.Server;
+    _netServerListen(): Promise<any>;
+    _ensureAtLeastOneWorker(): Promise<void>;
+    /**
+     * @returns {boolean}
+     */
+    isActive(): boolean;
+    stopClients(): Promise<void>;
+    stopServer(): Promise<any>;
+    stop(): Promise<void>;
+    onClose: () => void;
+    /**
+     * @param {import("net").Socket} socket
+     */
+    onConnection: (socket: import("net").Socket) => void;
+    /**
+     * @param {ServerClient} client
+     */
+    onClientClose: (client: ServerClient) => void;
+    spawnWorker(): Promise<void>;
+    workerHandlerToUse(): WorkerHandler;
+}
+import ServerClient from "./server-client.js";
+import EventEmitter from "events";
+import WorkerHandler from "./worker-handler/index.js";
+import { Logger } from "../logger.js";
+import Net from "net";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/http-server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http-server/index.js"],"names":[],"mappings":"AASA;IAYE;;;;;;OAMG;IACH,uDALG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,IAAI,GAAlB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,UAAU,GAAxB,MAAM;KAAmB,EAQnC;IAxBD,oBAAe;IAEf,4CAA4C;IAC5C,SADW,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAC3B;IAEZ,8BAA2B;IAC3B,oBAAe;IAEf,8BAA8B;IAC9B,gBADW,aAAa,EAAE,CACP;IAUjB,qDAAkC;IAClC,eAA8B;IAC9B,aAA6B;IAC7B,aAAwB;IACxB,mBAAkC;IAGpC;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAJC,sBAAiC;IAMnC,iCAaC;IAED,yCAIC;IAED;;OAEG;IACH,YAFa,OAAO,CAQnB;IAED,6BAUC;IAED,2BAYC;IAED,sBAGC;IAED,oBAEC;IAED;;OAEG;IACH,eAAgB,QAFL,OAAO,KAAK,EAAE,MAEH,UAkBrB;IAED;;OAEG;IACH,gBAAiB,QAFN,YAEY,UAWtB;IAED,6BAYC;IAED,oCAWC;CACF;yBA7KwB,oBAAoB;yBAHpB,QAAQ;0BAIP,2BAA2B;uBAHhC,cAAc;gBACnB,KAAK"}

package/dist/src/http-server/index.js

@@ -0,0 +1,147 @@
+// @ts-check
+import { digg } from "diggerize";
+import EventEmitter from "events";
+import { Logger } from "../logger.js";
+import Net from "net";
+import ServerClient from "./server-client.js";
+import WorkerHandler from "./worker-handler/index.js";
+export default class VelociousHttpServer {
+    clientCount = 0;
+    /** @type {Record<string, ServerClient>}  */
+    clients = {};
+    events = new EventEmitter();
+    workerCount = 0;
+    /** @type {WorkerHandler[]} */
+    workerHandlers = [];
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     * @param {number} [args.maxWorkers]
+     */
+    constructor({ configuration, host, maxWorkers, port }) {
+        this.configuration = configuration;
+        this.logger = new Logger(this);
+        this.host = host || "0.0.0.0";
+        this.port = port || 3006;
+        this.maxWorkers = maxWorkers || 16;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async start() {
+        await this._ensureAtLeastOneWorker();
+        this.netServer = new Net.Server();
+        this.netServer.on("close", this.onClose);
+        this.netServer.on("connection", this.onConnection);
+        await this._netServerListen();
+    }
+    _netServerListen() {
+        return new Promise((resolve, reject) => {
+            if (!this.netServer)
+                throw new Error("No netServer");
+            try {
+                this.netServer.listen(this.port, this.host, () => {
+                    this.logger.debug(`Velocious listening on ${this.host}:${this.port}`);
+                    resolve(null);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async _ensureAtLeastOneWorker() {
+        if (this.workerHandlers.length == 0) {
+            await this.spawnWorker();
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    isActive() {
+        if (this.netServer) {
+            return this.netServer.listening;
+        }
+        return false;
+    }
+    async stopClients() {
+        const promises = [];
+        for (const clientCount in this.clients) {
+            const client = this.clients[clientCount];
+            promises.push(client.end());
+        }
+        await Promise.all(promises);
+    }
+    stopServer() {
+        return new Promise((resolve, reject) => {
+            if (!this.netServer)
+                throw new Error("No netServer to stop");
+            this.netServer.close((error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    async stop() {
+        await this.stopClients();
+        await this.stopServer();
+    }
+    onClose = () => {
+        this.events.emit("close");
+    };
+    /**
+     * @param {import("net").Socket} socket
+     */
+    onConnection = (socket) => {
+        const clientCount = this.clientCount;
+        this.logger.debug(`New client ${clientCount}`);
+        this.clientCount++;
+        const workerHandler = this.workerHandlerToUse();
+        const client = new ServerClient({
+            clientCount,
+            configuration: this.configuration,
+            socket
+        });
+        client.events.on("close", this.onClientClose);
+        this.logger.debug(`Gave client ${clientCount} to worker ${workerHandler.workerCount}`);
+        workerHandler.addSocketConnection(client);
+        this.clients[clientCount] = client;
+    };
+    /**
+     * @param {ServerClient} client
+     */
+    onClientClose = (client) => {
+        const clientCount = digg(client, "clientCount");
+        const oldClientsLength = Object.keys(this.clients).length;
+        delete this.clients[clientCount];
+        const newClientsLength = Object.keys(this.clients).length;
+        if (newClientsLength != (oldClientsLength - 1)) {
+            console.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`);
+        }
+    };
+    async spawnWorker() {
+        const workerCount = this.workerCount;
+        this.workerCount++;
+        const workerHandler = new WorkerHandler({
+            configuration: this.configuration,
+            workerCount
+        });
+        await workerHandler.start();
+        this.workerHandlers.push(workerHandler);
+    }
+    workerHandlerToUse() {
+        this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`);
+        const randomWorkerNumber = Math.floor(Math.random() * this.workerHandlers.length);
+        const workerHandler = this.workerHandlers[randomWorkerNumber];
+        if (!workerHandler) {
+            throw new Error(`No workerHandler by that number: ${randomWorkerNumber}`);
+        }
+        return workerHandler;
+    }
+}