@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/spots/spot-native-actor-join-admission.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkSpotNativeActorJoinAdmission = void 0;
-const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const runtime_message_1 = require("../backend/runtime-message");
-const payload_codec_1 = require("../messaging/payload-codec");
-const spot_remote_codec_1 = require("./spot-remote-codec");
-class ZLinkSpotNativeActorJoinAdmission {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async admit(request, rejectClosing = false) {
-        const actorId = request.info.targetActor.actorId;
-        let accepted = false;
-        let acceptedActor;
-        let reply;
-        const decoded = this.decodeNativeActorJoinRequest(request.message);
-        try {
-            if (decoded !== undefined) {
-                throw new Error('Remote actor join requires the two-phase routed transfer protocol.');
-            }
-            const actor = this.options.resolveActor(actorId);
-            if (!rejectClosing && actor !== undefined) {
-                const target = this.options.getTarget();
-                const joinRequest = request.message;
-                const joinPayload = (0, payload_codec_1.wrapFrameworkPayloadMessage)(joinRequest, this.options.messageSerializers);
-                const response = await this.options.serial.execute(async () => this.options.defaultAccept || target.onActorJoin === undefined
-                    ? { accepted: this.options.defaultAccept }
-                    : target.onActorJoin(actorId, joinPayload));
-                accepted = response.accepted;
-                reply =
-                    response.reply === undefined
-                        ? undefined
-                        : (0, payload_codec_1.encodeFrameworkPayloadMessage)(response.reply, this.options.messageSerializers);
-                if (accepted) {
-                    acceptedActor = actor;
-                }
-            }
-        }
-        catch (error) {
-            this.reportHandlerException(actorId, error);
-            accepted = false;
-            reply?.close();
-            reply = undefined;
-        }
-        const operation = this.options.nativeSpot.replyActorJoin(request, accepted ? 0 : 1);
-        let submitted = false;
-        try {
-            if (reply !== undefined) {
-                operation.message(reply);
-            }
-            operation.submit();
-            submitted = true;
-        }
-        finally {
-            if (!submitted) {
-                reply?.close();
-            }
-            decoded?.request.close();
-            decoded?.actorCreateRequest?.close();
-        }
-        if (acceptedActor !== undefined) {
-            try {
-                // The native reply commits the actor's return to the Entry Spot. Publish
-                // the immutable membership callback only after that commit so observers
-                // never see an accepted membership before Core does.
-                await this.options.commitAcceptedActor?.(acceptedActor);
-            }
-            catch (error) {
-                this.reportHandlerException(actorId, error);
-            }
-        }
-    }
-    decodeNativeActorJoinRequest(message) {
-        try {
-            const payload = JSON.parse(message.data().toString());
-            if (payload.packetName !== spot_remote_codec_1.REMOTE_ACTOR_JOIN_PACKET ||
-                typeof payload.actorType !== 'string' ||
-                typeof payload.request !== 'string') {
-                return undefined;
-            }
-            return {
-                actorType: payload.actorType,
-                actorCreateRequest: typeof payload.actorCreateRequest === 'string'
-                    ? runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-                    : undefined,
-                request: runtime_message_1.ZLinkBufferMessage.from(Buffer.from(payload.request, 'base64'))
-            };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    reportHandlerException(actorId, error) {
-        this.options.dispatchErrors?.report({
-            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor,
-            messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend,
-            reason: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException,
-            action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
-            actorId,
-            error
-        });
-    }
-}
-exports.ZLinkSpotNativeActorJoinAdmission = ZLinkSpotNativeActorJoinAdmission;

package/src/runtime/actors/post-commit-actor-location.ts

@@ -1,121 +0,0 @@
-import type { RoutingId } from '../../contracts';
-import { ZLinkStateLane } from '../execution/state-lane';
-import type { ZLinkLocationLifecycle } from '../locations';
-import { ZLinkActorRetryDelay } from './actor-retry-delay';
-
-export interface ZLinkPostCommitActorLocationOptions {
-  readonly lifecycle: ZLinkLocationLifecycle;
-  readonly reportError?: (error: unknown) => void;
-  readonly signal?: AbortSignal;
-}
-
-interface ActorOperationQueue {
-  readonly operations: Array<(() => Promise<void>) | undefined>;
-  head: number;
-  count: number;
-}
-
-export class ZLinkPostCommitActorLocation {
-  private readonly lane = new ZLinkStateLane();
-  private readonly queues = new Map<string, ActorOperationQueue>();
-  private readonly tasks = new Map<string, Promise<void>>();
-
-  constructor(private readonly options: ZLinkPostCommitActorLocationOptions) {}
-
-  joinedEventually(
-    actorType: string,
-    actorId: string,
-    meshName: string,
-    spotId: RoutingId,
-    spotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorJoinedSpot(
-        actorType,
-        actorId,
-        meshName,
-        spotId,
-        spotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  leftEventually(
-    actorType: string,
-    actorId: string,
-    entrySpotId: RoutingId,
-    entrySpotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): void {
-    this.enqueue(actorId, () =>
-      this.options.lifecycle.notifyActorLeftSpot(
-        actorType,
-        actorId,
-        entrySpotId,
-        entrySpotGeneration,
-        membershipEpoch,
-        ownerNodeGeneration
-      )
-    );
-  }
-
-  private enqueue(actorId: string, operation: () => Promise<void>): void {
-    const queue = this.queues.get(actorId) ?? { operations: [], head: 0, count: 0 };
-    queue.operations.push(operation);
-    queue.count += 1;
-    this.queues.set(actorId, queue);
-    if (this.tasks.has(actorId)) {
-      return;
-    }
-    let task!: Promise<void>;
-    task = this.run(actorId).finally(
-      async () =>
-        await this.lane.run(() => {
-          if (this.tasks.get(actorId) === task) {
-            this.tasks.delete(actorId);
-          }
-        })
-    );
-    this.tasks.set(actorId, task);
-  }
-
-  private async run(actorId: string): Promise<void> {
-    const retryDelay = new ZLinkActorRetryDelay();
-    while (this.options.signal?.aborted !== true) {
-      const queue = this.queues.get(actorId);
-      const operation = queue?.operations[queue.head];
-      if (queue === undefined || operation === undefined) {
-        this.queues.delete(actorId);
-        return;
-      }
-      try {
-        await operation();
-        await this.lane.run(() => this.completeCore(queue));
-        retryDelay.reset();
-      } catch (error) {
-        this.options.reportError?.(error);
-        if (!(await retryDelay.wait(this.options.signal))) {
-          return;
-        }
-      }
-    }
-  }
-
-  private completeCore(queue: ActorOperationQueue): void {
-    queue.operations[queue.head] = undefined;
-    queue.head += 1;
-    queue.count -= 1;
-    if (queue.count === 0) {
-      queue.operations.length = 0;
-      queue.head = 0;
-    } else if (queue.head >= 1024 && queue.head * 2 >= queue.operations.length) {
-      queue.operations.splice(0, queue.head);
-      queue.head = 0;
-    }
-  }
-}

package/src/runtime/spots/spot-native-actor-join-admission.ts

@@ -1,155 +0,0 @@
-import type {
-  ZLinkActor,
-  ZLinkMessage,
-  ZLinkMessageSerializer,
-  ZLinkSpotActorJoinResult
-} from '../../contracts';
-import {
-  ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
-  ZLinkRuntimeDispatchErrorReason as ZLinkDispatchErrorReason,
-  ZLinkDispatchErrorSurface,
-  ZLinkDispatchMessageKind
-} from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { Message } from '../../contracts/Common/Message';
-import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import type { ZLinkBackendActorJoinRequest, ZLinkBackendSpot } from '../backend/contracts';
-import type { ZLinkDispatchErrorReporter } from '../channels';
-import {
-  encodeFrameworkPayloadMessage,
-  wrapFrameworkPayloadMessage
-} from '../messaging/payload-codec';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import { REMOTE_ACTOR_JOIN_PACKET } from './spot-remote-codec';
-
-interface ZLinkNativeActorJoinAdmissionTarget {
-  onActorJoin?(actorId: string, request: ZLinkMessage): Promise<ZLinkSpotActorJoinResult>;
-  onJoinedActor?(actor: ZLinkActor): Promise<void>;
-}
-
-interface ZLinkSpotNativeActorJoinAdmissionOptions {
-  readonly nativeSpot: ZLinkBackendSpot;
-  readonly serial: ZLinkSpotSerialTurnExecutor;
-  readonly resolveActor: (actorId: string) => ZLinkActor | undefined;
-  readonly getTarget: () => ZLinkNativeActorJoinAdmissionTarget;
-  readonly defaultAccept: boolean;
-  readonly commitAcceptedActor?: (actor: ZLinkActor) => Promise<void>;
-  readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
-  readonly dispatchErrors?: ZLinkDispatchErrorReporter;
-}
-
-export class ZLinkSpotNativeActorJoinAdmission {
-  constructor(private readonly options: ZLinkSpotNativeActorJoinAdmissionOptions) {}
-
-  async admit(request: ZLinkBackendActorJoinRequest, rejectClosing = false): Promise<void> {
-    const actorId = request.info.targetActor.actorId;
-    let accepted = false;
-    let acceptedActor: ZLinkActor | undefined;
-    let reply: Message | undefined;
-    const decoded = this.decodeNativeActorJoinRequest(request.message);
-    try {
-      if (decoded !== undefined) {
-        throw new Error('Remote actor join requires the two-phase routed transfer protocol.');
-      }
-      const actor = this.options.resolveActor(actorId);
-      if (!rejectClosing && actor !== undefined) {
-        const target = this.options.getTarget();
-        const joinRequest = request.message;
-        const joinPayload = wrapFrameworkPayloadMessage(
-          joinRequest,
-          this.options.messageSerializers
-        );
-        const response: ZLinkSpotActorJoinResult = await this.options.serial.execute(async () =>
-          this.options.defaultAccept || target.onActorJoin === undefined
-            ? { accepted: this.options.defaultAccept }
-            : target.onActorJoin(actorId, joinPayload)
-        );
-        accepted = response.accepted;
-        reply =
-          response.reply === undefined
-            ? undefined
-            : encodeFrameworkPayloadMessage(response.reply, this.options.messageSerializers);
-        if (accepted) {
-          acceptedActor = actor;
-        }
-      }
-    } catch (error) {
-      this.reportHandlerException(actorId, error);
-      accepted = false;
-      reply?.close();
-      reply = undefined;
-    }
-    const operation = this.options.nativeSpot.replyActorJoin(request, accepted ? 0 : 1);
-    let submitted = false;
-    try {
-      if (reply !== undefined) {
-        operation.message(reply);
-      }
-      operation.submit();
-      submitted = true;
-    } finally {
-      if (!submitted) {
-        reply?.close();
-      }
-      decoded?.request.close();
-      decoded?.actorCreateRequest?.close();
-    }
-    if (acceptedActor !== undefined) {
-      try {
-        // The native reply commits the actor's return to the Entry Spot. Publish
-        // the immutable membership callback only after that commit so observers
-        // never see an accepted membership before Core does.
-        await this.options.commitAcceptedActor?.(acceptedActor);
-      } catch (error) {
-        this.reportHandlerException(actorId, error);
-      }
-    }
-  }
-
-  private decodeNativeActorJoinRequest(message: Message):
-    | {
-        readonly actorType: string;
-        readonly actorCreateRequest?: Message;
-        readonly request: Message;
-      }
-    | undefined {
-    try {
-      const payload = JSON.parse(message.data().toString()) as {
-        readonly packetName?: unknown;
-        readonly actorType?: unknown;
-        readonly actorNodeRid?: unknown;
-        readonly actorNodeRidHex?: unknown;
-        readonly actorGeneration?: unknown;
-        readonly actorCreateRequest?: unknown;
-        readonly request?: unknown;
-      };
-      if (
-        payload.packetName !== REMOTE_ACTOR_JOIN_PACKET ||
-        typeof payload.actorType !== 'string' ||
-        typeof payload.request !== 'string'
-      ) {
-        return undefined;
-      }
-      return {
-        actorType: payload.actorType,
-        actorCreateRequest:
-          typeof payload.actorCreateRequest === 'string'
-            ? RuntimeMessage.from(Buffer.from(payload.actorCreateRequest, 'base64'))
-            : undefined,
-        request: RuntimeMessage.from(Buffer.from(payload.request, 'base64'))
-      };
-    } catch {
-      return undefined;
-    }
-  }
-
-  private reportHandlerException(actorId: string, error: unknown): void {
-    this.options.dispatchErrors?.report({
-      surface: ZLinkDispatchErrorSurface.SpotActor,
-      messageKind: ZLinkDispatchMessageKind.ActorSend,
-      reason: ZLinkDispatchErrorReason.HandlerException,
-      action: ZLinkDispatchErrorAction.Drop,
-      actorId,
-      error
-    });
-  }
-}