main
1// One run of one scenario against Artifacts, from the Worker: build the seed (src/bench/seed.ts), create a fresh
2// repository in the probe namespace, seed it, run each step with ply as the client under test (faults applied by the
3// recorder), read the end state back (src/bench/judge.ts), classify (src/bench/verdict.ts), then clean up: revoke every
4// token the repository has (the one create minted included), prove the revoked token is refused, delete the repository
5// and prove it is gone. The steps follow ply's own runner (test/probes/runner.mjs runScenario) step for step.
6import { GitHttp, type Span, type Tracer } from 'ply';
7import { plyOutcome, type Classified, type EndState, type Fault, type From, type Names, type Observation, type Push, type Scenario, type StepObservation, type Timeouts } from 'ply/probes';
8import { renderRay } from '../rays.ts';
9import type { RepoName, RunSeed } from './brand.ts';
10import { defectPack, handPack } from './handpack.ts';
11import { readEnd } from './judge.ts';
12import { createRecorder, type Channel, type Exchange, type Recorder } from './recorder.ts';
13import { type Result, err, ok } from './result.ts';
14import { buildSeed, objectsFor, oidOf, reachable, seedTips, ZERO_OID, type SeedStore, type StoredObject } from './seed.ts';
15import { verdictOf, type RunVerdict } from './verdict.ts';
17const TYPE_CODE: Readonly<Record<StoredObject['type'], number>> = { commit: 1, tree: 2, blob: 3, tag: 4 };
18const BLOB = 3;
19const REVOKED = new Set([401, 403]);
21// The parts of the Artifacts Workers binding a run uses (the namespace binding, scoped to the probe namespace).
22export type RepoHandle = {
23 listTokens(): Promise<{ readonly tokens: ReadonlyArray<{ readonly id: string; readonly state: string }> }>;
24 revokeToken(tokenOrId: string): Promise<boolean>;
25};
26export type ProbeRepos = {
27 create(name: string): Promise<{ readonly name: string; readonly remote: string; readonly token: string }>;
28 get(name: string): Promise<RepoHandle>;
29 delete(name: string): Promise<boolean>;
30};
32export type Cleanup = {
33 readonly tokensListed: number;
34 readonly tokensRevoked: number;
35 // the create-minted token, tried after the revokes: the status Artifacts answered and its cf-ray
36 readonly revokedStatus: number | null;
37 readonly revokedRay: string;
38 readonly refused: boolean;
39 readonly deleted: boolean;
40 readonly gone: boolean;
41 readonly errors: readonly string[];
42};
43export type RunResult = {
44 readonly steps: readonly StepObservation[];
45 readonly end: EndState | null;
46 readonly names: Names;
47 readonly exchanges: readonly Exchange[];
48 readonly verdict: RunVerdict;
49 readonly cleanup: Cleanup;
50 readonly remote: string;
51};
52export type RunDeps = {
53 readonly repos: ProbeRepos;
54 readonly upstream: typeof fetch;
55 readonly tracer: Tracer;
56 readonly parent: Span | null;
57 readonly keepBodies: (i: number, request: Uint8Array, response: Uint8Array) => void;
58 // called once the repository exists, before anything is pushed: the run's owner records it for the sweep
59 readonly created: (name: RepoName) => Promise<void>;
60};
62const errText = (e: unknown): string => (e instanceof Error ? `${e.name}: ${e.message}` : String(e)).slice(0, 300);
63const plyErr = (e: { readonly code: string; readonly message: string }, prefix: string): Classified => plyOutcome({ ok: false, code: e.code, message: `${prefix}${String(e.message)}` });
64const asPackObjects = (objs: readonly StoredObject[]): Array<{ readonly oid: string; readonly type: number; readonly data: Uint8Array }> => objs.map(o => ({ oid: o.oid, type: TYPE_CODE[o.type], data: o.data }));
66type Ctx = {
67 readonly store: SeedStore;
68 readonly scenario: Scenario;
69 readonly recorder: Recorder;
70 readonly remote: string;
71 readonly token: string;
72 readonly tracer: Tracer;
73};
74function client(c: Ctx, ch: Channel, parent: Span, timeouts: Timeouts): Result<GitHttp, Classified> {
75 const limits = timeouts === null ? {} : { limits: { firstByteTimeoutMs: timeouts.ms, idleTimeoutMs: timeouts.ms } };
76 const g = GitHttp.create(c.remote, { fetchImpl: c.recorder.fetchFor(ch), auth: { bearer: c.token }, tracer: c.tracer, parent, quirks: {}, recordResponseHeaders: ['cf-ray'], ...limits });
77 return g.ok ? ok(g.value) : err(plyErr(g.error, 'client: '));
78}
80async function plyPush(c: Ctx, push: Push, from: From, timeouts: Timeouts, parent: Span): Promise<Classified> {
81 const g = client(c, 'main', parent, timeouts);
82 if (!g.ok) return g.error;
83 if (from.tag === 'partial') {
84 const main = c.scenario.seed.refs.find(r => r.ref === 'refs/heads/main');
85 const tip = oidOf(c.store, { tag: 'obj', name: typeof main === 'object' ? main.at : '' });
86 if (!tip.ok) return { outcome: 'rejected', error: 'harness', detail: tip.error };
87 const f = await g.value.fetchPack({ wants: [tip.value], filter: 'blob:none' });
88 if (!f.ok) return plyErr(f.error, 'partial fetch: ');
89 const blobs = f.value.objects === null ? 0 : [...f.value.objects.values()].filter(o => o.type === BLOB).length;
90 if (blobs > 0) return { outcome: 'rejected', error: 'harness', detail: `partial fetch carried ${blobs} blobs` };
91 }
92 const have = seedTips(c.store, c.scenario);
93 if (!have.ok) return { outcome: 'rejected', error: 'harness', detail: have.error };
94 const objects = objectsFor(c.store, push, have.value);
95 if (!objects.ok) return { outcome: 'rejected', error: 'harness', detail: objects.error };
96 const cmds: Array<{ readonly ref: string; readonly oldOid: string; readonly newOid: string }> = [];
97 for (const u of push.updates) {
98 const o = oidOf(c.store, u.old);
99 const n = oidOf(c.store, u.new);
100 if (!o.ok || !n.ok) return { outcome: 'rejected', error: 'harness', detail: `unknown object in ${u.ref}` };
101 cmds.push({ ref: u.ref, oldOid: o.value, newOid: n.value });
102 }
103 const [first, ...rest] = cmds;
104 if (typeof first !== 'object') return { outcome: 'rejected', error: 'harness', detail: 'a push with no command' };
105 const commands = [first, ...rest] as const;
106 const atomic = push.atomic ? { atomic: true } : {};
107 const send = async (bytes: Result<Uint8Array, string>): Promise<Classified> => {
108 if (!bytes.ok) return { outcome: 'rejected', error: 'harness', detail: bytes.error };
109 const body = bytes.value;
110 const pack = new ReadableStream<Uint8Array>({ start(ctl) { ctl.enqueue(body); ctl.close(); } });
111 const r = await g.value.pushPack({ commands, pack, length: body.length, ...atomic });
112 return r.ok ? plyOutcome({ ok: true }) : plyErr(r.error, '');
113 };
114 switch (push.pack.tag) {
115 case 'hand': return send(await handPack(c.store, objects.value, push.pack));
116 case 'defect': return send(await defectPack(c.store, objects.value, push.pack.defect));
117 case 'objects':
118 case 'listed': {
119 const r = await g.value.push({ commands, objects: asPackObjects(objects.value), ...atomic });
120 return r.ok ? plyOutcome({ ok: true }) : plyErr(r.error, '');
121 }
122 }
123}
125async function plyFetch(c: Ctx, want: string, timeouts: Timeouts, parent: Span): Promise<Classified> {
126 const g = client(c, 'main', parent, timeouts);
127 if (!g.ok) return g.error;
128 const id = oidOf(c.store, { tag: 'obj', name: want });
129 if (!id.ok) return { outcome: 'rejected', error: 'harness', detail: id.error };
130 const f = await g.value.fetchPack({ wants: [id.value] });
131 if (!f.ok) return plyErr(f.error, '');
132 const objs = f.value.objects;
133 return objs !== null && objs.has(id.value) ? { outcome: 'landed', error: null, detail: `fetched ${objs.size} objects` } : { outcome: 'rejected', error: 'harness', detail: 'the wanted object did not arrive' };
134}
136// The other writer of a race: a forced move of each ref (old id = what the ref holds now), on the side channel.
137async function sideMove(c: Ctx, f: Extract<Fault, { readonly tag: 'race' }>, parent: Span): Promise<number> {
138 const span = c.tracer.start('bench.race', { parent, attrs: { 'bench.moves': f.moves.length } });
139 const g = client(c, 'side', span, null);
140 if (!g.ok) { span.error(new Error(g.error.detail)).end(); return 0; }
141 const ls = await g.value.lsRefs();
142 const now = new Map<string, string>(ls.ok ? [...ls.value.refs].map(([k, v]) => [k, String(v.oid)]) : []);
143 const commands = f.moves.map(m => {
144 const to = oidOf(c.store, m.to);
145 return { ref: m.ref, oldOid: now.get(m.ref) || ZERO_OID, newOid: to.ok ? to.value : ZERO_OID };
146 });
147 const objs = reachable(c.store, commands.map(x => x.newOid).filter(x => x !== ZERO_OID) as never).flatMap(o => {
148 const got = c.store.objects.get(o);
149 return typeof got === 'object' ? [got] : [];
150 });
151 const [first, ...rest] = commands;
152 const r = typeof first === 'object' ? await g.value.push({ commands: [first, ...rest], objects: asPackObjects(objs) }) : null;
153 span.set({ 'bench.race.ok': r !== null && r.ok }).end();
154 return commands.length;
155}
157async function seedRepo(c: Ctx, parent: Span): Promise<Result<number, string>> {
158 const refs = c.scenario.seed.refs;
159 if (refs.length === 0) return ok(0);
160 const span = c.tracer.start('bench.seed.push', { parent, attrs: { 'bench.refs': refs.length } });
161 c.recorder.setPhase({ tag: 'seed' }, span);
162 const g = client(c, 'side', span, null);
163 if (!g.ok) { span.error(new Error(g.error.detail)).end(); return err(g.error.detail); }
164 const tips = seedTips(c.store, c.scenario);
165 if (!tips.ok) { span.end(); return tips; }
166 const commands = refs.map((r, i) => ({ ref: r.ref, oldOid: ZERO_OID, newOid: String(tips.value[i]) }));
167 const objs = reachable(c.store, tips.value).flatMap(o => {
168 const got = c.store.objects.get(o);
169 return typeof got === 'object' ? [got] : [];
170 });
171 const [first, ...rest] = commands;
172 if (typeof first !== 'object') { span.end(); return ok(0); }
173 const r = await g.value.push({ commands: [first, ...rest], objects: asPackObjects(objs) });
174 if (!r.ok) { span.error(new Error(r.error.message)).end(); return err(`seed push: ${r.error.code}: ${r.error.message}`); }
175 span.set({ 'bench.objects': objs.length }).ok().end();
176 return ok(objs.length);
177}
179async function runStep(c: Ctx, i: number, steps: readonly StepObservation[], span: Span): Promise<StepObservation> {
180 const st = c.scenario.steps[i];
181 if (typeof st !== 'object') return { outcomes: [{ outcome: 'rejected', error: 'harness', detail: 'no such step' }] };
182 switch (st.tag) {
183 case 'push':
184 case 'fetch': {
185 if (st.tag === 'push' && st.ply.tag === 'none') return { outcomes: [{ outcome: 'landed', error: 'skipped', detail: st.ply.why }] };
186 const f = st.fault;
187 if (f.tag !== 'none') c.recorder.arm({ fault: f, on: st.tag === 'push' ? 'receive' : 'fetch', race: async () => (f.tag === 'race' ? sideMove(c, f, span) : 0) });
188 const r = st.tag === 'fetch' ? await plyFetch(c, st.want, st.timeouts, span) : await plyPush(c, st.push, st.from, st.timeouts, span);
189 const unfired = c.recorder.disarm();
190 return { outcomes: [{ outcome: r.outcome, error: r.error, detail: unfired ? `fault ${f.tag} never fired; ${r.detail}` : r.detail }] };
191 }
192 case 'retry-unlanded': {
193 const prev = c.scenario.steps[st.of];
194 const seen = steps[st.of];
195 const pushes = typeof prev === 'object' && prev.tag === 'concurrent' ? prev.pushes : [];
196 const outcomes: Array<StepObservation['outcomes'][number]> = [];
197 for (const [k, p] of pushes.entries()) {
198 const firstTry = typeof seen === 'object' ? seen.outcomes[k] : null;
199 if (typeof firstTry === 'object' && firstTry !== null && firstTry.outcome === 'landed') { outcomes.push({ outcome: 'landed', error: null, detail: 'landed the first time' }); continue; }
200 const r = await plyPush(c, p, { tag: 'full' }, null, span);
201 outcomes.push({ outcome: r.outcome, error: r.error, detail: `retry after ${typeof firstTry === 'object' && firstTry !== null ? firstTry.outcome : '?'}: ${r.detail}` });
202 }
203 const [o0, ...more] = outcomes;
204 return typeof o0 === 'object' ? { outcomes: [o0, ...more] } : { outcomes: [{ outcome: 'landed', error: null, detail: 'nothing to retry' }] };
205 }
206 case 'concurrent': {
207 const rs = await Promise.all(st.pushes.map(async p => plyPush(c, p, { tag: 'full' }, null, span)));
208 const [o0, ...more] = rs.map(r => ({ outcome: r.outcome, error: r.error, detail: r.detail }));
209 return typeof o0 === 'object' ? { outcomes: [o0, ...more] } : { outcomes: [{ outcome: 'landed', error: null, detail: 'no push' }] };
210 }
211 }
212}
214async function cleanup(deps: RunDeps, c: Ctx, name: RepoName, parent: Span): Promise<Cleanup> {
215 const span = deps.tracer.start('bench.cleanup', { parent, attrs: { 'artifacts.repo': name } });
216 c.recorder.setPhase({ tag: 'cleanup' }, span);
217 const errors: string[] = [];
218 let listed = 0;
219 let revoked = 0;
220 try {
221 const repo = await deps.repos.get(name);
222 const tokens = await repo.listTokens();
223 listed = tokens.tokens.length;
224 for (const t of tokens.tokens) {
225 const s = deps.tracer.start('bench.token.revoke', { parent: span, attrs: { 'artifacts.token.state': t.state } });
226 if (t.state === 'active' && (await repo.revokeToken(t.id))) revoked++;
227 s.end();
228 }
229 } catch (e) { errors.push(`revoke: ${errText(e)}`); }
230 let status: number | null = null;
231 let ray = 'no_response';
232 const probe = deps.tracer.start('bench.token.probe', { parent: span });
233 try {
234 const before = c.recorder.exchanges.length;
235 const res = await c.recorder.fetchFor('judge')(`${c.remote}/info/refs?service=git-upload-pack`, { headers: { authorization: `Bearer ${c.token}`, 'git-protocol': 'version=2' } });
236 await res.arrayBuffer();
237 status = res.status;
238 const x = c.recorder.exchanges[before];
239 ray = typeof x === 'object' ? renderRay(x.cfRay) : ray;
240 } catch (e) { errors.push(`probe: ${errText(e)}`); }
241 probe.set({ 'http.response.status_code': status === null ? -1 : status, 'cf.ray': ray }).end();
242 let deleted = false;
243 try { deleted = await deps.repos.delete(name); } catch (e) { errors.push(`delete: ${errText(e)}`); }
244 let gone = false;
245 try { await deps.repos.get(name); } catch (e) { gone = /NOT_FOUND|not found/i.test(errText(e)) || (typeof e === 'object' && e !== null && 'code' in e && e.code === 'NOT_FOUND'); }
246 const refused = status !== null && REVOKED.has(status);
247 span.set({ 'bench.tokens.listed': listed, 'bench.tokens.revoked': revoked, 'bench.revoked.status': status === null ? -1 : status, 'bench.repo.deleted': deleted, 'bench.repo.gone': gone });
248 if (refused && deleted && gone) span.ok(); else span.error(new Error(`cleanup incomplete: refused=${refused} deleted=${deleted} gone=${gone}`));
249 span.end();
250 return { tokensListed: listed, tokensRevoked: revoked, revokedStatus: status, revokedRay: ray, refused, deleted, gone, errors };
251}
253const NO_CLEANUP: Cleanup = { tokensListed: 0, tokensRevoked: 0, revokedStatus: null, revokedRay: 'no_response', refused: false, deleted: false, gone: false, errors: ['the repository was never created'] };
255export async function runLive(deps: RunDeps, scenario: Scenario, seed: RunSeed, name: RepoName): Promise<RunResult> {
256 const t0 = Date.now();
257 const root = deps.tracer.start('bench.run', { parent: deps.parent, attrs: { 'probe.scenario': scenario.id, 'bench.seed': seed, 'artifacts.repo': name } });
258 const fail = (stage: 'seed' | 'step' | 'judge', message: string): RunVerdict => ({ tag: 'harness', stage, message });
259 const built = await deps.tracer.span('bench.seed.build', { parent: root }, async s => { const r = await buildSeed(scenario.seed); s.set({ 'bench.objects': r.ok ? r.value.objects.size : 0 }); return r; });
260 if (!built.ok) {
261 root.error(new Error(built.error)).end();
262 return { steps: [], end: null, names: {}, exchanges: [], verdict: fail('seed', built.error), cleanup: NO_CLEANUP, remote: '' };
263 }
264 const store = built.value;
265 const created = deps.tracer.start('bench.repo.create', { parent: root, attrs: { 'artifacts.repo': name } });
266 let made: { readonly remote: string; readonly token: string };
267 try {
268 made = await deps.repos.create(name);
269 await deps.created(name);
270 created.ok().end();
271 } catch (e) {
272 created.error(e).end();
273 root.error(e).end();
274 return { steps: [], end: null, names: store.byOid, exchanges: [], verdict: fail('seed', `create: ${errText(e)}`), cleanup: NO_CLEANUP, remote: '' };
275 }
276 const token = made.token;
277 const recorder = createRecorder({ upstream: deps.upstream, now: () => Date.now() - t0, scrub: (s: string) => s.split(token).join('[token]'), tracer: deps.tracer, keepBodies: deps.keepBodies });
278 const c: Ctx = { store, scenario, recorder, remote: made.remote, token, tracer: deps.tracer };
279 const steps: StepObservation[] = [];
280 let verdict: RunVerdict = fail('step', 'not run');
281 let end: EndState | null = null;
282 try {
283 const seeded = await seedRepo(c, root);
284 if (!seeded.ok) verdict = fail('seed', seeded.error);
285 else {
286 for (const [i, step] of scenario.steps.entries()) {
287 const span = deps.tracer.start('bench.step', { parent: root, attrs: { 'probe.step': i, 'probe.step.kind': step.tag } });
288 recorder.setPhase({ tag: 'step', index: i }, span);
289 const before = recorder.exchanges.length;
290 const o = await runStep(c, i, steps, span);
291 const xs = recorder.exchanges.slice(before);
292 span.set({ 'probe.outcomes': o.outcomes.map(x => x.outcome).join(','), 'probe.errors': o.outcomes.map(x => String(x.error)).join(','), 'probe.exchanges': xs.length, 'probe.cf_rays': xs.map(x => renderRay(x.cfRay)).join(',') }).end();
293 steps.push(o);
294 }
295 const js = deps.tracer.start('bench.judge', { parent: root });
296 recorder.setPhase({ tag: 'judge' }, js);
297 const g = client(c, 'judge', js, null);
298 const judged = g.ok ? await readEnd(g.value) : err(g.error.detail);
299 if (judged.ok) {
300 end = judged.value.end;
301 js.set({ 'probe.refs': Object.keys(end.refs).length, 'probe.objects': end.objects.length }).ok().end();
302 const obs: Observation = { steps, end };
303 verdict = verdictOf(scenario, obs, store.byOid, recorder.exchanges);
304 } else {
305 js.error(new Error(judged.error)).end();
306 verdict = fail('judge', judged.error);
307 }
308 }
309 } catch (e) {
310 verdict = fail('step', errText(e));
311 }
312 const cleaned = await cleanup(deps, c, name, root);
313 root.set({ 'bench.verdict': verdict.tag, 'bench.exchanges': recorder.exchanges.length, 'bench.cleanup.ok': cleaned.refused && cleaned.deleted && cleaned.gone });
314 if (verdict.tag === 'harness') root.error(new Error(verdict.message)); else root.ok();
315 root.end();
316 return { steps, end, names: store.byOid, exchanges: recorder.exchanges, verdict, cleanup: cleaned, remote: made.remote };
317}
Diagnostics4 git calls · 357 ms
CallStatusSizeTime0357 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=152 git.server.agent=gitty/1.0 git.server.object_format=sha1 git.server.caps=agent ls-refs fetch object-format git.server.fetch=shallow filter sideband-all git.protocol.version=2 git.pkt.frames=8 git.pkt.data=6 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=152 git.pkt.payload.max=34
ls-refs200145 B3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=145 git.response.cache=UPDATING git.response.duration_ms=3 git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=145 git.pkt.payload.max=76 git.ls_refs.count=2 git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020040 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=41349 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=blob:none git.fetch.filter.requested=tree:0 git.fetch.filter.fallback=blob:none git.fetch.filter.learned=false git.fetch.wants=526b305930b8ef382f2d7a1f9c0238730a585921 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=41349 git.pkt.payload.max=41254 git.sideband.band1.bytes=41253 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=61 git.pack.bytes=41253 git.pack.ofs_delta=0 git.pack.ref_delta=0 git.pack.chain.max=0 git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c git.pack.full=61Open pack map
fetch2005.6 KiB352 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=351 git.response.bytes=5731 git.response.cache=MISS git.response.duration_ms=352 git.fetch.wants=40241eba5570e83ca793ee2590b352cc51dc3738 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=3 git.pkt.data=2 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=5731 git.pkt.payload.max=5710 git.sideband.band1.bytes=5709 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply-web.git
- Ref
- refs/heads/main
- Commit
- 526b305930b8ef382f2d7a1f9c0238730a585921
- cf-ray
- a5e2f7f55a933a24
- Request
- fdfb44d1…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format