@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/net/InboundConnectionInitiator.ts

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

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

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