@interopio/bridge 0.0.1-alpha

package/src/net/InboundConnectionInitiator.ts

@@ -0,0 +1,150 @@
+import {type Address, addressAsString} from '../cluster/Address.ts';
+import {createServer, type Server, type Socket} from 'node:net';
+import {deferred, type DeferredPromise} from '../utils/promise.ts';
+import {type InboundConnectionSettings} from './InboundConnection.ts';
+import getLogger from '../logging.ts';
+import {adopt, type ByteBuffer} from '../utils/buffer.ts';
+import {Accept, Initiate} from './HandshakeProtocol.ts';
+import {writeAndFlush} from './internal/AsyncSocketPromise.ts';
+import {createCrc, createUnprotected, type FrameDecoder} from './FrameDecoder.ts';
+import {globalByteBufferAllocator} from './ByteBufferAllocator.ts';
+
+const logger = getLogger('net.inbound.initiator');
+
+function addressId(address: Address, realAddress: {host: string, type: 4 | 6, port: number}) {
+    let result = addressAsString(address);
+    if ((address.address.address !== realAddress.host) || (address.port !== realAddress.port)) {
+        result += ` (${addressAsString(realAddress)})`;
+    }
+    return result;
+}
+
+class Handler {
+
+    private readonly settings: InboundConnectionSettings;
+    private socket: Socket;
+    private initiate?: Initiate;
+    private handshakeTimeoutId: ReturnType<typeof setTimeout>;
+
+    constructor(settings: InboundConnectionSettings) {
+        this.settings = settings;
+    }
+
+    private onData: (data: Buffer) => void;
+    private onError: (error: Error) => void;
+
+
+    activate(socket: Socket) {
+        this.socket = socket;
+        const remoteAddress: Pick<Address, 'host' | 'port' | 'type'> = {
+            host: socket.remoteAddress,
+            port: socket.remotePort,
+            type: socket.remoteFamily === 'IPv6' ? 6 : 4
+        };
+        this.handshakeTimeoutId = setTimeout(() => {
+            logger.error(`timeout handshake with ${addressId(this.initiate?.from, remoteAddress)}`);
+            this.failHandshake();
+        }, this.settings.handshakeTimeout ?? 30000);
+        this.onData = (data: Buffer) => {
+            if (this.initiate) {
+                throw new Error(`should not receive data after handshake: ${this.initiate}`);
+            }
+            this.acceptInitiate(adopt(data));
+        }
+        this.onError = (error: Error) => {
+            logger.error(`failed to properly handshake with peer ${socket.remoteAddress}`, error);
+            try {
+                this.failHandshake();
+            } catch (e) {
+                logger.error(`failed to fail handshake: ${e}`);
+            }
+        }
+        socket.on('data', this.onData);
+        socket.on('error', this.onError);
+    }
+
+    private failHandshake() {
+        clearTimeout(this.handshakeTimeoutId);
+        this.socket.off('data', this.onData);
+        this.socket.off('error', this.onError);
+        this.socket.destroy();
+    }
+
+    private acceptInitiate(input: ByteBuffer) {
+        this.initiate = Initiate.maybeDecode(input);
+        if (!this.initiate) {
+            return;
+        }
+
+        if (logger.enabledFor('debug')) {
+            logger.debug(`connection version ${this.initiate.acceptVersions.max} (min ${this.initiate.acceptVersions.min}) from ${addressAsString(this.initiate.from)}`);
+        }
+
+        const acceptVersions = this.settings.acceptVersions ?? {min: 13, max: 13};
+        const useVersion = Math.max(acceptVersions.min, Math.min(acceptVersions.max, this.initiate.acceptVersions.max));
+
+        const buffer = new Accept(useVersion, acceptVersions.max).encode();
+
+        const socketPromise = writeAndFlush(this.socket, {selfContained: true, buffer});
+        socketPromise.promise?.catch((err) => {
+            this.onError(err);
+        });
+
+        if (this.initiate.acceptVersions.min > acceptVersions.max) {
+            logger.info(`peer ${this.socket.remoteAddress} only supports messaging versions higher (${this.initiate.acceptVersions.min}) than this node supports (${acceptVersions.min})`);
+            this.failHandshake();
+        }
+        else if (this.initiate.acceptVersions.max < acceptVersions.min) {
+            logger.info(`peer ${this.socket.remoteAddress} only supports messaging versions lower (${this.initiate.acceptVersions.max}) than this node supports (${acceptVersions.min})`);
+            this.failHandshake();
+        }
+
+        else {
+            clearTimeout(this.handshakeTimeoutId);
+
+            const allocator = globalByteBufferAllocator;
+            let frameDecoder: FrameDecoder;
+            switch (this.initiate.framing) {
+                case 'UNPROTECTED': {
+                    frameDecoder = createUnprotected(allocator);
+                    break;
+                }
+                case 'CRC': {
+                    frameDecoder = createCrc(allocator);
+                    break;
+                }
+                default: {
+                    throw new Error(`unknown framing ${this.initiate.framing}`);
+                }
+            }
+            this.settings.handlers(this.initiate.from).handle(frameDecoder, this.socket, useVersion);
+            this.socket.off('data', this.onData);
+        }
+    }
+
+}
+
+
+function inboundSocketInitiator(settings: InboundConnectionSettings, connections: Socket[]): DeferredPromise<Server> {
+    const {host, port} = settings.bindAddress;
+    logger.info('listening on %s:%d', host, port);
+    const backlog = 1 << 9;
+
+    const s = createServer({keepAlive: true, noDelay: true}, (socket: Socket) => {
+        const handler = new Handler(settings);
+        connections.push(socket);
+        handler.activate(socket);
+    });
+    const d = deferred<Server>((cb: (err?: Error) => void) => {
+        s.close(cb);
+        return true;
+    });
+    s.listen(port, host, backlog, () => {
+        d.success(s);
+    });
+    return d;
+}
+
+export function bind(settings: InboundConnectionSettings, connections: Socket[]) {
+    return inboundSocketInitiator(settings, connections);
+}

package/src/net/InboundMessageHandler.ts

@@ -0,0 +1,377 @@
+import {Socket} from 'node:net';
+import {type Address, addressAsString} from '../cluster/Address.ts';
+import {adopt} from '../utils/buffer.ts';
+import type {Unit} from '../config/Duration.ts';
+import {type Message, type MessageHeader, serializer} from './Message.ts';
+import type {ShareableBytes} from './ShareableBytes.ts';
+import type {CorruptedFrame, Frame, FrameDecoder, ValidFrame} from './FrameDecoder.ts';
+import {approximateClock} from '../utils/clock.ts';
+import {ByteBufferInput} from '../io/VersionedSerializer.ts';
+import getLogger from '../logging.ts';
+
+const logger = getLogger('net.inbound.handler');
+
+interface InboundMessageCallbacks {
+
+    onHeaderArrived(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onArrived(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onArrivedExpired(messageSize: number, header: MessageHeader, wasCorrupt: boolean, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onArrivedCorrupt(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onClosedBeforeArrival(messageSize: number, header: MessageHeader, bytesReceived: number, wasCorrupt: boolean, wasExpired: boolean): void;
+
+    onFailedDeserialize(messageSize: number, header: MessageHeader, error: Error): void;
+
+    onDispatched(messageSize: number, header: MessageHeader): void;
+
+    onExecuting(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onProcessed(messageSize: number, header: MessageHeader): void;
+
+    onExpired(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void;
+
+    onExecuted(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit): void
+}
+
+abstract class ProcessMessage {
+    private readonly handler: InboundMessageHandler;
+
+    constructor(handler: InboundMessageHandler) {
+        this.handler = handler;
+    }
+
+    run(): void {
+        const header = this.header;
+        const approxStartTimeNs = approximateClock().now();
+        const expired = !approximateClock().isBefore(header.expiresAtNanos, approxStartTimeNs);
+
+        let processed = false;
+
+        try {
+            this.handler.callbacks.onExecuting(this.size, header, approxStartTimeNs - header.createdAtNanos, 'nanoseconds');
+
+            if (expired) {
+                this.handler.callbacks.onExpired(this.size, header, approxStartTimeNs - header.createdAtNanos, 'nanoseconds');
+                return;
+            }
+            const message = this.provideMessage();
+            if (message !== undefined) {
+                this.handler.consumer(message);
+                processed = true;
+                this.handler.callbacks.onProcessed(this.size, header);
+            }
+        } finally {
+            if (processed) {
+
+            } else {
+
+            }
+            this.releaseResources();
+
+            this.handler.callbacks.onExecuted(this.size, header, approximateClock().now() - approxStartTimeNs, 'nanoseconds');
+        }
+    }
+
+    abstract get size(): number;
+
+    abstract get header(): MessageHeader;
+
+    abstract provideMessage(): Message<unknown> | undefined;
+
+    releaseResources(): void {
+        // release resources if needed
+    }
+
+}
+
+
+class ProcessSmallMessage extends ProcessMessage {
+    private readonly message: Message<unknown>;
+    readonly size: number;
+
+    constructor(handler: InboundMessageHandler, message: Message<unknown>, size: number) {
+        super(handler);
+        this.message = message;
+        this.size = size;
+    }
+
+    get header(): MessageHeader {
+        return this.message.header;
+    }
+
+    provideMessage(): Message<unknown> | undefined {
+        return this.message;
+    }
+}
+
+class InboundMessageHandler {
+    private readonly socket: Socket;
+    private readonly decoder: FrameDecoder;
+    private readonly self: Address;
+    private readonly peer: Address;
+    private readonly version: number;
+
+    readonly callbacks: InboundMessageCallbacks;
+    readonly consumer: (msg: Message<unknown>) => void;
+
+    constructor(decoder: FrameDecoder,
+                socket: Socket,
+                self: Address,
+                peer: Address,
+                version: number,
+                onClosed: (handler: InboundMessageHandler) => void,
+                callbacks: InboundMessageCallbacks,
+                consumer: (msg: Message<unknown>) => void) {
+        this.decoder = decoder;
+        this.socket = socket;
+        this.self = self;
+        this.peer = peer;
+        this.version = version;
+
+        this.callbacks = callbacks;
+        this.consumer = consumer;
+
+        this.decoder.activate((frame: Frame) => this.processFrame(frame));
+
+        socket.on('data', (data) => {
+            const buffer = adopt(data);
+            try {
+                this.decoder.receive(buffer);
+            } catch (e) {
+                this.exceptionCaught(e);
+            }
+        });
+        socket.on('error', (error) => {
+            this.exceptionCaught(error);
+        });
+    }
+
+    protected exceptionCaught(e: Error): void {
+        this.decoder.discard();
+        logger.error(`${this.id()} exception caught while processing inbound messages; terminating connection`, e);
+        this.socket.destroy();
+    }
+
+    private processFrame(frame: Frame): boolean {
+        if (frame.corrupted === true) {
+            this.processCorruptedFrame(frame);
+            return true;
+        } else {
+            return this.processValidFrame(frame);
+        }
+    }
+
+    private readonly received: { count: number, bytes: number } = {count: 0, bytes: 0};
+
+    private processOneContainedMessage(bytes: ShareableBytes): boolean {
+        const buffer = bytes.get();
+
+        const clock = approximateClock();
+
+        const nowNs = clock.now();
+        const header = serializer.extractHeader(buffer, this.peer, nowNs, this.version);
+        const timeElapsed = nowNs - header.createdAtNanos;
+        const size = serializer.inferMessageSize(buffer, buffer.position, buffer.limit, this.version);
+
+        if (!clock.isBefore(header.expiresAtNanos, nowNs)) {
+            this.callbacks.onHeaderArrived(size, header, timeElapsed, 'nanoseconds');
+            this.callbacks.onArrivedExpired(size, header, false, timeElapsed, 'nanoseconds');
+            this.received.count += 1;
+            this.received.bytes += size;
+            bytes.skipBytes(size);
+            return true;
+        }
+
+        this.callbacks.onHeaderArrived(size, header, timeElapsed, 'nanoseconds');
+        this.callbacks.onArrived(size, header, timeElapsed, 'nanoseconds');
+        this.received.count += 1;
+        this.received.bytes += size;
+
+        this.processSmallMessage(bytes, size, header);
+
+        return true;
+    }
+
+    private processSmallMessage(contents: ShareableBytes, size: number, header: MessageHeader): void {
+        const buffer = contents.get();
+        const begin = buffer.position;
+        const end = buffer.limit;
+
+        buffer.limit = begin + size;
+
+        let message: Message<unknown>;
+        const input = new ByteBufferInput(buffer, false);
+
+        try {
+            const m = serializer.deserialize(input, header, this.version);
+            if (input.available() > 0) {
+                throw new Error(`not all bytes consumed: expected ${size} actual: at least ${size - input.available()}`);
+            }
+            message = m;
+        }
+        catch (e) {
+            this.callbacks.onFailedDeserialize(size, header, e);
+            logger.error(`${this.id()} unexpected exception caught while deserializing the message`, e);
+        }
+        finally {
+            if (message === undefined) {
+                // this.releaseCapacity(size);
+            }
+            buffer.position = begin + size;
+            buffer.limit = end;
+        }
+
+        if (message) {
+            this.dispatch(new ProcessSmallMessage(this, message, size));
+        }
+    }
+
+    private dispatch(task: ProcessMessage): void {
+        const header = task.header;
+        this.callbacks.onDispatched(task.size, header);
+        setImmediate(() => {
+            try {
+                task.run();
+            } catch (e) {
+                logger.error(`${this.id()} unexpected exception caught while processing the message`, e);
+            }
+        });
+    }
+
+    private id(): string {
+        return `${addressAsString(this.peer)} -> ${addressAsString(this.self)}`;
+    }
+
+
+    private processFrameOfContainedMessage(bytes: ShareableBytes): boolean {
+        while (bytes.hasRemaining) {
+            if (!this.processOneContainedMessage(bytes)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private processValidFrame(frame: ValidFrame): boolean {
+        if (frame.selfContained) {
+            return this.processFrameOfContainedMessage(frame.contents);
+        }
+    }
+
+    private processCorruptedFrame(frame: CorruptedFrame): void {
+        if (!frame.recoverable) {
+            throw new Error(`invalid crc`);
+        }
+
+    }
+}
+
+export interface MessageConsumer {
+    next(message: Message<unknown>): void
+
+    fail(header: MessageHeader, error: Error): void
+}
+
+type HandlerProvider = (decoder: FrameDecoder,
+                        socket: Socket,
+                        self: Address,
+                        peer: Address,
+                        version: number,
+                        onClosed: (handler: InboundMessageHandler) => void,
+                        callbacks: InboundMessageCallbacks,
+                        consumer: MessageConsumer) => InboundMessageHandler;
+
+class InboundMessageHandlers {
+    private readonly self: Address;
+    private readonly peer: Address;
+    private readonly callbacks: InboundMessageCallbacks;
+    private readonly consumer: MessageConsumer;
+    private readonly provider: HandlerProvider;
+    private handlers = new Array<InboundMessageHandler>();
+
+    constructor(self: Address,
+                peer: Address,
+                consumer: MessageConsumer,
+                provider?: (decoder: FrameDecoder,
+                            socket: Socket,
+                            self: Address,
+                            peer: Address,
+                            version: number,
+                            onClosed: (handler: InboundMessageHandler) => void,
+                            callbacks: InboundMessageCallbacks,
+                            consumer: MessageConsumer) => InboundMessageHandler) {
+        this.self = self;
+        this.peer = peer;
+        this.consumer = consumer;
+        this.provider = provider ?? ((decoder: FrameDecoder, socket: Socket, self, peer, version: number, onClosed, callbacks, consumer) => new InboundMessageHandler(decoder, socket, self, peer, version, onClosed, callbacks, (msg) => consumer.next(msg)));
+        this.callbacks = InboundMessageHandlers.makeCallbacks(peer, consumer);
+    }
+
+    handle(decoder: FrameDecoder, socket: Socket, version: number): InboundMessageHandler {
+        const handler = this.provider(decoder, socket, this.self, this.peer, version, (handler) => {
+            this.onHandleClosed(handler);
+        }, this.callbacks, this.consumer);
+
+        this.handlers.push(handler);
+        return handler;
+    }
+
+    private onHandleClosed(handler: InboundMessageHandler): void {
+        this.handlers = this.handlers.filter(h => h !== handler);
+    }
+
+    static makeCallbacks(peer: Address, consumer: MessageConsumer): InboundMessageCallbacks {
+        return {
+            onHeaderArrived(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit) {
+                // no-op
+            },
+            onArrived(messageSize: number, header: MessageHeader, timeElapsed: bigint, timeUnit: Unit) {
+                // no-op
+            },
+            onArrivedExpired(messageSize: number, header: MessageHeader, wasCorrupt: boolean, timeElapsed: bigint, timeUnit: Unit) {
+                // no-op
+            },
+            onArrivedCorrupt: (messageSize, header, timeElapsed, timeUnit) => {
+                consumer.fail(header, new Error(`invalid crc`));
+            },
+            onClosedBeforeArrival: (messageSize, header, bytesReceived, wasCorrupt, wasExpired) => {
+                consumer.fail(header, new Error(`invalid crc`));
+            },
+            onExpired: (messageSize, header, timeElapsed, timeUnit) => {
+                // no-op
+            },
+            onFailedDeserialize: (messageSize, header, error: Error) => {
+                consumer.fail(header, error);
+            },
+            onDispatched: (messageSize, header) => {
+                // no-op
+            },
+            onExecuting: (messageSize, header, timeElapsed, timeUnit) => {
+                // no-op
+            },
+            onExecuted: (messageSize, header, timeElapsed, timeUnit) => {
+                // no-op
+            },
+            onProcessed: (messageSize, header) => {
+                // no-op
+            }
+        };
+    }
+}
+
+export function getInbound(from: Address, handlers: Map<Address, InboundMessageHandlers>, consumer: MessageConsumer, settings: {
+    bindAddress: Address
+}) {
+    let handler = handlers.get(from);
+    if (handler) {
+        return handler;
+    }
+    handler = new InboundMessageHandlers(settings.bindAddress, from, consumer);
+    handlers.set(from, handler);
+    return handler;
+}
+
+export {InboundMessageHandlers};

package/src/net/InboundSink.ts

@@ -0,0 +1,38 @@
+import type {MessageConsumer} from './InboundMessageHandler.ts';
+import {isFlagOn, type Message, type MessageHeader} from './Message.ts';
+import {forError} from '../error/RequestFailure.ts';
+import {fromId, type VerbHandlerContext} from './Action.ts';
+
+export class InboundSink implements MessageConsumer {
+    private readonly context: Pick<VerbHandlerContext, 'messaging' | 'messageFactory'>;
+    private readonly sink: (message: Message<unknown>) => void;
+
+    constructor(context: Pick<VerbHandlerContext, 'messaging' | 'messageFactory'>) {
+        this.context = context;
+        this.sink = (message: Message<unknown>) => {
+            const handler = message.header.verb().handler(this.context as VerbHandlerContext);
+            if (!handler) {
+                throw new Error(`No handler for verb ${fromId(message.header.verb().id)}`);
+            }
+            handler.doVerb(message);
+        }
+    }
+
+    fail(header: MessageHeader, error: Error): void {
+        if (isFlagOn(header, 'CALL_BACK_ON_FAILURE')) {
+            const to = header.from;
+            const response = this.context.messageFactory().failureResponse(header.seq, header.expiresAtNanos, forError(error));
+            this.context.messaging().send(response, to);
+        }
+    }
+
+    next(message: Message<unknown>) {
+        try {
+            this.sink(message);
+        } catch (e) {
+            this.fail(message.header, e as Error);
+            // todo maybe just log warning for some errors
+            throw e;
+        }
+    }
+}