@interopio/gateway-server 0.4.0-beta → 0.5.0-beta

package/src/server/monitoring.ts

@@ -1,167 +0,0 @@
-import getLogger from '../logger.js';
-import {getHeapStatistics, writeHeapSnapshot, HeapInfo} from 'node:v8';
-import {PathLike} from 'node:fs';
-import {access, mkdir, rename, unlink} from 'node:fs/promises';
-
-const log = getLogger('monitoring');
-
-export type Options = typeof DEFAULT_OPTIONS;
-
-export type Command = 'run' | 'dump' | 'stop';
-export type Channel = (command?: Command) => Promise<boolean>;
-
-const DEFAULT_OPTIONS = {
-    memoryLimit: 1024 * 1024 * 1024, // 1GB
-    reportInterval: 10 * 60 * 1000, // 10 min
-    dumpLocation: '.', // current folder
-    maxBackups: 10,
-    dumpPrefix: 'Heap'
-}
-
-function fetchStats(): HeapInfo {
-    return getHeapStatistics();
-}
-
-async function dumpHeap(opts: Options) {
-    const prefix = opts.dumpPrefix ?? 'Heap';
-    const target = `${opts.dumpLocation}/${prefix}.heapsnapshot`;
-    if (log.enabledFor('debug')) {
-        log.debug(`starting heap dump in ${target}`);
-    }
-
-    await fileExists(opts.dumpLocation)
-        .catch(async (_) => {
-            if (log.enabledFor('debug')) {
-                log.debug(`dump location  ${opts.dumpLocation} does not exists. Will try to create it`);
-            }
-            try {
-                await mkdir(opts.dumpLocation, {recursive: true});
-                log.info(`dump location dir ${opts.dumpLocation} successfully created`);
-            } catch (e) {
-                log.error(`failed to create dump location ${opts.dumpLocation}`);
-            }
-        });
-    const dumpFileName = writeHeapSnapshot(target);
-    log.info(`heap dumped`);
-    try {
-        log.debug(`rolling snapshot backups`);
-        const lastFileName = `${opts.dumpLocation}/${prefix}.${opts.maxBackups}.heapsnapshot`;
-        await fileExists(lastFileName)
-            .then(async () => {
-                if (log.enabledFor('debug')) {
-                    log.debug(`deleting ${lastFileName}`);
-                }
-                try {
-                    await unlink(lastFileName);
-                } catch (e) {
-                    log.warn(`failed to delete ${lastFileName}`, e);
-                }
-            })
-            .catch(() => {
-                /* do nothing*/
-            });
-        for (let i = opts.maxBackups - 1; i > 0; i--) {
-            const currentFileName = `${opts.dumpLocation}/${prefix}.${i}.heapsnapshot`;
-            const nextFileName = `${opts.dumpLocation}/${prefix}.${i + 1}.heapsnapshot`;
-            await fileExists(currentFileName)
-                .then(async () => {
-                    try {
-                        await rename(currentFileName, nextFileName);
-                    } catch (e) {
-                        log.warn(`failed to rename ${currentFileName} to ${nextFileName}`, e);
-                    }
-                })
-                .catch(() => {
-                    /* do nothing*/
-                });
-        }
-        const firstFileName = `${opts.dumpLocation}/${prefix}.${1}.heapsnapshot`;
-        try {
-            await rename(dumpFileName, firstFileName);
-        } catch (e) {
-            log.warn(`failed to rename ${dumpFileName} to ${firstFileName}`, e);
-        }
-        log.debug('snapshots rolled');
-    } catch (e) {
-        log.error('error rolling backups', e);
-        throw e;
-    }
-}
-
-async function fileExists(path: PathLike): Promise<void> {
-    log.trace(`checking file ${path}`);
-    await access(path);
-}
-
-async function processStats(stats: HeapInfo, state: {
-    memoryLimitExceeded: boolean,
-    snapshot?: boolean
-}, opts: Options) {
-    if (log.enabledFor('debug')) {
-        log.debug(`processing heap stats ${JSON.stringify(stats)}`);
-    }
-    const limit = Math.min(opts.memoryLimit, (0.95 * stats.heap_size_limit));
-    const used = stats.used_heap_size;
-    log.info(`heap stats ${JSON.stringify(stats)}`);
-    if (used >= limit) {
-        log.warn(`used heap ${used} bytes exceeds memory limit ${limit} bytes`);
-        if (state.memoryLimitExceeded) {
-            delete state.snapshot;
-        } else {
-            state.memoryLimitExceeded = true;
-            state.snapshot = true;
-        }
-        await dumpHeap(opts);
-    } else {
-        state.memoryLimitExceeded = false;
-        delete state.snapshot;
-    }
-}
-
-export function start(opts?: Partial<Options>): Options & { channel: Channel } {
-    const merged: Options = {...DEFAULT_OPTIONS, ...opts};
-
-    let stopped = false;
-    const state = {memoryLimitExceeded: false};
-    const report = async () => {
-        const stats = fetchStats();
-        await processStats(stats, state, merged);
-    }
-    const interval = setInterval(report, merged.reportInterval);
-    const channel = async (command?: Command) => {
-        if (!stopped) {
-            command ??= 'run';
-            switch (command) {
-                case 'run': {
-                    await report();
-                    break;
-                }
-                case 'dump': {
-                    await dumpHeap(merged);
-                    break;
-                }
-                case 'stop': {
-                    stopped = true;
-                    clearInterval(interval);
-                    log.info('exit memory diagnostic');
-                    break;
-                }
-            }
-
-        }
-        return stopped;
-    }
-
-    return {...merged, channel};
-}
-
-async function run({channel}: { channel: Channel }, command?: Command) {
-    if (!await channel(command)) {
-        log.warn(`cannot execute command "${command}" already closed`)
-    }
-}
-
-
-export async function stop(m: { channel: Channel }) {
-    return await run(m, 'stop');
-}

package/src/server/types.ts

@@ -1,69 +0,0 @@
-export type Middleware<Request extends ServerHttpRequest = ServerHttpRequest, Response extends ServerHttpResponse = ServerHttpResponse> = ((context: WebExchange<Request, Response>, next: () => Promise<void>) => Promise<void>)[];
-
-export abstract class WebExchange<Request extends ServerHttpRequest = ServerHttpRequest, Response extends  ServerHttpResponse = ServerHttpResponse> {
-    abstract readonly request: Request
-    abstract readonly response: Response
-
-    get method(): string | undefined {
-        return this.request.method;
-    }
-
-    get path(): string | null | undefined {
-        return this.request.path;
-    }
-}
-export type ReadonlyHeaderValue = string | undefined;
-export type HeaderValue = number | ReadonlyHeaderValue;
-export type ReadonlyHeaderValues = (readonly string[]) | ReadonlyHeaderValue
-export type HeaderValues = (readonly string[]) | HeaderValue
-
-export interface HttpHeaders {
-    get(name: string): HeaderValues
-    list(name: string): string[]
-    one(name: string): HeaderValue
-    has(name: string): boolean
-    keys(): IteratorObject<string>
-}
-
-export interface ReadonlyHttpHeaders extends HttpHeaders {
-    get(name: string): ReadonlyHeaderValues
-    one(name: string): string | undefined
-
-}
-export interface MutableHttpHeaders extends HttpHeaders {
-    get(name: string): HeaderValues
-    one(name: string): HeaderValue
-    set(name: string, value: HeaderValues): this
-    add(name: string, value: string | (readonly string[])): this
-}
-
-export interface HttpMessage<Headers = HttpHeaders> {
-    readonly headers: Headers
-}
-
-export interface HttpRequest<Headers = HttpHeaders> extends HttpMessage<Headers> {
-    readonly path: string,
-    readonly method?: string
-    readonly URL: URL
-    readonly protocol: string
-    /**
-     * hostname[:port]
-     */
-    readonly host?: string
-    readonly body: Promise<Blob>
-}
-
-export interface HttpResponse<Headers = HttpHeaders> extends HttpMessage<Headers> {
-    readonly statusCode: number
-}
-
-export type ServerHttpRequest = HttpRequest<ReadonlyHttpHeaders> /* & {
-    // readonly text: Promise<string>
-    // readonly json: Promise<unknown>
-    // readonly socket: http.IncomingMessage['socket']
-    // readonly _req: http.IncomingMessage
-}*/
-
-export interface ServerHttpResponse extends HttpResponse<MutableHttpHeaders> {
-    statusCode: number
-}

package/src/server/ws-client-verify.ts

@@ -1,79 +0,0 @@
-import {IOGateway} from '@interopio/gateway';
-import {GatewayServer} from '../../gateway-server';
-import getLogger from '../logger.js';
-
-const log = getLogger('gateway.ws.client-verify');
-
-export type ProcessedOriginFilters
-    = Required<Omit<GatewayServer.OriginFilters, 'blacklist' | 'whitelist'>>
-    //| Required<Omit<GatewayServer.OriginFilters, 'block' | 'allow'>>
-    ;
-
-function acceptsMissing(originFilters: ProcessedOriginFilters): boolean {
-    switch (originFilters.missing) {
-        case 'allow': // fall-through
-        case 'whitelist':
-            return true;
-        case 'block': // fall-through
-        case 'blacklist':
-            return false;
-        default:
-            return false;
-    }
-}
-
-function tryMatch(originFilters: ProcessedOriginFilters, origin: string): boolean | undefined {
-    const block = originFilters.block ?? originFilters['blacklist'];
-    const allow = originFilters.allow ?? originFilters['whitelist'];
-    if (block.length > 0 && IOGateway.Filtering.valuesMatch(block, origin)) {
-        log.warn(`origin ${origin} matches block filter`);
-        return false;
-    } else if (allow.length > 0 && IOGateway.Filtering.valuesMatch(allow, origin)) {
-        if (log.enabledFor('debug')) {
-            log.debug(`origin ${origin} matches allow filter`);
-        }
-        return true;
-    }
-}
-
-function acceptsNonMatched(originFilters: ProcessedOriginFilters): boolean {
-    switch (originFilters.non_matched) {
-        case 'allow': // fall-through
-        case 'whitelist':
-            return true;
-        case 'block': // fall-through
-        case 'blacklist':
-            return false;
-        default:
-            return false;
-    }
-}
-
-export function acceptsOrigin(origin?: string, originFilters?: ProcessedOriginFilters): boolean {
-    if (!originFilters) {
-        return true;
-    }
-    if (!origin) {
-        return acceptsMissing(originFilters);
-    } else {
-        const matchResult: boolean | undefined = tryMatch(originFilters, origin);
-        if (matchResult) {
-            return matchResult;
-        } else {
-            return acceptsNonMatched(originFilters);
-        }
-    }
-}
-
-export function regexifyOriginFilters(originFilters?: GatewayServer.OriginFilters): ProcessedOriginFilters | undefined {
-    if (originFilters) {
-        const block = (originFilters.block ?? originFilters.blacklist ?? []).map(IOGateway.Filtering.regexify);
-        const allow = (originFilters.allow ?? originFilters.whitelist ?? []).map(IOGateway.Filtering.regexify);
-        return {
-            non_matched: originFilters.non_matched ?? 'allow',
-            missing: originFilters.missing ?? 'allow',
-            allow,
-            block,
-        }
-    }
-}

package/src/server.ts

@@ -1,316 +0,0 @@
-import {WebSocketServer} from 'ws';
-import http from 'node:http';
-import https from 'node:https';
-import {SecureContextOptions} from 'node:tls';
-import {AddressInfo} from 'node:net';
-import {readFileSync} from 'node:fs';
-import {AsyncLocalStorage} from 'node:async_hooks';
-import {IOGateway} from '@interopio/gateway';
-import wsGateway from './gateway/ws/core.js';
-import NodeConnections from './mesh/connections.js';
-import restDirectory from './mesh/rest-directory/routes.js';
-import meshBroker from './mesh/ws/broker/core.js';
-import meshRelays from './mesh/ws/relays/core.js';
-import meshCluster from './mesh/ws/cluster/core.js';
-import metrics from './metrics/routes.js';
-import {compose} from './common/compose.js';
-import {WebExchange, Middleware} from './server/types.js';
-import {DefaultWebExchange, HttpServerRequest, HttpServerResponse} from './server/exchange.js';
-import {socketKey} from './utils.js';
-import getLogger from './logger.js';
-import {localIp, portRange} from './server/address.js';
-import * as monitoring from './server/monitoring.js';
-import {acceptsOrigin, ProcessedOriginFilters, regexifyOriginFilters} from './server/ws-client-verify.js';
-import {GatewayServer} from '../gateway-server';
-import cors from './server/cors.ts';
-
-const logger = getLogger('app');
-
-function secureContextOptions(ssl: GatewayServer.SslConfig): SecureContextOptions {
-    const options: SecureContextOptions = {};
-    if (ssl.key) options.key = readFileSync(ssl.key);
-    if (ssl.cert) options.cert = readFileSync(ssl.cert);
-    if (ssl.ca) options.ca = readFileSync(ssl.ca);
-    return options;
-}
-
-type RequestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
-
-function createListener(middleware: Middleware<HttpServerRequest, HttpServerResponse>,
-                        routes: Map<string, RouteInfo>) {
-    const storage = new AsyncLocalStorage();
-
-    const listener = compose<WebExchange<HttpServerRequest, HttpServerResponse>>(
-        async ({response}, next) => {
-            response.headers.set('server', 'gateway-server');
-            await next();
-        },
-        ...cors({
-            origins: {allow: [/http:\/\/localhost(:\d+)?/]},
-            methods: {allow: ['GET', 'HEAD', 'POST', 'DELETE']},
-            headers: {allow: '*'},
-            credentials: {allow: true}
-        }),
-        ...middleware,
-        async ({request, response}, next) => {
-            if (request.method === 'GET' && request.path === '/health') {
-                response.statusCode = 200;
-                response._res.end(http.STATUS_CODES[200]);
-            } else {
-                await next();
-            }
-        },
-        async ({request, response}, next) => {
-            if (request.method === 'GET' && request.path === '/') {
-                response._res.end(`io.Gateway Server`);
-            } else {
-                await next();
-            }
-        },
-        async ({request, response}, _next) => {
-            const route = routes.get(request.path);
-            if (route) {
-                response.statusCode = 426;
-                response._res
-                    .appendHeader('Upgrade', 'websocket')
-                    .appendHeader('Connection', 'Upgrade')
-                    .appendHeader('Content-Type', 'text/plain');
-                response._res.end(`This service [${request.path}] requires use of the websocket protocol.`);
-            } else {
-                response.statusCode = 404;
-                response._res.end(http.STATUS_CODES[404]);
-            }
-        }
-    );
-
-    return (request: http.IncomingMessage, response: http.ServerResponse) => {
-        const exchange = new DefaultWebExchange(new HttpServerRequest(request), new HttpServerResponse(response));
-        return storage.run(exchange, async () => {
-            if (logger.enabledFor('debug')) {
-                const socket = exchange.request._req.socket;
-                if (logger.enabledFor('debug')) {
-                    logger.debug(`received ${exchange.method} request for ${exchange.path} from ${socket.remoteAddress}:${socket.remotePort}`);
-                }
-            }
-            return await listener(exchange);
-        });
-    };
-}
-
-function promisify<T>(fn: (callback?: (err?: Error) => void) => T): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-        const r = fn((err?: Error) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve(r);
-            }
-        });
-    });
-}
-
-type RouteInfo = {
-    readonly default?: boolean,
-    readonly ping?: number,
-    readonly maxConnections?: number
-    readonly originFilters?: ProcessedOriginFilters
-    readonly factory: (server: { endpoint: string, wss: WebSocketServer }) => Promise<{
-        info?: string,
-        close?: () => Promise<void>
-    }>,
-    // set later in listening
-    wss?: WebSocketServer,
-    close?: () => Promise<void>
-}
-
-function memoryMonitor(config?: GatewayServer.ServerConfig['memory']) {
-    if (config) {
-        return monitoring.start({
-            memoryLimit: config.memory_limit,
-            dumpLocation: config.dump_location,
-            dumpPrefix: config.dump_prefix,
-            reportInterval: config.report_interval,
-            maxBackups: config.max_backups
-        });
-    }
-}
-
-function regexAwareReplacer<T>(_key: string, value: T): string | T {
-    return value instanceof RegExp ? value.toString() : value;
-}
-
-export const Factory = async (options: GatewayServer.ServerConfig): Promise<GatewayServer.Server> => {
-    const ssl = options.ssl;
-    const createServer = ssl ? (options: http.ServerOptions, handler: RequestHandler) => https.createServer({...options, ...secureContextOptions(ssl)}, handler) : (options: http.ServerOptions, handler: RequestHandler) => http.createServer(options, handler);
-    const monitor = memoryMonitor(options.memory);
-    const middleware: Middleware<HttpServerRequest, HttpServerResponse> = [];
-    const routes: Map<string, RouteInfo> = new Map<string, RouteInfo>();
-    const gw = IOGateway.Factory({...options.gateway});
-    if (options.gateway) {
-        const config = options.gateway;
-        routes.set(config.route ?? '/', {
-            default: config.route === undefined,
-            ping: options.gateway.ping,
-            factory: wsGateway.bind(gw),
-            maxConnections: config.limits?.max_connections,
-            originFilters: regexifyOriginFilters(config.origins)
-        });
-    }
-    if (options.mesh) {
-        const connections = new NodeConnections(options.mesh.timeout ?? 60000);
-        middleware.push(...restDirectory(connections));
-        const ping = options.mesh.ping ?? 30000;
-        routes.set('/broker', {factory: meshBroker, ping: ping});
-        routes.set('/cluster', {factory: meshCluster, ping: ping});
-        routes.set('/relays', {factory: meshRelays, ping: ping});
-    }
-    if (options.metrics) {
-        middleware.push(...(await metrics(options.metrics)));
-    }
-
-    const ports = portRange(options.port ?? 0);
-    const host = options.host;
-    const serverP: Promise<http.Server> = new Promise((resolve, reject) => {
-        const onSocketError = (err: Error) => logger.error(`socket error: ${err}`, err);
-        const server = createServer(
-            {},
-            createListener(middleware, routes));
-
-        server.on('error', (e: Error) => {
-            if (e['code'] === 'EADDRINUSE') {
-                logger.debug(`port ${e['port']} already in use on address ${e['address']}`);
-                const {value: port} = ports.next();
-                if (port) {
-                    logger.info(`retry starting server on port ${port} and host ${host ?? '<unspecified>'}`);
-                    server.close();
-                    server.listen(port, host);
-                } else {
-                    logger.warn(`all configured port(s) ${options.port} are in use. closing...`);
-                    server.close();
-                    reject(e);
-                }
-            } else {
-                logger.error(`server error: ${e.message}`, e);
-                reject(e);
-            }
-        });
-        server
-            .on('listening', async () => {
-                const info = server.address() as AddressInfo;
-                for (const [path, route] of routes) {
-                    try {
-                        logger.info(`creating ws server for [${path}]. max connections: ${route.maxConnections ?? '<unlimited>'}, origin filters: ${route.originFilters ? JSON.stringify(route.originFilters, regexAwareReplacer) : '<none>'}`);
-                        const wss = new WebSocketServer({noServer: true});
-                        const endpoint = `${ssl ? 'wss' : 'ws'}://${localIp}:${info.port}${path}`;
-                        const handler = await route.factory({endpoint, wss});
-                        const pingInterval = route.ping;
-                        if (pingInterval) {
-                            const pingIntervalId = setInterval(() => {
-                                for (const client of wss.clients) {
-                                    if (client['connected'] === false) {
-                                        client.terminate();
-                                    }
-                                    client['connected'] = false;
-                                    client.ping();
-                                }
-                            }, pingInterval);
-                            wss.on('close', () => {
-                                clearInterval(pingIntervalId);
-                            });
-                        }
-                        route.wss = wss;
-                        route.close = handler.close?.bind(handler);
-                    } catch (e) {
-                        logger.warn(`failed to init route ${path}`, e);
-                    }
-                }
-                logger.info(`http server listening on ${info.address}:${info.port}`);
-                resolve(server);
-            });
-        server
-            .on('upgrade', (req, socket, head) => {
-                socket.addListener('error', onSocketError);
-                try {
-                    const request = new HttpServerRequest(req);
-                    const path = request.path ?? '/';
-                    const route = (routes.get(path) ?? Array.from(routes.values()).find(route => {
-                        if (path === '/' && route.default === true) {
-                            return true;
-                        }
-                    }));
-                    const host = request.host;
-                    const info = socketKey(request.socket);
-                    if (route?.wss) {
-                        socket.removeListener('error', onSocketError);
-                        const wss = route.wss;
-                        if (route.maxConnections !== undefined && wss.clients?.size >= route.maxConnections) {
-                            logger.warn(`${info} dropping ws connection request from ${host} on ${path}. max connections exceeded.`);
-                            socket.destroy();
-                            return;
-                        }
-
-                        const origin = request.headers['origin'];
-                        if (!acceptsOrigin(origin, route.originFilters)) {
-                            logger.info(`${info} dropping ws connection request from ${host} on ${path}. origin ${origin ?? '<missing>'}`);
-                            socket.destroy();
-                            return;
-                        }
-                        if (logger.enabledFor('debug')) {
-                            logger.debug(`${info} accepted new ws connection request from ${host} on ${path}`);
-                        }
-
-                        wss.handleUpgrade(req, socket, head, (ws) => {
-                            ws.on('pong', () => ws['connected'] = true);
-                            ws.on('ping', () => {
-                            });
-                            wss.emit('connection', ws, req);
-                        });
-                    } else {
-                        logger.warn(`${info} rejected upgrade request from ${host} on ${path}`);
-                        socket.destroy();
-                    }
-                } catch (err) {
-                    logger.error(`upgrade error: ${err}`, err);
-                }
-            })
-            .on('close', async () => {
-                logger.info(`http server closed.`);
-            });
-        try {
-            const {value: port} = ports.next();
-            server.listen(port, host);
-        } catch (e) {
-            logger.error(`error starting web socket server`, e);
-            reject(e instanceof Error ? e : new Error(`listen failed: ${e}`));
-        }
-    });
-    const server = await serverP;
-    return new class implements GatewayServer.Server {
-        readonly gateway = gw;
-
-        async close(): Promise<void> {
-            for (const [path, route] of routes) {
-                try {
-                    if (route.close) {
-                        await route.close();
-                    }
-                    logger.info(`stopping ws server for [${path}]. clients: ${route.wss?.clients?.size ?? 0}`);
-                    route.wss?.clients?.forEach(client => {
-                        client.terminate();
-                    });
-                    route.wss?.close();
-                } catch (e) {
-                    logger.warn(`error closing route ${path}`, e);
-                }
-            }
-            await promisify(cb => {
-                server.closeAllConnections();
-                server.close(cb);
-            });
-            if (monitor) {
-                await monitoring.stop(monitor);
-            }
-        }
-    }
-
-}

package/src/utils.ts

@@ -1,10 +0,0 @@
-import {type Socket} from 'node:net';
-
-export function socketKey(socket: Socket): string {
-    const remoteIp = socket.remoteAddress;
-    if (!remoteIp) {
-        throw new Error('Socket has no remote address');
-    }
-    return `${remoteIp}:${socket.remotePort}`;
-}
-