1163 lines
33 KiB
TypeScript
1163 lines
33 KiB
TypeScript
// Code generated by seatgen from the seat definitions; DO NOT EDIT.
|
|
|
|
// The contract of the seat "node-engine", defined whole (seats/node-engine/seat.json): The node seat every node's engine holds (novox/hq ADR 0563, ADR 0618 §3, §4): its hand acts on the operator's warrant, its read-only judgements, its compositions and what it reads of a manifest. Each verb is answered on this node's subject, mesh.seat.node-engine.tool.<verb>.<node>, and each event is published on mesh.seat.node-engine.event.<event>.<node>, the node's name its last token.
|
|
|
|
export const seat = "node-engine";
|
|
|
|
export const verbs = {
|
|
handOver: "hand-over",
|
|
accessAct: "access-act",
|
|
judgeDirectories: "judge-directories",
|
|
setuidSearch: "setuid-search",
|
|
rootFree: "root-free",
|
|
acts: "acts",
|
|
packages: "packages",
|
|
composition: "composition",
|
|
compose: "compose",
|
|
composeCandidate: "compose-candidate",
|
|
manifestReads: "manifest-reads",
|
|
seatList: "seat-list",
|
|
seatListAgain: "seat-list-again",
|
|
} as const;
|
|
|
|
export const events = {
|
|
asked: "asked",
|
|
done: "done",
|
|
refused: "refused",
|
|
manifestReadsChanged: "manifest-reads-changed",
|
|
} as const;
|
|
|
|
export const family = { name: "node-engine.events", maxAgeDays: 7 } as const;
|
|
|
|
export function askedSubject(caller: string): string {
|
|
return "mesh.seat.node-engine.event.asked." + caller;
|
|
}
|
|
|
|
export function doneSubject(caller: string): string {
|
|
return "mesh.seat.node-engine.event.done." + caller;
|
|
}
|
|
|
|
export function refusedSubject(caller: string): string {
|
|
return "mesh.seat.node-engine.event.refused." + caller;
|
|
}
|
|
|
|
export function manifestReadsChangedSubject(caller: string): string {
|
|
return "mesh.seat.node-engine.event.manifest-reads-changed." + caller;
|
|
}
|
|
|
|
export const states = {
|
|
have: "have",
|
|
composed: "composed",
|
|
data: "data",
|
|
packages: "packages",
|
|
health: "health",
|
|
findings: "findings",
|
|
} as const;
|
|
|
|
/** The key of one value of the state have under the form "<node>.<module>". */
|
|
export function haveByNodeModuleKey(node: string, module: string): string {
|
|
return node + "." + module;
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>.<module>", or undefined for a key of another form. */
|
|
export function parseHaveByNodeModuleKey(_key: string): { node: string; module: string } | undefined {
|
|
let _rest = _key;
|
|
const _at0 = _rest.indexOf(".");
|
|
if (_at0 <= 0) return undefined;
|
|
const node = _rest.slice(0, _at0);
|
|
_rest = _rest.slice(_at0 + 1);
|
|
if (_rest === "") return undefined;
|
|
const module = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { node, module };
|
|
}
|
|
|
|
/** The key of one value of the state have under the form "<node>.node". */
|
|
export function haveByNodeNodeKey(node: string): string {
|
|
return node + ".node";
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>.node", or undefined for a key of another form. */
|
|
export function parseHaveByNodeNodeKey(_key: string): { node: string } | undefined {
|
|
let _rest = _key;
|
|
const _at0 = _rest.indexOf(".node");
|
|
if (_at0 <= 0) return undefined;
|
|
const node = _rest.slice(0, _at0);
|
|
_rest = _rest.slice(_at0 + 5);
|
|
if (_rest !== "") return undefined;
|
|
return { node };
|
|
}
|
|
|
|
/** The key of one value of the state composed under the form "<node>.<module>.<fingerprint>". */
|
|
export function composedByNodeModuleFingerprintKey(node: string, module: string, fingerprint: string): string {
|
|
return node + "." + module + "." + fingerprint;
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>.<module>.<fingerprint>", or undefined for a key of another form. */
|
|
export function parseComposedByNodeModuleFingerprintKey(_key: string): { node: string; module: string; fingerprint: string } | undefined {
|
|
let _rest = _key;
|
|
const _at0 = _rest.indexOf(".");
|
|
if (_at0 <= 0) return undefined;
|
|
const node = _rest.slice(0, _at0);
|
|
_rest = _rest.slice(_at0 + 1);
|
|
const _at2 = _rest.indexOf(".");
|
|
if (_at2 <= 0) return undefined;
|
|
const module = _rest.slice(0, _at2);
|
|
_rest = _rest.slice(_at2 + 1);
|
|
if (_rest === "") return undefined;
|
|
const fingerprint = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { node, module, fingerprint };
|
|
}
|
|
|
|
/** The key of one value of the state composed under the form "<node>.node". */
|
|
export function composedByNodeNodeKey(node: string): string {
|
|
return node + ".node";
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>.node", or undefined for a key of another form. */
|
|
export function parseComposedByNodeNodeKey(_key: string): { node: string } | undefined {
|
|
let _rest = _key;
|
|
const _at0 = _rest.indexOf(".node");
|
|
if (_at0 <= 0) return undefined;
|
|
const node = _rest.slice(0, _at0);
|
|
_rest = _rest.slice(_at0 + 5);
|
|
if (_rest !== "") return undefined;
|
|
return { node };
|
|
}
|
|
|
|
/** The key of one value of the state data under the form "<node>.<module>". */
|
|
export function dataByNodeModuleKey(node: string, module: string): string {
|
|
return node + "." + module;
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>.<module>", or undefined for a key of another form. */
|
|
export function parseDataByNodeModuleKey(_key: string): { node: string; module: string } | undefined {
|
|
let _rest = _key;
|
|
const _at0 = _rest.indexOf(".");
|
|
if (_at0 <= 0) return undefined;
|
|
const node = _rest.slice(0, _at0);
|
|
_rest = _rest.slice(_at0 + 1);
|
|
if (_rest === "") return undefined;
|
|
const module = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { node, module };
|
|
}
|
|
|
|
/** The key of one value of the state packages under the form "<node>". */
|
|
export function packagesByNodeKey(node: string): string {
|
|
return node;
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>", or undefined for a key of another form. */
|
|
export function parsePackagesByNodeKey(_key: string): { node: string } | undefined {
|
|
let _rest = _key;
|
|
if (_rest === "") return undefined;
|
|
const node = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { node };
|
|
}
|
|
|
|
/** The key of one value of the state health under the form "<node>". */
|
|
export function healthByNodeKey(node: string): string {
|
|
return node;
|
|
}
|
|
|
|
/** The parts of a key of the form "<node>", or undefined for a key of another form. */
|
|
export function parseHealthByNodeKey(_key: string): { node: string } | undefined {
|
|
let _rest = _key;
|
|
if (_rest === "") return undefined;
|
|
const node = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { node };
|
|
}
|
|
|
|
/** The key of one value of the state findings under the form "<key>". */
|
|
export function findingsByKeyKey(key: string): string {
|
|
return key;
|
|
}
|
|
|
|
/** The parts of a key of the form "<key>", or undefined for a key of another form. */
|
|
export function parseFindingsByKeyKey(_key: string): { key: string } | undefined {
|
|
let _rest = _key;
|
|
if (_rest === "") return undefined;
|
|
const key = _rest;
|
|
_rest = "";
|
|
if (_rest !== "") return undefined;
|
|
return { key };
|
|
}
|
|
|
|
/** the hashes of the users of the list, sealed to the vault */
|
|
export interface AccountsHanded {
|
|
/** when */
|
|
"at": string;
|
|
"box": SealedBox;
|
|
"from": string;
|
|
/** the fingerprint of the vault's key */
|
|
"to": string;
|
|
"users": number;
|
|
}
|
|
|
|
/** one act asked through the seat, as acts reads it (ADR 0563 §9) */
|
|
export interface Act {
|
|
/** the act: hand-over, access-act, judge-directories or setuid-search */
|
|
"act": string;
|
|
/** the operator's ask of a hand-over or an access act */
|
|
"ask"?: string;
|
|
/** when it was asked, RFC 3339 */
|
|
"at": string;
|
|
/** the engine asked it itself, on finding a library's root holding data outside its group (ADR 0563 §4) */
|
|
"auto"?: boolean;
|
|
/** who answered, as the operator's warrant names them */
|
|
"by"?: string;
|
|
/** the caller as the runtime proved it */
|
|
"caller": string;
|
|
/** what the engine read on disk when it judged */
|
|
"disk"?: string;
|
|
/** when it ended, RFC 3339 */
|
|
"ended"?: string;
|
|
/** when the ask ends unanswered, RFC 3339 */
|
|
"expires"?: string;
|
|
/** the act's id */
|
|
"id": string;
|
|
/** the directory the act changes */
|
|
"path"?: string;
|
|
/** the warrant's proofs */
|
|
"proofs"?: string[];
|
|
/** what the engine said of it: its outcome or why it was refused */
|
|
"said"?: string;
|
|
/** the owner, group and mode it sets, in words */
|
|
"sets"?: string;
|
|
/** where it stands */
|
|
"state": "asked" | "done" | "refused" | "answered";
|
|
/** the path of a hand-over, or the access of an access act */
|
|
"subject"?: string;
|
|
/** the channel the warrant came on */
|
|
"via"?: string;
|
|
/** why it was asked, in words */
|
|
"why"?: string;
|
|
}
|
|
|
|
/** what the seat says of an act: the act, the path or access, the caller as the runtime proved it and the ask (ADR 0563 §1) */
|
|
export interface ActSaid {
|
|
/** the act */
|
|
"act": string;
|
|
/** the operator's ask */
|
|
"ask"?: string;
|
|
/** the caller as the runtime proved it */
|
|
"caller": string;
|
|
/** the node whose engine says it */
|
|
"node": string;
|
|
/** what the engine said of it */
|
|
"said"?: string;
|
|
/** where the act stands */
|
|
"state": "asked" | "done" | "refused";
|
|
/** the path or the access */
|
|
"subject"?: string;
|
|
}
|
|
|
|
/** the acts kept */
|
|
export interface Acts {
|
|
/** the acts, newest first */
|
|
"acts": Act[];
|
|
/** the node */
|
|
"node": string;
|
|
}
|
|
|
|
/** the node is adopted and which of its modules are taken */
|
|
export interface Adoption {
|
|
/** the modules taken */
|
|
"taken": string[];
|
|
/** by module, the resources left untaken */
|
|
"untaken"?: Record<string, string[]>;
|
|
}
|
|
|
|
/** the answer of an act the operator is asked */
|
|
export interface Asked {
|
|
/** the ask's id: acts shows where it stands */
|
|
"asked": string;
|
|
/** the node */
|
|
"node": string;
|
|
/** what happens next, in words */
|
|
"says": string;
|
|
}
|
|
|
|
/** a network attached to a link */
|
|
export interface AttachedNetwork {
|
|
"link": string;
|
|
"network": string;
|
|
}
|
|
|
|
/** a module the candidate adds */
|
|
export interface CandidateAdded {
|
|
"composed"?: string;
|
|
"module": string;
|
|
"unissued"?: string[];
|
|
}
|
|
|
|
/** the node's answer to one placement candidate naming it */
|
|
export interface CandidateAnswer {
|
|
"added"?: CandidateAdded[];
|
|
"differs"?: CandidateDiffers[];
|
|
"held"?: CandidateRefusal[];
|
|
"note"?: string;
|
|
"proposal": string;
|
|
"refusals"?: CandidateRefusal[];
|
|
/** why the node cannot compose with the candidate at all */
|
|
"refused"?: string;
|
|
/** modules the candidate removes */
|
|
"removed"?: string[];
|
|
"returns"?: string;
|
|
"revision": number;
|
|
/** modules whose composition is the one running */
|
|
"same"?: string[];
|
|
"values_differ"?: number;
|
|
/** same, differs or refused */
|
|
"verdict": "same" | "differs" | "refused";
|
|
}
|
|
|
|
/** the bodies of one resource that differ */
|
|
export interface CandidateBodies {
|
|
"composed"?: string;
|
|
"id": string;
|
|
"paths"?: string[];
|
|
"running"?: string;
|
|
"why": string;
|
|
}
|
|
|
|
/** a module whose composition with the candidate differs from the one running */
|
|
export interface CandidateDiffers {
|
|
"bodies"?: CandidateBodies[];
|
|
"composed"?: string;
|
|
"module": string;
|
|
"resource"?: string;
|
|
"running"?: string;
|
|
"why": string;
|
|
}
|
|
|
|
/** a module refused or held with the candidate */
|
|
export interface CandidateRefusal {
|
|
"module": string;
|
|
"today"?: string;
|
|
"why": string;
|
|
}
|
|
|
|
/** a group */
|
|
export interface DeclaredGroup {
|
|
"gid": number;
|
|
"name": string;
|
|
}
|
|
|
|
/** the identity of a module assigned to the node */
|
|
export interface DeclaredIdentity {
|
|
"gid": number;
|
|
"groups"?: number[];
|
|
"module": string;
|
|
"name": string;
|
|
"runner"?: string;
|
|
"uid": number;
|
|
}
|
|
|
|
/** a library the node is reached by */
|
|
export interface DeclaredLibrary {
|
|
"gid": number;
|
|
"group": string;
|
|
"home": boolean;
|
|
"library": string;
|
|
"paths"?: string[];
|
|
"root": string;
|
|
"runner"?: string;
|
|
"taken"?: boolean;
|
|
}
|
|
|
|
/** a unit that failed */
|
|
export interface FailedUnit {
|
|
"load"?: string;
|
|
"resource"?: string;
|
|
"result"?: string;
|
|
"scope": string;
|
|
/** since when */
|
|
"since": string;
|
|
"unit": string;
|
|
}
|
|
|
|
/** one answer the operator may give from a notification */
|
|
export interface FindingAction {
|
|
"arguments"?: Record<string, string>;
|
|
"label": string;
|
|
"level"?: "acknowledge" | "approve";
|
|
"machine"?: string;
|
|
/** the seat verb the operator channel calls */
|
|
"verb": string;
|
|
}
|
|
|
|
/** one observation, as it was said */
|
|
export interface FindingEvidence {
|
|
"at": string;
|
|
"said": string;
|
|
}
|
|
|
|
/** what the condition is about */
|
|
export interface FindingSubject {
|
|
/** the other machines it concerns */
|
|
"also"?: string[];
|
|
/** its id within the scope */
|
|
"id": string;
|
|
/** the machine it concerns, when there is one */
|
|
"machine"?: string;
|
|
/** machine, plan, call, build, merge, provider, seat, bus, core, probe, mesh, delivery or module */
|
|
"scope": string;
|
|
}
|
|
|
|
/** a login that fell back to another node */
|
|
export interface LoginFallback {
|
|
/** when */
|
|
"at": string;
|
|
"from": string;
|
|
"node": string;
|
|
"why": string;
|
|
}
|
|
|
|
/** what a node-engine says when what it reads changed or its node returned (ADR 0618 §4) */
|
|
export interface ManifestReadsChanged {
|
|
/** when it says it, RFC 3339 */
|
|
"at": string;
|
|
/** what its engine states it reads now */
|
|
"manifest-reads"?: string[];
|
|
/** the node */
|
|
"node": string;
|
|
/** the layout's version */
|
|
"v": number;
|
|
/** started: the engine started or what it states changed; returned: its node returned after being away */
|
|
"why": "started" | "returned";
|
|
}
|
|
|
|
/** one module's composition with the candidate */
|
|
export interface Module {
|
|
/** the candidate changes it from the one composed without it */
|
|
"changed"?: boolean;
|
|
/** the composition's digest when composed */
|
|
"digest"?: string;
|
|
/** the fingerprint it was composed at */
|
|
"fp"?: string;
|
|
/** the module, node for the node's own composition */
|
|
"module": string;
|
|
/** composed (digest set), refused by the candidate, or held without it too (words set) */
|
|
"state": "composed" | "refused" | "held";
|
|
/** why, for a refused or held one */
|
|
"words"?: string;
|
|
}
|
|
|
|
/** the node's network */
|
|
export interface NetworkHealth {
|
|
"parts": NetworkPart[];
|
|
/** since when */
|
|
"since": string;
|
|
/** running, degraded or unknown */
|
|
"state": string;
|
|
}
|
|
|
|
/** one part of the node's network */
|
|
export interface NetworkPart {
|
|
"owner"?: string;
|
|
"part": string;
|
|
"reason"?: string;
|
|
"said"?: string;
|
|
/** since when */
|
|
"since": string;
|
|
"state": string;
|
|
"streak"?: number;
|
|
"targets"?: string[];
|
|
"toward"?: string[];
|
|
"writer"?: string;
|
|
}
|
|
|
|
/** an account the node needs to log in again */
|
|
export interface NodeAccount {
|
|
"account": string;
|
|
"module"?: string;
|
|
"reason": string;
|
|
"resource"?: string;
|
|
/** since when */
|
|
"since": string;
|
|
}
|
|
|
|
/** a directory found where the node expected none */
|
|
export interface NodeDirectory {
|
|
"module": string;
|
|
"path": string;
|
|
"reason": string;
|
|
"resource": string;
|
|
/** since when */
|
|
"since": string;
|
|
}
|
|
|
|
/** what a node's own composition carries beside its resources */
|
|
export interface NodeOwn {
|
|
"adoption"?: Adoption;
|
|
"groups"?: DeclaredGroup[];
|
|
"identities"?: DeclaredIdentity[];
|
|
"libraries"?: DeclaredLibrary[];
|
|
/** the account the provisioner's client runs as on the node */
|
|
"provisioner_account"?: string;
|
|
}
|
|
|
|
/** what the machine observes of itself, for every node and composing part to read */
|
|
export interface NodeRecord {
|
|
"authority"?: string;
|
|
"capabilities"?: string[];
|
|
"certificate"?: string;
|
|
"contract"?: number;
|
|
"manifest-reads"?: string[];
|
|
"networks"?: AttachedNetwork[];
|
|
"networks-said"?: boolean;
|
|
"node": string;
|
|
"outward-links"?: string[];
|
|
"sealing-key"?: string;
|
|
"serving-key"?: string;
|
|
"trusts"?: string[];
|
|
"tunnel-key"?: string;
|
|
"v": number;
|
|
}
|
|
|
|
/** a tunnel peer and whether it is seen */
|
|
export interface PeerSeen {
|
|
"addresses"?: string[];
|
|
"key": string;
|
|
"seen": boolean;
|
|
}
|
|
|
|
/** one data item a module declares, as placed on a node */
|
|
export interface PlacedDataItem {
|
|
"class": string;
|
|
/** the path whose snapshot keeps it, empty when it is not backed up */
|
|
"covered_by"?: string;
|
|
"item": string;
|
|
/** walk, dataset or shallow */
|
|
"measure"?: string;
|
|
"module": string;
|
|
/** the item's place on the node */
|
|
"path": string;
|
|
/** backup, redundancy, both or none */
|
|
"protection"?: string;
|
|
}
|
|
|
|
/** the pull from a store a failed apply waits on */
|
|
export interface PullWait {
|
|
/** when the pull began */
|
|
"began": string;
|
|
/** that seat's holder, whose settling the apply waits for */
|
|
"holder": string;
|
|
"image": string;
|
|
/** what triggered the last try again, in words */
|
|
"retried"?: string;
|
|
/** when the apply was last tried again */
|
|
"retried-at"?: string;
|
|
/** the seat the pull came through */
|
|
"seat"?: string;
|
|
}
|
|
|
|
/** one revision of a composition key */
|
|
export interface Revision {
|
|
/** its digest */
|
|
"digest"?: string;
|
|
/** the composition's key */
|
|
"key": string;
|
|
/** the latest revision */
|
|
"latest"?: boolean;
|
|
/** why it cannot be read or trusted */
|
|
"refused"?: string;
|
|
/** how many resources it names */
|
|
"resources"?: number;
|
|
/** its revision */
|
|
"revision"?: number;
|
|
}
|
|
|
|
/** the engine's verdict of whether an account's resource is root-free, as the node's health lists it */
|
|
export interface RootAccountVerdict {
|
|
"account": string;
|
|
"module": string;
|
|
"reason"?: string;
|
|
"resource": string;
|
|
/** since when */
|
|
"since": string;
|
|
"state": string;
|
|
}
|
|
|
|
/** the engine's root-free verdict (ADR 0563 §6) */
|
|
export interface RootVerdict {
|
|
/** the machine is root-free */
|
|
"free": boolean;
|
|
/** when the engine judged it, RFC 3339 */
|
|
"judged": string;
|
|
/** the machine */
|
|
"machine": string;
|
|
/** why, in words */
|
|
"why": string;
|
|
}
|
|
|
|
/** the answer of a read-only judgement */
|
|
export interface Said {
|
|
/** the node */
|
|
"node": string;
|
|
/** the engine's judgement or search, one line per directory or program */
|
|
"said": string;
|
|
}
|
|
|
|
/** a value sealed to a key */
|
|
export interface SealedBox {
|
|
"ct": string;
|
|
"eph": string;
|
|
"iv": string;
|
|
"tag": string;
|
|
"v": number;
|
|
}
|
|
|
|
export interface SeatListStatus {
|
|
/** the seat mesh-catalog has answered */
|
|
"heard": boolean;
|
|
"held": SeatListHeld[];
|
|
"last-error"?: string;
|
|
/** a trunk definition that does not parse, by seat: the one held stands */
|
|
"refused"?: Record<string, string>;
|
|
"revision"?: number;
|
|
/** the seats held from the bootstrap alone */
|
|
"waiting"?: string[];
|
|
}
|
|
|
|
/** what an engine holds of the seat list (novox/hq ADR 0636 §7) */
|
|
export interface SeatList {
|
|
/** why the read failed, for seat-list-again */
|
|
"error"?: string;
|
|
/** the one line the engine says of it; empty when nothing waits */
|
|
"health": string;
|
|
"status": SeatListStatus;
|
|
}
|
|
|
|
export interface SeatListHeld {
|
|
/** the digest of the definition held; empty for a bootstrapped one */
|
|
"digest"?: string;
|
|
"seat": string;
|
|
"source": "trunk" | "bootstrap";
|
|
}
|
|
|
|
/** the node's units */
|
|
export interface UnitsHealth {
|
|
"away"?: string[];
|
|
"failed": FailedUnit[];
|
|
"state": string;
|
|
"unread"?: string[];
|
|
}
|
|
|
|
/** the bus's user list as the engine of the bus node wrote it to the bus module's file */
|
|
export interface UserListWritten {
|
|
/** when */
|
|
"at": string;
|
|
/** the digest of the file on the machine after the write */
|
|
"digest"?: string;
|
|
/** why a write failed */
|
|
"error"?: string;
|
|
/** which list the node follows now */
|
|
"follows"?: string;
|
|
"handed"?: AccountsHanded;
|
|
/** the bus node's sealing key, its public half */
|
|
"key"?: string;
|
|
"revision": number;
|
|
/** the key the list was taken from */
|
|
"source": string;
|
|
/** why the bus node does not watch the grants part's key now */
|
|
"unwatched"?: string;
|
|
"users": number;
|
|
/** the digest of the list the source holds, sha256:<hex> */
|
|
"wanted": string;
|
|
}
|
|
|
|
/** is what hand-over takes. */
|
|
export interface HandOverInput {
|
|
/** the directory's absolute path, as the engine states it */
|
|
"path": string;
|
|
/** why it is asked, in words the operator reads */
|
|
"why"?: string;
|
|
}
|
|
|
|
/** is what hand-over answers. */
|
|
export type HandOverAnswer = Asked;
|
|
|
|
/** is what access-act takes. */
|
|
export interface AccessActInput {
|
|
/** the access, library:<name> */
|
|
"access": string;
|
|
/** the act: take */
|
|
"act": string;
|
|
/** why it is asked, in words the operator reads */
|
|
"why"?: string;
|
|
}
|
|
|
|
/** is what access-act answers. */
|
|
export type AccessActAnswer = Asked;
|
|
|
|
/** is what judge-directories takes. */
|
|
export interface JudgeDirectoriesInput {
|
|
}
|
|
|
|
/** is what judge-directories answers. */
|
|
export type JudgeDirectoriesAnswer = Said;
|
|
|
|
/** is what setuid-search takes. */
|
|
export interface SetuidSearchInput {
|
|
/** why it is asked, in words */
|
|
"why"?: string;
|
|
}
|
|
|
|
/** is what setuid-search answers. */
|
|
export type SetuidSearchAnswer = Said;
|
|
|
|
/** is what root-free takes. */
|
|
export interface RootFreeInput {
|
|
}
|
|
|
|
/** is what root-free answers. */
|
|
export interface RootFreeAnswer {
|
|
/** this machine's verdict */
|
|
"machines": RootVerdict[];
|
|
}
|
|
|
|
/** is what acts takes. */
|
|
export interface ActsInput {
|
|
/** one act, by its id */
|
|
"id"?: string;
|
|
/** at most this many, newest */
|
|
"limit"?: string;
|
|
}
|
|
|
|
/** is what acts answers. */
|
|
export type ActsAnswer = Acts;
|
|
|
|
/** is what packages takes. */
|
|
export interface PackagesInput {
|
|
/** "true": write this machine's key again from what the engine composed */
|
|
"write"?: "true" | "false";
|
|
}
|
|
|
|
export interface PackagesAnswerKeyPackagesItem {
|
|
/** declared absent */
|
|
"absent": boolean;
|
|
/** the modules that declare it */
|
|
"modules": string[];
|
|
/** the package */
|
|
"package": string;
|
|
}
|
|
|
|
/** the node's key as the bus holds it; absent when the engine wrote none */
|
|
export interface PackagesAnswerKey {
|
|
/** the node */
|
|
"node": string;
|
|
/** its packages sorted by name, absent after present */
|
|
"packages": PackagesAnswerKeyPackagesItem[];
|
|
}
|
|
|
|
/** is what packages answers. */
|
|
export interface PackagesAnswer {
|
|
/** the node's key as the bus holds it; absent when the engine wrote none */
|
|
"key"?: PackagesAnswerKey;
|
|
/** why the key could not be read */
|
|
"key_error"?: string;
|
|
/** the node */
|
|
"node": string;
|
|
/** a note, such as that no key is written yet */
|
|
"note"?: string;
|
|
/** where the key is read: the engine's state packages */
|
|
"source": string;
|
|
/** with write: the key was written again (false: it already held what the engine composed) */
|
|
"wrote"?: boolean;
|
|
}
|
|
|
|
/** is what composition takes. */
|
|
export interface CompositionInput {
|
|
/** "true": list the resources that differ from what runs */
|
|
"diff"?: string;
|
|
/** a composition's digest (sha256:…), to read that revision rather than the latest */
|
|
"digest"?: string;
|
|
/** the module, as placed on this machine; node for the node's own */
|
|
"module": string;
|
|
}
|
|
|
|
/** the module's last apply that did not end running; absent when none */
|
|
export interface CompositionAnswerAttempt {
|
|
/** the want's revision the hold took */
|
|
"answered_revision"?: number;
|
|
/** the digest tried */
|
|
"composed"?: string;
|
|
/** the composition's revision it was tried at */
|
|
"composition_revision": number;
|
|
/** the fingerprint tried */
|
|
"fp": string;
|
|
/** held for a failed backup */
|
|
"held"?: boolean;
|
|
/** it failed because the bus did not answer for a moment */
|
|
"transient"?: boolean;
|
|
/** the want's revision it was tried at */
|
|
"want_revision": number;
|
|
}
|
|
|
|
/** what the module's have key says now; absent when it says nothing */
|
|
export interface CompositionAnswerHave {
|
|
/** digest */
|
|
"composed"?: string;
|
|
/** detail */
|
|
"detail"?: string;
|
|
/** fingerprint */
|
|
"fp"?: string;
|
|
/** judgement */
|
|
"judgement"?: string;
|
|
/** running, failed, held or waiting-yes */
|
|
"phase": string;
|
|
/** the digest that waits for a yes */
|
|
"waits"?: string;
|
|
}
|
|
|
|
/** the move from what runs to the composition read */
|
|
export interface CompositionAnswerJudged {
|
|
/** the judgement */
|
|
"judgement": string;
|
|
/** the agent would wait for a person's yes before applying it */
|
|
"waits_for_yes": boolean;
|
|
/** its words */
|
|
"words": string;
|
|
}
|
|
|
|
/** of the node's own composition, its own fields beside what runs names */
|
|
export interface CompositionAnswerOwn {
|
|
/** the revision's adoption; absent for a converged node */
|
|
"adoption"?: Record<string, unknown>;
|
|
/** groups */
|
|
"groups"?: number;
|
|
/** each module the node's composer held in its last pass, with why */
|
|
"held"?: Record<string, string>;
|
|
/** identities the revision names */
|
|
"identities"?: number;
|
|
/** libraries */
|
|
"libraries"?: number;
|
|
/** the account the provisioner's client runs as, as the revision names it */
|
|
"provisioner_account": string;
|
|
/** as what runs names it */
|
|
"runs_provisioner_account"?: string;
|
|
}
|
|
|
|
/** what runs of the module; absent when nothing runs */
|
|
export interface CompositionAnswerRuns {
|
|
/** digest */
|
|
"composed"?: string;
|
|
/** fingerprint */
|
|
"fp"?: string;
|
|
/** applied, have or kept */
|
|
"from": string;
|
|
/** phase */
|
|
"phase"?: string;
|
|
/** how many resources run */
|
|
"resources": number;
|
|
}
|
|
|
|
/** the module's want as the agent holds it; absent when it holds none */
|
|
export interface CompositionAnswerWant {
|
|
/** the operator's answer to a failed backup, again or skip */
|
|
"backup"?: string;
|
|
/** the composition's digest it names */
|
|
"composed"?: string;
|
|
/** its build's fingerprint */
|
|
"fp": string;
|
|
/** the module is removed */
|
|
"removed"?: boolean;
|
|
/** the revision of the want's key read last */
|
|
"revision": number;
|
|
/** the node composes the module itself (ADR 0547 §2) */
|
|
"self"?: boolean;
|
|
/** its words */
|
|
"words"?: string;
|
|
/** the digest a person said yes to */
|
|
"yes"?: string;
|
|
}
|
|
|
|
/** is what composition answers. */
|
|
export interface CompositionAnswer {
|
|
/** the module's last apply that did not end running; absent when none */
|
|
"attempt"?: CompositionAnswerAttempt;
|
|
"composition": Revision;
|
|
/** every resource that differs from what runs, when asked */
|
|
"diff"?: Record<string, unknown>[];
|
|
/** what the module's have key says now; absent when it says nothing */
|
|
"have"?: CompositionAnswerHave;
|
|
/** the move from what runs to the composition read */
|
|
"judged": CompositionAnswerJudged;
|
|
/** the module */
|
|
"module": string;
|
|
/** the node */
|
|
"node": string;
|
|
/** of the node's own composition, its own fields beside what runs names */
|
|
"own"?: CompositionAnswerOwn;
|
|
/** the revisions of its key the bucket keeps, oldest first */
|
|
"revisions"?: Revision[];
|
|
/** what runs of the module; absent when nothing runs */
|
|
"runs"?: CompositionAnswerRuns;
|
|
/** the agent has looked at the module once since it started */
|
|
"started": boolean;
|
|
/** the module's want as the agent holds it; absent when it holds none */
|
|
"want"?: CompositionAnswerWant;
|
|
}
|
|
|
|
/** is what compose takes. */
|
|
export interface ComposeInput {
|
|
/** a module placed on this machine whose apply is also tried again (optional) */
|
|
"module"?: string;
|
|
}
|
|
|
|
/** how the pass went */
|
|
export interface ComposeAnswerPass {
|
|
/** when the node composes again on its own, RFC 3339 */
|
|
"again"?: string;
|
|
/** when the pass ended, RFC 3339 */
|
|
"at": string;
|
|
/** the answer is the last pass, made moments ago */
|
|
"earlier"?: boolean;
|
|
/** how many compositions the pass handed the agent that differ from before */
|
|
"handed": number;
|
|
/** each module refused alone, with why */
|
|
"held"?: Record<string, string>;
|
|
/** why the node composed none of its modules */
|
|
"refused"?: string;
|
|
}
|
|
|
|
/** is what compose answers. */
|
|
export interface ComposeAnswer {
|
|
/** how the pass went */
|
|
"pass": ComposeAnswerPass;
|
|
/** the module whose apply was tried again */
|
|
"retried"?: string;
|
|
}
|
|
|
|
/** is what compose-candidate takes. */
|
|
export interface ComposeCandidateInput {
|
|
/** the key of the indexer's candidate, <group>.<heads hash> */
|
|
"candidate": string;
|
|
/** also answer the composition input the candidate was composed from, for the sandbox path */
|
|
"input"?: boolean;
|
|
}
|
|
|
|
/** is what compose-candidate answers. */
|
|
export interface ComposeCandidateAnswer {
|
|
/** the candidate's key */
|
|
"candidate": string;
|
|
/** when asked: the composition input it composed from */
|
|
"input"?: Record<string, unknown>;
|
|
/** every module placed on the node, sorted by name */
|
|
"modules": Module[];
|
|
/** the node */
|
|
"node": string;
|
|
"own": Module;
|
|
/** why the node could not compose with the candidate at all */
|
|
"refused"?: string;
|
|
/** how long the engine took, in milliseconds */
|
|
"took": number;
|
|
/** the layout's version */
|
|
"v": number;
|
|
/** the node's verdict (ADR 0593 §7, §9) */
|
|
"verdict": "composed" | "refused" | "unready" | "not-judged";
|
|
}
|
|
|
|
/** is what manifest-reads takes. */
|
|
export interface ManifestReadsInput {
|
|
}
|
|
|
|
/** is what manifest-reads answers. */
|
|
export interface ManifestReadsAnswer {
|
|
/** the reader capabilities its engine states: the manifest words, forms and seat names it reads; empty for an engine built before it said them, read as the baseline */
|
|
"manifest-reads"?: string[];
|
|
/** the node */
|
|
"node": string;
|
|
/** when the engine last stated them, RFC 3339 */
|
|
"stated-at": string;
|
|
/** the layout's version */
|
|
"v": number;
|
|
}
|
|
|
|
/** is what seat-list takes. */
|
|
export interface SeatListInput {
|
|
}
|
|
|
|
/** is what seat-list answers. */
|
|
export type SeatListAnswer = SeatList;
|
|
|
|
/** is what seat-list-again takes. */
|
|
export interface SeatListAgainInput {
|
|
}
|
|
|
|
/** is what seat-list-again answers. */
|
|
export type SeatListAgainAnswer = SeatList;
|
|
|
|
/** is the body of the event asked. */
|
|
export type AskedEvent = ActSaid;
|
|
|
|
/** is the body of the event done. */
|
|
export type DoneEvent = ActSaid;
|
|
|
|
/** is the body of the event refused. */
|
|
export type RefusedEvent = ActSaid;
|
|
|
|
/** is the body of the event manifest-reads-changed. */
|
|
export type ManifestReadsChangedEvent = ManifestReadsChanged;
|
|
|
|
/** is one value of the state have under the key <node>.<module>. */
|
|
export interface HaveByNodeModuleValue {
|
|
"build"?: string;
|
|
/** the move changes the build alone */
|
|
"build-alone"?: boolean;
|
|
/** the digest of the composition the node runs */
|
|
"composed"?: string;
|
|
"detail"?: string;
|
|
/** the fingerprint held */
|
|
"fp"?: string;
|
|
"handed"?: AccountsHanded;
|
|
/** what the module's own check says */
|
|
"health": "ok" | "failed" | "waits" | "unknown";
|
|
/** in phase waiting-yes, the judgement of the move */
|
|
"judgement"?: "recreates" | "moves-data" | "cannot-judge";
|
|
/** what the node keeps of the module as it runs */
|
|
"kept"?: string[];
|
|
/** how far it has come */
|
|
"phase": "backing-up" | "applying" | "checking" | "running" | "failed" | "removed" | "held" | "waiting-yes";
|
|
"pull-wait"?: PullWait;
|
|
/** each value sealed to the node's key */
|
|
"sealed"?: string[];
|
|
/** the sealed values by slot */
|
|
"sealed-at"?: Record<string, string>;
|
|
"user-list"?: UserListWritten;
|
|
"v": number;
|
|
/** in phase waiting-yes, the digest of the composition that waits */
|
|
"waits"?: string;
|
|
}
|
|
|
|
/** is one value of the state have under the key <node>.node. */
|
|
export interface HaveByNodeNodeValue {
|
|
"busy"?: Record<string, unknown>[];
|
|
/** the node's answer to each placement candidate naming it, by proposal id */
|
|
"candidates"?: Record<string, CandidateAnswer>;
|
|
/** the digest of the node's own composition it runs */
|
|
"composed"?: string;
|
|
/** own, or none (empty) */
|
|
"composes"?: string;
|
|
"composes-why"?: string;
|
|
"filters"?: Record<string, unknown>[];
|
|
"profile"?: Record<string, unknown>;
|
|
"record"?: NodeRecord;
|
|
"sealed"?: string[];
|
|
"sealed-at"?: Record<string, string>;
|
|
"strays"?: Record<string, unknown>[];
|
|
"v": number;
|
|
"windows"?: Record<string, unknown>[];
|
|
}
|
|
|
|
/** is one value of the state composed under the key <node>.<module>.<fingerprint>. */
|
|
export interface ComposedByNodeModuleFingerprintValue {
|
|
/** the module declares data */
|
|
"data"?: boolean;
|
|
/** the files the provisioner fills */
|
|
"filled_files"?: string[];
|
|
"fp": string;
|
|
"module": string;
|
|
"node": string;
|
|
/** the module's whole provisioning plan, catalogue.Plan, kept whole: it is the manifest layer's type */
|
|
"plan"?: Record<string, unknown>;
|
|
/** why the module cannot be composed at this fingerprint */
|
|
"refused"?: string;
|
|
/** the declaration resources, each saying its module */
|
|
"resources": Record<string, unknown>[];
|
|
"v": number;
|
|
}
|
|
|
|
/** is one value of the state composed under the key <node>.node. */
|
|
export interface ComposedByNodeNodeValue {
|
|
/** the module declares data */
|
|
"data"?: boolean;
|
|
/** the files the provisioner fills */
|
|
"filled_files"?: string[];
|
|
"node": string;
|
|
"own"?: NodeOwn;
|
|
/** the declaration resources, each saying its module */
|
|
"resources": Record<string, unknown>[];
|
|
"v": number;
|
|
}
|
|
|
|
/** is one value of the state data under the key <node>.<module>. */
|
|
export interface DataByNodeModuleValue {
|
|
"digest": string;
|
|
"items": PlacedDataItem[];
|
|
"module": string;
|
|
"node": string;
|
|
"v": number;
|
|
}
|
|
|
|
export interface PackagesByNodeValuePackagesItem {
|
|
"absent": boolean;
|
|
"modules": string[];
|
|
"package": string;
|
|
}
|
|
|
|
/** is one value of the state packages under the key <node>. */
|
|
export interface PackagesByNodeValue {
|
|
"node": string;
|
|
"packages": PackagesByNodeValuePackagesItem[];
|
|
}
|
|
|
|
/** is one value of the state health under the key <node>. */
|
|
export interface HealthByNodeValue {
|
|
/** when */
|
|
"at": string;
|
|
"contract"?: number;
|
|
"fallback"?: LoginFallback;
|
|
"found"?: NodeDirectory[];
|
|
"network"?: NetworkHealth;
|
|
"node": string;
|
|
"peers"?: PeerSeen[];
|
|
"relogin"?: NodeAccount[];
|
|
"root"?: RootAccountVerdict[];
|
|
"units"?: UnitsHealth;
|
|
"v": number;
|
|
}
|
|
|
|
/** is one value of the state findings under the key <key>. */
|
|
export interface FindingsByKeyValue {
|
|
"actions"?: FindingAction[];
|
|
"at": string;
|
|
/** newest first, at most 10 */
|
|
"evidence"?: FindingEvidence[];
|
|
"explanation"?: string;
|
|
"headline"?: string;
|
|
/** scope.id.token */
|
|
"key": string;
|
|
"kind": string;
|
|
"needs"?: string;
|
|
/** the module that wrote it */
|
|
"observer": string;
|
|
/** the key's last part when it is not the kind */
|
|
"ref"?: string;
|
|
"resolved"?: string;
|
|
/** self, operator, agent or healer:<name> */
|
|
"resolver"?: string;
|
|
/** what of its own saw it last */
|
|
"run"?: string;
|
|
"severity": "urgent" | "warning";
|
|
/** the row, probe or event that saw it */
|
|
"source": string;
|
|
"subject": FindingSubject;
|
|
/** one line */
|
|
"summary": string;
|
|
/** layout version, 1 */
|
|
"v": number;
|
|
}
|
|
|