geonix 1.12.2 → 1.20.0

package/src/Gateway.js

@@ -1,236 +1,258 @@
-import { connection } from './Connection.js'
-import { registry } from './Registry.js'
-import { createTCPServer, GeonixVersion, picoid, proxyHttp, sleep } from './Util.js'
-import express, { Router } from 'express'
-import { Request } from './Request.js'
-import { HEALTH_CHECK_ENDPOINT } from './WebServer.js'
-import expressWs from 'express-ws'
-import querystring from 'querystring'
-import semver from 'semver'
-import { WebSocket } from 'ws'
-
-const raw = express.raw({ limit: '100mb' })
-
-const DEBUG_ENDPOINT = '/lZ6jD2eC3iP0zB3jJ1yJ9pM8gG3yI3vS'
-const endpointMatcher = /^((?<options>.+)\|)?(?<verb>WS|GET|POST|PATCH|PUT|DELETE|HEAD|OPTIONS|ALL)\s(?<url>.*)/
+import { connection } from "./Connection.js";
+import { registry } from "./Registry.js";
+import { createTCPServer, GeonixVersion, picoid, proxyHttp, sleep } from "./Util.js";
+import express, { Router } from "express";
+import { Request } from "./Request.js";
+import { HEALTH_CHECK_ENDPOINT } from "./WebServer.js";
+import expressWs from "express-ws";
+import querystring from "querystring";
+import semver from "semver";
+import { WebSocket } from "ws";
+
+const raw = express.raw({ limit: "100mb" });
+
+const DEBUG_ENDPOINT = "/lZ6jD2eC3iP0zB3jJ1yJ9pM8gG3yI3vS";
+const endpointMatcher = /^((?<options>.+)\|)?(?<verb>WS|GET|POST|PATCH|PUT|DELETE|HEAD|OPTIONS|ALL)\s(?<url>.*)/;
 
 const logger = (req, res, next) => {
-    console.info(`HTTP ${req.method} ${req.url}`)
+    console.info(`HTTP ${req.method} ${req.url}`);
 
-    next()
-}
+    next();
+};
 
 const stats = {
     requests: 0,
     proxied: 0,
     proxied_over_nats: 0,
     debug_requests: 0
-}
+};
+
+const defaultOpts = {
+    beforeRequest: (_req, _res) => { },
+    afterRequest: (_req, _res) => { }
+};
 
 export class Gateway {
 
-    static start() {
-        return new Gateway()
+    static start(opts) {
+        return new Gateway(opts);
     }
 
-    #api = express()
-    #router = (req, res, next) => next()
-    #activeServers = []
-    #port
+    #opts = defaultOpts;
+    #api = express();
+    #router = (req, res, next) => next();
+    #port;
 
-    #rebuildRouter = false
-    #buildRouterRunning = false
-    #endpoints = []
+    #rebuildRouter = false;
+    #buildRouterRunning = false;
+    #endpoints = [];
 
-    #registry = {}
+    #registry = {};
 
-    constructor() {
-        expressWs(this.#api)
+    constructor(opts) {
+        expressWs(this.#api);
 
-        this.#start()
+        this.#opts = { ...this.#opts, ...opts };
+
+        this.#start();
     }
 
     async #start(port = 8080) {
-        await connection.waitUntilReady()
+        await connection.waitUntilReady();
 
-        this.#port = process.env.PORT || port
-        const server = this.#api.listen(this.#port)
+        this.#port = process.env.PORT || port;
+        this.#api.listen(this.#port);
 
-        console.debug(`geonix.gateway: listening on http://0.0.0.0:${this.#port}`)
+        console.debug(`geonix.gateway: listening on http://0.0.0.0:${this.#port}`);
 
         // logging
-        this.#api.use(logger)
+        this.#api.use(logger);
 
         // cors
         this.#api.use((req, res, next) => {
-            const origin = req.headers['origin']
-            const allMethods = 'GET,PUT,POST,DELETE,OPTIONS,HEAD'
-            const allHeaders = '*'
-            const requestMethod = req.headers['access-control-request-method']
-            const requestHeaders = req.headers['access-control-request-headers']
+            const origin = req.headers["origin"];
+            const allMethods = "GET,PUT,POST,DELETE,OPTIONS,HEAD";
+            const allHeaders = "*";
+            const requestMethod = req.headers["access-control-request-method"];
+            const requestHeaders = req.headers["access-control-request-headers"];
 
-            res.set('Access-Control-Allow-Credentials', 'true')
-            res.set('Access-Control-Allow-Origin', origin || '*')
-            res.set('Access-Control-Allow-Methods', requestMethod || allMethods)
-            res.set('Allow', requestMethod || allMethods)
-            res.set('Access-Control-Allow-Headers', requestHeaders || allHeaders)
+            res.set("Access-Control-Allow-Credentials", "true");
+            res.set("Access-Control-Allow-Origin", origin || "*");
+            res.set("Access-Control-Allow-Methods", requestMethod || allMethods);
+            res.set("Allow", requestMethod || allMethods);
+            res.set("Access-Control-Allow-Headers", requestHeaders || allHeaders);
 
-            next()
-        })
+            next();
+        });
 
         // debug router (only available in non-production environments)
-        if (process.env.NODE_ENV !== 'production')
-            this.#api.use(DEBUG_ENDPOINT, this.#debugRouter())
+        if (process.env.NODE_ENV !== "production")
+            this.#api.use(DEBUG_ENDPOINT, this.#debugRouter());
+
+        this.#api.use((req, res, next) => {
+            if (this.#opts.beforeRequest) {
+                this.#opts.beforeRequest(req, res);
+            }
+            next();
+        });
 
         // handle mapped endpoints as service calls
         this.#api.use(raw, (req, res, next) => {
-            stats.requests++
+            stats.requests++;
 
             if (this.#router)
-                this.#router(req, res, next)
+                this.#router(req, res, next);
             else
-                next()
-        })
+                next();
+        });
+
+        this.#api.use((req, res, next) => {
+            if (this.#opts.afterRequest) {
+                this.#opts.afterRequest(req, res);
+            }
+            next();
+        });
 
         // config
-        this.#api.disable('x-powered-by')
-        this.#api.disable('etag')
+        this.#api.disable("x-powered-by");
+        this.#api.disable("etag");
 
         // default answer
-        this.#api.all('*', (req, res) => {
+        this.#api.all("*", (req, res) => {
             res.status(404).send({
                 error: 404,
-                source: 'gw'
-            })
-        })
+                source: "gw"
+            });
+        });
 
         setInterval(() => {
             if (this.#rebuildRouter)
-                this.#buildRouter()
-        }, 1000)
+                this.#buildRouter();
+        }, 1000);
 
         while (true) {
             try {
                 // send keeplive to check if connection is still alive
-                await connection.publish('gx.gateway.keepalive', Date.now())
+                await connection.publish("gx.gateway.keepalive", Date.now());
 
-                await this.#handleAddedServics()
-                await this.#handleRemovedServices()
-                await sleep(1000)
+                await this.#handleAddedServics();
+                await this.#handleRemovedServices();
+                await sleep(1000);
 
-                if (connection.isClosed())
-                    break
+                if (connection.isClosed()) {
+                    break;
+                }
             } catch (e) {
-                console.error(e)
+                console.error(e);
             }
         }
 
         // terminate process
-        console.debug(`geonix.gateway: stopped`)
-        process.exit(0)
+        console.debug("geonix.gateway: stopped");
+        process.exit(0);
     }
 
     async #handleAddedServics() {
-        let entries = Object.values(registry.getEntries())
+        let entries = Object.values(registry.getEntries());
 
         const processEntry = async (entry) => {
             if (this.#registry[entry.i] !== undefined)
-                return false
+                return false;
 
-            console.log(`gateway.onServiceAdded: ${entry.n}@${entry.v} (#${entry.i})`)
+            console.log(`gateway.onServiceAdded: ${entry.n}@${entry.v} (#${entry.i})`);
 
             // figure out if endpoints is reachable via direct http call
-            let backend
+            let backend;
             for (let address of entry.a)
                 try {
-                    const ac = new AbortController()
-                    const timeout = setTimeout(() => ac.abort(), 500)
-                    const result = await (await fetch(`http://${address}${HEALTH_CHECK_ENDPOINT}`, { signal: ac.signal })).json()
-                    clearTimeout(timeout)
-                    if (result.status === 'healthy' && result.services?.includes(entry.n)) {
-                        backend = address
-                        console.log(`${serviceTag} directly reachable @ ${address}`)
-                        break
+                    const ac = new AbortController();
+                    const timeout = setTimeout(() => ac.abort(), 500);
+                    const result = await (await fetch(`http://${address}${HEALTH_CHECK_ENDPOINT}`, { signal: ac.signal })).json();
+                    clearTimeout(timeout);
+                    if (result.status === "healthy" && result.services?.includes(entry.n)) {
+                        backend = address;
+                        console.log(`${entry.n}@${entry.v} (#${entry.i}) directly reachable @ ${address}`);
+                        break;
                     }
-                } catch (e) {
+                } catch {
                     // silently ignore errors
                 }
 
-            let proxy
+            let proxy;
             if (!backend) {
                 // create proxy over nats
                 proxy = await createTCPServer(async (client) => {
-                    const streamId = picoid()
-                    stats.proxied_over_nats++
+                    const streamId = picoid();
+                    stats.proxied_over_nats++;
 
                     try {
-                        await this.#proxyHttpOverNats(streamId, entry, client)
+                        await this.#proxyHttpOverNats(streamId, entry, client);
                     } catch (e) {
-                        console.error('nats.proxy.error', e)
-                        client.destroy()
+                        console.error("nats.proxy.error", e);
+                        client.destroy();
                     }
-                }, 50000, 10000)
-                backend = `127.0.0.1:${proxy.port}`
+                }, 50000, 10000);
+                backend = `127.0.0.1:${proxy.port}`;
             }
 
-            this.#registry[entry.i] = { entry, proxy, backend }
+            this.#registry[entry.i] = { entry, proxy, backend };
 
-            return true
-        }
+            return true;
+        };
 
-        entries = (await Promise.all(entries.map(processEntry))).filter(result => result === true)
+        entries = (await Promise.all(entries.map(processEntry))).filter(result => result === true);
 
         if (entries.length > 0)
-            this.#rebuildRouter = true
+            this.#rebuildRouter = true;
     }
 
     async #handleRemovedServices() {
-        const localEntries = Object.values(this.#registry)
-        const registryEntries = registry.getEntries()
+        const localEntries = Object.values(this.#registry);
+        const registryEntries = registry.getEntries();
 
         for (let { entry, proxy } of localEntries) {
             if (registryEntries[entry.i] === undefined) {
-                proxy?.server?.close()
-                console.log(`gateway.onServiceRemoved: ${entry.n}@${entry.v}`)
-                delete this.#registry[entry.i]
+                proxy?.server?.close();
+                console.log(`gateway.onServiceRemoved: ${entry.n}@${entry.v}`);
+                delete this.#registry[entry.i];
 
-                this.#rebuildRouter = true
+                this.#rebuildRouter = true;
             }
         }
     }
 
     #debugRouter() {
-        const router = Router()
+        const router = Router();
 
         router.use((req, res, next) => {
-            stats.debug_requests++
+            stats.debug_requests++;
 
-            next()
-        })
+            next();
+        });
 
-        router.get('/services', (req, res) => {
-            const services = Object.values(registry.getEntries()).map(e => (`${e.n}@${e.v}`))
-            services.sort()
-            res.send(services)
-        })
+        router.get("/services", (req, res) => {
+            const services = Object.values(registry.getEntries()).map(e => (`${e.n}@${e.v}`));
+            services.sort();
+            res.send(services);
+        });
 
-        router.get('/endpoints', (req, res) => {
-            res.send(this.#endpoints)
-        })
+        router.get("/endpoints", (req, res) => {
+            res.send(this.#endpoints);
+        });
 
-        router.get('/router-registry', (req, res) => {
-            res.send(this.#registry)
-        })
+        router.get("/router-registry", (req, res) => {
+            res.send(this.#registry);
+        });
 
-        router.get('/registry', (req, res) => {
-            res.send(registry.getEntries())
-        })
+        router.get("/registry", (req, res) => {
+            res.send(registry.getEntries());
+        });
 
-        router.get('/stats', (req, res) => {
-            res.send(stats)
-        })
+        router.get("/stats", (req, res) => {
+            res.send(stats);
+        });
 
-        router.get('/info', (req, res) => {
+        router.get("/info", (req, res) => {
             res.send({
                 geonix: GeonixVersion,
                 node: {
@@ -242,39 +264,35 @@ export class Gateway {
                 mem: process.memoryUsage(),
                 rss: process.memoryUsage.rss(),
                 cpu: process.cpuUsage()
-            })
-        })
-
-        router.get('/rebuild', (req, res) => {
-            this.#rebuildRouter = true
-            res.send({ result: 'ok' })
-        })
+            });
+        });
 
-        router.use('/', express.static('src/status'))
-        router.all('*', (req, res) => {
-            res.status(404).send({ error: 404 })
-        })
+        router.all("*", (req, res) => {
+            res.status(404).send({ error: 404 });
+        });
 
-        return router
+        return router;
     }
 
     async #proxyHttpOverNats(streamId, entry, client) {
-        if (await Request(entry.n, 'SYS_createConnection', [streamId])) {
-            const ingress = await connection.subscribe(`gx2.stream.${streamId}.a`)
-
-            client.on('data', (chunk) => connection.publishRaw(`gx2.stream.${streamId}.b`, chunk))
-            client.on('close', () => {
-                connection.unsubscribe(ingress)
-                connection.publish(`gx2.stream.${streamId}.c`, Buffer.from('end'))
-            })
-            client.on('error', (error) => { })
+        if (await Request(entry.n, "SYS_createConnection", [streamId])) {
+            const ingress = await connection.subscribe(`gx2.stream.${streamId}.a`);
+
+            client.on("data", (chunk) => connection.publishRaw(`gx2.stream.${streamId}.b`, chunk));
+            client.on("close", () => {
+                connection.unsubscribe(ingress);
+                connection.publish(`gx2.stream.${streamId}.c`, Buffer.from("end"));
+            });
+            client.on("error", (_error) => {
+                // silently ignore errors
+            });
 
             const dataLoop = async () => {
                 for await (const event of ingress)
-                    client.write(event.data)
-            }
+                    client.write(event.data);
+            };
 
-            dataLoop()
+            dataLoop();
         }
     }
 
@@ -291,45 +309,44 @@ export class Gateway {
                 headers: {
                     ...req.headers
                 }
-            })
+            });
 
-            backend.on('open', () => {
-                backend.on('message', (data, isBinary) => inbound.send(isBinary ? data : data.toString()))
-                inbound.on('message', data => backend.send(data))
+            backend.on("open", () => {
+                backend.on("message", (data, isBinary) => inbound.send(isBinary ? data : data.toString()));
+                inbound.on("message", data => backend.send(data));
 
-                backend.on('close', () => inbound.close())
-                inbound.on('close', () => backend.close())
-            })
+                backend.on("close", () => inbound.close());
+                inbound.on("close", () => backend.close());
+            });
         } catch (e) {
-            console.error(e)
+            console.error(e);
         }
     }
 
-
     async #buildRouter() {
         if (this.#buildRouterRunning)
-            return
+            return;
 
-        console.debug('gateway.buildRouter')
+        console.debug("gateway.buildRouter");
 
-        this.#rebuildRouter = false
-        this.#buildRouterRunning = true
+        this.#rebuildRouter = false;
+        this.#buildRouterRunning = true;
 
         try {
-            const router = Router()
-            const entries = Object.values(this.#registry)
+            const router = Router();
+            const entries = Object.values(this.#registry);
 
-            const endpoints = []
+            const endpoints = [];
 
             for (let { entry, backend } of entries) {
                 // generate global endpoint list
                 for (let e of entry.m) {
                     if (endpointMatcher.test(e)) {
-                        const endpoint = endpointMatcher.exec(e).groups
+                        const endpoint = endpointMatcher.exec(e).groups;
                         let options = {
                             order: 100,
                             ...(endpoint.options ? querystring.parse(endpoint.options) : {})
-                        }
+                        };
 
                         try {
                             endpoints.push({
@@ -338,67 +355,66 @@ export class Gateway {
                                 options,
                                 endpoint,
                                 backend: [backend]
-                            })
+                            });
                         } catch (e) {
-                            console.error('gateway.buildRouter.error:', entry)
-                            console.error('gateway.buildRouter.error:', e)
+                            console.error("gateway.buildRouter.error:", entry);
+                            console.error("gateway.buildRouter.error:", e);
                         }
                     }
                 }
             }
 
             // handle duplicates (round-robin)
-            let index = endpoints.length
+            let index = endpoints.length;
             while (index--) {
-                const version = endpoints[index].version
-                const url = `${endpoints[index].endpoint.verb} ${endpoints[index].endpoint.url}`
+                const version = endpoints[index].version;
+                const url = `${endpoints[index].endpoint.verb} ${endpoints[index].endpoint.url}`;
 
                 for (let n = 0; n < index; n++)
                     if (`${endpoints[n].endpoint.verb} ${endpoints[n].endpoint.url}` === url && endpoints[n].version === version) {
-                        endpoints[n].backend = endpoints[n].backend.concat(endpoints[index].backend)
-                        endpoints.splice(index, 1)
-                        break
+                        endpoints[n].backend = endpoints[n].backend.concat(endpoints[index].backend);
+                        endpoints.splice(index, 1);
+                        break;
                     }
             }
 
             // sort endpoints by order, if there is one
-            endpoints.sort((a, b) => semver.rcompare(a.version, b.version))
-            endpoints.sort((a, b) => parseInt(a.options.order) - parseInt(b.options.order))
+            endpoints.sort((a, b) => semver.rcompare(a.version, b.version));
+            endpoints.sort((a, b) => parseInt(a.options.order) - parseInt(b.options.order));
 
-            this.#endpoints = endpoints
+            this.#endpoints = endpoints;
 
             // build the router
             for (let endpoint of endpoints) {
-                let { verb, url: uri } = endpoint.endpoint
-                let backend = endpoint.backend[endpoint.requests++ % endpoint.backend.length]
+                let { verb, url: uri } = endpoint.endpoint;
+                let backend = endpoint.backend[endpoint.requests++ % endpoint.backend.length];
 
-                verb = verb.toLowerCase()
+                verb = verb.toLowerCase();
 
-                if (verb === 'ws') {
+                if (verb === "ws") {
                     router.ws(uri, (ws, req) => {
-                        const url = req.originalUrl.replace(/\/\.websocket$/, '')
+                        const url = req.originalUrl.replace(/\/\.websocket$/, "");
 
-                        console.debug(`proxy.web.ws.to:`, backend + req.originalUrl)
-                        this.#proxyWebsocketOverNats(`ws://${backend}${url}`, ws, req)
-                    })
+                        console.debug("proxy.web.ws.to:", backend + req.originalUrl);
+                        this.#proxyWebsocketOverNats(`ws://${backend}${url}`, ws, req);
+                    });
                 } else
-                    router[verb](uri, async (req, res, next) => {
-                        stats.proxied++
-                        backend = endpoint.backend[endpoint.requests++ % endpoint.backend.length]
+                    router[verb](uri, async (req, res, _next) => {
+                        stats.proxied++;
+                        backend = endpoint.backend[endpoint.requests++ % endpoint.backend.length];
 
                         try {
-                            console.debug(`proxy.web.to:`, backend + req.originalUrl)
-                            await proxyHttp(`http://${backend}`, req, res)
+                            console.debug("proxy.web.to:", backend + req.originalUrl);
+                            await proxyHttp(`http://${backend}`, req, res);
                         } catch (e) {
-                            console.error('proxy.web.error:', e)
-                        } finally {
+                            console.error("proxy.web.error:", e);
                         }
-                    })
+                    });
             }
 
-            this.#router = router
+            this.#router = router;
         } finally {
-            this.#buildRouterRunning = false
+            this.#buildRouterRunning = false;
         }
     }