@interopio/bridge 0.0.1-alpha

package/src/net/Message.ts

@@ -0,0 +1,428 @@
+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();