import { MESSAGE_MAX } from './baseline.ts' import { confirmRoute, failureFault, logRoute, ROUTE_TUNABLES, SYSTEM_ROUTE_IO, type RouteIo, type RouteTunables } from './route-confirm.ts' import { cfOk, ROOT } from './cf.ts' import { isTrafficSplit, planCanary, trafficSplit, versionByTag } from './deploy-plan.ts' import { extractJson } from './json.ts' import { activeLog } from './log.ts' import { originMainReason, requireOriginMain } from './preflight.ts' import { errorMessage } from './proc.ts' import { checkoutReason, readCheckout, releaseTag, type ReleaseId } from './release.ts' import { fail, pass, type StageResult } from './result.ts' import type { CdConfig } from './config.ts' import { applySplit, readShares, rollbackTo } from './traffic.ts' const CANARY_PREFIX = 'cd canary ' /** Stands in for a version not uploaded yet, so the pre-upload plan can name a foreign 0% version. Never written. */ const PLACEHOLDER = '00000000-0000-4000-8000-000000000000' export type DeployValue = { readonly version: string readonly previous: string readonly dropped: string | null } /** * The canary is served to pinned requests on every fresh connection for PIN_SUSTAIN_MS (route-confirm.ts). `since` is * the split write, so the log's sample offsets are time since it. */ export async function pinReady( config: Pick, version: string, since: number, io: RouteIo = SYSTEM_ROUTE_IO, tunables: RouteTunables = ROUTE_TUNABLES, ): Promise<{ readonly ok: true } | { readonly ok: false; readonly reason: string; readonly fault: 'harness_fault' | 'worker' }> { const started = io.now() const verdict = await confirmRoute({ url: `${config.baseUrl}/`, version, headers: { 'Cloudflare-Workers-Version-Overrides': `${config.worker}="${version}"` }, since, }, io, tunables) const line = await logRoute({ purpose: 'pin', version, since, started }, verdict) process.stdout.write(`${line}\n`) if (verdict.kind === 'confirmed') return { ok: true } return { ok: false, reason: verdict.reason, fault: failureFault(verdict) } } async function versionTagged(worker: string, tag: string): Promise { const listed = await cfOk(['workers', 'versions', 'list', '--worker-id', worker, '--page', '1', '--per-page', '100']) let payload: unknown = listed try { payload = extractJson(listed) } catch { payload = listed } const found = versionByTag(payload, tag) return found.ok ? found.versionId : null } function canaryMessage(tag: string): string { const message = `${CANARY_PREFIX}${tag}` if (message.length > MESSAGE_MAX) throw new Error('canary message exceeds workers/message') return message } export async function stageDeploy( config: CdConfig, release: ReleaseId, opts: { readonly replaceCanary: string | null }, ): Promise> { const mainRef = await requireOriginMain(ROOT) if (!mainRef.ok) { const reason = originMainReason(mainRef) const context = mainRef.kind === 'not-on-origin-main' ? { kind: mainRef.kind, head: mainRef.head, main: mainRef.main } : { kind: mainRef.kind, reason: mainRef.reason } await activeLog()?.error(reason, context) return fail('deploy-canary', reason, false, 'harness_fault') } const checkout = await readCheckout(ROOT) if (!checkout.ok) return fail('deploy-canary', checkoutReason(checkout), false, 'harness_fault') if (checkout.web !== release.web) { return fail('deploy-canary', `checkout-unavailable: HEAD ${checkout.web} is not the release ply-web sha`, false, 'harness_fault') } const resolved = releaseTag(release) try { let version = await versionTagged(config.worker, resolved) // Refuse before building: a foreign 0% version is checked again (planCanary) against the split read after upload. const before = planCanary(await readShares(config.worker), version || PLACEHOLDER, opts.replaceCanary) if (before.kind === 'conflict') return fail('deploy-canary', before.reason, false, 'state_conflict') if (!version) { await cfOk(['build', '--mode', 'production']) await cfOk([ 'workers', 'versions', 'create', '--prebuilt', '--mode', 'production', '--worker', config.worker, '--tag', resolved, '--message', canaryMessage(resolved), ]) version = await versionTagged(config.worker, resolved) } if (!version) return fail('deploy-canary', `version-not-found: no version tagged ${resolved}`, false, 'harness_fault') const shares = await readShares(config.worker) const plan = planCanary(shares, version, opts.replaceCanary) if (plan.kind === 'refuse') return fail('deploy-canary', plan.reason, false, 'harness_fault') if (plan.kind === 'conflict') return fail('deploy-canary', plan.reason, false, 'state_conflict') const want = trafficSplit(0, version, plan.live) if (!isTrafficSplit(want)) return fail('deploy-canary', `${want.reason}; traffic was not changed`, false, 'harness_fault') const applied = await applySplit(config.worker, canaryMessage(resolved), want, shares, { kind: 'canary' }) if (!applied.ok && applied.kind === 'state_conflict') return fail('deploy-canary', applied.reason, false, 'state_conflict') if (!applied.ok) { const seen = await readShares(config.worker) const rolled = await rollbackTo(config.worker, plan.live, seen) const rollbackError = rolled.ok ? null : rolled.reason return fail('deploy-canary', rollbackError ? `${applied.reason}; ${rollbackError}` : applied.reason, rollbackError === null) } const pinned = await pinReady(config, version, Date.now()) if (!pinned.ok) return fail('deploy-canary', `${pinned.reason}; left the 0% canary in place`, false, pinned.fault) return pass('deploy-canary', { version, previous: plan.live, dropped: plan.dropped }) } catch (error) { return fail('deploy-canary', errorMessage(error), false, 'harness_fault') } }