@sockethub/server 5.0.0-alpha.3 → 5.0.0-alpha.6

package/src/index.ts

@@ -1,28 +1,68 @@
-const Sockethub = require('./sockethub').default;
-const sockethub = new Sockethub();
-
-module.exports = async () => {
-  process.once('uncaughtException', function (err) {
-    console.log('UNCAUGHT EXCEPTION');
-    // eslint-disable-next-line security-node/detect-crlf
-    console.log(err.stack);
-    process.exit(1);
-  });
-
-  process.once('SIGTERM', function () {
-    console.log('Received TERM signal. Exiting.');
-    process.exit(0);
-  });
-
-  process.once('SIGINT', function () {
-    console.log('Received INT signal. Exiting.');
-    process.exit(0);
-  });
-
-  process.once('exit', async function () {
-    console.log('destroying all platform instances');
-    await sockethub.removeAllPlatformInstances();
-  });
-
-  sockethub.boot();
+import debug from "debug";
+import config from "./config";
+import Sockethub from "./sockethub";
+
+let sentry: { readonly reportError: (err: Error) => void } = {
+    reportError: (err: Error) => {},
 };
+
+export async function server() {
+    let sockethub: Sockethub;
+    const log = debug("sockethub:init");
+
+    // conditionally initialize sentry
+    if (config.get("sentry:dsn")) {
+        log("initializing sentry");
+        sentry = await import("./sentry");
+    }
+
+    try {
+        sockethub = new Sockethub();
+    } catch (err) {
+        sentry.reportError(err);
+        console.error(err);
+        process.exit(1);
+    }
+
+    process.once("uncaughtException", (err: Error) => {
+        console.error(
+            `${(new Date()).toUTCString()} UNCAUGHT EXCEPTION\n`,
+            err.stack,
+        );
+        sentry.reportError(err);
+        process.exit(1);
+    });
+
+    process.once("unhandledRejection", (err: Error) => {
+        console.error(
+            `${(new Date()).toUTCString()} UNHANDLED REJECTION\n`,
+            err,
+        );
+        sentry.reportError(err);
+        process.exit(1);
+    });
+
+    process.once("SIGTERM", () => {
+        console.log("Received TERM signal. Exiting.");
+        process.exit(0);
+    });
+
+    process.once("SIGINT", () => {
+        console.log("Received INT signal. Exiting.");
+        process.exit(0);
+    });
+
+    process.once("exit", async () => {
+        console.log("sockethub shutdown...");
+        await sockethub.shutdown();
+        process.exit(0);
+    });
+
+    try {
+        await sockethub.boot();
+    } catch (err) {
+        sentry.reportError(err);
+        console.error(err);
+        process.exit(1);
+    }
+}

package/src/janitor.test.ts

@@ -0,0 +1,211 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
+
+import { Janitor } from "./janitor.js";
+
+const sockets = [
+    { id: "socket foo", emit: () => {} },
+    { id: "socket bar", emit: () => {} },
+];
+
+function getPlatformInstanceFake() {
+    return {
+        flaggedForTermination: false,
+        config: {
+            initialized: false,
+            persist: true,
+            requireCredentials: ["foo", "bar"],
+        },
+        global: false,
+        shutdown: sinon.stub(),
+        process: {
+            removeListener: sinon.stub(),
+        },
+        sessions: new Set(["session foo", "session bar"]),
+        sessionCallbacks: {
+            close: (() =>
+                new Map([
+                    ["session foo", function sessionFooClose() {}],
+                    ["session bar", function sessionBarClose() {}],
+                ]))(),
+            message: (() =>
+                new Map([
+                    ["session foo", function sessionFooMessage() {}],
+                    ["session bar", function sessionBarMessage() {}],
+                ]))(),
+        },
+    };
+}
+
+const cycleInterval = 10;
+
+describe("Janitor", () => {
+    let sandbox, fetchSocketsFake, janitor;
+
+    beforeEach((done) => {
+        sandbox = sinon.createSandbox();
+        fetchSocketsFake = sandbox.stub().returns(sockets);
+
+        janitor = new Janitor();
+        janitor.getSockets = fetchSocketsFake;
+        expect(janitor.cycleInterval).not.toEqual(cycleInterval);
+        janitor.cycleInterval = cycleInterval;
+        expect(janitor.cycleInterval).toEqual(cycleInterval);
+        janitor.start();
+        setTimeout(() => {
+            expect(janitor.cycleCount).toEqual(1);
+            done();
+        }, cycleInterval);
+    });
+
+    afterEach((done) => {
+        sandbox.reset();
+        janitor.stop();
+        setTimeout(() => {
+            done();
+        }, janitor.cycleInterval * 2);
+    });
+
+    it("runs cycle at every cycleInterval", (done) => {
+        const currCycleCount = janitor.cycleCount;
+        expect(currCycleCount).not.toEqual(0);
+        setTimeout(() => {
+            expect(janitor.cycleCount).toEqual(currCycleCount + 1);
+            setTimeout(() => {
+                expect(janitor.cycleCount).toEqual(currCycleCount + 2);
+                done();
+            }, cycleInterval);
+        }, cycleInterval);
+    });
+
+    describe("removeSessionCallbacks", () => {
+        it("removes session listeners and callbacks for a given platform", () => {
+            const pi = getPlatformInstanceFake();
+            const barMessage = pi.sessionCallbacks.message.get("session bar");
+            const barClose = pi.sessionCallbacks.close.get("session bar");
+            pi.flaggedForTermination = true;
+            janitor.removeSessionCallbacks(pi, "session foo");
+            sinon.assert.calledTwice(pi.process.removeListener);
+            expect(
+                pi.sessionCallbacks.message.get("session foo"),
+            ).toBeUndefined();
+            expect(pi.sessionCallbacks.message.get("session bar")).toEqual(
+                barMessage,
+            );
+            expect(
+                pi.sessionCallbacks.close.get("session foo"),
+            ).toBeUndefined();
+            expect(pi.sessionCallbacks.close.get("session bar")).toEqual(
+                barClose,
+            );
+        });
+    });
+
+    describe("removeStaleSocketSessions", () => {
+        it("doesnt do anything if the socket is active and stop is not flagged", async () => {
+            const pi = getPlatformInstanceFake();
+            janitor.removeSessionCallbacks = sinon.stub();
+            janitor.socketExists = sinon.stub().returns(true);
+            expect(janitor.stopTriggered).toBeFalse();
+            await janitor.removeStaleSocketSessions(pi);
+            sinon.assert.notCalled(janitor.removeSessionCallbacks);
+        });
+
+        it("removes session if the socket is active and stop is flagged", async () => {
+            const pi = getPlatformInstanceFake();
+            janitor.removeSessionCallbacks = sinon.stub();
+            janitor.socketExists = sinon.stub().returns(true);
+            janitor.stop();
+            expect(janitor.stopTriggered).toBeTrue();
+            await janitor.removeStaleSocketSessions(pi);
+            sinon.assert.calledTwice(janitor.removeSessionCallbacks);
+            sinon.assert.calledWith(
+                janitor.removeSessionCallbacks,
+                pi,
+                "session foo",
+            );
+            sinon.assert.calledWith(
+                janitor.removeSessionCallbacks,
+                pi,
+                "session bar",
+            );
+        });
+
+        it("removes session if the socket is inactive", async () => {
+            const pi = getPlatformInstanceFake();
+            janitor.removeSessionCallbacks = sinon.stub();
+            janitor.socketExists = sinon
+                .stub()
+                .onFirstCall()
+                .returns(false)
+                .onSecondCall()
+                .returns(true);
+            expect(janitor.stopTriggered).toBeFalse();
+            await janitor.removeStaleSocketSessions(pi);
+            sinon.assert.calledOnce(janitor.removeSessionCallbacks);
+            sinon.assert.calledWith(
+                janitor.removeSessionCallbacks,
+                pi,
+                "session foo",
+            );
+        });
+    });
+
+    describe("performStaleCheck", () => {
+        it("removes flagged and uninitialized platform instances", async () => {
+            const pi = getPlatformInstanceFake();
+            pi.flaggedForTermination = true;
+            pi.config.initialized = false;
+            janitor.removeStaleSocketSessions = sandbox.stub();
+            janitor.removeStalePlatformInstance = sandbox.stub();
+            await janitor.performStaleCheck(pi);
+            sinon.assert.calledOnce(janitor.removeStaleSocketSessions);
+            sinon.assert.calledOnce(janitor.removeStalePlatformInstance);
+            expect(pi.flaggedForTermination).toBeTrue();
+        });
+
+        it("flags for termination when there are not sockets", async () => {
+            const pi = getPlatformInstanceFake();
+            pi.sessions = new Set();
+            pi.flaggedForTermination = false;
+            pi.config.initialized = true;
+            janitor.removeStaleSocketSessions = sandbox.stub();
+            janitor.removeStalePlatformInstance = sandbox.stub();
+            await janitor.performStaleCheck(pi);
+            sinon.assert.calledOnce(janitor.removeStaleSocketSessions);
+            sinon.assert.calledOnce(janitor.removeStalePlatformInstance);
+        });
+    });
+
+    describe("removeStalePlatformInstance", () => {
+        it("flags stale platform", async () => {
+            const pi = getPlatformInstanceFake();
+            expect(pi.flaggedForTermination).toBeFalse();
+            await janitor.removeStalePlatformInstance(pi);
+            sinon.assert.notCalled(pi.shutdown);
+            expect(pi.flaggedForTermination).toBeTrue();
+        });
+
+        it("removes flagged stale platform", async () => {
+            const pi = getPlatformInstanceFake();
+            pi.flaggedForTermination = true;
+            await janitor.removeStalePlatformInstance(pi);
+            sinon.assert.calledOnce(pi.shutdown);
+        });
+    });
+
+    it("closes all connections when stop() is called", (done) => {
+        const prevCycle = janitor.cycleCount;
+        janitor.stop();
+        setTimeout(() => {
+            expect(janitor.cycleCount).toEqual(prevCycle);
+            setTimeout(() => {
+                expect(janitor.cycleCount).toEqual(prevCycle);
+                setTimeout(() => {
+                    expect(janitor.cycleCount).toEqual(prevCycle);
+                    done();
+                }, cycleInterval);
+            }, cycleInterval);
+        }, cycleInterval);
+    });
+});

package/src/janitor.ts

@@ -1,89 +1,157 @@
-import debug from 'debug';
-
-import PlatformInstance, { platformInstances } from './platform-instance';
-import listener, { SocketInstance } from "./listener";
-
-const rmLog = debug('sockethub:server:janitor');
-
-const TICK = 15000;
-let alreadyCalled: boolean = false;
-let cycleCount: number = 0;   // a counter for each setInterval call
-let reportCount: number = 0;  // number of times a report is printed
-
-/**
- * Every TICK the Janitor will compare existing platform instances with socket.ids (aka. sessionId)
- * If all of the sessionIds associated with a platformInstance have no corresponding socket.id
- * (from the http.io socket.io instance), then the platformInstance will first be flagged, if after
- * the next TICK the same state is determined, the platform will be destroyed (this allows for page
- * refreshes not destroying platform instances)
- */
-function janitorCycle() {
-  if (! alreadyCalled) { alreadyCalled = true; }
-  else { return; }
-  rmLog('initializing resource manager');
-  setInterval(async () => {
-    cycleCount++;
-    const sockets: Array<SocketInstance> = await listener.io.fetchSockets();
-
-    if (! (cycleCount % 4)) {
-      reportCount++;
-      rmLog(`socket sessions: ${sockets.length} platform instances: ${platformInstances.size}`);
+import debug from "debug";
+
+import listener, { type SocketInstance } from "./listener.js";
+import type PlatformInstance from "./platform-instance.js";
+import { platformInstances } from "./platform-instance.js";
+
+const rmLog = debug("sockethub:server:janitor");
+
+export class Janitor {
+    cycleInterval = 15000;
+    cycleCount = 0; // a counter for each cycleInterval
+    reportCount = 0; // number of times a report is printed
+    protected stopTriggered = false;
+    protected sockets: Array<SocketInstance>;
+    private cycleRunning = false;
+
+    /**
+     * Every TICK the `Janitor` will compare existing platform instances with `socket.ids`
+     * (aka. `sessionId`). If all the `sessionIds` associated with a `platformInstance` have
+     * no corresponding `socket.id` (from the `http.io` `socket.io` instance), then the
+     * `platformInstance` will first be flagged, if after the next `cycleInterval` the same
+     * state is determined, the platform will be destroyed (this allows for page
+     * refreshes not destroying platform instances)
+     */
+    start(): void {
+        rmLog("initializing");
+        this.clean().then(() => {
+            rmLog("cleaning cycle started");
+        });
     }
 
-    for (let platformInstance of platformInstances.values()) {
-      removeStaleSocketSessions(platformInstance, sockets);
-      // Static platforms are for global use, not tied to a unique to session / eg. credentials)
-      if ((! platformInstance.global) && (platformInstance.sessions.size === 0)) {
-        removeStalePlatformInstance(platformInstance);
-      } else {
-        platformInstance.flaggedForTermination = false;
-      }
+    async stop(): Promise<void> {
+        this.stopTriggered = true;
+        rmLog("stopping, terminating all sessions");
+        for (const platformInstance of platformInstances.values()) {
+            this.removeStaleSocketSessions(platformInstance);
+            await this.removeStalePlatformInstance(platformInstance);
+            await platformInstance.shutdown();
+        }
     }
-  }, TICK);
-}
 
-function socketExists(sessionId: string, sockets: Array<SocketInstance>) {
-  for (let socket of sockets) {
-    if (socket.id === sessionId) {
-      return true;
+    private removeSessionCallbacks(
+        platformInstance: PlatformInstance,
+        sessionId: string,
+    ): void {
+        for (const key in platformInstance.sessionCallbacks) {
+            platformInstance.process.removeListener(
+                key,
+                platformInstance.sessionCallbacks[key].get(sessionId),
+            );
+            platformInstance.sessionCallbacks[key].delete(sessionId);
+        }
     }
-  }
-  return false;
-}
 
-function removeSessionCallbacks(platformInstance: PlatformInstance, sessionId: string) {
-  for (const key in platformInstance.sessionCallbacks) {
-    platformInstance.sessionCallbacks[key].delete(sessionId);
-  }
-}
+    private removeStaleSocketSessions(
+        platformInstance: PlatformInstance,
+    ): void {
+        for (const sessionId of platformInstance.sessions.values()) {
+            if (this.stopTriggered || !this.socketExists(sessionId)) {
+                this.removeStaleSocketSession(platformInstance, sessionId);
+            }
+        }
+    }
 
-function removeStaleSocketSessions(platformInstance: PlatformInstance,
-                                   sockets: Array<SocketInstance>) {
-  for (const sessionId of platformInstance.sessions.values()) {
-    if (! socketExists(sessionId, sockets)) {
-      rmLog('removing stale socket session reference ' + sessionId + ' in platform instance '
-        + platformInstance.id);
-      platformInstance.sessions.delete(sessionId);
-      removeSessionCallbacks(platformInstance, sessionId);
+    private removeStaleSocketSession(
+        platformInstance: PlatformInstance,
+        sessionId: string,
+    ) {
+        rmLog(
+            `removing ${
+                !this.stopTriggered ? "stale " : ""
+            }socket session reference ${sessionId} 
+          in platform instance ${platformInstance.id}`,
+        );
+        platformInstance.sessions.delete(sessionId);
+        this.removeSessionCallbacks(platformInstance, sessionId);
+    }
+
+    private async removeStalePlatformInstance(
+        platformInstance: PlatformInstance,
+    ): Promise<void> {
+        if (platformInstance.flaggedForTermination || this.stopTriggered) {
+            rmLog(`terminating platform instance ${platformInstance.id}`);
+            await platformInstance.shutdown(); // terminate
+        } else {
+            rmLog(
+                `flagging for termination platform instance ${platformInstance.id} (no registered sessions found)`,
+            );
+            platformInstance.flaggedForTermination = true;
+        }
     }
-  }
-}
 
-function removeStalePlatformInstance(platformInstance: PlatformInstance) {
-  if (platformInstance.flaggedForTermination) {
-    rmLog(`terminating platform instance ${platformInstance.id}`);
-    platformInstance.destroy(); // terminate
-  } else {
-    rmLog(`flagging for termination platform instance ${platformInstance.id} ` +
-      `(no registered sessions found)`);
-    platformInstance.flaggedForTermination = true;
-  }
+    private socketExists(sessionId: string) {
+        for (const socket of this.sockets) {
+            if (socket.id === sessionId) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private async delay(ms: number): Promise<void> {
+        return await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    private async getSockets(): Promise<Array<SocketInstance>> {
+        return listener.io.fetchSockets();
+    }
+
+    private async performStaleCheck(platformInstance: PlatformInstance) {
+        this.removeStaleSocketSessions(platformInstance);
+        // Static platforms are for global use, not tied to a unique to session
+        // (e.g. a stateful platform where credentials are supplied)
+        if (!platformInstance.global) {
+            if (
+                (platformInstance.config.persist &&
+                    !platformInstance.config.initialized) ||
+                platformInstance.sessions.size === 0
+            ) {
+                // either the platform failed to initialize, or there are no more sessions linked to it
+                await this.removeStalePlatformInstance(platformInstance);
+            }
+        }
+    }
+
+    private async clean(): Promise<void> {
+        if (this.stopTriggered) {
+            this.cycleRunning = false;
+            return;
+        }
+        if (this.cycleRunning) {
+            throw new Error(
+                "janitor cleanup cycle called while already running",
+            );
+        }
+        this.cycleRunning = true;
+        this.cycleCount++;
+        this.sockets = await this.getSockets();
+
+        if (!(this.cycleCount % 4)) {
+            this.reportCount++;
+            rmLog(
+                `socket sessions: ${this.sockets.length} platform instances: ${platformInstances.size}`,
+            );
+        }
+
+        for (const platformInstance of platformInstances.values()) {
+            await this.performStaleCheck(platformInstance);
+        }
+        this.cycleRunning = false;
+        await this.delay(this.cycleInterval);
+        return this.clean();
+    }
 }
 
-const janitor = {
-  clean: janitorCycle,
-  alreadyCalled: alreadyCalled,
-  cycleCount: cycleCount,
-  reportCount: reportCount
-};
+const janitor = new Janitor();
 export default janitor;