@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/net/OutboundConnectionInitiator.ts

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

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

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

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