@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/net/Message.ts

@@ -1,428 +0,0 @@
-import {ByteBufferInput, type DataInput, type DataOutput, type VersionedSerializer} from '../io/VersionedSerializer.ts';
-import {fromId, NoPayload, type Verb, Verbs} from './Action.ts';
-import {approximateClock, type Clock, type ClockTranslation} from '../utils/clock.ts';
-import {type Address} from '../cluster/Address.ts';
-import type {RequestFailureReason} from '../error/RequestFailure.ts';
-import {convert} from '../config/Duration.ts';
-import {
-    computeUnsignedVIntSize,
-    getUnsignedVInt,
-    getUnsignedVInt32,
-    getUnsignedVIntSize,
-    skipUnsignedVInt
-} from '../utils/vint.ts';
-import type {ByteBuffer} from '../utils/buffer.ts';
-import {absn} from '../utils/bigint.ts';
-
-const MessageFlags = {
-    CALL_BACK_ON_FAILURE: 0x0,
-    URGENT: 0x3,
-}
-
-export type MessageFlag = keyof typeof MessageFlags
-
-export function isFlagOn(header: MessageHeader, flag: MessageFlag) {
-    return (header.flags & (1 << MessageFlags[flag])) !== 0;
-}
-
-function addFlag(header: MessageHeader, flag: MessageFlag): MessageHeader {
-    const flags = header.flags | (1 << MessageFlags[flag]);
-    return {...header, flags};
-}
-
-
-const VERSION_40 = 12;
-const VERSION_50 = 13;
-const VERSION_51 = 14;
-export const MessagingVersion =  {VERSION_40: VERSION_40, VERSION_50: VERSION_50, VERSION_51: VERSION_51};
-
-export interface MessageHeader {
-    // message sequence id
-    readonly seq: MessageId
-    // sender
-    readonly from: Address
-    // expiration time
-    readonly expiresAtNanos: bigint
-    // creation time
-    readonly createdAtNanos: bigint
-    // flags
-    readonly flags: number
-    readonly params?: unknown
-    // message verb
-    verb<T>(): Verb<T>
-}
-
-export type MessageId = bigint | number
-
-class Message<T> {
-    readonly header: MessageHeader;
-    readonly payload: T;
-    readonly payloadSerializer: VersionedSerializer<T>
-    readonly serializedSizes: {[keys: number]: number} = {};
-
-    constructor(header: MessageHeader, payload: T) {
-        this.payload = payload;
-        this.header = header;
-        this.payloadSerializer = header.verb<T>().serializer;
-    }
-
-    serializedSize(version: number): number {
-        // todo expect valid version here
-        this.serializedSizes[version] ??= serializer.serializedSize(this, version);
-        return this.serializedSizes[version];
-    }
-
-    payloadSize(version?: number): number {
-        return serializer.payloadSize(this, version);
-    }
-
-    get failureResponse(): boolean {
-        return fromId(this.header.verb().id) === 'FAILURE_RESPONSE';
-    }
-
-    get from() {
-        return this.header.from;
-    }
-
-    get creationTime() {
-        return approximateClock().translate.toMillisSinceEpoch(this.header.createdAtNanos);
-    }
-
-    get id() {
-        return this.header.seq;
-    }
-
-    get callbackOnFailure() {
-        return isFlagOn(this.header, 'CALL_BACK_ON_FAILURE');
-    }
-
-    withCallbackOnFailure() {
-        return this.withFlag('CALL_BACK_ON_FAILURE');
-    }
-
-    withFlag(flag: MessageFlag) {
-        return new Message(addFlag(this.header, flag), this.payload);
-    }
-
-    toString() {
-        return `from ${this.from}, verb: ${fromId(this.header.verb().id)}, seq: ${this.id}`;
-    }
-}
-
-export type {Message}
-
-let nextId = 0;
-
-const GRACE_START = 0xFFFFFFFFn - convert('milliseconds', 15, 'minutes');
-const GRACE_END =                 convert('milliseconds', 15, 'minutes');
-
-export class MessageFactory {
-    readonly from: Address;
-    private readonly clock: Clock;
-
-    constructor(from: Address, clock?: Clock) {
-        this.from = from;
-        this.clock = clock ?? approximateClock();
-    }
-
-
-    emptyResponse(message: Message<unknown>) {
-        return this.responseWith(message, NoPayload.instance);
-    }
-
-    responseWith<T>(message: Message<unknown>, payload: T): Message<T> {
-        let result = this.out<T>(message.header.verb().responseVerb as Verb<T>, payload, message.id, message.header.expiresAtNanos);
-        if (isFlagOn(message.header, 'URGENT')) {
-            result = result.withFlag('URGENT');
-        }
-        return result;
-    }
-
-    failureResponse(id: MessageId, expiresAt: bigint, reason: RequestFailureReason): Message<RequestFailureReason> {
-        return this.out(Verbs.FAILURE_RESPONSE, reason, id, expiresAt);
-    }
-
-    out<T>(verb: Verb<T>, payload: T, id?: MessageId, expiresAt?: bigint, flags?: MessageFlag[]): Message<T> {
-        if (!verb) {
-            throw new Error('verb is required');
-        }
-        const seq = id ?? ++nextId;
-        const createdAtNanos = this.clock.now();
-        const expiresAtNanos =  expiresAt ?? verb.expiresAt(createdAtNanos);
-        let encodedFlags = 0;
-        if (flags) {
-            for (const flag of flags) {
-                encodedFlags |= (1 << MessageFlags[flag]);
-            }
-        }
-        const header: MessageHeader = {
-            seq,
-            from: this.from,
-            createdAtNanos,
-            expiresAtNanos,
-            flags: encodedFlags,
-            verb: <V>() => {return verb as V;},
-
-        };
-        return new Message(header, payload);
-    }
-}
-
-function calculateCreatedAtNanos(messageTimestamp: number, timeSnapshot: ClockTranslation, nowNs: bigint): bigint {
-    const currentMillis = timeSnapshot.toMillisSinceEpoch(nowNs);
-
-    let hi = currentMillis & 0xFFFFFFFF00000000n;
-
-    const sentLo = BigInt(messageTimestamp) & 0x00000000FFFFFFFFn;
-    const currentLo = currentMillis & 0x00000000FFFFFFFFn;
-
-    if (sentLo > GRACE_START && currentLo < GRACE_END) {
-        hi -= 0x0000000100000000n;
-    }
-    else if (sentLo < GRACE_END && currentLo > GRACE_START) {
-        hi += 0x0000000100000000n;
-    }
-
-    let sentTimeMs = (hi | sentLo);
-
-    if (absn(currentMillis - sentTimeMs) > convert('milliseconds', 15, 'minutes')) {
-        sentTimeMs = currentMillis;
-    }
-
-    return timeSnapshot.fromMillisSinceEpoch(sentTimeMs);
-
-}
-
-class Serializer {
-    private static readonly CREATION_TIME_SIZE = 4; // 4 bytes for createdAtNanos
-
-    serialize<T>(message: Message<T>, out: DataOutput, version: number) {
-        this.serializeHeader(message.header, out, version);
-        out.writeUnsignedVInt32(message.payloadSize(version));
-        message.payloadSerializer.serialize(message.payload, out, version);
-    }
-
-    deserialize<T>(input: DataInput, header: MessageHeader, version: number): Message<T> {
-        this.skipHeader(input, version);
-        skipUnsignedVInt(input);// payload size
-        const payload = header.verb<T>().serializer.deserialize(input, version);
-        return new Message<T>(header, payload);
-    }
-
-    private skipHeader(input: DataInput, version: number) {
-        skipUnsignedVInt(input);
-        if (version >= VERSION_51) {
-            skipUnsignedVInt(input);
-        }
-        input.skipBytesFully(Serializer.CREATION_TIME_SIZE);
-        skipUnsignedVInt(input); // expiresIn
-        skipUnsignedVInt(input); // verb
-        skipUnsignedVInt(input); // flags
-        this.skipParams(input, version);
-    }
-
-    private skipParams(input: DataInput, version: number) {
-        const count = input.readUnsignedVInt32();
-        if (count == 0) {
-            return;
-        }
-        for (let i = 0; i < count; i++) {
-            skipUnsignedVInt(input);
-            const length = input.readUnsignedVInt32();
-            input.skipBytesFully(length);
-        }
-    }
-
-    serializedSize<T>(message: Message<T>, version: number): number {
-        let size = 0;
-        size += this.serializedSizeHeader(message.header, version);
-        const payloadSize = message.payloadSize(version);
-        size += computeUnsignedVIntSize(payloadSize);
-        size += payloadSize;
-        return size;
-    }
-
-    private serializedSizeHeader(header: MessageHeader, version?: number) {
-        let size = 0;
-        size += computeUnsignedVIntSize(header.seq);
-        if (version >= VERSION_51) {
-            // todo: epoch
-        }
-        size += Serializer.CREATION_TIME_SIZE; // createdAt
-        const expiresInMillis = convert('milliseconds', header.expiresAtNanos - header.createdAtNanos, 'nanoseconds');
-        size += computeUnsignedVIntSize(expiresInMillis); // expiresAtNanos - createdAtNanos
-        size += computeUnsignedVIntSize(header.verb().id); // verb.id
-        size += computeUnsignedVIntSize(header.flags); // flags
-        size += computeUnsignedVIntSize(0);// params size
-        return size;
-    }
-
-    private serializeHeader(header: MessageHeader, out: DataOutput, version?: number) {
-        out.writeUnsignedVInt(header.seq);
-        if (version >= VERSION_51) {
-            // todo: epoch
-        }
-        out.writeInt32(Number(0xffffffffn & approximateClock().translate.toMillisSinceEpoch(header.createdAtNanos)));
-        const expiresInMillis = convert('milliseconds', header.expiresAtNanos - header.createdAtNanos, 'nanoseconds');
-        out.writeUnsignedVInt(expiresInMillis);
-        out.writeUnsignedVInt32(header.verb().id);
-        out.writeUnsignedVInt32(header.flags);
-        this.serializeParams(header.params, out, version);
-    }
-
-    private serializeParams(params: unknown, out: DataOutput, version: number) {
-        out.writeUnsignedVInt32(0);
-    }
-
-    inferMessageSize(buffer: ByteBuffer, readerPosition: number, limit: number, version: number): number {
-        let position = readerPosition;
-        const seqSize = getUnsignedVIntSize(buffer, position, limit);
-        if (seqSize < 0) {
-            return -1; // not enough data
-        }
-        position += seqSize;
-        if (version >= VERSION_51) {
-            //todo: epoch
-        }
-        position += Serializer.CREATION_TIME_SIZE;
-        if (position > limit) {
-            return -1; // not enough data
-        }
-        const expiresInSize = getUnsignedVIntSize(buffer, position, limit);
-        if (expiresInSize < 0) {
-            return -1; // not enough data
-        }
-        position += expiresInSize;
-
-        const verbSize = getUnsignedVIntSize(buffer, position, limit);
-        if (verbSize < 0) {
-            return -1; // not enough data
-        }
-        position += verbSize;
-
-        const flagsSize = getUnsignedVIntSize(buffer, position, limit);
-        if (flagsSize < 0) {
-            return -1; // not enough data
-        }
-        position += flagsSize;
-
-        const paramsSize = this.extractParamsSize(buffer, position, limit);
-        if (paramsSize < 0) {
-            return -1; // not enough data
-        }
-        position += paramsSize;
-
-        const payloadSize = getUnsignedVInt(buffer, position, limit);
-        if (payloadSize < 0) {
-            return -1; // not enough data
-        }
-        position += computeUnsignedVIntSize(payloadSize) + Number(payloadSize);
-
-        const size = position - readerPosition;
-        // todo: check if size is valid
-        return size;
-    }
-
-    extractHeader(buffer: ByteBuffer, from: Address, nowNs: bigint, version: number): MessageHeader {
-        const timeSnapshot = approximateClock().translate;
-
-        let position = buffer.position;
-
-        const seq = getUnsignedVInt(buffer, position);
-        position += computeUnsignedVIntSize(seq);
-
-        if (version >= VERSION_51) {
-            const epochN= getUnsignedVInt(buffer, position);
-            position += computeUnsignedVIntSize(epochN);
-        }
-        const createdAtMillis = buffer.getInt32(position);
-        position += Serializer.CREATION_TIME_SIZE;
-
-        const expiresInMillis = getUnsignedVInt(buffer, position);
-        position += computeUnsignedVIntSize(expiresInMillis);
-
-        const verb = Verbs[fromId(getUnsignedVInt32(buffer, position))];
-        position += computeUnsignedVIntSize(verb.id);
-
-        const flags = getUnsignedVInt32(buffer, position);
-        position += computeUnsignedVIntSize(flags);
-
-        const params = this.extractParams(buffer, position, version);
-
-        const createdAtNanos = calculateCreatedAtNanos(createdAtMillis, timeSnapshot, nowNs);
-        const expiresAtNanos = createdAtNanos + BigInt(convert('nanoseconds', expiresInMillis, 'milliseconds'));
-
-        const header: MessageHeader = {
-            seq,
-            from,
-            createdAtNanos,
-            expiresAtNanos,
-            flags,
-            verb: <V>() => {return verb as V;},
-
-        };
-        return header;
-    }
-
-    private extractParams(buffer: ByteBuffer, readerPosition: number, version: number): unknown {
-        const count = getUnsignedVInt(buffer, readerPosition);
-        if (count == 0) {
-            return {};
-        }
-
-        const position = buffer.position;
-        buffer.position = readerPosition;
-        try {
-            const input = new ByteBufferInput(buffer, false);
-            return this.deserializeParams(input, version);
-        } finally {
-            buffer.position = position;
-        }
-    }
-
-    private deserializeParams(input: DataInput, version: number): unknown {
-        const count = input.readUnsignedVInt32();
-        if (count == 0) {
-            return {};
-        }
-
-        const params: Record<string, unknown> = {};
-        for (let i = 0; i < count; i++) {
-            const type = input.readUnsignedVInt32();
-            const length = input.readUnsignedVInt32();
-
-            input.skipBytesFully(length);
-        }
-    }
-
-    private extractParamsSize(buffer: ByteBuffer, readerPosition: number, limit: number): number {
-        let position = readerPosition;
-        const paramsCount = getUnsignedVInt(buffer, position, limit);
-        if (paramsCount < 0) {
-            return -1; // not enough data
-        }
-        position += computeUnsignedVIntSize(paramsCount);
-
-        for (let i = 0; i < paramsCount; i++) {
-
-            const type = getUnsignedVInt(buffer, position, limit);
-            if (type < 0) {
-                return -1; // not enough data
-            }
-            position += computeUnsignedVIntSize(type);
-
-            const length = getUnsignedVInt(buffer, position, limit);
-            if (length < 0) {
-                return -1; // not enough data
-            }
-            position += computeUnsignedVIntSize(length) + Number(length);
-        }
-        return position - readerPosition;
-    }
-
-    payloadSize<T>(message: Message<T>, version?: number): number {
-        let size = message.payload === undefined ? 0 : message.payloadSerializer.serializedSize(message.payload, version);
-        return size;
-    }
-}
-export const serializer = new Serializer();