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

package/src/defaults.json

@@ -1,20 +1,20 @@
 {
-  "activity-streams": {
-    "opts": {
-      "specialObjs": [ "credentials" ]
+  "$schema": "https://sockethub.org/schemas/3.0.0-alpha.4/sockethub-config.json",
+  "examples": true,
+  "log_file": "",
+  "packageConfig": {
+    "@sockethub/activity-streams": {
+      "specialObjs": ["credentials"],
+      "failOnUnknownObjectProperties": true
     }
   },
-  "examples": {
-    "enabled": false,
-    "secret": 1234567890
-  },
-  "sockethub": {
-    "port": 10550,
-    "host": "localhost",
-    "path": "/sockethub"
-  },
-  "log_file": "",
-  "platforms": [],
+  "platforms": [
+    "@sockethub/platform-dummy",
+    "@sockethub/platform-feeds",
+    "@sockethub/platform-irc",
+    "@sockethub/platform-metadata",
+    "@sockethub/platform-xmpp"
+  ],
   "public": {
     "protocol": "http",
     "host": "localhost",
@@ -22,7 +22,15 @@
     "path": "/"
   },
   "redis": {
-    "host": "127.0.0.1",
-    "port": 6379
+    "url": "redis://127.0.0.1:6379"
+  },
+  "sentry": {
+    "dsn": "",
+    "traceSampleRate": 1.0
+  },
+  "sockethub": {
+    "port": 10550,
+    "host": "localhost",
+    "path": "/sockethub"
   }
 }

package/src/index.ts

@@ -1,29 +1,68 @@
+import debug from "debug";
+import config from "./config";
 import Sockethub from "./sockethub";
 
-const sockethub = new Sockethub();
+let sentry: { readonly reportError: (err: Error) => void } = {
+    reportError: (err: Error) => {},
+};
 
-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);
-  });
+export async function server() {
+    let sockethub: Sockethub;
+    const log = debug("sockethub:init");
 
-  process.once('SIGTERM', function () {
-    console.log('Received TERM signal. Exiting.');
-    process.exit(0);
-  });
+    // conditionally initialize sentry
+    if (config.get("sentry:dsn")) {
+        log("initializing sentry");
+        sentry = await import("./sentry");
+    }
 
-  process.once('SIGINT', function () {
-    console.log('Received INT signal. Exiting.');
-    process.exit(0);
-  });
+    try {
+        sockethub = new Sockethub();
+    } catch (err) {
+        sentry.reportError(err);
+        console.error(err);
+        process.exit(1);
+    }
 
-  process.once('exit', async function () {
-    console.log('destroying all platform instances');
-    await sockethub.shutdown();
-  });
+    process.once("uncaughtException", (err: Error) => {
+        console.error(
+            `${(new Date()).toUTCString()} UNCAUGHT EXCEPTION\n`,
+            err.stack,
+        );
+        sentry.reportError(err);
+        process.exit(1);
+    });
 
-  sockethub.boot();
-};
+    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

@@ -1,189 +1,211 @@
-import proxyquire from 'proxyquire';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as sinon from "sinon";
 
-let sockets = [
-  { id: 'socket foo', emit: () => {} },
-  { id: 'socket bar', emit: () => {} }
-]
+import { Janitor } from "./janitor.js";
 
-proxyquire.noPreserveCache();
-proxyquire.noCallThru();
+const sockets = [
+    { id: "socket foo", emit: () => {} },
+    { id: "socket bar", emit: () => {} },
+];
 
 function getPlatformInstanceFake() {
-  return {
-    flaggedForTermination: false,
-    initialized: false,
-    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() {}]
-      ]))()
-    }
-  }
+    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(function (done) {
-    this.timeout(3000);
-    sandbox = sinon.createSandbox();
-    fetchSocketsFake = sandbox.stub().returns(sockets);
-    const janitorMod = proxyquire('./janitor', {
-      listener: {
-        io: {
-          fetchSockets: fetchSocketsFake
-        }
-      }
-    });
-    janitor = janitorMod.default;
-    janitor.getSockets = fetchSocketsFake;
-    expect(janitor.cycleInterval).to.not.equal(cycleInterval);
-    janitor.cycleInterval = cycleInterval;
-    expect(janitor.cycleInterval).to.equal(cycleInterval);
-    janitor.start();
-    setTimeout(() => {
-      expect(janitor.cycleCount).to.equal(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).to.not.equal(0);
-    setTimeout(() => {
-      expect(janitor.cycleCount).to.equal(currCycleCount + 1);
-      setTimeout(() => {
-        expect(janitor.cycleCount).to.equal(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')).to.be.undefined;
-      expect(pi.sessionCallbacks.message.get('session bar')).to.equal(barMessage);
-      expect(pi.sessionCallbacks.close.get('session foo')).to.be.undefined;
-      expect(pi.sessionCallbacks.close.get('session bar')).to.equal(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).to.be.false;
-      await janitor.removeStaleSocketSessions(pi);
-      sinon.assert.notCalled(janitor.removeSessionCallbacks);
+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);
     });
 
-    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).to.be.true;
-      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');
+    afterEach((done) => {
+        sandbox.reset();
+        janitor.stop();
+        setTimeout(() => {
+            done();
+        }, janitor.cycleInterval * 2);
     });
 
-    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).to.be.false;
-      await janitor.removeStaleSocketSessions(pi);
-      sinon.assert.calledOnce(janitor.removeSessionCallbacks);
-      sinon.assert.calledWith(janitor.removeSessionCallbacks, pi, 'session foo');
+    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('performStaleCheck', () => {
-    it('removes flagged and uninitialized platform instances', async () => {
-      const pi = getPlatformInstanceFake();
-      pi.flaggedForTermination = true;
-      pi.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).to.be.true;
+
+    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,
+            );
+        });
     });
 
-    it('flags for termination when there are not sockets', async () => {
-      const pi = getPlatformInstanceFake();
-      pi.sessions = new Set();
-      pi.flaggedForTermination = false;
-      pi.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("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('removeStalePlatformInstance', () => {
-    it('flags stale platform', async () => {
-      const pi = getPlatformInstanceFake();
-      expect(pi.flaggedForTermination).to.be.false;
-      await janitor.removeStalePlatformInstance(pi);
-      sinon.assert.notCalled(pi.shutdown);
-      expect(pi.flaggedForTermination).to.be.true;
+
+    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);
+        });
     });
 
-    it('removes flagged stale platform', async () => {
-      const pi = getPlatformInstanceFake();
-      pi.flaggedForTermination = true;
-      await janitor.removeStalePlatformInstance(pi);
-      sinon.assert.calledOnce(pi.shutdown);
+    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).to.equal(prevCycle);
-      setTimeout(() => {
-        expect(janitor.cycleCount).to.equal(prevCycle);
+
+    it("closes all connections when stop() is called", (done) => {
+        const prevCycle = janitor.cycleCount;
+        janitor.stop();
         setTimeout(() => {
-          expect(janitor.cycleCount).to.equal(prevCycle);
-          done();
-        }, cycleInterval)
-      }, cycleInterval)
-    }, cycleInterval);
-  });
-})
+            expect(janitor.cycleCount).toEqual(prevCycle);
+            setTimeout(() => {
+                expect(janitor.cycleCount).toEqual(prevCycle);
+                setTimeout(() => {
+                    expect(janitor.cycleCount).toEqual(prevCycle);
+                    done();
+                }, cycleInterval);
+            }, cycleInterval);
+        }, cycleInterval);
+    });
+});