main
1// #246: a host's own unpack failure. Cloudflare Artifacts answers a pack it cannot unpack with "unpack <reason>" and then
2// "ng <ref> <reason>" for every commanded ref, the same reason echoed (observed 2026-11-10 on prod: "invalid pack entry
3// type 0", "invalid zlib member", "pack stream incomplete at finish", "invalid pack signature"; plain and side-band;
4// one and two refs, atomic or not). That shape is a definite rejection (push_rejected, nothing moved), not ambiguous.
5// Every other non-git unpack status stays ambiguous (SPACE.md judgment 3): no ref lines, a ref line that does not echo
6// the status, or an "ok" beside it. A delete-only push answered with any unpack failure stays ambiguous (no pack sent).
7import { test } from 'vitest';
8import assert from 'node:assert/strict';
9import { classifyReport, decideOutcome, parseReceivePackTooLarge, push, ZERO_OID } from '../src/push.js';
10import { DEFAULT_LIMITS } from '../src/limits.js';
11import { pkt, FLUSH } from '../src/pktline.js';
12import { concat, te } from '../src/bytes.js';
13import { unwrap } from './unwrap.js';
15const A = 'refs/heads/a', B = 'refs/heads/b';
16const T0 = 'invalid pack entry type 0';
17const lines = (...ls) => ls.map(l => (typeof l === 'string' ? te.encode(l) : l));
18const cls = (ls, refs = [A]) => classifyReport(lines(...ls), refs.map(ref => ({ ref })));
19const ngs = (reason, ...refs) => refs.map(ref => ({ ref, ok: false, reason }));
21test('the echoed shape is unpackFailed and decides push_rejected; delete-only stays ambiguous', () => {
22 for (const reason of [T0, 'invalid zlib member', 'pack stream incomplete at finish', 'invalid pack signature']) {
23 const one = cls([`unpack ${reason}\n`, `ng ${A} ${reason}\n`]);
24 assert.deepEqual(one, { tag: 'unpackFailed', status: reason, refs: ngs(reason, A) });
25 assert.deepEqual(decideOutcome(one), { tag: 'rejected', code: 'push_rejected', refs: [{ ref: A, reason, cls: 'rejected' }] });
26 assert.deepEqual(decideOutcome(one, { atomic: true }).tag, 'rejected');
27 assert.deepEqual(decideOutcome(one, { pack: false }), { tag: 'ambiguous', why: 'unpack failed but no pack was sent' });
28 }
29 // two refs, in either order
30 assert.deepEqual(cls([`unpack ${T0}\n`, `ng ${B} ${T0}\n`, `ng ${A} ${T0}\n`], [A, B]), { tag: 'unpackFailed', status: T0, refs: ngs(T0, B, A) });
31 // git's own status with the echoed reasons is also an unpack failure
32 const git = 'index-pack abnormal exit';
33 assert.equal(cls([`unpack ${git}\n`, `ng ${A} ${git}\n`]).tag, 'unpackFailed');
34});
36test('a host status without the full echo is ambiguous', () => {
37 const why = (ls, refs) => { const s = cls(ls, refs); assert.equal(s.tag, 'malformed', JSON.stringify(s)); return s.why; };
38 // no ref lines at all, one ref missing, one ref not echoing, an "ok" beside it, git's "unpacker error" beside it
39 assert.equal(why([`unpack ${T0}\n`]), 'no git unpack line first');
40 assert.equal(why([`unpack ${T0}\n`, `ng ${A} ${T0}\n`], [A, B]), 'no git unpack line first');
41 assert.equal(why([`unpack ${T0}\n`, `ng ${A} ${T0}\n`, `ng ${B} stale ref\n`], [A, B]), 'no git unpack line first');
42 assert.equal(why([`unpack ${T0}\n`, `ng ${A} ${T0}\n`, `ok ${B}\n`], [A, B]), 'no git unpack line first');
43 assert.equal(why([`unpack ${T0}\n`, `ng ${A} unpacker error\n`]), 'no git unpack line first');
44 assert.equal(why([`unpack ${T0}\n`, `ok ${A}\n`]), 'no git unpack line first');
45 // a reason one byte off the status, and a status one byte off "ok" with ok lines (issue #33)
46 assert.equal(why([`unpack ${T0}\n`, `ng ${A} invalid pack entry type 1\n`]), 'no git unpack line first');
47 assert.equal(why(['unpack ok*\n', `ok ${A}\n`]), 'no git unpack line first');
48 // an unreadable or empty status is never a host's failure
49 assert.equal(why([concat([te.encode('unpack '), Uint8Array.of(0xff), te.encode('\n')]), `ng ${A} \udcff\n`]), 'no git unpack line first');
50 assert.equal(why(['unpack \n', `ng ${A} x\n`]), 'no git unpack line first');
51 // the ref lines are still checked as lines
52 assert.equal(why([`unpack ${T0}\n`, `ng refs/heads/zz ${T0}\n`]), 'status for a ref not commanded');
53 assert.equal(why([`unpack ${T0}\n`, `ng ${A} ${T0}\n`, `ng ${A} ${T0}\n`]), `two statuses for ${A}`);
54 // after "unpack ok" the same reason is an ordinary refusal
55 assert.deepEqual(decideOutcome(cls(['unpack ok\n', `ng ${A} ${T0}\n`])), { tag: 'rejected', code: 'push_rejected', refs: [{ ref: A, reason: T0, cls: 'rejected' }] });
56});
58// through push(): the bytes Artifacts sent on 2026-11-10, side-band and plain. A single-ref update is not read back.
59const tracerStub = { span: async (_n, _o, fn) => fn({ set() { return this; }, error() { return this; }, end() {} }) };
60const transportOf = (...frames) => {
61 const services = [];
62 return {
63 services,
64 t: {
65 limits: DEFAULT_LIMITS, tracer: tracerStub, parent: null,
66 async *frames(service) { services.push(service); for (const f of frames) yield f === null ? { kind: 'flush' } : { kind: 'data', payload: f }; },
67 },
68 };
69};
70const oid = n => n.toString(16).padStart(2, '0').repeat(20);
71const update = sideband => ({ commands: [{ ref: A, oldOid: oid(1), newOid: oid(3) }], sideband });
72// the band-1 payload Artifacts sent (its outer pkt "005c\x01…" and final flush are the transport's framing)
73// Built on first use inside a test, never while the file loads (#307): Stryker counts a src line reached during
74// module load as a static mutant and runs each mutant on it against the whole mutation suite instead of the tests
75// that cover it.
76let fixtureMemo = null;
77const fixture = () => (fixtureMemo ??= (() => {
78 const inner = concat([unwrap(pkt(`unpack ${T0}\n`)), unwrap(pkt(`ng ${A} ${T0}\n`)), FLUSH]);
79 return { inner };
80})());
82test('push(): Artifacts\' side-band and plain reports are push_rejected with the host\'s reason, no read-back', async () => {
83 const { inner } = fixture();
84 const cases = [
85 { sideband: true, frames: [concat([Uint8Array.of(1), inner]), null] },
86 { sideband: false, frames: [te.encode(`unpack ${T0}\n`), te.encode(`ng ${A} ${T0}\n`), null] },
87 ];
88 for (const c of cases) {
89 const { t, services } = transportOf(...c.frames);
90 const r = await push(t, update(c.sideband));
91 assert.equal(r.ok, false);
92 assert.equal(r.error.code, 'push_rejected', r.error.message);
93 assert.equal(r.error.message, `push rejected: ${T0}`);
94 assert.equal(r.error.report.tag, 'unpackFailed');
95 assert.equal(r.error.report.status, T0);
96 assert.deepEqual(services, ['git-receive-pack'], 'a definite answer reads nothing back');
97 }
98});
100test('push(): the same failure for a delete-only push is ambiguous', async () => {
101 const { inner } = fixture();
102 const { t } = transportOf(concat([Uint8Array.of(1), inner]), null);
103 const r = await push(t, { commands: [{ ref: A, oldOid: oid(1), newOid: ZERO_OID }], sideband: true });
104 assert.equal(r.ok, false);
105 assert.equal(r.error.code, 'ambiguous', r.error.message);
106});
108// #266: Artifacts refuses a shallow or disconnected push with a shorter ng reason than the unpack status.
109const MISSING_UNPACK = 'reachable object is missing';
110const MISSING_NG = 'missing object';
111const TOO_LARGE = 'artifacts_git_receive_pack_request_too_large: push is 286.3 MiB, limit is 64.0 MiB';
113test('Artifacts missing-object alias is unpackFailed and decides push_rejected; a one-byte-off reason stays ambiguous', () => {
114 const one = cls([`unpack ${MISSING_UNPACK}\n`, `ng ${A} ${MISSING_NG}\n`]);
115 assert.deepEqual(one, { tag: 'unpackFailed', status: MISSING_UNPACK, refs: ngs(MISSING_NG, A) });
116 assert.deepEqual(decideOutcome(one), { tag: 'rejected', code: 'push_rejected', refs: [{ ref: A, reason: MISSING_NG, cls: 'rejected' }] });
117 assert.deepEqual(decideOutcome(one, { atomic: true }).tag, 'rejected');
118 assert.deepEqual(decideOutcome(one, { pack: false }), { tag: 'ambiguous', why: 'unpack failed but no pack was sent' });
119 // two refs, both the alias
120 assert.deepEqual(cls([`unpack ${MISSING_UNPACK}\n`, `ng ${B} ${MISSING_NG}\n`, `ng ${A} ${MISSING_NG}\n`], [A, B]).tag, 'unpackFailed');
121 // a reason that is not the documented alias stays malformed (SPACE.md judgment 3)
122 assert.equal(cls([`unpack ${MISSING_UNPACK}\n`, `ng ${A} object is missing\n`]).tag, 'malformed');
123 assert.equal(cls([`unpack ${MISSING_UNPACK}\n`, `ng ${A} ${MISSING_UNPACK}\n`]).tag, 'unpackFailed');
124});
126test('push(): Artifacts missing-object reports are push_rejected, side-band and plain, no read-back', async () => {
127 const payload = concat([unwrap(pkt(`unpack ${MISSING_UNPACK}\n`)), unwrap(pkt(`ng ${A} ${MISSING_NG}\n`)), FLUSH]);
128 const cases = [
129 { sideband: true, frames: [concat([Uint8Array.of(1), payload]), null] },
130 { sideband: false, frames: [te.encode(`unpack ${MISSING_UNPACK}\n`), te.encode(`ng ${A} ${MISSING_NG}\n`), null] },
131 ];
132 for (const c of cases) {
133 const { t, services } = transportOf(...c.frames);
134 const r = await push(t, update(c.sideband));
135 assert.equal(r.ok, false);
136 assert.equal(r.error.code, 'push_rejected', r.error.message);
137 assert.equal(r.error.message, `push rejected: ${MISSING_NG}`);
138 assert.equal(r.error.report.tag, 'unpackFailed');
139 assert.equal(r.error.report.status, MISSING_UNPACK);
140 assert.deepEqual(services, ['git-receive-pack'], 'a definite answer reads nothing back');
141 }
142});
144test('Artifacts 64 MiB cap is limit_exceeded with got/max in bytes, not push_rejected or ambiguous', () => {
145 const one = cls([`unpack ${TOO_LARGE}\n`, `ng ${A} ${TOO_LARGE}\n`]);
146 assert.equal(one.tag, 'unpackFailed');
147 const decided = decideOutcome(one);
148 assert.deepEqual(decided, { tag: 'rejected', code: 'limit_exceeded', refs: [{ ref: A, reason: TOO_LARGE, cls: 'rejected' }] });
149 assert.equal(decideOutcome(one, { pack: false }).tag, 'ambiguous');
150});
152test('push(): Artifacts too-large report is limit_exceeded with the cap, side-band and plain, no read-back', async () => {
153 const payload = concat([unwrap(pkt(`unpack ${TOO_LARGE}\n`)), unwrap(pkt(`ng ${A} ${TOO_LARGE}\n`)), FLUSH]);
154 const cases = [
155 { sideband: true, frames: [concat([Uint8Array.of(1), payload]), null] },
156 { sideband: false, frames: [te.encode(`unpack ${TOO_LARGE}\n`), te.encode(`ng ${A} ${TOO_LARGE}\n`), null] },
157 ];
158 const wantGot = Math.round(286.3 * 1024 * 1024);
159 const wantMax = 64 * 1024 * 1024;
160 for (const c of cases) {
161 const { t, services } = transportOf(...c.frames);
162 const r = await push(t, update(c.sideband));
163 assert.equal(r.ok, false);
164 assert.equal(r.error.code, 'limit_exceeded', r.error.message);
165 assert.equal(r.error.what, 'receive-pack request');
166 assert.equal(r.error.got, wantGot);
167 assert.equal(r.error.max, wantMax);
168 assert.match(r.error.message, /64\.0 MiB/);
169 assert.equal(r.error.report.tag, 'unpackFailed');
170 assert.deepEqual(services, ['git-receive-pack'], 'a definite answer reads nothing back');
171 }
172});
174test('an empty receive-pack report stays ambiguous (concurrent same-repo 200 with no unpack/ref lines)', async () => {
175 // no frames at all: the body was empty (HTTP 200, no pkt-lines)
176 const empty = transportOf();
177 const none = await push(empty.t, update(true));
178 assert.equal(none.ok, false);
179 assert.equal(none.error.code, 'ambiguous', none.error.message);
180 // a flush before any report line (side-band or plain)
181 const flushed = transportOf(null);
182 const early = await push(flushed.t, update(true));
183 assert.equal(early.ok, false);
184 assert.equal(early.error.code, 'ambiguous', early.error.message);
185 const plain = transportOf(null);
186 const plainEmpty = await push(plain.t, update(false));
187 assert.equal(plainEmpty.ok, false);
188 assert.equal(plainEmpty.error.code, 'ambiguous');
189 // classifyReport of zero lines is still malformed, not a rejection
190 assert.deepEqual(decideOutcome(cls([])), { tag: 'ambiguous', why: 'no git unpack line first' });
191});
193// Review ec337c5 (push/too-large-regex-cubic-redos, hostile/too-large-regex-quadratic): the #266 pattern was
194// `[0-9]+[.]?[0-9]*` twice, so a digit run that never reaches " MiB" was split every possible way: quadratic for one
195// run (65,000 digits: 2.3 s), cubic for two (2,492 bytes: 12.9 s), on a reason any host writes in one pkt-line.
196// Host text is classified in time linear in its length. Proved by ratio, not by a clock threshold: 64 times the input
197// may cost at most 300 times the best run (linear is 64; quadratic 4,096; cubic 262,144).
198const HEAD = 'artifacts_git_receive_pack_request_too_large: push is ';
199const adversarial = [
200 ['one digit run, no " MiB"', n => HEAD + '1'.repeat(n)],
201 ['two digit runs, a wrong last byte', n => `${HEAD}${'1'.repeat(Math.floor(n / 3))} MiB, limit is ${'1'.repeat(n - Math.floor(n / 3))}X`],
202 ['digits and dots', n => `${HEAD}${'1.'.repeat(n / 2)} MiB, limit is 1 MiB`],
203];
204// ns per call, the best of `rounds` batches (the minimum is the run least disturbed by the machine)
205const best = (fn, batch, rounds) => {
206 let b = Infinity;
207 for (let i = 0; i < rounds; i++) {
208 const t0 = process.hrtime.bigint();
209 for (let j = 0; j < batch; j++) fn();
210 b = Math.min(b, Number(process.hrtime.bigint() - t0) / batch);
211 }
212 return b;
213};
214// a call that already takes over a millisecond is timed alone (the pre-fix pattern takes seconds); the verdict is the ratio
215const cost = fn => { const probe = best(fn, 1, 1); return probe > 1e6 ? Math.min(probe, best(fn, 1, 2)) : best(fn, 20, 9); };
216const SMALL = 1000, BIG = 64000, MAX_RATIO = 300;
218test('a host-written reason is classified in linear time: 64,000 adversarial digits cost under 300 times 1,000', { timeout: 120_000 }, () => {
219 for (const [name, make] of adversarial) {
220 const small = make(SMALL), big = make(BIG);
221 assert.equal(parseReceivePackTooLarge(big), null, name);
222 const direct = cost(() => parseReceivePackTooLarge(big)) / cost(() => parseReceivePackTooLarge(small));
223 assert.ok(direct < MAX_RATIO, `${name}: parseReceivePackTooLarge ${BIG} digits cost ${direct.toFixed(0)}x ${SMALL} digits`);
224 // the whole path a report line takes: reportStep's printable check, ngClass, rejectionCode, as ng and as an echoed unpack
225 const decide = reason => () => {
226 assert.equal(decideOutcome(cls([`unpack ok\n`, `ng ${A} ${reason}\n`])).code, 'push_rejected');
227 assert.equal(decideOutcome(cls([`unpack ${reason}\n`, `ng ${A} ${reason}\n`])).code, 'push_rejected');
228 };
229 const whole = cost(decide(big)) / cost(decide(small));
230 assert.ok(whole < MAX_RATIO, `${name}: classifyReport + decideOutcome ${BIG} digits cost ${whole.toFixed(0)}x ${SMALL} digits`);
231 }
232});
234test('parseReceivePackTooLarge: the observed Artifacts text parses to the same bytes; near misses and insane figures do not', () => {
235 // By hand, 1 MiB = 1,048,576 bytes: 286.3 MiB = 286 * 1,048,576 + 0.3 * 1,048,576 = 299,892,736 + 314,572.8
236 // = 300,207,308.8, rounded 300,207,309; 64.0 MiB = 67,108,864.
237 assert.deepEqual(parseReceivePackTooLarge(TOO_LARGE), { got: 300207309, max: 67108864 });
238 // whole MiB figures (no fraction): 65 * 1,048,576 = 68,157,440
239 assert.deepEqual(parseReceivePackTooLarge(`${HEAD}65 MiB, limit is 64 MiB`), { got: 68157440, max: 67108864 });
240 // 0.5 MiB = 524,288; 1.25 MiB = 1,310,720
241 assert.deepEqual(parseReceivePackTooLarge(`${HEAD}1.25 MiB, limit is 0.5 MiB`), { got: 1310720, max: 524288 });
242 const no = [
243 '', HEAD, `${HEAD} MiB, limit is MiB`, `${HEAD}286.3 MiB, limit is 64.0 MiB `, ` ${TOO_LARGE}`, `${TOO_LARGE}\n`, TOO_LARGE.replace('MiB,', 'GiB,'),
244 `${HEAD}286.3 MiB, limit is 64.0`, `${HEAD}.3 MiB, limit is 64.0 MiB`, `${HEAD}286. MiB, limit is 64.0 MiB`, `${HEAD}2.8.6 MiB, limit is 64.0 MiB`,
245 `${HEAD}-1 MiB, limit is 64.0 MiB`, `${HEAD}1e3 MiB, limit is 64.0 MiB`, `${HEAD}Infinity MiB, limit is 64.0 MiB`, `${HEAD}0x10 MiB, limit is 64.0 MiB`,
246 // a limit of nothing is not a size cap
247 `${HEAD}286.3 MiB, limit is 0 MiB`, `${HEAD}286.3 MiB, limit is 0.0 MiB`,
248 // more digits than any byte count ply can hold exactly: 10^10 MiB is over 2^53 bytes
249 `${HEAD}10000000000 MiB, limit is 64.0 MiB`, `${HEAD}286.3 MiB, limit is ${'9'.repeat(400)} MiB`,
250 // 300 leading zeros: more than the 9 integer digits a figure may have
251 `${HEAD}${'0'.repeat(300)}286.3 MiB, limit is 64.0 MiB`,
252 // the second figure's unit is checked too: the last four characters are ' MiB' and nothing else
253 `${HEAD}286.3 MiB, limit is 64.0 GiB`, `${HEAD}286.3 MiB, limit is 64.0 KiB`, `${HEAD}286.3 MiB, limit is 64.0 mib`, `${HEAD}286.3 MiB, limit is 64.0XXXX`,
254 `${HEAD}286.3 MiB, limit is 64.0MiB `, `${HEAD}286.3 MiB, limit is 64.0 MiB, limit is 64.0 GiB`,
255 // the first 54 characters are the head and nothing else: the same length with one word, one letter or the code changed
256 TOO_LARGE.replace('push is', 'pull is'), TOO_LARGE.replace('artifacts_git', 'Artifacts_git'), TOO_LARGE.replace('too_large:', 'too_small:'),
257 `${'x'.repeat(HEAD.length)}286.3 MiB, limit is 64.0 MiB`, `${HEAD.slice(1)} 286.3 MiB, limit is 64.0 MiB`,
258 // the head and the tail alone, sharing their space or not; no middle; the middle twice
259 `${HEAD}MiB`, `${HEAD} MiB`, `${HEAD}5 MiB`, `${HEAD}286.3 MiB`, `${HEAD}286.3 MiB, limit is 64.0 MiB, limit is 64.0 MiB`,
260 // 10 integer digits, 7 decimals (9 and 6 are the most a figure has, below)
261 `${HEAD}1000000000 MiB, limit is 64.0 MiB`, `${HEAD}286.3 MiB, limit is 1000000000 MiB`, `${HEAD}1.0000001 MiB, limit is 64.0 MiB`, `${HEAD}286.3 MiB, limit is 64.0000000 MiB`,
262 // 10 integer digits with decimals, on either side: the 9-digit bound holds for a figure with a '.' as for one without.
263 // It is the bound that keeps the byte count exact: 9999999999.5 MiB is 10,485,759,999,475,712 bytes, over 2^53
264 // (9,007,199,254,740,992), and 1234567890.5 has the same 10 digits.
265 `${HEAD}1234567890.5 MiB, limit is 64.0 MiB`, `${HEAD}286.3 MiB, limit is 1234567890.5 MiB`, `${HEAD}9999999999.5 MiB, limit is 64.0 MiB`, `${HEAD}286.3 MiB, limit is 9999999999.5 MiB`,
266 // a figure is digits only, on both sides
267 `${HEAD}286.3 MiB, limit is .5 MiB`, `${HEAD}286.3 MiB, limit is 64. MiB`, `${HEAD}286.3 MiB, limit is -64 MiB`, `${HEAD}286.3 MiB, limit is 6 4 MiB`, `${HEAD}286.3 MiB, limit is 64.0a MiB`, `${HEAD}a286.3 MiB, limit is 64.0 MiB`,
268 `${HEAD}0 MiB, limit is 64.0 MiB`, `${HEAD}0.0000004 MiB, limit is 64.0 MiB`,
269 ];
270 // the near misses are near: each of the two-figure ones differs from a parsing reason in the part named above
271 assert.equal(TOO_LARGE.replace('push is', 'pull is').length, TOO_LARGE.length);
272 assert.equal(HEAD.length, 54);
273 for (const reason of no) assert.equal(parseReceivePackTooLarge(reason), null, JSON.stringify(reason.slice(0, 120)));
274 // every figure that parses is a safe, positive byte count
275 const top = parseReceivePackTooLarge(`${HEAD}999999999.999999 MiB, limit is 999999999.999999 MiB`);
276 assert.ok(top !== null && Number.isSafeInteger(top.got) && top.got === top.max && top.got > 0, JSON.stringify(top));
277 // By hand: 999,999,999.999999 MiB = 10^9 * 2^20 - 2^20 / 10^6 = 1,048,576,000,000,000 - 1.048576, rounded
278 // 1,048,575,999,999,999; the smallest figure, 0.000001 MiB = 1.048576 bytes, rounds to 1; 9 leading digits with
279 // zeros: 000000001 MiB = 1,048,576.
280 assert.deepEqual(top, { got: 1048575999999999, max: 1048575999999999 });
281 assert.deepEqual(parseReceivePackTooLarge(`${HEAD}000000001 MiB, limit is 0.000001 MiB`), { got: 1048576, max: 1 });
282});
Diagnostics4 git calls · 298 ms
CallStatusSizeTime0298 ms
discover200152 B4 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch 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 B · hit3 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=HIT 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 1020038 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=291 git.response.bytes=38434 git.response.cache=HIT git.response.duration_ms=3 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=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=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=38434 git.pkt.payload.max=38339 git.sideband.band1.bytes=38338 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=63 git.pack.bytes=38338 git.pack.ofs_delta=0 git.pack.ref_delta=8 git.pack.chain.max=8 git.pack.trailer=0bc36ab7adf82d3109177f11f1ea93f1ce071f77 git.pack.full=55Open pack map
fetch2005.6 KiB291 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=5739 git.response.cache=MISS git.response.duration_ms=291 git.fetch.wants=cd028f08ac04c8d690d062fa2963b8f88382740d 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=5739 git.pkt.payload.max=5718 git.sideband.band1.bytes=5717 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.git
- Ref
- refs/heads/main
- Commit
- 19912563f540228593df0c489082e5e2508e21e4
- cf-ray
- a5e1b69b5de95b65
- Request
- d3fbbac2…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format