@interopio/bridge 0.0.1-alpha

package/src/net/FrameDecoder.ts

@@ -0,0 +1,314 @@
+import {shareableBytes, type ShareableBytes} from './ShareableBytes.ts';
+import type {ByteBufferAllocator} from './ByteBufferAllocator.ts';
+import {type ByteBuffer} from '../utils/buffer.ts';
+import {computeCrc32, crc24} from '../utils/crc.ts';
+
+export type ValidFrame = { corrupted: false, size: number, selfContained: boolean, contents: ShareableBytes };
+export type CorruptedFrame
+    = { corrupted: true, recoverable: true, size: number, selfContained: boolean, readCrc: number, computedCrc: number }
+    | { corrupted: true, recoverable: false, readCrc: number, computedCrc: number };
+export type Frame = ValidFrame | CorruptedFrame;
+export type FrameProcessor = (frame: Frame) => boolean;
+const HEADER_LENGTH = 6;
+const TRAILER_LENGTH = 4;
+const HEADER_AND_TRAILER_LENGTH = HEADER_LENGTH + TRAILER_LENGTH;
+
+const TMP = new DataView(new ArrayBuffer(8));
+export function reverseBytes32(i: number): number {
+    TMP.setInt32(0, i);
+    return TMP.getInt32(0, true);
+}
+function reverseBytes64(i: bigint): bigint {
+    TMP.setBigInt64(0, i);
+    return TMP.getBigInt64(0, true);
+}
+
+// fill target from source up to targetPosition
+function copyToSize(source: ByteBuffer, target: ByteBuffer, targetPosition: number): boolean {
+    const length = targetPosition - target.position;
+    if (length < 0) {
+        return true;
+    }
+    const extra = source.remaining - length;
+    if (extra <= 0) {
+        target.setByteBuffer(source);
+        return false;
+    }
+    source.limit = source.position + length;
+    target.setByteBuffer(source);
+    source.limit = source.position + extra;
+    return true;
+ }
+
+function readHeader6b(frame: ByteBuffer, begin: number): bigint {
+    let header6b: bigint;
+    if (frame.limit - begin >= 8) {
+        header6b = frame.getBigInt64();
+        if (frame.order === 'big-endian') {
+            header6b = reverseBytes64(header6b);
+        }
+        header6b &= 0xffffffffffffn;
+    } else {
+        header6b = 0n;
+        for (let i = 0; i < HEADER_LENGTH; i++) {
+            header6b |= (BigInt(frame.getInt8(begin + i))) << BigInt(i * 8);
+        }
+    }
+    return header6b;
+}
+
+function isSelfContained(header6b: bigint): boolean {
+    return (header6b & BigInt(1 << 17)) !== 0n;
+}
+
+function payloadLength(header6b: bigint): number {
+    return Number(header6b & 0x0ffffffffn) & 0x1FFFF;
+}
+
+function headerCrc(header6b: bigint): number {
+    return Number(((header6b >> 24n) & 0x0ffffffffffn)) & 0xFFFFFF;
+}
+
+function verifyHeader6b(header6b: bigint): CorruptedFrame | undefined {
+    const computeLengthCrc = crc24(header6b, 3);
+    const readLengthCrc = headerCrc(header6b);
+    return readLengthCrc === computeLengthCrc ? undefined : {corrupted: true, recoverable: false, readCrc: readLengthCrc, computedCrc: computeLengthCrc};
+}
+
+
+abstract class FrameDecoder {
+    protected allocator: ByteBufferAllocator;
+
+    private readonly frames: Frame[] = [];
+    private active: boolean = false;
+
+    constructor(allocator: ByteBufferAllocator) {
+        this.allocator = allocator;
+    }
+    private processor: FrameProcessor = (frame) => {
+        throw new Error('processor not set')
+    };
+
+    activate(processor: FrameProcessor): void {
+        this.processor = processor;
+        this.active = true;
+    }
+
+    reactivate(): void {
+        if (this.active) {
+            throw new Error('already active');
+        }
+
+        if (this.deliver(this.processor)) {
+            this.active = true;
+        }
+    }
+
+    discard(): void {
+        this.active = false;
+        this.processor = (frame) => {throw new Error('frame processor closed')};
+        if (this._stash) {
+            const bytes = this._stash;
+            delete this._stash;
+            this.allocator.put(bytes);
+        }
+        while (this.frames.length > 0) {
+            const frame = this.frames.shift();
+            FrameDecoder.releaseFrame(frame);
+        }
+    }
+
+    private static isFrameConsumed(frame: Frame): boolean {
+        if (frame.corrupted === false) {
+            return !frame.contents.hasRemaining;
+        }
+        return true;
+    }
+
+    private static releaseFrame(frame: Frame): void {
+        if (frame.corrupted === false) {
+            frame.contents.release();
+        }
+        // else, corrupted frames are not released
+    }
+
+    private deliver(process: FrameProcessor): boolean {
+
+        let deliver = true;
+        while (deliver && this.frames.length > 0) {
+            const frame = this.frames[0];
+            deliver = process(frame);
+            if (deliver && !FrameDecoder.isFrameConsumed(frame)) {
+                throw new Error('frame not fully consumed');
+            }
+            if (deliver || FrameDecoder.isFrameConsumed(frame)) {
+                this.frames.shift();
+                FrameDecoder.releaseFrame(frame);
+            }
+        }
+        return deliver;
+    }
+
+    private decode(frames: Frame[], bytes: ShareableBytes): void {
+        this.doDecode(frames, bytes, HEADER_LENGTH);
+    }
+
+    private _stash: ByteBuffer;
+
+    private stash(input: ShareableBytes, stashLength: number, begin: number, length: number): void {
+        const out = this.allocator.getAtLeast(stashLength);
+        const array = new Uint8Array(length);
+        input.get().getUint8Array(array, begin, length);
+        out.setUint8Array(array);
+        out.position = length;
+        this._stash = out;
+    }
+
+    protected abstract readHeader(frame: ByteBuffer, begin: number): bigint
+
+    protected abstract verifyHeader(header: bigint): CorruptedFrame | undefined;
+
+    protected abstract frameLength(header: bigint): number;
+
+    protected abstract unpackFrame(frame: ShareableBytes, begin: number, end: number, header: bigint): Frame;
+
+    protected doDecode(frames: Frame[], newBytes: ShareableBytes, headerLength: number): void {
+        const input = newBytes.get();
+        try {
+            if (this._stash !== undefined) {
+                if (!copyToSize(input, this._stash, headerLength)) {
+                    return;
+                }
+                const header = this.readHeader(this._stash, 0);
+                const c = this.verifyHeader(header);
+                if (c !== undefined) {
+                    this.discard();
+                    frames.push(c);
+                    return;
+                }
+                const frameLength = this.frameLength(header);
+                this._stash = this.ensureCapacity(this._stash, frameLength);
+
+                if (!copyToSize(input, this._stash, frameLength)) {
+                    return;
+                }
+
+                const stashed = shareableBytes(this._stash);
+
+                this._stash.flip();
+                delete this._stash;
+
+                try {
+                    frames.push(this.unpackFrame(stashed, 0, frameLength, header));
+                } finally {
+                    stashed.release();
+                }
+            }
+
+            let begin = input.position;
+            const limit = input.limit;
+            while (begin < limit) {
+                const remaining = limit - begin;
+                if (remaining < headerLength) {
+                    this.stash(newBytes, headerLength, begin, remaining);
+                    return;
+                }
+
+                const header = this.readHeader(input, begin);
+                const c = this.verifyHeader(header);
+                if (c !== undefined) {
+                    frames.push(c);
+                    return;
+                }
+
+                const frameLength = this.frameLength(header);
+                if (remaining < frameLength) {
+                    this.stash(newBytes, frameLength, begin, remaining);
+                    return;
+                }
+
+                frames.push(this.unpackFrame(newBytes, begin, begin + frameLength, header));
+                begin += frameLength;
+            }
+        } finally {
+            newBytes.release();
+        }
+    }
+
+
+    receive(buffer: ByteBuffer) {
+        this.decode(this.frames, shareableBytes(buffer));
+        if (this.active) {
+            this.active = this.deliver(this.processor);
+        }
+    }
+
+    private ensureCapacity(buffer: ByteBuffer, capacity: number) {
+        if (buffer.capacity >= capacity) {
+            return buffer;
+        }
+        const newBuffer = this.allocator.getAtLeast(capacity);
+        buffer.flip();
+        newBuffer.setByteBuffer(buffer);
+        this.allocator.put(buffer);
+        return newBuffer;
+    }
+}
+
+class FrameDecoderCrc extends FrameDecoder {
+
+    protected readHeader(frame: ByteBuffer, begin: number): bigint {
+        return readHeader6b(frame, begin);
+    }
+
+    protected verifyHeader(header: bigint): CorruptedFrame | undefined {
+        return verifyHeader6b(header);
+    }
+
+    protected frameLength(header: bigint): number {
+        return payloadLength(header) + HEADER_AND_TRAILER_LENGTH;
+    }
+
+    protected unpackFrame(bytes: ShareableBytes, begin: number, end: number, header6b: bigint): Frame {
+        const input = bytes.get();
+        const selfContained = isSelfContained(header6b);
+        let readFullCrc = input.getInt32(end - TRAILER_LENGTH);
+        if (input.order === 'big-endian') {
+            readFullCrc = reverseBytes32(readFullCrc);
+        }
+        const computedCrc = computeCrc32(input, begin + HEADER_LENGTH, end - TRAILER_LENGTH);
+
+        if (computedCrc !== readFullCrc) {
+            return {corrupted: true, recoverable: true, size: end - begin, readCrc: readFullCrc, computedCrc, selfContained};
+        }
+
+        const contents = bytes.slice(begin + HEADER_LENGTH, end - TRAILER_LENGTH);
+        return {corrupted: false, contents, size: contents.remaining, selfContained};
+    }
+}
+
+class FrameDecoderUnprotected extends FrameDecoder {
+    protected readHeader(frame: ByteBuffer, begin: number): bigint {
+        return readHeader6b(frame, begin);
+    }
+    protected verifyHeader(header: bigint): CorruptedFrame | undefined {
+        return verifyHeader6b(header);
+    }
+    protected frameLength(header: bigint): number {
+        return payloadLength(header) + HEADER_LENGTH;
+    }
+
+    protected unpackFrame(bytes: ShareableBytes, begin: number, end: number, header6b: bigint): Frame {
+        const selfContained = isSelfContained(header6b);
+        const contents = bytes.slice(begin + HEADER_LENGTH, end);
+        return {corrupted: false, contents, size: end - begin, selfContained};
+    }
+}
+
+export type {FrameDecoder};
+export function createUnprotected(allocator: ByteBufferAllocator): FrameDecoder {
+    return new FrameDecoderUnprotected(allocator);
+}
+export function createCrc(allocator: ByteBufferAllocator): FrameDecoder {
+    return new FrameDecoderCrc(allocator);
+}

package/src/net/FrameEncoder.ts

@@ -0,0 +1,138 @@
+import {allocate, type ByteBuffer} from '../utils/buffer.ts';
+import {computeCrc32, crc24} from '../utils/crc.ts';
+import {reverseBytes32} from './FrameDecoder.ts';
+
+import {ChannelHandlerAdapter} from './internal/channel/ChannelHandlerAdapter.ts';
+
+const HEADER_LENGTH = 6;
+const TRAILER_LENGTH = 4;
+const HEADER_AND_TRAILER_LENGTH = HEADER_LENGTH + TRAILER_LENGTH;
+
+function put3b(frame: ByteBuffer, index: number, value: number) {
+    frame.setInt8(index, value);
+    frame.setInt8(index + 1, value >>> 8);
+    frame.setInt8(index + 2, value >>> 16);
+}
+
+function writeHeader(frame: ByteBuffer, selfContained: boolean, payloadLength: number) {
+    let header3b: bigint = BigInt(payloadLength);
+    if (selfContained) {
+        header3b |= BigInt(1 << 17);
+    }
+    const crc = crc24(header3b, 3);
+    put3b(frame, 0, Number(header3b));
+    put3b(frame, 3, crc);
+}
+
+abstract class FrameEncoder extends ChannelHandlerAdapter {
+    get allocator(): PayloadAllocator {
+        return (capacity: number, selfContained = true) => new Payload(selfContained, capacity);
+    }
+
+    write(payload: Payload) {
+        this.encode(payload.selfContained, payload.buffer);
+    }
+
+    abstract encode(selfContained:boolean, buffer: ByteBuffer): void;
+}
+
+class FrameEncoderUnprotected extends FrameEncoder {
+
+    get allocator(): PayloadAllocator {
+        return (capacity: number, selfContained = true) => new Payload(selfContained, capacity, HEADER_LENGTH);
+    }
+
+    encode(selfContained: boolean, frame: ByteBuffer) {
+        const frameLength = frame.remaining;
+        const dataLength = frameLength - HEADER_LENGTH;
+        if (dataLength >= 1 << 17) {
+            throw new Error(`maximum frame size 128KiB exceeded: ${dataLength}`);
+        }
+        writeHeader(frame, selfContained, dataLength);
+    }
+}
+
+class FrameEncoderCrc extends FrameEncoder {
+    get allocator(): PayloadAllocator {
+        return (capacity: number, selfContained = true) => new Payload(selfContained, capacity, HEADER_LENGTH, TRAILER_LENGTH);
+    }
+
+    encode(selfContained: boolean, frame: ByteBuffer) {
+        try {
+            const frameLength = frame.remaining;
+            const dataLength = frameLength - HEADER_AND_TRAILER_LENGTH;
+            if (dataLength >= 1 << 17) {
+                throw new Error(`maximum frame size 128KiB exceeded: ${dataLength}`);
+            }
+            writeHeader(frame, selfContained, dataLength);
+            let frameCrc = computeCrc32(frame, HEADER_LENGTH, HEADER_LENGTH + dataLength);
+            if (frame.order === 'big-endian') {
+                frameCrc = reverseBytes32(frameCrc)
+            }
+            frame.limit = frameLength;
+            frame.setInt32(frameLength - TRAILER_LENGTH, frameCrc);
+            frame.position = 0;
+
+        }
+        catch (e) {
+            // frame.release();
+            throw e;
+        }
+    }
+}
+
+class Payload {
+    readonly selfContained: boolean;
+    readonly buffer: ByteBuffer;
+    readonly headerLength: number;
+    readonly trailerLength: number;
+    private _finished = false;
+
+    constructor(selfContained: boolean, payloadLength: number, headerLength: number = 0, trailerLength = 0) {
+        this.selfContained = selfContained;
+        this.headerLength = headerLength;
+        this.trailerLength = trailerLength;
+        this.buffer = allocate(payloadLength + headerLength + trailerLength);
+        this.buffer.position = headerLength;
+        this.buffer.limit = this.buffer.capacity - trailerLength;
+    }
+
+    get length(): number {
+        if (this._finished) {
+            throw new Error('already finished');
+        }
+        return this.buffer.position - this.headerLength;
+    }
+
+    get remaining(): number {
+        if (this._finished) {
+            throw new Error('already finished');
+        }
+        return this.buffer.remaining;
+    }
+
+    trim(length: number): void {
+        if (this._finished) {
+            throw new Error('already finished');
+        }
+        this.buffer.position = length + this.headerLength;
+    }
+
+    finish() {
+        if (this._finished) {
+            throw new Error('already finished');
+        }
+        this._finished = true;
+        this.buffer.limit = this.buffer.position + this.trailerLength;
+        this.buffer.position = 0;
+    }
+
+    release() {
+
+    }
+}
+
+export type {Payload};
+export type PayloadAllocator = (capacity: number, selfContained?: boolean) => Payload;
+export type {FrameEncoder};
+export const encoder: FrameEncoder = new FrameEncoderCrc();

package/src/net/HandshakeProtocol.ts

@@ -0,0 +1,143 @@
+import {type Address} from '../cluster/Address.ts';
+import {ByteBufferInput, ByteBufferOutput} from '../io/VersionedSerializer.ts';
+import {addressSerializer} from './AddressSerializer.ts'
+import {allocate, type ByteBuffer} from '../utils/buffer.ts';
+import {computeCrc32} from '../utils/crc.ts';
+
+
+/**
+ * The initial message sent when a node creates a connection to a remote node.
+ * - Magic
+ * - Flags
+ *  - Version
+ * - Broadcast Address
+ *
+ */
+
+
+export type AcceptVersions = Readonly<{min: number, max: number}>
+
+const FramingTypes = {
+    UNPROTECTED: 0,
+    // LZ4: 1
+    CRC: 2
+}
+export type Framing = keyof typeof FramingTypes;
+
+const MIN_LENGTH = 8;
+const ACCEPT_MAX_LENGTH = 12;
+const INITIATE_MAX_LENGTH = 12 + addressSerializer.MAX_SIZE;
+
+function getBits(packed: number, start: number, count: number): number {
+    return (packed >>> start) & ~(-1 << count);
+}
+
+export class Initiate {
+    readonly from: Address;
+    readonly framing: Framing;
+    readonly acceptVersions: AcceptVersions;
+    constructor(from: Address, framing: Framing, acceptVersions: AcceptVersions) {
+        this.from = from;
+        this.framing = framing;
+        this.acceptVersions = acceptVersions;
+    }
+
+    private encodeFlags(): number {
+        let flags = 0;
+        flags |= 0x2; // MESSAGING SMALL
+        flags |= (FramingTypes[this.framing] & 0x1) << 2 | (FramingTypes[this.framing] & 0x2) << 3;
+        flags |= this.acceptVersions.min << 8;
+        flags |= this.acceptVersions.min << 16;
+        flags |= this.acceptVersions.max << 24;
+        return flags;
+    }
+
+    encode(): ByteBuffer {
+        const buffer = allocate(INITIATE_MAX_LENGTH);
+        const out = new ByteBufferOutput(buffer);
+        out.writeUint32(0xCA552DFA);
+        out.writeUint32(this.encodeFlags());
+        addressSerializer.serialize(this.from, out, this.acceptVersions.min);
+        out.writeUint32(computeCrc32(buffer, 0, buffer.position));
+        buffer.flip();
+        return buffer;
+    }
+
+    static maybeDecode(buffer: ByteBuffer): Initiate | undefined {
+        if (buffer.remaining < MIN_LENGTH) {
+            return;
+        }
+        const position = buffer.position;
+        const input = new ByteBufferInput(buffer, false);
+        const magic = input.readInt32();
+
+        const flags = input.readInt32();
+        if (getBits(flags, 8, 8) < 12) {
+            return;
+        }
+
+        const minVersion = getBits(flags, 16, 8);
+        const maxVersion = getBits(flags, 24, 8);
+
+        if (maxVersion < 12) {
+            return;
+        }
+
+        const framingBits = getBits(flags, 2, 1) | (getBits(flags, 4, 1) << 1);
+        const framing = framingBits === 0 ? 'UNPROTECTED' : framingBits === 2 ? 'CRC': undefined;
+        const stream = getBits(flags, 3, 1) === 1;
+
+        const from = addressSerializer.deserialize(input, minVersion);
+
+        const computed = computeCrc32(buffer, position, position + buffer.position);
+        const read = input.readInt32();
+        if (computed !== read) {
+            throw new Error('crc32 mismatch');
+        }
+
+        return new Initiate(from, framing, {min: minVersion, max: maxVersion});
+    }
+}
+
+export class Accept {
+    readonly useMessagingVersion: number;
+    readonly maxMessagingVersion: number;
+
+    constructor(useMessagingVersion: number, maxMessagingVersion: number) {
+        this.useMessagingVersion = useMessagingVersion;
+        this.maxMessagingVersion = maxMessagingVersion;
+    }
+
+    encode(): ByteBuffer {
+        const buffer = allocate(ACCEPT_MAX_LENGTH);
+        const out = new ByteBufferOutput(buffer);
+        out.writeUint32(this.maxMessagingVersion);
+        out.writeUint32(this.useMessagingVersion);
+        out.writeUint32(computeCrc32(buffer, 0, 8));
+        buffer.flip();
+        return buffer;
+    }
+    static maybeDecode(buffer: ByteBuffer): Accept | undefined {
+        const position = buffer.position;
+        if (buffer.remaining < 4) {
+            return;
+        }
+        const maxMessagingVersion = buffer.getUint32();
+        if (maxMessagingVersion < 12) {
+            return;
+        }
+
+        if (buffer.remaining < 8) {
+            buffer.position = position;
+            return;
+        }
+        const useMessagingVersion = buffer.getUint32();
+
+        const computed = computeCrc32(buffer, position, position + 8);
+        const read = buffer.getUint32();
+        if (computed !== read) {
+            throw new Error('crc32 mismatch');
+        }
+        return new Accept(useMessagingVersion, maxMessagingVersion);
+    }
+}

package/src/net/InboundConnection.ts

@@ -0,0 +1,108 @@
+import {type Server, type Socket} from 'node:net';
+import type {Address} from '../cluster/Address.ts';
+import {deferred, type DeferredPromise} from '../utils/promise.ts';
+import getLogger from '../logging.ts';
+import {bind} from './InboundConnectionInitiator.ts';
+import type {AcceptVersions} from './HandshakeProtocol.ts';
+import type {FrameDecoder} from './FrameDecoder.ts';
+
+const logger = getLogger('net.inbound');
+
+export type InboundConnectionSettings = {
+    bindAddress: Address,
+    handlers: (from: Address) => { handle: (decoder: FrameDecoder, socket: Socket, version: number) => void },
+    acceptVersions?: AcceptVersions,
+    handshakeTimeout?: number,
+};
+
+export class InboundSocket {
+    readonly settings: InboundConnectionSettings;
+    private listen: Server;
+    private binding: DeferredPromise<Server>;
+    private closedBeforeOpen: boolean;
+    private closePromise: Promise<void>;
+
+    private readonly connections: Socket[] = [];
+
+    constructor(settings: InboundConnectionSettings) {
+        this.settings = settings;
+    }
+
+    async open(): Promise<void> {
+        if (this.listen) {
+            return;
+        }
+        if (this.binding) {
+            await this.binding.promise;
+            return;
+        }
+        if (this.closedBeforeOpen) {
+            throw new Error("Socket closed before open");
+        }
+        this.binding = bind(this.settings, this.connections);
+
+        const d = deferred<void>();
+        this.binding.promise
+            .catch((reason) => {
+                delete this.binding;
+                d.failure(reason);
+            })
+            .then((server: Server) => {
+                this.listen = server;
+                delete this.binding;
+                d.success();
+            })
+        await d.promise;
+    }
+
+    close(shutdownListeners?: () => void): Promise<void> {
+
+        const done = deferred<void>();
+
+        const close = () => {
+            const closing = [];
+            if (this.listen !== undefined) {
+                closing.push(new Promise<void>((resolve, reject) => {
+                    this.listen.close((err?) => {
+                        if (err) {
+                            reject(err);
+                        } else {
+                            resolve();
+                        }
+                    });
+                }));
+            }
+            this.connections.forEach((socket) => {
+                closing.push(new Promise<void>((resolve, _reject) => {
+                    socket.end(resolve);
+                }));
+            });
+            Promise.all(closing)
+                .then(() => {
+                    done.success();
+                }).catch((err) => {
+                    done.failure(err);
+                });
+        };
+
+        if (this.listen === undefined && this.binding === undefined) {
+            this.closedBeforeOpen = true;
+            return Promise.resolve();
+        }
+        if (this.closePromise !== undefined) {
+            return this.closePromise;
+        }
+        this.closePromise = done.promise;
+
+        if (this.listen !== undefined) {
+            close();
+        } else {
+            this.binding.cancel();
+            this.binding.promise.finally(() => close())
+        }
+
+        return done.promise;
+
+    }
+
+}