110 lines
7.6 KiB
TypeScript
110 lines
7.6 KiB
TypeScript
import Database from 'better-sqlite3';
|
|
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
|
|
import { newFixture, type Fixture } from '../helpers/fixture.js';
|
|
import { enableIncrementalVacuum, retentionClocks } from '../../src/lib/server/db/retention-clocks.js';
|
|
|
|
let fixture: Fixture;
|
|
beforeEach(async () => { vi.resetModules(); fixture = await newFixture([]); });
|
|
afterEach(async () => { await fixture.cleanup(); });
|
|
const old = new Date(Date.now() - 90 * 86400000).toISOString();
|
|
|
|
it('expires completed file payloads while keeping history, replay identity, holds and active work', async () => {
|
|
const { db } = await import('../../src/lib/server/db/index.js');
|
|
const hosts = await import('../../src/lib/server/hosts/index.js');
|
|
const { pruneHistory, setRetentionControl } = await import('../../src/lib/server/retention.js');
|
|
const { putFileBlob } = await import('../../src/lib/server/db/file-blobs.js');
|
|
const host = hosts.createHost({ name: 'Files' });
|
|
const payload = { files: [{ path: 'plugin.dll', contentBase64: Buffer.from('file').toString('base64') }] };
|
|
const completed = hosts.queueHostOperation(host.id, 'files.stage', payload, { idempotencyKey: 'finished' });
|
|
hosts.reportHostOperation(host.id, completed.id, { state: 'completed', result: { before: [{ path: 'plugin.dll', contentBase64: 'YmVmb3Jl' }] } });
|
|
const active = hosts.queueHostOperation(host.id, 'files.stage', payload);
|
|
const held = hosts.queueHostOperation(host.id, 'files.stage', payload);
|
|
hosts.reportHostOperation(host.id, held.id, { state: 'completed', result: {} });
|
|
setRetentionControl({ category: 'operation', id: held.id, protected: true });
|
|
const failed = hosts.queueHostOperation(host.id, 'files.stage', payload);
|
|
hosts.reportHostOperation(host.id, failed.id, { state: 'failed', error: 'unfinished repair' });
|
|
db().prepare('UPDATE ec_host_operations SET updated_at=?').run(old);
|
|
db().exec("INSERT INTO servers(name) VALUES('s')");
|
|
const hash = putFileBlob(Buffer.from('recipe-only'));
|
|
db().prepare(`INSERT INTO server_deployments(id,server,action,state,stage,started_at,finished_at,triggered_by)
|
|
VALUES('launch','s','create','done','done',?,?,'test')`).run(old, old);
|
|
db().prepare('INSERT INTO server_launch_recipes(deployment_id,recipe) VALUES(?,?)')
|
|
.run('launch', JSON.stringify({ files: [{ path: 'launch.dll', sha256: hash, contentHash: hash }] }));
|
|
expect(pruneHistory('workflow-payload')).toBe(1);
|
|
expect(db().prepare("SELECT state FROM server_deployments WHERE id='launch'").get()).toEqual({ state: 'done' });
|
|
expect(JSON.parse((db().prepare('SELECT recipe FROM server_launch_recipes').get() as { recipe: string }).recipe))
|
|
.toEqual({ files: [{ path: 'launch.dll', sha256: hash }] });
|
|
expect(db().prepare('SELECT 1 FROM file_blobs WHERE sha256=?').get(hash)).toBeUndefined();
|
|
expect(pruneHistory('operation-payload')).toBe(1);
|
|
expect(hosts.getHostOperation(completed.id)).toMatchObject({ state: 'completed', payload: { files: [{ path: 'plugin.dll' }] }, result: { before: [{ path: 'plugin.dll' }] } });
|
|
expect(hosts.getHostOperation(active.id)?.payload).toEqual(payload);
|
|
expect(hosts.getHostOperation(held.id)?.payload).toEqual(payload);
|
|
expect(hosts.getHostOperation(failed.id)?.payload).toEqual(payload);
|
|
expect(hosts.queueHostOperation(host.id, 'files.stage', payload, { idempotencyKey: 'finished' }).id).toBe(completed.id);
|
|
expect(() => hosts.queueHostOperation(host.id, 'files.stage', { files: [] }, { idempotencyKey: 'finished' })).toThrow('different request');
|
|
expect(pruneHistory('operation-payload')).toBe(0);
|
|
});
|
|
|
|
it('retains rebalance recovery files until the move is reconciled, then lets history expire', async () => {
|
|
const { db } = await import('../../src/lib/server/db/index.js');
|
|
const { ensureHostSchema } = await import('../../src/lib/server/hosts/schema.js');
|
|
const { pruneHistory } = await import('../../src/lib/server/retention.js');
|
|
const { putFileBlob } = await import('../../src/lib/server/db/file-blobs.js');
|
|
const { fleetSettings, saveFleetSettings } = await import('../../src/lib/server/settings.js');
|
|
ensureHostSchema(db());
|
|
saveFleetSettings({ ...fleetSettings(), historyKeepCount: 0, provisioningKeepDays: 1, payloadKeepDays: 1 });
|
|
db().prepare(`INSERT INTO server_deployments(id,server,action,state,stage,started_at,finished_at,triggered_by)
|
|
VALUES('move','s','rebuild','done','healthy',?,?,'rebalance:run')`).run(old, old);
|
|
const hash = putFileBlob(Buffer.from('frozen deployed file'));
|
|
db().prepare('INSERT INTO server_launch_recipes(deployment_id,recipe) VALUES(?,?)')
|
|
.run('move', JSON.stringify({ files: [{ path: 'script.gsc', sha256: hash, contentHash: hash }] }));
|
|
db().prepare(`INSERT INTO rebalancing_runs(id,settings,state,created_at,updated_at,message)
|
|
VALUES('run','{}','running',?,?,'waiting')`).run(old, old);
|
|
db().prepare(`INSERT INTO rebalancing_moves(id,run_id,ordinal,server,instance_id,generation,source_host_id,target_host_id,candidate,state,operation_id,message,updated_at)
|
|
VALUES('m','run',0,'s','i',1,'a','b','{}','moving','move','waiting',?)`).run(old);
|
|
expect(pruneHistory('workflow-payload')).toBe(0);
|
|
expect(pruneHistory('provisioning')).toBe(0);
|
|
db().prepare("UPDATE rebalancing_moves SET state='failed'").run();
|
|
expect(pruneHistory('workflow-payload')).toBe(0);
|
|
expect(pruneHistory('provisioning')).toBe(0);
|
|
db().prepare("UPDATE rebalancing_moves SET state='done'").run();
|
|
expect(pruneHistory('workflow-payload')).toBe(1);
|
|
expect(pruneHistory('provisioning')).toBe(1);
|
|
expect(db().prepare('SELECT state,operation_id FROM rebalancing_moves').get()).toEqual({ state: 'done', operation_id: null });
|
|
});
|
|
|
|
it('normalizes legacy retention clocks once and reuses clock indexes', () => {
|
|
const handle = new Database(':memory:');
|
|
try {
|
|
handle.exec(`CREATE TABLE history(id INTEGER PRIMARY KEY, at TEXT); CREATE INDEX history_age ON history(at);
|
|
INSERT INTO history(at) VALUES('2026-01-01 12:00:00'),('2026-01-01T08:00:00-04:00'),(NULL)`);
|
|
retentionClocks(handle, { history: ['at'] });
|
|
expect(handle.prepare('SELECT at FROM history ORDER BY id').all()).toEqual([
|
|
{ at: '2026-01-01T12:00:00.000Z' }, { at: '2026-01-01T12:00:00.000Z' }, { at: null }
|
|
]);
|
|
expect(handle.pragma('index_list(history)')).toHaveLength(1);
|
|
const prepare = vi.spyOn(handle, 'prepare');
|
|
retentionClocks(handle, { history: ['at'] });
|
|
expect(prepare.mock.calls.some(([sql]) => sql.startsWith('UPDATE'))).toBe(false);
|
|
} finally { handle.close(); }
|
|
});
|
|
|
|
it('enables incremental vacuum once and preserves host enable command boundaries', () => {
|
|
const handle = new Database(fixture.dbPath);
|
|
try {
|
|
handle.exec(`CREATE TABLE ec_host_operations(id TEXT, host_id TEXT);
|
|
CREATE TABLE ec_host_enable_requests(host_id TEXT, operation_floor INTEGER);
|
|
INSERT INTO ec_host_operations(rowid,id,host_id) VALUES(10,'before','h'),(30,'after','h');
|
|
INSERT INTO ec_host_enable_requests VALUES('h',20)`);
|
|
enableIncrementalVacuum(handle);
|
|
expect(handle.pragma('auto_vacuum', { simple: true })).toBe(2);
|
|
const eligible = () => handle.prepare(`SELECT id FROM ec_host_operations o JOIN ec_host_enable_requests e ON e.host_id=o.host_id
|
|
WHERE o.rowid>e.operation_floor`).all();
|
|
expect(eligible()).toEqual([{ id: 'after' }]);
|
|
const exec = vi.spyOn(handle, 'exec');
|
|
enableIncrementalVacuum(handle);
|
|
expect(exec.mock.calls).toHaveLength(0);
|
|
expect(eligible()).toEqual([{ id: 'after' }]);
|
|
} finally { handle.close(); }
|
|
});
|