main
1import assert from 'node:assert/strict'
2import { mkdtemp, readFile } from 'node:fs/promises'
3import { tmpdir } from 'node:os'
4import { join } from 'node:path'
5import { afterEach, describe, test } from 'node:test'
6import { runCf, useCfRunner, type CfResult } from '../scripts/cd/cf.ts'
7import { isTrafficSplit, trafficSplit, type VersionShare } from '../scripts/cd/deploy-plan.ts'
8import { RunLog, withRun } from '../scripts/cd/log.ts'
9import { withCommandSink } from '../scripts/cd/trace.ts'
10import { applySplit, classifyReadBack, useReadBack } from '../scripts/cd/traffic.ts'
11import { armStep, beginRamp, endRamp, HarnessFault, withWriteIntent } from '../scripts/cd/traffic-gate.ts'
13const NEXT = 'ab73257f-1111-4111-8111-111111111111'
14const PREV = '11111111-2222-4333-8444-555555555555'
16type Share = { version_id: string; percentage: number }
17type Create = { message: string; versions: Share[] }
19describe('traffic gate', { concurrency: false }, () => {
20 afterEach(() => {
21 endRamp()
22 useCfRunner(null)
23 useReadBack(null)
24 })
26 test('a deployment create with no active log is a harness fault and does not call cf', async () => {
27 let called = false
28 useCfRunner(async (): Promise<CfResult> => {
29 called = true
30 return { code: 0, stdout: '{}', stderr: '' }
31 })
32 await assert.rejects(
33 () => runCf(['workers', 'deployments', 'create', '--worker', 'ply', '--body', '{}']),
34 (error: unknown) => error instanceof HarnessFault && /no active log/.test(error.message),
35 )
36 assert.equal(called, false)
37 })
39 test('a create inside the run log still faults when the command sink is missing', async () => {
40 const dir = await mkdtemp(join(tmpdir(), 'ply-gate-'))
41 const log = await RunLog.open(join(dir, 'run'), join(dir, 'ledger.jsonl'), 'run-gate')
42 let called = false
43 useCfRunner(async (): Promise<CfResult> => {
44 called = true
45 return { code: 0, stdout: '{}', stderr: '' }
46 })
47 await withRun(log, async () => {
48 beginRamp(75)
49 await assert.rejects(
50 () => withWriteIntent({ kind: 'step', percent: 75 }, () => runCf(['workers', 'deployments', 'create', '--worker', 'ply', '--body', '{}'])),
51 (error: unknown) => error instanceof HarnessFault && /no command sink/.test(error.message),
52 )
53 })
54 assert.equal(called, false)
55 })
57 test('the 75% observe window refuses an unarmed 100% create, then accepts it after the decision', async () => {
58 const dir = await mkdtemp(join(tmpdir(), 'ply-gate-'))
59 const runDir = join(dir, 'run')
60 const log = await RunLog.open(runDir, join(dir, 'ledger.jsonl'), 'run-gate')
61 const clock = { t: Date.parse('2026-11-01T20:07:27.000Z') }
62 const live: Share[] = [
63 { version_id: NEXT, percentage: 50 },
64 { version_id: PREV, percentage: 50 },
65 ]
66 const creates: Create[] = []
67 useCfRunner(async (args): Promise<CfResult> => {
68 if (args[1] === 'deployments' && args[2] === 'list') {
69 return { code: 0, stdout: JSON.stringify({ deployments: [{ id: 'dep-1', versions: live }] }), stderr: '' }
70 }
71 if (args[1] === 'deployments' && args[2] === 'create') {
72 const raw = args[args.indexOf('--body') + 1]
73 if (!raw) return { code: 1, stdout: '', stderr: 'missing body' }
74 const body = JSON.parse(raw) as { versions: Share[]; annotations: { 'workers/message': string } }
75 live.splice(0, live.length, ...body.versions)
76 creates.push({ message: body.annotations['workers/message'], versions: body.versions.map(share => ({ version_id: share.version_id, percentage: share.percentage })) })
77 return { code: 0, stdout: '{}', stderr: '' }
78 }
79 return { code: 1, stdout: '', stderr: 'unexpected cf args' }
80 })
81 await withRun(log, () => withCommandSink(note => log.noteCommand(note), async () => {
82 beginRamp(75)
83 const at75 = trafficSplit(75, NEXT, PREV)
84 if (!isTrafficSplit(at75)) throw new Error(at75.reason)
85 const wrote75 = await applySplit('ply', `ramp ${NEXT} 75%`, at75, shares(live), { kind: 'step', percent: 75 })
86 assert.equal(wrote75.ok, true)
87 clock.t += 135_000
88 const at100 = trafficSplit(100, NEXT, PREV)
89 if (!isTrafficSplit(at100)) throw new Error(at100.reason)
90 await assert.rejects(
91 () => applySplit('ply', `ramp ${NEXT} 100%`, at100, shares(live), { kind: 'step', percent: 100 }),
92 (error: unknown) => error instanceof HarnessFault && /during observe/.test(error.message),
93 )
94 assert.equal(creates.length, 1)
95 const ref = await log.observation({
96 measurement: { source: 'ramp-step', percent: 75, at: clock.t },
97 query: { source: 'test' },
98 from: clock.t - 40_000,
99 to: clock.t,
100 raw: '{}',
101 })
102 await log.decision({
103 inputs: [ref],
104 rules: [{ name: 'ramp', value: 'advance' }],
105 outcome: 'advance',
106 reason: '75% passed',
107 })
108 armStep(100)
109 const wrote100 = await applySplit('ply', `ramp ${NEXT} 100%`, at100, shares(live), { kind: 'step', percent: 100 })
110 assert.equal(wrote100.ok, true)
111 }))
112 assert.deepEqual(creates.map(create => create.message), [`ramp ${NEXT} 75%`, `ramp ${NEXT} 100%`])
113 assert.deepEqual(creates.map(create => percentOf(create.versions, NEXT)), [75, 100])
114 const text = await readFile(join(runDir, 'events.jsonl'), 'utf8')
115 const lines = text.split('\n').filter(line => line.includes('"kind":"command"') && line.includes('deployments'))
116 const loggedCreates = lines.filter(line => line.includes('create'))
117 assert.equal(loggedCreates.length, creates.length)
118 assert.equal(text.includes('"kind":"state_change"'), true)
119 assert.equal(text.includes('"outcome":"advance"'), true)
120 })
122 test('two creates cannot overlap, and the second loses the arm', async () => {
123 const dir = await mkdtemp(join(tmpdir(), 'ply-gate-'))
124 const log = await RunLog.open(join(dir, 'run'), join(dir, 'ledger.jsonl'), 'run-gate')
125 const live: Share[] = [
126 { version_id: NEXT, percentage: 50 },
127 { version_id: PREV, percentage: 50 },
128 ]
129 let release: () => void = () => {}
130 const hold = new Promise<void>(resolve => {
131 release = resolve
132 })
133 let entered = 0
134 let releaseEntered: () => void = () => {}
135 const enteredGate = new Promise<void>(resolve => {
136 releaseEntered = resolve
137 })
138 useCfRunner(async (args): Promise<CfResult> => {
139 if (args[1] === 'deployments' && args[2] === 'list') {
140 return { code: 0, stdout: JSON.stringify({ deployments: [{ id: 'dep-1', versions: live }] }), stderr: '' }
141 }
142 if (args[1] === 'deployments' && args[2] === 'create') {
143 entered += 1
144 if (entered === 1) releaseEntered()
145 await hold
146 const raw = args[args.indexOf('--body') + 1]
147 if (!raw) return { code: 1, stdout: '', stderr: 'missing body' }
148 const body = JSON.parse(raw) as { versions: Share[] }
149 live.splice(0, live.length, ...body.versions)
150 return { code: 0, stdout: '{}', stderr: '' }
151 }
152 return { code: 1, stdout: '', stderr: 'unexpected cf args' }
153 })
154 await withRun(log, () => withCommandSink(note => log.noteCommand(note), async () => {
155 beginRamp(75)
156 const at75 = trafficSplit(75, NEXT, PREV)
157 if (!isTrafficSplit(at75)) throw new Error(at75.reason)
158 const expected = shares(live)
159 const first = applySplit('ply', `ramp ${NEXT} 75%`, at75, expected, { kind: 'step', percent: 75 })
160 const second = applySplit('ply', `ramp ${NEXT} 75%`, at75, expected, { kind: 'step', percent: 75 })
161 await enteredGate
162 assert.equal(entered, 1)
163 release()
164 const settled = await Promise.allSettled([first, second])
165 const fulfilled = settled.flatMap(result => result.status === 'fulfilled' ? [result.value] : [])
166 assert.equal(fulfilled.length, 2)
167 assert.equal(fulfilled.filter(result => result.ok).length, 1)
168 assert.equal(fulfilled.filter(result => !result.ok && result.kind === 'state_conflict').length, 1)
169 assert.equal(entered, 1)
170 }))
171 })
173 // Run 2026-11-12T21-21-31-209Z: the create landed (4918caf9) but the list 1 ms later still showed 9f0dc7f0 at 0%.
174 test('a stale list after a create is waited out, not judged rejected', async () => {
175 const dir = await mkdtemp(join(tmpdir(), 'ply-gate-'))
176 const log = await RunLog.open(join(dir, 'run'), join(dir, 'ledger.jsonl'), 'run-gate')
177 useReadBack({ attempts: 5, gapMs: 1 })
178 const prior: Share[] = [{ version_id: NEXT, percentage: 0 }, { version_id: PREV, percentage: 100 }]
179 let current = { id: '9f0dc7f0', versions: prior }
180 let staleReads = 0
181 let lists = 0
182 useCfRunner(async (args): Promise<CfResult> => {
183 if (args[1] === 'deployments' && args[2] === 'list') {
184 lists++
185 if (staleReads > 0) {
186 staleReads--
187 return { code: 0, stdout: JSON.stringify({ deployments: [{ id: '9f0dc7f0', versions: prior }] }), stderr: '' }
188 }
189 return { code: 0, stdout: JSON.stringify({ deployments: [current] }), stderr: '' }
190 }
191 if (args[1] === 'deployments' && args[2] === 'create') {
192 const raw = args[args.indexOf('--body') + 1]
193 if (!raw) return { code: 1, stdout: '', stderr: 'missing body' }
194 const body = JSON.parse(raw) as { versions: Share[] }
195 current = { id: '4918caf9', versions: body.versions }
196 staleReads = 2
197 return { code: 0, stdout: JSON.stringify({ id: '4918caf9' }), stderr: '' }
198 }
199 return { code: 1, stdout: '', stderr: 'unexpected cf args' }
200 })
201 await withRun(log, () => withCommandSink(note => log.noteCommand(note), async () => {
202 beginRamp(10)
203 const at10 = trafficSplit(10, NEXT, PREV)
204 if (!isTrafficSplit(at10)) throw new Error(at10.reason)
205 const wrote = await applySplit('ply', `ramp ${NEXT} 10%`, at10, shares(prior), { kind: 'step', percent: 10 })
206 assert.deepEqual(wrote, { ok: true })
207 assert.equal(lists, 4, 'one CAS read, two stale read-backs, one that shows the write')
208 }))
209 const at10 = trafficSplit(10, NEXT, PREV)
210 if (!isTrafficSplit(at10)) throw new Error(at10.reason)
211 const before = { id: '9f0dc7f0', versions: shares(prior) }
212 assert.deepEqual(classifyReadBack(before, before, at10), { kind: 'stale' })
213 assert.deepEqual(classifyReadBack(before, { id: '4918caf9', versions: shares([{ version_id: NEXT, percentage: 10 }, { version_id: PREV, percentage: 90 }]) }, at10), { kind: 'applied' })
214 const other = classifyReadBack(before, { id: 'ffff0000', versions: shares([{ version_id: NEXT, percentage: 25 }, { version_id: PREV, percentage: 75 }]) }, at10)
215 assert.equal(other.kind, 'mismatch', 'a new deployment that is not the split is a real rejection')
216 const neverShows = classifyReadBack({ id: null, versions: shares(prior) }, { id: null, versions: shares(prior) }, at10)
217 assert.equal(neverShows.kind, 'stale')
218 })
219})
221function shares(versions: readonly Share[]): VersionShare[] {
222 return versions.map(share => ({ versionId: share.version_id, percentage: share.percentage }))
223}
225function percentOf(versions: readonly Share[], id: string): number {
226 const share = versions.find(item => item.version_id === id)
227 if (!share) throw new Error(`missing ${id}`)
228 return share.percentage
229}
Diagnostics4 git calls · 564 ms
CallStatusSizeTime0564 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 · hit8 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=41349 git.response.cache=HIT git.response.duration_ms=8 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
fetch2002.8 KiB553 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=553 git.response.bytes=2884 git.response.cache=MISS git.response.duration_ms=553 git.fetch.wants=93073b6e5f2f230df400802c45f1a21441e77d4b 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=2884 git.pkt.payload.max=2863 git.sideband.band1.bytes=2862 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
- a5e30ffa4db7bdc9
- Request
- 8df1a033…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format