Types for MonitoringServer

Author: patuwwy

packages/host/src/lib/host.ts

@@ -226,7 +226,7 @@ export class Host implements IComponent {
         }
 
         if (sthConfig.monitorgingServer) {
-            this.startMonitoringServer(sthConfig.monitorgingServer.port);
+            this.startMonitoringServer(sthConfig.monitorgingServer.port).then(() => true);
         }
 
         this.auditor = new Auditor();
@@ -262,15 +262,13 @@ export class Host implements IComponent {
     }
 
     private async startMonitoringServer(port: number) {
-        const { MonitoringServer } = await loadModule({ name: "@scramjet/monitoring-server" }) as unknown as { MonitoringServer: IMonitoringServerConstructor };
+        const { MonitoringServer } = await loadModule<{ MonitoringServer: IMonitoringServerConstructor }>({ name: "@scramjet/monitoring-server" });
 
         this.logger.info("Starting monitoring server on port", port);
 
         this.monitoringServer = new MonitoringServer({
             port,
-            validator: async () => {
-                return await this.loadCheck.getLoadCheck();
-            }
+            check: async () => !!await this.loadCheck.getLoadCheck()
         });
 
         this.monitoringServer.startServer();

packages/module-loader/src/index.ts

@@ -2,14 +2,14 @@ import { ObjLogger } from "@scramjet/obj-logger";
 import { ModuleLoaderOpts } from "@scramjet/types";
 
 export const logger = new ObjLogger("ModuleLoader");
-export async function loadModule(opts: ModuleLoaderOpts): Promise<any> {
+export async function loadModule<T>(opts: ModuleLoaderOpts): Promise<T> {
     logger.info("Loading module", opts.name);
 
     if (!opts.name) {
         throw new Error("Name missing");
     }
 
-    let module: ClassDecorator | null;
+    let module: T;
 
     const heap = process.memoryUsage().heapUsed;
 

packages/monitoring-server/src/monitoring-server.ts

@@ -1,44 +1,43 @@
 import { createServer } from "http";
-import { IMonitoringServer, MonitoringServerOptions } from "@scramjet/types";
+import { IMonitoringServer, MonitoringServerOptions, MonitoringServerValidator as MonitoringServerHealthCheck } from "@scramjet/types";
 
 export class MonitoringServer implements IMonitoringServer {
-    id = "MonitoringServer";
-
     private options: MonitoringServerOptions;
+    private checks: MonitoringServerHealthCheck[] = [];
 
     constructor(options: MonitoringServerOptions) {
         this.options = options;
+
+        if (Array.isArray(options.check)) {
+            this.checks = options.check;
+        }
+
+        if (typeof this.options.check === "function") {
+            this.checks.push(this.options.check);
+        }
+    }
+
+    async handleHealtzRequest(): Promise<boolean> {
+        return Promise.all(this.checks.map(v => v())).then(res => res.every(v => (v === true)), () => false);
     }
 
     startServer() {
-        const server = createServer(async (req, res) => {
+        createServer(async (req, res) => {
             if (req.url === "/healtz" && req.method === "GET") {
-                let ok = true;
-
-                if (this.options.validator) {
-                    try {
-                        ok = await this.options.validator();
-                    } catch (_e) {
-                        res.statusCode = 500;
-                        res.end();
-                    }
-                }
+                const healtz = await this.handleHealtzRequest();
 
                 res.setHeader("Content-type", "text/plain");
 
-                if (ok) {
+                if (healtz) {
                     res.statusCode = 200;
                     res.end("ok");
-                } else {
-                    res.statusCode = 500;
-                    res.end();
+
+                    return;
                 }
-            } else {
-                res.statusCode = 404;
+
+                res.statusCode = 500;
                 res.end();
             }
-        });
-
-        server.listen(this.options.port);
+        }).listen(this.options.port);
     }
 }

packages/types/src/monitoring-server.ts

@@ -1,8 +1,10 @@
 import { MaybePromise } from "./utils";
 
+export type MonitoringServerValidator = () => MaybePromise<boolean>;
+
 export type MonitoringServerOptions = {
     port: number,
-    validator: MaybePromise<any>;
+    check?: MonitoringServerValidator | MonitoringServerValidator[];
 }
 
 export interface IMonitoringServer {