@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 380 lines 13.1 KB
Raw
1 import * as vmwareengine from "@distilled.cloud/gcp/vmwareengine_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 type { Providers } from "../Providers.ts";
10 import {
11 DEFAULT_GLOBAL,
12 VmwareengineNotResolved,
13 canonicalizeLink,
14 changedFields,
15 collectPages,
16 createInternalLabels,
17 encodeOwnership,
18 expandName,
19 hasAlchemyLabels,
20 hasOwnershipMarker,
21 normalizeLocation,
22 parentOf,
23 parseName,
24 parseOwnership,
25 replaceOnIdentity,
26 rfc1035,
27 toPhysicalId,
28 waitForOperation,
29 waitUntilGone,
30 waitUntilPresent,
31 waitUntilReady,
32 } from "./internal.ts";
33
34 const COLLECTION = "networkPeerings";
35 const VEN_COLLECTION = "vmwareEngineNetworks";
36
37 export type NetworkPeeringPeerNetworkType =
38 | vmwareengine.NetworkPeeringPeerNetworkTypeEnum
39 | (string & {});
40
41 export type NetworkPeeringProps = {
42 /**
43 * Network peering id (the `{networkPeering}` segment of
44 * `projects/{project}/locations/global/networkPeerings/{networkPeering}`).
45 * If omitted, a unique RFC1035 name is generated. Immutable.
46 */
47 networkPeeringId?: string;
48 /**
49 * Location. Network peering is a global resource.
50 * @default "global"
51 */
52 location?: string;
53 /**
54 * Relative resource name of the network to peer with. VPC networks use
55 * `projects/{project}/global/networks/{network}`; VMware Engine
56 * networks use
57 * `projects/{project}/locations/global/vmwareEngineNetworks/{id}`.
58 * Immutable.
59 */
60 peerNetwork: string;
61 /**
62 * Type of the peer network (`STANDARD`, `VMWARE_ENGINE_NETWORK`, …).
63 * Immutable.
64 */
65 peerNetworkType: NetworkPeeringPeerNetworkType;
66 /**
67 * VMware Engine network to peer
68 * (`projects/{project}/locations/{location}/vmwareEngineNetworks/{id}`
69 * or the network id). Immutable.
70 */
71 vmwareEngineNetwork: string;
72 /**
73 * Export custom routes to the peer. Default true.
74 */
75 exportCustomRoutes?: boolean;
76 /**
77 * Import custom routes from the peer. Default true.
78 */
79 importCustomRoutes?: boolean;
80 /**
81 * Export custom routes that contain public IP ranges. Default true.
82 */
83 exportCustomRoutesWithPublicIp?: boolean;
84 /**
85 * Import custom routes that contain public IP ranges. Default true.
86 */
87 importCustomRoutesWithPublicIp?: boolean;
88 /**
89 * Automatically exchange subnet routes. Currently always true.
90 */
91 exchangeSubnetRoutes?: boolean;
92 /**
93 * Peer MTU in bytes. `0` uses the API default of 1500.
94 */
95 peerMtu?: number;
96 /**
97 * Human-readable description. Network peerings have no labels field, so
98 * Alchemy stamps ownership into a `[alchemy …]` prefix and strips it
99 * from attributes. Description is the only in-place update.
100 */
101 description?: string;
102 };
103
104 export type NetworkPeering = Resource<
105 "GCP.VMwareEngine.NetworkPeering",
106 NetworkPeeringProps,
107 {
108 /** Full resource name. */
109 name: string;
110 /** Network peering id (last path segment). */
111 networkPeeringId: string;
112 /** Project id. */
113 project: string;
114 /** Location id. Always `"global"`. */
115 location: string;
116 /** Peer network resource name. */
117 peerNetwork: string | undefined;
118 /** Peer network type. */
119 peerNetworkType: string | undefined;
120 /** VMware Engine network resource name. */
121 vmwareEngineNetwork: string | undefined;
122 /** Whether custom routes are exported. */
123 exportCustomRoutes: boolean;
124 /** Whether custom routes are imported. */
125 importCustomRoutes: boolean;
126 /** Whether public-IP custom routes are exported. */
127 exportCustomRoutesWithPublicIp: boolean;
128 /** Whether public-IP custom routes are imported. */
129 importCustomRoutesWithPublicIp: boolean;
130 /** Whether subnet routes are exchanged. */
131 exchangeSubnetRoutes: boolean;
132 /** Configured peer MTU. */
133 peerMtu: number | undefined;
134 /** User description with the Alchemy ownership prefix stripped. */
135 description: string | undefined;
136 /** Server-reported state. */
137 state: string | undefined;
138 /** Extra state details. */
139 stateDetails: string | undefined;
140 /** System-generated unique identifier. */
141 uid: string | undefined;
142 /** RFC3339 creation timestamp. */
143 createTime: string | undefined;
144 /** RFC3339 last-update timestamp. */
145 updateTime: string | undefined;
146 },
147 never,
148 Providers
149 >;
150
151 /**
152 * A peering between a VMware Engine network and a VPC or another VMware
153 * Engine network. NetworkPeering is a global resource.
154 *
155 * Network peerings have no labels field, so Alchemy stamps ownership into
156 * the description for `list` / nuke. Identity, peer network, peer type,
157 * and VMware Engine network are immutable. Description updates in place.
158 *
159 * ### Creating a NetworkPeering
160 * **Example:** Peer a VMware Engine network with the default VPC
161 * ```typescript
162 * const peering = yield* GCP.VMwareEngine.NetworkPeering("ToVpc", {
163 * vmwareEngineNetwork: ven.name,
164 * peerNetwork: "projects/my-project/global/networks/default",
165 * peerNetworkType: "STANDARD",
166 * description: "gcve to vpc",
167 * });
168 * ```
169 *
170 * @resource
171 * @category VMwareEngine
172 */
173 export const NetworkPeering = Resource<NetworkPeering>("GCP.VMwareEngine.NetworkPeering");
174
175 const resourceName = (project: string, networkPeeringId: string) =>
176 `${parentOf(project, DEFAULT_GLOBAL)}/${COLLECTION}/${networkPeeringId}`;
177
178 const expandVen = (project: string, value: string) =>
179 expandName(value, project, DEFAULT_GLOBAL, VEN_COLLECTION);
180
181 const boolOrDefault = (value: boolean | undefined, fallback: boolean) => value ?? fallback;
182
183 const toAttrs = (item: vmwareengine.NetworkPeering, project: string) => {
184 const name = item.name ?? "";
185 const parsed = parseName(name, COLLECTION, DEFAULT_GLOBAL);
186 const ownership = parseOwnership(item.description);
187 return {
188 name,
189 networkPeeringId: parsed.id,
190 project: parsed.project || project,
191 location: parsed.location || DEFAULT_GLOBAL,
192 peerNetwork: item.peerNetwork,
193 peerNetworkType: item.peerNetworkType,
194 vmwareEngineNetwork: item.vmwareEngineNetwork,
195 exportCustomRoutes: item.exportCustomRoutes !== false,
196 importCustomRoutes: item.importCustomRoutes !== false,
197 exportCustomRoutesWithPublicIp: item.exportCustomRoutesWithPublicIp !== false,
198 importCustomRoutesWithPublicIp: item.importCustomRoutesWithPublicIp !== false,
199 exchangeSubnetRoutes: item.exchangeSubnetRoutes !== false,
200 peerMtu: item.peerMtu,
201 description: ownership.text,
202 state: item.state,
203 stateDetails: item.stateDetails,
204 uid: item.uid,
205 createTime: item.createTime,
206 updateTime: item.updateTime,
207 };
208 };
209
210 const getByName = (name: string) =>
211 vmwareengine
212 .getProjectsLocationsNetworkPeerings({ name })
213 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
214
215 export const NetworkPeeringProvider = () =>
216 Provider.succeed(NetworkPeering, {
217 stables: ["name", "networkPeeringId", "project", "location", "uid", "createTime"],
218
219 diff: Effect.fn(function* ({ news, olds, output }) {
220 if (!isResolved(news)) return undefined;
221 const previousPeer = canonicalizeLink(olds?.peerNetwork ?? output?.peerNetwork);
222 const nextPeer = canonicalizeLink(news.peerNetwork);
223 const previousVen = canonicalizeLink(
224 olds?.vmwareEngineNetwork ?? output?.vmwareEngineNetwork,
225 );
226 const nextVen = canonicalizeLink(news.vmwareEngineNetwork);
227 const previousType = olds?.peerNetworkType ?? output?.peerNetworkType ?? "";
228 return replaceOnIdentity({
229 previousId: olds?.networkPeeringId ?? output?.networkPeeringId,
230 nextId: news.networkPeeringId
231 ? rfc1035(news.networkPeeringId, "networkpeering")
232 : (olds?.networkPeeringId ?? output?.networkPeeringId),
233 previousLocation: DEFAULT_GLOBAL,
234 nextLocation: normalizeLocation(news.location, DEFAULT_GLOBAL),
235 extra:
236 (previousPeer.length > 0 && previousPeer !== nextPeer) ||
237 (previousVen.length > 0 && previousVen !== nextVen) ||
238 (previousType.length > 0 && previousType !== news.peerNetworkType),
239 });
240 }),
241
242 read: Effect.fn(function* ({ id, olds, output }) {
243 const env = yield* GcpEnvironment.current;
244 const networkPeeringId = yield* toPhysicalId(
245 id,
246 olds?.networkPeeringId,
247 output?.networkPeeringId,
248 "networkpeering",
249 );
250 const name = output?.name ?? resourceName(env.project, networkPeeringId);
251 const existing = yield* getByName(name);
252 if (existing === undefined) return undefined;
253 const attrs = toAttrs(existing, env.project);
254 const { labels } = parseOwnership(existing.description);
255 return (yield* hasAlchemyLabels(id, labels)) ? attrs : Unowned(attrs);
256 }),
257
258 list: () =>
259 Effect.gen(function* () {
260 const env = yield* GcpEnvironment.current;
261 const items = yield* collectPages(
262 vmwareengine.listProjectsLocationsNetworkPeerings.pages({
263 parent: parentOf(env.project, DEFAULT_GLOBAL),
264 pageSize: 1000,
265 }),
266 (page) => page.networkPeerings,
267 );
268 return items
269 .filter((item) => hasOwnershipMarker(item.description))
270 .map((item) => toAttrs(item, env.project));
271 }),
272
273 reconcile: Effect.fn(function* ({ id, news, output }) {
274 const env = yield* GcpEnvironment.current;
275 const networkPeeringId = yield* toPhysicalId(
276 id,
277 news.networkPeeringId,
278 output?.networkPeeringId,
279 "networkpeering",
280 );
281 const name = resourceName(env.project, networkPeeringId);
282 const ownership = yield* createInternalLabels(id);
283 const desiredDescription = encodeOwnership(ownership, news.description);
284 const vmwareEngineNetwork = expandVen(env.project, news.vmwareEngineNetwork);
285 const exportCustomRoutes = boolOrDefault(news.exportCustomRoutes, true);
286 const importCustomRoutes = boolOrDefault(news.importCustomRoutes, true);
287 const exportCustomRoutesWithPublicIp = boolOrDefault(
288 news.exportCustomRoutesWithPublicIp,
289 true,
290 );
291 const importCustomRoutesWithPublicIp = boolOrDefault(
292 news.importCustomRoutesWithPublicIp,
293 true,
294 );
295 const exchangeSubnetRoutes = boolOrDefault(news.exchangeSubnetRoutes, true);
296
297 let current = yield* getByName(output?.name ?? name);
298
299 if (current === undefined) {
300 const created = yield* vmwareengine
301 .createProjectsLocationsNetworkPeerings({
302 parent: parentOf(env.project, DEFAULT_GLOBAL),
303 networkPeeringId,
304 body: {
305 peerNetwork: news.peerNetwork,
306 peerNetworkType: news.peerNetworkType,
307 vmwareEngineNetwork,
308 exportCustomRoutes,
309 importCustomRoutes,
310 exportCustomRoutesWithPublicIp,
311 importCustomRoutesWithPublicIp,
312 exchangeSubnetRoutes,
313 peerMtu: news.peerMtu,
314 description: desiredDescription,
315 },
316 })
317 .pipe(
318 Effect.retry({
319 while: (error) => error._tag === "Conflict",
320 times: 5,
321 schedule: Schedule.spaced("2 seconds"),
322 }),
323 Effect.catchTag("Conflict", () => Effect.undefined),
324 );
325 if (created !== undefined) {
326 yield* waitForOperation(created);
327 }
328 current = yield* waitUntilPresent(getByName(name), name);
329 }
330
331 if (current === undefined) {
332 return yield* new VmwareengineNotResolved({ resourceName: name });
333 }
334
335 current = yield* waitUntilReady(
336 getByName(current.name ?? name),
337 current.name ?? name,
338 (item) => item.state,
339 );
340
341 const descriptionChanged = (current.description ?? "") !== desiredDescription;
342 const updateMask = changedFields([["description", descriptionChanged]]);
343
344 if (updateMask.length > 0) {
345 const operation = yield* vmwareengine.patchProjectsLocationsNetworkPeerings({
346 name: current.name ?? name,
347 updateMask: updateMask.join(","),
348 body: {
349 name: current.name ?? name,
350 description: desiredDescription,
351 },
352 });
353 yield* waitForOperation(operation);
354 current = yield* waitUntilReady(
355 getByName(current.name ?? name),
356 current.name ?? name,
357 (item) => item.state,
358 );
359 }
360
361 return toAttrs(current, env.project);
362 }),
363
364 delete: Effect.fn(function* ({ output }) {
365 const operation = yield* vmwareengine
366 .deleteProjectsLocationsNetworkPeerings({ name: output.name })
367 .pipe(
368 Effect.retry({
369 while: (error) => error._tag === "Conflict",
370 times: 8,
371 schedule: Schedule.spaced("2 seconds"),
372 }),
373 Effect.catchTag("NotFound", () => Effect.undefined),
374 );
375 if (operation !== undefined) {
376 yield* waitForOperation(operation, { notFoundOk: true });
377 }
378 yield* waitUntilGone(getByName(output.name), output.name);
379 }),
380 });