@intentius/chant 0.124.96 → 0.124.98
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/audit/core.d.ts +29 -0
- package/dist/audit/core.d.ts.map +1 -1
- package/dist/audit/core.js +48 -11
- package/dist/audit/identity.d.ts +27 -0
- package/dist/audit/identity.d.ts.map +1 -0
- package/dist/audit/identity.js +36 -0
- package/dist/audit/report-html.d.ts +3 -1
- package/dist/audit/report-html.d.ts.map +1 -1
- package/dist/audit/report-html.js +1 -1
- package/dist/audit/report-model.d.ts +16 -0
- package/dist/audit/report-model.d.ts.map +1 -1
- package/dist/audit/report-model.js +5 -1
- package/dist/change-set-graph.d.ts +3 -1
- package/dist/change-set-graph.d.ts.map +1 -1
- package/dist/change-set-graph.js +7 -1
- package/dist/change-set.d.ts +5 -2
- package/dist/change-set.d.ts.map +1 -1
- package/dist/change-set.js +6 -3
- package/dist/ci-agent.d.ts +17 -0
- package/dist/ci-agent.d.ts.map +1 -1
- package/dist/ci-agent.js +32 -0
- package/dist/ci-comment-allow.d.ts +88 -0
- package/dist/ci-comment-allow.d.ts.map +1 -0
- package/dist/ci-comment-allow.js +178 -0
- package/dist/ci-comment-commands.d.ts +12 -0
- package/dist/ci-comment-commands.d.ts.map +1 -1
- package/dist/ci-comment-commands.js +22 -0
- package/dist/ci-control.d.ts +6 -1
- package/dist/ci-control.d.ts.map +1 -1
- package/dist/ci-control.js +6 -1
- package/dist/ci-product.d.ts +3 -0
- package/dist/ci-product.d.ts.map +1 -1
- package/dist/ci-product.js +3 -0
- package/dist/cli/commands/audit.d.ts +3 -1
- package/dist/cli/commands/audit.d.ts.map +1 -1
- package/dist/cli/commands/audit.js +23 -6
- package/dist/cli/commands/import.d.ts +8 -1
- package/dist/cli/commands/import.d.ts.map +1 -1
- package/dist/cli/commands/import.js +31 -6
- package/dist/cli/handlers/agent.d.ts.map +1 -1
- package/dist/cli/handlers/agent.js +12 -2
- package/dist/cli/handlers/pr-comment.d.ts +6 -0
- package/dist/cli/handlers/pr-comment.d.ts.map +1 -1
- package/dist/cli/handlers/pr-comment.js +12 -0
- package/dist/cli/handlers/promote.d.ts.map +1 -1
- package/dist/cli/handlers/promote.js +53 -6
- package/dist/cli/main.d.ts.map +1 -1
- package/dist/cli/main.js +29 -6
- package/dist/cli/parse-args.d.ts.map +1 -1
- package/dist/cli/parse-args.js +23 -0
- package/dist/cli/registry.d.ts +8 -0
- package/dist/cli/registry.d.ts.map +1 -1
- package/dist/cloud-lister/mask.d.ts +30 -1
- package/dist/cloud-lister/mask.d.ts.map +1 -1
- package/dist/cloud-lister/mask.js +66 -3
- package/dist/components/driver.d.ts +8 -1
- package/dist/components/driver.d.ts.map +1 -1
- package/dist/components/driver.js +1 -0
- package/dist/components/product-pipeline.d.ts +23 -1
- package/dist/components/product-pipeline.d.ts.map +1 -1
- package/dist/components/product-pipeline.js +40 -7
- package/dist/components/product-plan.d.ts +20 -0
- package/dist/components/product-plan.d.ts.map +1 -1
- package/dist/components/product-plan.js +11 -1
- package/dist/control/applied.d.ts +8 -1
- package/dist/control/applied.d.ts.map +1 -1
- package/dist/control/applied.js +18 -2
- package/dist/control/dispatch.d.ts +52 -0
- package/dist/control/dispatch.d.ts.map +1 -1
- package/dist/control/dispatch.js +140 -4
- package/dist/control/train.d.ts +198 -0
- package/dist/control/train.d.ts.map +1 -0
- package/dist/control/train.js +294 -0
- package/dist/deep-observation.js +2 -2
- package/dist/floor-table.data.d.ts.map +1 -1
- package/dist/floor-table.data.js +7 -1
- package/dist/graph-detail.d.ts +9 -0
- package/dist/graph-detail.d.ts.map +1 -1
- package/dist/graph-detail.js +38 -13
- package/dist/graph-refs.d.ts +233 -3
- package/dist/graph-refs.d.ts.map +1 -1
- package/dist/graph-refs.js +106 -15
- package/dist/lint/post-synth.d.ts +22 -0
- package/dist/lint/post-synth.d.ts.map +1 -1
- package/dist/lint/rules/declarable-naming-convention.d.ts +12 -0
- package/dist/lint/rules/declarable-naming-convention.d.ts.map +1 -1
- package/dist/lint/rules/declarable-naming-convention.js +38 -8
- package/dist/lint/rules/imported-source.d.ts +20 -0
- package/dist/lint/rules/imported-source.d.ts.map +1 -0
- package/dist/lint/rules/imported-source.js +27 -0
- package/dist/lint/rules/no-unused-declarable.d.ts.map +1 -1
- package/dist/lint/rules/no-unused-declarable.js +3 -0
- package/dist/op/gate.d.ts +2 -0
- package/dist/op/gate.d.ts.map +1 -1
- package/dist/op/gate.js +8 -1
- package/dist/pr-forge-reads.d.ts +17 -0
- package/dist/pr-forge-reads.d.ts.map +1 -1
- package/dist/pr-forge-reads.js +55 -0
- package/dist/reconcile.d.ts +9 -0
- package/dist/reconcile.d.ts.map +1 -1
- package/dist/release-floors.d.ts +9 -1
- package/dist/release-floors.d.ts.map +1 -1
- package/dist/release-floors.js +10 -2
- package/dist/repo-path.d.ts +29 -0
- package/dist/repo-path.d.ts.map +1 -0
- package/dist/repo-path.js +81 -0
- package/dist/sensitive-key.d.ts +23 -0
- package/dist/sensitive-key.d.ts.map +1 -1
- package/dist/sensitive-key.js +37 -0
- package/dist/terraform/hcl2json.d.ts +7 -0
- package/dist/terraform/hcl2json.d.ts.map +1 -1
- package/dist/terraform/hcl2json.js +7 -0
- package/dist/wave-runtime.mjs +352 -345
- package/dist/workspace/catalog-edges.d.ts +147 -0
- package/dist/workspace/catalog-edges.d.ts.map +1 -0
- package/dist/workspace/catalog-edges.js +461 -0
- package/dist/workspace/compose-graph.d.ts +73 -3
- package/dist/workspace/compose-graph.d.ts.map +1 -1
- package/dist/workspace/declaration.d.ts +2 -0
- package/dist/workspace/declaration.d.ts.map +1 -1
- package/dist/workspace/declaration.js +1 -0
- package/dist/workspace/declaration.schema.json +6 -0
- package/dist/workspace/discover.d.ts +134 -0
- package/dist/workspace/discover.d.ts.map +1 -0
- package/dist/workspace/discover.js +372 -0
- package/dist/workspace/graph-cli.d.ts +20 -0
- package/dist/workspace/graph-cli.d.ts.map +1 -1
- package/dist/workspace/graph-cli.js +178 -20
- package/dist/workspace/graph.schema.json +195 -2
- package/dist/workspace/release-train.d.ts +214 -3
- package/dist/workspace/release-train.d.ts.map +1 -1
- package/dist/workspace/release-train.js +552 -16
- package/dist/workspace/repo-ref.d.ts +14 -0
- package/dist/workspace/repo-ref.d.ts.map +1 -1
- package/dist/workspace/repo-ref.js +26 -1
- package/dist/workspace/workspace-gates.d.ts +24 -0
- package/dist/workspace/workspace-gates.d.ts.map +1 -1
- package/dist/workspace/workspace-gates.js +29 -5
- package/dist/workspace/workspace-ledger.d.ts +31 -5
- package/dist/workspace/workspace-ledger.d.ts.map +1 -1
- package/dist/workspace/workspace-ledger.js +2 -1
- package/dist/workspace/workspace-run.d.ts +14 -0
- package/dist/workspace/workspace-run.d.ts.map +1 -1
- package/dist/workspace/workspace-run.js +2 -2
- package/dist/yaml.d.ts.map +1 -1
- package/dist/yaml.js +33 -8
- package/package.json +1 -1
- package/src/audit/core.test.ts +64 -1
- package/src/audit/core.ts +75 -10
- package/src/audit/identity.test.ts +31 -0
- package/src/audit/identity.ts +43 -0
- package/src/audit/report-html.ts +4 -2
- package/src/audit/report-model.ts +21 -1
- package/src/change-set-graph.test.ts +33 -1
- package/src/change-set-graph.ts +7 -1
- package/src/change-set.ts +6 -3
- package/src/ci-agent.test.ts +32 -0
- package/src/ci-agent.ts +42 -0
- package/src/ci-comment-allow.test.ts +380 -0
- package/src/ci-comment-allow.ts +184 -0
- package/src/ci-comment-commands.ts +25 -0
- package/src/ci-control.ts +42 -0
- package/src/ci-product.ts +3 -0
- package/src/cli/commands/audit-parser-notice.test.ts +74 -0
- package/src/cli/commands/audit.test.ts +12 -0
- package/src/cli/commands/audit.ts +25 -7
- package/src/cli/commands/import-layout.test.ts +2 -1
- package/src/cli/commands/import.ts +29 -6
- package/src/cli/handlers/agent.ts +13 -2
- package/src/cli/handlers/pr-before-merge.test.ts +18 -0
- package/src/cli/handlers/pr-comment.ts +12 -0
- package/src/cli/handlers/promote.test.ts +68 -0
- package/src/cli/handlers/promote.ts +52 -6
- package/src/cli/main.test.ts +5 -0
- package/src/cli/main.ts +29 -6
- package/src/cli/parse-args.ts +18 -0
- package/src/cli/registry.ts +8 -0
- package/src/cloud-lister/kubernetes.k3d.e2e.test.ts +104 -0
- package/src/cloud-lister/mask-references.test.ts +132 -0
- package/src/cloud-lister/mask.ts +68 -3
- package/src/components/driver.ts +9 -1
- package/src/components/product-pipeline.ts +57 -7
- package/src/components/product-plan.ts +27 -2
- package/src/control/applied.ts +33 -3
- package/src/control/dispatch.ts +156 -5
- package/src/control/train.test.ts +215 -0
- package/src/control/train.ts +413 -0
- package/src/deep-observation.ts +2 -2
- package/src/floor-table.data.ts +7 -1
- package/src/graph-detail.ts +37 -12
- package/src/graph-refs.test.ts +45 -1
- package/src/graph-refs.ts +321 -14
- package/src/lint/post-synth.ts +20 -0
- package/src/lint/rules/declarable-naming-convention.test.ts +35 -1
- package/src/lint/rules/declarable-naming-convention.ts +35 -8
- package/src/lint/rules/imported-source.test.ts +22 -0
- package/src/lint/rules/imported-source.ts +31 -0
- package/src/lint/rules/no-unused-declarable.test.ts +16 -0
- package/src/lint/rules/no-unused-declarable.ts +7 -0
- package/src/op/gate.ts +10 -2
- package/src/pr-forge-reads.ts +62 -0
- package/src/reconcile.ts +9 -0
- package/src/release-floors.ts +14 -2
- package/src/repo-path.test.ts +72 -0
- package/src/repo-path.ts +103 -0
- package/src/sensitive-key.ts +38 -0
- package/src/terraform/hcl2json.ts +8 -0
- package/src/workspace/application-set.e2e.test.ts +405 -0
- package/src/workspace/catalog-edges.ts +507 -0
- package/src/workspace/ci-green-workflow.test.ts +2 -2
- package/src/workspace/cluster-join.e2e.test.ts +150 -0
- package/src/workspace/compose-graph.ts +74 -5
- package/src/workspace/declaration.schema.json +6 -0
- package/src/workspace/declaration.ts +3 -0
- package/src/workspace/discover.e2e.test.ts +122 -0
- package/src/workspace/discover.test.ts +225 -0
- package/src/workspace/discover.ts +406 -0
- package/src/workspace/drift-reader.test.ts +3 -3
- package/src/workspace/external-secret-catalog.e2e.test.ts +98 -0
- package/src/workspace/external-secret-catalog.test.ts +142 -0
- package/src/workspace/graph-cli.ts +207 -21
- package/src/workspace/graph-contract.test.ts +92 -0
- package/src/workspace/graph.schema.json +195 -2
- package/src/workspace/helm-references.e2e.test.ts +135 -0
- package/src/workspace/identity-annotation-catalog.e2e.test.ts +91 -0
- package/src/workspace/identity-annotation-catalog.test.ts +139 -0
- package/src/workspace/release-train-repos.test.ts +304 -0
- package/src/workspace/release-train.test.ts +296 -0
- package/src/workspace/release-train.ts +631 -16
- package/src/workspace/repo-ref.ts +26 -1
- package/src/workspace/runs-on.test.ts +45 -0
- package/src/workspace/workspace-gates.ts +48 -5
- package/src/workspace/workspace-ledger.ts +28 -5
- package/src/workspace/workspace-run.test.ts +1 -1
- package/src/workspace/workspace-run.ts +2 -2
- package/src/yaml.test.ts +96 -8
- package/src/yaml.ts +36 -8
|
@@ -8,15 +8,54 @@
|
|
|
8
8
|
* the one `--pin <member>=<label|digest>` picks. It refuses unless every
|
|
9
9
|
* `chant` member of the declaration has a release, so a train never leaves a
|
|
10
10
|
* member out. It is written to `_members/_workspace/<env>/trains.jsonl`.
|
|
11
|
+
*
|
|
12
|
+
* A train's digest (#4037) is over the member release digests and nothing
|
|
13
|
+
* else, so the same picks always give the same train digest, whatever the
|
|
14
|
+
* environment, actor or time. The member releases are named, never copied
|
|
15
|
+
* or changed.
|
|
16
|
+
*
|
|
17
|
+
* `chant workspace train promote <env>` (#4037) promotes a train: each
|
|
18
|
+
* member's `chant components promote --to <env> --release <its digest>`,
|
|
19
|
+
* under the member's own chant, producers first. With `--gate <name>`,
|
|
20
|
+
* every member plans first (`--plan-only`), one workspace gate fact covers
|
|
21
|
+
* each member's release gates with its change set and release, and nothing
|
|
22
|
+
* deploys until `chant workspace run approve <name>` approves it. The
|
|
23
|
+
* promote is a workspace run record that names the train.
|
|
24
|
+
*
|
|
25
|
+
* A train can pin `repo` members too (#5119): each one's releases are read
|
|
26
|
+
* at its pinned revision through that repository's own `chant release list
|
|
27
|
+
* --json`. A train of `repo` members is promoted from the control repo, one
|
|
28
|
+
* member repository at a time: each call dispatches a member, or moves on
|
|
29
|
+
* from its answer in `_control/applied.jsonl` (`--continue`). Each member
|
|
30
|
+
* keeps its own gate (../control/train.ts has the jobs on both sides).
|
|
11
31
|
*/
|
|
32
|
+
import { spawn } from "node:child_process";
|
|
12
33
|
import { randomUUID } from "node:crypto";
|
|
13
34
|
import { resolve } from "node:path";
|
|
14
35
|
import { formatError } from "../cli/format.js";
|
|
36
|
+
import { CHANT_EXIT } from "../exit-codes.js";
|
|
37
|
+
import { computePlanDigest } from "../lifecycle/plan-digest.js";
|
|
15
38
|
import { readAllReleases, readCuts } from "../lifecycle/release-store.js";
|
|
39
|
+
import { WORKSPACE_GATE_ENV, WORKSPACE_RUN_ENV } from "../op/workspace-run-env.js";
|
|
16
40
|
import { readDeclaration, WorkspaceReadError } from "./declaration.js";
|
|
41
|
+
import { REPO_KIND } from "./kinds.js";
|
|
17
42
|
import { locateWorkspace } from "./which-chant.js";
|
|
18
|
-
import { appendWorkspaceLine, readWorkspaceLines } from "./workspace-ledger.js";
|
|
43
|
+
import { appendWorkspaceLine, appendWorkspaceRun, readWorkspaceLines, readWorkspaceRuns } from "./workspace-ledger.js";
|
|
44
|
+
import { appendWorkspaceGatePending, readWorkspaceGate, workspaceGateDigest } from "./workspace-gates.js";
|
|
19
45
|
import { actorFromEnv } from "../actor.js";
|
|
46
|
+
import { NEXT_RELEASE } from "../release-floors.js";
|
|
47
|
+
/**
|
|
48
|
+
* The digest of a train (#4037): over each member's name and release digest,
|
|
49
|
+
* sorted by member. The commit and the label are the release's own, and the
|
|
50
|
+
* release digest already covers the commit, so they stay out, as do the
|
|
51
|
+
* environment, the id, the actor and the time.
|
|
52
|
+
*/
|
|
53
|
+
export function trainDigest(members) {
|
|
54
|
+
const subject = [...members]
|
|
55
|
+
.map((m) => ({ member: m.member, releaseDigest: m.releaseDigest }))
|
|
56
|
+
.sort((a, b) => (a.member < b.member ? -1 : a.member > b.member ? 1 : 0));
|
|
57
|
+
return computePlanDigest("release-train", { members: subject });
|
|
58
|
+
}
|
|
20
59
|
const TRAINS_FILE = "trains.jsonl";
|
|
21
60
|
/**
|
|
22
61
|
* Pick each member's release, pure. `pins` maps a member to a label or a
|
|
@@ -28,25 +67,41 @@ export function pickTrain(members, pins = new Map()) {
|
|
|
28
67
|
const picked = [];
|
|
29
68
|
for (const name of pins.keys()) {
|
|
30
69
|
if (!members.some((m) => m.member === name))
|
|
31
|
-
problems.push(`--pin ${name}: not a chant member of the workspace`);
|
|
70
|
+
problems.push(`--pin ${name}: not a chant or repo member of the workspace`);
|
|
32
71
|
}
|
|
33
72
|
for (const m of members) {
|
|
73
|
+
if (m.problem !== undefined) {
|
|
74
|
+
problems.push(`member ${m.member}: ${m.problem}`);
|
|
75
|
+
continue;
|
|
76
|
+
}
|
|
34
77
|
const pin = pins.get(m.member);
|
|
35
78
|
const r = pin === undefined ? m.releases[0] : m.releases.find((x) => x.releaseDigest === pin || x.label === pin);
|
|
36
79
|
if (!r) {
|
|
37
|
-
|
|
80
|
+
const where = m.repo !== undefined ? `in ${m.repo}` : "in its directory";
|
|
81
|
+
problems.push(pin === undefined ? `member ${m.member} has no release; cut one with chant release cut ${where}` : `member ${m.member} has no release ${pin}`);
|
|
38
82
|
continue;
|
|
39
83
|
}
|
|
40
84
|
picked.push(r);
|
|
41
85
|
}
|
|
86
|
+
// #4037: a train names at least one release, so its digest never covers nothing.
|
|
87
|
+
if (members.length === 0)
|
|
88
|
+
problems.push("the workspace declares no chant or repo member, so a train has nothing to pin");
|
|
42
89
|
return problems.length > 0 ? { problems } : { members: picked };
|
|
43
90
|
}
|
|
44
|
-
/**
|
|
45
|
-
|
|
91
|
+
/**
|
|
92
|
+
* Every `chant` member's releases, newest cut first, read from its ledger,
|
|
93
|
+
* and every `repo` member's, read through that repository's own
|
|
94
|
+
* `chant release list --json` at its pinned revision (#5119).
|
|
95
|
+
*/
|
|
96
|
+
export async function readMemberReleases(cwd, opts = {}) {
|
|
46
97
|
const located = locateWorkspace(cwd);
|
|
47
98
|
const declaration = readDeclaration(located.tree, "", { rootChant: true });
|
|
48
99
|
const out = [];
|
|
49
100
|
for (const m of declaration.members) {
|
|
101
|
+
if (m.kind === REPO_KIND && m.repo !== null) {
|
|
102
|
+
out.push(await (opts.readRepo ?? readRepoReleases)(m.name, m.repo, located.rootOnDisk));
|
|
103
|
+
continue;
|
|
104
|
+
}
|
|
50
105
|
if (m.kind !== "chant")
|
|
51
106
|
continue;
|
|
52
107
|
const loc = { cwd: located.rootOnDisk, member: m.dir === "." ? "." : m.name };
|
|
@@ -62,20 +117,402 @@ export async function readMemberReleases(cwd) {
|
|
|
62
117
|
}
|
|
63
118
|
return out;
|
|
64
119
|
}
|
|
120
|
+
/** Starts one chant command in `cwd` and gives back what it printed. */
|
|
121
|
+
function spawnChant(command, argv, cwd) {
|
|
122
|
+
const [bin, ...pre] = command;
|
|
123
|
+
return new Promise((done) => {
|
|
124
|
+
const child = spawn(bin, [...pre, ...argv], { cwd, stdio: ["ignore", "pipe", "pipe"], env: process.env });
|
|
125
|
+
const out = [];
|
|
126
|
+
const err = [];
|
|
127
|
+
child.stdout.on("data", (b) => out.push(b));
|
|
128
|
+
child.stderr.on("data", (b) => err.push(b));
|
|
129
|
+
child.on("error", (e) => done({ exitCode: 127, stdout: "", stderr: `could not start ${bin}: ${e.message}` }));
|
|
130
|
+
child.on("close", (code) => done({ exitCode: code ?? 1, stdout: Buffer.concat(out).toString("utf8"), stderr: Buffer.concat(err).toString("utf8") }));
|
|
131
|
+
});
|
|
132
|
+
}
|
|
133
|
+
/**
|
|
134
|
+
* The releases of a `repo` member (#5119), read the way its graph is read
|
|
135
|
+
* (#3168): chant fetches the pinned revision into the user's cache, brings
|
|
136
|
+
* that repository's `chant/lifecycle` into the cache clone, and runs
|
|
137
|
+
* `chant release list --json` in the workspace root at the revision, under
|
|
138
|
+
* the chant that resolves there. Nothing is written in the other
|
|
139
|
+
* repository. A read that fails says why, and stops the train.
|
|
140
|
+
*/
|
|
141
|
+
export async function readRepoReleases(member, ref, workspaceRoot, opts = {}) {
|
|
142
|
+
const { fetchRepoAt, fetchRepoLifecycle, redactUrl } = await import("./repo-ref.js");
|
|
143
|
+
const url = redactUrl(ref.url);
|
|
144
|
+
const base = { member, releases: [], repo: url };
|
|
145
|
+
const fetched = fetchRepoAt(ref, workspaceRoot, opts.env);
|
|
146
|
+
if (!fetched.ok)
|
|
147
|
+
return { ...base, problem: fetched.message };
|
|
148
|
+
const lifecycle = fetchRepoLifecycle(ref, workspaceRoot, opts.env);
|
|
149
|
+
if (!lifecycle.ok)
|
|
150
|
+
return { ...base, problem: lifecycle.message };
|
|
151
|
+
const { resolveToolchain } = await import("./member-commands.js");
|
|
152
|
+
const command = opts.command ?? resolveToolchain(fetched.dir, fetched.worktree).command;
|
|
153
|
+
const r = await spawnChant(command, ["release", "list", "--json"], fetched.dir);
|
|
154
|
+
let doc;
|
|
155
|
+
try {
|
|
156
|
+
doc = JSON.parse(r.stdout);
|
|
157
|
+
}
|
|
158
|
+
catch {
|
|
159
|
+
doc = null;
|
|
160
|
+
}
|
|
161
|
+
const { RELEASES_SCHEMA_ID } = await import("./releases.js");
|
|
162
|
+
if (!doc || doc.$schema !== RELEASES_SCHEMA_ID) {
|
|
163
|
+
const tail = r.stderr.trim().split("\n").slice(-3).join("; ");
|
|
164
|
+
return { ...base, problem: `chant release list in ${url} at ${ref.rev.slice(0, 12)} exited ${r.exitCode} and printed no releases document${tail ? `: ${tail}` : ""}` };
|
|
165
|
+
}
|
|
166
|
+
if (doc.error)
|
|
167
|
+
return { ...base, problem: `chant release list in ${url} at ${ref.rev.slice(0, 12)}: ${String(doc.error.code)}: ${String(doc.error.message)}` };
|
|
168
|
+
const entries = Array.isArray(doc.releases) ? doc.releases : [];
|
|
169
|
+
const releases = [];
|
|
170
|
+
// The document lists the newest cut first; a release no cut names comes last and is not one a train takes.
|
|
171
|
+
for (const e of entries) {
|
|
172
|
+
if (typeof e.releaseDigest !== "string" || typeof e.commit !== "string" || !Array.isArray(e.cuts) || e.cuts.length === 0)
|
|
173
|
+
continue;
|
|
174
|
+
releases.push({ member, releaseDigest: e.releaseDigest, commit: e.commit, label: typeof e.label === "string" ? e.label : null, repo: { url, rev: ref.rev } });
|
|
175
|
+
}
|
|
176
|
+
return { ...base, releases };
|
|
177
|
+
}
|
|
65
178
|
function isTrain(v) {
|
|
66
179
|
const t = v;
|
|
67
180
|
return typeof t === "object" && t !== null && t.version === 1 && typeof t.id === "string" && typeof t.env === "string" && Array.isArray(t.members);
|
|
68
181
|
}
|
|
69
182
|
export async function readReleaseTrains(cwd, env) {
|
|
70
|
-
|
|
183
|
+
const { records, malformed } = await readWorkspaceLines(cwd, env, TRAINS_FILE, isTrain);
|
|
184
|
+
return { records: records.map((t) => ({ ...t, trainDigest: t.trainDigest ?? trainDigest(t.members) })), malformed };
|
|
185
|
+
}
|
|
186
|
+
/** The train `ref` names, by id or digest, else the newest. Null when there is none. */
|
|
187
|
+
export function findTrain(trains, ref) {
|
|
188
|
+
if (ref === undefined)
|
|
189
|
+
return trains.at(-1) ?? null;
|
|
190
|
+
return trains.filter((t) => t.id === ref || t.trainDigest === ref).at(-1) ?? null;
|
|
71
191
|
}
|
|
72
192
|
export async function appendReleaseTrain(cwd, record) {
|
|
73
193
|
return appendWorkspaceLine(cwd, record.env, TRAINS_FILE, record, `Release train: ${record.env} ${record.id}`);
|
|
74
194
|
}
|
|
75
|
-
|
|
195
|
+
/** The first chant that writes {@link ReleaseTrainRecord.trainDigest} and has `chant workspace train promote` (#4037). */
|
|
196
|
+
export const TRAIN_PROMOTE_FLOOR = NEXT_RELEASE;
|
|
197
|
+
// ── Promote ──────────────────────────────────────────────────────────────────
|
|
198
|
+
/** What a step of a train's promote runs in each member: `chant components promote`. */
|
|
199
|
+
export const TRAIN_STEP_OP = "components promote";
|
|
200
|
+
function isMemberReleasePlan(v) {
|
|
201
|
+
const p = v;
|
|
202
|
+
return typeof p === "object" && p !== null && typeof p.releaseDigest === "string" && typeof p.op === "string" && Array.isArray(p.gates) && (p.changeSet === null || typeof p.changeSet === "string");
|
|
203
|
+
}
|
|
204
|
+
/**
|
|
205
|
+
* The covers a workspace gate needs for one member's release (#4037): one
|
|
206
|
+
* per release gate, bound to the member's change set, the environment and
|
|
207
|
+
* the release. None for an empty change set, which passes without an
|
|
208
|
+
* approval, nor for a promote that declares no gate.
|
|
209
|
+
*/
|
|
210
|
+
export function releaseCovers(member, env, plan) {
|
|
211
|
+
if (plan.changeSet === null || plan.empty === true)
|
|
212
|
+
return [];
|
|
213
|
+
return plan.gates.map((gate) => ({ member, op: plan.op, gate, planDigest: plan.changeSet, environment: env, releaseDigest: plan.releaseDigest }));
|
|
214
|
+
}
|
|
215
|
+
const promoteArgv = (env, m, extra = []) => ["components", "promote", "--to", env, "--release", m.releaseDigest, ...extra, "--json"];
|
|
216
|
+
/** The JSON a member's promote printed, or null. */
|
|
217
|
+
function parseJson(stdout) {
|
|
218
|
+
const at = stdout.indexOf("{");
|
|
219
|
+
if (at < 0)
|
|
220
|
+
return null;
|
|
221
|
+
try {
|
|
222
|
+
return JSON.parse(stdout.slice(at));
|
|
223
|
+
}
|
|
224
|
+
catch {
|
|
225
|
+
return null;
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
/** The member run and the gate a member's `promote --json` output names. */
|
|
229
|
+
function promoteOutcome(stdout) {
|
|
230
|
+
const doc = parseJson(stdout);
|
|
231
|
+
const runId = doc?.recorded?.find((r) => typeof r.runId === "string")?.runId;
|
|
232
|
+
const g = doc?.run?.gate;
|
|
233
|
+
return {
|
|
234
|
+
run: typeof runId === "string" ? runId : null,
|
|
235
|
+
...(g && typeof g.gate === "string"
|
|
236
|
+
? { gate: { op: typeof g.op === "string" ? g.op : TRAIN_STEP_OP, name: g.gate, planDigest: typeof g.planDigest === "string" ? g.planDigest : null, environment: typeof g.environment === "string" ? g.environment : null } }
|
|
237
|
+
: {}),
|
|
238
|
+
};
|
|
239
|
+
}
|
|
240
|
+
/**
|
|
241
|
+
* Promote a release train (#4037). Each member's release is promoted with
|
|
242
|
+
* `chant components promote --to <env> --release <digest>` under its own
|
|
243
|
+
* chant, producers first, stopping at the first member that does not pass.
|
|
244
|
+
*
|
|
245
|
+
* With a workspace gate, each member plans first and deploys nothing; the
|
|
246
|
+
* covers of every member's release gates are recorded as one pending fact
|
|
247
|
+
* naming the train, and the run ends gated. Once an approval of exactly
|
|
248
|
+
* those covers stands, the same call promotes every member under the gate,
|
|
249
|
+
* so each release gate takes the approval in place of its own where the
|
|
250
|
+
* member opts in at base. A member whose plan moved since then plans a
|
|
251
|
+
* change set the approval does not cover, and stops at its own gate.
|
|
252
|
+
*/
|
|
253
|
+
export async function promoteTrain(query) {
|
|
254
|
+
const now = query.now ?? (() => new Date().toISOString());
|
|
255
|
+
const { records } = await readReleaseTrains(query.cwd, query.env);
|
|
256
|
+
const train = findTrain(records, query.train);
|
|
257
|
+
if (!train) {
|
|
258
|
+
return {
|
|
259
|
+
kind: "refused",
|
|
260
|
+
message: query.train === undefined ? `no release train is recorded for ${query.env}; record one with chant workspace train ${query.env}` : `no release train ${query.train} is recorded for ${query.env}`,
|
|
261
|
+
};
|
|
262
|
+
}
|
|
263
|
+
if (train.members.length === 0)
|
|
264
|
+
return { kind: "refused", message: `release train ${train.id} pins no member, so there is nothing to promote` };
|
|
265
|
+
const across = train.members.filter((m) => m.repo !== undefined);
|
|
266
|
+
if (across.length > 0) {
|
|
267
|
+
if (across.length < train.members.length) {
|
|
268
|
+
return { kind: "refused", message: `release train ${train.id} pins repo members (${across.map((m) => m.member).join(", ")}) and chant members (${train.members.filter((m) => !m.repo).map((m) => m.member).join(", ")}); a promote runs chant members here and dispatches repo members, so record a train of one kind` };
|
|
269
|
+
}
|
|
270
|
+
return promoteAcrossRepos(query, train, now);
|
|
271
|
+
}
|
|
272
|
+
if (query.continue)
|
|
273
|
+
return { kind: "refused", message: "--continue advances a train of repo members, and this train pins chant members" };
|
|
274
|
+
const { defaultReadGraph, defaultRunMember, orderTargets } = await import("./workspace-run.js");
|
|
275
|
+
const read = await (query.readGraph ?? defaultReadGraph)(query.cwd);
|
|
276
|
+
if ("error" in read)
|
|
277
|
+
return { kind: "refused", message: `the workspace graph could not be read: ${read.error}` };
|
|
278
|
+
const { graph } = read;
|
|
279
|
+
const missing = train.members.filter((m) => !graph.members.some((g) => g.name === m.member && g.status === "composed"));
|
|
280
|
+
if (missing.length > 0)
|
|
281
|
+
return { kind: "refused", message: `release train ${train.id} pins ${missing.map((m) => m.member).join(", ")}, which the workspace graph does not compose` };
|
|
282
|
+
const order = orderTargets(train.members.map((m) => ({ member: m.member, op: TRAIN_STEP_OP })), graph.links).map((t) => train.members.find((m) => m.member === t.member));
|
|
283
|
+
if (query.dryRun)
|
|
284
|
+
return { kind: "planned", train, order: order.map((m) => m.member) };
|
|
285
|
+
const id = `ws-${randomUUID()}`;
|
|
286
|
+
const started = now();
|
|
287
|
+
const citation = { id: train.id, digest: train.trainDigest };
|
|
288
|
+
const steps = order.map((m) => ({ target: `${m.member}/${TRAIN_STEP_OP}`, member: m.member, op: TRAIN_STEP_OP, status: "not-run", exitCode: null, memberRun: null }));
|
|
289
|
+
const runMember = query.runMember ?? ((m, argv, e) => defaultRunMember(query.cwd, m, argv, e));
|
|
290
|
+
const dirOf = (member) => graph.members.find((g) => g.name === member).dir;
|
|
291
|
+
const finish = async (status, pending, approved, gatherCovers) => {
|
|
292
|
+
const record = { version: 1, id, started, ended: now(), status, env: query.env, gate: query.gate ?? null, dependentsOf: null, steps, train: citation };
|
|
293
|
+
let written = pending;
|
|
294
|
+
let ledgerError = null;
|
|
295
|
+
try {
|
|
296
|
+
if (gatherCovers && query.gate && !written)
|
|
297
|
+
written = await appendWorkspaceGatePending(query.cwd, { gate: query.gate, run: id, timestamp: record.ended, covers: gatherCovers, train: citation });
|
|
298
|
+
await appendWorkspaceRun(query.cwd, record);
|
|
299
|
+
}
|
|
300
|
+
catch (err) {
|
|
301
|
+
ledgerError = err instanceof Error ? err.message : String(err);
|
|
302
|
+
}
|
|
303
|
+
return { kind: "ran", train, record, pending: written, approved, ledgerError };
|
|
304
|
+
};
|
|
305
|
+
// With a workspace gate: every member plans before any deploys.
|
|
306
|
+
let approved = null;
|
|
307
|
+
if (query.gate) {
|
|
308
|
+
const covers = [];
|
|
309
|
+
for (let i = 0; i < order.length; i++) {
|
|
310
|
+
const m = order[i];
|
|
311
|
+
const step = steps[i];
|
|
312
|
+
const result = await runMember({ name: m.member, dir: dirOf(m.member) }, promoteArgv(query.env, m, ["--plan-only"]), { [WORKSPACE_RUN_ENV]: id });
|
|
313
|
+
query.onOutput?.(`${step.target} --plan-only`, result);
|
|
314
|
+
const plan = parseJson(result.stdout);
|
|
315
|
+
if (result.exitCode !== 0 || !isMemberReleasePlan(plan) || plan.releaseDigest !== m.releaseDigest) {
|
|
316
|
+
step.status = "fail";
|
|
317
|
+
step.exitCode = result.exitCode;
|
|
318
|
+
return finish("fail", null, null);
|
|
319
|
+
}
|
|
320
|
+
covers.push(...releaseCovers(m.member, query.env, plan));
|
|
321
|
+
}
|
|
322
|
+
if (covers.length > 0) {
|
|
323
|
+
const digest = workspaceGateDigest(covers);
|
|
324
|
+
const { pending, approvals } = await readWorkspaceGate(query.cwd, query.gate);
|
|
325
|
+
if (approvals.some((a) => a.digest === digest && workspaceGateDigest(a.covers) === digest)) {
|
|
326
|
+
approved = digest;
|
|
327
|
+
}
|
|
328
|
+
else {
|
|
329
|
+
// Nothing deployed; each member with a cover waits on the workspace gate.
|
|
330
|
+
for (const step of steps) {
|
|
331
|
+
const c = covers.find((x) => x.member === step.member);
|
|
332
|
+
if (c)
|
|
333
|
+
step.gate = { op: c.op, name: c.gate, planDigest: c.planDigest, environment: c.environment ?? null };
|
|
334
|
+
step.status = c ? "gated" : "not-run";
|
|
335
|
+
}
|
|
336
|
+
const standing = pending.filter((p) => p.digest === digest).at(-1) ?? null;
|
|
337
|
+
return finish("gated", standing, null, covers);
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
}
|
|
341
|
+
const env = { [WORKSPACE_RUN_ENV]: id, ...(query.gate ? { [WORKSPACE_GATE_ENV]: query.gate } : {}) };
|
|
342
|
+
let status = "ok";
|
|
343
|
+
for (let i = 0; i < order.length; i++) {
|
|
344
|
+
const m = order[i];
|
|
345
|
+
const step = steps[i];
|
|
346
|
+
const result = await runMember({ name: m.member, dir: dirOf(m.member) }, promoteArgv(query.env, m), env);
|
|
347
|
+
query.onOutput?.(step.target, result);
|
|
348
|
+
step.exitCode = result.exitCode;
|
|
349
|
+
step.status = result.exitCode === 0 ? "ok" : result.exitCode === CHANT_EXIT.waiting ? "gated" : "fail";
|
|
350
|
+
const found = promoteOutcome(result.stdout);
|
|
351
|
+
step.memberRun = found.run;
|
|
352
|
+
if (found.gate)
|
|
353
|
+
step.gate = found.gate;
|
|
354
|
+
if (step.status !== "ok") {
|
|
355
|
+
status = step.status;
|
|
356
|
+
break;
|
|
357
|
+
}
|
|
358
|
+
}
|
|
359
|
+
return finish(status, null, approved);
|
|
360
|
+
}
|
|
361
|
+
// ── Across repositories (#5119) ──────────────────────────────────────────────
|
|
362
|
+
/** What a step of a train's promote across repositories runs in the member repository: its train job's `chant run --release`. */
|
|
363
|
+
export const TRAIN_REPO_STEP_OP = "run --release";
|
|
364
|
+
/** The answers after which the next member is dispatched. */
|
|
365
|
+
const TRAIN_PASSES = ["applied", "unchanged"];
|
|
366
|
+
/** The member links in the declaration: producer to consumer, which a promote across repositories orders by. */
|
|
367
|
+
async function declarationLinks(cwd) {
|
|
368
|
+
const declaration = readDeclaration(locateWorkspace(cwd).tree, "", { rootChant: true });
|
|
369
|
+
return declaration.members.flatMap((m) => m.links.map((l) => ({ consumer: m.name, producer: l.member, status: "declared" })));
|
|
370
|
+
}
|
|
371
|
+
/** Dispatches with the forge's API and the member's token from the environment ({@link trainTokenEnv}). */
|
|
372
|
+
export const defaultTrainDispatcher = async (member, d) => {
|
|
373
|
+
const { dispatchTrainMember, trainMemberTarget, trainProductOf } = await import("../control/train.js");
|
|
374
|
+
await dispatchTrainMember(trainMemberTarget(member.repo), d, { words: trainProductOf() });
|
|
375
|
+
};
|
|
376
|
+
async function defaultReadAnswers(cwd) {
|
|
377
|
+
const { gitControlAppliedLedger, parseControlApplied } = await import("../control/applied.js");
|
|
378
|
+
return parseControlApplied(await gitControlAppliedLedger({ cwd }).read()).records;
|
|
379
|
+
}
|
|
380
|
+
/** Each run's newest line: a promote across repositories appends its run again as each member answers. */
|
|
381
|
+
export function latestRuns(runs) {
|
|
382
|
+
const at = new Map();
|
|
383
|
+
runs.forEach((r, i) => at.set(r.id, i));
|
|
384
|
+
return runs.filter((r, i) => at.get(r.id) === i);
|
|
385
|
+
}
|
|
386
|
+
/**
|
|
387
|
+
* Promote a train of `repo` members (#5119) from the control repo, one
|
|
388
|
+
* member repository at a time, producers first. Each call does one step and
|
|
389
|
+
* returns:
|
|
390
|
+
*
|
|
391
|
+
* - With no promote of the train in flight, it starts one: a workspace run
|
|
392
|
+
* record citing the train, and a dispatch into the first member
|
|
393
|
+
* repository, whose step is `dispatched`. `--continue` starts nothing.
|
|
394
|
+
* - With one in flight, `--continue` reads the control repo's apply records
|
|
395
|
+
* for the member it waits on. `applied` or `unchanged` passes the step
|
|
396
|
+
* and dispatches the next member, or ends the run `ok`. `waiting` ends it
|
|
397
|
+
* `gated` at the member's own gate, and `failed` or `partial` ends it
|
|
398
|
+
* `fail`, the step saying why. An answer for another release fails the
|
|
399
|
+
* step. With no answer yet nothing is written. Without `--continue` it
|
|
400
|
+
* refuses, naming the member it waits on.
|
|
401
|
+
*
|
|
402
|
+
* Each member keeps its own gate: no workspace gate covers members in other
|
|
403
|
+
* repositories, so `--gate` is refused.
|
|
404
|
+
*/
|
|
405
|
+
async function promoteAcrossRepos(query, train, now) {
|
|
406
|
+
if (query.gate)
|
|
407
|
+
return { kind: "refused", message: `release train ${train.id} pins repo members, and each keeps its own gate: a workspace gate covers members of this repository only, so drop --gate` };
|
|
408
|
+
const { orderTargets } = await import("./workspace-run.js");
|
|
409
|
+
const links = await (query.readLinks ?? declarationLinks)(query.cwd);
|
|
410
|
+
const order = orderTargets(train.members.map((m) => ({ member: m.member, op: TRAIN_REPO_STEP_OP })), links).map((t) => train.members.find((m) => m.member === t.member));
|
|
411
|
+
if (query.dryRun)
|
|
412
|
+
return { kind: "planned", train, order: order.map((m) => m.member) };
|
|
413
|
+
const runs = latestRuns((await readWorkspaceRuns(query.cwd, query.env)).records).filter((r) => r.train?.id === train.id);
|
|
414
|
+
const inFlight = runs.filter((r) => r.status === "dispatched").at(-1) ?? null;
|
|
415
|
+
if (!inFlight && query.continue)
|
|
416
|
+
return { kind: "idle", train, message: `no promote of release train ${train.id} to ${query.env} is in flight, so there is nothing to continue` };
|
|
417
|
+
if (inFlight && !query.continue) {
|
|
418
|
+
const waiting = inFlight.steps.find((s) => s.status === "dispatched")?.member ?? "a member";
|
|
419
|
+
return { kind: "refused", message: `promote ${inFlight.id} of release train ${train.id} is in flight and waits on ${waiting}; it continues when that member answers (chant workspace train promote ${query.env} ${train.id} --continue)` };
|
|
420
|
+
}
|
|
421
|
+
const dispatch = query.dispatch ?? defaultTrainDispatcher;
|
|
422
|
+
const record = inFlight
|
|
423
|
+
? { ...inFlight, steps: inFlight.steps.map((s) => ({ ...s })) }
|
|
424
|
+
: {
|
|
425
|
+
version: 1,
|
|
426
|
+
id: `ws-${randomUUID()}`,
|
|
427
|
+
started: now(),
|
|
428
|
+
ended: now(),
|
|
429
|
+
status: "dispatched",
|
|
430
|
+
env: query.env,
|
|
431
|
+
gate: null,
|
|
432
|
+
dependentsOf: null,
|
|
433
|
+
steps: order.map((m) => ({ target: `${m.member}/${TRAIN_REPO_STEP_OP}`, member: m.member, op: TRAIN_REPO_STEP_OP, status: "not-run", exitCode: null, memberRun: null, repo: m.repo.url })),
|
|
434
|
+
train: { id: train.id, digest: train.trainDigest },
|
|
435
|
+
};
|
|
436
|
+
const memberOf = (name) => train.members.find((m) => m.member === name);
|
|
437
|
+
/** Dispatch the first step not run yet, or end the run ok when none is left. */
|
|
438
|
+
const next = async () => {
|
|
439
|
+
const step = record.steps.find((s) => s.status === "not-run");
|
|
440
|
+
if (!step) {
|
|
441
|
+
record.status = "ok";
|
|
442
|
+
return;
|
|
443
|
+
}
|
|
444
|
+
const m = memberOf(step.member);
|
|
445
|
+
try {
|
|
446
|
+
await dispatch({ name: m.member, repo: m.repo.url }, { member: m.member, env: query.env, train: train.id, run: record.id, releaseDigest: m.releaseDigest, commit: m.commit });
|
|
447
|
+
step.status = "dispatched";
|
|
448
|
+
record.status = "dispatched";
|
|
449
|
+
}
|
|
450
|
+
catch (err) {
|
|
451
|
+
step.status = "fail";
|
|
452
|
+
step.reason = `the dispatch into ${m.repo.url} was not taken: ${err instanceof Error ? err.message : String(err)}`;
|
|
453
|
+
record.status = "fail";
|
|
454
|
+
}
|
|
455
|
+
};
|
|
456
|
+
if (!inFlight)
|
|
457
|
+
await next();
|
|
458
|
+
else {
|
|
459
|
+
const step = record.steps.find((s) => s.status === "dispatched");
|
|
460
|
+
if (!step)
|
|
461
|
+
return { kind: "idle", train, message: `promote ${record.id} of release train ${train.id} waits on no member` };
|
|
462
|
+
const answers = (await (query.readAnswers ?? defaultReadAnswers)(query.cwd)).filter((a) => a.member === step.member && a.train?.train === train.id && a.train.run === record.id);
|
|
463
|
+
const answer = answers.sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).at(-1);
|
|
464
|
+
if (!answer)
|
|
465
|
+
return { kind: "waiting", train, record: inFlight, member: step.member };
|
|
466
|
+
const m = memberOf(step.member);
|
|
467
|
+
step.outcome = answer.outcome;
|
|
468
|
+
if (answer.train.releaseDigest !== m.releaseDigest || answer.train.env !== query.env) {
|
|
469
|
+
step.status = "fail";
|
|
470
|
+
step.reason = `${step.member} answered for release ${answer.train.releaseDigest} in ${answer.train.env}, and the train pins ${m.releaseDigest} in ${query.env}`;
|
|
471
|
+
record.status = "fail";
|
|
472
|
+
}
|
|
473
|
+
else if (TRAIN_PASSES.includes(answer.outcome)) {
|
|
474
|
+
step.status = "ok";
|
|
475
|
+
await next();
|
|
476
|
+
}
|
|
477
|
+
else {
|
|
478
|
+
step.status = answer.outcome === "waiting" ? "gated" : "fail";
|
|
479
|
+
step.reason = answer.outcome === "waiting" ? `${step.member}'s run waits at its own gate; approve it there, then promote the train again` : `${step.member}'s run ended ${answer.outcome} at ${answer.sha.slice(0, 12)}`;
|
|
480
|
+
record.status = answer.outcome === "waiting" ? "gated" : "fail";
|
|
481
|
+
}
|
|
482
|
+
}
|
|
483
|
+
record.ended = now();
|
|
484
|
+
let ledgerError = null;
|
|
485
|
+
try {
|
|
486
|
+
await appendWorkspaceRun(query.cwd, record);
|
|
487
|
+
}
|
|
488
|
+
catch (err) {
|
|
489
|
+
ledgerError = err instanceof Error ? err.message : String(err);
|
|
490
|
+
}
|
|
491
|
+
return { kind: "ran", train, record, pending: null, approved: null, ledgerError };
|
|
492
|
+
}
|
|
493
|
+
const USAGE = "chant workspace train <env> [--pin <member>=<label|digest>]... [--dry-run] [--json] | chant workspace train list <env> [--json] | chant workspace train promote <env> [<train id|digest>] [--gate <name>] [--continue] [--dry-run] [--json]";
|
|
494
|
+
/** Each train with the runs that promoted it, oldest first. */
|
|
495
|
+
export function trainsWithPromotions(trains, runs) {
|
|
496
|
+
const latest = latestRuns(runs);
|
|
497
|
+
return trains.map((t) => ({
|
|
498
|
+
...t,
|
|
499
|
+
promotions: latest
|
|
500
|
+
.filter((r) => r.train?.id === t.id)
|
|
501
|
+
.map((r) => ({
|
|
502
|
+
run: r.id,
|
|
503
|
+
started: r.started,
|
|
504
|
+
ended: r.ended,
|
|
505
|
+
status: r.status,
|
|
506
|
+
gate: r.gate,
|
|
507
|
+
members: r.steps.map((s) => ({ member: s.member, status: s.status, memberRun: s.memberRun, ...(s.repo !== undefined ? { repo: s.repo } : {}), ...(s.outcome !== undefined ? { outcome: s.outcome } : {}), ...(s.reason !== undefined ? { reason: s.reason } : {}) })),
|
|
508
|
+
})),
|
|
509
|
+
}));
|
|
510
|
+
}
|
|
76
511
|
export async function runWorkspaceTrain(ctx) {
|
|
77
512
|
const words = ctx.args.positionals ?? [];
|
|
78
513
|
const rest = words[0] === "train" ? words.slice(1) : words;
|
|
514
|
+
if (rest[0] === "promote")
|
|
515
|
+
return runTrainPromote(ctx, rest.slice(1));
|
|
79
516
|
const listing = rest[0] === "list";
|
|
80
517
|
const env = listing ? rest[1] : rest[0];
|
|
81
518
|
if (!env) {
|
|
@@ -87,13 +524,17 @@ export async function runWorkspaceTrain(ctx) {
|
|
|
87
524
|
if (listing) {
|
|
88
525
|
const root = locateWorkspace(cwd).rootOnDisk;
|
|
89
526
|
const { records } = await readReleaseTrains(root, env);
|
|
527
|
+
const listed = trainsWithPromotions(records, (await readWorkspaceRuns(root, env)).records);
|
|
90
528
|
if (ctx.args.json)
|
|
91
|
-
console.log(JSON.stringify({ env, trains:
|
|
92
|
-
else if (
|
|
529
|
+
console.log(JSON.stringify({ env, trains: listed }, null, 2));
|
|
530
|
+
else if (listed.length === 0)
|
|
93
531
|
console.log(`No release train recorded for ${env}.`);
|
|
94
|
-
else
|
|
95
|
-
for (const t of
|
|
96
|
-
|
|
532
|
+
else {
|
|
533
|
+
for (const t of listed) {
|
|
534
|
+
const last = t.promotions.at(-1);
|
|
535
|
+
console.log(`${t.timestamp} ${t.id} ${t.trainDigest} ${t.members.map((m) => `${m.member}@${m.label ?? m.releaseDigest.slice(0, 19)}`).join(" ")}${last ? ` promoted: ${last.status}` : ""}`);
|
|
536
|
+
}
|
|
537
|
+
}
|
|
97
538
|
return 0;
|
|
98
539
|
}
|
|
99
540
|
const pins = new Map();
|
|
@@ -108,21 +549,21 @@ export async function runWorkspaceTrain(ctx) {
|
|
|
108
549
|
const root = locateWorkspace(cwd).rootOnDisk;
|
|
109
550
|
const picked = pickTrain(await readMemberReleases(root), pins);
|
|
110
551
|
if ("problems" in picked) {
|
|
111
|
-
console.error(formatError({ message: `no release train for ${env}: every chant member needs a release`, hint: USAGE }));
|
|
552
|
+
console.error(formatError({ message: `no release train for ${env}: every chant and repo member needs a release`, hint: USAGE }));
|
|
112
553
|
for (const p of picked.problems)
|
|
113
554
|
console.error(` ${p}`);
|
|
114
555
|
return 1;
|
|
115
556
|
}
|
|
116
557
|
const actor = ctx.args.actor ?? actorFromEnv();
|
|
117
|
-
const record = { version: 1, id: `train-${randomUUID()}`, env, timestamp: new Date().toISOString(), actor, members: picked.members };
|
|
558
|
+
const record = { version: 1, id: `train-${randomUUID()}`, env, timestamp: new Date().toISOString(), actor, members: picked.members, trainDigest: trainDigest(picked.members) };
|
|
118
559
|
if (!ctx.args.dryRun)
|
|
119
560
|
await appendReleaseTrain(root, record);
|
|
120
561
|
if (ctx.args.json)
|
|
121
562
|
console.log(JSON.stringify({ ...record, written: !ctx.args.dryRun }, null, 2));
|
|
122
563
|
else {
|
|
123
|
-
console.log(`${ctx.args.dryRun ? "Would record" : "Recorded"} release train ${record.id} for ${env}:`);
|
|
564
|
+
console.log(`${ctx.args.dryRun ? "Would record" : "Recorded"} release train ${record.id} for ${env}, digest ${record.trainDigest}:`);
|
|
124
565
|
for (const m of record.members)
|
|
125
|
-
console.log(` ${m.member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest} ${m.commit.slice(0, 12)}`);
|
|
566
|
+
console.log(` ${m.member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest} ${m.commit.slice(0, 12)}${m.repo ? ` ${m.repo.url}` : ""}`);
|
|
126
567
|
}
|
|
127
568
|
return 0;
|
|
128
569
|
}
|
|
@@ -133,3 +574,98 @@ export async function runWorkspaceTrain(ctx) {
|
|
|
133
574
|
return 1;
|
|
134
575
|
}
|
|
135
576
|
}
|
|
577
|
+
async function runTrainPromote(ctx, words) {
|
|
578
|
+
const [env, ref] = words;
|
|
579
|
+
if (!env) {
|
|
580
|
+
console.error(formatError({ message: "chant workspace train promote needs an environment", hint: USAGE }));
|
|
581
|
+
return 1;
|
|
582
|
+
}
|
|
583
|
+
const cwd = resolve(".");
|
|
584
|
+
// The root's chant promotes the train (ws-021), as it runs a workspace run.
|
|
585
|
+
const { handToRootChant } = await import("./which-chant.js");
|
|
586
|
+
const handed = await handToRootChant(cwd, undefined);
|
|
587
|
+
if (handed !== undefined)
|
|
588
|
+
return handed;
|
|
589
|
+
const { args } = ctx;
|
|
590
|
+
let outcome;
|
|
591
|
+
try {
|
|
592
|
+
outcome = await promoteTrain({
|
|
593
|
+
cwd: locateWorkspace(cwd).rootOnDisk,
|
|
594
|
+
env,
|
|
595
|
+
...(ref !== undefined ? { train: ref } : {}),
|
|
596
|
+
...(args.gate !== undefined ? { gate: args.gate } : {}),
|
|
597
|
+
...(args.dryRun ? { dryRun: true } : {}),
|
|
598
|
+
...(args.continueTrain ? { continue: true } : {}),
|
|
599
|
+
onOutput: args.json
|
|
600
|
+
? undefined
|
|
601
|
+
: (target, r) => {
|
|
602
|
+
process.stderr.write(`── ${target} (exit ${r.exitCode})\n`);
|
|
603
|
+
if (r.stderr)
|
|
604
|
+
process.stderr.write(r.stderr.endsWith("\n") ? r.stderr : `${r.stderr}\n`);
|
|
605
|
+
},
|
|
606
|
+
});
|
|
607
|
+
}
|
|
608
|
+
catch (err) {
|
|
609
|
+
if (!(err instanceof WorkspaceReadError))
|
|
610
|
+
throw err;
|
|
611
|
+
console.error(formatError({ message: `${err.code}: ${err.describe()}`, hint: USAGE }));
|
|
612
|
+
return 1;
|
|
613
|
+
}
|
|
614
|
+
if (outcome.kind === "refused") {
|
|
615
|
+
if (args.json)
|
|
616
|
+
console.log(JSON.stringify({ status: "refused", message: outcome.message }, null, 2));
|
|
617
|
+
console.error(formatError({ message: outcome.message, hint: USAGE }));
|
|
618
|
+
return 1;
|
|
619
|
+
}
|
|
620
|
+
if (outcome.kind === "idle") {
|
|
621
|
+
if (args.json)
|
|
622
|
+
console.log(JSON.stringify({ status: "idle", train: outcome.train.id, message: outcome.message }, null, 2));
|
|
623
|
+
else
|
|
624
|
+
console.log(outcome.message);
|
|
625
|
+
return 0;
|
|
626
|
+
}
|
|
627
|
+
if (outcome.kind === "waiting") {
|
|
628
|
+
if (args.json)
|
|
629
|
+
console.log(JSON.stringify({ ...outcome.record, waitingOn: outcome.member }, null, 2));
|
|
630
|
+
else
|
|
631
|
+
console.log(`release train ${outcome.train.id} to ${env}: promote ${outcome.record.id} waits on ${outcome.member}, which has not answered yet`);
|
|
632
|
+
return 0;
|
|
633
|
+
}
|
|
634
|
+
if (outcome.kind === "planned") {
|
|
635
|
+
if (args.json)
|
|
636
|
+
console.log(JSON.stringify({ status: "planned", train: outcome.train, order: outcome.order }, null, 2));
|
|
637
|
+
else {
|
|
638
|
+
console.log(`chant workspace train promote would promote ${outcome.train.id} (${outcome.train.trainDigest}) to ${env}, in order:`);
|
|
639
|
+
for (const member of outcome.order) {
|
|
640
|
+
const m = outcome.train.members.find((x) => x.member === member);
|
|
641
|
+
console.log(` ${member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest}`);
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
return 0;
|
|
645
|
+
}
|
|
646
|
+
const { record, pending, approved, ledgerError } = outcome;
|
|
647
|
+
if (args.json)
|
|
648
|
+
console.log(JSON.stringify({ ...record, pending, approved, ledgerError }, null, 2));
|
|
649
|
+
else {
|
|
650
|
+
console.log(`release train ${outcome.train.id} to ${env}: ${record.status}${approved ? ` (workspace gate "${record.gate}" approved ${approved})` : ""}`);
|
|
651
|
+
for (const s of record.steps)
|
|
652
|
+
console.log(` ${s.member.padEnd(24)} ${s.status}${s.memberRun ? ` (run ${s.memberRun})` : ""}${s.gate ? ` gate ${s.gate.name}` : ""}${s.repo ? ` ${s.repo}` : ""}${s.reason ? ` ${s.reason}` : ""}`);
|
|
653
|
+
if (record.status === "dispatched") {
|
|
654
|
+
const at = record.steps.find((s) => s.status === "dispatched");
|
|
655
|
+
if (at)
|
|
656
|
+
console.log(`Dispatched ${at.member}. The control repo continues the train when it answers: chant workspace train promote ${env} ${outcome.train.id} --continue`);
|
|
657
|
+
}
|
|
658
|
+
if (record.status === "gated" && pending) {
|
|
659
|
+
console.log(`Workspace gate "${pending.gate}" is pending over ${pending.covers.length} release gate(s) of ${new Set(pending.covers.map((c) => c.member)).size} member(s), digest ${pending.digest}. Nothing was deployed.`);
|
|
660
|
+
console.log(` Approve: chant workspace run approve ${pending.gate} --plan ${pending.digest}`);
|
|
661
|
+
console.log(` Then run the same chant workspace train promote again. The approval stands in only for members that set acceptWorkspaceGates: true at base.`);
|
|
662
|
+
}
|
|
663
|
+
if (ledgerError)
|
|
664
|
+
console.error(formatError({ message: `the workspace run record was not written: ${ledgerError}` }));
|
|
665
|
+
}
|
|
666
|
+
if (record.status === "fail")
|
|
667
|
+
return 1;
|
|
668
|
+
if (record.status === "gated")
|
|
669
|
+
return CHANT_EXIT.waiting;
|
|
670
|
+
return 0;
|
|
671
|
+
}
|