devcontour-harness 0.1.0-alpha.45 → 0.1.0-alpha.47
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +20 -2
- package/docs/architecture.md +8 -0
- package/docs/compatibility.md +4 -1
- package/docs/contracts.md +25 -5
- package/docs/release-notes/0.1.0-alpha.46.md +63 -0
- package/docs/release-notes/0.1.0-alpha.47.md +138 -0
- package/docs/upgrade.md +119 -19
- package/lib/agents/review-probe.js +8 -3
- package/lib/contracts/cli.d.ts +11 -0
- package/lib/contracts/events.d.ts +13 -1
- package/lib/contracts/events.js +2 -0
- package/lib/contracts/execution.d.ts +1 -0
- package/lib/contracts/execution.js +13 -0
- package/lib/contracts/handoff.d.ts +1 -0
- package/lib/contracts/handoff.js +6 -1
- package/lib/contracts/ports.d.ts +54 -0
- package/lib/contracts/published.d.ts +8 -0
- package/lib/contracts/report.d.ts +4 -0
- package/lib/control/harness.d.ts +1 -1
- package/lib/control/workflow.d.ts +5 -1
- package/lib/control/workflow.js +18 -3
- package/lib/engine/classify.d.ts +6 -0
- package/lib/engine/classify.js +26 -0
- package/lib/engine/engine.d.ts +25 -2
- package/lib/engine/engine.js +76 -7
- package/lib/engine/runner.d.ts +11 -6
- package/lib/engine/runner.js +107 -34
- package/lib/environment/host-load.d.ts +12 -0
- package/lib/environment/host-load.js +7 -0
- package/lib/environment/lifecycle.d.ts +12 -1
- package/lib/environment/lifecycle.js +19 -2
- package/lib/environment/process.d.ts +71 -1
- package/lib/environment/process.js +149 -31
- package/lib/handoff/pack.js +7 -1
- package/lib/index.d.ts +5 -1
- package/lib/index.js +7 -1
- package/lib/report/document.js +2 -0
- package/lib/storage/sqlite.d.ts +47 -4
- package/lib/storage/sqlite.js +279 -34
- package/lib/testing/store-contract.d.ts +9 -0
- package/lib/testing/store-contract.js +235 -0
- package/lib/verification/applicability.d.ts +25 -2
- package/lib/verification/applicability.js +34 -1
- package/lib/verification/gates-at.js +15 -1
- package/lib/verification/gates.d.ts +3 -10
- package/lib/verification/gates.js +136 -15
- package/lib/verification/reaped.d.ts +24 -0
- package/lib/verification/reaped.js +24 -0
- package/package.json +1 -1
- package/schemas/execution-document.schema.json +4 -0
- package/schemas/handoff-pack.schema.json +4 -0
- package/schemas/run-event.schema.json +2 -0
- package/schemas/value-report.schema.json +3 -1
package/lib/storage/sqlite.js
CHANGED
|
@@ -47,13 +47,29 @@ function fileMark(file) {
|
|
|
47
47
|
}
|
|
48
48
|
/** Сколько событий одной транзакции допускается (договор курсора адаптеров). */
|
|
49
49
|
const MAX_EVENTS_PER_TRANSACTION = 1024;
|
|
50
|
+
/**
|
|
51
|
+
* Строки аренды попыток (D53). Создаётся первой строкой: открытие и чтение
|
|
52
|
+
* базы прежней версии таблицу не добавляют.
|
|
53
|
+
*/
|
|
54
|
+
const LEASES_TABLE = 'CREATE TABLE IF NOT EXISTS leases (kind TEXT NOT NULL, id TEXT NOT NULL, token TEXT NOT NULL, owner TEXT NOT NULL, engine TEXT NOT NULL, until INTEGER NOT NULL, PRIMARY KEY(kind, id))';
|
|
55
|
+
const leaseOf = (row) => ({
|
|
56
|
+
id: row.id,
|
|
57
|
+
token: row.token,
|
|
58
|
+
owner: row.owner,
|
|
59
|
+
engineVersion: row.engine || undefined,
|
|
60
|
+
leaseUntil: row.until,
|
|
61
|
+
});
|
|
50
62
|
/**
|
|
51
63
|
* Standalone ExecutionStore: нейтральный документ, события и локальные
|
|
52
64
|
* записи в одной SQLite. Транзакция — `BEGIN IMMEDIATE` (вложенная —
|
|
53
|
-
* SAVEPOINT); документ читается
|
|
54
|
-
*
|
|
55
|
-
*
|
|
56
|
-
*
|
|
65
|
+
* SAVEPOINT); документ читается не больше раза на внешнюю транзакцию — при
|
|
66
|
+
* первом обращении к записям модели, — вложенные работают с ним же и при
|
|
67
|
+
* отказе восстанавливают его снимок и свой буфер событий. Документ пишется,
|
|
68
|
+
* только если транзакция изменила записи модели, и проверяется схемой при
|
|
69
|
+
* каждой такой фиксации: состояние вне договора не записывается.
|
|
70
|
+
*
|
|
71
|
+
* Аренда попыток (D53) — строки таблицы `leases` в той же базе: продление
|
|
72
|
+
* (`renewLease`) меняет одну строку, не читая и не переписывая документ.
|
|
57
73
|
*
|
|
58
74
|
* Версия: в `meta` записаны версия формата и версия писателя. Неизвестная
|
|
59
75
|
* версия формата отклоняется при открытии, до любой записи.
|
|
@@ -105,6 +121,15 @@ export class SqliteExecutionStore {
|
|
|
105
121
|
this.db
|
|
106
122
|
.prepare('INSERT OR IGNORE INTO state VALUES(1, ?)')
|
|
107
123
|
.run(JSON.stringify(emptyDocument()));
|
|
124
|
+
// Миграция D53: сроки активных попыток прежней версии переходят в
|
|
125
|
+
// строки той же транзакцией, что ставит метку. Иначе процесс прежней
|
|
126
|
+
// версии успел бы продлить срок в документе между двумя шагами.
|
|
127
|
+
const doc = this.load();
|
|
128
|
+
if (!doc.leaseRows && doc.attempts.some((a) => a.status === 'active')) {
|
|
129
|
+
this.markLeaseRows(doc);
|
|
130
|
+
this.writeDocument(doc);
|
|
131
|
+
this.bumpDataVersion();
|
|
132
|
+
}
|
|
108
133
|
this.db.exec('COMMIT');
|
|
109
134
|
}
|
|
110
135
|
catch (error) {
|
|
@@ -165,9 +190,124 @@ export class SqliteExecutionStore {
|
|
|
165
190
|
db.close();
|
|
166
191
|
}
|
|
167
192
|
}
|
|
193
|
+
/**
|
|
194
|
+
* Документ с наложенными сроками аренды: при метке срок активной попытки —
|
|
195
|
+
* из её строки, пока token строки равен token попытки; без такой строки
|
|
196
|
+
* аренды нет (0). Без метки (документ прежней версии) источник — документ.
|
|
197
|
+
*/
|
|
168
198
|
load() {
|
|
169
199
|
const row = this.db.prepare('SELECT data FROM state WHERE id=1').get();
|
|
170
|
-
|
|
200
|
+
const doc = parseDocument(row.data);
|
|
201
|
+
if (doc.leaseRows) {
|
|
202
|
+
const rows = new Map(this.leaseRows().map((r) => [r.id, r]));
|
|
203
|
+
for (const a of doc.attempts)
|
|
204
|
+
if (a.status === 'active') {
|
|
205
|
+
const lease = rows.get(a.id);
|
|
206
|
+
a.leaseUntil = lease && lease.token === a.token ? lease.until : 0;
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
return doc;
|
|
210
|
+
}
|
|
211
|
+
hasLeases = false;
|
|
212
|
+
/** Есть ли таблица строк аренды (её создаёт первая строка). */
|
|
213
|
+
leaseTable() {
|
|
214
|
+
return (this.hasLeases ||= !!this.db
|
|
215
|
+
.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='leases'")
|
|
216
|
+
.get());
|
|
217
|
+
}
|
|
218
|
+
leaseRows() {
|
|
219
|
+
if (!this.leaseTable())
|
|
220
|
+
return [];
|
|
221
|
+
return this.db
|
|
222
|
+
.prepare("SELECT id, token, owner, engine, until FROM leases WHERE kind='attempt'")
|
|
223
|
+
.all();
|
|
224
|
+
}
|
|
225
|
+
putLeaseRow(a) {
|
|
226
|
+
this.db.exec(LEASES_TABLE);
|
|
227
|
+
this.hasLeases = true;
|
|
228
|
+
this.db
|
|
229
|
+
.prepare("INSERT OR REPLACE INTO leases VALUES('attempt', ?, ?, ?, ?, ?)")
|
|
230
|
+
.run(a.id, a.token, a.owner, a.engineVersion ?? '', a.leaseUntil);
|
|
231
|
+
}
|
|
232
|
+
deleteLeaseRow(id) {
|
|
233
|
+
if (this.leaseTable())
|
|
234
|
+
this.db.prepare("DELETE FROM leases WHERE kind='attempt' AND id=?").run(id);
|
|
235
|
+
}
|
|
236
|
+
/** Метка D53 и строки всех активных попыток документа — в открытой транзакции. */
|
|
237
|
+
markLeaseRows(doc) {
|
|
238
|
+
for (const a of doc.attempts)
|
|
239
|
+
if (a.status === 'active')
|
|
240
|
+
this.putLeaseRow(a);
|
|
241
|
+
doc.leaseRows = true;
|
|
242
|
+
}
|
|
243
|
+
/** Документ проверяется схемой и пишется; растёт `sequence`. */
|
|
244
|
+
writeDocument(doc) {
|
|
245
|
+
doc.sequence++;
|
|
246
|
+
const parsed = executionDocumentSchema.parse(doc);
|
|
247
|
+
this.db.prepare('UPDATE state SET data=? WHERE id=1').run(JSON.stringify(parsed));
|
|
248
|
+
}
|
|
249
|
+
/** `PRAGMA data_version` на момент последней проверки документа этим соединением. */
|
|
250
|
+
validatedAt;
|
|
251
|
+
/**
|
|
252
|
+
* Проверка формата в начале транзакции без разбора документа на каждой.
|
|
253
|
+
* Документ разбирается строгой схемой, если его могло изменить другое
|
|
254
|
+
* соединение (`PRAGMA data_version` сменился) с прошлой проверки: документ
|
|
255
|
+
* вне договора (например, более новой версии) — отказ до любой записи и в
|
|
256
|
+
* транзакции, которая только продлевает аренду строкой. Свои фиксации
|
|
257
|
+
* `data_version` этого соединения не меняют: продления одного процесса
|
|
258
|
+
* документ не разбирают. Возвращает разобранный документ или `undefined`.
|
|
259
|
+
*/
|
|
260
|
+
validate() {
|
|
261
|
+
const { data_version } = this.db.prepare('PRAGMA data_version').get();
|
|
262
|
+
if (data_version === this.validatedAt)
|
|
263
|
+
return undefined;
|
|
264
|
+
const doc = this.load();
|
|
265
|
+
this.validatedAt = data_version;
|
|
266
|
+
return doc;
|
|
267
|
+
}
|
|
268
|
+
/** Версия данных (`ExecutionView.dataVersion`): продление строкой её не меняет. */
|
|
269
|
+
dataVersion() {
|
|
270
|
+
const row = this.db.prepare("SELECT value FROM meta WHERE key='dataVersion'").get();
|
|
271
|
+
return Number(row?.value ?? 0);
|
|
272
|
+
}
|
|
273
|
+
bumpDataVersion() {
|
|
274
|
+
this.db
|
|
275
|
+
.prepare("INSERT OR REPLACE INTO meta VALUES('dataVersion', ?)")
|
|
276
|
+
.run(String(this.dataVersion() + 1));
|
|
277
|
+
}
|
|
278
|
+
/**
|
|
279
|
+
* Шаг вниз перед откатом на версию без строк аренды (D53): срок строки
|
|
280
|
+
* копируется в документ, метка и строки снимаются одной транзакцией. Без
|
|
281
|
+
* него прежняя версия отказывала бы навсегда. Выполняется после остановки
|
|
282
|
+
* очереди; следующее открытие этой версией с активными попытками снова
|
|
283
|
+
* перенесёт сроки в строки. Возвращает число активных попыток, чей срок
|
|
284
|
+
* перенесён в документ.
|
|
285
|
+
*/
|
|
286
|
+
stepDownLeases() {
|
|
287
|
+
if (this.frame)
|
|
288
|
+
throw new Error('Шаг вниз — вне транзакции');
|
|
289
|
+
if (this.options.readOnly)
|
|
290
|
+
throw new HarnessError('STATE_VERSION_UNSUPPORTED', 'Состояние открыто только для чтения');
|
|
291
|
+
this.db.exec('BEGIN IMMEDIATE');
|
|
292
|
+
try {
|
|
293
|
+
const doc = this.load();
|
|
294
|
+
const active = doc.leaseRows ? doc.attempts.filter((a) => a.status === 'active').length : 0;
|
|
295
|
+
if (doc.leaseRows || this.leaseRows().length) {
|
|
296
|
+
delete doc.leaseRows;
|
|
297
|
+
if (this.leaseTable())
|
|
298
|
+
this.db.prepare("DELETE FROM leases WHERE kind='attempt'").run();
|
|
299
|
+
this.writeDocument(doc);
|
|
300
|
+
this.bumpDataVersion();
|
|
301
|
+
}
|
|
302
|
+
this.db.exec('COMMIT');
|
|
303
|
+
return active;
|
|
304
|
+
}
|
|
305
|
+
catch (error) {
|
|
306
|
+
this.hasLeases = false;
|
|
307
|
+
if (this.db.isTransaction)
|
|
308
|
+
this.db.exec('ROLLBACK');
|
|
309
|
+
throw error;
|
|
310
|
+
}
|
|
171
311
|
}
|
|
172
312
|
read(fn) {
|
|
173
313
|
if (this.frame)
|
|
@@ -176,7 +316,7 @@ export class SqliteExecutionStore {
|
|
|
176
316
|
return fn(this.view(this.reading));
|
|
177
317
|
this.db.exec('BEGIN');
|
|
178
318
|
try {
|
|
179
|
-
this.reading = {
|
|
319
|
+
this.reading = { dirty: false, touched: false, drafts: [], depth: 0, doc: this.validate() };
|
|
180
320
|
const value = fn(this.view(this.reading));
|
|
181
321
|
this.db.exec('COMMIT');
|
|
182
322
|
return value;
|
|
@@ -195,17 +335,31 @@ export class SqliteExecutionStore {
|
|
|
195
335
|
const outer = this.frame;
|
|
196
336
|
const point = 'harness_' + ++this.savepoint;
|
|
197
337
|
this.db.exec(outer ? `SAVEPOINT ${point}` : 'BEGIN IMMEDIATE');
|
|
198
|
-
|
|
338
|
+
// Документ читается при первом обращении к записям модели (`doc` кадра):
|
|
339
|
+
// продление аренды строкой его не разбирает и не пишет.
|
|
340
|
+
let validated;
|
|
199
341
|
try {
|
|
200
342
|
if (!outer)
|
|
201
|
-
|
|
343
|
+
validated = this.validate();
|
|
202
344
|
}
|
|
203
345
|
catch (error) {
|
|
204
346
|
this.db.exec('ROLLBACK');
|
|
205
347
|
throw error;
|
|
206
348
|
}
|
|
207
|
-
const frame = outer ?? {
|
|
208
|
-
|
|
349
|
+
const frame = outer ?? {
|
|
350
|
+
dirty: false,
|
|
351
|
+
touched: false,
|
|
352
|
+
drafts: [],
|
|
353
|
+
depth: 0,
|
|
354
|
+
doc: validated,
|
|
355
|
+
};
|
|
356
|
+
const saved = outer
|
|
357
|
+
? {
|
|
358
|
+
doc: frame.doc ? structuredClone(frame.doc) : undefined,
|
|
359
|
+
dirty: frame.dirty,
|
|
360
|
+
touched: frame.touched,
|
|
361
|
+
}
|
|
362
|
+
: undefined;
|
|
209
363
|
const drafts = frame.drafts.length;
|
|
210
364
|
frame.depth++;
|
|
211
365
|
this.frame = frame;
|
|
@@ -219,21 +373,32 @@ export class SqliteExecutionStore {
|
|
|
219
373
|
else {
|
|
220
374
|
if (frame.drafts.length > MAX_EVENTS_PER_TRANSACTION)
|
|
221
375
|
throw new Error('Слишком много событий в одной транзакции');
|
|
222
|
-
frame.
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
if (
|
|
376
|
+
if (frame.dirty)
|
|
377
|
+
this.writeDocument(frame.doc);
|
|
378
|
+
const events = kind !== 'heartbeat' && frame.drafts.length > 0;
|
|
379
|
+
if (events)
|
|
226
380
|
this.writeEvents(frame.drafts);
|
|
381
|
+
if (frame.dirty || frame.touched || events)
|
|
382
|
+
this.bumpDataVersion();
|
|
227
383
|
this.db.exec('COMMIT');
|
|
228
384
|
}
|
|
229
385
|
return value;
|
|
230
386
|
}
|
|
231
387
|
catch (error) {
|
|
388
|
+
// Таблица строк аренды, созданная откаченной частью, исчезла вместе с ней.
|
|
389
|
+
this.hasLeases = false;
|
|
232
390
|
if (outer) {
|
|
233
391
|
this.db.exec(`ROLLBACK TO ${point}; RELEASE ${point}`);
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
392
|
+
// Документ, прочитанный вложенной частью, читается заново из базы.
|
|
393
|
+
if (saved.doc && frame.doc) {
|
|
394
|
+
for (const key of Object.keys(frame.doc))
|
|
395
|
+
delete frame.doc[key];
|
|
396
|
+
Object.assign(frame.doc, saved.doc);
|
|
397
|
+
}
|
|
398
|
+
else
|
|
399
|
+
frame.doc = saved.doc;
|
|
400
|
+
frame.dirty = saved.dirty;
|
|
401
|
+
frame.touched = saved.touched;
|
|
237
402
|
frame.drafts.length = drafts;
|
|
238
403
|
}
|
|
239
404
|
else
|
|
@@ -265,20 +430,83 @@ export class SqliteExecutionStore {
|
|
|
265
430
|
this.db.close();
|
|
266
431
|
}
|
|
267
432
|
view(frame) {
|
|
268
|
-
const
|
|
433
|
+
const loaded = () => (frame.doc ??= this.load());
|
|
434
|
+
const doc = () => new DocumentView(loaded());
|
|
435
|
+
// Изменение записи модели: документ будет записан при фиксации.
|
|
436
|
+
const edit = () => {
|
|
437
|
+
if (this.frame !== frame)
|
|
438
|
+
throw new Error('Запись вне транзакции');
|
|
439
|
+
frame.dirty = true;
|
|
440
|
+
return doc();
|
|
441
|
+
};
|
|
269
442
|
const db = this.db;
|
|
270
443
|
const inTx = () => this.frame === frame;
|
|
271
444
|
return {
|
|
272
|
-
control: () => doc.control(),
|
|
273
|
-
controller: () => doc.controller(),
|
|
274
|
-
graph: (id) => doc.graph(id),
|
|
275
|
-
graphs: () => doc.graphs(),
|
|
276
|
-
work: (id) => doc.work(id),
|
|
277
|
-
works: (graphId) => doc.works(graphId),
|
|
278
|
-
attempt: (id) => doc.attempt(id),
|
|
279
|
-
attempts: (workId) => doc.attempts(workId),
|
|
280
|
-
|
|
281
|
-
|
|
445
|
+
control: () => doc().control(),
|
|
446
|
+
controller: () => doc().controller(),
|
|
447
|
+
graph: (id) => doc().graph(id),
|
|
448
|
+
graphs: () => doc().graphs(),
|
|
449
|
+
work: (id) => doc().work(id),
|
|
450
|
+
works: (graphId) => doc().works(graphId),
|
|
451
|
+
attempt: (id) => doc().attempt(id),
|
|
452
|
+
attempts: (workId) => doc().attempts(workId),
|
|
453
|
+
activeAttempts: () => doc()
|
|
454
|
+
.attempts()
|
|
455
|
+
.filter((a) => a.status === 'active'),
|
|
456
|
+
verification: (id) => doc().verification(id),
|
|
457
|
+
verifications: () => doc().verifications(),
|
|
458
|
+
attemptLease: (id) => {
|
|
459
|
+
// Строка есть только при метке: её достаточно, документ не читается.
|
|
460
|
+
const row = this.leaseTable()
|
|
461
|
+
? db
|
|
462
|
+
.prepare("SELECT id, token, owner, engine, until FROM leases WHERE kind='attempt' AND id=?")
|
|
463
|
+
.get(id)
|
|
464
|
+
: undefined;
|
|
465
|
+
if (row)
|
|
466
|
+
return leaseOf(row);
|
|
467
|
+
// Без строки: у документа прежней версии (без метки) срок — в нём.
|
|
468
|
+
const d = loaded();
|
|
469
|
+
if (d.leaseRows)
|
|
470
|
+
return undefined;
|
|
471
|
+
const a = d.attempts.find((x) => x.id === id);
|
|
472
|
+
return a?.status === 'active'
|
|
473
|
+
? {
|
|
474
|
+
id: a.id,
|
|
475
|
+
token: a.token,
|
|
476
|
+
owner: a.owner,
|
|
477
|
+
engineVersion: a.engineVersion,
|
|
478
|
+
leaseUntil: a.leaseUntil,
|
|
479
|
+
}
|
|
480
|
+
: undefined;
|
|
481
|
+
},
|
|
482
|
+
activeLeases: (at) => loaded()
|
|
483
|
+
.attempts.filter((a) => a.status === 'active' && a.leaseUntil > at)
|
|
484
|
+
.map((a) => ({
|
|
485
|
+
id: a.id,
|
|
486
|
+
token: a.token,
|
|
487
|
+
owner: a.owner,
|
|
488
|
+
engineVersion: a.engineVersion,
|
|
489
|
+
leaseUntil: a.leaseUntil,
|
|
490
|
+
})),
|
|
491
|
+
dataVersion: () => this.dataVersion(),
|
|
492
|
+
renewLease: (kind, id, token, owner, engineVersion, until, now) => {
|
|
493
|
+
if (!inTx())
|
|
494
|
+
throw new Error('Продление аренды вне транзакции');
|
|
495
|
+
if (kind !== 'attempt')
|
|
496
|
+
throw new Error('Неизвестный вид аренды: ' + String(kind));
|
|
497
|
+
if (!this.leaseTable())
|
|
498
|
+
return false;
|
|
499
|
+
const changed = db
|
|
500
|
+
.prepare("UPDATE leases SET until=? WHERE kind='attempt' AND id=? AND token=? AND owner=? AND engine=? AND until>?")
|
|
501
|
+
.run(until, id, token, owner, engineVersion ?? '', now).changes;
|
|
502
|
+
if (changed !== 1)
|
|
503
|
+
return false;
|
|
504
|
+
// Прочитанный документ транзакции видит новый срок; записи он не требует.
|
|
505
|
+
const a = frame.doc?.attempts.find((x) => x.id === id);
|
|
506
|
+
if (a)
|
|
507
|
+
a.leaseUntil = until;
|
|
508
|
+
return true;
|
|
509
|
+
},
|
|
282
510
|
local(namespace, owner, key) {
|
|
283
511
|
const row = db
|
|
284
512
|
.prepare('SELECT data FROM local WHERE namespace=? AND owner=? AND key=?')
|
|
@@ -301,21 +529,38 @@ export class SqliteExecutionStore {
|
|
|
301
529
|
value: localSchemas[namespace].parse(JSON.parse(r.data)),
|
|
302
530
|
}));
|
|
303
531
|
},
|
|
304
|
-
putGraph: (g) =>
|
|
305
|
-
putWork: (w) =>
|
|
306
|
-
putAttempt: (a) =>
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
532
|
+
putGraph: (g) => edit().putGraph(g),
|
|
533
|
+
putWork: (w) => edit().putWork(w),
|
|
534
|
+
putAttempt: (a) => {
|
|
535
|
+
edit().putAttempt(a);
|
|
536
|
+
// Строка аренды — той же транзакцией: активная попытка пишет её,
|
|
537
|
+
// неактивная удаляет. Первая строка ставит метку и переносит сроки
|
|
538
|
+
// всех активных попыток документа.
|
|
539
|
+
const d = loaded();
|
|
540
|
+
if (a.status !== 'active')
|
|
541
|
+
this.deleteLeaseRow(a.id);
|
|
542
|
+
else if (!d.leaseRows)
|
|
543
|
+
this.markLeaseRows(d);
|
|
544
|
+
else
|
|
545
|
+
this.putLeaseRow(a);
|
|
546
|
+
},
|
|
547
|
+
putVerification: (v) => edit().putVerification(v),
|
|
548
|
+
setControl: (c) => edit().setControl(c),
|
|
549
|
+
setController: (l) => edit().setController(l),
|
|
310
550
|
putLocal(namespace, owner, key, value) {
|
|
311
551
|
if (!inTx())
|
|
312
552
|
throw new Error('Локальная запись вне транзакции');
|
|
313
553
|
const parsed = localSchemas[namespace].parse(value);
|
|
554
|
+
// Запись в базу проверенного формата: документ вне договора (например,
|
|
555
|
+
// более новой версии) — отказ до записи, как у записей модели.
|
|
556
|
+
loaded();
|
|
557
|
+
frame.touched = true;
|
|
314
558
|
db.prepare('INSERT OR REPLACE INTO local VALUES(?,?,?,?)').run(namespace, owner || WORKSPACE_OWNER, key, JSON.stringify(parsed));
|
|
315
559
|
},
|
|
316
560
|
emit(event) {
|
|
317
561
|
if (!inTx())
|
|
318
562
|
throw new Error('Событие вне транзакции');
|
|
563
|
+
loaded();
|
|
319
564
|
frame.drafts.push(event);
|
|
320
565
|
},
|
|
321
566
|
};
|
|
@@ -18,4 +18,13 @@ export declare function executionStoreContract(name: string, test: (title: strin
|
|
|
18
18
|
* ChangeSet). По умолчанию — `putVerification` в транзакции начала.
|
|
19
19
|
*/
|
|
20
20
|
startVerification?: (store: ExecutionStore, verification: JointVerificationState) => void;
|
|
21
|
+
/**
|
|
22
|
+
* Адаптер держит аренду попыток строками (D53: `attemptLease`,
|
|
23
|
+
* `dataVersion`, `renewLease`; `activeLeases` — по желанию). По умолчанию —
|
|
24
|
+
* определяется по адаптеру: есть методы — проверки строк обязательны;
|
|
25
|
+
* нет ни одного — адаптер прежнего договора (продление через
|
|
26
|
+
* `putAttempt`), проверки строк не применяются. Часть методов без
|
|
27
|
+
* остальных — отказ.
|
|
28
|
+
*/
|
|
29
|
+
leaseRows?: boolean;
|
|
21
30
|
}): void;
|
|
@@ -125,6 +125,16 @@ export function executionStoreContract(name, test, open, tempDir, options = {})
|
|
|
125
125
|
costUsd: null,
|
|
126
126
|
costSource: 'unknown',
|
|
127
127
|
});
|
|
128
|
+
const leaseRows = options.leaseRows ?? declaresLeaseRows(open(tempDir()));
|
|
129
|
+
if (leaseRows)
|
|
130
|
+
leaseRowCases(name, test, open, tempDir, work);
|
|
131
|
+
else
|
|
132
|
+
test(`${name}: D53 адаптер без строк аренды не объявляет их методы частично`, () => {
|
|
133
|
+
const s = open(tempDir());
|
|
134
|
+
const methods = s.transact('heartbeat', (tx) => LEASE_METHODS.filter((k) => typeof tx[k] === 'function'));
|
|
135
|
+
assert.equal(methods.length, 0, 'часть методов строк аренды без остальных');
|
|
136
|
+
s.close();
|
|
137
|
+
});
|
|
128
138
|
test(`${name}: запись видна следующей транзакции и другому экземпляру`, () => {
|
|
129
139
|
const dir = tempDir();
|
|
130
140
|
const a = open(dir);
|
|
@@ -413,3 +423,228 @@ export function executionStoreContract(name, test, open, tempDir, options = {})
|
|
|
413
423
|
s.close();
|
|
414
424
|
});
|
|
415
425
|
}
|
|
426
|
+
/**
|
|
427
|
+
* Методы строк аренды, которые адаптер объявляет вместе (их зовёт
|
|
428
|
+
* продление движка). `activeLeases` необязателен и в набор не входит:
|
|
429
|
+
* движок его не вызывает.
|
|
430
|
+
*/
|
|
431
|
+
const LEASE_METHODS = ['attemptLease', 'dataVersion', 'renewLease'];
|
|
432
|
+
/** Объявляет ли адаптер аренду строками: все четыре метода договора D53. */
|
|
433
|
+
function declaresLeaseRows(store) {
|
|
434
|
+
try {
|
|
435
|
+
const methods = store.transact('heartbeat', (tx) => LEASE_METHODS.filter((k) => typeof tx[k] === 'function'));
|
|
436
|
+
return methods.length > 0;
|
|
437
|
+
}
|
|
438
|
+
finally {
|
|
439
|
+
store.close();
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
/** Активная попытка поручения `workId` для проверок строки аренды. */
|
|
443
|
+
function sampleAttempt(id, workId, leaseUntil) {
|
|
444
|
+
return {
|
|
445
|
+
id,
|
|
446
|
+
workId,
|
|
447
|
+
repositoryId: 'app',
|
|
448
|
+
attempt: 1,
|
|
449
|
+
token: ('token-' + id).padEnd(32, 'x'),
|
|
450
|
+
owner: 'owner-a',
|
|
451
|
+
runtime: 'fixture',
|
|
452
|
+
reviewer: 'fixture',
|
|
453
|
+
policyDigest: digestOf('policy'),
|
|
454
|
+
status: 'active',
|
|
455
|
+
phase: 'running',
|
|
456
|
+
startedAt: '2026-01-01T00:00:00.000Z',
|
|
457
|
+
leaseUntil,
|
|
458
|
+
engineVersion: 'engine-1',
|
|
459
|
+
evidence: [],
|
|
460
|
+
};
|
|
461
|
+
}
|
|
462
|
+
/**
|
|
463
|
+
* Аренда попыток строкой (D53). Каждый случай называет поломку, которую
|
|
464
|
+
* он ловит: строка, пережившая смену статуса или token, или продление,
|
|
465
|
+
* которое переписывает документ, оживили бы чужую или истёкшую попытку.
|
|
466
|
+
*/
|
|
467
|
+
function leaseRowCases(name, test, open, tempDir, work) {
|
|
468
|
+
const T0 = 1_000_000;
|
|
469
|
+
const seed = (s, leaseUntil = T0 + 30_000, id = 'a1') => {
|
|
470
|
+
const attempt = sampleAttempt(id, 'w-' + id, leaseUntil);
|
|
471
|
+
s.transact('run.claimed', (tx) => {
|
|
472
|
+
tx.putWork({ ...work('w-' + id, 'running'), activeRunId: id, attempt: 1 });
|
|
473
|
+
tx.putAttempt(attempt);
|
|
474
|
+
});
|
|
475
|
+
return attempt;
|
|
476
|
+
};
|
|
477
|
+
const renew = (s, a, until, now) => s.transact('heartbeat', (tx) => {
|
|
478
|
+
assert.ok(typeof tx.renewLease === 'function', 'адаптер объявляет renewLease');
|
|
479
|
+
return tx.renewLease('attempt', a.id, a.token, a.owner, a.engineVersion, until, now);
|
|
480
|
+
});
|
|
481
|
+
// Действующие аренды: `activeLeases`, если адаптер его объявил, иначе по
|
|
482
|
+
// срокам активных попыток — то же правило.
|
|
483
|
+
const liveLeases = (s, at) => s.read((v) => typeof v.activeLeases === 'function'
|
|
484
|
+
? v.activeLeases(at).map((l) => l.id)
|
|
485
|
+
: (v.activeAttempts?.() ?? v.attempts())
|
|
486
|
+
.filter((x) => x.status === 'active' && x.leaseUntil > at)
|
|
487
|
+
.map((x) => x.id));
|
|
488
|
+
const lease = (s, id) => s.read((v) => {
|
|
489
|
+
assert.ok(typeof v.attemptLease === 'function', 'адаптер объявляет attemptLease');
|
|
490
|
+
return v.attemptLease(id);
|
|
491
|
+
});
|
|
492
|
+
test(`${name}: D53 выдача пишет строку аренды; activeLeases — только действующие`, () => {
|
|
493
|
+
// Ловит: putAttempt активной попытки не пишет строку — продлевать нечего.
|
|
494
|
+
const s = open(tempDir());
|
|
495
|
+
const a = seed(s);
|
|
496
|
+
assert.deepEqual(lease(s, a.id), {
|
|
497
|
+
id: a.id,
|
|
498
|
+
token: a.token,
|
|
499
|
+
owner: a.owner,
|
|
500
|
+
engineVersion: a.engineVersion,
|
|
501
|
+
leaseUntil: a.leaseUntil,
|
|
502
|
+
});
|
|
503
|
+
assert.deepEqual(liveLeases(s, T0), [a.id]);
|
|
504
|
+
assert.deepEqual(liveLeases(s, a.leaseUntil), [], 'срок, равный моменту, уже не действует');
|
|
505
|
+
s.close();
|
|
506
|
+
});
|
|
507
|
+
test(`${name}: D53 продление меняет только строку — не документ, не события, не dataVersion`, () => {
|
|
508
|
+
// Ловит: продление переписывает документ или поднимает версию данных
|
|
509
|
+
// (F46: каждый heartbeat переписывал всё состояние), а чтение попытки
|
|
510
|
+
// не накладывает срок строки.
|
|
511
|
+
const dir = tempDir();
|
|
512
|
+
const s = open(dir);
|
|
513
|
+
const a = seed(s);
|
|
514
|
+
const before = s.read((v) => ({
|
|
515
|
+
version: v.dataVersion(),
|
|
516
|
+
work: v.work('w-' + a.id),
|
|
517
|
+
attempt: v.attempt(a.id),
|
|
518
|
+
}));
|
|
519
|
+
const events = s.events().length;
|
|
520
|
+
assert.equal(renew(s, a, T0 + 60_000, T0 + 10_000), true);
|
|
521
|
+
const after = s.read((v) => ({
|
|
522
|
+
version: v.dataVersion(),
|
|
523
|
+
work: v.work('w-' + a.id),
|
|
524
|
+
attempt: v.attempt(a.id),
|
|
525
|
+
attempts: v.attempts().find((x) => x.id === a.id),
|
|
526
|
+
active: (v.activeAttempts?.() ?? v.attempts()).find((x) => x.id === a.id),
|
|
527
|
+
}));
|
|
528
|
+
assert.equal(after.version, before.version, 'продление не меняет версию данных');
|
|
529
|
+
assert.deepEqual(after.work, before.work);
|
|
530
|
+
assert.deepEqual({ ...after.attempt, leaseUntil: 0 }, { ...before.attempt, leaseUntil: 0 }, 'кроме срока попытка прежняя');
|
|
531
|
+
assert.equal(after.attempt?.leaseUntil, T0 + 60_000, 'attempt() — срок строки');
|
|
532
|
+
assert.equal(after.attempts?.leaseUntil, T0 + 60_000, 'attempts() — срок строки');
|
|
533
|
+
assert.equal(after.active?.leaseUntil, T0 + 60_000, 'activeAttempts() — срок строки');
|
|
534
|
+
assert.equal(s.events().length, events, 'продление не пишет событий');
|
|
535
|
+
const other = open(dir);
|
|
536
|
+
assert.equal(other.read((v) => v.attempt(a.id)?.leaseUntil), T0 + 60_000, 'другой экземпляр видит продлённый срок');
|
|
537
|
+
// Истечение по снимку видит срок строки, а не прежний срок документа.
|
|
538
|
+
assert.deepEqual(other.read((v) => v.attempts().filter((x) => x.status === 'active' && x.leaseUntil <= T0 + 40_000)), []);
|
|
539
|
+
other.close();
|
|
540
|
+
s.close();
|
|
541
|
+
});
|
|
542
|
+
test(`${name}: D53 продление отклоняется: чужой token, владелец, версия движка, истёкший срок`, () => {
|
|
543
|
+
// Ловит: безусловное продление по id и оживление истёкшей аренды
|
|
544
|
+
// прежним token (ограждение держалось бы на «никто ещё не истёк»).
|
|
545
|
+
const s = open(tempDir());
|
|
546
|
+
const a = seed(s, T0 + 30_000);
|
|
547
|
+
const now = T0 + 10_000;
|
|
548
|
+
assert.equal(renew(s, { ...a, token: 'other-'.padEnd(32, 'y') }, T0 + 90_000, now), false);
|
|
549
|
+
assert.equal(renew(s, { ...a, owner: 'owner-b' }, T0 + 90_000, now), false);
|
|
550
|
+
assert.equal(renew(s, { ...a, engineVersion: 'engine-2' }, T0 + 90_000, now), false);
|
|
551
|
+
assert.equal(renew(s, { ...a, engineVersion: undefined }, T0 + 90_000, now), false);
|
|
552
|
+
assert.equal(renew(s, a, T0 + 90_000, T0 + 30_000), false, 'срок равен моменту — истёк');
|
|
553
|
+
assert.equal(renew(s, a, T0 + 90_000, T0 + 45_000), false, 'истёкший не продлевается');
|
|
554
|
+
assert.equal(renew(s, { ...a, id: 'missing' }, T0 + 90_000, now), false);
|
|
555
|
+
assert.equal(lease(s, a.id)?.leaseUntil, T0 + 30_000, 'отказ не меняет срок');
|
|
556
|
+
assert.equal(s.read((v) => v.attempt(a.id)?.leaseUntil), T0 + 30_000);
|
|
557
|
+
s.close();
|
|
558
|
+
});
|
|
559
|
+
for (const status of ['succeeded', 'failed', 'cancelled', 'expired'])
|
|
560
|
+
test(`${name}: D53 смена статуса на ${status} удаляет строку аренды той же транзакцией`, () => {
|
|
561
|
+
// Ловит: строка, пережившая конец попытки, продлевалась бы прежним
|
|
562
|
+
// token и показывала бы занятость завершённой попытки.
|
|
563
|
+
const s = open(tempDir());
|
|
564
|
+
const a = seed(s);
|
|
565
|
+
s.transact('run.failed', (tx) => {
|
|
566
|
+
tx.putAttempt({
|
|
567
|
+
...tx.attempt(a.id),
|
|
568
|
+
status,
|
|
569
|
+
finishedAt: '2026-01-01T00:01:00.000Z',
|
|
570
|
+
});
|
|
571
|
+
tx.putWork({ ...tx.work('w-' + a.id), activeRunId: undefined, status: 'failed' });
|
|
572
|
+
});
|
|
573
|
+
assert.equal(lease(s, a.id), undefined);
|
|
574
|
+
assert.equal(renew(s, a, T0 + 90_000, T0 + 1), false);
|
|
575
|
+
assert.deepEqual(liveLeases(s, 0), []);
|
|
576
|
+
assert.equal(s.read((v) => v.attempt(a.id)?.status), status);
|
|
577
|
+
s.close();
|
|
578
|
+
});
|
|
579
|
+
test(`${name}: D53 новый token (adopt, recovery) переписывает строку; прежний token отклоняется`, () => {
|
|
580
|
+
// Ловит: adopt оставляет строку прежнего владельца — старый процесс
|
|
581
|
+
// продолжал бы продлевать попытку, перешедшую к новому.
|
|
582
|
+
const s = open(tempDir());
|
|
583
|
+
const a = seed(s, T0 + 30_000);
|
|
584
|
+
const adopted = {
|
|
585
|
+
...a,
|
|
586
|
+
token: 'adopted-'.padEnd(32, 'z'),
|
|
587
|
+
owner: 'owner-b',
|
|
588
|
+
engineVersion: 'engine-2',
|
|
589
|
+
leaseUntil: T0 + 70_000,
|
|
590
|
+
};
|
|
591
|
+
s.transact('run.recovered', (tx) => tx.putAttempt(adopted));
|
|
592
|
+
assert.deepEqual(lease(s, a.id), {
|
|
593
|
+
id: a.id,
|
|
594
|
+
token: adopted.token,
|
|
595
|
+
owner: 'owner-b',
|
|
596
|
+
engineVersion: 'engine-2',
|
|
597
|
+
leaseUntil: T0 + 70_000,
|
|
598
|
+
});
|
|
599
|
+
assert.equal(renew(s, a, T0 + 90_000, T0 + 1), false, 'прежний token');
|
|
600
|
+
assert.equal(renew(s, adopted, T0 + 90_000, T0 + 1), true, 'новый token');
|
|
601
|
+
assert.equal(s.read((v) => v.attempt(a.id)?.leaseUntil), T0 + 90_000);
|
|
602
|
+
s.close();
|
|
603
|
+
});
|
|
604
|
+
test(`${name}: D53 отклонённый recovery (срок 0) — аренды нет, продление отклоняется`, () => {
|
|
605
|
+
// Ловит: срок 0, записанный rejectRecovery, не доходит до строки — и
|
|
606
|
+
// попытка, которую recovery отпустил, продлевалась бы владельцем.
|
|
607
|
+
const s = open(tempDir());
|
|
608
|
+
const a = seed(s, T0 + 30_000);
|
|
609
|
+
s.transact('recovery.rejected', (tx) => tx.putAttempt({ ...tx.attempt(a.id), leaseUntil: 0 }));
|
|
610
|
+
assert.equal(s.read((v) => v.attempt(a.id)?.leaseUntil), 0);
|
|
611
|
+
assert.equal(renew(s, a, T0 + 90_000, T0 + 1), false);
|
|
612
|
+
assert.deepEqual(liveLeases(s, 0), []);
|
|
613
|
+
s.close();
|
|
614
|
+
});
|
|
615
|
+
test(`${name}: D53 строка откатывается вместе с транзакцией и вложенной частью`, () => {
|
|
616
|
+
// Ловит: строка аренды пишется вне транзакции документа — откат
|
|
617
|
+
// оставлял бы аренду попытки, которой нет.
|
|
618
|
+
const s = open(tempDir());
|
|
619
|
+
assert.throws(() => s.transact('run.claimed', (tx) => {
|
|
620
|
+
tx.putWork({ ...work('w-r1', 'running'), activeRunId: 'r1', attempt: 1 });
|
|
621
|
+
tx.putAttempt(sampleAttempt('r1', 'w-r1', T0 + 30_000));
|
|
622
|
+
throw new Error('отказ');
|
|
623
|
+
}));
|
|
624
|
+
assert.equal(lease(s, 'r1'), undefined);
|
|
625
|
+
const a = seed(s, T0 + 30_000, 'r2');
|
|
626
|
+
// Адаптер может писать строки сразу (standalone) или при фиксации из
|
|
627
|
+
// разницы документа (DevContour). Внешняя транзакция после отката
|
|
628
|
+
// вложенной меняет другую запись модели: документ фиксируется, и
|
|
629
|
+
// строка остаётся, только если откат вернул и попытку, и строку.
|
|
630
|
+
s.transact('run.phase', (outerTx) => {
|
|
631
|
+
assert.throws(() => s.transact('run.failed', (inner) => {
|
|
632
|
+
inner.putAttempt({ ...inner.attempt(a.id), status: 'failed' });
|
|
633
|
+
throw new Error('вложенный отказ');
|
|
634
|
+
}));
|
|
635
|
+
assert.equal(s.read((v) => v.attemptLease(a.id)?.token), a.token, 'откат вложенной части вернул строку');
|
|
636
|
+
assert.equal(s.read((v) => v.attempt(a.id)?.status), 'active');
|
|
637
|
+
outerTx.putWork({ ...outerTx.work('w-' + a.id), attempt: 2 });
|
|
638
|
+
});
|
|
639
|
+
assert.equal(s.read((v) => v.work('w-' + a.id)?.attempt), 2, 'внешняя часть записана');
|
|
640
|
+
assert.equal(lease(s, a.id)?.leaseUntil, T0 + 30_000);
|
|
641
|
+
assert.equal(renew(s, a, T0 + 60_000, T0 + 1), true, 'строка действует после фиксации');
|
|
642
|
+
// Продление внутри транзакции, которая затем падает, тоже откатывается.
|
|
643
|
+
assert.throws(() => s.transact('heartbeat', (tx) => {
|
|
644
|
+
assert.equal(tx.renewLease('attempt', a.id, a.token, a.owner, a.engineVersion, T0 + 99_000, T0 + 2), true);
|
|
645
|
+
throw new Error('отказ');
|
|
646
|
+
}));
|
|
647
|
+
assert.equal(lease(s, a.id)?.leaseUntil, T0 + 60_000);
|
|
648
|
+
s.close();
|
|
649
|
+
});
|
|
650
|
+
}
|