@serve.zone/interfaces 32.68.0 → 32.70.0

package/dist_ts/data/sparknodereport.d.ts

@@ -1,4 +1,5 @@
 import { type IProtocolOffer } from '../protocol.js';
+import type { TNodeActionName } from './clusternode.js';
 /** Host observations only. Container and workload readiness belong to Pallet. */
 export interface ISparkNodeReport {
     observedAt: number;
@@ -27,6 +28,24 @@ export interface ISparkNodeReport {
      * it made one since it started. Whether the node carries the hostname is `runtime.hostname`.
      */
     hostApply?: ISparkNodeHostApply;
+    /**
+     * The host's boot, stated by a Spark that executes node actions: how Cloudly verifies an action
+     * that reboots (`nodeActionVerification`) and whether the host waits for a reboot.
+     */
+    boot?: ISparkNodeBoot;
+    /**
+     * The node actions this Spark executes (`sparkNodeActionContracts`), in canonical order. Cloudly
+     * admits a node runtime action only for a node whose report states its executor, so an action
+     * Spark cannot execute is refused when it is requested rather than left to expire.
+     */
+    actionExecutors?: TNodeActionName[];
+}
+/** One boot of the host. */
+export interface ISparkNodeBoot {
+    /** The kernel's `boot_id` (`/proc/sys/kernel/random/boot_id`), a lowercase UUID; it changes with every boot. */
+    id: string;
+    /** Whether the host states that a package it installed waits for a reboot (`/var/run/reboot-required`). */
+    rebootRequired: boolean;
 }
 /** Whether Spark applied a desired hostname: `applied` once the host carries it. */
 export type TSparkNodeHostApplyOutcome = 'applied' | 'failed';

package/dist_ts/data/sparknodereport.js

@@ -3,6 +3,7 @@ import { readDataProperties, readExactDataRecord } from '../private/dataproperti
 import { isClusterNodeId } from '../private/nodeidentifier.js';
 import { protocolRefusalHttpStatus, readProtocolOffer } from '../protocol.js';
 import { isClusterNodeHostname } from './clusternodehostname.js';
+import { isHostBootId, isNodeActionNameList } from './nodeaction.js';
 /** Bounds of `ISparkNodeHostApply.reason`. */
 export const sparkNodeHostApplyContract = Object.freeze({
     maximumReasonLength: 512,
@@ -72,8 +73,10 @@ export const snapshotSparkNodeReport = (valueArg) => {
     const reportKeys = ['observedAt', 'metrics', 'runtime'];
     const properties = readDataProperties(valueArg);
     requireValue(properties !== null);
-    const hasHostApply = Object.hasOwn(properties, 'hostApply');
-    const value = record(valueArg, hasHostApply ? [...reportKeys, 'hostApply'] : reportKeys);
+    // Each optional member is read exactly when the report states it, so a report without them is
+    // the report an earlier Spark sends and is read the way an earlier reader read it.
+    const optionalKeys = ['hostApply', 'boot', 'actionExecutors'].filter((keyArg) => Object.hasOwn(properties, keyArg));
+    const value = record(valueArg, [...reportKeys, ...optionalKeys]);
     const metrics = record(value.metrics, ['cpuUsagePercent', 'memoryUsedMB', 'memoryAvailableMB',
         'diskUsedGB', 'diskAvailableGB']);
     const runtime = record(value.runtime, ['hostname', 'platform', 'arch', 'osRelease', 'bundle',
@@ -100,9 +103,23 @@ export const snapshotSparkNodeReport = (valueArg) => {
             }),
             localRuntimeReady: true, workloadReadiness: 'unverified',
         }),
-        ...(hasHostApply ? { hostApply: snapshotSparkNodeHostApply(value.hostApply) } : {}),
+        ...(optionalKeys.includes('hostApply') ? { hostApply: snapshotSparkNodeHostApply(value.hostApply) } : {}),
+        ...(optionalKeys.includes('boot') ? { boot: snapshotSparkNodeBoot(value.boot) } : {}),
+        ...(optionalKeys.includes('actionExecutors')
+            ? { actionExecutors: snapshotActionExecutors(value.actionExecutors) } : {}),
     });
 };
+/** One `boot`: exactly its keys. */
+const snapshotSparkNodeBoot = (valueArg) => {
+    const value = record(valueArg, ['id', 'rebootRequired']);
+    requireValue(isHostBootId(value.id) && typeof value.rebootRequired === 'boolean');
+    return Object.freeze({ id: value.id, rebootRequired: value.rebootRequired });
+};
+/** One `actionExecutors`: a canonical list of at least one action name, detached and frozen. */
+const snapshotActionExecutors = (valueArg) => {
+    requireValue(isNodeActionNameList(valueArg));
+    return Object.freeze([...valueArg]);
+};
 export const snapshotSparkNodeHeartbeatRequest = (valueArg) => {
     const value = record(valueArg, ['nodeId', 'nodeToken', 'protocol', 'report']);
     return Object.freeze({
@@ -163,4 +180,4 @@ export const snapshotSparkNodeDesiredHost = (valueArg) => {
         protocol: readProtocolOffer(value),
     });
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparknodereport.js","sourceRoot":"","sources":["../../ts/data/sparknodereport.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparknodereport.js","sourceRoot":"","sources":["../../ts/data/sparknodereport.ts"],"names":[],"mappings":"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"}

package/dist_ts/requests/backup.d.ts

@@ -45,6 +45,14 @@ export interface IReq_Any_Cloudly_RestoreServiceBackup extends plugins.typedrequ
         backupId: string;
         clear?: boolean;
         resourceTypes?: Array<TBackupSnapshot['type']>;
+        /**
+         * Must be `true` to restore a `failed` backup whose failure is `incomplete`, and is refused for
+         * any other backup. Such a restore restores what the backup captured: `resourceTypes` is
+         * required and names only types it captured, none of the resources it did not capture
+         * (`failure.uncaptured`) is restored, so the service then holds data from two points in time,
+         * and the backup stays `failed`.
+         */
+        confirmPartialRestore?: boolean;
     };
     response: {
         backup: IBackupRecord;

package/dist_ts/requests/node.d.ts

@@ -3,6 +3,8 @@ import type { IBareMetal } from '../data/baremetal.js';
 import type { ICluster } from '../data/cluster.js';
 import type { IClusterNode, INodeAction, INodeMetricsSample, TNodeActionName } from '../data/clusternode.js';
 import type { IDeployment } from '../data/deployment.js';
+import type { INodeActionConfirmation, INodeActionPreview } from '../data/nodeaction.js';
+import type { ISparkFleetTarget, ISparkFleetTargetChange, ISparkNodeTargetHold } from '../data/sparkfleettarget.js';
 import type { IIdentity } from '../data/user.js';
 import type { IPlatformObjectStorageEndpoint } from '../platform/objectstorage.js';
 import type { IPlatformDatabaseEndpoint } from '../platform/database.js';
@@ -342,6 +344,18 @@ export interface IReq_Any_Cloudly_ResetClusterNodeHostname extends plugins.typed
         node: IClusterNode;
     };
 }
+/**
+ * An administrator requests one action on one node.
+ *
+ * A node whose Swarm-era daemon reports last receives it as before, in the metrics-sample answer;
+ * `confirmation` is not read for it. A node that reports through the node runtime is sent the
+ * action only with a `confirmation` (`data.validateNodeActionConfirmation`) of the preview the
+ * administrator read (`getNodeActionPreview`): the typed hostname, the impact digest, when the
+ * impact names a Corestore on the node the consent to restart it, and for an update the fleet Spark
+ * target revision the preview showed. The action then carries
+ * `lifecycle`, with the confirmation, the impact and, for an update, the fleet target frozen in it.
+ * Every refusal is one of `data.nodeActionRefusals` and changes nothing.
+ */
 export interface IReq_Any_Cloudly_CreateNodeAction extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_CreateNodeAction> {
     method: 'createNodeAction';
     request: {
@@ -349,11 +363,97 @@ export interface IReq_Any_Cloudly_CreateNodeAction extends plugins.typedrequestI
         nodeId: string;
         actionName: TNodeActionName;
         payload?: INodeAction['payload'];
+        confirmation?: INodeActionConfirmation;
+    };
+    response: {
+        action: INodeAction;
+    };
+}
+/**
+ * An administrator previews one action on one node that reports through the node runtime: what it
+ * interrupts, read from Cloudly's database, the digest a confirmation names, and every reason a
+ * request would be refused now. A preview changes nothing.
+ */
+export interface IReq_Any_Cloudly_GetNodeActionPreview extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetNodeActionPreview> {
+    method: 'getNodeActionPreview';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        actionName: TNodeActionName;
+    };
+    response: {
+        preview: INodeActionPreview;
+    };
+}
+/**
+ * An administrator withdraws one node runtime action while it is still `pending`, at the revision
+ * they read. A claimed action is never withdrawn: Spark may already have stopped the node.
+ */
+export interface IReq_Any_Cloudly_CancelNodeAction extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_CancelNodeAction> {
+    method: 'cancelNodeAction';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        actionId: string;
+        expectedRevision: number;
     };
     response: {
         action: INodeAction;
     };
 }
+/**
+ * An administrator reads the fleet Spark target (`data.ISparkFleetTarget`, `null` while there is
+ * none), its newest changes and every node hold.
+ */
+export interface IReq_Any_Cloudly_GetSparkFleetTarget extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetSparkFleetTarget> {
+    method: 'getSparkFleetTarget';
+    request: {
+        identity: IIdentity;
+    };
+    response: {
+        target: ISparkFleetTarget | null;
+        /** Newest first, at most `data.sparkFleetTargetContract.historyLimit`. */
+        history: ISparkFleetTargetChange[];
+        /** Sorted by node id. */
+        holds: ISparkNodeTargetHold[];
+    };
+}
+/**
+ * An administrator sets the fleet Spark target to one release version, at the revision they read
+ * (`0` while there is none). Cloudly reads the release's `SHA256SUMS.txt` and `install.sh`, refuses
+ * any mismatch between them, and stores the version with the SHA-256 it checked. Every refusal is
+ * one of `data.sparkFleetTargetRefusals`.
+ */
+export interface IReq_Any_Cloudly_SetSparkFleetTarget extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_SetSparkFleetTarget> {
+    method: 'setSparkFleetTarget';
+    request: {
+        identity: IIdentity;
+        /** `data.validateSetSparkFleetTargetInput` judges these two. */
+        version: string;
+        expectedRevision: number;
+    };
+    response: {
+        target: ISparkFleetTarget;
+    };
+}
+/**
+ * An administrator holds one node at the release it runs (`hold: { reason }`) or releases it
+ * (`hold: null`). Answers the hold as it now stands.
+ */
+export interface IReq_Any_Cloudly_SetSparkNodeTargetHold extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_SetSparkNodeTargetHold> {
+    method: 'setSparkNodeTargetHold';
+    request: {
+        identity: IIdentity;
+        nodeId: string;
+        /** `data.validateSparkNodeTargetHoldInput` judges it. */
+        hold: {
+            reason: string;
+        } | null;
+    };
+    response: {
+        hold: ISparkNodeTargetHold | null;
+    };
+}
 export interface IReq_Any_Cloudly_GetNodeActions extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_Any_Cloudly_GetNodeActions> {
     method: 'getNodeActions';
     request: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.68.0",
+  "version": "32.70.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {

package/readme.md

@@ -216,6 +216,53 @@ next heartbeat; the node has converged when `runtime.hostname` states the intent
 hostname. A Spark that sends `hostApply` raises its `minimumPeerVersion` so it
 reaches only a Cloudly that reads it.
 
+### Node Actions
+
+A node action (`INodeAction`: reboot, serve.zone service update, system upgrade)
+that a node runtime executes carries `lifecycle` (`INodeActionLifecycle`): the
+administrator's confirmation (`INodeActionConfirmation`: the typed hostname, the
+digest of the impact preview they read, when the impact names a Corestore on the
+node the consent to restart it, and for an update the fleet Spark target revision
+the preview showed, refused `target-changed` once the target moved), the impact (`INodeActionImpact`), the fleet
+Spark target an update moves the node to, a revision, the current deadline, the
+claim, a failure with its remedy and a timeline. A Swarm-era record carries none of
+it and travels only in the Swarm-era metrics-sample answer. `TNodeActionStatus`
+keeps the four shipped values (`pending` is the requested state) and adds
+`claimed`, `executing`, `draining`, `rebooting`, `verifying`, `expired`,
+`cancelled` and `unverified`; `data.nodeActionStatusKinds` states which are open.
+
+`data.sparkNodeActionContracts` defines the node runtime's two action routes,
+authenticated and judged in the heartbeat's order: `offer` (`/spark/nodes/action`)
+answers the node's one open action (`ISparkNodeActionAssignment`) or `null`, and
+`transition` (`/spark/nodes/action/transition`) takes one step at the revision the
+assignment states — `claim` with the host's boot id, a forward `phase`
+(`sparkNodeActionPhaseOrder`), `complete` (a host upgrade without a reboot) or
+`fail` with one of `sparkNodeActionFailureCodes` — and answers `applied`,
+`replayed` (the same step again at the same revision) or a named refusal.
+`data.admitsSparkNodeActionTransition` states which step an action admits.
+Cloudly verifies every action from what the node reports
+(`data.nodeActionVerification`): a new `boot.id`, the target bundle version, or a
+completed host upgrade; a heartbeat stating `boot.rebootRequired` after a host
+upgrade fails it `reboot-required` rather than rebooting. A deadline
+(`data.nodeActionCompletionBudgetMs`, `nodeActionContract`) that passes ends an
+action `unverified`.
+
+A Spark that executes actions states `ISparkNodeReport.boot` (the kernel boot id
+and whether the host waits for a reboot) and `actionExecutors`, the canonical list
+of action names it executes; Cloudly admits an action only for a node that states
+its executor. Both are optional members an earlier reader refuses, so a Spark sends
+them only to a Cloudly that reads them, like `hostApply`.
+
+`data.ISparkFleetTarget` is the one fleet Spark target: a version and the SHA-256
+its release's `SHA256SUMS.txt` states for `install.sh`, with a revision, who set
+it and when, an append-only history (`ISparkFleetTargetChange`) and per-node
+holds (`ISparkNodeTargetHold`). `data.readSparkNodeTargetStanding` places a node
+at, behind or ahead of it, held, unreported or untargeted. The admin requests
+(`getNodeActionPreview`, `createNodeAction` with `confirmation`,
+`cancelNodeAction`, `getSparkFleetTarget`, `setSparkFleetTarget`,
+`setSparkNodeTargetHold`) answer refusals by name from `data.nodeActionRefusals`
+and `data.sparkFleetTargetRefusals`.
+
 The snapshot functions reject unknown keys, accessors, malformed identities and
 nonfinite/out-of-range numbers, then return detached frozen records. Transports
 own byte limits, timeouts and cancellation. These contracts do not implement a

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '32.68.0',
+  version: '32.70.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/backup.ts

@@ -72,10 +72,46 @@ export interface IBackupReplicationResult {
   completedAt: number;
 }
 
+/**
+ * One resource a service declares that a backup of it did not capture, with why; each kind of
+ * resource has its own reason.
+ *
+ * `volume-capture-unavailable`: a service volume is a node-local storage claim on its Pallet node,
+ * which no relay can capture yet; a `volume` snapshot is a Corestore Docker volume and captures no
+ * service volume. `binding-not-snapshotted`: the backup holds no snapshot of the Corestore resource
+ * the binding names.
+ */
+export type TBackupUncapturedResource =
+  | { type: 'volume'; mountPath: string; reason: 'volume-capture-unavailable' }
+  | { type: 'database' | 'objectstorage'; bindingId: string; reason: 'binding-not-snapshotted' };
+
+/** Why a resource a service declares is not in one of its backups (`TBackupUncapturedResource`). */
+export type TBackupUncapturedReason = TBackupUncapturedResource['reason'];
+
+/**
+ * The named kind of a `failed` backup's failure; a failure without one is named only in `errorText`.
+ *
+ * `incomplete`: the backup did not capture every resource its service declares, and `uncaptured`
+ * names each one it missed. What it did capture is restored only by a partial restore an
+ * administrator confirms (`IReq_Any_Cloudly_RestoreServiceBackup` `confirmPartialRestore`), which
+ * restores none of `uncaptured`, and the backup stays `failed`.
+ * `archive-unreadable`: its stored archive is missing or damaged, so it restores nothing.
+ */
+export type TBackupFailure =
+  | { kind: 'incomplete'; uncaptured: TBackupUncapturedResource[] }
+  | { kind: 'archive-unreadable' };
+
 export interface IBackupRestoreEvent {
   restoredAt: number;
   status: 'restored' | 'failed';
   errorText?: string;
+  /** The resource types the restore was limited to; absent when it restored every snapshot. */
+  resourceTypes?: TBackupResourceType[];
+  /**
+   * A confirmed partial restore of an `incomplete` backup: it restored only `resourceTypes`, and
+   * none of the backup's `failure.uncaptured`.
+   */
+  partial?: true;
 }
 
 /**
@@ -114,6 +150,8 @@ export interface IBackupRecord {
   completedAt?: number;
   requestedBy?: string;
   errorText?: string;
+  /** The named kind of a `failed` backup's failure (`TBackupFailure`). */
+  failure?: TBackupFailure;
   restoreHistory?: IBackupRestoreEvent[];
   /**
    * Authoritative isolated-restore holds. Cloudly atomically appends the
@@ -124,6 +162,25 @@ export interface IBackupRecord {
   tags?: Record<string, string>;
 }
 
+/**
+ * The resource types a partial restore of a backup may name (`confirmPartialRestore`).
+ *
+ * For a `failed` backup whose failure is `incomplete`: every type it holds a snapshot of, except
+ * `volume` (a `volume` snapshot is a Corestore Docker volume and captures no service volume) and the
+ * type of any resource it did not capture, so a partial restore never restores a snapshot standing
+ * for a resource the backup missed. For every other backup: none. Database before object storage.
+ */
+export const readPartialRestoreResourceTypes = (
+  backupArg: Pick<IBackupRecord, 'status' | 'failure'> & { snapshots: ReadonlyArray<Pick<TBackupSnapshot, 'type'>> },
+): Array<Exclude<TBackupResourceType, 'volume'>> => {
+  const failure = backupArg.failure;
+  if (backupArg.status !== 'failed' || failure?.kind !== 'incomplete') return [];
+  const uncapturedTypes = new Set<TBackupResourceType>(failure.uncaptured.map((resourceArg) => resourceArg.type));
+  return (['database', 'objectstorage'] as const).filter((typeArg) => (
+    !uncapturedTypes.has(typeArg) && backupArg.snapshots.some((snapshotArg) => snapshotArg.type === typeArg)
+  ));
+};
+
 /** Retention policy understood by containerarchive prune. */
 export interface IArchiveRetentionPolicy {
   keepLast?: number;

package/ts/data/clusternode.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../plugins.js';
 import { isSha256Digest, type TSha256Digest, type TImmutableContainerPlatform } from './immutableimage.js';
 import type { ISparkNodeReportRecord } from './sparknodereport.js';
+import type { INodeActionExpiry, INodeActionLifecycle } from './nodeaction.js';
 import type { IClusterNodeHostnameIntent } from './clusternodehostname.js';
 import type { IPlatformObjectStorageEndpoint } from '../platform/objectstorage.js';
 import type { IPlatformDatabaseEndpoint } from '../platform/database.js';
@@ -74,11 +75,21 @@ export interface INodeMetricsSample {
 
 export type TNodeActionName = 'systemUpgrade' | 'reboot' | 'serveZoneServiceUpdate';
 
-export type TNodeActionStatus = 'pending' | 'running' | 'succeeded' | 'failed';
+/**
+ * Every state of a node action; `nodeActionStatusKinds` states which are open and what each means.
+ * The first four are the ones the Swarm-era carrier shipped and keep their meaning.
+ */
+export type TNodeActionStatus = 'pending' | 'running' | 'succeeded' | 'failed'
+  | 'claimed' | 'executing' | 'draining' | 'rebooting' | 'verifying'
+  | 'expired' | 'cancelled' | 'unverified';
 
 /**
  * An operator-requested action executed by spark on a node.
- * Delivered to spark in metrics-sample responses; results posted back.
+ *
+ * A Swarm-era record is delivered to the Swarm-era daemon in metrics-sample responses, which
+ * posts results back; it carries no `lifecycle`. A node runtime action carries `lifecycle`: Spark
+ * takes it from `sparkNodeActionContracts.offer` and states each step on
+ * `sparkNodeActionContracts.transition`, and Cloudly verifies it from the node's reports.
  */
 export interface INodeAction {
   id: string;
@@ -94,6 +105,10 @@ export interface INodeAction {
   startedAt?: number;
   finishedAt?: number;
   resultText?: string;
+  /** The node runtime's lifecycle; absent on a Swarm-era record. */
+  lifecycle?: INodeActionLifecycle;
+  /** Why the action ended `expired`; present exactly then. */
+  expiry?: INodeActionExpiry;
 }
 
 export interface IServeZoneServiceRuntimeInfo {

package/ts/data/index.ts

@@ -81,6 +81,8 @@ export * from './clusternodehostname.js';
 export * from './settings.js';
 export * from './sparklegacyretirement.js';
 export * from './sparknodereport.js';
+export * from './nodeaction.js';
+export * from './sparkfleettarget.js';
 export * from './service.js';
 export * from './servicecredential.js';
 export * from './serviceplatformownership.js';