Throttle agent usage writes and cache inventory per request
This commit is contained in:
@@ -0,0 +1,146 @@
|
||||
import { setImmediate } from 'node:timers/promises';
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
||||
import type { HostInventory } from '../../src/lib/hosts.js';
|
||||
import { newFixture, type Fixture } from '../helpers/fixture.js';
|
||||
|
||||
let fixture: Fixture;
|
||||
const epoch = Date.parse('2026-10-05T12:00:00Z');
|
||||
const inventory = { hostname: 'request-cache-host', protocolVersion: 1, dockerRunning: true, directoriesWritable: true,
|
||||
storageAvailable: 100 * 1024 ** 3, runtimeImages: ['plutainer:test'], libraries: [{ id: 'test-library', state: 'ready' }] };
|
||||
beforeEach(async () => {
|
||||
vi.resetModules(); vi.useFakeTimers({ toFake: ['Date'] }); vi.setSystemTime(epoch);
|
||||
fixture = await newFixture([]);
|
||||
});
|
||||
afterEach(async () => { vi.restoreAllMocks(); vi.useRealTimers(); await fixture.cleanup(); });
|
||||
|
||||
async function enrolled() {
|
||||
const hosts = await import('../../src/lib/server/hosts/index.js');
|
||||
const context = await import('../../src/lib/server/hosts/request-context.js');
|
||||
const host = hosts.createHost({ name: 'Request cache host' });
|
||||
const { credential } = hosts.enrollHost(hosts.createEnrollment(host.id).token, inventory);
|
||||
// Finish enrollment's independent availability refresh before counting parses.
|
||||
await setImmediate();
|
||||
return { ...hosts, ...context, hostId: host.id, credential };
|
||||
}
|
||||
|
||||
describe('agent credential usage writes', () => {
|
||||
it('writes on first use and at most once per minute, including after reopening the database', async () => {
|
||||
const api = await enrolled();
|
||||
const { db, closeDb } = await import('../../src/lib/server/db/index.js');
|
||||
db().exec(`CREATE TABLE credential_usage_writes (credential_id TEXT, at TEXT);
|
||||
CREATE TRIGGER count_credential_usage AFTER UPDATE OF last_used_at ON ec_host_credentials
|
||||
BEGIN INSERT INTO credential_usage_writes VALUES (NEW.id, NEW.last_used_at); END;`);
|
||||
const writes = () => db().prepare('SELECT at FROM credential_usage_writes').all();
|
||||
const authenticate = () => expect(api.authenticateCredential(api.credential)?.id).toBe(api.hostId);
|
||||
authenticate(); authenticate(); authenticate();
|
||||
expect(writes()).toEqual([{ at: new Date(epoch).toISOString() }]);
|
||||
vi.setSystemTime(epoch + 59_999);
|
||||
authenticate();
|
||||
closeDb(); authenticate();
|
||||
expect(writes()).toHaveLength(1);
|
||||
vi.setSystemTime(epoch + 60_000);
|
||||
authenticate(); authenticate();
|
||||
expect(writes()).toEqual([{ at: new Date(epoch).toISOString() }, { at: new Date(epoch + 60_000).toISOString() }]);
|
||||
expect(api.authenticateCredential('invalid')).toBeNull();
|
||||
expect(writes()).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('checks revocation immediately and records first use of a replacement credential', async () => {
|
||||
const api = await enrolled();
|
||||
const { db } = await import('../../src/lib/server/db/index.js');
|
||||
await api.withHostRequestContext(() => {
|
||||
expect(api.authenticateCredential(api.credential)?.id).toBe(api.hostId);
|
||||
vi.setSystemTime(epoch + 1000);
|
||||
const replacement = api.rotateCredential(api.hostId);
|
||||
expect(api.authenticateCredential(api.credential)).toBeNull();
|
||||
expect(api.authenticateCredential(replacement)?.id).toBe(api.hostId);
|
||||
expect(db().prepare('SELECT last_used_at FROM ec_host_credentials WHERE revoked_at IS NULL').get())
|
||||
.toEqual({ last_used_at: new Date(epoch + 1000).toISOString() });
|
||||
api.revokeCredentials(api.hostId);
|
||||
expect(api.authenticateCredential(replacement)).toBeNull();
|
||||
expect(api.getHost(api.hostId)?.credentialActive).toBe(false);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('request-scoped host inventory parsing', () => {
|
||||
it('parses once across authentication, host reads, and operation handling within a request', async () => {
|
||||
const api = await enrolled();
|
||||
const serialized = JSON.stringify(inventory);
|
||||
const parse = vi.spyOn(JSON, 'parse');
|
||||
await api.withHostRequestContext(async () => {
|
||||
const authenticated = api.authenticateCredential(api.credential)!;
|
||||
const operation = api.queueHostOperation(api.hostId, 'instance.inspect', { name: 'server' });
|
||||
api.pendingHostOperationRows(api.hostId, 'read', false);
|
||||
api.reportHostOperationStatus(api.hostId, operation.id, { state: 'accepted' });
|
||||
await Promise.resolve();
|
||||
for (let i = 0; i < 10; i++) expect(api.getHost(api.hostId)?.inventory).toBe(authenticated.inventory);
|
||||
expect(api.requireReadyHost(api.hostId).inventory).toBe(authenticated.inventory);
|
||||
expect(api.listHosts()[0].inventory).toBe(authenticated.inventory);
|
||||
});
|
||||
expect(parse.mock.calls.filter(([value]) => value === serialized)).toHaveLength(1);
|
||||
await api.withHostRequestContext(() => api.getHost(api.hostId));
|
||||
expect(parse.mock.calls.filter(([value]) => value === serialized)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('keeps host metadata fresh and reparses changed inventory, including after rollback', async () => {
|
||||
const api = await enrolled();
|
||||
const { db } = await import('../../src/lib/server/db/index.js');
|
||||
await api.withHostRequestContext(() => {
|
||||
const original = api.getHost(api.hostId)!;
|
||||
const updated = api.updateHost(api.hostId, { name: 'Renamed host', mode: 'draining' });
|
||||
expect(updated).toMatchObject({ name: 'Renamed host', mode: 'draining', readiness: 'draining' });
|
||||
expect(updated.inventory).toBe(original.inventory);
|
||||
const heartbeat = api.heartbeat(api.hostId, { ...inventory, storageAvailable: 123 });
|
||||
expect(heartbeat.inventory).not.toBe(original.inventory);
|
||||
expect(api.getHost(api.hostId)?.inventory).toBe(heartbeat.inventory);
|
||||
expect(api.getHost(api.hostId)?.inventory.storageAvailable).toBe(123);
|
||||
expect(() => db().transaction(() => {
|
||||
db().prepare('UPDATE ec_hosts SET inventory=? WHERE id=?').run(JSON.stringify({ ...inventory, storageAvailable: 456 }), api.hostId);
|
||||
expect(api.getHost(api.hostId)?.inventory.storageAvailable).toBe(456);
|
||||
throw new Error('rollback');
|
||||
})()).toThrow('rollback');
|
||||
expect(api.getHost(api.hostId)?.inventory.storageAvailable).toBe(123);
|
||||
});
|
||||
});
|
||||
|
||||
it('isolates overlapping requests and does not cache reads outside a request', async () => {
|
||||
const api = await enrolled();
|
||||
let release!: () => void;
|
||||
const gate = new Promise<void>(resolve => { release = resolve; });
|
||||
let first!: HostInventory;
|
||||
const request = api.withHostRequestContext(async () => {
|
||||
first = api.getHost(api.hostId)!.inventory;
|
||||
await gate;
|
||||
expect(api.getHost(api.hostId)!.inventory).toBe(first);
|
||||
});
|
||||
try {
|
||||
await api.withHostRequestContext(async () => {
|
||||
const second = api.getHost(api.hostId)!.inventory;
|
||||
expect(second).not.toBe(first);
|
||||
await Promise.resolve();
|
||||
expect(api.getHost(api.hostId)!.inventory).toBe(second);
|
||||
});
|
||||
expect(api.getHost(api.hostId)!.inventory).not.toBe(api.getHost(api.hostId)!.inventory);
|
||||
} finally { release(); await request; }
|
||||
});
|
||||
|
||||
it.each([false, true])('releases cached inventory from inherited work after request completion (failed: %s)', async failed => {
|
||||
const api = await enrolled();
|
||||
let release!: () => void;
|
||||
const gate = new Promise<void>(resolve => { release = resolve; });
|
||||
let detached!: Promise<void>;
|
||||
let original!: HostInventory;
|
||||
const request = api.withHostRequestContext(() => {
|
||||
original = api.getHost(api.hostId)!.inventory;
|
||||
detached = gate.then(() => {
|
||||
const later = api.getHost(api.hostId)!.inventory;
|
||||
expect(later).not.toBe(original);
|
||||
expect(api.getHost(api.hostId)!.inventory).not.toBe(later);
|
||||
});
|
||||
if (failed) throw new Error('request failed');
|
||||
});
|
||||
if (failed) await expect(request).rejects.toThrow('request failed'); else await request;
|
||||
release(); await detached;
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user