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

package/src/sockethub.ts

@@ -1,165 +1,198 @@
-import debug from 'debug';
-import { Socket } from "socket.io";
-import { IActivityStream } from "@sockethub/schemas";
-
-import crypto from './crypto';
-import init from './bootstrap/init';
-import middleware from './middleware';
-import createActivityObject from "./middleware/create-activity-object";
-import expandActivityStream from "./middleware/expand-activity-stream";
-import storeCredentials from "./middleware/store-credentials";
-import validate from "./middleware/validate";
-import janitor from './janitor';
-import listener from './listener';
-import ProcessManager from "./process-manager";
-import PlatformInstance, { platformInstances } from "./platform-instance";
-import { getSessionStore } from "./store";
-
-const log = debug('sockethub:server:core');
-
-
-export interface JobDataDecrypted {
-  title?: string;
-  msg: IActivityStream;
-  sessionId: string;
-}
-
-export interface JobDataEncrypted {
-  title?: string;
-  msg: string;
-  sessionId: string;
-}
-
-export interface JobDecrypted {
-  data: JobDataDecrypted,
-  remove?: Function;
-}
+import debug from "debug";
+import type { Socket } from "socket.io";
+
+import { crypto } from "@sockethub/crypto";
+import { CredentialsStore } from "@sockethub/data-layer";
+import type { CredentialsStoreInterface } from "@sockethub/data-layer";
+import type {
+    ActivityStream,
+    InternalActivityStream,
+} from "@sockethub/schemas";
+
+import getInitObject from "./bootstrap/init.js";
+import config from "./config";
+import janitor from "./janitor.js";
+import listener from "./listener.js";
+import middleware from "./middleware.js";
+import createActivityObject from "./middleware/create-activity-object.js";
+import expandActivityStream from "./middleware/expand-activity-stream.js";
+import storeCredentials from "./middleware/store-credentials.js";
+import validate from "./middleware/validate.js";
+import ProcessManager from "./process-manager.js";
+
+const log = debug("sockethub:server:core");
+
+type ErrMsg = {
+    context: string;
+    error: string;
+    content: object;
+};
+
+function attachError(err: unknown, msg: InternalActivityStream | undefined) {
+    const finalError: ErrMsg = {
+        context: "error",
+        error: err.toString(),
+        content: {},
+    };
 
-export interface JobEncrypted {
-  data: JobDataEncrypted,
-  remove?: Function;
-}
+    // biome-ignore lint/performance/noDelete: <explanation>
+    delete msg.sessionSecret;
 
-function attachError(err, msg) {
-  if (typeof msg !== 'object') {
-    msg = { context: 'error' };
-  }
-  msg.error = err.toString();
-  delete msg.sessionSecret;
-  return msg;
+    if (msg) {
+        finalError.content = msg;
+    }
+    return finalError;
 }
 
 class Sockethub {
-  private readonly parentId: string;
-  private readonly parentSecret1: string;
-  private readonly parentSecret2: string;
-  counter: number;
-  platforms: Map<string, object>;
-  status: boolean;
-  queue: any;
-  processManager: ProcessManager;
-
-  constructor() {
-    this.counter = 0;
-    this.platforms = init.platforms;
-    this.status = false;
-    this.parentId = crypto.randToken(16);
-    this.parentSecret1 = crypto.randToken(16);
-    this.parentSecret2 = crypto.randToken(16);
-    this.processManager = new ProcessManager(
-      this.parentId, this.parentSecret1, this.parentSecret2);
-    log('session id: ' + this.parentId);
-  }
-
-  /**
-   * initialization of Sockethub starts here
-   */
-  boot() {
-    if (this.status) {
-      return log('Sockethub.boot() called more than once');
-    } else {
-      this.status = true;
+    private readonly parentId: string;
+    private readonly parentSecret1: string;
+    private readonly parentSecret2: string;
+    counter: number;
+    platforms: Map<string, object>;
+    status: boolean;
+    processManager: ProcessManager;
+
+    constructor() {
+        this.status = false;
+        this.parentId = crypto.randToken(16);
+        this.parentSecret1 = crypto.randToken(16);
+        this.parentSecret2 = crypto.randToken(16);
+        log(`session id: ${this.parentId}`);
+    }
+
+    /**
+     * initialization of Sockethub starts here
+     */
+    async boot() {
+        if (this.status) {
+            return log("Sockethub.boot() called more than once");
+        }
+        this.status = true;
+
+        const init = await getInitObject().catch((err) => {
+            log(err);
+            process.exit(1);
+        });
+
+        this.processManager = new ProcessManager(
+            this.parentId,
+            this.parentSecret1,
+            this.parentSecret2,
+            init,
+        );
+
+        this.platforms = init.platforms;
+
+        log("active platforms: ", [...init.platforms.keys()]);
+        listener.start(); // start external services
+        janitor.start(); // start cleanup cycle
+        log("registering handlers");
+        listener.io.on("connection", this.handleIncomingConnection.bind(this));
     }
 
-    log('active platforms: ', [...init.platforms.keys()]);
-    janitor.clean(); // start cleanup cycle
-    listener.start();   // start external services
-    log('registering handlers');
-    listener.io.on('connection', this.handleIncomingConnection.bind(this));
-  }
+    async shutdown() {
+        await janitor.stop();
+    }
 
-  async removeAllPlatformInstances() {
-    for (let platform of platformInstances) {
-      await platform[1].destroy();
+    private handleIncomingConnection(socket: Socket) {
+        // session-specific debug messages
+        const sessionLog = debug(`sockethub:server:core:${socket.id}`);
+        const sessionSecret = crypto.randToken(16);
+        // stores instance is session-specific
+        // stores = getSessionStore(this.parentId, this.parentSecret1, socket.id, sessionSecret);
+        const credentialsStore: CredentialsStoreInterface =
+            new CredentialsStore(
+                this.parentId,
+                socket.id,
+                this.parentSecret1 + sessionSecret,
+                config.get("redis"),
+            );
+
+        sessionLog("socket.io connection");
+
+        socket.on("disconnect", () => {
+            sessionLog("disconnect received from client");
+        });
+
+        socket.on(
+            "credentials",
+            middleware("credentials")
+                .use(expandActivityStream)
+                .use(validate("credentials", socket.id))
+                .use(storeCredentials(credentialsStore))
+                .use((err, data, next) => {
+                    // error handler
+                    next(attachError(err, data));
+                })
+                .use((data, next) => {
+                    next();
+                })
+                .done(),
+        );
+
+        // when new activity objects are created on the client side, an event is
+        // fired, and we receive a copy on the server side.
+        socket.on(
+            "activity-object",
+            middleware("activity-object")
+                .use(validate("activity-object", socket.id))
+                .use(createActivityObject)
+                .use((err, data, next) => {
+                    next(attachError(err, data));
+                })
+                .use((data, next) => {
+                    next();
+                })
+                .done(),
+        );
+
+        socket.on(
+            "message",
+            middleware("message")
+                .use(expandActivityStream)
+                .use(validate("message", socket.id))
+                .use((msg, next) => {
+                    // The platform thread must find the credentials on their own using the given
+                    // sessionSecret, which indicates that this specific session (socket
+                    // connection) has provided credentials.
+                    msg.sessionSecret = sessionSecret;
+                    next(msg);
+                })
+                .use((err, data, next) => {
+                    next(attachError(err, data));
+                })
+                .use(async (msg: ActivityStream, next) => {
+                    const platformInstance = this.processManager.get(
+                        msg.context,
+                        msg.actor.id,
+                        socket.id,
+                    );
+                    // job validated and queued, stores socket.io callback for when job is completed
+                    try {
+                        const job = await platformInstance.queue.add(
+                            socket.id,
+                            msg,
+                        );
+                        if (job) {
+                            platformInstance.completedJobHandlers.set(
+                                job.title,
+                                next,
+                            );
+                        } else {
+                            // failed to add job to queue, reject handler immediately
+                            msg.error = "failed to add job to queue";
+                            next(msg);
+                        }
+                    } catch (err) {
+                        // Queue is closed (platform terminating) - send error to client
+                        msg.error = err.message || "platform unavailable";
+                        next(msg);
+                    }
+                })
+                .done(),
+        );
     }
-  }
-
-  private createJob(socketId: string, platformInstance: PlatformInstance, msg): JobDataEncrypted {
-    const title = `${msg.context}-${(msg.id) ? msg.id : this.counter++}`;
-    const job: JobDataEncrypted = {
-      title: title,
-      sessionId: socketId,
-      msg: crypto.encrypt(msg, this.parentSecret1 + this.parentSecret2)
-    };
-    return job;
-  };
-
-  private handleIncomingConnection(socket: Socket) {
-    // session-specific debug messages
-    const sessionLog = debug('sockethub:server:core:' + socket.id),
-          sessionSecret = crypto.randToken(16),
-          // store instance is session-specific
-          store = getSessionStore(this.parentId, this.parentSecret1, socket.id, sessionSecret);
-
-    sessionLog(`socket.io connection`);
-
-    socket.on('disconnect', () => {
-      sessionLog('disconnect received from client');
-    });
-
-    socket.on('credentials',
-      middleware('credentials')
-        .use(expandActivityStream)
-        .use(validate('credentials', socket.id))
-        .use(storeCredentials(store, sessionLog))
-        .use((err, data, next) => {
-          // error handler
-          next(attachError(err, data));
-        }).use((data, next) => { next(); })
-        .done());
-
-    // when new activity objects are created on the client side, an event is
-    // fired and we receive a copy on the server side.
-    socket.on('activity-object',
-      middleware('activity-object')
-        .use(validate('activity-object', socket.id))
-        .use(createActivityObject)
-        .use((err, data, next) => {
-          next(attachError(err, data));
-        }).use((data, next) => { next(); })
-        .done());
-
-    socket.on('message',
-      middleware('message')
-        .use(expandActivityStream)
-        .use(validate('message', socket.id))
-        .use((msg, next) => {
-          // The platform thread must find the credentials on their own using the given
-          // sessionSecret, which indicates that this specific session (socket
-          // connection) has provided credentials.
-          msg.sessionSecret = sessionSecret;
-          next(msg);
-        }).use((err, data, next) => {
-          next(attachError(err, data));
-        }).use((msg, next) => {
-          const platformInstance = this.processManager.get(msg.context, msg.actor.id, socket.id);
-          sessionLog(`queued to channel ${platformInstance.id}`);
-          const job = this.createJob(socket.id, platformInstance, msg);
-          // job validated and queued, store socket.io callback for when job is completed
-          platformInstance.completedJobHandlers.set(job.title, next);
-          platformInstance.queue.add(job);
-        }).done());
-  }
 }
 
 export default Sockethub;

package/src/util.ts

@@ -0,0 +1,5 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+export const __dirname = dirname(__filename);