Files
maka/packages/storage/src/__tests__/sqlite-long-term-memory-crash.test.ts
T
agent-radar 7be535059e
Dependency audit / audit (push) Canceled after 0s
CI / plan (push) Canceled after 0s
Gitoxide helper admission / macos-latest (push) Canceled after 0s
Gitoxide helper admission / ubuntu-latest (push) Canceled after 0s
Gitoxide helper admission / windows-latest (push) Canceled after 0s
Runtime Host peer admission / quality (push) Canceled after 0s
Windows recovery / windows_recovery (push) Canceled after 0s
CI / heavy (push) Canceled after 0s
CI / test (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 19:05:14 +08:00

155 lines
5.1 KiB
TypeScript

/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import assert from 'node:assert/strict';
import { spawn } from 'node:child_process';
import { writeSync } from 'node:fs';
import { mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { test } from 'node:test';
import { fileURLToPath } from 'node:url';
import type { MemoryItemWrite } from '@maka/core/long-term-memory';
import {
SqliteMemoryItemStore,
type SqliteMemoryItemStoreFailpoint,
} from '../sqlite-long-term-memory-store.js';
const childMode = process.env.MAKA_LONG_TERM_MEMORY_CRASH_CHILD;
if (childMode) {
await runCrashChild(childMode);
} else {
test('retains one committed Item and its receipt when killed between COMMIT and return', {
timeout: 30_000,
}, async () => {
const root = await mkdtemp(join(tmpdir(), 'maka-long-term-memory-crash-'));
const databasePath = join(root, 'memory.sqlite');
const child = spawn(process.execPath, [fileURLToPath(import.meta.url)], {
env: {
...process.env,
MAKA_LONG_TERM_MEMORY_CRASH_CHILD: 'after_commit',
MAKA_LONG_TERM_MEMORY_CRASH_DB: databasePath,
},
stdio: ['ignore', 'pipe', 'pipe'],
});
try {
await waitForReady(child);
child.kill('SIGKILL');
await new Promise<void>((resolve, reject) => {
child.once('exit', () => resolve());
child.once('error', reject);
});
const store = new SqliteMemoryItemStore(databasePath, { now: () => 1_000 });
try {
const record = await store.readItem('crash-item');
assert.equal(record?.item.content, memoryWrite().content);
assert.ok(await store.readOperation('crash-create'));
const replayed = await store.applyMutations({
operationId: 'crash-create',
mutations: [{ type: 'create', item: memoryWrite() }],
});
assert.equal(replayed.replayed, true);
assert.equal(replayed.results[0]?.itemId, 'crash-item');
assert.equal((await store.searchByKeys({ terms: ['crash'], match: 'exact' })).length, 1);
} finally {
store.close();
}
} finally {
if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL');
await rm(root, { recursive: true, force: true });
}
});
}
async function runCrashChild(mode: string): Promise<void> {
if (mode !== 'after_commit') throw new Error(`Unknown long-term memory crash mode ${mode}`);
const databasePath = requiredEnv('MAKA_LONG_TERM_MEMORY_CRASH_DB');
const failpoint = (point: SqliteMemoryItemStoreFailpoint): void => {
if (point === 'after_commit') blockUntilKilled();
};
const store = new SqliteMemoryItemStore(databasePath, {
now: () => 1_000,
idFactory: () => 'crash-item',
failpoint,
});
await store.applyMutations({
operationId: 'crash-create',
mutations: [{ type: 'create', item: memoryWrite() }],
});
throw new Error('Long-term memory crash mode missed its failpoint');
}
function waitForReady(child: ReturnType<typeof spawn>): Promise<void> {
return new Promise((resolve, reject) => {
let stdout = '';
let stderr = '';
child.stdout?.on('data', (chunk) => {
stdout += String(chunk);
if (stdout.includes('READY\n')) resolve();
});
child.stderr?.on('data', (chunk) => {
stderr += String(chunk);
});
child.once('exit', (code, signal) => {
reject(
new Error(
`long-term memory crash child exited before READY: code=${code} signal=${signal} ${stderr}`,
),
);
});
child.once('error', reject);
});
}
function memoryWrite(): MemoryItemWrite {
return {
content: 'Committed before the process was killed.',
kind: 'knowledge',
statementType: 'fact',
temporalType: 'undated',
scopeType: 'global',
observedAt: 900,
origin: 'agent_extracted',
keys: [{ key: 'crash', keyType: 'exact', keyOrigin: 'deterministic' }],
sources: [
{
sessionId: 'session-crash',
runId: 'run-crash',
turnId: 'turn-crash',
eventId: 'event-crash',
},
],
};
}
function blockUntilKilled(): never {
writeSync(1, 'READY\n');
Atomics.wait(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), 0, 0);
throw new Error('unreachable');
}
function requiredEnv(name: string): string {
const value = process.env[name];
if (!value) throw new Error(`Missing ${name}`);
return value;
}