@serve.zone/interfaces 32.68.0 → 32.69.0

package/dist_ts/data/nodeaction.js

@@ -0,0 +1,434 @@
+import { canonicalizeStrictJson, compareWireTokens, createCanonicalJsonSha256Hex } from '../private/canonicaljson.js';
+import { readDataElements, readDataProperties, readExactDataRecord } from '../private/dataproperties.js';
+import { isClusterNodeId } from '../private/nodeidentifier.js';
+import { isCanonicalTokenList } from '../private/tokenlist.js';
+import { protocolRefusalHttpStatus, readProtocolOffer } from '../protocol.js';
+import { isReleaseVersion } from './releaseversion.js';
+/**
+ * Every node action, in canonical token order, so a list of them (a Spark's `actionExecutors`)
+ * is compared byte for byte.
+ */
+export const nodeActionNames = Object.freeze([
+    'reboot',
+    'serveZoneServiceUpdate',
+    'systemUpgrade',
+]);
+const nodeActionNamesComplete = true;
+void nodeActionNamesComplete;
+export const isNodeActionName = (valueArg) => (nodeActionNames.some((nameArg) => nameArg === valueArg));
+/**
+ * Whether each action state is still open or ended.
+ *
+ * The four values the Swarm-era carrier shipped keep their meaning: `pending` is the requested
+ * state of every action, `running` is a Swarm-era action its daemon started, and `succeeded` and
+ * `failed` end one. The node runtime's lifecycle (`INodeActionLifecycle`) adds the rest:
+ *
+ * - `claimed`: the node's Spark took the action (`claim`), stating the boot it took it in.
+ * - `executing`, `draining`, `rebooting`: the phase Spark reports, only ever forward
+ *   (`sparkNodeActionPhaseOrder`).
+ * - `verifying`: Cloudly saw the evidence the action changed the node (`nodeActionVerification`)
+ *   and waits for the node's runtime to come back.
+ * - `expired`: never claimed in its claim window, or a Swarm-era record no carrier can deliver
+ *   (`TNodeActionExpiryReason`).
+ * - `cancelled`: an operator withdrew it while it was still `pending`.
+ * - `unverified`: its deadline passed before Cloudly could verify it. An operator judges the node;
+ *   Cloudly never retries it.
+ */
+export const nodeActionStatusKinds = Object.freeze({
+    pending: 'open',
+    running: 'open',
+    claimed: 'open',
+    executing: 'open',
+    draining: 'open',
+    rebooting: 'open',
+    verifying: 'open',
+    succeeded: 'terminal',
+    failed: 'terminal',
+    expired: 'terminal',
+    cancelled: 'terminal',
+    unverified: 'terminal',
+});
+/** Every open state, the ones the one-open-action-per-node rule counts. */
+export const nodeActionOpenStatuses = Object.freeze(Object.keys(nodeActionStatusKinds)
+    .filter((statusArg) => nodeActionStatusKinds[statusArg] === 'open'));
+export const isNodeActionOpen = (statusArg) => (nodeActionStatusKinds[statusArg] === 'open');
+/**
+ * The phases Spark reports while it executes a claimed action, in the only order it may report
+ * them. A phase may be skipped, never repeated or reported after a later one.
+ */
+export const sparkNodeActionPhaseOrder = Object.freeze(['claimed', 'executing', 'draining', 'rebooting']);
+/**
+ * Time budgets of the node runtime's action lifecycle, in milliseconds.
+ *
+ * A requested action waits `claimWindowMs` for its node's Spark to claim it, then expires. A claimed
+ * action must be verified within its completion budget (`nodeActionCompletionBudgetMs`), measured
+ * from the claim, or it ends `unverified`. Each budget is the sum of the steps the action takes. One
+ * budget is read from Spark's code; every other one is chosen here, and each member says which.
+ */
+export const nodeActionContract = Object.freeze({
+    /** Chosen: how long a requested action waits for its node's Spark to claim it (10 min). */
+    claimWindowMs: 600_000,
+    /**
+     * Spark code: `sparkNodeStopTimeoutSeconds`, the node unit's `TimeoutStopSec=` (522 s), in which
+     * Pallet stops every workload it runs.
+     */
+    drainMs: 522_000,
+    /** Chosen: a host's reboot until Spark reports from the new boot (10 min). */
+    bootMs: 600_000,
+    /**
+     * Chosen: how long Pallet takes to start and register again after the node runtime starts
+     * (712 s, from the 2026-11-05 survey; Spark states no start budget of its own).
+     */
+    startMs: 712_000,
+    /** Chosen: downloading and checking the target's node bundle before anything stops (10 min). */
+    downloadMs: 600_000,
+    /** Chosen: the host's package upgrade (30 min). */
+    hostUpgradeMs: 1_800_000,
+    /** Entries an action's timeline keeps; each state is entered at most once. */
+    maximumTimelineEntries: 16,
+    /** Characters of operator text one timeline entry or failure carries. */
+    maximumDetailLength: 512,
+    /** Services one impact names; a node holding more is answered `impact-unreadable`. */
+    maximumImpactServices: 1024,
+    /** Characters of one service name an impact carries. */
+    maximumServiceNameLength: 256,
+});
+/**
+ * How long a claimed action has until Cloudly must have verified it, from the claim.
+ *
+ * A reboot drains, boots and starts the node. An update downloads the target, then restarts the
+ * node runtime on it: a drain and a start, no boot. A host upgrade runs the package upgrade and,
+ * with `reboot`, the reboot after it.
+ */
+export const nodeActionCompletionBudgetMs = (actionNameArg, rebootArg) => {
+    const c = nodeActionContract;
+    switch (actionNameArg) {
+        case 'reboot':
+            return c.drainMs + c.bootMs + c.startMs;
+        case 'serveZoneServiceUpdate':
+            return c.downloadMs + c.drainMs + c.startMs;
+        case 'systemUpgrade':
+            return c.hostUpgradeMs + (rebootArg ? c.drainMs + c.bootMs + c.startMs : 0);
+    }
+};
+/** Whether an action reboots the host, which is how Cloudly verifies it (`nodeActionVerification`). */
+export const nodeActionReboots = (actionNameArg, rebootArg) => (actionNameArg === 'reboot' || (actionNameArg === 'systemUpgrade' && rebootArg));
+export const nodeActionVerification = (actionNameArg, rebootArg) => nodeActionReboots(actionNameArg, rebootArg) ? 'new-boot'
+    : actionNameArg === 'serveZoneServiceUpdate' ? 'target-version' : 'upgrade-complete';
+/** Whether the action restarts the node runtime and is verified by its return (see `nodeActionVerification`). */
+export const nodeActionRestartsRuntime = (actionNameArg, rebootArg) => (nodeActionVerification(actionNameArg, rebootArg) !== 'upgrade-complete');
+/**
+ * Why an action ended `failed`, each with the remedy an operator is told.
+ *
+ * The first group is stated by Spark (`TSparkNodeActionFailureCode`), the second by Cloudly.
+ */
+export const nodeActionFailureRemedies = Object.freeze({
+    'download-failed': 'Spark could not download the target release. Check that the node reaches '
+        + 'code.foss.global, then request the update again.',
+    'installer-mismatch': 'The downloaded install.sh does not have the SHA-256 the target states. '
+        + 'Nothing was installed; set the fleet Spark target again, then request the update again.',
+    'install-failed': 'The node bundle installer failed and left the installed release in place. '
+        + 'Read the node\'s Spark journal, then request the update again.',
+    'drain-failed': 'Pallet did not stop its workloads within the stop budget. Read the node\'s '
+        + 'Pallet journal before requesting the action again.',
+    'reboot-failed': 'The host did not accept the reboot. Read the node\'s Spark journal.',
+    'host-upgrade-failed': 'The host package upgrade failed. Read the node\'s Spark journal, repair '
+        + 'the package state on the host, then request the upgrade again.',
+    'executor-failed': 'Spark could not run the action. Read the node\'s Spark journal.',
+    'reboot-required': 'The host upgrade finished and applying it needs a reboot. Request a system '
+        + 'upgrade with reboot, or a reboot, when the node may go down.',
+    'target-below-node': 'The node runs a newer Spark than the action\'s target, so the update '
+        + 'would downgrade it. Set the fleet Spark target to the release the node should run.',
+});
+/** The failure codes Spark may state with a `fail` transition. */
+export const sparkNodeActionFailureCodes = Object.freeze([
+    'download-failed',
+    'drain-failed',
+    'executor-failed',
+    'host-upgrade-failed',
+    'install-failed',
+    'installer-mismatch',
+    'reboot-failed',
+]);
+/** The SHA-256 (lowercase hex) of one impact's canonical JSON, which a confirmation names. */
+export const computeNodeActionImpactDigest = async (impactArg) => {
+    const fail = (reasonArg) => { throw new Error(`Node action impact rejected: ${reasonArg}`); };
+    return createCanonicalJsonSha256Hex(canonicalizeStrictJson(impactArg, fail, 'node action impact'), fail);
+};
+/**
+ * Every reason Cloudly answers instead of admitting, previewing or cancelling a node action. Each
+ * travels by name as a `TypedResponseError`, and a refused request changes nothing.
+ */
+export const nodeActionRefusals = Object.freeze([
+    /** No node of that id exists. */
+    'node-missing',
+    /** The node reported through no Spark that carries actions: it never reported at all. */
+    'node-action-undeliverable',
+    /** The node's Spark does not state that it executes this action (`ISparkNodeReport.actionExecutors`). */
+    'node-action-unsupported',
+    /**
+     * System upgrade on a node runtime node: its Spark does not state the `systemUpgrade` executor,
+     * which Spark states only once its host-upgrade executor passed the lab qualification.
+     */
+    'system-upgrade-unqualified',
+    /** The node already has an open action. */
+    'node-action-open',
+    /** Another node of the cluster has an open action; a cluster runs one disruptive action at a time. */
+    'cluster-action-open',
+    /** An update without a fleet Spark target. */
+    'spark-target-unset',
+    /** An update whose target is below the Spark bundle version the node reports. */
+    'spark-target-below-node',
+    /** An update of a node that is held at its release (`ISparkNodeTargetHold`). */
+    'spark-target-held',
+    /** The request states no confirmation, or one that is not well-formed for this action. */
+    'confirmation-invalid',
+    /** The typed hostname is not the hostname the node reports. */
+    'confirmation-hostname-mismatch',
+    /** What the action interrupts changed since the preview the confirmation names. */
+    'impact-changed',
+    /** An update whose confirmation names another fleet Spark target revision than the one Cloudly would freeze. */
+    'target-changed',
+    /** The impact names a Corestore on the node and the confirmation does not consent to restarting it. */
+    'corestore-consent-required',
+    /** Cloudly could not read what the action interrupts. */
+    'impact-unreadable',
+    /** No action of that id on that node. */
+    'node-action-missing',
+    /** Only a `pending` action is cancelled. */
+    'node-action-not-cancellable',
+    /** The action moved since the revision the request names. */
+    'node-action-revision-stale',
+]);
+const maximumHostnameLength = 253;
+const hostnamePattern = /^[a-z0-9](?:[a-z0-9.-]{0,251}[a-z0-9])?$/;
+const sha256HexPattern = /^[a-f0-9]{64}$/;
+/**
+ * Validates one confirmation for one action and names every reason it is refused.
+ *
+ * Shape only: an update must state `targetRevision`, every other action must not. Whether it
+ * matches the node, the impact and the fleet target Cloudly reads now is Cloudly's decision
+ * (`confirmation-hostname-mismatch`, `impact-changed`, `target-changed`, `corestore-consent-required`).
+ */
+export const validateNodeActionConfirmation = (valueArg, actionNameArg, pathArg = 'node action confirmation') => {
+    // An update names the target revision it confirmed; no other action does.
+    const update = actionNameArg === 'serveZoneServiceUpdate';
+    const value = readExactDataRecord(valueArg, ['confirmedHostname', 'impactDigest', 'corestoreRestart', 'reboot',
+        ...(update ? ['targetRevision'] : [])]);
+    if (value === null) {
+        return [update
+                ? `${pathArg} must use its exact schema, with the targetRevision the preview showed`
+                : `${pathArg} must use its exact schema, without a targetRevision`];
+    }
+    const errors = [];
+    if (update && (!Number.isSafeInteger(value.targetRevision) || value.targetRevision < 1)) {
+        errors.push(`${pathArg} targetRevision must be a positive integer`);
+    }
+    if (typeof value.confirmedHostname !== 'string' || value.confirmedHostname.length > maximumHostnameLength
+        || !hostnamePattern.test(value.confirmedHostname)) {
+        errors.push(`${pathArg} confirmedHostname must be a lowercase hostname`);
+    }
+    if (typeof value.impactDigest !== 'string' || !sha256HexPattern.test(value.impactDigest)) {
+        errors.push(`${pathArg} impactDigest must be a lowercase SHA-256 hex digest`);
+    }
+    if (typeof value.corestoreRestart !== 'boolean')
+        errors.push(`${pathArg} corestoreRestart must be a boolean`);
+    if (typeof value.reboot !== 'boolean') {
+        errors.push(`${pathArg} reboot must be a boolean`);
+    }
+    else if (value.reboot && actionNameArg !== 'systemUpgrade') {
+        errors.push(`${pathArg} reboot is stated for systemUpgrade only`);
+    }
+    return errors;
+};
+/**
+ * The node runtime's action routes.
+ *
+ * Spark asks the offer route after each accepted heartbeat and states every step on the transition
+ * route. Both are authenticated with the node's Spark credential exactly like
+ * `sparkNodeHeartbeatContract` and judged in the same server order: the offer first, within
+ * `maxRequestBytes`, answered with `protocolRefusalStatus` and an `IProtocolRefusal` body on
+ * refusal, before the node is authenticated. The server's offer on these routes names, as its
+ * minimum, the release that introduced them, so a Spark below it is refused by name and is never
+ * handed an action.
+ */
+export const sparkNodeActionContracts = Object.freeze({
+    offer: Object.freeze({
+        endpoint: '/spark/nodes/action',
+        maxRequestBytes: 1024,
+        maxResponseBytes: 4096,
+    }),
+    transition: Object.freeze({
+        endpoint: '/spark/nodes/action/transition',
+        maxRequestBytes: 2048,
+        maxResponseBytes: 4096,
+    }),
+    protocolRefusalStatus: protocolRefusalHttpStatus,
+});
+const fail = () => { throw new Error('Spark node action contract rejected.'); };
+function requireValue(valueArg) {
+    if (!valueArg)
+        fail();
+}
+const record = (valueArg, keysArg) => {
+    const result = readExactDataRecord(valueArg, keysArg);
+    requireValue(result !== null);
+    return result;
+};
+const nodeId = (valueArg) => (isClusterNodeId(valueArg) ? valueArg : fail());
+const nodeToken = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && /^secureToken[a-f0-9]{64}$/.test(valueArg));
+    return valueArg;
+};
+const integer = (valueArg, minimumArg) => {
+    requireValue(Number.isSafeInteger(valueArg) && !Object.is(valueArg, -0) && valueArg >= minimumArg);
+    return valueArg;
+};
+/** An action id as Cloudly mints them: a short URL-safe token. */
+const actionId = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && /^[A-Za-z0-9_-]{1,64}$/.test(valueArg));
+    return valueArg;
+};
+/** The kernel's `boot_id`: one lowercase UUID. */
+export const isHostBootId = (valueArg) => (typeof valueArg === 'string'
+    && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(valueArg));
+const bootId = (valueArg) => (isHostBootId(valueArg) ? valueArg : fail());
+const operatorText = (valueArg) => {
+    requireValue(typeof valueArg === 'string' && valueArg.length <= nodeActionContract.maximumDetailLength
+        && /^[\x20-\x7e]*$/.test(valueArg));
+    return valueArg;
+};
+const snapshotTarget = (valueArg) => {
+    const value = record(valueArg, ['version', 'installerSha256', 'targetRevision']);
+    requireValue(isReleaseVersion(value.version));
+    requireValue(typeof value.installerSha256 === 'string' && sha256HexPattern.test(value.installerSha256));
+    return Object.freeze({
+        version: value.version, installerSha256: value.installerSha256,
+        targetRevision: integer(value.targetRevision, 1),
+    });
+};
+const assignmentStatuses = ['pending', 'claimed', 'executing', 'draining', 'rebooting', 'verifying'];
+/** One assignment, exactly its keys; detached and frozen. */
+export const snapshotSparkNodeActionAssignment = (valueArg) => {
+    const value = record(valueArg, ['id', 'actionName', 'status', 'revision', 'deadlineAt', 'reboot', 'target', 'claim']);
+    requireValue(isNodeActionName(value.actionName));
+    const status = assignmentStatuses.find((statusArg) => statusArg === value.status) ?? fail();
+    requireValue(typeof value.reboot === 'boolean' && (!value.reboot || value.actionName === 'systemUpgrade'));
+    const target = value.target === null ? null : snapshotTarget(value.target);
+    requireValue((target !== null) === (value.actionName === 'serveZoneServiceUpdate'));
+    const claim = value.claim === null ? null : Object.freeze({ bootId: bootId(record(value.claim, ['bootId']).bootId) });
+    requireValue((claim === null) === (status === 'pending'));
+    return Object.freeze({
+        id: actionId(value.id), actionName: value.actionName, status,
+        revision: integer(value.revision, 1), deadlineAt: integer(value.deadlineAt, 1),
+        reboot: value.reboot, target, claim,
+    });
+};
+export const snapshotSparkNodeActionOfferRequest = (valueArg) => {
+    const value = record(valueArg, ['nodeId', 'nodeToken', 'protocol']);
+    return Object.freeze({
+        nodeId: nodeId(value.nodeId), nodeToken: nodeToken(value.nodeToken), protocol: readProtocolOffer(value),
+    });
+};
+export const snapshotSparkNodeActionOffer = (valueArg) => {
+    const value = record(valueArg, ['nodeId', 'action', 'protocol']);
+    return Object.freeze({
+        nodeId: nodeId(value.nodeId),
+        action: value.action === null ? null : snapshotSparkNodeActionAssignment(value.action),
+        protocol: readProtocolOffer(value),
+    });
+};
+const snapshotTransition = (valueArg) => {
+    const properties = readDataProperties(valueArg);
+    requireValue(properties !== null);
+    switch (properties.kind) {
+        case 'claim':
+            return Object.freeze({ kind: 'claim', bootId: bootId(record(valueArg, ['kind', 'bootId']).bootId) });
+        case 'phase': {
+            const phase = record(valueArg, ['kind', 'phase']).phase;
+            const known = sparkNodeActionPhaseOrder.find((phaseArg) => phaseArg !== 'claimed' && phaseArg === phase);
+            return Object.freeze({ kind: 'phase', phase: (known ?? fail()) });
+        }
+        case 'complete':
+            record(valueArg, ['kind']);
+            return Object.freeze({ kind: 'complete' });
+        case 'fail': {
+            const value = record(valueArg, ['kind', 'code', 'detail']);
+            const code = sparkNodeActionFailureCodes.find((codeArg) => codeArg === value.code) ?? fail();
+            return Object.freeze({ kind: 'fail', code, detail: operatorText(value.detail) });
+        }
+        default:
+            return fail();
+    }
+};
+export const snapshotSparkNodeActionTransitionRequest = (valueArg) => {
+    const value = record(valueArg, ['nodeId', 'nodeToken', 'protocol', 'actionId', 'expectedRevision', 'transition']);
+    return Object.freeze({
+        nodeId: nodeId(value.nodeId), nodeToken: nodeToken(value.nodeToken), protocol: readProtocolOffer(value),
+        actionId: actionId(value.actionId), expectedRevision: integer(value.expectedRevision, 1),
+        transition: snapshotTransition(value.transition),
+    });
+};
+const transitionRefusals = [
+    'action-unknown', 'action-closed', 'revision-stale', 'transition-invalid',
+];
+export const snapshotSparkNodeActionTransitionAnswer = (valueArg) => {
+    const properties = readDataProperties(valueArg);
+    requireValue(properties !== null);
+    if (properties.outcome === 'refused') {
+        const value = record(valueArg, ['outcome', 'reason', 'action', 'protocol']);
+        const reason = transitionRefusals.find((reasonArg) => reasonArg === value.reason) ?? fail();
+        return Object.freeze({
+            outcome: 'refused', reason,
+            action: value.action === null ? null : snapshotSparkNodeActionAssignment(value.action),
+            protocol: readProtocolOffer(value),
+        });
+    }
+    const value = record(valueArg, ['outcome', 'action', 'protocol']);
+    requireValue(value.outcome === 'applied' || value.outcome === 'replayed');
+    return Object.freeze({
+        outcome: value.outcome,
+        action: value.action === null ? null : snapshotSparkNodeActionAssignment(value.action),
+        protocol: readProtocolOffer(value),
+    });
+};
+/**
+ * Whether an open action admits one transition from Spark, judged from its state alone.
+ *
+ * `claim` takes a `pending` action. A `phase` moves strictly forward in `sparkNodeActionPhaseOrder`
+ * from `claimed` or an earlier phase, and only into a phase the action has: `rebooting` only for
+ * an action that reboots, `draining` for every action but a host upgrade without a reboot.
+ * `complete` ends the execution of a host upgrade without a reboot. `fail` ends any claimed action
+ * that Cloudly is not yet verifying.
+ */
+export const admitsSparkNodeActionTransition = (actionArg, transitionArg) => {
+    const executing = sparkNodeActionPhaseOrder.indexOf(actionArg.status);
+    switch (transitionArg.kind) {
+        case 'claim':
+            return actionArg.status === 'pending';
+        case 'phase': {
+            if (executing < 0)
+                return false;
+            const next = sparkNodeActionPhaseOrder.indexOf(transitionArg.phase);
+            if (next <= executing)
+                return false;
+            if (transitionArg.phase === 'rebooting')
+                return nodeActionReboots(actionArg.actionName, actionArg.reboot);
+            if (transitionArg.phase === 'draining')
+                return nodeActionRestartsRuntime(actionArg.actionName, actionArg.reboot);
+            return actionArg.actionName !== 'reboot';
+        }
+        case 'complete':
+            return executing >= 1 && nodeActionVerification(actionArg.actionName, actionArg.reboot) === 'upgrade-complete';
+        case 'fail':
+            return executing >= 0;
+    }
+};
+/** True when a value is a canonical list of action names: known names, strictly increasing, at least one. */
+export const isNodeActionNameList = (valueArg) => {
+    const elements = readDataElements(valueArg, nodeActionNames.length);
+    return elements !== null && elements.length > 0 && isCanonicalTokenList(elements, nodeActionNames);
+};
+/** Sorts action names into canonical order, so a list built from a set compares byte for byte. */
+export const sortNodeActionNames = (namesArg) => ([...new Set(namesArg)].sort(compareWireTokens));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodeaction.js","sourceRoot":"","sources":["../../ts/data/nodeaction.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/sparkfleettarget.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The Spark release every node of the fleet should run: one row in Cloudly's database, the only
+ * source of the release a fresh node's bootstrap installs and an update moves a node to.
+ *
+ * An administrator names the version and the revision they read; Cloudly reads the SHA-256 of the
+ * release's `install.sh` from the release's published `SHA256SUMS.txt`, checks it against the
+ * `install.sh` it downloads, and stores the pair. Nobody types a hash. A database without the row
+ * holds no target, and every reader refuses by name (`spark-target-unset`) rather than falling
+ * back to a release of its own.
+ *
+ * A target below the release a node runs is admitted: that node reads `ahead` of it, and an update
+ * that would move it down is refused (`spark-target-below-node`).
+ */
+export interface ISparkFleetTarget {
+    /** `MAJOR.MINOR.PATCH`, without `v`. */
+    version: string;
+    /** The SHA-256 the release's `SHA256SUMS.txt` states for `install.sh`, lowercase hex. */
+    installerSha256: string;
+    /** Advances by one with every change; the first target is revision 1. */
+    revision: number;
+    /** Who set it: `admin:<userId>`, or `migration:<step>` for the target a data step seeded. */
+    setBy: string;
+    setAt: number;
+}
+/**
+ * One change of the fleet target, kept in an append-only history: the target as it was set, and
+ * the version it replaced (`null` for the first). The history is the audit; nothing else records
+ * why a target moved.
+ */
+export interface ISparkFleetTargetChange extends ISparkFleetTarget {
+    previousVersion: string | null;
+}
+/**
+ * One node held at the release it runs: it reads `held` rather than behind or ahead, and an update
+ * of it is refused (`spark-target-held`) until the hold is released. There is no per-node or
+ * per-cluster target; a hold is the only exception to the one fleet target.
+ */
+export interface ISparkNodeTargetHold {
+    nodeId: string;
+    /** Operator text naming why the node is held. */
+    reason: string;
+    heldBy: string;
+    heldAt: number;
+}
+export declare const sparkFleetTargetContract: Readonly<{
+    /** Changes one `getSparkFleetTarget` answers, newest first. */
+    readonly historyLimit: 50;
+    /** Characters of one hold's reason. */
+    readonly maximumHoldReasonLength: 256;
+}>;
+/**
+ * Every reason Cloudly answers instead of reading or changing the fleet target or a hold. Each
+ * travels by name as a `TypedResponseError`, and a refused request changes nothing.
+ */
+export declare const sparkFleetTargetRefusals: readonly ["spark-target-request-invalid", "spark-target-revision-stale", "spark-release-unavailable", "spark-release-checksum-missing", "spark-release-checksum-mismatch", "node-missing"];
+export type TSparkFleetTargetRefusalCode = typeof sparkFleetTargetRefusals[number];
+/**
+ * Where one node stands against the fleet target.
+ *
+ * - `at-target`, `behind`, `ahead`: the Spark bundle version it reports, compared to the target.
+ * - `held`: the node is held (`ISparkNodeTargetHold`), whatever it runs.
+ * - `unreported`: the node reports no Spark bundle version (it never reported through the node
+ *   runtime).
+ * - `untargeted`: there is no fleet target.
+ */
+export type TSparkNodeTargetStanding = 'at-target' | 'behind' | 'ahead' | 'held' | 'unreported' | 'untargeted';
+export declare const readSparkNodeTargetStanding: (argsArg: {
+    bundleVersion: string | null;
+    target: Pick<ISparkFleetTarget, 'version'> | null;
+    held: boolean;
+}) => TSparkNodeTargetStanding;
+/**
+ * Validates one `setSparkFleetTarget` input and names every reason it is refused: a release version
+ * and the revision of the target the administrator read, `0` while there is none.
+ */
+export declare const validateSetSparkFleetTargetInput: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Validates one hold a request states: `{ reason }` to hold the node, `null` to release it.
+ */
+export declare const validateSparkNodeTargetHoldInput: (valueArg: unknown, pathArg?: string) => string[];

package/dist_ts/data/sparkfleettarget.js

@@ -0,0 +1,71 @@
+import { readExactDataRecord } from '../private/dataproperties.js';
+import { compareReleaseVersions, isReleaseVersion, parseReleaseVersion } from './releaseversion.js';
+export const sparkFleetTargetContract = Object.freeze({
+    /** Changes one `getSparkFleetTarget` answers, newest first. */
+    historyLimit: 50,
+    /** Characters of one hold's reason. */
+    maximumHoldReasonLength: 256,
+});
+/**
+ * Every reason Cloudly answers instead of reading or changing the fleet target or a hold. Each
+ * travels by name as a `TypedResponseError`, and a refused request changes nothing.
+ */
+export const sparkFleetTargetRefusals = Object.freeze([
+    /** The request is not well-formed (`validateSetSparkFleetTargetInput`, `validateSparkNodeTargetHoldInput`). */
+    'spark-target-request-invalid',
+    /** The target moved since the revision the request names (`0` while there is none). */
+    'spark-target-revision-stale',
+    /** The release, its `SHA256SUMS.txt` or its `install.sh` could not be downloaded. */
+    'spark-release-unavailable',
+    /** The release's `SHA256SUMS.txt` states no SHA-256 for `install.sh`. */
+    'spark-release-checksum-missing',
+    /** The downloaded `install.sh` does not have the SHA-256 its `SHA256SUMS.txt` states. */
+    'spark-release-checksum-mismatch',
+    /** No node of that id exists. */
+    'node-missing',
+]);
+export const readSparkNodeTargetStanding = (argsArg) => {
+    if (argsArg.held)
+        return 'held';
+    if (argsArg.target === null)
+        return 'untargeted';
+    const running = parseReleaseVersion(argsArg.bundleVersion);
+    const target = parseReleaseVersion(argsArg.target.version);
+    if (running === null || target === null)
+        return 'unreported';
+    const order = compareReleaseVersions(running, target);
+    return order === 0 ? 'at-target' : order < 0 ? 'behind' : 'ahead';
+};
+/**
+ * Validates one `setSparkFleetTarget` input and names every reason it is refused: a release version
+ * and the revision of the target the administrator read, `0` while there is none.
+ */
+export const validateSetSparkFleetTargetInput = (valueArg, pathArg = 'spark fleet target input') => {
+    const value = readExactDataRecord(valueArg, ['version', 'expectedRevision']);
+    if (value === null)
+        return [`${pathArg} must use its exact schema`];
+    const errors = [];
+    if (!isReleaseVersion(value.version))
+        errors.push(`${pathArg} version must be a MAJOR.MINOR.PATCH release version`);
+    if (!Number.isSafeInteger(value.expectedRevision) || Object.is(value.expectedRevision, -0)
+        || value.expectedRevision < 0) {
+        errors.push(`${pathArg} expectedRevision must be a non-negative integer`);
+    }
+    return errors;
+};
+/**
+ * Validates one hold a request states: `{ reason }` to hold the node, `null` to release it.
+ */
+export const validateSparkNodeTargetHoldInput = (valueArg, pathArg = 'spark node target hold') => {
+    if (valueArg === null)
+        return [];
+    const value = readExactDataRecord(valueArg, ['reason']);
+    if (value === null)
+        return [`${pathArg} must be null or use its exact schema`];
+    return typeof value.reason === 'string' && value.reason.length > 0
+        && value.reason.length <= sparkFleetTargetContract.maximumHoldReasonLength
+        && /^[\x20-\x7e]+$/.test(value.reason)
+        ? []
+        : [`${pathArg} reason must be printable text of 1 to ${sparkFleetTargetContract.maximumHoldReasonLength} characters`];
+};
+//# sourceMappingURL=data:application/json;base64,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