devcontour-harness 0.1.0-alpha.26 → 0.1.0-alpha.27
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 +9 -2
- package/docs/architecture.md +59 -0
- package/docs/compatibility.md +24 -12
- package/docs/connectors.md +5 -2
- package/docs/contracts.md +47 -25
- package/docs/release-notes/0.1.0-alpha.27.md +36 -0
- package/docs/review-protocol.md +10 -4
- package/docs/toolchains.md +83 -0
- package/docs/upgrade.md +10 -0
- package/lib/cli.js +13 -0
- package/lib/contracts/cli.d.ts +124 -0
- package/lib/contracts/cli.js +66 -0
- package/lib/contracts/policy.d.ts +30 -0
- package/lib/contracts/policy.js +23 -0
- package/lib/contracts/published.d.ts +8 -0
- package/lib/control/harness.d.ts +12 -0
- package/lib/control/harness.js +4 -0
- package/lib/control/review.js +6 -1
- package/lib/engine/joint-runner.js +34 -1
- package/lib/engine/runner.d.ts +29 -0
- package/lib/engine/runner.js +200 -2
- package/lib/engine/worktree-cleanup.d.ts +131 -0
- package/lib/engine/worktree-cleanup.js +520 -0
- package/lib/environment/isolation.d.ts +1 -0
- package/lib/environment/isolation.js +2 -1
- package/lib/environment/os-tools.d.ts +4 -2
- package/lib/environment/os-tools.js +4 -2
- package/lib/environment/process.d.ts +5 -0
- package/lib/environment/process.js +40 -17
- package/lib/environment/resources.d.ts +9 -0
- package/lib/environment/resources.js +24 -0
- package/lib/index.d.ts +1 -0
- package/lib/index.js +1 -0
- package/lib/integrations/connector/commands.d.ts +2 -1
- package/lib/integrations/connector/commands.js +10 -2
- package/lib/integrations/connector/store.d.ts +1 -1
- package/lib/integrations/connector/store.js +11 -6
- package/lib/profiles/resolve.d.ts +6 -0
- package/lib/toolchains/inspect.d.ts +1 -1
- package/lib/toolchains/inspect.js +29 -1
- package/lib/toolchains/probe.d.ts +16 -0
- package/lib/toolchains/probe.js +20 -0
- package/lib/verification/confirm.d.ts +3 -1
- package/lib/verification/confirm.js +16 -2
- package/lib/verification/dependencies.d.ts +3 -0
- package/lib/verification/dependencies.js +11 -0
- package/lib/verification/dependency-store.d.ts +117 -0
- package/lib/verification/dependency-store.js +811 -0
- package/lib/verification/gates-at.js +18 -0
- package/package.json +1 -1
- package/schemas/execution-policy.schema.json +34 -0
|
@@ -0,0 +1,811 @@
|
|
|
1
|
+
import { randomUUID } from 'node:crypto';
|
|
2
|
+
import { constants } from 'node:fs';
|
|
3
|
+
import { copyFile, lstat, mkdir, readdir, readFile, rename, rm, stat, statfs, utimes, writeFile, } from 'node:fs/promises';
|
|
4
|
+
import { dirname, join } from 'node:path';
|
|
5
|
+
import { setTimeout as delay } from 'node:timers/promises';
|
|
6
|
+
import { digestOf, sha256, } from "../contracts/index.js";
|
|
7
|
+
import { OversizedFile, readBounded } from "../environment/bounded-read.js";
|
|
8
|
+
import { checkoutPath } from "../environment/checkout-root.js";
|
|
9
|
+
import { snapshotLimit } from "../environment/isolation.js";
|
|
10
|
+
import { osTool } from "../environment/os-tools.js";
|
|
11
|
+
import { processStartedAt } from "../environment/live-calls.js";
|
|
12
|
+
import { command, gitOutput } from "../environment/process.js";
|
|
13
|
+
import { ResourcePool, resourceKey } from "../environment/resources.js";
|
|
14
|
+
import { declaredManagerVersion, defaultProbe, dependencyStoreSupports, dependencyStoreVersions, versionOf, } from "../toolchains/probe.js";
|
|
15
|
+
import { runCheck } from "./gates.js";
|
|
16
|
+
const managers = {
|
|
17
|
+
pnpm: {
|
|
18
|
+
dir: '.pnpm-store',
|
|
19
|
+
version: ['pnpm', '--version'],
|
|
20
|
+
// `pnpm fetch` читает только lockfile; `--ignore-workspace` не даёт искать
|
|
21
|
+
// pnpm-workspace.yaml вверх от рабочего каталога. Скрипты в seed не идут.
|
|
22
|
+
fetch: (store) => [
|
|
23
|
+
'pnpm',
|
|
24
|
+
'fetch',
|
|
25
|
+
'--ignore-workspace',
|
|
26
|
+
'--ignore-scripts',
|
|
27
|
+
'--store-dir=' + store,
|
|
28
|
+
],
|
|
29
|
+
env: (store) => ({ npm_config_store_dir: store }),
|
|
30
|
+
// Патчи лежат в репозитории, а сборка видит только lockfile.
|
|
31
|
+
permanent: /ERR_PNPM_(?:PATCH_NOT_FOUND|BROKEN_LOCKFILE|LOCKFILE_BREAKING_CHANGE)/,
|
|
32
|
+
buildEnv: (work) => ({
|
|
33
|
+
npm_config_userconfig: join(work, 'npmrc'),
|
|
34
|
+
npm_config_cache_dir: join(work, 'cache'),
|
|
35
|
+
npm_config_state_dir: join(work, 'state'),
|
|
36
|
+
}),
|
|
37
|
+
buildFiles: { 'package.json': '{}\n', npmrc: '' },
|
|
38
|
+
},
|
|
39
|
+
};
|
|
40
|
+
const FORMAT = 1;
|
|
41
|
+
/** Сколько последних по использованию seeds остаётся: текущий и основа следующего. */
|
|
42
|
+
const KEEP_SEEDS = 2;
|
|
43
|
+
const FILE_CONCURRENCY = 16;
|
|
44
|
+
const CLONE_CONCURRENCY = 8;
|
|
45
|
+
/** Глубина, на которой дерево делится на порции клонирования (`v10/files/ab`). */
|
|
46
|
+
const CLONE_BATCH_DEPTH = 3;
|
|
47
|
+
/** После отказа сборки: отказавший реестр не отнимает предел у каждой попытки. */
|
|
48
|
+
const FAILED_BUILD_COOLDOWN_MS = 10 * 60 * 1000;
|
|
49
|
+
/** Запас свободного места поверх размера seed при обычном копировании. */
|
|
50
|
+
const COPY_HEADROOM = 1.1;
|
|
51
|
+
/**
|
|
52
|
+
* Какую долю остатка времени фазы могут занять сборка и ожидание чужой сборки:
|
|
53
|
+
* только эти шаги зависят от сети. Остальное время — работе, которая её ждёт.
|
|
54
|
+
*/
|
|
55
|
+
const STORE_TIME_SHARE = 1 / 3;
|
|
56
|
+
/**
|
|
57
|
+
* Сколько полного бюджета должно оставаться к началу сборки, чтобы её истечение
|
|
58
|
+
* говорило о реестре. Меньше — фаза опоздала сама, и отказ не значит ничего.
|
|
59
|
+
*/
|
|
60
|
+
const FULL_BUDGET_SHARE = 0.75;
|
|
61
|
+
/**
|
|
62
|
+
* Предел пробы версий. Запуск node и pnpm на загруженной машине занимает секунды,
|
|
63
|
+
* а отказ пробы стоит хранилища на всю фазу: короткий предел доктора здесь мал.
|
|
64
|
+
*/
|
|
65
|
+
const IDENTITY_PROBE_MS = 30000;
|
|
66
|
+
/**
|
|
67
|
+
* Допуск сравнения момента запуска: на Linux `lstart` считается от часов и после
|
|
68
|
+
* их перевода сдвигается. Живая аренда важнее: pid, занятый в эти секунды другим
|
|
69
|
+
* процессом, только заставит подождать до конца бюджета.
|
|
70
|
+
*/
|
|
71
|
+
const START_TOLERANCE_MS = 5000;
|
|
72
|
+
/** Больше package.json в корне не читается: файл пишет кандидат. */
|
|
73
|
+
const MANIFEST_LIMIT = 1024 * 1024;
|
|
74
|
+
/** Предел lockfile checkout: файл пишет кандидат. */
|
|
75
|
+
const LOCK_LIMIT = 64 * 1024 * 1024;
|
|
76
|
+
/** Каталог seeds: том рабочих деревьев и уже закрытое песочницей место. */
|
|
77
|
+
export function dependencyStoreRoot(placement, stateDir, repositoryId) {
|
|
78
|
+
return checkoutPath(placement, join(stateDir, 'dependency-store', repositoryId), repositoryId, 'dependency-store');
|
|
79
|
+
}
|
|
80
|
+
/** Параллельно, с пределом. Отказ останавливает раздачу и дожидается идущих: никто не пишет после возврата. */
|
|
81
|
+
const within = async (items, limit, action) => {
|
|
82
|
+
let next = 0;
|
|
83
|
+
const workers = await Promise.allSettled(Array.from({ length: Math.min(limit, items.length) }, async () => {
|
|
84
|
+
while (next < items.length) {
|
|
85
|
+
const index = next++;
|
|
86
|
+
try {
|
|
87
|
+
await action(items[index]);
|
|
88
|
+
}
|
|
89
|
+
catch (error) {
|
|
90
|
+
next = items.length;
|
|
91
|
+
throw error;
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
}));
|
|
95
|
+
for (const worker of workers)
|
|
96
|
+
if (worker.status === 'rejected')
|
|
97
|
+
throw worker.reason;
|
|
98
|
+
};
|
|
99
|
+
/** Файлы дерева. Ссылка и всё, что не обычный файл, — отказ: seed их не содержит. */
|
|
100
|
+
async function regularFiles(root) {
|
|
101
|
+
const top = await lstat(root);
|
|
102
|
+
if (!top.isDirectory())
|
|
103
|
+
throw new SeedRefused('корень хранилища — не каталог');
|
|
104
|
+
const files = [];
|
|
105
|
+
const walk = async (prefix) => {
|
|
106
|
+
for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
|
|
107
|
+
const rel = prefix ? prefix + '/' + entry.name : entry.name;
|
|
108
|
+
if (entry.isDirectory())
|
|
109
|
+
await walk(rel);
|
|
110
|
+
else if (entry.isFile()) {
|
|
111
|
+
const st = await lstat(join(root, rel));
|
|
112
|
+
files.push({ rel, mode: st.mode & 0o777, size: st.size });
|
|
113
|
+
}
|
|
114
|
+
else
|
|
115
|
+
throw new SeedRefused(`в хранилище не обычный файл: ${rel}`);
|
|
116
|
+
}
|
|
117
|
+
};
|
|
118
|
+
await walk('');
|
|
119
|
+
return files;
|
|
120
|
+
}
|
|
121
|
+
class SeedRefused extends Error {
|
|
122
|
+
}
|
|
123
|
+
async function fingerprint(root) {
|
|
124
|
+
const list = await regularFiles(root);
|
|
125
|
+
// Map, а не объект: файл `__proto__` не должен исчезнуть из отпечатка.
|
|
126
|
+
const files = new Map();
|
|
127
|
+
await within(list, FILE_CONCURRENCY, async (f) => {
|
|
128
|
+
files.set(f.rel, [sha256(await readFile(join(root, f.rel))), f.mode]);
|
|
129
|
+
});
|
|
130
|
+
return { files, bytes: list.reduce((sum, f) => sum + f.size, 0) };
|
|
131
|
+
}
|
|
132
|
+
/** Дерево в точности равно манифесту: тот же набор файлов, байты и права. */
|
|
133
|
+
async function assertMatches(root, manifest) {
|
|
134
|
+
const { files } = await fingerprint(root);
|
|
135
|
+
const expected = Object.keys(manifest.files);
|
|
136
|
+
if (files.size !== expected.length)
|
|
137
|
+
throw new SeedRefused(`набор файлов изменён: ${files.size} вместо ${expected.length}`);
|
|
138
|
+
for (const rel of expected) {
|
|
139
|
+
const [hash, mode] = manifest.files[rel];
|
|
140
|
+
const found = files.get(rel);
|
|
141
|
+
if (!found)
|
|
142
|
+
throw new SeedRefused(`нет файла ${rel}`);
|
|
143
|
+
if (found[0] !== hash)
|
|
144
|
+
throw new SeedRefused(`изменено содержимое ${rel}`);
|
|
145
|
+
if (found[1] !== mode)
|
|
146
|
+
throw new SeedRefused(`изменены права ${rel}`);
|
|
147
|
+
}
|
|
148
|
+
}
|
|
149
|
+
/** Способы размещения дерева; тест подменяет `cloneable`, чтобы проверить обычную копию. */
|
|
150
|
+
export const storeTree = {
|
|
151
|
+
/**
|
|
152
|
+
* Предел файлов seed: копия лежит в checkout и входит в сверку защищённых
|
|
153
|
+
* путей. Seed больше неё превратил бы ускорение в отказ каждой проверки.
|
|
154
|
+
*/
|
|
155
|
+
maxFiles: Math.floor(snapshotLimit * 0.75),
|
|
156
|
+
/**
|
|
157
|
+
* Предел элементов checkout вместе с копией seed. Запас — на то, что проверки
|
|
158
|
+
* допишут в дерево после развёртывания.
|
|
159
|
+
*/
|
|
160
|
+
maxEntries: Math.floor(snapshotLimit * 0.9),
|
|
161
|
+
/**
|
|
162
|
+
* Меньше этого остатка сборка не начинается и ничего не отмечает: за такое время
|
|
163
|
+
* она не успеет, а опоздавшая фаза не должна закрывать сборку остальным.
|
|
164
|
+
*/
|
|
165
|
+
minBuildMs: 30000,
|
|
166
|
+
/** Запуск сборки; тест подменяет его: исход гонки с отменой иначе не воспроизвести. */
|
|
167
|
+
run: runCheck,
|
|
168
|
+
/** Запись `.gitignore` хранилища; тест подменяет её, чтобы проверить отказ. */
|
|
169
|
+
ignore: (dest) => writeFile(join(dest, '.gitignore'), '*\n'),
|
|
170
|
+
/**
|
|
171
|
+
* Том клонирует файлы. `cp -c` на другом томе молча копирует, поэтому способ
|
|
172
|
+
* выясняется заранее: от него зависит проверка свободного места.
|
|
173
|
+
*/
|
|
174
|
+
async cloneable(from, to, sample, signal) {
|
|
175
|
+
if ((await stat(from)).dev !== (await stat(dirname(to))).dev)
|
|
176
|
+
return false;
|
|
177
|
+
if (process.platform === 'darwin') {
|
|
178
|
+
const df = await command([osTool('df'), '-Y', from], from, { signal, timeoutMs: 10000 });
|
|
179
|
+
return /^\S+\s+apfs\s/m.test(df.stdout);
|
|
180
|
+
}
|
|
181
|
+
if (process.platform !== 'linux')
|
|
182
|
+
return false;
|
|
183
|
+
const probe = join(dirname(to), `.reflink-probe-${randomUUID()}`);
|
|
184
|
+
const done = await command([osTool('cp'), '--reflink=always', sample, probe], from, {
|
|
185
|
+
signal,
|
|
186
|
+
timeoutMs: 10000,
|
|
187
|
+
});
|
|
188
|
+
await rm(probe, { force: true });
|
|
189
|
+
return done.code === 0;
|
|
190
|
+
},
|
|
191
|
+
async freeBytes(path) {
|
|
192
|
+
const free = await statfs(path);
|
|
193
|
+
return Number(free.bavail) * Number(free.bsize);
|
|
194
|
+
},
|
|
195
|
+
/** Копия-при-записи порциями: один `cp` на всё дерево вдвое медленнее. */
|
|
196
|
+
async clone(from, to, signal) {
|
|
197
|
+
const batches = [];
|
|
198
|
+
const expand = async (src, dst, depth) => {
|
|
199
|
+
await mkdir(dst, { recursive: true });
|
|
200
|
+
for (const entry of await readdir(src, { withFileTypes: true }))
|
|
201
|
+
if (entry.isDirectory() && depth + 1 < CLONE_BATCH_DEPTH)
|
|
202
|
+
await expand(join(src, entry.name), join(dst, entry.name), depth + 1);
|
|
203
|
+
else
|
|
204
|
+
batches.push([join(src, entry.name), join(dst, entry.name)]);
|
|
205
|
+
};
|
|
206
|
+
await expand(from, to, 0);
|
|
207
|
+
const flags = process.platform === 'darwin'
|
|
208
|
+
? ['-c', '-R']
|
|
209
|
+
: ['-R', '--reflink=always', '--preserve=mode,timestamps'];
|
|
210
|
+
await within(batches, CLONE_CONCURRENCY, async ([src, dst]) => {
|
|
211
|
+
const done = await command([osTool('cp'), ...flags, src, dst], from, {
|
|
212
|
+
signal,
|
|
213
|
+
timeoutMs: 120000,
|
|
214
|
+
});
|
|
215
|
+
if (done.code)
|
|
216
|
+
throw new Error(`Клонирование не удалось: ${done.stderr.trim()}`);
|
|
217
|
+
});
|
|
218
|
+
},
|
|
219
|
+
async copy(from, to) {
|
|
220
|
+
const files = await regularFiles(from);
|
|
221
|
+
await mkdir(to, { recursive: true });
|
|
222
|
+
await within([...new Set(files.map((f) => dirname(join(to, f.rel))))].sort(), FILE_CONCURRENCY, async (dir) => void (await mkdir(dir, { recursive: true })));
|
|
223
|
+
await within(files, FILE_CONCURRENCY, (f) => copyFile(join(from, f.rel), join(to, f.rel), constants.COPYFILE_EXCL));
|
|
224
|
+
},
|
|
225
|
+
};
|
|
226
|
+
/** Элементы дерева вне `node_modules` и `.git`: столько же насчитает сверка защищённых путей. */
|
|
227
|
+
async function treeEntries(root) {
|
|
228
|
+
let count = 0;
|
|
229
|
+
const walk = async (dir) => {
|
|
230
|
+
for (const entry of await readdir(dir, { withFileTypes: true })) {
|
|
231
|
+
if (entry.name === 'node_modules' || entry.name === '.git')
|
|
232
|
+
continue;
|
|
233
|
+
count++;
|
|
234
|
+
if (entry.isDirectory())
|
|
235
|
+
await walk(join(dir, entry.name));
|
|
236
|
+
}
|
|
237
|
+
};
|
|
238
|
+
await walk(root);
|
|
239
|
+
return count;
|
|
240
|
+
}
|
|
241
|
+
/** Развернуть seed в `to` и сверить результат; способ — клон, иначе копия. */
|
|
242
|
+
async function place(seed, to, signal) {
|
|
243
|
+
const sample = join(seed.store, '..', 'manifest.json');
|
|
244
|
+
const cloned = await storeTree.cloneable(seed.store, to, sample, signal);
|
|
245
|
+
if (cloned)
|
|
246
|
+
await storeTree.clone(seed.store, to, signal);
|
|
247
|
+
else {
|
|
248
|
+
const available = await storeTree.freeBytes(dirname(to));
|
|
249
|
+
if (available < seed.manifest.bytes * COPY_HEADROOM)
|
|
250
|
+
throw new Error(`копия seed не помещается: нужно ${seed.manifest.bytes} байт, свободно ${available}`);
|
|
251
|
+
await storeTree.copy(seed.store, to);
|
|
252
|
+
}
|
|
253
|
+
await assertMatches(to, seed.manifest);
|
|
254
|
+
return cloned ? 'clone' : 'copy';
|
|
255
|
+
}
|
|
256
|
+
const pool = (s, action) => {
|
|
257
|
+
const resources = new ResourcePool(s.ctx.resourceDatabase);
|
|
258
|
+
try {
|
|
259
|
+
return action(resources);
|
|
260
|
+
}
|
|
261
|
+
finally {
|
|
262
|
+
resources.close();
|
|
263
|
+
}
|
|
264
|
+
};
|
|
265
|
+
/** Убрать seed: сначала переименование, чтобы читатель не застал половину. */
|
|
266
|
+
async function dropSeed(s, key) {
|
|
267
|
+
const trash = join(s.root, 'tmp', randomUUID());
|
|
268
|
+
await mkdir(dirname(trash), { recursive: true });
|
|
269
|
+
await rename(join(s.root, 'seeds', key), trash).catch(() => undefined);
|
|
270
|
+
await rm(trash, { recursive: true, force: true });
|
|
271
|
+
pool(s, (p) => p.setSeedPin(s.root, key, undefined));
|
|
272
|
+
}
|
|
273
|
+
const refuse = async (s, key, why) => {
|
|
274
|
+
(s.receipt.refused ??= []).push(`${key}: ${why}`);
|
|
275
|
+
await dropSeed(s, key);
|
|
276
|
+
};
|
|
277
|
+
/** Seed с закреплённым манифестом; неверный — отказ, отсутствующий — `undefined`. */
|
|
278
|
+
async function readSeed(s, key) {
|
|
279
|
+
const dir = join(s.root, 'seeds', key);
|
|
280
|
+
const path = join(dir, 'manifest.json');
|
|
281
|
+
const st = await lstat(path).catch(() => undefined);
|
|
282
|
+
if (!st) {
|
|
283
|
+
// Каталог без манифеста сам по себе не seed: публикация атомарна.
|
|
284
|
+
if (await lstat(dir).catch(() => undefined))
|
|
285
|
+
await refuse(s, key, 'нет манифеста');
|
|
286
|
+
return undefined;
|
|
287
|
+
}
|
|
288
|
+
if (!st.isFile())
|
|
289
|
+
return void (await refuse(s, key, 'манифест — не обычный файл'));
|
|
290
|
+
const raw = await readFile(path);
|
|
291
|
+
if (sha256(raw) !== pool(s, (p) => p.seedPin(s.root, key)))
|
|
292
|
+
return void (await refuse(s, key, 'манифест не совпал с закреплённым'));
|
|
293
|
+
const manifest = JSON.parse(raw.toString('utf8'));
|
|
294
|
+
if (manifest.key !== key)
|
|
295
|
+
return void (await refuse(s, key, 'ключ манифеста другой'));
|
|
296
|
+
return { key, store: join(dir, 'store'), manifest };
|
|
297
|
+
}
|
|
298
|
+
const sameIdentity = (a, b) => digestOf(a) === digestOf(b);
|
|
299
|
+
async function seedKeys(s) {
|
|
300
|
+
return readdir(join(s.root, 'seeds')).catch(() => []);
|
|
301
|
+
}
|
|
302
|
+
/** Самый свежий seed той же среды — частичное попадание или основа сборки. */
|
|
303
|
+
async function newestSeed(s) {
|
|
304
|
+
const seeds = [];
|
|
305
|
+
for (const key of await seedKeys(s)) {
|
|
306
|
+
const seed = await readSeed(s, key);
|
|
307
|
+
// Ключ содержит формат, но основа выбирается перебором: seed другого формата
|
|
308
|
+
// не подходит и основой.
|
|
309
|
+
if (seed?.manifest.format === FORMAT && sameIdentity(seed.manifest.identity, s.identity))
|
|
310
|
+
seeds.push(seed);
|
|
311
|
+
}
|
|
312
|
+
return seeds.sort((a, b) => b.manifest.builtAt.localeCompare(a.manifest.builtAt))[0];
|
|
313
|
+
}
|
|
314
|
+
/**
|
|
315
|
+
* Эксклюзивная секция сборки между процессами: аренда `ResourcePool`, брошенная
|
|
316
|
+
* упавшим процессом снимается штатным `clearAbandoned`. Корректность на ней не
|
|
317
|
+
* держится (публикация атомарна): она только не даёт качать одно и то же дважды.
|
|
318
|
+
* Живую аренду не отнимает ни срок, ни бюджет. Истёк бюджет — `undefined`.
|
|
319
|
+
*
|
|
320
|
+
* В `owner` записан момент запуска владельца (число: текст `ps` зависит от TZ
|
|
321
|
+
* процесса): pid после перезапуска контейнера занимает другой процесс, и
|
|
322
|
+
* `clearAbandoned` по одному pid ждал бы вечно.
|
|
323
|
+
* Запись своя у этой аренды, поведение других ресурсов не меняется.
|
|
324
|
+
*/
|
|
325
|
+
const LEASE_OWNER = 'dependency-store-started:';
|
|
326
|
+
async function exclusive(s, work) {
|
|
327
|
+
const resource = {
|
|
328
|
+
id: 'dependency-store',
|
|
329
|
+
kind: 'service',
|
|
330
|
+
value: 'dependency-store:' + s.root,
|
|
331
|
+
};
|
|
332
|
+
const key = resourceKey(resource);
|
|
333
|
+
const token = randomUUID();
|
|
334
|
+
const owner = LEASE_OWNER + (processStartedAt(process.pid) ?? '');
|
|
335
|
+
const compared = new Set();
|
|
336
|
+
const leases = new ResourcePool(s.ctx.resourceDatabase);
|
|
337
|
+
try {
|
|
338
|
+
for (;;) {
|
|
339
|
+
if (s.signal.aborted) {
|
|
340
|
+
if (s.outer.aborted)
|
|
341
|
+
throw s.outer.reason;
|
|
342
|
+
return undefined;
|
|
343
|
+
}
|
|
344
|
+
if (leases.tryAcquire([resource], owner, token, s.budgetMs))
|
|
345
|
+
break;
|
|
346
|
+
const lease = leases.list().find((l) => l.key === key);
|
|
347
|
+
if (lease) {
|
|
348
|
+
try {
|
|
349
|
+
leases.clearAbandoned(key, lease.token);
|
|
350
|
+
continue;
|
|
351
|
+
}
|
|
352
|
+
catch {
|
|
353
|
+
/* Процесс с этим pid есть (или аренда уже снята): чей он — ниже. */
|
|
354
|
+
}
|
|
355
|
+
const started = lease.owner.startsWith(LEASE_OWNER)
|
|
356
|
+
? lease.owner.slice(LEASE_OWNER.length)
|
|
357
|
+
: '';
|
|
358
|
+
if (started && !compared.has(lease.token)) {
|
|
359
|
+
compared.add(lease.token);
|
|
360
|
+
const actual = processStartedAt(lease.pid);
|
|
361
|
+
// Сравнить не с чем — владелец считается живым.
|
|
362
|
+
if (actual !== undefined && Math.abs(actual - Number(started)) > START_TOLERANCE_MS) {
|
|
363
|
+
leases.release(lease.token);
|
|
364
|
+
continue;
|
|
365
|
+
}
|
|
366
|
+
}
|
|
367
|
+
}
|
|
368
|
+
try {
|
|
369
|
+
await delay(200, undefined, { signal: s.signal });
|
|
370
|
+
}
|
|
371
|
+
catch (error) {
|
|
372
|
+
if (s.outer.aborted)
|
|
373
|
+
throw error;
|
|
374
|
+
return undefined;
|
|
375
|
+
}
|
|
376
|
+
}
|
|
377
|
+
return await work();
|
|
378
|
+
}
|
|
379
|
+
finally {
|
|
380
|
+
leases.release(token);
|
|
381
|
+
leases.close();
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
const failedMark = (s, key) => join(s.root, 'failed', key);
|
|
385
|
+
/** Действующая пометка отказа; нечитаемая равна её отсутствию и будет заменена. */
|
|
386
|
+
async function failedBuild(s, key) {
|
|
387
|
+
const path = failedMark(s, key);
|
|
388
|
+
const raw = await readFile(path, 'utf8').catch(() => undefined);
|
|
389
|
+
if (raw === undefined)
|
|
390
|
+
return undefined;
|
|
391
|
+
let mark;
|
|
392
|
+
try {
|
|
393
|
+
mark = JSON.parse(raw);
|
|
394
|
+
}
|
|
395
|
+
catch {
|
|
396
|
+
return undefined;
|
|
397
|
+
}
|
|
398
|
+
if (typeof mark?.reason !== 'string')
|
|
399
|
+
return undefined;
|
|
400
|
+
if (mark.maxBytes !== undefined && mark.maxBytes !== s.spec.maxBytes)
|
|
401
|
+
return undefined;
|
|
402
|
+
if (mark.permanent)
|
|
403
|
+
return mark;
|
|
404
|
+
const st = await stat(path).catch(() => undefined);
|
|
405
|
+
return st && Date.now() - st.mtimeMs < FAILED_BUILD_COOLDOWN_MS ? mark : undefined;
|
|
406
|
+
}
|
|
407
|
+
const failedReason = (mark) => (mark.permanent ? 'сборка этого lockfile невозможна: ' : 'недавняя сборка не удалась: ') +
|
|
408
|
+
mark.reason;
|
|
409
|
+
/** Запись через переименование: обрыв не оставляет половину пометки. */
|
|
410
|
+
async function markFailed(s, key, mark) {
|
|
411
|
+
s.receipt.reason = mark.reason;
|
|
412
|
+
if (mark.untouched)
|
|
413
|
+
s.receipt.untouched = true;
|
|
414
|
+
const dir = join(s.root, 'failed');
|
|
415
|
+
await mkdir(dir, { recursive: true });
|
|
416
|
+
const staged = join(dir, `.${randomUUID()}`);
|
|
417
|
+
await writeFile(staged, JSON.stringify(mark));
|
|
418
|
+
await rename(staged, failedMark(s, key));
|
|
419
|
+
}
|
|
420
|
+
const remaining = (s) => s.budgetEnds - Date.now();
|
|
421
|
+
/** Пол не выше полного бюджета, иначе малый `timeoutMs` не дал бы собрать seed никогда. */
|
|
422
|
+
const buildFloor = (s) => Math.min(storeTree.minBuildMs, s.fullBudgetMs * FULL_BUDGET_SHARE);
|
|
423
|
+
/** Один проход сборки в каталоге `work`; итог — дерево с отпечатком или причина отказа. */
|
|
424
|
+
async function fetchInto(s, work, lock, settings, base) {
|
|
425
|
+
const project = join(work, 'project');
|
|
426
|
+
const store = join(work, 'store');
|
|
427
|
+
await rm(work, { recursive: true, force: true });
|
|
428
|
+
await mkdir(project, { recursive: true });
|
|
429
|
+
await writeFile(join(project, s.spec.lockfile.split('/').at(-1)), lock + '\n');
|
|
430
|
+
for (const [name, text] of Object.entries(s.manager.buildFiles))
|
|
431
|
+
await writeFile(join(name === 'package.json' ? project : work, name), text);
|
|
432
|
+
if (base)
|
|
433
|
+
await place(base, store, s.outer);
|
|
434
|
+
const result = await storeTree.run({ config: s.ctx.policy }, {
|
|
435
|
+
argv: s.manager.fetch(store),
|
|
436
|
+
cwd: project,
|
|
437
|
+
env: { ...s.execution.env, ...s.manager.buildEnv(work) },
|
|
438
|
+
redact: s.execution.redact,
|
|
439
|
+
signal: s.signal,
|
|
440
|
+
timeoutMs: s.budgetMs,
|
|
441
|
+
write: [work],
|
|
442
|
+
readable: [],
|
|
443
|
+
controller: s.ctx.boundary.hidden,
|
|
444
|
+
...(s.ctx.boundary.checkouts?.length ? { checkouts: s.ctx.boundary.checkouts } : {}),
|
|
445
|
+
settingsDir: settings,
|
|
446
|
+
});
|
|
447
|
+
await mkdir(s.logDir, { recursive: true });
|
|
448
|
+
await writeFile(join(s.logDir, 'dependency-store.log'), s.execution.redact(result.stdout + '\n' + result.stderr));
|
|
449
|
+
// Прерванный менеджер мог выйти и без кода ошибки: его store не итог сборки, а
|
|
450
|
+
// пустой store иначе выглядел бы неизбежным отказом самого lockfile.
|
|
451
|
+
if (result.code || result.timedOut || s.signal.aborted) {
|
|
452
|
+
const output = s.execution.redact(result.stderr || result.stdout).trim();
|
|
453
|
+
throw new BuildFailed(`сборка seed: код ${result.code}${result.timedOut ? ', предел времени' : ''}: ${output.slice(-500)}`, !result.timedOut && s.manager.permanent.test(result.stdout + result.stderr));
|
|
454
|
+
}
|
|
455
|
+
try {
|
|
456
|
+
return { store, ...(await fingerprint(store)) };
|
|
457
|
+
}
|
|
458
|
+
catch (error) {
|
|
459
|
+
// Отказ относится к тому, что менеджер только что записал, а не к основе.
|
|
460
|
+
if (error instanceof SeedRefused)
|
|
461
|
+
throw new BuildFailed(`сборка seed: ${error.message}`, true);
|
|
462
|
+
throw error;
|
|
463
|
+
}
|
|
464
|
+
}
|
|
465
|
+
class BuildFailed extends Error {
|
|
466
|
+
permanent;
|
|
467
|
+
detail;
|
|
468
|
+
constructor(message, permanent, detail = {}) {
|
|
469
|
+
super(message);
|
|
470
|
+
this.permanent = permanent;
|
|
471
|
+
this.detail = detail;
|
|
472
|
+
}
|
|
473
|
+
}
|
|
474
|
+
/** Сборка seed и атомарная публикация; отказ — причина и пометка, не исключение. */
|
|
475
|
+
async function buildSeed(s, key, lock, lockSha256) {
|
|
476
|
+
await sweep(s);
|
|
477
|
+
const tmp = join(s.root, 'tmp', randomUUID());
|
|
478
|
+
const work = join(tmp, 'work');
|
|
479
|
+
const full = remaining(s) >= s.fullBudgetMs * FULL_BUDGET_SHARE;
|
|
480
|
+
try {
|
|
481
|
+
// Основа — свежий seed той же среды: сдвиг lockfile докачивает только разницу.
|
|
482
|
+
let base = await newestSeed(s);
|
|
483
|
+
let built;
|
|
484
|
+
for (;;) {
|
|
485
|
+
try {
|
|
486
|
+
built = await fetchInto(s, work, lock, join(tmp, 'settings'), base);
|
|
487
|
+
}
|
|
488
|
+
catch (error) {
|
|
489
|
+
if (!base)
|
|
490
|
+
throw error;
|
|
491
|
+
if (error instanceof SeedRefused)
|
|
492
|
+
await refuse(s, base.key, error.message);
|
|
493
|
+
// Приговор lockfile выносит только сборка без основы.
|
|
494
|
+
else if (!(error instanceof BuildFailed && error.permanent))
|
|
495
|
+
throw error;
|
|
496
|
+
base = undefined;
|
|
497
|
+
continue;
|
|
498
|
+
}
|
|
499
|
+
// Основа копит пакеты прежних lockfile: сверх предела — заново с пустого.
|
|
500
|
+
if ((built.bytes <= s.spec.maxBytes && built.files.size <= storeTree.maxFiles) || !base)
|
|
501
|
+
break;
|
|
502
|
+
base = undefined;
|
|
503
|
+
}
|
|
504
|
+
if (built.bytes > s.spec.maxBytes)
|
|
505
|
+
throw new BuildFailed(`seed ${built.bytes} байт больше предела ${s.spec.maxBytes}`, true, {
|
|
506
|
+
maxBytes: s.spec.maxBytes,
|
|
507
|
+
untouched: true,
|
|
508
|
+
});
|
|
509
|
+
if (built.files.size > storeTree.maxFiles)
|
|
510
|
+
throw new BuildFailed(`seed из ${built.files.size} файлов больше предела ${storeTree.maxFiles}`, true, { untouched: true });
|
|
511
|
+
// Менеджер мог выйти с кодом 0 и ничего не сохранить: такой seed не ускоряет
|
|
512
|
+
// ничего, а выглядел бы попаданием.
|
|
513
|
+
if (!built.files.size)
|
|
514
|
+
throw new BuildFailed('менеджер не сохранил ни одного файла', true);
|
|
515
|
+
const manifest = {
|
|
516
|
+
format: FORMAT,
|
|
517
|
+
key,
|
|
518
|
+
identity: s.identity,
|
|
519
|
+
lockSha256,
|
|
520
|
+
builtAt: new Date().toISOString(),
|
|
521
|
+
bytes: built.bytes,
|
|
522
|
+
files: Object.fromEntries(built.files),
|
|
523
|
+
};
|
|
524
|
+
const raw = JSON.stringify(manifest);
|
|
525
|
+
const staged = join(tmp, 'seed');
|
|
526
|
+
await mkdir(staged);
|
|
527
|
+
await rename(built.store, join(staged, 'store'));
|
|
528
|
+
await writeFile(join(staged, 'manifest.json'), raw);
|
|
529
|
+
await mkdir(join(s.root, 'seeds'), { recursive: true });
|
|
530
|
+
// Закрепление раньше публикации: читатель не застаёт незакреплённый seed.
|
|
531
|
+
pool(s, (p) => p.setSeedPin(s.root, key, sha256(raw)));
|
|
532
|
+
await rename(staged, join(s.root, 'seeds', key));
|
|
533
|
+
// Новый seed значит новый lockfile: прежние отказы к нему не относятся.
|
|
534
|
+
await rm(join(s.root, 'failed'), { recursive: true, force: true });
|
|
535
|
+
s.receipt.built = true;
|
|
536
|
+
await collect(s, key);
|
|
537
|
+
return { key, store: join(s.root, 'seeds', key, 'store'), manifest };
|
|
538
|
+
}
|
|
539
|
+
catch (error) {
|
|
540
|
+
if (s.outer.aborted)
|
|
541
|
+
throw error;
|
|
542
|
+
const known = error instanceof BuildFailed ? error : undefined;
|
|
543
|
+
// Неизбежный отказ остаётся собой, даже если бюджет истёк в тот же момент.
|
|
544
|
+
const expired = s.signal.aborted && !known?.permanent;
|
|
545
|
+
const reason = expired
|
|
546
|
+
? `бюджет хранилища ${s.budgetMs} мс истёк`
|
|
547
|
+
: error instanceof Error
|
|
548
|
+
? error.message
|
|
549
|
+
: String(error);
|
|
550
|
+
// Истечение бюджета опоздавшей фазы говорит о ней, а не о реестре: остальным
|
|
551
|
+
// попыткам сборка не закрывается.
|
|
552
|
+
if (expired && !full) {
|
|
553
|
+
s.receipt.reason = reason;
|
|
554
|
+
if (known?.detail.untouched)
|
|
555
|
+
s.receipt.untouched = true;
|
|
556
|
+
}
|
|
557
|
+
else
|
|
558
|
+
await markFailed(s, key, {
|
|
559
|
+
reason,
|
|
560
|
+
permanent: known?.permanent ?? false,
|
|
561
|
+
...known?.detail,
|
|
562
|
+
});
|
|
563
|
+
return undefined;
|
|
564
|
+
}
|
|
565
|
+
finally {
|
|
566
|
+
await rm(tmp, { recursive: true, force: true }).catch(() => undefined);
|
|
567
|
+
}
|
|
568
|
+
}
|
|
569
|
+
/** Брошенные каталоги сборки: вызывается под арендой, живых среди них нет. */
|
|
570
|
+
async function sweep(s) {
|
|
571
|
+
for (const name of await readdir(join(s.root, 'tmp')).catch(() => []))
|
|
572
|
+
await rm(join(s.root, 'tmp', name), { recursive: true, force: true });
|
|
573
|
+
}
|
|
574
|
+
/**
|
|
575
|
+
* Предел диска: остаются последние по использованию seeds, не больше
|
|
576
|
+
* `KEEP_SEEDS` и в пределах `maxBytes`. Только что собранный остаётся всегда.
|
|
577
|
+
*/
|
|
578
|
+
async function collect(s, current) {
|
|
579
|
+
const seeds = [];
|
|
580
|
+
for (const key of await seedKeys(s)) {
|
|
581
|
+
const path = join(s.root, 'seeds', key, 'manifest.json');
|
|
582
|
+
const seed = await readFile(path, 'utf8').then(async (raw) => ({
|
|
583
|
+
key,
|
|
584
|
+
used: (await stat(path)).mtimeMs,
|
|
585
|
+
bytes: Number(JSON.parse(raw).bytes) || 0,
|
|
586
|
+
}), () => undefined);
|
|
587
|
+
if (seed)
|
|
588
|
+
seeds.push(seed);
|
|
589
|
+
}
|
|
590
|
+
const ordered = seeds.sort((a, b) => Number(b.key === current) - Number(a.key === current) || b.used - a.used);
|
|
591
|
+
let total = 0;
|
|
592
|
+
for (const [i, seed] of ordered.entries()) {
|
|
593
|
+
total += seed.bytes;
|
|
594
|
+
if (i && (i >= KEEP_SEEDS || total > s.spec.maxBytes))
|
|
595
|
+
await dropSeed(s, seed.key);
|
|
596
|
+
}
|
|
597
|
+
}
|
|
598
|
+
/** Точный seed целевой ветки (собирается при нужде), иначе свежий seed той же среды. */
|
|
599
|
+
async function chooseSeed(s) {
|
|
600
|
+
const lock = await gitOutput(s.ctx.repoPath(s.repo), 'show', `${s.repo.targetRef}:${s.spec.lockfile}`).catch(() => undefined);
|
|
601
|
+
if (lock === undefined) {
|
|
602
|
+
s.receipt.reason = `${s.spec.lockfile} нет в ${s.repo.targetRef}`;
|
|
603
|
+
return undefined;
|
|
604
|
+
}
|
|
605
|
+
const lockSha256 = sha256(lock);
|
|
606
|
+
const key = digestOf({ format: FORMAT, identity: s.identity, lockSha256 });
|
|
607
|
+
const exact = await readSeed(s, key);
|
|
608
|
+
if (exact)
|
|
609
|
+
return exact;
|
|
610
|
+
const mark = (failed) => {
|
|
611
|
+
s.receipt.reason = failedReason(failed);
|
|
612
|
+
if (failed.untouched)
|
|
613
|
+
s.receipt.untouched = true;
|
|
614
|
+
};
|
|
615
|
+
const late = () => {
|
|
616
|
+
if (remaining(s) >= buildFloor(s))
|
|
617
|
+
return false;
|
|
618
|
+
s.receipt.reason = `на сборку seed остаётся меньше ${buildFloor(s)} мс`;
|
|
619
|
+
return true;
|
|
620
|
+
};
|
|
621
|
+
const failed = await failedBuild(s, key);
|
|
622
|
+
if (failed)
|
|
623
|
+
mark(failed);
|
|
624
|
+
else if (!late()) {
|
|
625
|
+
const built = await exclusive(s, async () => {
|
|
626
|
+
const seed = await readSeed(s, key);
|
|
627
|
+
if (seed)
|
|
628
|
+
return seed;
|
|
629
|
+
// Проверка под арендой: очередь за упавшей сборкой не повторяет её, а
|
|
630
|
+
// дождавшийся конца бюджета не начинает то, что не успеет.
|
|
631
|
+
const refused = await failedBuild(s, key);
|
|
632
|
+
if (refused)
|
|
633
|
+
mark(refused);
|
|
634
|
+
else if (!late())
|
|
635
|
+
return buildSeed(s, key, lock, lockSha256);
|
|
636
|
+
return undefined;
|
|
637
|
+
});
|
|
638
|
+
if (built)
|
|
639
|
+
return built;
|
|
640
|
+
s.receipt.reason ??= 'не дождались чужой сборки seed';
|
|
641
|
+
}
|
|
642
|
+
return newestSeed(s);
|
|
643
|
+
}
|
|
644
|
+
/** Версии среды или причина, почему их не узнать: без неё промах не объяснить. */
|
|
645
|
+
async function identityOf(manager, spec, env) {
|
|
646
|
+
const probe = (argv) => defaultProbe(argv, { timeoutMs: IDENTITY_PROBE_MS, env }).then((r) => (r.code ? `${argv[0]}: код ${r.code}${r.timedOut ? ', предел времени' : ''}` : r), (error) => `${argv[0]}: ${error instanceof Error ? error.message : String(error)}`);
|
|
647
|
+
const [tool, node] = await Promise.all([probe(manager.version), probe(['node', '--version'])]);
|
|
648
|
+
if (typeof tool === 'string' || typeof node === 'string')
|
|
649
|
+
return `не найден ${manager.version[0]} или node: ${[tool, node]
|
|
650
|
+
.filter((r) => typeof r === 'string')
|
|
651
|
+
.join('; ')}`;
|
|
652
|
+
return {
|
|
653
|
+
manager: spec.manager,
|
|
654
|
+
version: tool.stdout.trim(),
|
|
655
|
+
node: node.stdout.trim(),
|
|
656
|
+
platform: process.platform,
|
|
657
|
+
arch: process.arch,
|
|
658
|
+
};
|
|
659
|
+
}
|
|
660
|
+
/** Почему этой версией менеджера хранилище не пользуется, или `undefined`. */
|
|
661
|
+
async function unsupported(identity, spec, cwd) {
|
|
662
|
+
const { from, below } = dependencyStoreVersions[spec.manager];
|
|
663
|
+
const version = versionOf(identity.version);
|
|
664
|
+
if (!version)
|
|
665
|
+
return `версия ${spec.manager} не определена`;
|
|
666
|
+
// Файл пишет кандидат: чтение не идёт по ссылке, не ждёт устройство и не берёт лишнего.
|
|
667
|
+
// Нечитаемый файл скрывает закреплённую версию; отсутствующий ничего не закрепляет.
|
|
668
|
+
let pinned;
|
|
669
|
+
try {
|
|
670
|
+
const raw = await readBounded(join(cwd, 'package.json'), MANIFEST_LIMIT);
|
|
671
|
+
pinned = JSON.parse(raw)?.packageManager;
|
|
672
|
+
}
|
|
673
|
+
catch (error) {
|
|
674
|
+
if (error.code !== 'ENOENT')
|
|
675
|
+
return `package.json не прочитан: версия ${spec.manager} не определена`;
|
|
676
|
+
}
|
|
677
|
+
const versions = [version, declaredManagerVersion(pinned, spec.manager)].filter((v) => v !== undefined);
|
|
678
|
+
const wrong = versions.find((v) => !dependencyStoreSupports(spec.manager, v));
|
|
679
|
+
return wrong && `${spec.manager} ${wrong} вне проверенных версий ${from} … <${below}`;
|
|
680
|
+
}
|
|
681
|
+
/** Lockfile checkout: обычный файл внутри дерева или ничего; сверх предела — `oversized`. */
|
|
682
|
+
async function checkoutLock(cwd, lockfile) {
|
|
683
|
+
const text = await readBounded(join(cwd, lockfile), LOCK_LIMIT).catch((error) => error instanceof OversizedFile ? 'oversized' : undefined);
|
|
684
|
+
return text === undefined || text === 'oversized' ? text : sha256(text.trim());
|
|
685
|
+
}
|
|
686
|
+
/**
|
|
687
|
+
* Подготовить хранилище checkout до `prepare` и gates. Промах — обычный исход:
|
|
688
|
+
* исключение бывает только при отмене, а сводка пишется в `dir`.
|
|
689
|
+
* Окружение менеджера дописывается в `execution` (как `withEnvironment` дописывает
|
|
690
|
+
* каталог окружения) и повторяется в квитанции для хостов с окружением на gate.
|
|
691
|
+
*/
|
|
692
|
+
export async function materializeStore(ctx, input) {
|
|
693
|
+
const spec = input.repo.dependencyStore;
|
|
694
|
+
if (!spec)
|
|
695
|
+
return undefined;
|
|
696
|
+
const started = Date.now();
|
|
697
|
+
const manager = managers[spec.manager];
|
|
698
|
+
const dest = join(input.cwd, manager.dir);
|
|
699
|
+
const summary = {};
|
|
700
|
+
let env = {};
|
|
701
|
+
// Хранилище checkout всегда скрыто от git своим `.gitignore`: и при промахе —
|
|
702
|
+
// менеджер всё равно создаёт его здесь, и проект не обязан его игнорировать.
|
|
703
|
+
const seal = async () => {
|
|
704
|
+
await mkdir(dest, { recursive: true });
|
|
705
|
+
await storeTree.ignore(dest);
|
|
706
|
+
env = manager.env(dest);
|
|
707
|
+
Object.assign(input.execution.env, env);
|
|
708
|
+
};
|
|
709
|
+
try {
|
|
710
|
+
if (ctx.policy.isolation.mode !== 'os')
|
|
711
|
+
summary.reason = 'isolation.mode: none: граница seed не действует, установка обычная';
|
|
712
|
+
// Занятый путь — и ссылка, которую кандидат мог положить, чтобы увести
|
|
713
|
+
// запись controller из дерева: туда ничего не пишется.
|
|
714
|
+
else if (await lstat(dest).catch(() => undefined))
|
|
715
|
+
summary.reason = `${manager.dir} уже есть в дереве`;
|
|
716
|
+
else {
|
|
717
|
+
const identity = await identityOf(manager, spec, input.execution.env);
|
|
718
|
+
const refusal = typeof identity === 'string' ? identity : await unsupported(identity, spec, input.cwd);
|
|
719
|
+
// Вне проверенных версий окружение и дерево остаются как без хранилища.
|
|
720
|
+
// Найти менеджер не удалось — то же: проверить версию нечем.
|
|
721
|
+
if (refusal || typeof identity === 'string')
|
|
722
|
+
summary.reason = refusal;
|
|
723
|
+
else {
|
|
724
|
+
const lock = await checkoutLock(input.cwd, spec.lockfile);
|
|
725
|
+
if (lock === undefined)
|
|
726
|
+
summary.reason = `в дереве нет файла ${spec.lockfile}`;
|
|
727
|
+
else if (lock === 'oversized') {
|
|
728
|
+
summary.reason = `${spec.lockfile} больше предела ${LOCK_LIMIT} байт`;
|
|
729
|
+
summary.untouched = true;
|
|
730
|
+
}
|
|
731
|
+
else {
|
|
732
|
+
const budgetMs = Math.max(1, Math.floor(Math.min(spec.timeoutMs, (ctx.deadline - Date.now()) * STORE_TIME_SHARE)));
|
|
733
|
+
const s = {
|
|
734
|
+
ctx,
|
|
735
|
+
repo: input.repo,
|
|
736
|
+
spec,
|
|
737
|
+
manager,
|
|
738
|
+
root: ctx.root(input.repo.id),
|
|
739
|
+
execution: input.execution,
|
|
740
|
+
outer: input.signal,
|
|
741
|
+
signal: AbortSignal.any([input.signal, AbortSignal.timeout(budgetMs)]),
|
|
742
|
+
budgetMs,
|
|
743
|
+
budgetEnds: Date.now() + budgetMs,
|
|
744
|
+
fullBudgetMs: Math.min(spec.timeoutMs, ctx.phaseMs * STORE_TIME_SHARE),
|
|
745
|
+
logDir: input.dir,
|
|
746
|
+
identity,
|
|
747
|
+
receipt: summary,
|
|
748
|
+
};
|
|
749
|
+
const present = await treeEntries(input.cwd);
|
|
750
|
+
for (let round = 0; round < 2 && !summary.outcome; round++) {
|
|
751
|
+
const seed = await chooseSeed(s);
|
|
752
|
+
if (!seed)
|
|
753
|
+
break;
|
|
754
|
+
const entries = Object.keys(seed.manifest.files).length + present;
|
|
755
|
+
if (entries > storeTree.maxEntries) {
|
|
756
|
+
// Копия не влезла бы в сверку защищённых путей: проверка упала бы.
|
|
757
|
+
summary.reason = `checkout с копией seed — ${entries} элементов, предел ${storeTree.maxEntries}`;
|
|
758
|
+
summary.untouched = true;
|
|
759
|
+
break;
|
|
760
|
+
}
|
|
761
|
+
try {
|
|
762
|
+
summary.mode = await place(seed, dest, input.signal);
|
|
763
|
+
await utimes(join(s.root, 'seeds', seed.key, 'manifest.json'), new Date(), new Date());
|
|
764
|
+
summary.outcome = seed.manifest.lockSha256 === lock ? 'hit' : 'partial';
|
|
765
|
+
summary.seed = seed.key;
|
|
766
|
+
summary.files = Object.keys(seed.manifest.files).length;
|
|
767
|
+
summary.bytes = seed.manifest.bytes;
|
|
768
|
+
}
|
|
769
|
+
catch (error) {
|
|
770
|
+
await rm(dest, { recursive: true, force: true });
|
|
771
|
+
delete summary.mode;
|
|
772
|
+
if (!(error instanceof SeedRefused))
|
|
773
|
+
throw error;
|
|
774
|
+
await refuse(s, seed.key, error.message);
|
|
775
|
+
}
|
|
776
|
+
}
|
|
777
|
+
}
|
|
778
|
+
// Предел — причина промаха: установка в дереве сама упёрлась бы в сверку.
|
|
779
|
+
if (summary.outcome || !summary.untouched)
|
|
780
|
+
await seal();
|
|
781
|
+
}
|
|
782
|
+
}
|
|
783
|
+
}
|
|
784
|
+
catch (error) {
|
|
785
|
+
if (input.signal.aborted)
|
|
786
|
+
throw error;
|
|
787
|
+
// Квитанция не обещает то, чего в дереве уже нет.
|
|
788
|
+
for (const field of ['outcome', 'mode', 'seed', 'files', 'bytes'])
|
|
789
|
+
delete summary[field];
|
|
790
|
+
summary.reason = error instanceof Error ? error.message : String(error);
|
|
791
|
+
env = {};
|
|
792
|
+
await rm(dest, { recursive: true, force: true }).catch(() => undefined);
|
|
793
|
+
// Не вышло и это — в дереве ничего не остаётся, как без хранилища. Так же, если
|
|
794
|
+
// причина промаха — предел.
|
|
795
|
+
if (!summary.untouched)
|
|
796
|
+
await seal().catch(() => rm(dest, { recursive: true, force: true }).catch(() => undefined));
|
|
797
|
+
}
|
|
798
|
+
delete summary.untouched;
|
|
799
|
+
const receipt = {
|
|
800
|
+
outcome: 'miss',
|
|
801
|
+
...summary,
|
|
802
|
+
manager: spec.manager,
|
|
803
|
+
durationMs: Date.now() - started,
|
|
804
|
+
env,
|
|
805
|
+
};
|
|
806
|
+
// Квитанция — наблюдение, а не условие работы: полный диск не отказ фазы.
|
|
807
|
+
await mkdir(input.dir, { recursive: true })
|
|
808
|
+
.then(() => writeFile(join(input.dir, 'dependency-store.json'), JSON.stringify(receipt, null, 2)))
|
|
809
|
+
.catch(() => undefined);
|
|
810
|
+
return receipt;
|
|
811
|
+
}
|