The best way to control Claude Code, Codex and more from any computer or phone

main
ts 257 lines 8.44 KB
Raw
1 import * as metastore from "@distilled.cloud/gcp/metastore_v1";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Effect from "effect/Effect";
7 import * as Schedule from "effect/Schedule";
8 import { GcpEnvironment } from "../Environment.ts";
9 import { createInternalLabels } from "../Labels.ts";
10 import type { Providers } from "../Providers.ts";
11 import {
12 encodeOwnership,
13 expandParent,
14 hasOwnershipMarker,
15 listAtNested,
16 listOwnedPages,
17 normalizeLocation,
18 ownedByAlchemy,
19 parseName,
20 parseOwnership,
21 replaceOnIdentity,
22 ResourceNotResolved,
23 toPhysicalId,
24 waitForOperation,
25 waitUntilExists,
26 waitUntilGone,
27 waitUntilReady,
28 } from "./internal.ts";
29
30 export type ServicesBackupProps = {
31 /**
32 * Parent Dataproc Metastore service. Full name
33 * `projects/{project}/locations/{location}/services/{service}` or the
34 * service id (combined with `location`). Immutable — changing it
35 * replaces the backup.
36 */
37 service: string;
38 /**
39 * Region used when `service` is a bare id.
40 * @default the stack's GCP region (`GCP.Region`, else the profile region, else `us-central1`)
41 */
42 location?: string;
43 /**
44 * Backup id (the `{backup}` segment). If omitted, a unique RFC1035 name
45 * is generated. Must begin with a letter and end with a letter or
46 * number. Immutable — changing it replaces the backup.
47 */
48 backupId?: string;
49 /**
50 * Human-readable description. Backups have no labels field and no
51 * update API, so Alchemy stamps ownership into the description at
52 * create and cannot change it in place.
53 */
54 description?: string;
55 };
56
57 export type ServicesBackup = Resource<
58 "GCP.Metastore.ServicesBackup",
59 ServicesBackupProps,
60 {
61 /** Full resource name. */
62 name: string;
63 /** Backup id (last path segment). */
64 backupId: string;
65 /** Parent service name. */
66 service: string;
67 /** Project id. */
68 project: string;
69 /** Location id. */
70 location: string;
71 /** User description with the Alchemy ownership prefix stripped. */
72 description: string | undefined;
73 /** Server-reported state. */
74 state: string | undefined;
75 /** Services currently restoring from this backup. */
76 restoringServices: string[];
77 /** RFC3339 creation timestamp. */
78 createTime: string | undefined;
79 /** RFC3339 completion timestamp. */
80 endTime: string | undefined;
81 },
82 never,
83 Providers
84 >;
85
86 /**
87 * A Dataproc Metastore service backup — a point-in-time capture of a
88 * Hive metastore.
89 *
90 * Changing `backupId`, `service`, or `location` replaces the backup.
91 * Description is set at create; backups have no update API.
92 *
93 * ### Creating a Backup
94 * **Example:** Manual backup
95 * ```typescript
96 * const backup = yield* GCP.Metastore.ServicesBackup("Nightly", {
97 * service: hive.name,
98 * description: "pre-release",
99 * });
100 * ```
101 *
102 * **Example:** Explicit id
103 * ```typescript
104 * const backup = yield* GCP.Metastore.ServicesBackup("Nightly", {
105 * service: hive.name,
106 * backupId: "nightly-01",
107 * });
108 * ```
109 *
110 * @resource
111 * @category Metastore
112 */
113 export const ServicesBackup = Resource<ServicesBackup>("GCP.Metastore.ServicesBackup");
114
115 const resourceName = (service: string, backupId: string) => `${service}/backups/${backupId}`;
116
117 const toAttrs = (item: metastore.Backup, project: string, region: string) => {
118 const name = item.name ?? "";
119 const parsed = parseName(name, "backups", region);
120 const { text } = parseOwnership(item.description);
121 return {
122 name,
123 backupId: parsed.id,
124 service: parsed.parent,
125 project: parsed.project || project,
126 location: parsed.location,
127 description: text,
128 state: item.state,
129 restoringServices: item.restoringServices ?? [],
130 createTime: item.createTime,
131 endTime: item.endTime,
132 };
133 };
134
135 const getByName = (name: string) =>
136 name.length === 0
137 ? Effect.undefined
138 : metastore
139 .getProjectsLocationsServicesBackups({ name })
140 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
141
142 const listOwned = (project: string) =>
143 listAtNested(project, "services/-", (parent) =>
144 listOwnedPages(
145 metastore.listProjectsLocationsServicesBackups.pages({
146 parent,
147 pageSize: 1000,
148 }),
149 (page) => page.backups,
150 (item) => hasOwnershipMarker(item.description),
151 ),
152 );
153
154 export const ServicesBackupProvider = () =>
155 Provider.succeed(ServicesBackup, {
156 stables: ["name", "backupId", "service", "project", "location", "createTime"],
157
158 diff: Effect.fn(function* ({ news, olds, output }) {
159 if (!isResolved(news)) return undefined;
160 const env = yield* GcpEnvironment.current;
161 return replaceOnIdentity({
162 previousId: olds?.backupId ?? output?.backupId,
163 nextId: news.backupId ?? olds?.backupId ?? output?.backupId,
164 previousLocation: normalizeLocation(olds?.location ?? output?.location, env.region),
165 nextLocation: normalizeLocation(
166 news.location ?? olds?.location ?? output?.location,
167 env.region,
168 ),
169 previousParent: olds?.service ?? output?.service,
170 nextParent: news.service,
171 });
172 }),
173
174 read: Effect.fn(function* ({ id, olds, output }) {
175 const env = yield* GcpEnvironment.current;
176 const backupId = yield* toPhysicalId(id, olds?.backupId, output?.backupId, "backup");
177 const location = normalizeLocation(olds?.location ?? output?.location, env.region);
178 const service = expandParent(
179 olds?.service ?? output?.service ?? "",
180 env.project,
181 location,
182 "services",
183 );
184 const name = output?.name ?? resourceName(service, backupId);
185 const existing = yield* getByName(name);
186 if (existing === undefined) return undefined;
187 const attrs = toAttrs(existing, env.project, env.region);
188 return (yield* ownedByAlchemy(id, existing.description)) ? attrs : Unowned(attrs);
189 }),
190
191 list: () =>
192 Effect.gen(function* () {
193 const env = yield* GcpEnvironment.current;
194 const items = yield* listOwned(env.project);
195 return items.map((item) => toAttrs(item, env.project, env.region));
196 }),
197
198 reconcile: Effect.fn(function* ({ id, news, output }) {
199 const env = yield* GcpEnvironment.current;
200 const backupId = yield* toPhysicalId(id, news.backupId, output?.backupId, "backup");
201 const location = normalizeLocation(news.location ?? output?.location, env.region);
202 const service = expandParent(news.service, env.project, location, "services");
203 const name = resourceName(service, backupId);
204 const desiredLabels = yield* createInternalLabels(id);
205 const description = encodeOwnership(desiredLabels, news.description);
206
207 let current = yield* getByName(output?.name ?? name);
208
209 if (current === undefined) {
210 const created = yield* metastore
211 .createProjectsLocationsServicesBackups({
212 parent: service,
213 backupId,
214 body: { description },
215 })
216 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
217 if (created !== undefined) {
218 // ALREADY_EXISTS (6): a concurrent create won the race.
219 yield* waitForOperation(created).pipe(
220 Effect.catchTag("GCP.OperationFailed", (error) =>
221 error.code === 6 ? Effect.void : Effect.fail(error),
222 ),
223 );
224 }
225 current = yield* waitUntilExists(getByName(name), name);
226 current = yield* waitUntilReady(getByName(name), name, (item) => item.state);
227 }
228
229 if (current === undefined) {
230 return yield* new ResourceNotResolved({ resourceName: name });
231 }
232
233 return toAttrs(current, env.project, env.region);
234 }),
235
236 delete: Effect.fn(function* ({ output }) {
237 const operation = yield* metastore
238 .deleteProjectsLocationsServicesBackups({ name: output.name })
239 .pipe(
240 Effect.retry({
241 while: (error) => error._tag === "Conflict",
242 times: 8,
243 schedule: Schedule.spaced("2 seconds"),
244 }),
245 Effect.catchTag("NotFound", () => Effect.undefined),
246 );
247 if (operation !== undefined) {
248 // NOT_FOUND (5): already gone.
249 yield* waitForOperation(operation).pipe(
250 Effect.catchTag("GCP.OperationFailed", (error) =>
251 error.code === 5 ? Effect.void : Effect.fail(error),
252 ),
253 );
254 }
255 yield* waitUntilGone(getByName(output.name), output.name);
256 }),
257 });