@interopio/bridge 0.0.1-alpha → 0.0.4-beta.0

package/src/net/FrameDecoder.ts

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

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

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

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