Files
mtusi2026lab4/test/upload-memory-probe.mjs
qrtx dc46ac213d feat(storage): add RustFS attachments and presigned uploads
Add two API replicas, safe object reconciliation, upload validation, regression tests and documented load experiments.
2026-11-12 10:16:39 +03:00

148 lines
4.6 KiB
JavaScript

// Executed by the test through docker exec; does not change the API process.
import { readFileSync, readdirSync } from 'node:fs';
import { createInterface } from 'node:readline';
import { performance } from 'node:perf_hooks';
const emit = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
const candidates = readdirSync('/proc').filter((name) => {
if (!/^\d+$/.test(name) || Number(name) === process.pid) return false;
try {
const args = readFileSync(`/proc/${name}/cmdline`, 'utf8').split('\0');
return args.some((arg) => /(^|\/)dist\/main\.js$/.test(arg));
} catch {
return false;
}
});
if (candidates.length !== 1)
throw new Error('Expected exactly one API process');
const pid = Number(candidates[0]);
const startTime = () =>
readFileSync(`/proc/${pid}/stat`, 'utf8').split(') ').at(-1).split(' ')[19];
const identity = startTime();
function snapshot() {
if (startTime() !== identity)
throw new Error('API process changed during test');
const status = readFileSync(`/proc/${pid}/status`, 'utf8');
const rss = Number(status.match(/^VmRSS:\s+(\d+) kB$/m)?.[1]) * 1024;
const hwm = Number(status.match(/^VmHWM:\s+(\d+) kB$/m)?.[1]) * 1024;
if (!Number.isFinite(rss) || !Number.isFinite(hwm))
throw new Error('Missing RSS/HWM metrics');
const events = Object.fromEntries(
readFileSync('/sys/fs/cgroup/memory.events', 'utf8')
.trim()
.split('\n')
.map((line) => {
const [key, value] = line.split(' ');
return [key, Number(value)];
}),
);
let rx = 0;
let tx = 0;
for (const line of readFileSync('/proc/net/dev', 'utf8')
.split('\n')
.slice(2)) {
if (!line.includes(':')) continue;
const [name, counters] = line.split(':');
if (name.trim() === 'lo') continue;
const values = counters.trim().split(/\s+/).map(Number);
rx += values[0];
tx += values[8];
}
const cgroup = Number(
readFileSync('/sys/fs/cgroup/memory.current', 'utf8').trim(),
);
return {
rss,
hwm,
oom: events.oom,
oomKill: events.oom_kill,
rx,
tx,
cgroup,
};
}
let active;
function sample() {
const value = snapshot();
if (active) {
active.peakRss = Math.max(active.peakRss, value.rss);
active.peakCgroup = Math.max(active.peakCgroup, value.cgroup);
active.maxSampleGapMs = Math.max(
active.maxSampleGapMs,
performance.now() - active.lastSample,
);
active.lastSample = performance.now();
active.samples++;
}
return value;
}
const timer = setInterval(() => {
if (!active) return;
try {
sample();
} catch {
emit({
event: 'error',
message: 'API memory probe failed; process may have restarted',
});
process.exit(1);
}
}, 50);
const input = createInterface({ input: process.stdin });
input.on('line', (command) => {
try {
if (command === 'begin') {
if (active) throw new Error('Memory phase already active');
const baseline = snapshot();
active = {
baseline,
peakRss: baseline.rss,
peakCgroup: baseline.cgroup,
samples: 0,
started: performance.now(),
lastSample: performance.now(),
maxSampleGapMs: 0,
};
emit({ event: 'begin', pid });
} else if (command === 'end') {
if (!active) throw new Error('No memory phase active');
const end = sample();
emit({
event: 'summary',
pid,
baselineRssBytes: active.baseline.rss,
sampledPeakRssBytes: active.peakRss,
finalRssBytes: end.rss,
baselineCgroupBytes: active.baseline.cgroup,
sampledPeakCgroupBytes: active.peakCgroup,
finalCgroupBytes: end.cgroup,
lifetimeHwmBeforeBytes: active.baseline.hwm,
lifetimeHwmAfterBytes: end.hwm,
oomDelta: end.oom - active.baseline.oom,
oomKillDelta: end.oomKill - active.baseline.oomKill,
networkRxBytes: end.rx - active.baseline.rx,
networkTxBytes: end.tx - active.baseline.tx,
samples: active.samples,
maxSampleGapMs: active.maxSampleGapMs,
durationMs: performance.now() - active.started,
});
active = undefined;
} else if (command === 'snapshot') {
emit({ event: 'snapshot', ...snapshot() });
} else if (command === 'quit') {
input.close();
process.stdin.destroy();
} else throw new Error('Unknown memory probe command');
} catch {
emit({ event: 'error', message: 'Memory probe command failed' });
process.exit(1);
}
});
input.on('close', () => clearInterval(timer));
emit({
event: 'ready',
pid,
instance: readFileSync('/etc/hostname', 'utf8').trim(),
intervalMs: 50,
});