GitHubivarvong
ply
main
1// Protocol product-space fuzz: wants × haves × deepen/deepen-since/deepen-not × filter × thin × ofs-delta ×
2// done/negotiate × client shallow state × server pack settings, on generated DAG repos, against real git.
3// Oracle: the object model read back from git + the exact expected-set rules calibrated in dag.js.
4// node test/fuzz/protocol.mjs [--n 300] [--seed 1] [--case <seed>]
5import { treeClosure } from './dag.js';
6import { join } from 'node:path';
7import { mkdirSync, rmSync } from 'node:fs';
8import { git, gitBuf, tmpRoot, makeBareRepo, startGitServer } from '../server.js';
9import { genDag, readModel, expectedObjects, requiredAndHad } from './dag.js';
10import { packObjectsOracle, reconstructFor } from './packobjects.js';
11import { Rng } from './prng.js';
12import { GitHttp } from '../../src/client.js';
13import { Tracer, arrayExporter, flattenLine } from '../../src/otel.js';
14import { TYPE_NAME } from '../../src/objects.js';
16const args = Object.fromEntries(process.argv.slice(2).map((a, i, arr) => a.startsWith('--') ? [a.slice(2), arr[i + 1] ?? true] : []).filter(x => x.length));
17const N = parseInt(args.n ?? '200', 10), SEED = parseInt(args.seed ?? String(Date.now() % 1e9), 10), ONLY = args.case ? parseInt(args.case, 10) : null;
18// The run seed, before any case: a clock-seeded run is replayable only if it says which seed the clock gave (#308).
19console.log(`protocol: seed ${SEED}, n ${N} replay: node --import ./test/ts-resolve.mjs test/fuzz/protocol.mjs --n ${N} --seed ${SEED}`);
21const { root, cleanup } = tmpRoot();
22// capture the real pack-objects invocation through uploadpack.packObjectsHook (honored from protected config only)
23import { writeFileSync, readFileSync } from 'node:fs';
24import { fileURLToPath } from 'node:url';
25import { unwrap, unwrapAsync } from '../unwrap.js';
26const hookCfg = join(root, 'gitconfig'); const hookLog = join(root, 'hooklog');
27writeFileSync(hookCfg, `[uploadpack]\n\tpackObjectsHook = ${fileURLToPath(new URL('./pack-objects-hook.sh', import.meta.url))}\n`);
28const srv = await startGitServer(root, { GIT_CONFIG_GLOBAL: hookCfg, PLY_HOOK_LOG: hookLog });
29const repos = new Map(); // seed → {model, dag, name}
30function repoFor(rng) {
31 const key = rng.int(0, 5);
32 if (repos.has(key)) return repos.get(key);
33 const r = new Rng(1000 + key);
34 const name = `dag${key}`;
35 const bare = makeBareRepo(root, name);
36 const work = join(root, `w${name}`); mkdirSync(work);
37 const dag = genDag(r, work, { commits: r.int(6, 24), branches: r.int(2, 4) });
38 git(work, ['push', '-q', '--all', bare]); git(work, ['push', '-q', '--tags', bare]);
39 const pack = { window: r.pick([0, 1, 10, 250]), depth: r.pick([0, 1, 5, 50]), compression: r.pick([0, 1, 6, 9]) };
40 for (const [k, v] of Object.entries(pack)) git(bare, ['config', `pack.${k}`, String(v)]);
41 git(bare, ['config', 'uploadpack.allowFilter', 'true']);
42 const gc = r.bool(0.6); if (gc) git(bare, ['gc', '-q']); // gc on a bare repo writes a bitmap index: a different object-selection path
43 const useBitmaps = gc && r.bool(0.7); git(bare, ['config', 'pack.useBitmaps', String(useBitmaps)]);
44 const model = readModel(bare);
45 const rec = { model, dag, name, bare, pack, key, allOids: [...model.type.keys()], bitmap: useBitmaps, gc };
46 repos.set(key, rec);
47 return rec;
48}
50const cov = new Map();
51const fails = [];
52const seeds = ONLY !== null ? [ONLY] : Array.from({ length: N }, (_, i) => (SEED * 7919 + i * 104729) >>> 0);
53try {
54 for (let i = 0; i < seeds.length; i++) {
55 const rng = new Rng(seeds[i]);
56 const R = repoFor(rng);
57 const { model, dag } = R;
58 const commits = [...model.commits.keys()];
59 const blobs = R.allOids.filter(o => model.type.get(o) === 'blob'), trees = R.allOids.filter(o => model.type.get(o) === 'tree');
60 const tagOid = model.refs.get('refs/tags/v1');
61 const pickWant = () => rng.weighted([[rng.pick(commits), 6], [dag.tip, 3], [tagOid, 1], [rng.pick(trees), 1], [rng.pick(blobs), 1]]);
62 const wants = Array.from(new Set(Array.from({ length: rng.weighted([[1, 6], [2, 2], [3, 1]]) }, pickWant)));
63 const pickHave = () => rng.weighted([[rng.pick(commits), 6], ['f'.repeat(39) + rng.int(0, 9), 1], [wants[0], 1], [tagOid, 1], [rng.pick(blobs), 1]]);
64 const haves = Array.from(new Set(Array.from({ length: rng.weighted([[0, 4], [1, 3], [2, 2], [4, 1], [8, 1]]) }, pickHave)));
65 const deepen = rng.weighted([[undefined, 5], [1, 2], [2, 2], [3, 1], [5, 1], [50, 1]]);
66 const deepenSince = deepen === undefined && rng.bool(0.15) ? 1700000000 + rng.int(0, 24) * 1000 - 500 : undefined;
67 const deepenNot = deepen === undefined && !deepenSince && rng.bool(0.15) ? [rng.pick([...model.refs.keys()])] : [];
68 const filters = [undefined, 'blob:none', `blob:limit=${rng.pick([0, 1, 100, 1000, 5000])}`, `tree:${rng.int(0, 4)}`];
69 let filter = rng.weighted([[filters[0], 4], [filters[1], 2], [filters[2], 2], [filters[3], 2], ['combine', 1]]);
70 if (filter === 'combine') filter = `combine:${rng.pick(filters.slice(1))}+${rng.pick(filters.slice(1))}`;
71 const thinPack = rng.bool(0.3), ofsDelta = rng.bool(0.7), done = rng.bool(0.75);
72 // client shallow state: declare some commits shallow (we "have" them but not their parents)
73 const shallow = haves.filter(h => model.commits.has(h)).filter(() => rng.bool(0.25));
74 const req = { wants, haves, deepen, deepenSince, deepenNot, filter, thinPack, ofsDelta, done, shallows: shallow };
75 const exp = expectedObjects(model, { wants, haves, deepen, deepenSince, deepenNot, filter, shallow, bitmap: R.bitmap, thinPack });
76 // degenerate deepen-since/not: a want older than since, a want cut by deepen-not, or no commit wants at all.
77 // git 2.43 upload-pack either dies mid-response or applies rev-list slop semantics we do not model.
78 const wantCommits = wants.map(w => model.tags.get(w) ?? w).filter(w => model.commits.has(w));
79 const degenerate = (deepenSince || deepenNot.length) && (wantCommits.length === 0 || wantCommits.some(w => (deepenSince && model.commits.get(w).date < deepenSince) || (deepenNot.length && !exp.inDepth.has(w))));
80 const exporter = arrayExporter();
81 const c = unwrap(GitHttp.create(`${srv.url}/${R.name}.git`, { tracer: new Tracer({ exporter }) }));
82 const external = oid => (model.type.has(oid) ? { type: { blob: 3, tree: 2, commit: 1, tag: 4 }[model.type.get(oid)], data: new Uint8Array(gitBuf(R.bare, ['cat-file', model.type.get(oid), oid])) } : undefined);
83 const problems = [];
84 let r, usedNegotiate = false;
85 const t0 = performance.now();
86 try {
87 r = done ? await unwrapAsync(c.fetchPack(req, { external })) : await unwrapAsync(c.negotiate(req, { external }));
88 usedNegotiate = !done;
89 if (!r.parsed) throw Object.assign(new Error(`no pack (acks=${r.acks} nak=${r.nak})`), { code: 'nopack' });
90 } catch (e) {
91 r = null;
92 // the only legitimate server refusals: want of an object the server will not serve, or deepen on non-commits
93 const legit = e.code === 'remote_error';
94 // git 2.43 upload-pack dies mid-response (after "shallow-info") for deepen-since combined with client shallow lines
95 const serverCrash = e.code === 'protocol' && /without flush/.test(e.message) && degenerate;
96 problems.push(`${legit ? 'remote refused' : serverCrash ? 'server crash (known)' : 'ERROR'}: ${e.code} ${e.message.slice(0, 140)}`);
97 if (legit || serverCrash) { cov.set(legit ? 'remote_error' : 'server_crash.deepen_since+shallow', (cov.get(legit ? 'remote_error' : 'server_crash.deepen_since+shallow') ?? 0) + 1); problems.length = 0; }
98 }
99 const ms = performance.now() - t0;
100 if (r && degenerate) { cov.set('degenerate_deepen.pack', (cov.get('degenerate_deepen.pack') ?? 0) + 1); }
101 else if (r) {
102 const got = new Set(r.objects.keys());
103 // (1) two-sided bound from the model: everything required is present; every extra is something the client has
104 const bound = requiredAndHad(model, { wants, haves, deepen, deepenSince, deepenNot, filter, shallow, bitmap: R.bitmap });
105 const missingReq = [...bound.required].filter(o => !got.has(o)), extraNotHad = [...got].filter(o => !bound.required.has(o) && !bound.had.has(o));
106 if (missingReq.length) problems.push(`BOUND: ${missingReq.length} required objects missing [${missingReq.slice(0, 3).map(o => model.type.get(o)).join(',')}]`);
107 if (missingReq.length && process.env.PROTO_DEBUG) {
108 const where = o => { const out = []; for (const w of wants) { const roots = model.commits.has(w) ? [model.commits.get(w).tree] : model.type.get(w) === 'tree' ? [w] : []; for (const r of roots) { const d = treeClosure(model, [r]).get(o); if (d !== undefined) out.push(`${w.slice(0, 7)}(${model.type.get(w)})@${d}`); } } return out.join(' '); };
109 console.log(' haves:', haves.map(h => `${h.slice(0, 7)}:${model.type.get(h)}`).join(' '), ' wants:', wants.map(w => `${w.slice(0, 7)}:${model.type.get(w)}`).join(' '));
110 for (const o of missingReq) console.log(` missing ${o.slice(0, 7)} ${model.type.get(o)} reachable via ${where(o)}; had? ${bound.had.has(o)}`);
111 const rl = extra => git(R.bare, ['rev-list', '--objects', `--filter=${filter}`, ...wants, ...extra]).toString();
112 for (const o of missingReq) console.log(` rev-list ${o.slice(0, 7)}: no-have=${rl([]).includes(o)} with ^have=${rl(['--not', ...haves]).includes(o)}`);
113 for (const h of haves) if (model.type.get(h) === 'tree') console.log(` have-tree ${h.slice(0,7)} contains: ${[...treeClosure(model, [h]).entries()].map(([o, d]) => o.slice(0, 7) + '@' + d).join(' ')}`);
114 }
115 if (extraNotHad.length) problems.push(`BOUND: ${extraNotHad.length} extra objects the client does not have [${extraNotHad.slice(0, 3).map(o => model.type.get(o)).join(',')}]`);
116 // (2) the calibrated model (bitmap vs traversal rules); a mismatch here is a modeling gap, reported but weaker
117 const missing = [...exp.objects].filter(o => !got.has(o)), extra = [...got].filter(o => !exp.objects.has(o));
118 const modelOk = !missing.length && !extra.length;
119 cov.set(`model.${exp.mode}.${modelOk ? 'exact' : 'approx'}`, (cov.get(`model.${exp.mode}.${modelOk ? 'exact' : 'approx'}`) ?? 0) + 1);
120 // (3) exact oracle: pack-objects invoked as upload-pack does → identical object set
121 { // pack-objects run in the same repo takes the same bitmap/traversal decision upload-pack does
122 // grafts registered for this request: every client shallow (send_unshallow re-registers even the unshallowed ones), plus the new boundary
123 const shallowSet = new Set([...shallow.filter(c => model.commits.has(c)), ...bound.boundary]);
124 try {
125 const o = packObjectsOracle(R.bare, model, req, { shallowSet, unshallowed: bound.unshallow, inDepth: bound.inDepth, external });
126 const oMissing = [...o.objects.keys()].filter(x => !got.has(x)), oExtra = [...got].filter(x => !o.objects.has(x));
127 if (oMissing.length || oExtra.length) problems.push(`ORACLE: pack-objects set differs: oracle-only ${oMissing.length} [${oMissing.slice(0, 3).map(x => model.type.get(x)).join(',')}] fetch-only ${oExtra.length} [${oExtra.slice(0, 3).map(x => model.type.get(x)).join(',')}]`);
128 else cov.set(`oracle.exact.${exp.mode}`, (cov.get(`oracle.exact.${exp.mode}`) ?? 0) + 1);
129 // and the invocation itself: what upload-pack actually ran vs what we reconstruct from the model
130 try {
131 const realArgs = readFileSync(hookLog + '.args', 'utf8').trim().replace(/^git --shallow-file \S* pack-objects /, '').replace(/^git pack-objects /, '');
132 const realStdin = readFileSync(hookLog + '.stdin', 'utf8');
133 const mine = reconstructFor(model, req, { shallowSet, unshallowed: bound.unshallow });
134 // compare modulo duplicate entries: send_unshallow's re-parse may list a parent twice depending on in-memory parse state
135 const norm = t => { const lines = t.trim().split('\n'); const i = lines.indexOf('--not'); const uniq = a => [...new Set(a)].sort(); return JSON.stringify([uniq(lines.slice(0, i).filter(l => l.startsWith('--shallow'))), uniq(lines.slice(0, i).filter(l => !l.startsWith('--shallow'))), uniq(lines.slice(i + 1).filter(Boolean))]); };
136 if (realArgs !== mine.args.join(' ') || norm(realStdin) !== norm(mine.stdin)) problems.push(`INVOCATION differs:\n real: ${realArgs} | ${realStdin.trim().split('\n').join(' | ')}\n mine: ${mine.args.join(' ')} | ${mine.stdin.trim().split('\n').join(' | ')}`);
137 else cov.set('invocation.exact', (cov.get('invocation.exact') ?? 0) + 1);
138 } catch (e) { problems.push(`INVOCATION capture failed: ${e.message}`); }
139 } catch (e) { problems.push(`ORACLE failed: ${e.message.slice(0, 120)}`); }
140 }
141 for (const [oid, o] of r.objects) {
142 if (TYPE_NAME[o.type] !== model.type.get(oid)) { problems.push(`type ${oid}`); break; }
143 if (o.data.length !== model.size.get(oid)) { problems.push(`size ${oid}`); break; }
144 if (rng.bool(0.2) && !Buffer.from(o.data).equals(gitBuf(R.bare, ['cat-file', model.type.get(oid), oid]))) { problems.push(`content ${oid}`); break; }
145 }
146 if (deepen !== undefined || deepenSince || deepenNot.length) {
147 const gotShallow = [...r.shallow].sort(), gotUn = [...r.unshallow].sort();
148 if (gotShallow.join() !== exp.shallow.join()) problems.push(`shallow lines got ${gotShallow.length} exp ${exp.shallow.length}`);
149 if (gotUn.join() !== exp.unshallow.join()) problems.push(`unshallow lines got ${gotUn.length} exp ${exp.unshallow.length}`);
150 } else if (r.shallow.length || r.unshallow.length) problems.push('shallow lines without deepen');
151 if (!ofsDelta && r.parsed.stats.ofsDelta) problems.push('ofs delta despite not requested');
152 if (!thinPack && r.resolved.stats.externalBases) problems.push('external base in non-thin pack');
153 if (thinPack && r.resolved.stats.externalBases) {
154 // client safety: every thin base must be resolvable from what the client declared it has (full closure of haves)
155 for (const [, o] of r.objects) { const baseOid = o.packBase.tag === 'ref' ? o.packBase.oid : null; if (baseOid && !r.objects.has(baseOid) && !bound.had.has(baseOid)) { problems.push(`thin base ${baseOid.slice(0, 8)} (${model.type.get(baseOid)}) not derivable from the client's haves`); break; } }
156 }
157 if (R.pack.depth && r.resolved.stats.maxChain > R.pack.depth) problems.push(`chain ${r.resolved.stats.maxChain} > pack.depth ${R.pack.depth}`);
158 const span = exporter.lines.flatMap(flattenLine).filter(s => s.name === 'git.upload-pack fetch').pop();
159 if (span.attrs['git.pack.objects'] !== got.size) problems.push('span object count');
160 // negotiation: acks ⊆ haves the server has; a NAK round means no common
161 if (usedNegotiate) {
162 const known = new Set(haves.filter(h => model.type.has(h)));
163 for (const rd of r.rounds) for (const a of rd.acks) if (!known.has(a)) problems.push(`ack for unknown ${a.slice(0, 8)}`);
164 if (r.rounds.some(rd => rd.nak && rd.acks.length)) problems.push('NAK with acks');
165 }
166 // coverage
167 const b = [`wants.${wants.length}`, `haves.${Math.min(haves.length, 4)}`, `deepen.${deepen ?? (deepenSince ? 'since' : deepenNot.length ? 'not' : 'none')}`, `filter.${(filter ?? 'none').replace(/=\d+/, '').replace(/:\d/, ':N')}`, `thin.${thinPack}`, `ofs.${ofsDelta}`, `done.${done}`, `shallow.${shallow.length > 0}`, `want_types.${[...new Set(wants.map(w => model.type.get(w)))].sort().join('+')}`, `pack.depth.${R.pack.depth}`, `pack.window.${R.pack.window}`, `chain.${Math.min(r.resolved.stats.maxChain, 5)}`, `objects.${got.size === 0 ? 0 : 2 ** Math.floor(Math.log2(got.size))}`, `ext_bases.${r.resolved.stats.externalBases > 0}`, `shallow_lines.${r.shallow.length > 0}`, `mode.${exp.mode}`, `server.${R.gc ? (R.bitmap ? 'bitmap' : 'packed') : 'loose'}`, `unshallow_lines.${r.unshallow.length > 0}`, ...(usedNegotiate ? [`rounds.${r.rounds.length}`, `ready.${r.ready}`, `nak.${r.rounds.some(x => x.nak)}`] : [])];
168 for (const x of b) cov.set(x, (cov.get(x) ?? 0) + 1);
169 }
170 const tag = problems.length ? 'FAIL' : 'ok ';
171 process.stdout.write(`${tag} #${String(i).padStart(3)} seed=${seeds[i]} repo=${R.key}${R.bitmap ? 'B' : R.gc ? 'P' : 'L'} w=${wants.length}${wants.map(w => model.type.get(w)[0]).join('')} h=${haves.length} ${deepen !== undefined ? 'd' + deepen : deepenSince ? 'since' : deepenNot.length ? 'not' : ' '} ${(filter ?? '-').padEnd(26)} ${thinPack ? 'thin' : ' '} ${ofsDelta ? 'ofs' : 'ref'} ${done ? 'done' : 'nego'} ${shallow.length ? 'sh' + shallow.length : ' '} → ${r ? r.parsed.stats.count : '-'} obj ${String(ms | 0).padStart(4)}ms\n`);
172 if (problems.length) {
173 fails.push(seeds[i]);
174 const idx = o => { const k = dag.commitOids.indexOf(o); return k >= 0 ? 'c' + k : (model.type.get(o)?.[0] ?? '?') + o.slice(0, 6); };
175 console.log(' ' + problems.join('\n ') + `\n repro: node test/fuzz/protocol.mjs --case ${seeds[i]}`);
176 console.log(' graph:', [...model.commits.entries()].map(([c, v]) => `${idx(c)}(${(v.date - 1700000000) / 1000})←${v.parents.map(idx).join(',')}`).join(' '));
177 console.log(' req:', JSON.stringify({ wants: wants.map(idx), haves: haves.map(idx), deepen, deepenSince, deepenNot, filter, thinPack, ofsDelta, done, shallows: shallow.map(idx), mode: exp.mode, server: R.gc ? (R.bitmap ? 'bitmap' : 'packed') : 'loose' }));
178 if (r) {
179 const got = new Set(r.objects.keys());
180 console.log(' got commits:', [...got].filter(o => model.commits.has(o)).map(idx).join(' '), '| exp:', [...exp.objects].filter(o => model.commits.has(o)).map(idx).join(' '));
181 console.log(' missing:', [...exp.objects].filter(o => !got.has(o)).map(idx).join(' '), '| extra:', [...got].filter(o => !exp.objects.has(o)).map(idx).join(' '));
182 console.log(' shallow got:', r.shallow.map(idx), 'exp:', exp.shallow.map(idx), 'unshallow got:', r.unshallow.map(idx), 'exp:', exp.unshallow.map(idx));
183 console.log(' ext bases:', [...r.objects.values()].filter(o => o.packBase.tag === 'ref' && !r.objects.has(o.packBase.oid)).map(o => idx(o.packBase.oid)).join(' '));
184 } else {
185 const { fetchBody: fetchBodyR } = await import('../../src/client.js');
186 const res = await fetch(`${srv.url}/${R.name}.git/git-upload-pack`, { method: 'POST', headers: { 'Content-Type': 'application/x-git-upload-pack-request', 'Git-Protocol': 'version=2' }, body: fetchBodyR(req).value });
187 console.log(' raw:', res.status, JSON.stringify(Buffer.from(await res.arrayBuffer()).toString('latin1').slice(0, 200)));
188 }
189 }
190 }
191} finally { await srv.close(); cleanup(); }
192console.log(`\n${seeds.length} cases, ${fails.length} failures. Coverage (${cov.size} buckets):`);
193console.log([...cov.entries()].sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0])).map(([k, v]) => `${String(v).padStart(4)} ${k}`).join('\n'));
194process.exit(fails.length ? 1 : 0);
Diagnostics7 git calls · 211 ms
CallStatusSizeTime0211 ms
discover200191 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=191 git.server.agent=git/github-9922ec520325-Linux git.server.object_format=sha1 git.server.caps=agent ls-refs fetch server-option object-format git.server.fetch=shallow wait-for-done filter git.protocol.version=2 git.pkt.frames=9 git.pkt.data=7 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=191 git.pkt.payload.max=36
ls-refs20012 KiB98 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=95 git.response.bytes=11990 git.response.cache=EXPIRED git.response.duration_ms=95 git.protocol.version=2 git.pkt.frames=152 git.pkt.data=151 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=11990 git.pkt.payload.max=122 git.ls_refs.count=151 git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 102004.2 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=4347 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=19912563f540228593df0c489082e5e2508e21e4 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=7 git.pkt.data=5 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=4347 git.pkt.payload.max=4247 git.sideband.band1.bytes=4247 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=10 git.pack.bytes=4247 git.pack.ofs_delta=0 git.pack.ref_delta=0 git.pack.chain.max=0 git.pack.trailer=a6caf8e129bea82c9bae4cbc7c130c9205add400 git.pack.full=10Open pack map
fetchtree:0200919 B · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=919 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=800d30ba8923860bfc460ca884b7f9ba22083588 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=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=919 git.pkt.payload.max=892 git.sideband.band1.bytes=892 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=892 git.pack.trailer=5323b9266eea5ded637285d1c5320699f12be76eOpen pack map
fetchtree:02005.6 KiB · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=5724 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=58fabb6768b3f737ee9cd8bac647bdc27405fb4d 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=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=5724 git.pkt.payload.max=5697 git.sideband.band1.bytes=5697 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=5697 git.pack.trailer=be7e0453974a5fe832f9065a33bb7e3434c10e9bOpen pack map
fetchtree:0200853 B · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=853 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=fb781d4e4fd58ededa1f1078d937de6f4b1316a2 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=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=853 git.pkt.payload.max=826 git.sideband.band1.bytes=826 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=826 git.pack.trailer=c89bc485f6ad08d875fc515f3fdd69897096847bOpen pack map
fetch2006.6 KiB99 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=99 git.response.bytes=6729 git.response.cache=MISS git.response.duration_ms=99 git.fetch.wants=4fa1bad198859a9807da251fead67779d0aa6bd5 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=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=6729 git.pkt.payload.max=6702 git.sideband.band1.bytes=6702 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://github.com/ivarvong/ply
- Ref
- refs/heads/main
- Commit
- 19912563f540228593df0c489082e5e2508e21e4
- cf-ray
- a5e2a23ead5e1293
- Request
- 62911676…
- Protocol
- v2 · sha1
- Agent
- git/github-9922ec520325-Linux
- Filter
- advertised
- Fetch
- shallow wait-for-done filter
- Capabilities
- agent ls-refs fetch server-option object-format