@interopio/gateway-server 0.4.0-beta

package/src/mesh/connections.ts

@@ -0,0 +1,101 @@
+import getLogger from '../logger.js';
+
+const logger = getLogger('mesh.connections');
+
+export type Node = { node: string, endpoint: string, users?: string[] };
+export type NodeConnection = { node: string, connect: Node[] }
+
+type NodeValue = Omit<Node, 'users'> & {
+    users: Set<string>, memberId: number, lastAccess: number
+}
+
+export interface NodeConnections {
+    announce(nodes: Node[]): NodeConnection[];
+    remove(node: string): boolean;
+}
+
+export default class InMemoryNodeConnections implements NodeConnections {
+    private readonly nodes = new Map<string, NodeValue>();
+    private readonly nodesByEndpoint = new Map<string, string>();
+    private memberIds: number = 0;
+
+    constructor(private readonly timeout: number = 60000) {
+    }
+
+    announce(nodes: Node[]): NodeConnection[] {
+        for (const node of nodes) {
+            const {node: nodeId, users, endpoint} = node;
+            const foundId = this.nodesByEndpoint.get(endpoint);
+            if (foundId) {
+                if (foundId !== nodeId) {
+                    logger.warn(`endpoint ${endpoint} clash. replacing node ${foundId} with ${nodeId}`);
+                    this.nodesByEndpoint.set(endpoint, nodeId);
+                    this.nodes.delete(foundId);
+                }
+            } else {
+                logger.info(`endpoint ${endpoint} announced for ${nodeId}`);
+                this.nodesByEndpoint.set(endpoint, nodeId);
+            }
+            this.nodes.set(nodeId, this.updateNode(node, new Set<string>(users ?? []), nodeId, this.nodes.get(nodeId)));
+        }
+        this.cleanupOldNodes();
+        const sortedNodes = Array.from(this.nodes.values()).sort((a, b) => a.memberId - b.memberId);
+        return nodes.map((e) => {
+            const node = e.node;
+            const connect = this.findConnections(sortedNodes, this.nodes.get(node));
+            return {node, connect};
+        });
+    }
+
+    remove(nodeId: string) {
+        const removed = this.nodes.get(nodeId);
+        if (removed) {
+            this.nodes.delete(nodeId);
+            const endpoint = removed.endpoint;
+            this.nodesByEndpoint.delete(endpoint);
+            logger.info(`endpoint ${endpoint} removed for ${nodeId}`);
+            return true;
+        }
+        return false;
+    }
+
+    private updateNode(newNode: Node, users: Set<string>, _key: string, oldNode?: NodeValue): NodeValue {
+        const node: Omit<NodeValue, 'lastAccess' | 'users'> = !oldNode ? {...newNode, memberId: this.memberIds++} : oldNode;
+        return {...node, users, lastAccess: Date.now()};
+    }
+
+    private cleanupOldNodes() {
+        const threshold = Date.now() - this.timeout;
+        for (const [nodeId,v] of this.nodes) {
+            if (v.lastAccess < threshold) {
+                if (logger.enabledFor('debug')) {
+                    logger.debug(`${nodeId} expired - no announcement since ${new Date(v.lastAccess).toISOString()}, timeout is ${this.timeout} ms.`);
+                }
+                this.nodes.delete(nodeId);
+            }
+        }
+    }
+
+    private findConnections(sortedNodes: NodeValue[], node?: NodeValue): Node[] {
+        return sortedNodes.reduce((l, c) => {
+            if (node !== undefined && c.memberId < node.memberId) {
+                const intersection = new Set(c.users);
+                node.users.forEach(user => {
+                    if (!c.users.has(user)) {
+                        intersection.delete(user);
+                    }
+                });
+                c.users.forEach(user => {
+                    if (!node.users.has(user)) {
+                        intersection.delete(user);
+                    }
+                });
+                if (intersection.size > 0) {
+                    const e: Node = {node: c.node, endpoint: c.endpoint};
+                    return l.concat(e);
+                }
+            }
+            return l;
+        }, new Array<Node>());
+    }
+}

package/src/mesh/rest-directory/routes.ts

@@ -0,0 +1,38 @@
+import {Middleware} from '../../server/types.js';
+import {NodeConnections, Node} from '../connections.js';
+import {HttpServerRequest, HttpServerResponse} from '../../server/exchange.js';
+
+function routes(connections: NodeConnections): Middleware<HttpServerRequest, HttpServerResponse> {
+    return [
+        async (ctx, next: () => Promise<void>) => {
+            if (ctx.method === 'POST' && ctx.path === '/api/nodes') {
+                const json = await ctx.request.json;
+                if (!Array.isArray(json)) {
+                    ctx.response.statusCode = 400
+                    ctx.response._res.end();
+                } else {
+                    const nodes = json as Node[];
+                    const result = connections.announce(nodes);
+                    const body = JSON.stringify(result);
+                    ctx.response.headers.set('content-type', 'application/json');
+                    ctx.response.statusCode = 200;
+                    ctx.response._res
+                        .end(body);
+                }
+            } else {
+                await next();
+            }
+        },
+        async ({method, path, response}, next: () => Promise<void>) => {
+            if (method === 'DELETE' && path?.startsWith('/api/nodes/')) {
+                const nodeId = path?.substring('/api/nodes/'.length);
+                connections.remove(nodeId);
+                response.statusCode = 200;
+                response._res.end();
+            } else {
+                await next();
+            }
+        },
+    ];
+}
+export default routes;

package/src/mesh/ws/broker/core.ts

@@ -0,0 +1,163 @@
+import * as ws from 'ws';
+import getLogger from '../../../logger.js';
+import {socketKey} from '../../../utils.ts';
+import {IOGateway} from '@interopio/gateway';
+import GatewayEncoders = IOGateway.Encoding;
+
+const logger = getLogger('mesh.ws.broker');
+
+type Command =
+    // client to broker
+    { type: 'hello', 'node-id': string }
+    | { type: 'bye', 'node-id': string }
+    | { type: 'data', from: string, to: 'all' | string}
+    // broker to client
+    | { type: 'node-added', 'node-id': string, 'new-node': string }
+    | { type: 'node-removed', 'node-id': string, 'removed-node': string }
+
+    ;
+
+
+function broadcastNodeAdded(nodes: NodeSockets, newSocket: ws.WebSocket, newNodeId: string) {
+    Object.entries(nodes.nodes).forEach(([nodeId, socket]) => {
+        if (nodeId !== newNodeId) {
+            newSocket.send(codec.encode({type: 'node-added', 'node-id': newNodeId, "new-node": nodeId}));
+            socket.send(codec.encode({type: 'node-added', 'node-id': nodeId, "new-node": newNodeId}));
+        }
+    });
+}
+
+function broadcastNodeRemoved(nodes: NodeSockets, removedNodeId: string) {
+    Object.entries(nodes.nodes).forEach(([nodeId, socket]) => {
+        if (nodeId !== removedNodeId) {
+            socket.send(codec.encode({type: 'node-removed', 'node-id': nodeId, "removed-node": removedNodeId}));
+        }
+    });
+}
+
+function onOpen(connectedNodes: NodeSockets, key: string) {
+    logger.info(`[${key}] connection accepted`);
+}
+
+function onClose(connectedNodes: NodeSockets, key: string, code: number, reason: string): void {
+    logger.info(`[${key}] connected closed [${code}](${reason})`);
+    const nodeIds = connectedNodes.sockets[key];
+    if (nodeIds) {
+        delete connectedNodes.sockets[key];
+        for (const nodeId of nodeIds) {
+            delete connectedNodes.nodes[nodeId];
+        }
+        for (const nodeId of nodeIds) {
+            broadcastNodeRemoved(connectedNodes, nodeId);
+        }
+    }
+}
+
+function processMessage(connectedNodes: NodeSockets, socket: ws.WebSocket, key: string, msg: Command) {
+    switch (msg.type) {
+        case 'hello': {
+            const nodeId = msg['node-id'];
+            connectedNodes.nodes[nodeId] = socket;
+            connectedNodes.sockets[key] = connectedNodes.sockets[key] ?? [];
+            connectedNodes.sockets[key].push(nodeId);
+            logger.info(`[${key}] node ${nodeId} added.`);
+            broadcastNodeAdded(connectedNodes, socket, nodeId);
+            break;
+        }
+        case 'bye': {
+            const nodeId = msg["node-id"];
+            delete connectedNodes[nodeId];
+            logger.info(`[${key}] node ${nodeId} removed.`);
+            broadcastNodeRemoved(connectedNodes, nodeId);
+            break;
+        }
+        case 'data': {
+            const sourceNodeId = msg.from;
+            const targetNodeId = msg.to;
+            if ('all' === targetNodeId) {
+                Object.entries(connectedNodes.nodes).forEach(([nodeId, socket]) => {
+                    if (nodeId !== sourceNodeId) {
+                        socket.send(codec.encode(msg));
+                    }
+                });
+            }
+            else {
+                const socket = connectedNodes.nodes[targetNodeId];
+                if (socket) {
+                    socket.send(codec.encode(msg));
+                }
+                else {
+                    logger.warn(`unable to send to node ${targetNodeId} message ${JSON.stringify(msg)}`);
+                }
+            }
+            break;
+        }
+        default: {
+            logger.warn(`[${key}] ignoring unknown message ${JSON.stringify(msg)}`);
+            break;
+        }
+    }
+}
+
+const codec = GatewayEncoders.transit<Command>({
+    keywordize: new Map<string, GatewayEncoders.KeywordizeCommand>([
+        ['/type', '*'],
+        ['/message/body/type', '*'],
+        ['/message/origin', '*'],
+        ['/message/receiver/type', '*'],
+        ['/message/source/type', '*'],
+        ['/message/body/type', '*'],
+    ])
+});
+
+function onMessage(connectedNodes: NodeSockets, socket: ws.WebSocket, key: string, msg: string): void {
+    try {
+        const decoded = codec.decode(msg);
+        if (logger.enabledFor('debug')) {
+            logger.debug(`[${key}] processing msg ${JSON.stringify(decoded)}`);
+        }
+        processMessage(connectedNodes, socket, key, decoded);
+    } catch (ex) {
+        logger.error(`[${key}] unable to process message`, ex);
+    }
+}
+
+class WebsocketBroker {
+    constructor(private readonly server: ws.WebSocketServer) {
+    }
+
+    async close() {
+        this.server.close();
+    }
+}
+type NodeSockets = {nodes: {[nodeId: string]: ws.WebSocket}, sockets: {[socket: string]: string[]}};
+
+async function create(server: {wss: ws.WebSocketServer}): Promise<{close: () => Promise<void>}> {
+    const connectedNodes: NodeSockets = {nodes: {}, sockets: {}};
+    logger.info(`mesh server is listening`);
+
+    server.wss
+        .on('error', () => {
+            logger.error(`error starting mesh server`);
+        })
+        .on('connection', (socket, request) => {
+            const key = socketKey(request.socket);
+            onOpen(connectedNodes, key);
+            socket.on('error', (err: Error) => {
+                logger.error(`[${key}] websocket error: ${err}`, err);
+            });
+            socket.on('message', (data, isBinary) => {
+                if (Array.isArray(data)) {
+                    data = Buffer.concat(data);
+                }
+                onMessage(connectedNodes, socket, key, data as unknown as string);
+            });
+            socket.on('close', (code, reason) => {
+                onClose(connectedNodes, key, code, reason as unknown as string);
+            });
+        });
+
+    return new WebsocketBroker(server.wss);
+}
+
+export default create;

package/src/mesh/ws/cluster/core.ts

@@ -0,0 +1,107 @@
+import * as ws from 'ws';
+import {socketKey} from '../../../utils.js';
+import {relays} from '../relays/core.js';
+import getLogger from '../../../logger.js';
+import {HttpServerRequest} from '../../../server/exchange.ts';
+
+const logger = getLogger('mesh.ws.cluster');
+
+
+function onMessage(key: string, node: string | undefined, socketsByNodeId: Map<string, Map<string, ws.WebSocket>>, msg: string) {
+    try {
+        relays.send(key, node, msg, (k, err?: Error) => {
+            if (err) {
+                logger.warn(`${k} error writing msg ${msg}: ${err}`);
+                return;
+            }
+            if (logger.enabledFor('debug')) {
+                logger.debug(`${k} sent msg ${msg}`);
+            }
+        });
+    } catch (ex) {
+        logger.error(`${key} unable to process message`, ex);
+        if (node) {
+            const socket = socketsByNodeId.get(node)?.get(key);
+            socket?.terminate();
+        }
+    }
+}
+
+async function create(server: {wss: ws.WebSocketServer}): Promise<{ close?: () => Promise<void> }> {
+    const socketsByNodeId = new Map<string, Map<string, ws.WebSocket>>();
+    relays.onMsg = (k, nodeId, msg) => {
+        try {
+            const sockets = socketsByNodeId.get(nodeId);
+            if (sockets && sockets.size > 0) {
+                for (const [key, socket] of sockets) {
+                    socket.send(msg, {binary: false}, (err?: Error) => {
+                        if (err) {
+                            logger.warn(`${key} error writing from ${k} msg ${msg}: ${err}`);
+                            return;
+                        }
+                        if (logger.enabledFor('debug')) {
+                            logger.debug(`${key} sent from ${k} msg ${msg}`);
+                        }
+                    });
+                }
+            } else {
+                logger.warn(`${k} dropped msg ${msg}.`);
+            }
+        } catch (ex) {
+            logger.error(`${k} unable to process message`, ex);
+        }
+    };
+    server.wss
+        .on('error', () => {
+            logger.error(`error starting mesh server`);
+        })
+        .on('listening', () => {
+            logger.info(`mesh server is listening`);
+        })
+        .on('connection', (socket, req) => {
+            const request = new HttpServerRequest(req);
+            const key = socketKey(request.socket);
+            const query = new URLSearchParams(request.query ?? undefined);
+            logger.info(`${key} connected on cluster with ${query}`);
+            const node = query.get('node');
+            if (node) {
+                let sockets = socketsByNodeId.get(node);
+                if (!sockets) {
+                    sockets = new Map<string, ws.WebSocket>();
+                    socketsByNodeId.set(node, sockets);
+                }
+                sockets.set(key, socket);
+            }
+            else {
+                socket.terminate();
+                return;
+            }
+            //onOpen(connectedNodes, key);
+            socket.on('error', (err: Error) => {
+                logger.error(`${key} websocket error: ${err}`, err);
+            });
+            socket.on('message', (data, _isBinary) => {
+                if (Array.isArray(data)) {
+                    data = Buffer.concat(data);
+                }
+                onMessage(key, node, socketsByNodeId,  data as unknown as string);
+            });
+            socket.on('close', (_code, _reason) => {
+                logger.info(`${key} disconnected from cluster`);
+                const sockets = socketsByNodeId.get(node);
+                if (sockets) {
+                    sockets.delete(key);
+                    if (sockets.size === 0) {
+                        socketsByNodeId.delete(node);
+                    }
+                }
+            });
+        });
+    return {
+        close: async () => {
+            server.wss.close();
+        }
+    };
+}
+
+export default create;

package/src/mesh/ws/relays/core.ts

@@ -0,0 +1,159 @@
+import * as ws from 'ws';
+import {socketKey} from '../../../utils.js';
+import getLogger from '../../../logger.js';
+
+import {IOGateway} from '@interopio/gateway';
+import GatewayEncoders = IOGateway.Encoding;
+
+const logger = getLogger('mesh.ws.relay');
+
+type Command
+    = { type: 'hello', 'from': string, to: string }
+    | { type: 'bye', 'from': string, to: 'all' | string }
+    | { type: 'data', from: string, to: 'all' | string, data: {body: {type: string}}}
+
+    ;
+
+const codec = GatewayEncoders.transit<Command>({
+    keywordize: new Map<string, GatewayEncoders.KeywordizeCommand>([
+        ['/type', '*'],
+        ['/message/body/type', '*'],
+        ['/message/origin', '*'],
+        ['/message/receiver/type', '*'],
+        ['/message/source/type', '*'],
+        ['/message/body/type', '*'],
+    ])
+});
+
+export interface Relays {
+    onMsg?: ((key: string, node: string, msg: string) => void);
+    onErr?: ((key: string, err: Error) => void)
+    send(key: string, node: string | undefined, msg: string,  cb: (key: string, err?: Error) => void): void;
+}
+
+class InternalRelays implements Relays {
+    // key -> socket
+    private readonly clients = new Map<string, ws.WebSocket>();
+    // node -> key
+    private readonly links = new Map<string, string>();
+    public onMsg?: (key: string, node: string, msg: string) => void
+    public onErr?: (key: string, err: Error) => void
+
+    add(key: string, soc: ws.WebSocket) {
+        this.clients.set(key, soc);
+    }
+
+    remove(key: string) {
+        this.clients.delete(key);
+        for (const [node, k] of this.links) {
+            if (k === key) {
+                this.links.delete(node);
+            }
+        }
+    }
+
+    receive(key: string, msg: string) {
+        const node = this.link(key, msg);
+
+        if (node && this.onMsg) {
+            this.onMsg(key, node, msg);
+        }
+    }
+
+    private link(key: string, msg: string): string | undefined {
+        try {
+            const decoded = codec.decode(msg);
+            const {type, from, to} = decoded;
+            if (to === 'all') {
+                switch (type) {
+                    case 'hello': {
+                        if (logger.enabledFor('debug')) {
+                            logger.debug(`${key} registers node ${from}`);
+                        }
+                        this.links.set(from, key);
+                        break;
+                    }
+                    case 'bye': {
+                        if (logger.enabledFor('debug')) {
+                            logger.debug(`${key} unregisters node ${from}`);
+                        }
+                        this.links.delete(from);
+                        break;
+                    }
+                }
+                return;
+            }
+            return from;
+        } catch (e) {
+            if (this.onErr) {
+                // probably a decode error or a bug
+                this.onErr(key, e instanceof Error ? e : new Error(`link failed :${e}`));
+            }
+            else {
+                logger.warn(`${key} unable to process ${msg}`, e);
+            }
+        }
+    }
+
+    send(key: string, node: string, msg: string, cb: (k: string, err?: Error) => void): void {
+        const decoded = codec.decode(msg);
+        if (logger.enabledFor('debug')) {
+            logger.debug(`${key} sending msg to ${node} ${JSON.stringify(decoded)}`);
+        }
+
+        const clientKey = this.links.get(node);
+        if (clientKey) {
+            const client = this.clients.get(clientKey);
+            if (client) {
+                client.send(msg, {binary: false}, (err?: Error) => {
+                    cb(clientKey, err)
+                });
+                return;
+            }
+        }
+        throw new Error(`${key} no active link for ${decoded.to}`);
+    }
+}
+const internal = new InternalRelays();
+export const relays: Relays = internal;
+
+
+async function create(server: {wss:ws.WebSocketServer}): Promise<{ close?: () => Promise<void> }> {
+
+    logger.info(`relays server is listening`);
+    server.wss
+        .on('error', () => {
+            logger.error(`error starting relays server`);
+        })
+        .on('connection', (socket, request) => {
+            const key = socketKey(request.socket);
+            logger.info(`${key} connected on relays`);
+            internal.add(key, socket);
+            //onOpen(connectedNodes, key);
+            socket.on('error', (err: Error) => {
+                logger.error(`[${key}] websocket error: ${err}`, err);
+            });
+            socket.on('message', (data, _isBinary) => {
+                if (Array.isArray(data)) {
+                    data = Buffer.concat(data);
+                }
+                try {
+                    internal.receive(key, data as unknown as string);
+                } catch (e) {
+                    logger.warn(`[${key}] error processing received data '${data}'`, e);
+                }
+            });
+            socket.on('close', (code, reason) => {
+                internal.remove(key);
+
+                logger.info(`${key} disconnected from relays`);
+            });
+        });
+    return {
+        close: async () => {
+            server.wss.close();
+        }
+    };
+}
+
+export default create;

package/src/metrics/routes.ts

@@ -0,0 +1,86 @@
+import {Metrics} from '@interopio/gateway-metrics-api';
+import {Middleware, WebExchange} from '../server/types.js';
+import getLogger from '../logger.js';
+import {FilePublisherConfig} from '@interopio/gateway/metrics/publisher/file';
+import {HttpServerRequest, HttpServerResponse} from '../server/exchange.ts';
+
+const logger = getLogger('metrics');
+
+const COOKIE_NAME = 'GW_LOGIN';
+
+function loggedIn(auth, ctx: WebExchange) {
+    if (auth) {
+        const cookieHeaderValue = ctx.request.headers.list('cookie');
+        const cookie = cookieHeaderValue?.join('; ').split('; ').find(value => value.startsWith(`${COOKIE_NAME}=`));
+        return cookie && (parseInt(cookie?.substring(COOKIE_NAME.length + 1)) > Date.now());
+    }
+    return true;
+}
+
+async function routes(config: {file?: FilePublisherConfig, auth?}): Promise<Middleware<HttpServerRequest, HttpServerResponse>> {
+    const {jsonFileAppender} = await import('@interopio/gateway/metrics/publisher/file');
+    const appender = jsonFileAppender(logger);
+    await appender.open(config.file?.location ?? 'metrics.ndjson', config.file?.append ?? true);
+    return [
+        async (ctx, next: () => Promise<void>) => {
+            if (ctx.method === 'GET' && ctx.path === '/api/metrics') {
+                if (loggedIn(config.auth, ctx)) {
+                    ctx.response.statusCode = 200;
+                } else {
+                    ctx.response.statusCode = 302;
+                    ctx.response.headers.set('location', '/api/login?redirectTo=/api/metrics');
+                }
+                ctx.response._res.end();
+            }
+            else {
+                await next();
+            }
+        },
+        async (ctx, next: () => Promise<void>) => {
+            if (ctx.method === 'GET' && ctx.path === '/api/login') {
+                const redirectTo = new URLSearchParams(ctx.request.query ?? undefined).get('redirectTo');
+                const expires = Date.now() + 180 * 1000;
+                ctx.response.headers.add('set-cookie', `${COOKIE_NAME}=${expires}; Path=/api; SameSite=strict`)
+                if (redirectTo) {
+                    ctx.response.statusCode = 302;
+                    ctx.response.headers.set('location', redirectTo);
+                }
+                else {
+                    ctx.response.statusCode = 200;
+                }
+                ctx.response._res.end();
+            } else {
+                await next();
+            }
+        },
+        async (ctx, next: () => Promise<void>) => {
+            if (ctx.method === 'POST' && ctx.path === '/api/metrics') {
+                if (loggedIn(config.auth, ctx)) {
+                    ctx.response.statusCode = 202;
+                    ctx.response._res.end();
+                    try {
+                        const json = await ctx.request.json;
+                        const update = json as Metrics.Update;
+                        if (logger.enabledFor('debug')) {
+                            logger.debug(`${JSON.stringify(update)}`);
+                        }
+                        if ((config.file?.status ?? false) || (update.status === undefined)) {
+                            await appender.write(update);
+                        }
+                    } catch (e) {
+                        logger.error(`error processing metrics`, e);
+                    }
+                }
+                else {
+                    ctx.response.statusCode = 401;
+                    ctx.response._res.end();
+                }
+            }
+            else {
+                await next();
+            }
+        },
+    ];
+}
+
+export default routes;