export interface StartRequestHandler { fetch: (request: Request) => Promise | Response } export interface RunSsrRequestLoopOptions { seed: number iterations?: number } export interface RunRequestLoopOptions { seed: number concurrency: number totalRequests: number buildRequest: (random: () => number, index: number) => Request validateResponse?: (response: Response, request: Request) => void } const requestInit = { method: 'GET', headers: { accept: 'text/html', }, } satisfies RequestInit function createDeterministicRandom(seed: number) { let state = seed >>> 0 return () => { state = (state * 1664525 + 1013904223) >>> 0 return state / 0x100000000 } } function randomSegment(random: () => number) { return Math.floor(random() * 1_000_000_000).toString(36) } export { createDeterministicRandom, randomSegment } export async function drainResponse(response: Response) { const reader = response.body?.getReader() if (!reader) { return } try { while (true) { const result = await reader.read() if (result.done) { break } } } finally { reader.releaseLock() } } function randomSearchValue(random: () => number) { return `q-${randomSegment(random)}` } function randomRequestUrl(random: () => number) { const a = randomSegment(random) const b = randomSegment(random) const c = randomSegment(random) const d = randomSegment(random) const q = randomSearchValue(random) return `http://localhost/${a}/${b}/${c}/${d}?q=${q}` } export async function runSsrRequestLoop( handler: StartRequestHandler, { seed, iterations = 10 }: RunSsrRequestLoopOptions, ) { const random = createDeterministicRandom(seed) const pendingBodyReads: Array> = [] for (let index = 0; index < iterations; index++) { const requestUrl = randomRequestUrl(random) const response = await handler.fetch(new Request(requestUrl, requestInit)) if (response.status !== 200) { await Promise.allSettled(pendingBodyReads) throw new Error( `Request failed with non-200 status ${response.status} (${requestUrl})`, ) } pendingBodyReads.push(drainResponse(response)) } await Promise.all(pendingBodyReads) } export async function runRequestLoop( handler: StartRequestHandler, { seed, concurrency, totalRequests, buildRequest, validateResponse, }: RunRequestLoopOptions, ) { const requestSequences = buildRequestSequences({ seed, concurrency, totalRequests, buildRequest, }) const validate = validateResponse ?? ((response: Response, request: Request) => { if (response.status !== 200) { throw new Error( `Request failed with non-200 status ${response.status} (${request.url})`, ) } }) let startWorkers = () => {} const startBarrier = new Promise((resolve) => { startWorkers = resolve }) const workers = requestSequences.map(async (requests) => { await startBarrier for (const request of requests) { const response = await handler.fetch(request) let validationFailure: { error: unknown } | undefined try { validate(response, request) } catch (error) { validationFailure = { error } } await drainResponse(response) if (validationFailure) { throw validationFailure.error } } }) startWorkers() const results = await Promise.allSettled(workers) const failedWorker = results.find( (result): result is PromiseRejectedResult => result.status === 'rejected', ) if (failedWorker) { throw failedWorker.reason } } export type BuildRequestSequencesOptions = Pick< RunRequestLoopOptions, 'seed' | 'concurrency' | 'totalRequests' | 'buildRequest' > /** * Build the entire seeded workload before any request starts, then partition * it round-robin so completion timing can never change a worker's next input. */ export function buildRequestSequences({ seed, concurrency, totalRequests, buildRequest, }: BuildRequestSequencesOptions): Array> { assertPositiveInteger('concurrency', concurrency) assertPositiveInteger('totalRequests', totalRequests) if (concurrency > totalRequests) { throw new RangeError( `concurrency (${concurrency}) cannot exceed totalRequests (${totalRequests})`, ) } const random = createDeterministicRandom(seed) const requestSequences = Array.from( { length: concurrency }, () => new Array(), ) for (let index = 0; index < totalRequests; index++) { requestSequences[index % concurrency]!.push(buildRequest(random, index)) } return requestSequences } function assertPositiveInteger(name: string, value: number) { if (!Number.isSafeInteger(value) || value < 1) { throw new RangeError( `${name} must be a positive integer; received ${value}`, ) } }