Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

Cache.ts

242 lines9.8 KB

1import * as Context from "effect/Context";
2import * as Effect from "effect/Effect";
3import * as Clock from "effect/Clock";
4import * as Layer from "effect/Layer";
5import * as Schema from "effect/Schema";
6import type * as Cloudflare from "@cloudflare/workers-types";
7import { Summary, recordSummary } from "./Summary.ts";
8import * as Savings from "./Savings.ts";
9import type { ProtocolBindings } from "./protocolTypes.ts";
10import * as Admission from "./Admission.ts";
11import { developerIdentity } from "./developerAuth.ts";
12​
13const decodeSummary = Schema.decodeEffect(Schema.fromJsonString(Summary));
14​
15export class CacheError extends Schema.TaggedError<CacheError>()("CacheError", {
16 status: Schema.Number,
17 reason: Schema.String,
18}) {}
19​
20export class Bindings extends Context.Service<
21 Bindings,
22 ProtocolBindings & {
23 readonly developerKeys: string;
24 readonly readerKeys: string;
25 readonly readLimit: Cloudflare.RateLimit;
26 readonly storeLimit: Cloudflare.RateLimit;
27 }
28>()("@t3tools/task-cache/Cache/Bindings") {}
29​
30export class Cache extends Context.Service<
31 Cache,
32 {
33 readonly handle: (
34 request: Request,
35 context: Pick<Cloudflare.ExecutionContext, "waitUntil">,
36 ) => Effect.Effect<Response>;
37 readonly cleanup: Effect.Effect<void, CacheError>;
38 }
39>()("@t3tools/task-cache/Cache") {}
40​
41const make = Effect.gen(function* () {
42 const bindings = yield* Bindings;
43 const admission = yield* Admission.Admission;
44 const savings = yield* Savings.Savings;
45 // The source-only protocol dependency is bundled for Workers, never evaluated by Node during deployment.
46 const {
47 authorizeCacheWrite,
48 authorizeTelemetry,
49 keys,
50 cborResponse,
51 cleanup,
52 getScope,
53 selectBlob,
54 errorResponse,
55 HttpError,
56 fetchMetadata,
57 defaults,
58 store,
59 readBody,
60 Deadline,
61 Observations,
62 } = yield* Effect.promise(() => import("./protocol.ts"));
63​
64 // The upstream adapter owns the experimental wire format and atomic D1 publication.
65 const protocol = <A>(run: (signal: AbortSignal) => Promise<A>) =>
66 Effect.tryPromise({
67 try: run,
68 catch: (cause) =>
69 new CacheError({
70 status: cause instanceof HttpError ? cause.status : 503,
71 reason: cause instanceof HttpError ? cause.code : "unavailable",
72 }),
73 });
74​
75 const checkLimit = Effect.fn("TaskCache.checkLimit")(function* (operation: string) {
76 const allowed = yield* protocol(() =>
77 (operation === "store" ? bindings.storeLimit : bindings.readLimit).limit({
78 key: `t3code:${operation.startsWith("blob/") ? "blob" : operation}`,
79 }),
80 );
81 if (!allowed.success) return yield* new CacheError({ status: 429, reason: "rate_limit" });
82 });
83​
84 const handle = Effect.fn("TaskCache.handle")(
85 function* (request: Request, context: Pick<Cloudflare.ExecutionContext, "waitUntil">) {
86 const url = new URL(request.url);
87 const route = /^\/projects\/t3code\/(fetch|store|telemetry|blob\/([0-9a-f-]{36}))$/.exec(
88 url.pathname,
89 );
90 const operation = route?.[1] ?? "unknown";
91 const writing = operation === "store";
92 yield* Effect.annotateCurrentSpan({
93 "cache.operation": operation.startsWith("blob/") ? "blob" : operation,
94 });
95 if (
96 !route ||
97 url.search ||
98 request.method !== (operation.startsWith("blob/") ? "GET" : "POST")
99 ) {
100 return yield* new CacheError({ status: 404, reason: "unknown_route" });
101 }
102 if (!request.headers.has("authorization"))
103 return yield* new CacheError({ status: 401, reason: "missing_identity" });
104 const developer = yield* developerIdentity(request, bindings.developerKeys);
105 if (writing || operation === "telemetry") {
106 if (developer === null)
107 return yield* new CacheError({ status: 403, reason: "invalid_identity" });
108 } else {
109 const reader = developer ?? (yield* developerIdentity(request, bindings.readerKeys));
110 if (typeof reader !== "string")
111 return yield* new CacheError({ status: 403, reason: "read_denied" });
112 }
113 return yield* admission
114 .withPermit(
115 writing,
116 Effect.scoped(
117 Effect.gen(function* () {
118 const controller = yield* Effect.acquireRelease(
119 Effect.sync(() => new AbortController()),
120 (value) => Effect.sync(() => value.abort()),
121 );
122 const deadline = yield* Effect.acquireRelease(
123 Effect.sync(
124 () =>
125 new Deadline(
126 writing ? defaults.deadlineMs : 15000,
127 AbortSignal.any([request.signal, controller.signal]),
128 ),
129 ),
130 (value) =>
131 Effect.sync(() => {
132 controller.abort();
133 value.dispose();
134 }),
135 );
136 const stats = new Observations();
137 yield* Effect.addFinalizer(() =>
138 Effect.annotateCurrentSpan(
139 Object.fromEntries(
140 Object.entries(stats.toJSON()).map(([key, value]) => [`cache.${key}`, value]),
141 ),
142 ),
143 );
144 if (!writing && operation !== "telemetry") yield* checkLimit(operation);
145 const scope = yield* protocol(() => getScope(bindings.INDEX, "t3code", stats));
146 if (operation === "telemetry") {
147 let identity = developer ?? undefined;
148 if (identity === undefined) {
149 identity = yield* protocol(() => authorizeTelemetry(request, scope, keys));
150 }
151 yield* checkLimit(operation);
152 const bytes = yield* protocol(() => readBody(request.body, 256 * 1024, deadline));
153 const summary = yield* decodeSummary(new TextDecoder().decode(bytes)).pipe(
154 Effect.mapError(() => new CacheError({ status: 400, reason: "invalid_summary" })),
155 );
156 if (summary.tasks.length === 0) return new Response(null, { status: 204 });
157 const now = yield* Clock.currentTimeMillis;
158 if (summary.recordedAt > now + 60_000 || summary.recordedAt < now - 30 * 86400_000)
159 return yield* new CacheError({ status: 400, reason: "summary_expired" });
160 yield* savings
161 .record(summary, identity)
162 .pipe(
163 Effect.mapError(
164 () => new CacheError({ status: 503, reason: "telemetry_unavailable" }),
165 ),
166 );
167 yield* recordSummary(summary, identity);
168 yield* savings
169 .emitTotals(identity, summary.host)
170 .pipe(
171 Effect.mapError(
172 () => new CacheError({ status: 503, reason: "telemetry_unavailable" }),
173 ),
174 );
175 return new Response(null, { status: 204 });
176 }
177 if (writing) {
178 if (developer !== undefined && !scope.writes_enabled) {
179 return yield* new CacheError({ status: 403, reason: "developer_write_denied" });
180 }
181 const now = yield* Clock.currentTimeMillis;
182 const identity =
183 developer === undefined
184 ? yield* protocol(() => authorizeCacheWrite(request, scope, keys))
185 : {
186 exp: Math.floor(now / 1000) + 900,
187 repository_id: scope.repository_id,
188 workflow_ref: `developer/${developer}`,
189 };
190 yield* checkLimit(operation);
191 return yield* protocol(() =>
192 store(request, bindings, context, scope, identity, defaults, deadline, stats),
193 );
194 }
195 if (operation === "fetch") {
196 const result = yield* protocol(() =>
197 fetchMetadata(request, bindings, "t3code", defaults, deadline, stats),
198 );
199 return cborResponse(result);
200 }
201 const selected = yield* protocol(() =>
202 selectBlob(bindings.INDEX, "t3code", route[2]!, stats),
203 );
204 if (!selected) return yield* new CacheError({ status: 404, reason: "blob_missing" });
205 stats.r2_operations++;
206 const object = yield* protocol(() => bindings.ARTIFACTS.get(selected.blob_object));
207 if (!object) return yield* new CacheError({ status: 404, reason: "blob_missing" });
208 if (object.size !== selected.blob_size)
209 return yield* new CacheError({ status: 503, reason: "blob_size" });
210 return new Response(object.body, {
211 headers: {
212 "Content-Type": "application/octet-stream",
213 "Content-Length": String(object.size),
214 "Cache-Control": "no-store",
215 },
216 });
217 }),
218 ),
219 )
220 .pipe(
221 Effect.timeout(writing ? "2 minutes" : "15 seconds"),
222 Effect.catchTags({
223 AdmissionRejected: () =>
224 Effect.fail(new CacheError({ status: 503, reason: "concurrency_limit" })),
225 TimeoutError: () => Effect.fail(new CacheError({ status: 503, reason: "deadline" })),
226 }),
227 );
228 },
229 Effect.catchTags({
230 // The enclosing operation owns the span for this inline handler.
231 CacheError: Effect.fnUntraced(function* (error) {
232 if (error.status >= 500)
233 yield* Effect.logWarning("Cache request failed", { reason: error.reason });
234 return errorResponse(new HttpError(error.status, error.reason));
235 }),
236 }),
237 );
238​
239 return Cache.of({ handle, cleanup: protocol(() => cleanup(bindings)) });
240});
241​
242export const layer = Layer.effect(Cache, make);