@interopio/gateway-server 0.4.0-beta

package/src/server/exchange.ts

@@ -0,0 +1,379 @@
+import {
+    HeaderValue,
+    HeaderValues,
+    HttpRequest, HttpResponse,
+    MutableHttpHeaders,
+    ReadonlyHttpHeaders,
+    ServerHttpRequest,
+    ServerHttpResponse,
+    WebExchange
+} from './types.js';
+import http from 'node:http';
+import http2 from 'node:http2';
+
+function requestToProtocol(request: ServerHttpRequest, defaultProtocol: string): string {
+    let proto = request.headers.get('x-forwarded-proto');
+
+    if (Array.isArray(proto)) {
+        proto = proto[0];
+    }
+    if (proto !== undefined) {
+        return (proto as string).split(',', 1)[0].trim();
+    }
+    return defaultProtocol;
+}
+
+function requestToHost(request: ServerHttpRequest, defaultHost?: string): string | undefined {
+    let host = request.headers.get('x-forwarded-for');
+    if (host === undefined) {
+        host = request.headers.get('x-forwarded-host');
+        if (Array.isArray(host)) {
+            host = host[0];
+        }
+        if (host) {
+            const port = request.headers.one('x-forwarded-port');
+            if (port) {
+                host = `${host}:${port}`;
+            }
+        }
+        if (host === undefined) {
+            host = request.headers.one('host');
+        }
+    }
+    if (Array.isArray(host)) {
+        host = host[0];
+    }
+    if (host) {
+        return (host as string).split(',', 1)[0].trim();
+    }
+
+
+
+    return defaultHost;
+}
+
+export class HttpServerRequest implements ServerHttpRequest {
+    private _body: Promise<Blob> | undefined;
+    private _url: URL | undefined;
+    private readonly _headers: ReadonlyHttpHeaders;
+    constructor(readonly _req: http.IncomingMessage) {
+        this._headers = new IncomingMessageHeaders(_req);
+    }
+
+    get http2(): boolean {
+        return this._req.httpVersionMajor >= 2;
+    }
+
+    get headers() {
+        return this._headers;
+    }
+
+    get path() {
+        return this.URL?.pathname;
+    }
+
+    get URL() {
+        this._url ??= new URL(this._req.url!, `${this.protocol}://${this.host}`);
+        return this._url;
+    }
+    get query() {
+        return this.URL?.search;
+    }
+
+    get method() {
+        return this._req.method;
+    }
+
+    get host() {
+        let dh: string | undefined = undefined;
+        if (this._req.httpVersionMajor >= 2) {
+            dh = (this._req?.headers as http2.IncomingHttpHeaders)[':authority'];
+        }
+        if (dh === undefined) {
+            dh = this._req?.socket.remoteAddress;
+        }
+        return requestToHost(this, dh);
+    }
+
+    get protocol() {
+        let dp: string | undefined = undefined;
+        if (this._req.httpVersionMajor > 2) {
+            dp = (this._req.headers as http2.IncomingHttpHeaders)[':scheme'];
+        }
+        if (dp === undefined) {
+            dp = this._req?.socket['encrypted'] ? 'https' : 'http'
+        }
+        return requestToProtocol(this, dp);
+    }
+
+    get socket() {
+        return this._req.socket;
+    }
+
+    get body() {
+        this._body ??= new Promise((resolve, reject) => {
+            const chunks: Uint8Array[] = [];
+            this._req
+                .on('error', (err: Error) => reject(err))
+                .on('data', (chunk) => chunks.push(chunk))
+                .on('end', () => {
+                    resolve(new Blob(chunks));
+                });
+        });
+        return this._body;
+    }
+
+    get text() {
+        return this.body.then(async (blob) => await blob.text());
+    }
+
+    get json() {
+        return this.body.then(async (blob) => {
+            const json = JSON.parse(await blob.text());
+            return json;
+            // try {
+            // } catch (e) {
+            //     reject(e instanceof Error ? e : new Error(`parse failed :${e}`));
+            // }
+        });
+    }
+}
+
+class IncomingMessageHeaders implements ReadonlyHttpHeaders {
+    constructor(private readonly _msg: http.IncomingMessage) {
+    }
+
+    has(name: string): boolean {
+        return this._msg.headers[name] !== undefined;
+    }
+
+    get(name: string): string | (readonly string[]) | undefined {
+        return this._msg.headers[name];
+    }
+
+    list(name: string): string[] {
+        return toList(this._msg.headers[name]);
+    }
+
+    one(name: string): string | undefined {
+        const value = this._msg.headers[name];
+        if (Array.isArray(value)) {
+            return value[0];
+        }
+        return value;
+    }
+    keys() {
+        return Object.keys(this._msg.headers).values();
+    }
+}
+
+class OutgoingMessageHeaders implements MutableHttpHeaders {
+    constructor(private readonly _msg: http.OutgoingMessage) {
+    }
+
+    has(name: string): boolean {
+        return this._msg.hasHeader(name);
+    }
+
+    keys() {
+        return this._msg.getHeaderNames().values();
+    }
+
+    get(name: string): HeaderValues {
+        return this._msg.getHeader(name);
+    }
+
+    one(name: string): HeaderValue {
+        const value = this._msg.getHeader(name);
+        if (Array.isArray(value)) {
+            return value[0];
+        }
+        return value;
+    }
+
+    set(name: string, value: HeaderValues): this {
+        if (!this._msg.headersSent) {
+            if (Array.isArray(value)) {
+                value = value.map(v => typeof v === 'number' ? String(v) : v);
+            } else if (typeof value === 'number') {
+                value = String(value);
+            }
+
+            if (value) {
+                this._msg.setHeader(name, value);
+            }
+            else {
+                this._msg.removeHeader(name);
+            }
+        }
+        return this;
+    }
+
+    add(name: string, value: string | (readonly string[])): this {
+        if (!this._msg.headersSent) {
+            this._msg.appendHeader(name, value);
+        }
+        return this;
+    }
+
+    list(name: string): string[] {
+        const values = this.get(name);
+        return toList(values);
+    }
+}
+
+export class HttpServerResponse implements ServerHttpResponse {
+    private readonly _headers: MutableHttpHeaders;
+    constructor(readonly _res: http.ServerResponse) {
+        this._headers = new OutgoingMessageHeaders(_res);
+    }
+
+    get statusCode(): number {
+        return this._res.statusCode;
+    }
+
+    set statusCode(value: number) {
+        if (this._res.headersSent) {
+            return;
+        }
+        this._res.statusCode = value;
+    }
+
+    get headers() {
+        return this._headers;
+    }
+}
+
+export class DefaultWebExchange<Request extends ServerHttpRequest, Response extends ServerHttpResponse> extends WebExchange<Request, Response> {
+    constructor(readonly request: Request, readonly response: Response) {
+        super();
+    }
+}
+
+function toList(values: number | string | (readonly string[]) | undefined): string[] {
+    if (typeof values === 'string') {
+        values = [values];
+    }
+    if (typeof values === 'number') {
+        values = [String(values)];
+    }
+    const list: string[] = [];
+    if (values) {
+        for (const value of values) {
+            if (value) {
+                list.push(...parseHeader(value));
+            }
+        }
+    }
+    return list;
+}
+
+function parseHeader(value: string): string[] {
+    const list: string[] = [];
+    {
+        let start = 0;
+        let end = 0;
+
+        for (let i = 0; i < value.length; i++) {
+            switch (value.charCodeAt(i)) {
+                case 0x20: // space
+                    if (start === end) {
+                        start = end = i + 1;
+                    }
+                    break;
+                case 0x2c: // comma
+                    list.push(value.slice(start, end));
+                    start = end = i + 1;
+                    break;
+                default:
+                    end = end + 1;
+                    break;
+            }
+        }
+        list.push(value.slice(start, end));
+    }
+
+    return list;
+}
+
+export class MapHttpHeaders extends Map<string, (readonly string[])> implements MutableHttpHeaders {
+
+    get(name: string) {
+        return super.get(name.toLowerCase());
+    }
+
+    one(name: string): string | undefined {
+        return this.get(name)?.[0];
+    }
+
+    list(name: string) {
+        const values = super.get(name.toLowerCase());
+        return toList(values);
+    }
+
+    set(name: string, value: number | string | (readonly string[]) | undefined): this {
+        if (typeof value === 'number') {
+            value = String(value);
+        }
+        if (typeof value === 'string') {
+            value = [value];
+        }
+        if (value) {
+            return super.set(name.toLowerCase(), value);
+        }
+        else {
+            super.delete(name.toLowerCase());
+            return this;
+        }
+    }
+
+    add(name: string, value: string | (readonly string[])) {
+        const prev = super.get(name.toLowerCase());
+        if (typeof value === 'string') {
+            value = [value];
+        }
+        if (prev) {
+            value = prev.concat(value);
+        }
+        this.set(name, value);
+        return this;
+    }
+}
+
+export class MockHttpRequest implements HttpRequest<MutableHttpHeaders> {
+    private _body?: Blob;
+    readonly headers = new MapHttpHeaders();
+
+    constructor(private readonly url: URL, method?: string) {
+        this.method = method ?? 'GET';
+        this.headers.set('Host', url.hostname);
+        this.path = url?.pathname ?? '/';
+    }
+    method: string;
+    path: string;
+
+    get host() {
+        return requestToHost(this, this.url.host);
+    }
+    get protocol() {
+        return requestToProtocol(this, this.url.protocol.slice(0, -1));
+    }
+
+    get body(): Promise<Blob> {
+        const body = this._body;
+        return body ? Promise.resolve(body): Promise.reject(new Error(`no body set`));
+    }
+    set body(value: Blob) {
+        this._body = value;
+    }
+
+    get URL() {
+        return new URL(this.path, `${this.protocol}://${this.host}`);
+    }
+}
+
+export class MockHttpResponse implements HttpResponse<MutableHttpHeaders> {
+    statusCode!: number;
+    headers = new MapHttpHeaders();
+
+}

package/src/server/monitoring.ts

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,79 @@
+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,
+        }
+    }
+}