Files
orca/cloud/apps/relay-edge/spike/run-all-lifecycle.ts

93 lines
4.9 KiB
TypeScript

// Later run-all.ts checks against the same host: rebind, orphan grace, silence,
// forced resets.
import WebSocket from 'ws'
import { GRACE_MS, ORIGIN, PING_MS, PORT, SILENCE_MS, makeControl, openPhone, record, sleep, waitFor, type Ctx, type Control } from './run-all-harness'
type Ack = Awaited<ReturnType<Control['client']['connect']>>
export async function runLifecycleChecks(ctx: Ctx, main: Control, mainAck: Ack): Promise<void> {
// Rebind keeps generation and splices (resume secret within orphan grace).
{
const live = openPhone(ctx)
await waitFor(() => live.hello !== null, 5000)
const generation = mainAck.generation
const rebind = makeControl(ctx, ORIGIN, {
previousGeneration: generation,
controlResumeSecret: mainAck.controlResumeSecret
})
const r = await rebind.client.connect().catch((e: Error) => e)
await sleep(300)
live.ws.send('after-rebind')
const echoed = await waitFor(() => live.inbox.some((m) => m.data === 'after-rebind'), 3000)
record('R5 rebind with resume secret keeps generation and live splice',
!(r instanceof Error) && r.generation === generation && echoed && main.events.closes.includes(4408),
r instanceof Error ? r.message : `gen ${generation}->${r.generation} spliceEcho=${echoed} oldClosed=${main.events.closes.join(',')}`)
// Orphan then return after grace: new generation, persisted floor (not reset to 1).
rebind.client.closeNow()
await sleep(GRACE_MS + 1500)
const fresh = makeControl(ctx, ORIGIN)
const f = await fresh.client.connect()
record('R2 orphan grace expiry closes splices 4408; generation floor persists', f.generation === generation + 1 && live.closed === 4408,
`gen=${f.generation} phoneClosedWith=${live.closed}`)
// Silence: a control that never pongs is closed 4408 within the silence window.
const mute = new WebSocket(`ws://127.0.0.1:${PORT}/v1/host/control`, {
headers: { authorization: `Bearer ${ctx.jwt}` }
})
let muteClose = 0
mute.on('close', (c) => (muteClose = c))
await new Promise((res) => mute.on('open', res))
// Complete the handshake by hand with the shipped proof answerer, then never pong.
const { answerRelayHostChallenge } = await import('../../../../src/main/runtime/mobile-cloud-relay/relay-host-proof')
mute.send(JSON.stringify({ type: 'host-hello', v: 1, relayHostId: ctx.relayHostId, assignmentEpoch: 7,
hostPublicKeyB64: ctx.keypair.publicKeyB64, appVersion: 'spike' }))
mute.on('message', (raw) => {
const m = JSON.parse(raw.toString())
if (m.type === 'host-challenge') {
const proofB64 = answerRelayHostChallenge(m, { relayOrigin: ORIGIN, ...ctx.identity, relayHostId: ctx.relayHostId,
hostPublicKey: ctx.keypair.publicKey, hostSecretKey: ctx.keypair.secretKey, assignmentEpoch: 7, resumeRequested: false })
mute.send(JSON.stringify({ type: 'host-challenge-ack', challengeId: m.challengeId, proofB64 }))
}
})
await waitFor(() => muteClose !== 0, SILENCE_MS + PING_MS * 3 + 2000)
record('R2 silent control closed 4408 by alarm silence check', muteClose === 4408, `close=${muteClose}`)
}
// R2: forced object reset (ctx.abort). Locally this drops every socket (1006); the durable
// generation floor must survive so the next control gets floor+1, never a reused generation.
{
const before = makeControl(ctx, ORIGIN)
const b = await before.client.connect()
await fetch(`${ORIGIN}/__spike/abort/${ctx.relayHostId}`).catch(() => {})
const dropped = await waitFor(() => before.events.closes.length > 0, 5000)
await sleep(300)
const after = makeControl(ctx, ORIGIN)
const a2 = await after.client.connect().catch((e: Error) => e)
record('R2 forced reset: sockets drop locally (expected for abort), storage keeps generation floor',
!(a2 instanceof Error) && a2.generation === b.generation + 1,
`dropped=${dropped} close=${before.events.closes.join(',')} gen ${b.generation}->${a2 instanceof Error ? a2.message : a2.generation}`)
after.client.closeNow()
}
// F1: after a forced reset (no close events), a desktop that rebinds within the grace keeps its
// generation, so splices living in SpliceRelay objects are not torn down.
{
const before = makeControl(ctx, ORIGIN)
const b = await before.client.connect()
await fetch(`${ORIGIN}/__spike/abort/${ctx.relayHostId}`).catch(() => {})
await waitFor(() => before.events.closes.length > 0, 5000)
await sleep(300)
const back = makeControl(ctx, ORIGIN, {
previousGeneration: b.generation,
controlResumeSecret: b.controlResumeSecret
})
const r = await back.client.connect().catch((e: Error) => e)
record('F1 rebind after forced reset keeps generation',
!(r instanceof Error) && r.generation === b.generation,
r instanceof Error ? r.message : `gen ${b.generation}->${r.generation}`)
back.client.closeNow()
}
}