ankka-console 0.10.0 → 0.12.0

package/dist/testing/fake-control-plane.d.ts

@@ -2,7 +2,8 @@
  * A control plane in one process: every route the console uses, over in-memory state, with the
  * control plane's rules as the console can observe them — who sees what, `404` rather than `403`
  * for an outsider, owner-only operations, tombstoned ids, `409` for a non-empty delete, a disabled
- * organization refusing changes, descriptor validation, a deploy token shown once.
+ * organization refusing changes, descriptor validation, a deploy token shown once, grants made,
+ * listed and ended with their effect, and machines registered with a secret shown once.
  *
  * It answers from state rather than from a script, so it cannot run out quietly. What a test needs
  * to steer is explicit: `script()` makes the next answer on one route a given status, `tick()` moves
@@ -32,6 +33,10 @@ export interface FakeControlPlaneOptions {
     signupUrl?: string;
     baseDomain?: string;
     port?: number;
+    /** The broker's address outside the cluster; unset, the installation does not expose its broker and a machine's topic grant opens nothing. */
+    brokerBootstrap?: string;
+    /** The most bytes a second a machine may be given on either side; the control plane's default is 32 MiB. */
+    byteRateCeiling?: number;
 }
 type Role = "owner" | "member";
 interface Member {
@@ -66,16 +71,144 @@ interface Registry {
     setAt: string;
     setBy?: string;
 }
+interface ProjectSecret {
+    /** Values held as the cluster holds them; the control plane never answers with one. */
+    entries: Map<string, string>;
+    setAt: string;
+    setBy?: string;
+}
 interface Project {
     id: string;
     name: string;
     organizationId: string;
     registry?: Registry;
+    secrets?: Map<string, ProjectSecret>;
+    /** Declared topics, by name: their partitions, compaction, contract and what the broker reported of each. */
+    topics?: Map<string, TopicRecord>;
+    /** Declared brokers beside the installation's, by name. */
+    brokers?: Map<string, BrokerRecord>;
+    /** Where the project's new buckets in Google Cloud Storage are made (feature 039). */
+    location?: string;
+    /** Feature 041: restores asked for, in order, and rehearsals. Restores verify at once here. */
+    restores?: {
+        name: string;
+        line: string;
+        moment: string;
+        requestedBy?: string;
+        requestedAt: string;
+    }[];
+    rehearsals?: {
+        name: string;
+        line: string;
+        moment: string;
+        requestedBy?: string;
+        requestedAt: string;
+    }[];
+    databaseHistory?: {
+        kind: string;
+        by?: string;
+        at: string;
+        detail?: string;
+    }[];
+    credentialGeneration?: number;
+    database?: {
+        replicas: number;
+        synchronous: boolean;
+        retentionDays?: number;
+        rehearse?: string;
+    };
+    /** The changes to its topics, newest first. */
+    history?: ProjectHistoryRecord[];
     hidden: boolean;
 }
+interface ProjectHistoryRecord {
+    kind: string;
+    topic: string;
+    actor?: {
+        subject: string;
+        display?: string;
+        administrative: boolean;
+    };
+    at?: string;
+    changes: {
+        setting: string;
+        from: string;
+        to: string;
+    }[];
+}
+interface BrokerRecord {
+    bootstrap: string;
+    shape: string;
+    secret: string;
+    declaredAt: string;
+}
+/** A topic source as an instance reports it, with how far behind it is. */
+interface TopicSourceRecord {
+    kind: string;
+    component: string;
+    topic: string;
+    group: string;
+    start?: string;
+    version?: number;
+    broker?: string;
+    contract?: string;
+    lag?: number;
+    failing?: string;
+    /** What the broker still holds of the topic, per partition. */
+    gap?: {
+        partitions: {
+            partition: number;
+            beginning: number;
+            earliestRetained?: string;
+        }[];
+        compacted?: boolean;
+        gone?: boolean;
+        readAt?: string;
+    };
+}
+/** A topic's settings, in the words a member types, as the control plane keeps them. */
+interface TopicSettingsRecord {
+    retention: string;
+    retentionSize: string;
+    cleanup: string;
+    tombstoneWindow: string;
+    minCompactionLag: string;
+    maxCompactionLag: string;
+    copies?: number;
+    minInSync?: number;
+}
+declare const SettingNames: readonly ["retention", "retentionSize", "cleanup", "tombstoneWindow", "minCompactionLag", "maxCompactionLag", "copies", "minInSync"];
+type SettingName = (typeof SettingNames)[number];
+interface TopicRecord {
+    partitions: number;
+    phase?: string;
+    detail?: string;
+    compacted?: boolean;
+    contract?: {
+        name: string;
+        fingerprint: string;
+        schema: unknown;
+    };
+    /** Every setting, and the ones the installation supplied; absent for a topic seeded without them. */
+    settings?: TopicSettingsRecord;
+    defaulted?: SettingName[];
+    /** How many copies the broker holds, as a seed says. */
+    copiesHeld?: number;
+}
+/** One side a running service takes on a declared topic with a contract, against it; `topic` is the fake's own, for the project's listing. */
+interface TopicCheckRecord {
+    topic?: string;
+    service: string;
+    component: string;
+    direction: string;
+    stated?: string;
+    state: string;
+}
 interface Service {
     name: string;
     projectId: string;
+    /** Custom hostnames (feature 045), in the order added; the fake serves each at once. */
+    customHostnames?: string[];
     lifecycle: string;
     generation: number;
     image: string;
@@ -84,6 +217,10 @@ interface Service {
     detail?: string;
     exposed: boolean;
     paused: boolean;
+    /** What the cluster reports of its database; `null` until it has reported one. */
+    database: string | null;
+    /** The restore a member switched it to (feature 041); the project database when absent. */
+    databaseCluster?: string;
     history: {
         kind: string;
         generation: number;
@@ -93,9 +230,72 @@ interface Service {
             administrative: boolean;
         };
         at: string;
+        image?: string;
+        digest?: string;
+        hostname?: string;
+        rolledBackTo?: number;
+    }[];
+    /** The descriptor in force, and the applied ones a rollback can return to, newest first, at most fifty. */
+    descriptor?: unknown;
+    kept: {
+        generation: number;
+        descriptor: unknown;
     }[];
     logs: Map<string, string[]>;
     previousLogs: Map<string, string[]>;
+    /** The platform's container's output: the sidecar beside a process, the proxy beside a web-hosted one. */
+    platformLogs: Map<string, string[]>;
+    hosting?: string;
+    mounts?: {
+        path: string;
+        service: string;
+        state: string;
+    }[];
+    callers?: string[];
+    processPort?: number;
+    /** What the operator reported of the service's credential on the installation's broker. */
+    broker?: string;
+    /** Topics the service's components use that its project does not declare, as last read. */
+    undeclaredTopics?: string[];
+    /** The sides it takes on declared topics with a contract, as last read. */
+    topicChecks?: TopicCheckRecord[];
+    /** Its topic sources with how far behind each is, as last read. */
+    topicSources?: TopicSourceRecord[];
+    /** The descriptor asked for a bucket (feature 034). */
+    provisionObjectStorage?: boolean;
+    /** The descriptor gave an ANKKA_S3_ variable: an object store of its own. */
+    ownObjectStore?: boolean;
+    /** The descriptor asked that the bucket be reachable from the internet. */
+    exposeObjectStorage?: boolean;
+    /** The store the bucket is in, `garage` or `gcs`, as the operator reports it (feature 039). */
+    objectStore?: string;
+    /** Where its bucket in Google Cloud Storage is. */
+    bucketLocation?: string;
+    /** Where a move of its bucket from Garage is, as the control plane phrases it. */
+    storageMove?: string;
+    /** What the instances report when asked for the topology; generated from the service when unset. */
+    topology?: FakeTopology;
+}
+/** A service's instances, what each answered, and the merged document, as a suite scripts it. */
+export interface FakeTopology {
+    instances: {
+        pod: string;
+        status: "ok" | "unreachable" | "unsupported" | "failed";
+        problem?: string;
+    }[];
+    nodes: unknown[];
+    declared: unknown[];
+    calls: unknown[];
+    differences?: {
+        node: string;
+        presentOn: string[];
+    }[];
+    window?: {
+        seconds: number;
+        since: string;
+        calls: number;
+        unanswered?: number;
+    };
 }
 interface Token {
     id: string;
@@ -108,6 +308,48 @@ interface Token {
     expiresAt?: string;
     revoked: boolean;
 }
+/** What one grant opens, flat as the control plane holds it (feature 040). */
+export interface FakeGrantTarget {
+    kind: string;
+    service?: string;
+    method?: string;
+    path?: string;
+    topic?: string;
+    right?: string;
+    decrypt?: boolean;
+}
+interface GrantAct {
+    by?: string;
+    at: string;
+}
+/** A grant a project made; `changes` is what the grantee's side records of it. */
+interface Grant {
+    id: string;
+    projectId: string;
+    grantee: string;
+    target: FakeGrantTarget;
+    state: string;
+    granted: GrantAct;
+    answered?: GrantAct;
+    ended?: GrantAct;
+    changes: {
+        change: string;
+        by?: string;
+        at: string;
+    }[];
+}
+interface Machine {
+    organizationId: string;
+    name: string;
+    registeredBy?: string;
+    registeredAt: string;
+    byteRates?: {
+        produceBytesPerSecond: number;
+        consumeBytesPerSecond: number;
+        requestPercentage: number;
+    };
+    hidden: boolean;
+}
 export interface FakeControlPlane {
     url: string;
     server: Server;
@@ -120,6 +362,8 @@ export interface FakeControlPlane {
     /** Advance every service in a transitional state by one step. */
     tick(): void;
     appendLog(projectId: string, name: string, line: string, instance?: string): void;
+    /** What a service's instances report when its topology is read, from now on. */
+    scriptTopology(projectId: string, name: string, topology: FakeTopology): void;
     /** Who may create organizations from now on, and where the refusal sends people. */
     policy(creation: "open" | "platform-admin", signupUrl?: string): void;
     /** From now on, created organizations and projects are missing from listings until `settle()`. */
@@ -132,11 +376,36 @@ export interface FakeControlPlane {
         services: Map<string, Service>;
         tokens: Map<string, Token>;
         tombstones: Set<string>;
+        /** Every project's grants, by id. */
+        grants: Map<string, Grant>;
+        /** Registered machines, by `<organization>/<name>`. */
+        machines: Map<string, Machine>;
     };
     seed(seed: FakeSeed): void;
     close(): Promise<void>;
 }
+/** The installation's cloud, as `GET /installation` reports it (feature 044). */
+export interface FakeCloud {
+    provider: string;
+    account: string;
+    location: string;
+    kmsKey?: string;
+}
 export interface FakeSeed {
+    /** The installation's cloud (feature 044); `null` for an installation that names none, as until seeded. */
+    cloud?: FakeCloud | null;
+    /** Where the installation keeps new buckets (feature 039); Garage until a suite says otherwise. */
+    objectStore?: "garage" | "gcs";
+    /** Feature 041: start held, as a control plane whose own database was restored. */
+    held?: {
+        targetTime: string;
+        services?: {
+            project: string;
+            service: string;
+            recordedImage?: string;
+            clusterImage?: string;
+        }[];
+    };
     organizations?: {
         id: string;
         name: string;
@@ -155,6 +424,70 @@ export interface FakeSeed {
         image?: string;
         lifecycle?: string;
         instances?: number;
+        hosting?: string;
+        mounts?: {
+            path: string;
+            service: string;
+            state: string;
+        }[];
+        callers?: string[];
+        processPort?: number;
+        exposed?: boolean;
+        /** What the cluster reports of its database; `null` until it has reported one. */
+        database?: string | null;
+        broker?: string;
+        undeclaredTopics?: string[];
+        topicChecks?: TopicCheckRecord[];
+        topicSources?: TopicSourceRecord[];
+        provisionObjectStorage?: boolean;
+        exposeObjectStorage?: boolean;
+        ownObjectStore?: boolean;
+        /** The store its bucket is in, `garage` or `gcs`. */
+        objectStore?: string;
+        bucketLocation?: string;
+    }[];
+    /** Project secrets, by name and entry: a value each, never listed. */
+    secrets?: {
+        projectId: string;
+        name: string;
+        entries: Record<string, string>;
+    }[];
+    /** Brokers a project declares beside the installation's. */
+    brokers?: {
+        projectId: string;
+        name: string;
+        bootstrap: string;
+        shape: string;
+        secret: string;
+    }[];
+    /** Topics a project declares, as the control plane holds them, with the broker's report. */
+    topics?: {
+        projectId: string;
+        name: string;
+        partitions: number;
+        phase?: string;
+        detail?: string;
+        compacted?: boolean;
+        contract?: {
+            name: string;
+            schema: unknown;
+        };
+        /** Its settings, each the installation's shipped default unless given; none for a topic from before settings. */
+        settings?: Partial<TopicSettingsRecord>;
+    }[];
+    /** Grants a project made, as if an owner had made them: accepted within its organization, pending to another, unless `state` says. */
+    grants?: {
+        projectId: string;
+        grantee: string;
+        target: FakeGrantTarget;
+        state?: string;
+        by?: string;
+    }[];
+    /** Machines registered on an organization. */
+    machines?: {
+        organizationId: string;
+        name: string;
+        byteRates?: Machine["byteRates"];
     }[];
 }
 export declare function fakeControlPlane(options?: FakeControlPlaneOptions): Promise<FakeControlPlane>;