@serve.zone/interfaces 32.11.0 → 32.13.0

package/ts/data/clusternode.ts

@@ -1,6 +1,12 @@
 import * as plugins from '../plugins.js';
 import type { TSha256Digest, TImmutableContainerPlatform } from './immutableimage.js';
 import type { ISparkNodeReportRecord } from './sparknodereport.js';
+import {
+  validateFleetCutoverLocalNodeSnapshot,
+  validateFleetCutoverManagerSnapshot,
+  type IFleetCutoverLocalNodeSnapshot,
+  type IFleetCutoverManagerSnapshot,
+} from './fleetcutover.js';
 import { protocolRefusalHttpStatus, validateProtocolOfferOn, type IProtocolOffer } from '../protocol.js';
 import {
   canonicalizeStrictJson,
@@ -119,13 +125,13 @@ export const sparkSwarmNodeContracts = Object.freeze({
     maxResponseBytes: 2048,
   } as const),
   /**
-   * By far the largest of the four: a manager snapshot carries up to the 1024 observed nodes
-   * `validateSparkSwarmObservationRequest` admits, each with two identifiers of up to 200
-   * characters, which is close to 600 KiB of body this route must still be able to read.
+   * The largest route: beside 1024 observed nodes, a cutover observation may carry independently
+   * bounded local-container and manager-service snapshots. Four MiB covers those validators while
+   * preserving one transport-level refusal before JSON is accepted.
    */
   swarmObservation: Object.freeze({
     endpoint: '/spark/swarm-nodes/swarm-observation',
-    maxRequestBytes: 786_432,
+    maxRequestBytes: 4_194_304,
     maxResponseBytes: 2048,
   } as const),
   protocolRefusalStatus: protocolRefusalHttpStatus,
@@ -229,6 +235,8 @@ export type TSparkSwarmObservation =
       state: 'member';
       localSwarmNodeId: string;
       controlAvailable: false;
+      /** Local Docker-daemon evidence; it is accepted under this node's own credential. */
+      fleetCutoverLocalSnapshot?: IFleetCutoverLocalNodeSnapshot;
     })
   | (ISparkSwarmObservationBase & {
       state: 'member';
@@ -236,6 +244,10 @@ export type TSparkSwarmObservation =
       localSwarmNodeId: string;
       controlAvailable: true;
       managerSnapshot?: ISwarmManagerSnapshot;
+      /** A manager still reports physical containers only from its own local Docker daemon. */
+      fleetCutoverLocalSnapshot?: IFleetCutoverLocalNodeSnapshot;
+      /** Manager-visible services/tasks only; it never claims remote physical containers. */
+      fleetCutoverManagerSnapshot?: IFleetCutoverManagerSnapshot;
     });
 
 export type TSparkSwarmObservationRejectionCode =
@@ -573,7 +585,13 @@ export const validateSparkSwarmObservation = async (
       : observation.state === 'not-member'
         ? commonKeys
         : observation.state === 'member' && observation.controlAvailable === false
-          ? [...commonKeys, 'localSwarmNodeId', 'controlAvailable']
+          ? [
+              ...commonKeys,
+              'localSwarmNodeId',
+              'controlAvailable',
+              ...(observation.fleetCutoverLocalSnapshot === undefined
+                ? [] : ['fleetCutoverLocalSnapshot']),
+            ]
           : observation.state === 'member' && observation.controlAvailable === true
             ? [
                 ...commonKeys,
@@ -581,6 +599,10 @@ export const validateSparkSwarmObservation = async (
                 'localSwarmNodeId',
                 'controlAvailable',
                 ...(observation.managerSnapshot === undefined ? [] : ['managerSnapshot']),
+                ...(observation.fleetCutoverLocalSnapshot === undefined
+                  ? [] : ['fleetCutoverLocalSnapshot']),
+                ...(observation.fleetCutoverManagerSnapshot === undefined
+                  ? [] : ['fleetCutoverManagerSnapshot']),
               ]
             : [];
     if (expectedKeys.length === 0 || !hasExactKeys(observation, expectedKeys)) {
@@ -602,6 +624,17 @@ export const validateSparkSwarmObservation = async (
         || typeof observation.controlAvailable !== 'boolean') {
         errors.push('Spark Swarm member observation must have canonical local authority');
       }
+      if (observation.fleetCutoverLocalSnapshot !== undefined) {
+        const localErrors = await validateFleetCutoverLocalNodeSnapshot(
+          observation.fleetCutoverLocalSnapshot,
+        );
+        errors.push(...localErrors.map(errorArg => `Spark Swarm observation ${errorArg}`));
+        if (isRuntimeRecord(observation.fleetCutoverLocalSnapshot)
+          && observation.fleetCutoverLocalSnapshot.swarmNodeId
+            !== observation.localSwarmNodeId) {
+          errors.push('Spark Swarm cutover local snapshot must name the local Swarm node');
+        }
+      }
       if (observation.controlAvailable === true) {
         if (!isRuntimeIdentifier(observation.swarmClusterId)) {
           errors.push('Spark Swarm manager observation must have canonical cluster authority');
@@ -613,6 +646,23 @@ export const validateSparkSwarmObservation = async (
             observation.managerSnapshot,
           ));
         }
+        if (observation.fleetCutoverManagerSnapshot !== undefined) {
+          if (observation.managerSnapshot === undefined) {
+            errors.push('Spark Swarm cutover manager snapshot requires the same manager observation');
+          }
+          const managerErrors = await validateFleetCutoverManagerSnapshot(
+            observation.fleetCutoverManagerSnapshot,
+          );
+          errors.push(...managerErrors.map(errorArg => `Spark Swarm observation ${errorArg}`));
+          if (isRuntimeRecord(observation.fleetCutoverManagerSnapshot)
+            && isRuntimeRecord(observation.fleetCutoverManagerSnapshot.inventory)) {
+            const cutoverInventory = observation.fleetCutoverManagerSnapshot.inventory;
+            if (cutoverInventory.swarmClusterId !== observation.swarmClusterId
+              || cutoverInventory.managerSwarmNodeId !== observation.localSwarmNodeId) {
+              errors.push('Spark Swarm cutover manager snapshot must name the observed authority');
+            }
+          }
+        }
       }
     }
     return errors;