@intentius/chant-lexicon-terraform 0.124.85 → 0.124.87
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/ci-setup.d.ts +11 -2
- package/dist/ci-setup.d.ts.map +1 -1
- package/dist/ci-setup.js +11 -6
- package/dist/components/capability-plugin.d.ts +12 -0
- package/dist/components/capability-plugin.d.ts.map +1 -1
- package/dist/components/capability-plugin.js +22 -4
- package/dist/compose.d.ts.map +1 -1
- package/dist/compose.js +1 -1
- package/dist/estate-migration.d.ts +101 -0
- package/dist/estate-migration.d.ts.map +1 -0
- package/dist/estate-migration.js +471 -0
- package/dist/integrity.json +2 -2
- package/dist/manifest.json +1 -1
- package/dist/op/activities/terraform.d.ts +65 -0
- package/dist/op/activities/terraform.d.ts.map +1 -1
- package/dist/op/activities/terraform.js +94 -1
- package/dist/state/backend.d.ts +46 -9
- package/dist/state/backend.d.ts.map +1 -1
- package/dist/state/backend.js +84 -31
- package/dist/state/gitlab.d.ts +1 -1
- package/dist/state/gitlab.d.ts.map +1 -1
- package/dist/state/gitlab.js +27 -14
- package/dist/state/index.d.ts +1 -0
- package/dist/state/index.d.ts.map +1 -1
- package/dist/state/index.js +1 -0
- package/dist/state/s3.d.ts +9 -3
- package/dist/state/s3.d.ts.map +1 -1
- package/dist/state/s3.js +4 -3
- package/dist/state/source.d.ts +92 -0
- package/dist/state/source.d.ts.map +1 -0
- package/dist/state/source.js +254 -0
- package/dist/state/store.d.ts +41 -4
- package/dist/state/store.d.ts.map +1 -1
- package/dist/state/store.js +125 -10
- package/dist/state/versions.d.ts +77 -10
- package/dist/state/versions.d.ts.map +1 -1
- package/dist/state/versions.js +118 -64
- package/dist/state-migration.d.ts +43 -1
- package/dist/state-migration.d.ts.map +1 -1
- package/dist/state-migration.js +251 -20
- package/dist/state-ops.d.ts +2 -3
- package/dist/state-ops.d.ts.map +1 -1
- package/dist/state-ops.js +4 -7
- package/package.json +2 -2
- package/src/ci-setup.test.ts +20 -0
- package/src/ci-setup.ts +11 -6
- package/src/components/capability-plugin.ts +36 -3
- package/src/components/terraform-apply-command-hook.test.ts +157 -0
- package/src/compose.ts +1 -0
- package/src/estate-migration.test.ts +186 -0
- package/src/estate-migration.ts +563 -0
- package/src/op/activities/terraform.ts +153 -3
- package/src/state/backend-verdict.test.ts +4 -3
- package/src/state/backend.test.ts +3 -1
- package/src/state/backend.ts +108 -33
- package/src/state/gitlab.ts +25 -12
- package/src/state/index.ts +1 -0
- package/src/state/s3.ts +5 -4
- package/src/state/source.ts +289 -0
- package/src/state/store.ts +145 -11
- package/src/state/versions.test.ts +365 -0
- package/src/state/versions.ts +148 -68
- package/src/state-migration-backends.test.ts +277 -0
- package/src/state-migration.ts +265 -23
- package/src/state-ops.ts +6 -8
|
@@ -0,0 +1,365 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* #4793: a state store's version reads on each backend chant reads (s3, gcs,
|
|
3
|
+
* azurerm, a GitLab-managed http backend and local), the version an apply
|
|
4
|
+
* leaves (`readStateVersion`), and every version a store keeps
|
|
5
|
+
* (`listStateVersions`). Each store is in memory behind the fetch the store
|
|
6
|
+
* calls; no bucket, container or GitLab is reached.
|
|
7
|
+
*/
|
|
8
|
+
import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
|
|
9
|
+
import { tmpdir } from "node:os";
|
|
10
|
+
import { join } from "node:path";
|
|
11
|
+
import { describe, expect, test } from "vitest";
|
|
12
|
+
import { LOCKABLE_BACKENDS, LOCKS, isRefused, lockRefusal, readableStateObject, stateObject, type LockableState } from "./backend";
|
|
13
|
+
import type { StoreFetch } from "./object-store";
|
|
14
|
+
import { stateStore } from "./store";
|
|
15
|
+
import { keepsHistory, listStateVersions, readStateVersion, stateVersionSource } from "./versions";
|
|
16
|
+
|
|
17
|
+
type Answer = Awaited<ReturnType<StoreFetch>>;
|
|
18
|
+
const answer = (status = 200, body = "", headers: Record<string, string> = {}): Answer => {
|
|
19
|
+
const h = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
|
|
20
|
+
return { ok: status < 300, status, text: async () => body, headers: { get: (n: string) => h[n.toLowerCase()] ?? null, forEach: (fn: (v: string, k: string) => void) => Object.entries(h).forEach(([k, v]) => fn(v, k)) } as Answer["headers"] };
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
const at = (m: number): string => `2026-11-09T12:${String(m).padStart(2, "0")}:00.000Z`;
|
|
24
|
+
|
|
25
|
+
/** A root whose data dir records `type` and `config`, as init leaves it. */
|
|
26
|
+
function initialised(type: string, config: Record<string, unknown>): string {
|
|
27
|
+
const dir = mkdtempSync(join(tmpdir(), "chant-versions-"));
|
|
28
|
+
mkdirSync(join(dir, ".terraform"));
|
|
29
|
+
writeFileSync(join(dir, ".terraform", "terraform.tfstate"), JSON.stringify({ version: 3, backend: { type, config } }));
|
|
30
|
+
return dir;
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
/** A versioned S3 bucket in memory, path-style at http://s3.test/<bucket>/<key>, with ListObjectVersions; unversioned when `versioning` is false. */
|
|
34
|
+
function fakeS3(versioning = true) {
|
|
35
|
+
const objects = new Map<string, Array<{ id: string; body: string; when: string }>>();
|
|
36
|
+
const seen: string[] = [];
|
|
37
|
+
let n = 0;
|
|
38
|
+
const put = (key: string, body: string): string => {
|
|
39
|
+
const id = versioning ? `v${++n}` : "";
|
|
40
|
+
objects.set(key, [...(versioning ? (objects.get(key) ?? []) : []), { id, body, when: at(++n) }]);
|
|
41
|
+
return id;
|
|
42
|
+
};
|
|
43
|
+
const fetch: StoreFetch = async (url, init) => {
|
|
44
|
+
const u = new URL(url);
|
|
45
|
+
const path = decodeURIComponent(u.pathname.slice(1));
|
|
46
|
+
const vid = u.searchParams.get("versionId");
|
|
47
|
+
seen.push(`${init.method} ${path}${vid ? `?${vid}` : ""}`);
|
|
48
|
+
if (u.searchParams.has("versions")) {
|
|
49
|
+
const prefix = `${path}${u.searchParams.get("prefix")}`;
|
|
50
|
+
const blocks = [...objects].filter(([k]) => k.startsWith(prefix)).flatMap(([k, vs]) => vs.map((v, i) => `<Version><Key>${k.slice(path.length)}</Key><VersionId>${v.id || "null"}</VersionId><IsLatest>${i === vs.length - 1}</IsLatest><LastModified>${v.when}</LastModified></Version>`));
|
|
51
|
+
return answer(200, `<ListVersionsResult>${blocks.join("")}<IsTruncated>false</IsTruncated></ListVersionsResult>`);
|
|
52
|
+
}
|
|
53
|
+
const all = objects.get(path) ?? [];
|
|
54
|
+
const v = vid ? all.find((x) => x.id === vid) : all.at(-1);
|
|
55
|
+
if (!v) return answer(404);
|
|
56
|
+
return answer(200, init.method === "HEAD" ? "" : v.body, v.id ? { "x-amz-version-id": v.id } : {});
|
|
57
|
+
};
|
|
58
|
+
return { put, fetch, seen };
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
/** GCS's JSON API in memory, at http://gcs.test: objects by generation, object versioning on unless `versioning` is false, and the object listing. */
|
|
62
|
+
function fakeGcs(versioning = true) {
|
|
63
|
+
const objects = new Map<string, { generation: string; body: string; when: string }[]>();
|
|
64
|
+
let n = 1000;
|
|
65
|
+
const put = (key: string, body: string): string => {
|
|
66
|
+
const generation = String(++n);
|
|
67
|
+
objects.set(key, [...(versioning ? (objects.get(key) ?? []) : []), { generation, body, when: at(n - 1000) }]);
|
|
68
|
+
return generation;
|
|
69
|
+
};
|
|
70
|
+
const fetch: StoreFetch = async (url, init) => {
|
|
71
|
+
const u = new URL(url);
|
|
72
|
+
const gen = u.searchParams.get("generation");
|
|
73
|
+
let m = /^\/storage\/v1\/b\/([^/]+)$/.exec(u.pathname);
|
|
74
|
+
if (m) return answer(200, JSON.stringify({ versioning: { enabled: versioning } }));
|
|
75
|
+
m = /^\/storage\/v1\/b\/([^/]+)\/o$/.exec(u.pathname);
|
|
76
|
+
if (m && init.method === "GET") {
|
|
77
|
+
const prefix = `${m[1]}/${u.searchParams.get("prefix")}`;
|
|
78
|
+
const items = [...objects].filter(([k]) => k.startsWith(prefix)).flatMap(([k, vs]) => vs.map((v, i) => ({ name: k.slice(m![1]!.length + 1), generation: v.generation, timeCreated: v.when, ...(i < vs.length - 1 ? { timeDeleted: at(59) } : {}) })));
|
|
79
|
+
return answer(200, JSON.stringify({ items }));
|
|
80
|
+
}
|
|
81
|
+
m = /^\/storage\/v1\/b\/([^/]+)\/o\/(.+)$/.exec(u.pathname);
|
|
82
|
+
if (!m) return answer(404);
|
|
83
|
+
const key = `${m[1]}/${decodeURIComponent(m[2]!)}`;
|
|
84
|
+
const found = gen ? objects.get(key)?.find((o) => o.generation === gen) : objects.get(key)?.at(-1);
|
|
85
|
+
if (!found) return answer(404);
|
|
86
|
+
if (u.searchParams.get("alt") === "media") return answer(200, found.body, { "x-goog-generation": found.generation });
|
|
87
|
+
return answer(200, JSON.stringify({ name: m[2], generation: found.generation }));
|
|
88
|
+
};
|
|
89
|
+
return { put, fetch };
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
/**
|
|
93
|
+
* Azure Blob Storage in memory, at `host`: blobs with snapshots (and version
|
|
94
|
+
* ids when `versions`), and List Blobs with include=versions.
|
|
95
|
+
*/
|
|
96
|
+
function fakeAzure(versions = false, host = "acme.blob.core.windows.net") {
|
|
97
|
+
type Blob = { body: string; snapshots: { id: string; body: string }[]; versions: { id: string; body: string; when: string }[] };
|
|
98
|
+
const blobs = new Map<string, Blob>();
|
|
99
|
+
let n = 0;
|
|
100
|
+
const stamp = (): string => `2026-11-09T12:00:${String(++n).padStart(2, "0")}.0000000Z`;
|
|
101
|
+
const write = (key: string, body: string): string => {
|
|
102
|
+
const b = blobs.get(key);
|
|
103
|
+
const id = stamp();
|
|
104
|
+
blobs.set(key, { body, snapshots: b?.snapshots ?? [], versions: [...(b?.versions ?? []), { id, body, when: new Date(Date.UTC(2026, 10, 9, 12, n)).toUTCString() }] });
|
|
105
|
+
return id;
|
|
106
|
+
};
|
|
107
|
+
const fetch: StoreFetch = async (url, init) => {
|
|
108
|
+
const u = new URL(url);
|
|
109
|
+
if (u.host !== host) return answer(404);
|
|
110
|
+
const comp = u.searchParams.get("comp");
|
|
111
|
+
if (comp === "list") {
|
|
112
|
+
const prefix = `${u.pathname.slice(1)}/${u.searchParams.get("prefix")}`;
|
|
113
|
+
const listed = versions ? [...blobs].filter(([k]) => k.startsWith(prefix)).flatMap(([k, b]) => b.versions.map((v, i) => `<Blob><Name>${k.slice(k.indexOf("/") + 1)}</Name><VersionId>${v.id}</VersionId>${i === b.versions.length - 1 ? "<IsCurrentVersion>true</IsCurrentVersion>" : ""}<Properties><Last-Modified>${v.when}</Last-Modified></Properties></Blob>`)) : [];
|
|
114
|
+
return answer(200, `<EnumerationResults><Blobs>${listed.join("")}</Blobs><NextMarker /></EnumerationResults>`);
|
|
115
|
+
}
|
|
116
|
+
const key = decodeURIComponent(u.pathname.slice(1));
|
|
117
|
+
const b = blobs.get(key);
|
|
118
|
+
if (init.method === "PUT" && comp === "snapshot") {
|
|
119
|
+
if (!b) return answer(404);
|
|
120
|
+
const id = stamp();
|
|
121
|
+
b.snapshots.push({ id, body: b.body });
|
|
122
|
+
return answer(201, "", { "x-ms-snapshot": id });
|
|
123
|
+
}
|
|
124
|
+
const snap = u.searchParams.get("snapshot");
|
|
125
|
+
const ver = u.searchParams.get("versionid");
|
|
126
|
+
if (!b) return answer(404);
|
|
127
|
+
const found = snap ? b.snapshots.find((s) => s.id === snap) : ver ? b.versions.find((v) => v.id === ver) : { body: b.body };
|
|
128
|
+
if (!found) return answer(404);
|
|
129
|
+
const headers: Record<string, string> = { etag: `"${b.body.length}"`, "x-ms-lease-state": "available", ...(versions && !snap ? { "x-ms-version-id": ver ?? b.versions.at(-1)!.id } : {}) };
|
|
130
|
+
return answer(200, init.method === "HEAD" ? "" : found.body, headers);
|
|
131
|
+
};
|
|
132
|
+
return { blobs, write, fetch };
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
/** GitLab's Terraform state API in memory, for project 7 at http://gitlab.test: versions by serial. */
|
|
136
|
+
function fakeGitLab() {
|
|
137
|
+
const versions: Array<{ serial: number; body: string }> = [];
|
|
138
|
+
const fetch: StoreFetch = async (url, init) => {
|
|
139
|
+
const m = new URL(url).pathname.match(/^\/api\/v4\/projects\/7\/terraform\/state\/net(\/versions\/(\d+))?$/);
|
|
140
|
+
if (!m) return answer(404);
|
|
141
|
+
const v = m[2] !== undefined ? versions.find((x) => String(x.serial) === m[2]) : versions.at(-1);
|
|
142
|
+
if (!v) return answer(404);
|
|
143
|
+
return answer(200, init.method === "HEAD" ? "" : v.body);
|
|
144
|
+
};
|
|
145
|
+
const put = (serial: number) => versions.push({ serial, body: JSON.stringify({ version: 4, serial, lineage: "l", resources: [] }) });
|
|
146
|
+
return { put, fetch };
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
const AWS = { AWS_ACCESS_KEY_ID: "AK", AWS_SECRET_ACCESS_KEY: "SK", AWS_REGION: "us-east-1" };
|
|
150
|
+
const S3_CONFIG = { bucket: "acme-state", key: "app.tfstate", endpoints: { s3: "http://s3.test" }, use_lockfile: true };
|
|
151
|
+
const GCS_CONFIG = { bucket: "acme-state", prefix: "app", storage_custom_endpoint: "http://gcs.test/storage/v1/", access_token: "tok" };
|
|
152
|
+
const AZ_CONFIG = { storage_account_name: "acme", container_name: "tfstate", key: "app.tfstate", access_key: Buffer.from("key").toString("base64") };
|
|
153
|
+
const GITLAB_ADDRESS = "http://gitlab.test/api/v4/projects/7/terraform/state/net";
|
|
154
|
+
const GITLAB_CONFIG = { address: GITLAB_ADDRESS, lock_address: `${GITLAB_ADDRESS}/lock`, unlock_address: `${GITLAB_ADDRESS}/lock`, username: "gitlab-ci-token", password: "glcbt" };
|
|
155
|
+
|
|
156
|
+
/** The store of the root initialised with `type` and `config`. */
|
|
157
|
+
function storeOf(dir: string, env: NodeJS.ProcessEnv, fetch: StoreFetch) {
|
|
158
|
+
const o = stateObject(dir, env);
|
|
159
|
+
if (isRefused(o)) throw new Error(o.reason);
|
|
160
|
+
return stateStore(o as LockableState, dir, fetch);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
describe("a state store reads the state's versions", () => {
|
|
164
|
+
test("s3: the object's version id, an older one by its id, and the bucket's list of them", async () => {
|
|
165
|
+
const s3 = fakeS3();
|
|
166
|
+
const v1 = s3.put("acme-state/app.tfstate", '{"serial":1}');
|
|
167
|
+
const v2 = s3.put("acme-state/app.tfstate", '{"serial":2}');
|
|
168
|
+
const store = storeOf(initialised("s3", S3_CONFIG), AWS, s3.fetch);
|
|
169
|
+
expect(await store.version()).toEqual({ exists: true, versionId: v2 });
|
|
170
|
+
expect(await store.hasVersion(v1)).toBe(true);
|
|
171
|
+
expect(await store.hasVersion("v9")).toBe(false);
|
|
172
|
+
expect(await store.readVersion(v1)).toBe('{"serial":1}');
|
|
173
|
+
expect(await store.isAt(v2)).toBe(true);
|
|
174
|
+
expect(await store.isAt(v1)).toBe(false);
|
|
175
|
+
expect((await store.listVersions!()).map((v) => [v.version_id, v.latest])).toEqual([[v2, true], [v1, false]]);
|
|
176
|
+
});
|
|
177
|
+
|
|
178
|
+
test("s3: a bucket without versioning keeps only the latest state", async () => {
|
|
179
|
+
const s3 = fakeS3(false);
|
|
180
|
+
s3.put("acme-state/app.tfstate", "{}");
|
|
181
|
+
const store = storeOf(initialised("s3", S3_CONFIG), AWS, s3.fetch);
|
|
182
|
+
expect(await store.version()).toEqual({ exists: true, off: "bucket versioning is off for acme-state, so it keeps only the latest state" });
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
test("gcs: a generation, read by generation, and the listing of each", async () => {
|
|
186
|
+
const g = fakeGcs();
|
|
187
|
+
const g1 = g.put("acme-state/app/default.tfstate", '{"serial":1}');
|
|
188
|
+
const g2 = g.put("acme-state/app/default.tfstate", '{"serial":2}');
|
|
189
|
+
const store = storeOf(initialised("gcs", GCS_CONFIG), {}, g.fetch);
|
|
190
|
+
expect(await store.version()).toEqual({ exists: true, versionId: g2 });
|
|
191
|
+
expect(await store.hasVersion(g1)).toBe(true);
|
|
192
|
+
expect(await store.readVersion(g1)).toBe('{"serial":1}');
|
|
193
|
+
expect(await store.isAt(g2)).toBe(true);
|
|
194
|
+
expect((await store.listVersions!()).map((v) => [v.version_id, v.latest])).toEqual([[g2, true], [g1, false]]);
|
|
195
|
+
const off = fakeGcs(false);
|
|
196
|
+
off.put("acme-state/app/default.tfstate", "{}");
|
|
197
|
+
expect(await storeOf(initialised("gcs", GCS_CONFIG), {}, off.fetch).version()).toMatchObject({ off: "object versioning is off for acme-state, so it keeps only the latest state" });
|
|
198
|
+
});
|
|
199
|
+
|
|
200
|
+
test("azurerm: the blob's version id when the account keeps versions, and the list of them", async () => {
|
|
201
|
+
const a = fakeAzure(true);
|
|
202
|
+
const v1 = a.write("tfstate/app.tfstate", '{"serial":1}');
|
|
203
|
+
const v2 = a.write("tfstate/app.tfstate", '{"serial":2}');
|
|
204
|
+
const store = storeOf(initialised("azurerm", AZ_CONFIG), {}, a.fetch);
|
|
205
|
+
expect(await store.version()).toEqual({ exists: true, versionId: v2 });
|
|
206
|
+
expect(await store.hasVersion(v1)).toBe(true);
|
|
207
|
+
expect(await store.readVersion(v1)).toBe('{"serial":1}');
|
|
208
|
+
expect(await store.isAt(v1)).toBe(false);
|
|
209
|
+
expect((await store.listVersions!()).map((v) => [v.version_id, v.latest])).toEqual([[v2, true], [v1, false]]);
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
test("azurerm: without versions, a snapshot names the state when pinned, and the state is at it while its text is the same", async () => {
|
|
213
|
+
const a = fakeAzure();
|
|
214
|
+
a.write("tfstate/app.tfstate", '{"serial":1}');
|
|
215
|
+
const store = storeOf(initialised("azurerm", { ...AZ_CONFIG, snapshot: true }), {}, a.fetch);
|
|
216
|
+
expect(await store.version()).toEqual({ exists: true, off: "the blob keeps no versions, and only a snapshot would name this one" });
|
|
217
|
+
const pinned = await store.version(true);
|
|
218
|
+
expect(pinned.versionId).toBe(a.blobs.get("tfstate/app.tfstate")!.snapshots[0]!.id);
|
|
219
|
+
expect(await store.hasVersion(pinned.versionId!)).toBe(true);
|
|
220
|
+
expect(await store.readVersion(pinned.versionId!)).toBe('{"serial":1}');
|
|
221
|
+
expect(await store.isAt(pinned.versionId!)).toBe(true);
|
|
222
|
+
a.write("tfstate/app.tfstate", '{"serial":2}');
|
|
223
|
+
expect(await store.isAt(pinned.versionId!)).toBe(false);
|
|
224
|
+
expect(await storeOf(initialised("azurerm", AZ_CONFIG), {}, a.fetch).version()).toMatchObject({ off: expect.stringContaining("takes no snapshots (snapshot = true)") });
|
|
225
|
+
});
|
|
226
|
+
|
|
227
|
+
test("azurerm: a backend that names a metadata_host gets its endpoint from that cloud's metadata", async () => {
|
|
228
|
+
const a = fakeAzure(true, "acme.blob.core.example.test");
|
|
229
|
+
const id = a.write("tfstate/app.tfstate", "{}");
|
|
230
|
+
const fetch: StoreFetch = async (url, init) => (url.startsWith("https://meta.test/metadata/endpoints?") ? answer(200, JSON.stringify({ suffixes: { storage: "core.example.test" } })) : a.fetch(url, init));
|
|
231
|
+
const o = stateObject(initialised("azurerm", { ...AZ_CONFIG, environment: "stack", metadata_host: "meta.test" }), {});
|
|
232
|
+
expect(o).toMatchObject({ backend: "azurerm", metadataHost: "meta.test" });
|
|
233
|
+
expect(await stateStore(o as LockableState, "", fetch).version()).toEqual({ exists: true, versionId: id });
|
|
234
|
+
expect(stateObject(initialised("azurerm", { ...AZ_CONFIG, environment: "stack" }), {})).toMatchObject({ refused: "config", reason: expect.stringContaining("names no metadata_host") });
|
|
235
|
+
});
|
|
236
|
+
|
|
237
|
+
test("http: a GitLab-managed state's version id is its serial", async () => {
|
|
238
|
+
const g = fakeGitLab();
|
|
239
|
+
g.put(3);
|
|
240
|
+
g.put(4);
|
|
241
|
+
const store = storeOf(initialised("http", GITLAB_CONFIG), {}, g.fetch);
|
|
242
|
+
expect(store.backend).toBe("http");
|
|
243
|
+
expect(await store.version()).toEqual({ exists: true, versionId: "4" });
|
|
244
|
+
expect(await store.hasVersion("3")).toBe(true);
|
|
245
|
+
expect(await store.hasVersion("v3")).toBe(false);
|
|
246
|
+
expect(await store.readVersion("3")).toContain('"serial":3');
|
|
247
|
+
expect(await store.isAt("4")).toBe(true);
|
|
248
|
+
expect(await store.isAt("3")).toBe(false);
|
|
249
|
+
expect(store.listVersions).toBeUndefined();
|
|
250
|
+
});
|
|
251
|
+
|
|
252
|
+
test("local: keeps only the latest state, and lists none", async () => {
|
|
253
|
+
const dir = initialised("local", {});
|
|
254
|
+
writeFileSync(join(dir, "terraform.tfstate"), "{}");
|
|
255
|
+
const store = storeOf(dir, {}, fakeS3().fetch);
|
|
256
|
+
expect(await store.version()).toEqual({ exists: true, off: "a local backend keeps only the latest state" });
|
|
257
|
+
expect(await store.hasVersion("1")).toBe(false);
|
|
258
|
+
expect(await store.readVersion("1")).toBeUndefined();
|
|
259
|
+
expect(store.listVersions).toBeUndefined();
|
|
260
|
+
});
|
|
261
|
+
|
|
262
|
+
test("a state export's version source reads a GitLab-managed state like the others", async () => {
|
|
263
|
+
const g = fakeGitLab();
|
|
264
|
+
g.put(5);
|
|
265
|
+
const src = stateVersionSource(stateObject(initialised("http", GITLAB_CONFIG), {}), g.fetch);
|
|
266
|
+
expect("refused" in src).toBe(false);
|
|
267
|
+
if ("refused" in src) return;
|
|
268
|
+
expect(src.location).toBe(GITLAB_ADDRESS);
|
|
269
|
+
expect(await src.current()).toEqual({ exists: true, versionId: "5" });
|
|
270
|
+
});
|
|
271
|
+
});
|
|
272
|
+
|
|
273
|
+
describe("an http backend is locked when it is a GitLab-managed state", () => {
|
|
274
|
+
test("LOCKABLE_BACKENDS takes http, and the verdict refuses an http backend at any other address", () => {
|
|
275
|
+
expect(LOCKABLE_BACKENDS).toContain("http");
|
|
276
|
+
expect(LOCKS).toBe("chant locks and writes s3 (with use_lockfile = true), gcs, azurerm, local and GitLab-managed http states");
|
|
277
|
+
expect(lockRefusal({ backend: { type: "http", config: { address: GITLAB_ADDRESS } } })).toBeUndefined();
|
|
278
|
+
expect(lockRefusal({ backend: { type: "http", config: {} } }, { TF_HTTP_ADDRESS: GITLAB_ADDRESS })).toBeUndefined();
|
|
279
|
+
expect(lockRefusal({ backend: { type: "http", config: { address: "https://state.example.test/net" } } })).toMatchObject({ refused: "backend", reason: expect.stringContaining("is not a GitLab project's state API") });
|
|
280
|
+
expect(stateObject(initialised("http", GITLAB_CONFIG), {})).toMatchObject({ backend: "http", address: GITLAB_ADDRESS, lockAddress: `${GITLAB_ADDRESS}/lock` });
|
|
281
|
+
});
|
|
282
|
+
});
|
|
283
|
+
|
|
284
|
+
describe("the version an apply leaves", () => {
|
|
285
|
+
test("is the store's version id, read from metadata only, on each backend", async () => {
|
|
286
|
+
const s3 = fakeS3();
|
|
287
|
+
const v = s3.put("acme-state/app.tfstate", "{}");
|
|
288
|
+
expect(await readStateVersion(initialised("s3", S3_CONFIG), AWS, { fetch: s3.fetch })).toEqual({ backend: "s3", location: "s3://acme-state/app.tfstate", version_id: v, versioning: "on" });
|
|
289
|
+
expect(s3.seen).toEqual(["HEAD acme-state/app.tfstate"]);
|
|
290
|
+
const g = fakeGcs();
|
|
291
|
+
const gen = g.put("acme-state/app/default.tfstate", "{}");
|
|
292
|
+
expect(await readStateVersion(initialised("gcs", GCS_CONFIG), {}, { fetch: g.fetch })).toEqual({ backend: "gcs", location: "gs://acme-state/app/default.tfstate", version_id: gen, versioning: "on" });
|
|
293
|
+
const gl = fakeGitLab();
|
|
294
|
+
gl.put(9);
|
|
295
|
+
expect(await readStateVersion(initialised("http", GITLAB_CONFIG), {}, { fetch: gl.fetch })).toEqual({ backend: "http", location: GITLAB_ADDRESS, version_id: "9", versioning: "on" });
|
|
296
|
+
});
|
|
297
|
+
|
|
298
|
+
test("an azurerm blob without versions that the backend snapshots is named by a snapshot", async () => {
|
|
299
|
+
const a = fakeAzure();
|
|
300
|
+
a.write("tfstate/app.tfstate", "{}");
|
|
301
|
+
const r = await readStateVersion(initialised("azurerm", { ...AZ_CONFIG, snapshot: true }), {}, { fetch: a.fetch });
|
|
302
|
+
expect(r).toEqual({ backend: "azurerm", location: "az://acme/tfstate/app.tfstate", version_id: a.blobs.get("tfstate/app.tfstate")!.snapshots[0]!.id, versioning: "on" });
|
|
303
|
+
});
|
|
304
|
+
|
|
305
|
+
test("an s3 backend without use_lockfile is read all the same: a read holds no lock", async () => {
|
|
306
|
+
const s3 = fakeS3();
|
|
307
|
+
const v = s3.put("acme-state/app.tfstate", "{}");
|
|
308
|
+
const dir = initialised("s3", { ...S3_CONFIG, use_lockfile: false, dynamodb_table: "locks" });
|
|
309
|
+
expect(stateObject(dir, AWS)).toMatchObject({ refused: "no-lockfile" });
|
|
310
|
+
expect(readableStateObject(dir, AWS)).toMatchObject({ backend: "s3", lockfile: false });
|
|
311
|
+
expect(await readStateVersion(dir, AWS, { fetch: s3.fetch })).toMatchObject({ version_id: v, versioning: "on" });
|
|
312
|
+
});
|
|
313
|
+
|
|
314
|
+
test("off for a bucket without versioning, a local state and a backend that keeps no history; unknown with why otherwise; never throws", async () => {
|
|
315
|
+
const off = fakeS3(false);
|
|
316
|
+
off.put("acme-state/app.tfstate", "{}");
|
|
317
|
+
expect(await readStateVersion(initialised("s3", S3_CONFIG), AWS, { fetch: off.fetch })).toMatchObject({ versioning: "off", note: expect.stringContaining("bucket versioning is off for acme-state") });
|
|
318
|
+
expect(await readStateVersion(initialised("s3", S3_CONFIG), AWS, { fetch: fakeS3().fetch })).toMatchObject({ versioning: "unknown", note: "the state object is not in the bucket" });
|
|
319
|
+
expect(await readStateVersion(initialised("s3", S3_CONFIG), AWS, { fetch: async () => answer(403, "<Error><Code>AccessDenied</Code></Error>") })).toMatchObject({ versioning: "unknown", note: expect.stringContaining("403") });
|
|
320
|
+
expect(await readStateVersion(initialised("s3", S3_CONFIG), {}, { fetch: fakeS3().fetch })).toMatchObject({ versioning: "unknown", note: expect.stringContaining("no credentials") });
|
|
321
|
+
expect(await readStateVersion(initialised("http", GITLAB_CONFIG), {}, { fetch: fakeGitLab().fetch })).toMatchObject({ backend: "http", versioning: "unknown", note: "GitLab holds no state at this address" });
|
|
322
|
+
expect(await readStateVersion(mkdtempSync(join(tmpdir(), "chant-versions-")), {})).toEqual({ backend: "local", location: "terraform.tfstate", versioning: "off", note: "a local backend keeps only the latest state" });
|
|
323
|
+
const pg = await readStateVersion(initialised("pg", { conn_str: "postgres://tf:secret@db.internal:5432/states", schema_name: "net" }), {});
|
|
324
|
+
expect(pg).toMatchObject({ backend: "pg", versioning: "off", location: "pg:db.internal:5432/states/net.states", note: expect.stringContaining("which each write replaces") });
|
|
325
|
+
expect(JSON.stringify(pg)).not.toContain("secret");
|
|
326
|
+
expect(await readStateVersion(initialised("http", { address: "https://state.example.test/net" }), {})).toMatchObject({ backend: "http", versioning: "off", note: expect.stringContaining("names no versions") });
|
|
327
|
+
expect(await readStateVersion(initialised("cos", { bucket: "b", prefix: "net" }), {})).toMatchObject({ backend: "cos", versioning: "unknown", note: "a cos backend can keep versions of the state, which chant does not read" });
|
|
328
|
+
expect(await readStateVersion(initialised("remote", { organization: "acme", workspaces: [{ name: "net" }] }), {})).toMatchObject({ backend: "remote", versioning: "unknown", location: "remote:app.terraform.io/acme/net" });
|
|
329
|
+
expect(keepsHistory({ type: "http", config: {} }, { TF_HTTP_ADDRESS: GITLAB_ADDRESS })).toBeUndefined();
|
|
330
|
+
});
|
|
331
|
+
|
|
332
|
+
test("a product's words name its keys in a credentials refusal, and `backend` stands in for the recorded one", async () => {
|
|
333
|
+
const words = { hints: { gcp: "oidc.gcp", azure: "oidc.azure" } };
|
|
334
|
+
expect(await readStateVersion(initialised("gcs", { bucket: "b" }), {}, { words })).toMatchObject({ backend: "gcs", versioning: "unknown", note: expect.stringContaining("give the job oidc.gcp") });
|
|
335
|
+
expect(await readStateVersion(initialised("azurerm", { ...AZ_CONFIG, access_key: null }), {}, { words })).toMatchObject({ note: expect.stringContaining("give the job oidc.azure") });
|
|
336
|
+
const s3 = fakeS3();
|
|
337
|
+
const v = s3.put("acme-state/unit.tfstate", "{}");
|
|
338
|
+
expect(await readStateVersion(mkdtempSync(join(tmpdir(), "chant-versions-")), AWS, { fetch: s3.fetch, backend: { type: "s3", config: { ...S3_CONFIG, key: "unit.tfstate" } } })).toMatchObject({ version_id: v });
|
|
339
|
+
});
|
|
340
|
+
});
|
|
341
|
+
|
|
342
|
+
describe("every version a store keeps", () => {
|
|
343
|
+
test("lists an s3, gcs or azurerm state's versions by the location a run recorded, newest first", async () => {
|
|
344
|
+
const s3 = fakeS3();
|
|
345
|
+
const v1 = s3.put("acme-state/app.tfstate", "{}");
|
|
346
|
+
const v2 = s3.put("acme-state/app.tfstate", "{}");
|
|
347
|
+
s3.put("acme-state/app.tfstate.tflock", "{}");
|
|
348
|
+
const listed = await listStateVersions("s3://acme-state/app.tfstate", { ...AWS, AWS_ENDPOINT_URL: "http://s3.test" }, { fetch: s3.fetch });
|
|
349
|
+
expect(listed).toMatchObject({ versions: [{ version_id: v2, latest: true }, { version_id: v1, latest: false }] });
|
|
350
|
+
const a = fakeAzure(true);
|
|
351
|
+
const id = a.write("tfstate/app.tfstate", "{}");
|
|
352
|
+
expect(await listStateVersions("az://acme/tfstate/app.tfstate", { AZURE_STORAGE_KEY: Buffer.from("key").toString("base64") }, { fetch: a.fetch })).toMatchObject({ versions: [{ version_id: id, latest: true }] });
|
|
353
|
+
// The job's own identity lists a gcs state's generations; with none, the list says so.
|
|
354
|
+
expect(await listStateVersions("gs://acme-state/app/default.tfstate", {}, { words: { hints: { gcp: "oidc.gcp" } } })).toMatchObject({ error: expect.stringContaining("give the job oidc.gcp") });
|
|
355
|
+
});
|
|
356
|
+
|
|
357
|
+
test("skips a GitLab state, any other location and a store that lists none, and answers a failed list with why", async () => {
|
|
358
|
+
expect(await listStateVersions(GITLAB_ADDRESS, {})).toEqual({ skipped: "GitLab's state API lists no versions of a state" });
|
|
359
|
+
expect(await listStateVersions("terraform.tfstate", {})).toEqual({ skipped: "chant lists the versions of s3, gcs and azurerm states only" });
|
|
360
|
+
expect(await listStateVersions("az://acme/tfstate", {})).toEqual({ skipped: "az://acme/tfstate names no blob" });
|
|
361
|
+
expect(await listStateVersions("az://acme/tfstate/app.tfstate", { AZURE_STORAGE_KEY: "a2V5" }, { fetch: fakeAzure(false).fetch })).toEqual({ skipped: "the store lists no versions of the state" });
|
|
362
|
+
expect(await listStateVersions("s3://acme-state/app.tfstate", AWS, { fetch: async () => answer(403, "<Error><Code>AccessDenied</Code></Error>") })).toMatchObject({ error: expect.stringContaining("403") });
|
|
363
|
+
expect(await listStateVersions("s3://acme-state/app.tfstate", {}, { words: { setting: "reports.bucket" } })).toMatchObject({ error: expect.stringContaining("reports.bucket") });
|
|
364
|
+
});
|
|
365
|
+
});
|
package/src/state/versions.ts
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* A root's state read by version
|
|
3
|
-
*
|
|
4
|
-
*
|
|
2
|
+
* A root's state read by version: for chant core's state export (#4762,
|
|
3
|
+
* `@intentius/chant/state-export`), for what an apply leaves, and for an
|
|
4
|
+
* audit of every version a store keeps (#4793). The reads are the stores'
|
|
5
|
+
* (./store.ts):
|
|
5
6
|
*
|
|
6
7
|
* s3 bucket versioning: the object's `x-amz-version-id`
|
|
7
8
|
* gcs object versioning: a version is a generation
|
|
@@ -10,71 +11,29 @@
|
|
|
10
11
|
* a request for the current version takes one, whose id names it
|
|
11
12
|
* http a GitLab-managed state (./gitlab.ts): GitLab keeps each version
|
|
12
13
|
* by its serial, so the version id is the serial
|
|
14
|
+
* local keeps only the latest state
|
|
13
15
|
*
|
|
14
|
-
* A
|
|
15
|
-
*
|
|
16
|
+
* A backend chant reads no versions of is named by what it keeps: pg,
|
|
17
|
+
* kubernetes, consul and an http backend other than GitLab's keep no
|
|
18
|
+
* history (each write replaces the state in place), and any other may keep
|
|
19
|
+
* versions chant does not read. Nothing here writes a state; the one write
|
|
20
|
+
* is the azurerm snapshot above.
|
|
16
21
|
*
|
|
17
|
-
* Lifted from terragucci's `backend.ts
|
|
18
|
-
* `readVersion` of its stores
|
|
22
|
+
* Lifted from terragucci's `backend.ts`: the `version`, `hasVersion`,
|
|
23
|
+
* `readVersion` and `isAt` of its stores, `keepsHistory`, `stateVersion` and
|
|
24
|
+
* `listStateVersions`, so terragucci deletes its copy.
|
|
19
25
|
*/
|
|
20
26
|
import type { StateVersion, StateVersionSource } from "@intentius/chant/state-export";
|
|
21
|
-
import { AzureBlobClient, type
|
|
22
|
-
import {
|
|
23
|
-
import {
|
|
24
|
-
import type
|
|
25
|
-
import type
|
|
26
|
-
import {
|
|
27
|
+
import { AzureBlobClient, azureFromEnv, GcsClient, gcsFromEnv, S3Client, s3FromEnv, type ObjectVersion } from "@intentius/chant/object-store";
|
|
28
|
+
import { literal, stateAddress } from "../compose/state-address";
|
|
29
|
+
import { initialisedBackend, isRefused, readableStateObject, stateLocation, type InitialisedBackend, type StateObject, type StateStoreWords } from "./backend";
|
|
30
|
+
import { isGitLabAddress, type GitLabStateStore } from "./gitlab";
|
|
31
|
+
import { StoreError, type StoreFetch } from "./object-store";
|
|
32
|
+
import { stateStore } from "./store";
|
|
27
33
|
|
|
28
34
|
/** What the version reads cover, for a refusal. */
|
|
29
35
|
export const READS_VERSIONS = "a state export reads versions of s3, gcs and azurerm states and GitLab-managed state";
|
|
30
36
|
|
|
31
|
-
function s3Versions(o: Extract<StoredState, { backend: "s3" }>, fetchFn?: StoreFetch): StateVersionSource {
|
|
32
|
-
const client = new S3Client(o.target, fetchFn);
|
|
33
|
-
return {
|
|
34
|
-
location: `s3://${o.bucket}/${o.key}`,
|
|
35
|
-
async current(): Promise<StateVersion> {
|
|
36
|
-
const head = await client.head(o.key);
|
|
37
|
-
if (!head.exists) return { exists: false };
|
|
38
|
-
return head.versionId ? { exists: true, versionId: head.versionId } : { exists: true, off: `bucket versioning is off for ${o.bucket}, so it keeps only the latest state` };
|
|
39
|
-
},
|
|
40
|
-
hasVersion: (id) => client.hasVersion(o.key, id),
|
|
41
|
-
readVersion: (id) => client.readVersion(o.key, id),
|
|
42
|
-
};
|
|
43
|
-
}
|
|
44
|
-
|
|
45
|
-
function gcsVersions(o: Extract<StoredState, { backend: "gcs" }>, fetchFn?: StoreFetch): StateVersionSource {
|
|
46
|
-
const client = new GcsClient(o.target, fetchFn);
|
|
47
|
-
return {
|
|
48
|
-
location: `gs://${o.bucket}/${o.key}`,
|
|
49
|
-
async current(): Promise<StateVersion> {
|
|
50
|
-
const head = await client.head(o.key);
|
|
51
|
-
if (!head.exists) return { exists: false };
|
|
52
|
-
if ((await client.versioning()) === false) return { exists: true, off: `object versioning is off for ${o.bucket}, so it keeps only the latest state` };
|
|
53
|
-
return { exists: true, ...(head.generation ? { versionId: head.generation } : {}) };
|
|
54
|
-
},
|
|
55
|
-
hasVersion: async (id) => (await client.head(o.key, id)).exists,
|
|
56
|
-
readVersion: (id) => client.readGeneration(o.key, id),
|
|
57
|
-
};
|
|
58
|
-
}
|
|
59
|
-
|
|
60
|
-
function azureVersions(o: Extract<StoredState, { backend: "azurerm" }>, fetchFn?: StoreFetch, pin = true): StateVersionSource {
|
|
61
|
-
const client = new AzureBlobClient({ account: o.account, container: o.container, endpoint: o.endpoint, ...o.auth } as AzureTarget, fetchFn);
|
|
62
|
-
// A blob that keeps versions names each by its version id; else by a snapshot.
|
|
63
|
-
const at = async (id: string) => ((await client.head(o.key)).versionId ? { versionid: id } : { snapshot: id });
|
|
64
|
-
return {
|
|
65
|
-
location: `az://${o.account}/${o.container}/${o.key}`,
|
|
66
|
-
async current(): Promise<StateVersion> {
|
|
67
|
-
const head = await client.head(o.key);
|
|
68
|
-
if (!head.exists) return { exists: false };
|
|
69
|
-
if (head.versionId) return { exists: true, versionId: head.versionId };
|
|
70
|
-
if (!o.snapshot) return { exists: true, off: `blob versioning is off for ${o.account}, and the backend takes no snapshots (snapshot = true), so it keeps only the latest state` };
|
|
71
|
-
return pin ? { exists: true, versionId: await client.snapshot(o.key) } : { exists: true, off: "the blob keeps no versions, and only a snapshot would name this one" };
|
|
72
|
-
},
|
|
73
|
-
hasVersion: async (id) => (await client.head(o.key, await at(id))).exists,
|
|
74
|
-
readVersion: async (id) => client.readAt(o.key, await at(id)),
|
|
75
|
-
};
|
|
76
|
-
}
|
|
77
|
-
|
|
78
37
|
/**
|
|
79
38
|
* A root's state as a version source, or why it has none: a refused backend,
|
|
80
39
|
* or a local state, which keeps no versions. With `pin: false` an azurerm
|
|
@@ -84,20 +43,141 @@ function azureVersions(o: Extract<StoredState, { backend: "azurerm" }>, fetchFn?
|
|
|
84
43
|
export function stateVersionSource(o: StateObject, fetchFn?: StoreFetch, options: { pin?: boolean } = {}): StateVersionSource | { refused: string } {
|
|
85
44
|
if (isRefused(o)) return { refused: o.reason };
|
|
86
45
|
if (o.backend === "local") return { refused: `the state is a local file, ${stateLocation(o)}, which keeps no versions; ${READS_VERSIONS}` };
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
return
|
|
46
|
+
const store = stateStore(o, "", fetchFn);
|
|
47
|
+
const pin = options.pin ?? true;
|
|
48
|
+
return {
|
|
49
|
+
location: store.location,
|
|
50
|
+
current: () => store.version(pin),
|
|
51
|
+
hasVersion: (id) => store.hasVersion(id),
|
|
52
|
+
readVersion: (id) => store.readVersion(id),
|
|
53
|
+
};
|
|
90
54
|
}
|
|
91
55
|
|
|
92
56
|
/** A GitLab-managed state as a version source: the version id is the serial. */
|
|
93
57
|
export function gitlabVersionSource(store: GitLabStateStore): StateVersionSource {
|
|
94
58
|
return {
|
|
95
59
|
location: store.location,
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
return now ? { exists: true, versionId: String(now.serial) } : { exists: false };
|
|
99
|
-
},
|
|
100
|
-
hasVersion: async (id) => /^\d+$/.test(id) && (await store.hasVersion(id)),
|
|
60
|
+
current: (): Promise<StateVersion> => store.version(),
|
|
61
|
+
hasVersion: (id) => store.hasVersion(id),
|
|
101
62
|
readVersion: (id) => store.readVersion(id),
|
|
102
63
|
};
|
|
103
64
|
}
|
|
65
|
+
|
|
66
|
+
/**
|
|
67
|
+
* Why a backend keeps no history, for the types that keep none: each write
|
|
68
|
+
* replaces the state in place. GitLab's http backend keeps each version by
|
|
69
|
+
* serial, so an http backend is in this list only when its address is not
|
|
70
|
+
* GitLab's state API.
|
|
71
|
+
*/
|
|
72
|
+
export const NO_HISTORY: Readonly<Record<string, string>> = {
|
|
73
|
+
pg: "a pg backend keeps one row per workspace, which each write replaces",
|
|
74
|
+
kubernetes: "a kubernetes backend keeps one Secret per workspace, which each write replaces",
|
|
75
|
+
consul: "a consul backend keeps one key per workspace, which each write replaces",
|
|
76
|
+
http: "an http backend keeps what its server holds at the address and names no versions",
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
const str = (v: unknown): string | undefined => (typeof v === "string" && v !== "" ? v : undefined);
|
|
80
|
+
|
|
81
|
+
/** Whether the backend keeps no history of the state: false for one that keeps none, undefined when it may keep some. The address of an http backend is the recorded one, else TF_HTTP_ADDRESS. */
|
|
82
|
+
export function keepsHistory(b: InitialisedBackend, env: NodeJS.ProcessEnv = {}): false | undefined {
|
|
83
|
+
if (!(b.type in NO_HISTORY)) return undefined;
|
|
84
|
+
if (b.type === "http" && isGitLabAddress(str(b.config.address) ?? env.TF_HTTP_ADDRESS)) return undefined;
|
|
85
|
+
return false;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/** The state's address (../compose/state-address.ts) from the configuration init recorded, credentials left out. */
|
|
89
|
+
export function recordedAddress(b: InitialisedBackend): string | undefined {
|
|
90
|
+
const workspaces = Array.isArray(b.config.workspaces) ? b.config.workspaces[0] : b.config.workspaces;
|
|
91
|
+
const get = (n: string): string | null | undefined => literal(b.config[n] ?? (workspaces && typeof workspaces === "object" ? (workspaces as Record<string, unknown>)[n] : undefined));
|
|
92
|
+
const a = stateAddress(b.type, get, "");
|
|
93
|
+
return "key" in a ? a.key : undefined;
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
/** The version of a root's state an apply leaves, as a run records it. */
|
|
97
|
+
export interface RootStateVersion {
|
|
98
|
+
/** The backend the root initialised: `s3`, `local`, `gcs` and so on. */
|
|
99
|
+
backend: string;
|
|
100
|
+
/** Where the state is: `s3://<bucket>/<key>`, `gs://<bucket>/<key>`, `az://<account>/<container>/<key>`, a GitLab state's address, the local file's path, or another backend's address. */
|
|
101
|
+
location?: string;
|
|
102
|
+
/** The backend's id for this version: an S3 version id, a GCS generation, an Azure blob version id or snapshot time, a GitLab serial. Absent when the backend keeps no versions or none could be read. */
|
|
103
|
+
version_id?: string;
|
|
104
|
+
/** `on`: the backend keeps each version; `off`: it keeps only the latest; `unknown`: chant could not tell. */
|
|
105
|
+
versioning: "on" | "off" | "unknown";
|
|
106
|
+
/** Why the version could not be read, or what `off` means for this backend. */
|
|
107
|
+
note?: string;
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
export interface ReadStateVersionOptions {
|
|
111
|
+
/** The calls the store makes. Default the global fetch. */
|
|
112
|
+
fetch?: StoreFetch;
|
|
113
|
+
/** Stands in for the backend `init` recorded: a Terragrunt unit's, from its evaluated `remote_state` block. */
|
|
114
|
+
backend?: InitialisedBackend;
|
|
115
|
+
/** The product's words for a credentials refusal (`StateStoreWords`). */
|
|
116
|
+
words?: StateStoreWords;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
/**
|
|
120
|
+
* The version of the state a root's backend holds now, from the object's
|
|
121
|
+
* metadata (#4793). An azurerm blob that keeps snapshots and no versions
|
|
122
|
+
* gets a snapshot, whose time names the version. Never throws: a version
|
|
123
|
+
* that cannot be read is `unknown`, with why.
|
|
124
|
+
*/
|
|
125
|
+
export async function readStateVersion(dir: string, env: NodeJS.ProcessEnv = process.env, options: ReadStateVersionOptions = {}): Promise<RootStateVersion> {
|
|
126
|
+
const recorded = options.backend ?? initialisedBackend(dir, env);
|
|
127
|
+
const o = readableStateObject(dir, env, recorded, options.words);
|
|
128
|
+
if (isRefused(o)) {
|
|
129
|
+
const b = recorded ?? { type: "local", config: {} };
|
|
130
|
+
const location = recordedAddress(b);
|
|
131
|
+
const at = location ? { location } : {};
|
|
132
|
+
if (o.refused !== "backend") return { backend: o.backend, ...at, versioning: "unknown", note: o.reason };
|
|
133
|
+
if (keepsHistory(b, env) === false) return { backend: b.type, ...at, versioning: "off", note: NO_HISTORY[b.type] };
|
|
134
|
+
return { backend: b.type, ...at, versioning: "unknown", note: `a ${b.type} backend can keep versions of the state, which chant does not read` };
|
|
135
|
+
}
|
|
136
|
+
const location = stateLocation(o)!;
|
|
137
|
+
if (o.backend === "local") return { backend: "local", location, versioning: "off", note: "a local backend keeps only the latest state" };
|
|
138
|
+
try {
|
|
139
|
+
const v = await stateStore(o, dir, options.fetch).version(true);
|
|
140
|
+
if (!v.exists) return { backend: o.backend, location, versioning: "unknown", note: o.backend === "http" ? "GitLab holds no state at this address" : `the state object is not in the ${o.backend === "azurerm" ? "container" : "bucket"}` };
|
|
141
|
+
if (v.versionId) return { backend: o.backend, location, version_id: v.versionId, versioning: "on" };
|
|
142
|
+
if (v.off) return { backend: o.backend, location, versioning: "off", note: v.off };
|
|
143
|
+
return { backend: o.backend, location, versioning: "unknown", note: "the store gave no version id" };
|
|
144
|
+
} catch (e) {
|
|
145
|
+
return { backend: o.backend, location, versioning: "unknown", note: (e as Error).message };
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/** What a state's store lists of its versions: each one, newest first; why none are listed; or why the list could not be read. */
|
|
150
|
+
export type StateVersionList = { versions: ObjectVersion[] } | { skipped: string } | { error: string };
|
|
151
|
+
|
|
152
|
+
/**
|
|
153
|
+
* Every version a state's store keeps, by the state's location as a run
|
|
154
|
+
* recorded it (`s3://<bucket>/<key>`, `gs://<bucket>/<key>`,
|
|
155
|
+
* `az://<account>/<container>/<key>`), from the store's list of the
|
|
156
|
+
* object's versions with the job's own identity: ids and times, never a
|
|
157
|
+
* state's contents (#4793). A GitLab state is skipped, since GitLab's state
|
|
158
|
+
* API lists no versions, and so is any other location, with why. Throws
|
|
159
|
+
* only what is neither a store's error nor a failed call.
|
|
160
|
+
*/
|
|
161
|
+
export async function listStateVersions(location: string, env: NodeJS.ProcessEnv = process.env, options: { fetch?: StoreFetch; words?: StateStoreWords } = {}): Promise<StateVersionList> {
|
|
162
|
+
const m = /^(s3|gs|az):\/\/([^/]+)\/(.+)$/.exec(location);
|
|
163
|
+
if (!m) {
|
|
164
|
+
if (isGitLabAddress(location)) return { skipped: "GitLab's state API lists no versions of a state" };
|
|
165
|
+
return { skipped: "chant lists the versions of s3, gcs and azurerm states only" };
|
|
166
|
+
}
|
|
167
|
+
const [, scheme, bucket, rest] = m as unknown as [string, string, string, string];
|
|
168
|
+
const words = { setting: "the state bucket", sessionName: "chant-state", ...options.words };
|
|
169
|
+
try {
|
|
170
|
+
let versions: ObjectVersion[];
|
|
171
|
+
if (scheme === "s3") versions = await new S3Client(s3FromEnv({ bucket, ...words }, env), options.fetch).listVersions(rest);
|
|
172
|
+
else if (scheme === "gs") versions = await new GcsClient(gcsFromEnv({ bucket, ...words }, env), options.fetch).listVersions(rest);
|
|
173
|
+
else {
|
|
174
|
+
const [container, ...key] = rest.split("/");
|
|
175
|
+
if (!container || key.length === 0) return { skipped: `${location} names no blob` };
|
|
176
|
+
versions = await new AzureBlobClient(azureFromEnv({ account: bucket, container, ...words }, env), options.fetch).listVersions(key.join("/"));
|
|
177
|
+
}
|
|
178
|
+
return versions.length > 0 ? { versions } : { skipped: "the store lists no versions of the state" };
|
|
179
|
+
} catch (e) {
|
|
180
|
+
if (!(e instanceof StoreError) && !(e instanceof TypeError)) throw e;
|
|
181
|
+
return { error: e.message };
|
|
182
|
+
}
|
|
183
|
+
}
|