@interopio/bridge 0.0.1-alpha → 0.0.3-beta

package/src/net/internal/AsyncResourceExecutor.ts

@@ -1,464 +0,0 @@
-import { globalClock } from '../../utils/clock.ts';
-import {type Comparator, PriorityQueue} from '../../utils/collections.ts';
-import {convert, type Unit} from '../../config/Duration.ts';
-
-
-export interface Runnable {
-    run(): void
-}
-
-export interface Executor {
-    execute(task: (...args: unknown[]) => void, ...args:unknown[]): void;
-}
-
-export interface ExecutorService extends Executor {
-    readonly terminated: Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-export interface ScheduledExecutorService extends ExecutorService {
-    schedule(task: Runnable, delay: bigint, unit: Unit): ScheduledTask;
-}
-
-export interface EventExecutorGroup extends ScheduledExecutorService {
-    next(): EventExecutor;
-    readonly terminated: Promise<void>;
-    shutdown(): Promise<void>;
-}
-
-export interface EventExecutor extends EventExecutorGroup {
-    readonly ordered: boolean
-    readonly parent?: EventExecutorGroup
-    inEventLoop(): boolean
-}
-
-export abstract class AbstractExecutorService implements ExecutorService {
-
-    abstract execute(task: (...args:unknown[]) => void, ...args: unknown[]): void;
-
-    abstract get terminated(): Promise<void>;
-
-    abstract shutdown(): Promise<void>;
-}
-export abstract class AbstractEventExecutor extends AbstractExecutorService implements EventExecutor {
-    private readonly _parent?: EventExecutorGroup
-
-    constructor(parent?: EventExecutorGroup) {
-        super();
-        this._parent = parent;
-
-    }
-
-    get parent(): EventExecutorGroup {
-        return this._parent;
-    }
-
-    schedule(task: Runnable, delay: bigint, unit: Unit): ScheduledTask {
-        throw new Error('not implemented');
-    }
-
-    next(): EventExecutor {
-        return this;
-    }
-
-    abstract inEventLoop(): boolean;
-
-    abstract get ordered(): boolean
-
-    static safeExecute(task: Runnable) {
-        try {
-            task.run();
-        } catch (err) {
-            // todo
-            console.error(err);
-        }
-    }
-}
-
-export interface ScheduledTask {
-    cancel(): boolean
-    readonly deadline: PreciseTimeSpan
-    readonly completed: Promise<void>
-}
-
-export interface ScheduledRunnable extends Runnable, ScheduledTask {
-    run(): void
-}
-
-const SCHEDULED_TASK_COMPARATOR: Comparator<ScheduledTask> = (task1, task2) => {
-    return PreciseTimeSpan.COMPARATOR(task1.deadline, task2.deadline);
-}
-
-export class PreciseTimeSpan {
-    static readonly START_TIME = globalClock.nanoTime();
-
-    static readonly ZERO = new PreciseTimeSpan(0n);
-    static readonly MINUS_ONE = new PreciseTimeSpan(-1n);
-
-    private readonly _nanos: bigint;
-    private constructor(nanos: bigint) {
-        this._nanos = nanos;
-    }
-    get nanos(): bigint {
-        return this._nanos;
-    }
-    static fromNanos(nanos: bigint) {
-        return new PreciseTimeSpan(nanos);
-    }
-
-    static fromStart() {
-        return new PreciseTimeSpan(PreciseTimeSpan.getTimeChangeSinceStart());
-    }
-    static Deadline(nanosOrTimeSpan: bigint | PreciseTimeSpan) {
-        if (typeof nanosOrTimeSpan === 'bigint') {
-            return new PreciseTimeSpan(PreciseTimeSpan.getTimeChangeSinceStart() + nanosOrTimeSpan);
-        }
-        return new PreciseTimeSpan(PreciseTimeSpan.getTimeChangeSinceStart() + nanosOrTimeSpan.nanos);
-    }
-
-    static getTimeChangeSinceStart() {
-        return globalClock.nanoTime() - PreciseTimeSpan.START_TIME;
-    }
-
-    public static readonly COMPARATOR: Comparator<PreciseTimeSpan> = (ts1 , ts2) => {
-        return ts1.nanos > ts2.nanos ? 1 : (ts1.nanos < ts2.nanos ? -1 : 0);
-    }
-
-}
-
-
-export abstract class AbstractScheduledEventExecutor extends AbstractEventExecutor {
-
-    protected readonly _scheduledTaskQueue = new PriorityQueue<ScheduledRunnable>(SCHEDULED_TASK_COMPARATOR);
-
-    protected static getNanos(): PreciseTimeSpan {
-        return PreciseTimeSpan.fromStart();
-    }
-    protected isEmpty(taskQueue?: PriorityQueue<unknown>) {
-        return taskQueue === undefined || taskQueue.size === 0;
-    }
-
-    protected pollScheduledTask(nanos?: PreciseTimeSpan): ScheduledRunnable | undefined {
-        if (!this.inEventLoop()) {
-            throw new Error(`not in event loop`);
-        }
-        nanos ??= AbstractScheduledEventExecutor.getNanos();
-
-        const scheduledTask = this._scheduledTaskQueue.peek();
-        if (scheduledTask === undefined) {
-            return undefined;
-        }
-        if (scheduledTask.deadline.nanos < nanos.nanos) {
-            this._scheduledTaskQueue.dequeue();
-            return scheduledTask;
-        }
-        return undefined;
-    }
-
-    protected nextScheduledTaskNanos(){
-        const nextScheduledTask = this.peekScheduledTask();
-        return nextScheduledTask?.deadline ?? PreciseTimeSpan.MINUS_ONE;
-    }
-
-    protected peekScheduledTask(): ScheduledTask | undefined {
-        if (this.isEmpty(this._scheduledTaskQueue)) {
-            return undefined;
-        }
-        return this._scheduledTaskQueue.peek();
-    }
-
-    protected hasScheduledTasks(): boolean {
-        const scheduledTask = this.peekScheduledTask();
-        return scheduledTask !== undefined && scheduledTask.deadline.nanos <= PreciseTimeSpan.fromStart().nanos;
-    }
-
-    schedule(task: Runnable, delay: bigint, unit: Unit): ScheduledTask {
-        return this.addSchedule(new RunnableScheduledTask(this, task, PreciseTimeSpan.Deadline(convert('nanoseconds', delay, unit))));
-    }
-
-    get ordered(): true {
-        return true;
-    }
-
-    addSchedule(task: ScheduledRunnable): ScheduledRunnable {
-        if (this.inEventLoop()) {
-            this._scheduledTaskQueue.enqueue(task);
-        }
-        else {
-            this.execute((e, t) => {
-                (e as AbstractScheduledEventExecutor)._scheduledTaskQueue.enqueue(t as ScheduledRunnable);
-            }, this, task);
-        }
-        return task;
-    }
-
-    removeScheduled(task: ScheduledRunnable): void {
-        if (this.inEventLoop()) {
-            this._scheduledTaskQueue.remove(task);
-        }
-        else {
-            this.execute((e, t) => {
-                (e as AbstractScheduledEventExecutor)._scheduledTaskQueue.remove(t as ScheduledRunnable);
-            }, this, task);
-        }
-    }
-}
-
-export class PromiseCompletionSource<T = void> {
-    private _resolve: (value: T) => void;
-    private _reject: (reason?: any) => void;
-    private readonly _promise: Promise<T> = new Promise<T>((resolve, reject) => {
-        this._resolve = resolve;
-        this._reject = reject;
-        console.error('PromiseCompletionSource created', this._resolve);
-    });
-
-    private _result?: {value: T} | {reason: any} | {token: unknown}
-
-    tryResolve(value: T) {
-        if (this._result === undefined) {
-            this._result = {value};
-            this._resolve(value);
-            return true;
-        }
-        return false;
-    }
-
-    resolve(value: T) {
-        if (this._result !== undefined) {
-            throw new Error('already in final state');
-        }
-        this._result = {value};
-        this._resolve(value);
-    }
-
-    tryReject(reason?: any) {
-        if (this._result === undefined) {
-            this._result = {reason};
-            this._reject(reason);
-            return true;
-        }
-        return false;
-    }
-
-    reject(reason?: any) {
-        if (this._result !== undefined) {
-            throw new Error('already in final state');
-        }
-        this._result = {reason};
-        this._reject(reason);
-    }
-
-    tryCancel(token?: unknown) {
-        if (this._result === undefined) {
-            this._result = {token};
-            this._reject(new Error('canceled'));
-            return true;
-        }
-        return false;
-    }
-
-    cancel(token?: unknown) {
-        if (this._result !== undefined) {
-            throw new Error('already in final state')
-        }
-        this._result = {token};
-        this._reject(new Error('canceled'));
-    }
-
-    get promise() {
-        return this._promise;
-    }
-}
-
-export function rejectedPromise<T>(reason?: any): Promise<T> {
-    const tcp = new PromiseCompletionSource<T>();
-    tcp.tryReject(reason);
-    return tcp.promise;
-}
-const resolved = Promise.resolve();
-export function resolvedPromise(): Promise<void> {
-    return resolved;
-}
-export class TaskCancellablePromise extends PromiseCompletionSource {
-
-    private static createVoidTcp() {
-        const tcp = new TaskCancellablePromise();
-        tcp.tryComplete();
-        return tcp;
-    }
-    public static readonly Void = TaskCancellablePromise.createVoidTcp();
-
-    tryComplete() {
-        return this.tryResolve();
-    }
-
-    complete() {
-        return super.resolve();
-    }
-
-    setUncancellable() {
-        return true;
-    }
-}
-
-abstract class AbstractScheduledTask implements ScheduledRunnable {
-    protected readonly _executor: AbstractScheduledEventExecutor;
-    private readonly _deadline: PreciseTimeSpan;
-    protected readonly _completed: PromiseCompletionSource;
-
-    static readonly CancellationProhibited: number = 1;
-    static readonly CancellationRequested: number = 1 << 1;
-    private _cancelState: number = 0;
-
-    protected constructor(executor: AbstractScheduledEventExecutor, deadline: PreciseTimeSpan, completed: PromiseCompletionSource) {
-        this._executor = executor;
-        this._deadline = deadline;
-        this._completed = completed;
-    }
-
-    get deadline() {
-        return this._deadline;
-    }
-
-    cancel() {
-        if (!this.atomicCancellationStateUpdate(AbstractScheduledTask.CancellationRequested, AbstractScheduledTask.CancellationProhibited)) {
-            return false;
-        }
-        const canceled = this._completed.tryCancel();
-        if (canceled) {
-            this._executor.removeScheduled(this);
-        }
-        return canceled;
-    }
-
-    get completed(): Promise<void> {
-        return this._completed.promise;
-    }
-
-    run() {
-        if (this.trySetUncancellable()) {
-            try {
-                this.execute();
-                this._completed.tryResolve();
-            } catch (err) {
-                this._completed.tryReject(err);
-            }
-        }
-    }
-
-    protected abstract execute(): void;
-
-    trySetUncancellable() {
-        return this.atomicCancellationStateUpdate(AbstractScheduledTask.CancellationProhibited, AbstractScheduledTask.CancellationRequested);
-    }
-
-    private atomicCancellationStateUpdate(newBits: number, illegalBits: number) {
-        let cancelState = this._cancelState;
-        let oldCancelState: number;
-        do
-        {
-            oldCancelState = cancelState;
-            if ((cancelState & illegalBits) !== 0) {
-                return false;
-            }
-            cancelState = this._cancelState = (this._cancelState === cancelState ? cancelState | newBits : this._cancelState);
-        } while (cancelState !== oldCancelState);
-        return true;
-    }
-
-}
-
-class RunnableScheduledTask extends AbstractScheduledTask {
-    private readonly _action: Runnable;
-    constructor(executor: AbstractScheduledEventExecutor, action: Runnable, deadline: PreciseTimeSpan) {
-        super(executor, deadline, new TaskCancellablePromise())
-        this._action = action;
-    }
-
-    protected execute() {
-        this._action.run();
-    }
-}
-
-export abstract class AbstractEventExecutorGroup implements EventExecutorGroup {
-    abstract next(): EventExecutor;
-    execute(task: (...args:unknown[]) => void, ...args: unknown[]): void {
-        this.next().execute(task, ...args);
-    }
-    schedule(task: Runnable, delay: bigint, unit: Unit): ScheduledTask {
-        return this.next().schedule(task, delay, unit);
-    }
-    abstract get terminated(): Promise<void>;
-    abstract shutdown(): Promise<void>;
-}
-
-export type RejectedHandler = (task: () => void, executor: SingleThreadEventExecutor) => void;
-const REJECT: RejectedHandler = (task: () => void, executor: SingleThreadEventExecutor) => {throw new Error('reject');}
-
-export abstract class SingleThreadEventExecutor extends AbstractEventExecutor {
-    static readonly States = {
-        NOT_STARTED: 1,
-        STARTED: 2,
-        SHUTTING_DOWN: 3,
-        SHUTDOWN: 4,
-        TERMINATED: 5,
-    }
-    private _state: number = SingleThreadEventExecutor.States.NOT_STARTED;
-    private readonly _maxPending: number;
-    private readonly _rejectedHandler: RejectedHandler;
-    private readonly _terminated: Promise<void>;
-    private _completeTermination: () => void;
-
-    constructor(executor: Executor, parent?: EventExecutorGroup, maxPending: number = Number.MAX_SAFE_INTEGER, rejectedHandler: RejectedHandler = REJECT) {
-        super(parent);
-        this._maxPending = Math.max(16, maxPending);
-        this._rejectedHandler = rejectedHandler;
-        this._terminated = new Promise<void>((resolve, reject) => {
-            this._completeTermination = resolve;
-        })
-    }
-
-    get ordered(): true {
-        return true;
-    }
-
-    get terminated(): Promise<void> {
-        return this._terminated;
-    }
-
-    async shutdown() {
-        // todo
-        this._completeTermination();
-        return this._terminated;
-    }
-
-    public isShuttingDown() {
-        return this._state >= SingleThreadEventExecutor.States.SHUTTING_DOWN;
-    }
-
-    execute(task: () => void) {
-        setImmediate(() => {
-            task();
-        });
-    }
-
-    protected updateLastExecutionTime() {
-
-    }
-
-    protected confirmShutdown(): boolean {
-        if (!this.isShuttingDown()) {
-            return false;
-        }
-
-        if (!this.inEventLoop()) {
-            throw new Error("not in event loop");
-        }
-
-        // todo
-
-        return true;
-    }
-}
-

package/src/net/internal/AsyncSocketPromise.ts

@@ -1,37 +0,0 @@
-import {Socket} from 'node:net';
-import type {ByteBuffer} from '../../utils/buffer.ts';
-import {type FrameEncoder} from '../FrameEncoder.ts';
-
-export interface SocketPromise {
-    readonly success: boolean
-    readonly socket: Socket
-    promise: Promise<void>
-}
-
-export function writeAndFlush(socket: Socket, sending: { selfContained: boolean, buffer: ByteBuffer }): SocketPromise {
-    let success: boolean = false;
-    const promise = new Promise<void>((resolve, reject) => {
-        const encoder: FrameEncoder = socket['encoder'];
-        const {buffer, selfContained} = sending;
-        if (encoder) {
-            encoder.encode(selfContained, buffer);
-        }
-        const array = new Uint8Array(buffer.limit);
-        buffer.getUint8Array(array);
-        success = socket.write(array, (err: Error) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve();
-            }
-        });
-    })
-    return new class implements SocketPromise {
-        promise: Promise<void> = promise;
-        readonly socket: Socket = socket;
-
-        get success() {
-            return success;
-        }
-    };
-}

package/src/net/internal/channel/ChannelHandlerAdapter.ts

@@ -1,99 +0,0 @@
-import type {
-    ChannelHandler,
-    ChannelHandlerContext,
-    ChannelInboundHandler,
-    ChannelOutboundHandler,
-    SocketAddress
-} from './types.ts';
-
-export type ChannelHandlerMethods = keyof (ChannelHandler & ChannelInboundHandler & ChannelOutboundHandler);
-
-export abstract class ChannelHandlerAdapter implements ChannelHandler {
-    static readonly Shareable: boolean = false;
-    static readonly Skip: Array<ChannelHandlerMethods>  = ['errorCaught'];
-
-    handlerAdded(ctx: ChannelHandlerContext): void {
-        // no-op
-    }
-
-    handlerRemoved(ctx: ChannelHandlerContext): void {
-        // no-op
-    }
-
-    get shareable(): boolean {
-        return false;
-    }
-
-    added: boolean = false;
-}
-
-export class ChannelOutboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelOutboundHandler {
-    static readonly Skip: Array<keyof ChannelOutboundHandler> = ['onBind', 'onConnect', 'onDisconnect', 'onClose', 'onDeregister', 'onRead', 'onWrite', 'onFlush'];
-    onBind(ctx: ChannelHandlerContext, localAddress: SocketAddress): Promise<void> {
-        return ctx.bind(localAddress);
-    }
-
-    onConnect(ctx: ChannelHandlerContext, remoteAddress: SocketAddress, localAddress: SocketAddress): Promise<void> {
-        return ctx.connect(remoteAddress, localAddress);
-    }
-
-    onDisconnect(ctx: ChannelHandlerContext, ): Promise<void> {
-        return ctx.disconnect();
-    }
-
-    onClose(ctx: ChannelHandlerContext, error?: Error): Promise<void> {
-        return ctx.close(error);
-    }
-
-    onDeregister(ctx: ChannelHandlerContext): Promise<void> {
-        return ctx.deregister();
-    }
-
-    onRead(ctx: ChannelHandlerContext): void {
-        ctx.read();
-    }
-
-    onWrite(ctx: ChannelHandlerContext, message: unknown): Promise<void> {
-        return ctx.write(message);
-    }
-
-    onFlush(ctx: ChannelHandlerContext): void {
-        ctx.flush();
-    }
-}
-
-export class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
-    static readonly Skip: Array<ChannelHandlerMethods> = ['channelRegistered', 'channelUnregistered', 'channelActive', 'channelInactive', 'channelRead', 'channelReadComplete',  'channelWritabilityChanged', 'errorCaught'];
-
-    channelRegistered(ctx: ChannelHandlerContext) {
-        ctx.fireChannelRegistered();
-    }
-
-    channelUnregistered(ctx: ChannelHandlerContext) {
-        ctx.fireChannelUnregistered();
-    }
-
-    channelActive(ctx: ChannelHandlerContext) {
-        ctx.fireChannelActive();
-    }
-
-    channelInactive(ctx: ChannelHandlerContext) {
-        ctx.fireChannelInactive()
-    }
-
-    channelRead(ctx: ChannelHandlerContext, data: unknown) {
-        ctx.fireChannelRead(data);
-    }
-
-    channelReadComplete(ctx: ChannelHandlerContext) {
-        ctx.fireChannelReadComplete();
-    }
-
-    channelWritabilityChanged(ctx: ChannelHandlerContext) {
-        ctx.fireChannelWritabilityChanged();
-    }
-
-    errorCaught(ctx: ChannelHandlerContext, error: Error) {
-        ctx.fireErrorCaught(error);
-    }
-}