@interopio/gateway-server 0.4.0-beta

package/gateway-server.d.ts

@@ -0,0 +1,69 @@
+import {IOGateway} from '@interopio/gateway';
+import {FilePublisherConfig} from '@interopio/gateway/metrics/publisher/file';
+
+export default GatewayServer.Factory;
+
+export namespace GatewayServer {
+    export const Factory: (options: ServerConfig) => Promise<Server>;
+    export type SslConfig = {key?: string, cert?: string, ca?: string};
+    export type OriginFilters = {
+        non_matched?: IOGateway.Filtering.Action
+        missing?: IOGateway.Filtering.Action
+        block?: IOGateway.Filtering.Matcher[]
+        allow?: IOGateway.Filtering.Matcher[]
+        /**
+         * @deprecated
+         * @see block
+         */
+        blacklist?: IOGateway.Filtering.Matcher[]
+        /**
+         * @deprecated
+         * @see allow
+         */
+        whitelist?: IOGateway.Filtering.Matcher[]
+    }
+    export import LoggerConfig = IOGateway.Logging.LogConfig;
+    export type ServerConfig = {
+        /**
+         * The port to bind for network communication.
+         * Accepts a single valuer or a range.
+         * If a range is specified, will bind to the first available port in the range.
+         *
+         * Defaults to 0 - a random port.
+         */
+        port?: number | string
+        /**
+         * The network address.
+         */
+        host?: string
+        ssl?: SslConfig,
+
+        memory?: {
+            memory_limit?: number
+            dump_location?: string,
+            dump_prefix?: string,
+            report_interval?: number,
+            max_backups?: number,
+        },
+
+        gateway?: IOGateway.GatewayConfig & {
+            route?: string
+            ping?: number
+            origins?: OriginFilters
+            limits?: {
+                max_connections?: number
+            },
+        }
+        mesh?: {
+            timeout?: number // defaults to 60000
+            ping?: number // defaults to 30000
+        }
+        metrics?: {
+            file: FilePublisherConfig
+        }
+    }
+    export interface Server {
+        readonly gateway: IOGateway.Gateway
+        close(): Promise<void>
+    }
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@interopio/gateway-server",
+    "version": "0.4.0-beta",
+    "keywords": [
+        "gateway",
+        "server",
+        "mesh",
+        "io.connect",
+        "glue42",
+        "interop.io"
+    ],
+    "homepage": "https://interop.io/",
+    "author": {
+        "name": "interop.io",
+        "url": "https://interop.io/"
+    },
+    "license": "ISC",
+    "scripts": {
+        "start": "node .",
+        "test": "mocha test --recursive",
+        "prepare": "node scripts/prepare.mjs",
+        "build": "node scripts/build.mjs",
+        "prepack": "npm run build",
+        "clean": "node scripts/clean.mjs",
+        "coverage": "c8 --reporter=lcov --src=./src npm run test"
+    },
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./gateway-server.d.ts",
+            "import": "./dist/index.js",
+            "node": "./dist/index.cjs",
+            "require": "./dist/index.cjs"
+        },
+        "./metrics-rest": {
+            "import": "./dist/metrics-rest.js",
+            "node": "./dist/metrics-rest.cjs",
+            "require": "./dist/metrics-rest.cjs"
+        },
+        "./gateway-ent": {
+            "import": {
+                "types": "./types/gateway-ent.d.ts",
+                "default": "./dist/gateway-ent.js"
+            },
+            "node": "./dist/gateway-ent.cjs",
+            "require": "./dist/gateway-ent.cjs"
+        }
+    },
+    "main": "dist/index.js",
+    "types": "gateway-server.d.ts",
+    "type": "module",
+    "dependencies": {
+        "@interopio/gateway": "^0.9.0-beta",
+        "ws": "^8.18.2",
+        "http-cookie-agent": "^6.0.8",
+        "undici": "^6.21.3",
+        "tough-cookie": "^5.0.0"
+    },
+    "engines": {
+        "node": ">=18.17"
+    },
+    "devDependencies": {
+        "@types/transit-js": "^0.8.3",
+        "@types/ws": "^8.18.1"
+    }
+}

package/readme.md

@@ -0,0 +1,9 @@
+# io.Gateway Server
+
+## `@glue42/gateway-ent` compatibility
+
+This package aims to provide compatibility with `@glue42/gateway-ent` package
+
+```javascript
+import * as gw from '@interopio/gateway-server/gateway-ent';
+```

package/src/common/compose.ts

@@ -0,0 +1,40 @@
+
+// https://github.com/koajs/compose/blob/master/index.js
+/**
+ * @typeParam T - Type of context passed through the middleware
+ * @param middleware middleware stack
+ * @return {Callback}
+ */
+export function compose<T>(...middleware: (((ctx: T, next: () => Promise<void>) => Promise<void>) | ((ctx: T) => Promise<void>))[]): (ctx: T) => Promise<void> {
+    if (!Array.isArray(middleware)) {
+        throw new Error('middleware must be array!');
+    }
+    for (const fn of middleware) {
+        if (typeof fn !== 'function') {
+            throw new Error('middleware must be compose of functions!');
+        }
+    }
+    return async function (ctx: T, next?: () => Promise<void>) {
+        let index = -1;
+        return await dispatch(0);
+
+        async function dispatch(i: number): Promise<void> {
+            if (i < index) {
+                throw new Error('next() called multiple times');
+            }
+            index = i;
+            let fn: ((() => Promise<void>) | undefined) | ((c: T, n: () => Promise<void>) => Promise<void>);
+            if (i === middleware.length) {
+                fn = next;
+            }
+            else {
+                fn = middleware[i];
+            }
+            if (!fn) {
+                return;
+            }
+
+            await fn(ctx, dispatch.bind(null, i + 1));
+        }
+    }
+}

package/src/gateway/ent/config.ts

@@ -0,0 +1,174 @@
+import {GatewayServer} from '../../../gateway-server';
+import {IOGateway} from '@interopio/gateway';
+import { GatewayConfig, MetricsPublisherConfig } from '../../../types/gateway-ent';
+
+function toMetricsFilters(legacy?: MetricsPublisherConfig['filters']): IOGateway.MetricFilters | undefined {
+    if (legacy) {
+        const publishers = legacy.publishers.map(publisher => {
+            return {identity: publisher.publisher, metrics: publisher.metrics};
+        });
+        const non_matched = legacy['non-matched'];
+        return {publishers, non_matched};
+    }
+}
+
+function toMetricsPublisherConfig(legacy: MetricsPublisherConfig & {
+    conflation?: { 'max-datapoints-repo'?: number } & MetricsPublisherConfig['conflation']
+}): IOGateway.BasicMetricsPublisherConfig {
+    const filters = toMetricsFilters(legacy?.filters);
+    const conflation = toConflation(legacy?.conflation);
+    return {...legacy, filters, conflation};
+}
+
+function toConflation(legacy?: {
+    'max-datapoints-repo'?: number
+} & MetricsPublisherConfig['conflation']): IOGateway.BasicMetricsPublisherConfig['conflation'] | undefined {
+    if (legacy) {
+        return {interval: legacy.interval};
+    }
+}
+
+function toMetricsConfig(legacy: GatewayConfig['metrics']): IOGateway.GatewayConfig['metrics'] {
+    const metrics: IOGateway.GatewayConfig['metrics'] = {publishers: []};
+    legacy?.publishers?.forEach((publisher) => {
+        if (typeof publisher === 'string') {
+            if (publisher === 'rest') {
+                metrics.publishers.push('rest');
+                if (legacy.rest) {
+                    const conf = {...legacy.rest};
+                    const userAgent = conf["user-agent"];
+                    delete conf['user-agent'];
+                    const headers = {...conf.headers, ...(userAgent ? {'user-agent': userAgent} : {})};
+                    delete conf.headers;
+                    metrics.rest = {
+                        endpoint: conf.endpoint,
+                        headers: headers,
+                        ...toMetricsPublisherConfig(conf)
+                    };
+                    metrics.rest['publishFn'] ??= '@interopio/gateway-server/metrics-rest'
+                }
+            } else if (publisher === 'file') {
+                metrics.publishers.push('file');
+                if (legacy.file) {
+                    const conf = {...legacy.file};
+                    const status = conf['skip-status'] === undefined ? true : !conf['skip-status'];
+                    delete conf['skip-status'];
+                    metrics.file = {
+                        location: conf.location,
+                        status: status,
+                        ...toMetricsPublisherConfig(conf)
+                    };
+                }
+            } else {
+                // unsupported predefined type
+            }
+        } else {
+            const configuration = {...publisher.configuration};
+            const splitSize = configuration["split-size"];
+            delete configuration["split-size"];
+            const file = publisher['file'] as string;
+            const custom: IOGateway.CustomMetricsPublisherConfig = {
+                split_size: splitSize,
+                publisher: {file, configuration},
+                ...toMetricsPublisherConfig(configuration)
+            }
+            metrics.publishers.push(custom);
+        }
+    });
+    if (legacy?.filters) {
+        metrics.filters = toMetricsFilters(legacy?.filters);
+    }
+    return metrics;
+}
+type GatewayCluster = Required<GatewayConfig>['cluster'];
+type P2P = Required<GatewayCluster>['p2p'];
+
+function toCluster(legacy?: P2P): IOGateway.MeshConfig['cluster'] | undefined {
+    if (legacy?.directory) {
+        const legacyDirectory = legacy.directory;
+        const config: IOGateway.MeshConfig['cluster'] = {endpoint: legacy?.['endpoint']};
+        if (legacyDirectory.type === 'rest') {
+            let directory: IOGateway.RestMeshDirectoryConfig | undefined = undefined;
+            if (config.endpoint === undefined) {
+                config.endpoint = legacyDirectory.config!.directory_uri!;
+            }
+            else {
+                directory = {uri: legacyDirectory.config!.directory_uri};
+            }
+            if (legacyDirectory.config?.announce_interval) {
+                directory ??= {};
+                directory.interval = Number(legacyDirectory.config.announce_interval);
+            }
+            if (directory !== undefined) {
+                config.directory = directory;
+            }
+            return config;
+        }
+        else if (legacyDirectory.type === 'static') {
+            config.directory = {members : legacyDirectory.members ?? []};
+            return config;
+        }
+    }
+}
+
+function toMeshConfig(legacy: GatewayConfig['cluster']) {
+    const mesh: IOGateway.MeshConfig = {};
+    if (legacy?.configuration?.node_id) mesh.node = legacy.configuration.node_id;
+    if (legacy?.type === 'broker') mesh.broker = {endpoint: legacy.broker!.endpoint!};
+    if (legacy?.type === 'p2p') {
+        const cluster = toCluster(legacy.p2p);
+        if (cluster) {
+            mesh.cluster = cluster;
+        }
+    }
+    return mesh;
+}
+
+export function toServerConfig(config: GatewayConfig): GatewayServer.ServerConfig {
+    const gateway: GatewayServer.ServerConfig["gateway"] = {
+        route: config.route,
+        limits: config.limits,
+        origins: config.security?.origin_filters as GatewayServer.OriginFilters,
+        clients: config['clients'] ?? {inactive_seconds: 0, buffer_size: 100},
+        contexts: {
+            lifetime: 'retained',
+            visibility: [
+                {context: /___channel___.+/, restrictions: 'cluster'},
+                {context: /T42\..+/, restrictions: 'local'}
+            ]
+        },
+        methods: {
+            visibility: [
+                {method: /T42\..+/, restrictions: 'local'}
+            ]
+        },
+        peers: {
+            visibility: [
+                {domain: 'context', restrictions: 'cluster'},
+                {domain: 'agm', restrictions: 'local'}
+            ]
+        },
+        metrics: {publishers: []}
+    };
+    if (config.authentication?.token_ttl) gateway.token = {ttl: config.authentication?.token_ttl as number};
+    if (config['contexts']) {
+        gateway.contexts = config['contexts'];
+    }
+    if (config['methods']) {
+        gateway.methods = config['methods'];
+    }
+    if (config['peers']) {
+        gateway.peers = config['peers'];
+    }
+    if (config.cluster?.enabled) {
+        gateway.mesh = toMeshConfig(config.cluster);
+
+    }
+    if (config.metrics?.publishers) gateway.metrics = toMetricsConfig(config.metrics);
+    return {
+        port: config.port ?? 3434,
+        host: config.ip ?? config['host'],
+        memory: config['memory'],
+        gateway: gateway
+    };
+}

package/src/gateway/ent/index.ts

@@ -0,0 +1,18 @@
+import {toLogConfig} from './logging.js';
+import {ServerDelegate} from './server.js';
+import {toServerConfig} from './config.js';
+import {
+    Gateway,
+    GatewayConfig,
+    LogInfo,
+    LogLevel
+} from '../../../types/gateway-ent';
+import {IOGateway} from '@interopio/gateway';
+
+export function create(config: GatewayConfig): Gateway {
+    return new ServerDelegate(toServerConfig(config));
+}
+
+export function configure_logging(config?: { level: LogLevel, appender?: (info: LogInfo) => void }) {
+    IOGateway.Logging.configure(toLogConfig(config));
+}

package/src/gateway/ent/logging.ts

@@ -0,0 +1,89 @@
+import {LogInfo, LogLevel} from '@interopio/gateway-server/gateway-ent';
+import {IOGateway} from '@interopio/gateway';
+import {format} from 'node:util';
+
+class LogInfoAdapter implements LogInfo {
+    private _parsed?: { err?: Error, msg: string };
+    private _timestamp?: string;
+    private _output?: string;
+
+    constructor(private readonly event: IOGateway.Logging.LogEvent) {
+    }
+
+    private parsed(): { err?: Error, msg: string } {
+        if (this._parsed === undefined) {
+            let err: Error | undefined = undefined;
+            let vargs = this.event.data;
+            if (this.event.data[0] instanceof Error) {
+                err = this.event.data[0];
+                vargs = vargs.slice(1);
+            }
+            const msg = format(this.event.message, ...vargs);
+            this._parsed = {err, msg};
+        }
+        return this._parsed;
+    }
+
+    get time(): Date {
+        return this.event.time;
+    }
+
+    get level(): LogLevel {
+        return this.event.level;
+    }
+
+    get namespace() {
+        return this.event.name;
+    }
+
+    get file(): string {
+        return undefined as unknown as string;
+    }
+
+    get line(): number {
+        return undefined as unknown as number;
+    }
+
+    get message(): string {
+        return this.parsed().msg;
+    }
+
+    get stacktrace(): Error | undefined {
+        return this.parsed().err;
+    }
+
+    private get timestamp(): string {
+        if (this._timestamp === undefined) {
+            this._timestamp = this.time.toISOString();
+        }
+        return this._timestamp;
+    }
+
+    get output(): string {
+        if (this._output === undefined) {
+            const err = this.parsed().err;
+            const stacktrace = err ? `\n${err.stack ?? err}` : '';
+            this._output = `${this.timestamp} ${this.level.toUpperCase()} [${this.namespace}] - ${this.message}${stacktrace}`;
+        }
+        return this._output;
+    }
+}
+
+export function toLogConfig(config?: { level?: LogLevel; appender?: (info: LogInfo) => void }): IOGateway.Logging.LogConfig {
+    let level: Exclude<LogLevel, 'report' | 'fatal'> = 'info';
+    if (config?.level) {
+        if (config.level === 'fatal') {
+            level = 'error';
+        } else if (config.level !== 'report') {
+            level = config.level;
+        }
+    }
+    const result: IOGateway.Logging.LogConfig = {level};
+    const appenderFn = config?.appender;
+    if (appenderFn) {
+        result.appender = (event: IOGateway.Logging.LogEvent) => {
+            appenderFn(new LogInfoAdapter(event));
+        };
+    }
+    return result;
+}

package/src/gateway/ent/server.ts

@@ -0,0 +1,34 @@
+import {Gateway, GatewayClient, GatewayMessage} from '@interopio/gateway-server/gateway-ent';
+import {GatewayServer} from '@interopio/gateway-server';
+
+export class ServerDelegate implements Gateway {
+    private server?: GatewayServer.Server;
+
+    constructor(private readonly config: GatewayServer.ServerConfig) {
+    }
+
+    async connect(cb: (client: GatewayClient, msg: GatewayMessage) => void): Promise<GatewayClient> {
+        if (!this.server) {
+            throw new Error(`not started`);
+        }
+        const client = await this.server.gateway.connect((c, m) => cb(c as unknown as GatewayClient, m as GatewayMessage));
+        return client as unknown as GatewayClient;
+    }
+
+    info(): { endpoint: string } {
+        return this.server?.gateway.info() as { endpoint: string };
+    }
+
+    async start(): Promise<Gateway> {
+        if (!this.server) {
+            this.server = await GatewayServer.Factory(this.config);
+        }
+        return this;
+    }
+
+    async stop(): Promise<Gateway> {
+        await this.server?.close();
+        delete this.server;
+        return this;
+    }
+}

package/src/gateway/metrics/rest.ts

@@ -0,0 +1,20 @@
+import * as rest from '@interopio/gateway/metrics/publisher/rest';
+import {IOGateway} from '@interopio/gateway';
+import {CookieAgent} from 'http-cookie-agent/undici';
+import {CookieJar} from 'tough-cookie';
+
+export const fetchWithCookies = (existing?: rest.Fetch): rest.Fetch => {
+    const fetchFn = existing ?? rest.fetchWithTimeout();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const jar: any = new CookieJar();
+    const dispatcher = new CookieAgent({cookies: {jar}});
+    return async (endpoint: string | URL, request: Omit<RequestInit, 'signal'>, timeout: number) => {
+        const requestWithDispatcher = {...request, dispatcher};
+        return await fetchFn(endpoint, requestWithDispatcher, timeout);
+    }
+}
+export const name = rest.name;
+
+export function create(cfg: rest.RestPublisherConfig, logger: IOGateway.Logging.Logger) {
+    return rest.create({...cfg, fetch: fetchWithCookies(cfg.fetch)}, logger);
+}

package/src/gateway/ws/core.ts

@@ -0,0 +1,90 @@
+import * as ws from 'ws';
+import getLogger from '../../logger.js';
+import {socketKey} from '../../utils.js';
+import {HttpServerRequest} from '../../server/exchange.js';
+import {IOGateway} from '@interopio/gateway';
+import GatewayEncoders = IOGateway.Encoding;
+
+const log = getLogger('ws');
+const codec = GatewayEncoders.json<IOGateway.Message>();
+
+function initClient(this: IOGateway.Gateway, key: string, socket: ws.WebSocket, host?: string): IOGateway.GatewayClient<string> | undefined {
+    const opts = {
+        key,
+        host,
+        codec,
+        onPing: () => {
+            socket.ping((err?: Error) => {
+                if (err) {
+                    log.warn(`failed to ping ${key}`, err);
+                }
+                else {
+                    log.info(`ping sent to ${key}`);
+                }
+            });
+        },
+        onDisconnect: (reason: 'inactive' | 'shutdown') => {
+            switch (reason) {
+                case 'inactive': {
+                    log.warn(`no heartbeat (ping) received from ${key}, closing socket`);
+                    socket.close(4001, 'ping expected');
+                    break;
+                }
+                case 'shutdown': {
+                    socket.close(1001, 'shutdown');
+                    break;
+                }
+            }
+        }
+    };
+    try {
+        return this.client((data) => socket.send(data), opts);
+    } catch (err) {
+        log.warn(`${key} failed to create client`, err);
+    }
+}
+
+async function create(this: IOGateway.Gateway, server: {endpoint: string, wss: ws.WebSocketServer}): Promise<{ close: () => Promise<void> }> {
+    log.info('start gateway');
+    await this.start({endpoint: server.endpoint});
+
+    server.wss
+        .on('error', (err: Error) => {
+            log.error('error starting the gateway websocket server', err);
+        })
+        .on('connection', (socket, req) => {
+            const request = new HttpServerRequest(req);
+            const key = socketKey(request.socket);
+            const host = request.host;
+            log.info(`${key} connected on gw from ${host}`);
+            const client = initClient.call(this, key, socket);
+            if (!client) {
+                log.error(`${key} gw client init failed`);
+                socket.terminate();
+                return;
+            }
+            socket.on('error', (err: Error) => {
+                log.error(`${key} websocket error: ${err}`, err);
+            });
+            socket.on('message', (data, _isBinary) => {
+                if (Array.isArray(data)) {
+                    data = Buffer.concat(data);
+                }
+                // JSON.parse will invoke abstract operation ToString (coerce it) prior parsing (https://262.ecma-international.org/5.1/#sec-15.12.2)
+                client.send(data as unknown as string);
+
+            });
+            socket.on('close', (code) => {
+                log.info(`${key} disconnected from gw. code: ${code}`);
+                client.close();
+            });
+        });
+    return {
+        close: async () => {
+            server.wss.close();
+            await this.stop();
+        }
+    }
+}
+
+export default create;

package/src/index.ts

@@ -0,0 +1,3 @@
+import * as GatewayServer from './server.js';
+export {GatewayServer};
+export default GatewayServer.Factory;

package/src/logger.ts

@@ -0,0 +1,6 @@
+import {IOGateway} from '@interopio/gateway';
+export import Logger = IOGateway.Logging.Logger;
+
+export default function getLogger(name: string): Logger {
+    return IOGateway.Logging.getLogger(`gateway.server.${name}`);
+}