문제: 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.
204 lines
8.9 KiB
TypeScript
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({"));
|
|
});
|
|
});
|