@interopio/bridge 0.0.1-alpha

package/src/net/OutboundConnectionInitiator.ts

@@ -0,0 +1,76 @@
+import {createConnection, Socket} from 'node:net';
+import {Initiate, Accept} from './HandshakeProtocol.ts';
+import {deferred, type DeferredPromise} from '../utils/promise.ts';
+import {type OutboundConnectionSettings} from './OutboundConnection.ts';
+import getLogger from '../logging.ts';
+import {writeAndFlush} from './internal/AsyncSocketPromise.ts';
+import {adopt} from '../utils/buffer.ts';
+import {encoder, type PayloadAllocator} from './FrameEncoder.ts';
+
+const logger = getLogger('net.outbound.initiator');
+
+export type MessagingSuccess = {outcome: 'success', socket: Socket, version: number, allocator: PayloadAllocator, settings: OutboundConnectionSettings}
+export type OutboundSocketInitiatorResultSuccess = MessagingSuccess;
+export type OutboundSocketInitiatorResult<Success extends OutboundSocketInitiatorResultSuccess>
+    = OutboundSocketInitiatorResultSuccess
+    | { outcome: 'retry', withVersion: number }
+    | { outcome: 'incompatible' };
+
+function outboundSocketInitiator<Success extends OutboundSocketInitiatorResultSuccess>(result: DeferredPromise<OutboundSocketInitiatorResult<Success>>, settings: OutboundConnectionSettings): DeferredPromise<OutboundSocketInitiatorResult<Success>> {
+    if (logger.enabledFor('debug')) {
+        logger.debug(`creating outbound socket to ${settings}`);
+    }
+    const {host, port} = settings.connectTo;
+    const socket = createConnection({port, host, keepAlive: true, noDelay: settings.tcpNoDelay});
+    const d = deferred<OutboundSocketInitiatorResult<Success>>();
+    socket
+        .on('connect', () => {
+
+            const initiate = new Initiate(settings.from, 'CRC', settings.acceptVersions);
+            logger.debug(`starting handshake to ${settings.connectToId}`);
+            const listener = (data: Buffer) => {
+                const accept = Accept.maybeDecode(adopt(data));
+                if (!accept) {
+                    return;
+                }
+
+                let result: OutboundSocketInitiatorResult<Success>;
+
+                if (accept.useMessagingVersion < settings.acceptVersions.min || accept.useMessagingVersion > settings.acceptVersions.max) {
+                    result = {outcome: 'incompatible'};
+                }
+                else {
+                    socket['encoder'] = encoder;
+                    result = {
+                        outcome: 'success',
+                        socket,
+                        version: accept.useMessagingVersion,
+                        allocator: encoder.allocator,
+                        settings
+                    };
+                }
+
+                if (result.outcome === 'success') {
+                    socket.off('data', listener);
+                }
+                else {
+                    socket.destroy();
+                }
+                d.success(result);
+            };
+            socket.on('data', listener);
+            const promise = writeAndFlush(socket, {selfContained: true, buffer: initiate.encode()});
+        })
+        .on('error', (err: Error) => {
+            socket.destroy();
+            d.failure(err)
+        });
+
+    d.promise.then(result.success).catch(result.failure);
+    return d;
+}
+
+export function initiateMessaging(settings: Required<OutboundConnectionSettings>, result: DeferredPromise<OutboundSocketInitiatorResult<MessagingSuccess>>): DeferredPromise<OutboundSocketInitiatorResult<MessagingSuccess>> {
+    const bootstrap = outboundSocketInitiator(result, settings);
+    return bootstrap;
+}

package/src/net/RequestCallbacks.ts

@@ -0,0 +1,148 @@
+import {type Address, addressAsString} from '../cluster/Address.ts';
+import type {Messenger} from '../gossip/Messenger.ts';
+import type {Message, MessageId} from './Message.ts';
+import {ObjectMap} from '../utils/collections.ts';
+import type {RequestFailureReason} from "../error/RequestFailure";
+import {preciseClock} from '../utils/clock.ts';
+import getLogger from '../logging.ts';
+import type {OutboundMessageCallbacks} from "./OutboundConnection";
+
+const logger = getLogger('net.callbacks');
+
+type CallbackKey = Readonly<{id: MessageId, peer: Address}>;
+
+class CallbackInfo {
+    readonly createdAtNanos: bigint;
+    readonly expiresAtNanos: bigint;
+    readonly peer: Address;
+    readonly callback: RequestCallback<unknown>;
+    constructor(message: Message<unknown>, peer: Address, callback: RequestCallback<unknown>) {
+        this.createdAtNanos = message.header.createdAtNanos;
+        this.expiresAtNanos = message.header.expiresAtNanos;
+        this.peer = peer;
+        this.callback = callback;
+    }
+
+    invokeOnFailure(): boolean {
+        return this.callback.onFailure !== undefined;
+    }
+
+    readyToDie(atNano: bigint) {
+        return atNano > this.expiresAtNanos;
+    }
+
+    toString() {
+        return `{peer: "${addressAsString(this.peer)}", callback: ${this.callback}, invokeOnFailure: ${this.invokeOnFailure()}}`;
+    }
+}
+
+export interface RequestCallback<T> {
+    (message: Message<T>): void;
+    onFailure?(from: Address, failureReason: RequestFailureReason): void;
+}
+
+export type {CallbackInfo};
+
+
+export class RequestCallbacks implements OutboundMessageCallbacks {
+    private messaging: Messenger;
+    private readonly callbacks = new ObjectMap<CallbackKey, CallbackInfo>();
+    private readonly expireIntervalId: ReturnType<typeof setInterval>;
+    constructor(messaging: Messenger) {
+        this.messaging = messaging;
+        this.expireIntervalId = setInterval(() => {
+            this.expire();
+        }, 1000);
+    }
+
+    private removeAndExpire(id: MessageId, from: Address): void {
+        const callbackInfo = this.remove(id, from);
+        if (callbackInfo) {
+            this.onExpiredCallback(callbackInfo);
+        }
+    }
+    private expire(): void {
+        const start = preciseClock.now();
+        let n = 0;
+        for (const [key, value] of this.callbacks) {
+            if (value.readyToDie(start)) {
+                if (this.callbacks.delete(key)) {
+                    n++;
+                    this.onExpiredCallback(value);
+                }
+            }
+        }
+        if (logger.enabledFor('trace')) {
+            logger.debug(`Expired ${n} callbacks`);
+        }
+    }
+
+    private forceExpire(): void {
+        for (const [key, value] of this.callbacks) {
+            if (this.callbacks.delete(key)) {
+                this.onExpiredCallback(value);
+            }
+        }
+    }
+
+    private onExpiredCallback(info: CallbackInfo): void {
+        this.messaging.markExpiredCallback(info.peer);
+    }
+
+    remove(id: MessageId, from: Address): CallbackInfo | undefined {
+        const key: CallbackKey = {id, peer: from};
+        const callbackInfo = this.callbacks.get(key);
+        if (callbackInfo) {
+            this.callbacks.delete(key);
+        }
+        return callbackInfo;
+    }
+
+    addWithExpiration(callback: RequestCallback<unknown>, message: Message<unknown>, to: Address) {
+        const key: CallbackKey = {id: message.id, peer: to};
+        if (this.callbacks.has(key)) {
+            throw new Error(`Callback already exists for id ${message.id}/${addressAsString(to)}! (${this.callbacks.get(key)})`);
+        }
+        this.callbacks.set(key, new CallbackInfo(message, to, callback));
+    }
+
+    shutdownNow(expire = false): void {
+        if (this.expireIntervalId) {
+            clearInterval(this.expireIntervalId);
+        }
+        if (expire) {
+            this.forceExpire();
+        }
+    }
+
+    shutdown(): void {
+        this.expire();
+        if (this.callbacks.size !== 0) {
+            setTimeout(() => {
+                this.shutdown();
+            }, 100);
+        }
+        else {
+            clearInterval(this.expireIntervalId);
+        }
+    }
+
+
+    onExpired(message: Message<unknown>, peer: Address) {
+        this.removeAndExpireMessage(message, peer);
+    }
+
+    onFailedSerialize(message: Message<unknown>, peer: Address, bytesWritten: number, error: Error) {
+        this.removeAndExpireMessage(message, peer);
+    }
+
+    onDiscardOnClose(message: Message<unknown>, peer: Address) {
+        this.removeAndExpireMessage(message, peer);
+    }
+
+    private removeAndExpireMessage(message: Message<unknown>, peer: Address): void {
+        this.removeAndExpire(message.header.seq, peer)
+        // todo forward info
+    }
+
+}

package/src/net/ResponseHandler.ts

@@ -0,0 +1,30 @@
+import {fromId, type VerbHandler, type VerbHandlerContext} from './Action.ts';
+import type {Message} from './Message.ts';
+import {approximateClock} from '../utils/clock.ts';
+import type {RequestFailureReason} from '../error/RequestFailure.ts';
+import getLogger from '../logging.ts';
+
+const logger = getLogger('net.response');
+
+export function responseHandler<T>(ctx: VerbHandlerContext): VerbHandler<T> {
+    return  (new class implements VerbHandler<T> {
+        doVerb(message: Message<T>): void {
+            const {id, from} = message;
+            const callbackInfo = ctx.messaging().callbacks.remove(id, from);
+            if (!callbackInfo) {
+                if (logger.enabledFor('debug')) {
+                    logger.debug(`No callback (already removed?) for message ${fromId(message.header.verb().id)}@${id} from ${from}`);
+                }
+                return;
+            }
+            const latency = approximateClock().now() - callbackInfo.createdAtNanos;
+            const callback = callbackInfo.callback;
+            if (message.failureResponse && callbackInfo.invokeOnFailure()) {
+                callback.onFailure(from, message.payload as RequestFailureReason);
+            }
+            else {
+                callback(message);
+            }
+        }
+    });
+}

package/src/net/ShareableBytes.ts

@@ -0,0 +1,125 @@
+import type {ByteBuffer} from '../utils/buffer.ts';
+import {forNetworking} from '../utils/memory/BufferPools.ts';
+
+class ShareableBytes {
+    private readonly bytes: ByteBuffer;
+    private readonly owner: ShareableBytes;
+    private count: number;
+
+    private static readonly UNSHARED = -1;
+    private static readonly RELEASED = 0;
+
+    constructor(bytes: ByteBuffer, owner?: ShareableBytes) {
+        if (owner === undefined) {
+            this.owner = this;
+            this.count = ShareableBytes.UNSHARED;
+        } else {
+            this.owner = owner;
+            this.count = ShareableBytes.RELEASED;
+        }
+        this.bytes = bytes;
+    }
+
+    public get(): ByteBuffer {
+        if (this.owner.count === ShareableBytes.RELEASED) {
+            throw new Error("assertion failed: ShareableBytes is released");
+        }
+        return this.bytes;
+    }
+
+    public get hasRemaining(): boolean {
+        return this.bytes.hasRemaining;
+    }
+
+    public get remaining(): number {
+        return this.bytes.remaining;
+    }
+
+    /**/
+    skipBytes(n: number): void {
+        this.bytes.position += n;
+    }
+
+    /**/
+    consume() {
+        this.bytes.position = this.bytes.limit;
+    }
+
+    public share() {
+        const count = this.owner.count;
+        if (count < 0) {
+            this.owner.count = -count;
+        }
+        return this;
+    }
+
+    private retain() {
+        this.owner.doRetain();
+        return this;
+    }
+
+    private doRetain() {
+        let count = this.count;
+        if (count < 0) {
+            this.count = count - 1;
+            return;
+        }
+        while (true) {
+            if (count === ShareableBytes.RELEASED) {
+                throw new Error("Attempted to reference an already released SharedBytes");
+            }
+
+            if (this.count === count) {
+                this.count++;
+                return;
+            }
+            count = this.count;
+        }
+    }
+
+    public release() {
+        this.owner.doRelease();
+    }
+
+    private doRelease() {
+        let count = this.count;
+        if (count < 0) {
+            this.count = count += 1;
+        } else if (count > 0) {
+            count = --this.count;
+        } else {
+            throw new Error("Attempted to release an already released SharedBytes");
+        }
+
+        if (count === ShareableBytes.RELEASED) {
+            forNetworking().put(this.bytes);
+        }
+    }
+
+    /**/
+    get released(): boolean {
+        return this.owner.count === ShareableBytes.RELEASED;
+    }
+
+    public sliceAndConsume(length: number): ShareableBytes {
+        const begin = this.bytes.position;
+        const end = begin + length;
+        const result = this.slice(begin, end);
+        this.bytes.position = end;
+        return result;
+    }
+
+    /**/
+    slice(begin: number, end: number): ShareableBytes {
+        const slice = this.bytes.duplicate();
+        slice.position = begin;
+        slice.limit = end;
+        return new ShareableBytes(slice, this.owner.retain());
+    }
+}
+
+export type {ShareableBytes};
+
+export function shareableBytes(bytes: ByteBuffer): ShareableBytes {
+    return new ShareableBytes(bytes);
+}