GitHubivarvong

ply

main
ply6 git calls226 ms25 KiB4 cachedprotocol v2
65 lines6.3 KiBRaw
1// Prepare (do not push) a single-file edit against a real remote and dump the pack + spans.
2// node test/live-prepare.mjs <url> <ref> <path> <find> <replace> [out.pack]
3import { writeFileSync } from 'node:fs';
4import { GitHttp } from '../src/client.js';
5import { parseCommit, parseTree, treeReplaceOid, hashObject, encodeCommit, ident, objectHeader, TYPE } from '../src/objects.js';
6import { validateIdent } from '../src/validate.js';
7import { spliceDelta, buildPack } from '../src/pack.js';
8import { Sha1, fromHex } from '../src/sha1.js';
9import { te } from '../src/bytes.js';
10import { Tracer, arrayExporter, flattenLine } from '../src/otel.js';
11import { withLimits } from '../src/limits.js';
12import { spInit, spStep as spStepR, spFinish as spFinishR, scanInit, scanStep, scanFinish } from '../src/edit.js';
13import { unwrap, unwrapAsync } from './unwrap.js';
15// Throwing adapters over the Result API (0.2.0): the assertions below are about the throw.
16const spStep = (...a) => unwrap(spStepR(...a));
17const spFinish = (...a) => unwrap(spFinishR(...a));
18export async function prepare({ url, ref = 'refs/heads/main', path, find, replace, author = { name: 'ply', email: 'ply@edge' }, message = 'ply edit', auth, fetchImpl, head: hint = null }) {
19 const exporter = arrayExporter(); const tracer = new Tracer({ exporter });
20 const root = tracer.start('git.edit.prepare', { attrs: { 'git.edit.path': path } });
21 const client = unwrap(GitHttp.create(url, { tracer, parent: root, limits: withLimits({ requestTimeoutMs: 25000 }), auth, fetchImpl }));
22 const t0 = Date.now();
23 let oldCommit = hint;
24 if (!oldCommit) { const { refs, head } = await unwrapAsync(client.lsRefs([ref, 'HEAD'])); oldCommit = refs.get(ref)?.oid; if (!oldCommit) throw Object.assign(new Error(`no ${ref} (HEAD→${head})`), { code: 'not_found' }); }
25 const cf = await unwrapAsync(client.fetchPack({ wants: [oldCommit], filter: 'tree:0', deepen: 1 }));
26 const commit = unwrap(parseCommit(cf.objects.get(oldCommit).data));
27 const comps = path.split('/'); const levels = []; let treeOid = commit.tree;
28 for (let d = 0; d < comps.length; d++) {
29 const tf = await unwrapAsync(client.fetchPack({ wants: [treeOid], filter: 'tree:0' }));
30 const data = tf.objects.get(treeOid).data; const entry = unwrap(parseTree(data)).find(e => e.name === comps[d]);
31 if (!entry) throw Object.assign(new Error(`${comps[d]} not in ${treeOid}`), { code: 'not_found' });
32 levels.push({ treeOid, data, entry }); treeOid = entry.oid;
33 }
34 const blobOid = treeOid;
35 const findB = te.encode(find), replB = te.encode(replace);
36 let sp = spInit(), scan = scanInit({ find: findB, replace: replB }), sha = null, newLen = 0, inflated = 0;
37 const ds = new DecompressionStream('deflate'); const w = ds.writable.getWriter();
38 const fspan = tracer.start('git.upload-pack fetch', { parent: root });
39 const pump = (async () => { for await (const c of client.packStream({ wants: [blobOid] }, fspan)) { const r = spStep(sp, c); sp = r.state; for (const z of r.zlib) await w.write(z); } sp = spFinish(sp); await w.close(); fspan.end(); })();
40 for await (const chunk of ds.readable) { if (!sha) { newLen = sp.size - findB.length + replB.length; sha = new Sha1().update(objectHeader('blob', newLen)); } inflated += chunk.length; const r = scanStep(scan, chunk); scan = r.state; for (const p of r.emit) sha.update(p); }
41 await pump; if (!sha) { newLen = sp.size - findB.length + replB.length; sha = new Sha1().update(objectHeader('blob', newLen)); }
42 const fin = scanFinish(scan); scan = fin.state; for (const p of fin.emit) sha.update(p);
43 if (scan.count !== 1) throw Object.assign(new Error(`expected exactly one match, found ${scan.count}`), { code: 'match_count' });
44 const newBlob = sha.hex();
45 const blobDelta = spliceDelta({ baseLen: sp.size, off: scan.matches[0], oldLen: findB.length, insert: replB }).delta;
46 const treeObjs = []; let child = newBlob;
47 for (let i = levels.length - 1; i >= 0; i--) { const { treeOid: oldT, data, entry } = levels[i]; const nd = treeReplaceOid(data, entry, child); const nid = hashObject('tree', nd); treeObjs.unshift({ type: TYPE.TREE, data: spliceDelta({ baseLen: data.length, off: entry.oidOffset, oldLen: 20, insert: fromHex(child) }).delta, baseOid: oldT, newOid: nid }); child = nid; }
48 const who = unwrap(ident(unwrap(validateIdent({ name: author.name, email: author.email, time: Math.floor(Date.now() / 1000), tz: author.tz }))));
49 const commitData = unwrap(encodeCommit({ tree: child, parents: [oldCommit], author: who, committer: who, message: message + '\n' }));
50 const newCommit = hashObject('commit', commitData);
51 const objects = [{ type: TYPE.COMMIT, data: commitData }, ...treeObjs.map(t => ({ type: t.type, data: t.data, base: { tag: 'ref', oid: t.baseOid } })), blobDelta.length >= 4 ? { type: TYPE.BLOB, data: blobDelta, base: { tag: 'ref', oid: blobOid } } : { type: TYPE.BLOB, data: new Uint8Array(0) }];
52 const { pack, entries } = await buildPack(objects);
53 root.set({ 'git.edit.commit.old': oldCommit, 'git.edit.commit.new': newCommit, 'git.edit.push.bytes': pack.length, }).end();
54 return { ms: Date.now() - t0, oldCommit, newCommit, oldTree: commit.tree, newTree: child, oldBlob: blobOid, newBlob, baseLen: sp.size, newLen, matchOffset: scan.matches[0], trees: treeObjs.map(t => ({ old: t.baseOid, new: t.newOid })), command: `${oldCommit} ${newCommit} ${ref}`, pack, entries, spans: exporter.lines.flatMap(flattenLine) };
57if (process.argv[1] && import.meta.url.endsWith(process.argv[1].split('/').pop())) {
58 const [url, ref, path, find, replace, out = 'live.pack'] = process.argv.slice(2);
59 const auth = process.env.PLY_TOKEN ? { token: process.env.PLY_TOKEN } : undefined;
60 const r = await prepare({ url, ref, path, find, replace, auth });
61 writeFileSync(out, r.pack);
62 const { pack, spans, ...rest } = r;
63 console.log(JSON.stringify(rest, null, 1));
64 for (const s of spans) console.log(s.name.padEnd(26), String(Math.round(s.ms)).padStart(5) + 'ms', s.status.code === 2 ? 'ERR' : ' ', 'req', s.attrs['http.request.body.size'] ?? '', 'resp', s.attrs['http.response.body.size'] ?? '', s.attrs['git.pack.objects'] !== undefined ? `objs=${s.attrs['git.pack.objects']}` : '', s.attrs['git.sideband.band2.frames'] ? `band2=${s.attrs['git.sideband.band2.frames']}` : '', s.attrs['http.response.ttfb_ms'] !== undefined ? `ttfb=${s.attrs['http.response.ttfb_ms']}` : '');
Diagnostics6 git calls · 226 ms
CallStatusSizeTime0226 ms
discover200191 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
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 KiB · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=11990
git.response.cache=HIT
git.response.duration_ms=2
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=10
Open pack map
fetchtree:0200919 B · 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=919
git.response.cache=HIT
git.response.duration_ms=2
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=5323b9266eea5ded637285d1c5320699f12be76e
Open pack map
fetchtree:02005.6 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=5724
git.response.cache=HIT
git.response.duration_ms=2
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=be7e0453974a5fe832f9065a33bb7e3434c10e9b
Open pack map
fetch2002.5 KiB217 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=217
git.response.bytes=2605
git.response.cache=MISS
git.response.duration_ms=217
git.fetch.wants=4bbbb38a8e050f9413ac5466bbc47c761bd14f7a
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=2605
git.pkt.payload.max=2578
git.sideband.band1.bytes=2578
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
a5e2dd12edacc125
Request
f29c9475…
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