diff --git a/packages/plugin/tests/identity-store-process.test.ts b/packages/plugin/tests/identity-store-process.test.ts new file mode 100644 index 0000000..1daf5d5 --- /dev/null +++ b/packages/plugin/tests/identity-store-process.test.ts @@ -0,0 +1,199 @@ +import { spawn } from 'node:child_process' +import type { ChildProcess } from 'node:child_process' +import { createHash } from 'node:crypto' +import { mkdtemp, readdir, readFile, rm, utimes, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { fileURLToPath, pathToFileURL } from 'node:url' +import { build } from 'esbuild' +import { afterAll, beforeAll, describe, expect, it } from 'vitest' +import type { HostIdentity } from '../src/identity-store.js' +import { IdentityStore } from '../src/identity-store.js' + +const directories: string[] = [] +const children: ChildProcess[] = [] +let worker = '' +let scratch = '' + +beforeAll(async () => { + scratch = await mkdtemp(join(tmpdir(), 'dsh-identity-lock-')) + directories.push(scratch) + const entry = join(scratch, 'identity-store.mjs') + // The lock only means something across real processes, so the store is built + // into a standalone module the workers below import. + await build({ + entryPoints: [fileURLToPath(new URL('../src/identity-store.ts', import.meta.url))], + outfile: entry, bundle: true, platform: 'node', format: 'esm', logLevel: 'silent', + }) + worker = join(scratch, 'worker.mjs') + await writeFile(worker, ` + import { IdentityStore } from ${JSON.stringify(pathToFileURL(entry).href)}; + const [directory, name] = process.argv.slice(2); + process.stdout.write('ready\\n'); + const identity = await new IdentityStore({ directory }).loadOrCreate(name); + process.stdout.write(JSON.stringify(identity) + '\\n'); + `) +}) + +afterAll(async () => { + for (const child of children.splice(0)) child.kill() + await Promise.all(directories.splice(0).map(directory => rm(directory, { recursive: true, force: true }))) +}) + +describe('identity lock across processes', () => { + it('settles two simultaneous first-time creations on one key pair', async () => { + const directory = await temporaryDirectory() + const first = startWorker(directory) + const second = startWorker(directory) + const created = await Promise.all([first.done, second.done]) + + for (const identity of created) { + expect(identity).toMatchObject({ deviceId: created[0]!.deviceId, publicKey: created[0]!.publicKey, privateKey: created[0]!.privateKey }) + } + await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({ + publicKey: created[0]!.publicKey, privateKey: created[0]!.privateKey, + }) + }) + + it('waits out a lock whose owner record has not landed yet instead of reclaiming it', async () => { + const directory = await temporaryDirectory() + const lock = join(directory, 'device.lock') + // The window between the exclusive create and the pid write: the lock + // exists, its record does not. Reclaiming it would admit a second creator + // while the process that created it is still inside the critical section. + await writeFile(lock, '') + + const contender = startWorker(directory) + await contender.started + await settle() + expect(contender.child.exitCode).toBeNull() + expect(await readFile(lock, 'utf8')).toBe('') + expect(await readdir(directory)).toEqual(['device.lock']) + + await rm(lock, { force: true }) + await expect(contender.done).resolves.toMatchObject({ publicKey: expect.any(String) }) + }) + + it('never takes over a live owner, however stale the lock looks', async () => { + const directory = await temporaryDirectory() + const lock = join(directory, 'device.lock') + const owner = `${process.pid}\n` + await writeFile(lock, owner) + // Age is not evidence of abandonment: a suspended owner resumes and still + // owns this file, so no contender may replace it under the old 60s rule. + const aged = new Date(Date.now() - 6 * 60 * 60 * 1000) + await utimes(lock, aged, aged) + + const contender = startWorker(directory) + await contender.started + await settle() + expect(contender.child.exitCode).toBeNull() + expect(await readFile(lock, 'utf8')).toBe(owner) + + // The resumed owner releases; the waiting process then proceeds, having + // never created a lock the owner could have deleted on the way out. + await rm(lock, { force: true }) + await expect(contender.done).resolves.toMatchObject({ publicKey: expect.any(String) }) + expect(await readFile(lock, 'utf8').catch(() => undefined)).toBeUndefined() + }) + + it('reclaims a lock whose owner died', async () => { + const directory = await temporaryDirectory() + await writeFile(join(directory, 'device.lock'), `${await deadPid()}\n`) + + await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({ + publicKey: expect.any(String), + }) + expect(await readdir(directory)).toEqual(['device.json', 'device.key', 'trusted-peers.json']) + }) + + it('reclaims once when two processes race for the same dead lock', async () => { + const directory = await temporaryDirectory() + await writeFile(join(directory, 'device.lock'), `${await deadPid()}\n`) + + const contenders = [startWorker(directory), startWorker(directory)] + const created = await Promise.all(contenders.map(contender => contender.done)) + expect(created[1]).toMatchObject({ deviceId: created[0]!.deviceId, publicKey: created[0]!.publicKey }) + await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({ + publicKey: created[0]!.publicKey, privateKey: created[0]!.privateKey, + }) + }) + + it('reclaims once when two processes race after an interrupted takeover left both device.lock and its real takeover claim', async () => { + const directory = await temporaryDirectory() + const lockRecord = `${await deadPid()}\n` + const takeoverRecord = `${await deadPid()}\n` + const takeoverName = `device.lock.takeover-${createHash('sha256').update(lockRecord).digest('hex').slice(0, 16)}` + await writeFile(join(directory, 'device.lock'), lockRecord) + await writeFile(join(directory, takeoverName), takeoverRecord) + + const contenders = [startWorker(directory), startWorker(directory)] + const created = await Promise.all(contenders.map(contender => contender.done)) + expect(created[1]).toMatchObject({ deviceId: created[0]!.deviceId, publicKey: created[0]!.publicKey }) + expect((await readdir(directory)).sort()).toEqual(['device.json', 'device.key', 'trusted-peers.json']) + await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({ + publicKey: created[0]!.publicKey, privateKey: created[0]!.privateKey, + }) + }) + + it('keeps the pair consistent when a reset overlaps another process creating', async () => { + const directory = await temporaryDirectory() + const contender = startWorker(directory) + const created = await new IdentityStore({ directory }).reset('Workstation') + const workerIdentity = await contender.done + + const settled = await new IdentityStore({ directory }).loadOrCreate('Workstation') + expect(settled.publicKey).toBe(created.publicKey) + expect([created.deviceId, workerIdentity.deviceId]).toContain(settled.deviceId) + }) +}) + +function startWorker(directory: string, name = 'Workstation') { + const child = spawn(process.execPath, [worker, directory, name], { stdio: ['ignore', 'pipe', 'pipe'] }) + children.push(child) + let stdout = '' + let stderr = '' + let ready: () => void = () => undefined + const started = new Promise(resolve => { ready = resolve }) + child.stdout.setEncoding('utf8') + child.stderr.setEncoding('utf8') + child.stdout.on('data', (chunk: string) => { + stdout += chunk + if (stdout.includes('ready\n')) ready() + }) + child.stderr.on('data', (chunk: string) => { stderr += chunk }) + const done = new Promise((resolve, reject) => { + child.once('error', reject) + child.once('close', code => { + if (code !== 0) { + reject(new Error(`identity worker exited with ${code}: ${stderr}`)) + return + } + try { + resolve(JSON.parse(stdout.trim().split('\n').pop() ?? '') as HostIdentity) + } catch { + reject(new Error(`unexpected identity worker output: ${stdout}`)) + } + }) + }) + return { child, started, done } +} + +/** A pid that provably named a process which has since exited. */ +async function deadPid(): Promise { + const child = spawn(process.execPath, ['-e', ''], { stdio: 'ignore' }) + const pid = child.pid! + await new Promise(resolve => child.once('exit', () => resolve())) + return pid +} + +async function temporaryDirectory(): Promise { + const directory = await mkdtemp(join(tmpdir(), 'dsh-identity-lock-')) + directories.push(directory) + return directory +} + +/** Let a worker reach and contend for the lock before asserting on it. */ +function settle(): Promise { + return new Promise(resolve => setTimeout(resolve, 400)) +}