main
ply4 git calls370 ms43 KiB2 cachedprotocol v2
120 lines5.8 KiBRaw
1import { MESSAGE_MAX } from './baseline.ts'
2import { confirmRoute, failureFault, logRoute, ROUTE_TUNABLES, SYSTEM_ROUTE_IO, type RouteIo, type RouteTunables } from './route-confirm.ts'
3import { cfOk, ROOT } from './cf.ts'
4import { isTrafficSplit, planCanary, trafficSplit, versionByTag } from './deploy-plan.ts'
5import { extractJson } from './json.ts'
6import { activeLog } from './log.ts'
7import { originMainReason, requireOriginMain } from './preflight.ts'
8import { errorMessage } from './proc.ts'
9import { checkoutReason, readCheckout, releaseTag, type ReleaseId } from './release.ts'
10import { fail, pass, type StageResult } from './result.ts'
11import type { CdConfig } from './config.ts'
12import { applySplit, readShares, rollbackTo } from './traffic.ts'
14const CANARY_PREFIX = 'cd canary '
15/** Stands in for a version not uploaded yet, so the pre-upload plan can name a foreign 0% version. Never written. */
16const PLACEHOLDER = '00000000-0000-4000-8000-000000000000'
18export type DeployValue = {
19 readonly version: string
20 readonly previous: string
21 readonly dropped: string | null
24/**
25 * The canary is served to pinned requests on every fresh connection for PIN_SUSTAIN_MS (route-confirm.ts). `since` is
26 * the split write, so the log's sample offsets are time since it.
27 */
28export async function pinReady(
29 config: Pick<CdConfig, 'baseUrl' | 'worker'>,
30 version: string,
31 since: number,
32 io: RouteIo = SYSTEM_ROUTE_IO,
33 tunables: RouteTunables = ROUTE_TUNABLES,
34): Promise<{ readonly ok: true } | { readonly ok: false; readonly reason: string; readonly fault: 'harness_fault' | 'worker' }> {
35 const started = io.now()
36 const verdict = await confirmRoute({
37 url: `${config.baseUrl}/`,
38 version,
39 headers: { 'Cloudflare-Workers-Version-Overrides': `${config.worker}="${version}"` },
40 since,
41 }, io, tunables)
42 const line = await logRoute({ purpose: 'pin', version, since, started }, verdict)
43 process.stdout.write(`${line}\n`)
44 if (verdict.kind === 'confirmed') return { ok: true }
45 return { ok: false, reason: verdict.reason, fault: failureFault(verdict) }
48async function versionTagged(worker: string, tag: string): Promise<string | null> {
49 const listed = await cfOk(['workers', 'versions', 'list', '--worker-id', worker, '--page', '1', '--per-page', '100'])
50 let payload: unknown = listed
51 try {
52 payload = extractJson(listed)
53 } catch {
54 payload = listed
55 }
56 const found = versionByTag(payload, tag)
57 return found.ok ? found.versionId : null
60function canaryMessage(tag: string): string {
61 const message = `${CANARY_PREFIX}${tag}`
62 if (message.length > MESSAGE_MAX) throw new Error('canary message exceeds workers/message')
63 return message
66export async function stageDeploy(
67 config: CdConfig,
68 release: ReleaseId,
69 opts: { readonly replaceCanary: string | null },
70): Promise<StageResult<DeployValue>> {
71 const mainRef = await requireOriginMain(ROOT)
72 if (!mainRef.ok) {
73 const reason = originMainReason(mainRef)
74 const context = mainRef.kind === 'not-on-origin-main'
75 ? { kind: mainRef.kind, head: mainRef.head, main: mainRef.main }
76 : { kind: mainRef.kind, reason: mainRef.reason }
77 await activeLog()?.error(reason, context)
78 return fail('deploy-canary', reason, false, 'harness_fault')
79 }
80 const checkout = await readCheckout(ROOT)
81 if (!checkout.ok) return fail('deploy-canary', checkoutReason(checkout), false, 'harness_fault')
82 if (checkout.web !== release.web) {
83 return fail('deploy-canary', `checkout-unavailable: HEAD ${checkout.web} is not the release ply-web sha`, false, 'harness_fault')
84 }
85 const resolved = releaseTag(release)
86 try {
87 let version = await versionTagged(config.worker, resolved)
88 // Refuse before building: a foreign 0% version is checked again (planCanary) against the split read after upload.
89 const before = planCanary(await readShares(config.worker), version || PLACEHOLDER, opts.replaceCanary)
90 if (before.kind === 'conflict') return fail('deploy-canary', before.reason, false, 'state_conflict')
91 if (!version) {
92 await cfOk(['build', '--mode', 'production'])
93 await cfOk([
94 'workers', 'versions', 'create', '--prebuilt', '--mode', 'production',
95 '--worker', config.worker, '--tag', resolved, '--message', canaryMessage(resolved),
96 ])
97 version = await versionTagged(config.worker, resolved)
98 }
99 if (!version) return fail('deploy-canary', `version-not-found: no version tagged ${resolved}`, false, 'harness_fault')
100 const shares = await readShares(config.worker)
101 const plan = planCanary(shares, version, opts.replaceCanary)
102 if (plan.kind === 'refuse') return fail('deploy-canary', plan.reason, false, 'harness_fault')
103 if (plan.kind === 'conflict') return fail('deploy-canary', plan.reason, false, 'state_conflict')
104 const want = trafficSplit(0, version, plan.live)
105 if (!isTrafficSplit(want)) return fail('deploy-canary', `${want.reason}; traffic was not changed`, false, 'harness_fault')
106 const applied = await applySplit(config.worker, canaryMessage(resolved), want, shares, { kind: 'canary' })
107 if (!applied.ok && applied.kind === 'state_conflict') return fail('deploy-canary', applied.reason, false, 'state_conflict')
108 if (!applied.ok) {
109 const seen = await readShares(config.worker)
110 const rolled = await rollbackTo(config.worker, plan.live, seen)
111 const rollbackError = rolled.ok ? null : rolled.reason
112 return fail('deploy-canary', rollbackError ? `${applied.reason}; ${rollbackError}` : applied.reason, rollbackError === null)
113 }
114 const pinned = await pinReady(config, version, Date.now())
115 if (!pinned.ok) return fail('deploy-canary', `${pinned.reason}; left the 0% canary in place`, false, pinned.fault)
116 return pass('deploy-canary', { version, previous: plan.live, dropped: plan.dropped })
117 } catch (error) {
118 return fail('deploy-canary', errorMessage(error), false, 'harness_fault')
119 }
Diagnostics4 git calls · 370 ms
CallStatusSizeTime0370 ms
discover200152 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=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 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=61
Open pack map
fetch2002.1 KiB365 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=365
git.response.bytes=2127
git.response.cache=MISS
git.response.duration_ms=365
git.fetch.wants=1ba8465c09f9b25db65ba215966030503ca5e512
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=2127
git.pkt.payload.max=2106
git.sideband.band1.bytes=2105
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
a5e2dea488512308
Request
10a609b3…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format