Files
clean-architecture-frontend…/tests/unit/system-test-prerequisites.test.ts
T
DongHyeonka 4e1a385fd9 fix(ci): 시스템 시험 사전 점검이 user manager의 cgroup 제어기를 본다
문제: provider scope는 systemd user manager에게서 cpu·memory·pids
제어기를 받아야 한도를 건다. 사전 점검은 root cgroup에 쓸 수 있는
제어기가 있는지만 봐서, user manager가 아무 제어기도 받지 못한
컨테이너(2026-11-14, desktop 4회 중 1회)에서도 PASS를 냈다. 그 뒤
provider 시험 18개가 하나씩 `cannot read memory.max`로 떨어졌다.

고른 방법: 이 프로세스의 uid(/proc/self/status)로 user manager의
cgroup(user.slice/user-<uid>.slice/user@<uid>.service)을 찾고, 그
cgroup.controllers에 cpu·memory·pids가 다 있는지 본다. 빠지면 빠진
이름과 있는 목록을 댄다. cgroup v2 확인이 실패한 호스트에서는 이 경로가
뜻이 없어 건너뛴다. 호스트를 읽는 부분은 기존처럼 SystemTestHost를
거친다.
버린 대안: systemd-run --user --scope로 실제 scope를 띄워 memory.max를
읽기는 본 단계와 더 같지만, 사전 점검이 unit을 만들고 정리해야 한다.
제어기 목록은 scope가 받을 수 있는 것과 같은 값이라 읽기로 충분하다.

위험·한계: systemd의 표준 user manager cgroup 경로를 가정한다. 그 경로에
manager가 없으면 사전 점검이 실패한다(provider는 systemd-run --user를
쓰므로 그때도 돌 수 없다).

검증: 노트북 감싸개에서 새 시험이 옛 점검으로 4개 실패(RED), 고친 뒤
system-test-prerequisites 13/13 통과. 노트북에서 실제 점검 PASS.
2026-11-14 06:04:30 +09:00

204 lines
8.9 KiB
TypeScript

import { readFile } from "node:fs/promises";
import { describe, expect, it } from "vitest";
import {
findProviderSandboxNamespaceFailure,
findSystemTestPrerequisiteFailures,
formatSystemTestPrerequisiteReport,
NAMESPACE_PROBE_ARGUMENTS,
type SystemTestHost,
} from "../../scripts/check-system-test-prerequisites.ts";
import { PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS } from "../../scripts/lib/provider-sandbox-namespaces.ts";
type SpawnCall = Readonly<{ command: string; args: readonly string[] }>;
type SpawnResult = ReturnType<SystemTestHost["spawn"]>;
const RTM_NEWADDR = "bwrap: loopback: Failed RTM_NEWADDR: Operation not permitted";
const USER_MANAGER_CONTROLLERS = "/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/cgroup.controllers";
/** A host that has every prerequisite, except what `bwrap` and `files` say. */
function fakeHost(
bwrap: SpawnResult,
files: Readonly<Record<string, string>> = {},
): { host: SystemTestHost; calls: SpawnCall[] } {
const calls: SpawnCall[] = [];
const host: SystemTestHost = {
access: async () => undefined,
readFile: async (target) => {
const content = {
"/sys/fs/cgroup/cgroup.controllers": "cpuset cpu io memory pids\n",
"/proc/self/status": "Name:\tnode\nUid:\t1000\t1000\t1000\t1000\n",
[USER_MANAGER_CONTROLLERS]: "cpu memory pids\n",
...files,
}[target];
if (content === undefined) throw new Error(`ENOENT: ${target}`);
return content;
},
spawn: (command, args) => {
calls.push({ command, args });
if (command === "/usr/bin/systemctl") return { status: 0, stderr: "" };
if (command === "/usr/bin/bwrap") return bwrap;
throw new Error(`unexpected spawn: ${command}`);
},
};
return { host, calls };
}
// 1105/12-01. The check looked only for the bwrap executable, so a host that
// refuses unprivileged user namespaces printed PASS and then failed 18
// provider tests with bwrap's raw netlink error.
describe("system test prerequisites (1105/12-01)", () => {
it("passes when bubblewrap creates the provider sandbox's namespaces", async () => {
const { host, calls } = fakeHost({ status: 0, stderr: "" });
expect(await findSystemTestPrerequisiteFailures(host)).toEqual([]);
const probes = calls.filter(({ command }) => command === "/usr/bin/bwrap");
expect(probes).toHaveLength(1);
expect(probes[0]?.args).toEqual(NAMESPACE_PROBE_ARGUMENTS);
expect(probes[0]?.args.at(-1)).toBe("/bin/true");
});
it("probes with exactly the namespace options the provider sandbox uses", async () => {
expect(PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS).toEqual([
"--unshare-pid",
"--unshare-ipc",
"--unshare-uts",
"--unshare-net",
]);
expect(NAMESPACE_PROBE_ARGUMENTS.slice(0, PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS.length)).toEqual(
PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS,
);
// The provider takes the list from the same module instead of its own copy.
const provider = await readFile("scripts/run-and-validate-provider.ts", "utf8");
expect(provider).toContain("...PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS,");
expect(provider).not.toMatch(/"--unshare-/u);
});
it("fails with the namespace restriction, bwrap's stderr and what to do when bwrap cannot set up loopback", async () => {
const { host } = fakeHost(
{ status: 1, stderr: `${RTM_NEWADDR}\n` },
{ "/proc/sys/kernel/apparmor_restrict_unprivileged_userns": "1\n" },
);
const failures = await findSystemTestPrerequisiteFailures(host);
expect(failures).toHaveLength(1);
const failure = failures[0] ?? "";
expect(failure).toMatch(/^this host does not allow unprivileged user and network namespaces/u);
expect(failure).toContain("--unshare-net");
expect(failure).toContain(`bwrap stderr: ${RTM_NEWADDR}`);
expect(failure).toContain("kernel.apparmor_restrict_unprivileged_userns = 1");
expect(failure).toMatch(/AppArmor profile/u);
expect(failure).toMatch(/sysctl kernel\.apparmor_restrict_unprivileged_userns=0/u);
expect(failure).toMatch(/another runner/u);
expect(formatSystemTestPrerequisiteReport(failures)).toContain(
" - this host does not allow unprivileged user and network namespaces",
);
});
it("fails the same way when the probe cannot run to the end", async () => {
const { host } = fakeHost({ status: null, stderr: "", error: new Error("spawnSync /usr/bin/bwrap ETIMEDOUT") });
const failures = await findSystemTestPrerequisiteFailures(host);
expect(failures).toHaveLength(1);
expect(failures[0]).toMatch(/^this host does not allow unprivileged user and network namespaces/u);
expect(failures[0]).toContain("did not finish: spawnSync /usr/bin/bwrap ETIMEDOUT");
});
it("keeps the executable, cgroup v2 and systemd bus checks, and probes bwrap only when it is there", async () => {
const calls: SpawnCall[] = [];
const host: SystemTestHost = {
access: async (target) => {
if (target === "/usr/bin/bwrap") throw new Error(`EACCES: ${target}`);
},
readFile: async () => "\n",
spawn: (command, args) => {
calls.push({ command, args });
return { status: 1, stderr: "Failed to connect to bus" };
},
};
expect(await findSystemTestPrerequisiteFailures(host)).toEqual([
"bubblewrap is required at /usr/bin/bwrap",
"cgroup v2 controllers are unavailable",
"a reachable systemd manager bus is required",
]);
expect(calls.map(({ command }) => command)).toEqual(["/usr/bin/systemctl"]);
});
});
// 2026-11-14. In one system container in four, systemd delegated no cgroup
// controller to the root user manager; this check printed PASS and then every
// provider stopped with `provider cgroup enforcement failed: cannot read
// memory.max`.
describe("system test prerequisites: provider scope controllers", () => {
it.each([
["none", "\n", "cpu, memory, pids", "none"],
["memory", "cpu pids\n", "memory", "cpu pids"],
])("names the controllers the user manager lacks (%s missing)", async (_label, delegated, missing, has) => {
const { host } = fakeHost({ status: 0, stderr: "" }, { [USER_MANAGER_CONTROLLERS]: delegated });
expect(await findSystemTestPrerequisiteFailures(host)).toEqual([
"the systemd user manager at /sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service " +
`has no ${missing} cgroup controller for provider scopes (it has: ${has})`,
]);
});
it("reads the user manager only where cgroup v2 is there", async () => {
const { host } = fakeHost({ status: 0, stderr: "" }, { "/sys/fs/cgroup/cgroup.controllers": "\n", [USER_MANAGER_CONTROLLERS]: "\n" });
expect(await findSystemTestPrerequisiteFailures(host)).toEqual(["cgroup v2 controllers are unavailable"]);
});
it("names an unreadable uid", async () => {
const { host } = fakeHost({ status: 0, stderr: "" }, { "/proc/self/status": "Name:\tnode\n" });
expect(await findSystemTestPrerequisiteFailures(host)).toEqual([
"this process's uid is unreadable at /proc/self/status",
]);
});
it("requires a user manager for this process's own uid", async () => {
const { host } = fakeHost({ status: 0, stderr: "" }, { "/proc/self/status": "Uid:\t0\t0\t0\t0\n" });
expect(await findSystemTestPrerequisiteFailures(host)).toEqual([
"a systemd user manager is required at /sys/fs/cgroup/user.slice/user-0.slice/user@0.service",
]);
});
});
// 1101/13-03. The release provider jobs run the same sandbox on whatever
// runner picks them up. The supervisor checked only that the executables
// exist, so a host that refuses the namespaces failed later with bwrap's raw
// error and without the host settings.
describe("provider sandbox namespace check (1101/13-03)", () => {
it("passes on a host that creates the namespaces and probes only with bwrap", async () => {
const { host, calls } = fakeHost({ status: 0, stderr: "" });
expect(await findProviderSandboxNamespaceFailure(host)).toBeUndefined();
expect(calls).toEqual([{ command: "/usr/bin/bwrap", args: NAMESPACE_PROBE_ARGUMENTS }]);
});
it("names the restriction, bwrap's stderr and the host settings on a host that refuses them", async () => {
const { host } = fakeHost(
{ status: 1, stderr: `${RTM_NEWADDR}\n` },
{ "/proc/sys/kernel/apparmor_restrict_unprivileged_userns": "1\n" },
);
const failure = (await findProviderSandboxNamespaceFailure(host)) ?? "";
expect(failure).toMatch(/^this host does not allow unprivileged user and network namespaces/u);
expect(failure).toContain(`bwrap stderr: ${RTM_NEWADDR}`);
expect(failure).toContain("kernel.apparmor_restrict_unprivileged_userns = 1");
});
it("runs before the provider supervisor launches anything", async () => {
const provider = await readFile("scripts/run-and-validate-provider.ts", "utf8");
const check = provider.indexOf("await findProviderSandboxNamespaceFailure()");
expect(check).toBeGreaterThan(0);
expect(check).toBeLessThan(provider.indexOf("superviseProviderEvidence({"));
});
});