209 lines
9.1 KiB
TypeScript
209 lines
9.1 KiB
TypeScript
import { execFileSync } from "node:child_process";
|
|
import { existsSync } from "node:fs";
|
|
import { readdir, readFile, writeFile } from "node:fs/promises";
|
|
import { createTempTree, type TempTree } from "@umt/testkit";
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
import {
|
|
defaultWorkerCommand,
|
|
FsError,
|
|
type FsProgress,
|
|
FsProxy,
|
|
fsErrorClass,
|
|
fsTestHookFromEnv,
|
|
sweepStalePartials,
|
|
toFsError,
|
|
} from "./index.ts";
|
|
|
|
// fsproxy:单个文件操作在执行子进程里跑,按进度心跳判挂死 → SIGTERM → SIGKILL → FsError('TIMEOUT')。
|
|
|
|
const trees: TempTree[] = [];
|
|
async function tree(...a: Parameters<typeof createTempTree>) {
|
|
const t = await createTempTree(...a);
|
|
trees.push(t);
|
|
return t;
|
|
}
|
|
afterEach(async () => {
|
|
await Promise.all(trees.splice(0).map((t) => t.cleanup()));
|
|
});
|
|
|
|
const MiB = 1024 * 1024;
|
|
const fast = { hangTimeoutMs: 800, quickTimeoutMs: 800, progressIntervalMs: 20, killGraceMs: 300 };
|
|
|
|
describe("FsProxy(子进程)", () => {
|
|
it("正常复制:结果与进程内一致,进度回调有值(复制 + 校验两阶段)", async () => {
|
|
const t = await tree({ "src/a.mkv": 6 * MiB + 5, "dst/": null });
|
|
const px = new FsProxy({ mode: "subprocess", progressIntervalMs: 1 });
|
|
const seen: FsProgress[] = [];
|
|
const r = await px.copy(
|
|
t.path("src/a.mkv"),
|
|
t.path("dst/a.mkv"),
|
|
{ hash: "sha256" },
|
|
{ onProgress: (p) => seen.push(p) },
|
|
);
|
|
expect(px.mode).toBe("subprocess");
|
|
expect(r.outcome).toBe("committed");
|
|
expect(r.bytes).toBe(6 * MiB + 5);
|
|
expect(r.sha256).toMatch(/^[0-9a-f]{64}$/);
|
|
expect((await readFile(t.path("dst/a.mkv"))).equals(await readFile(t.path("src/a.mkv")))).toBe(true);
|
|
const copy = seen.filter((p) => p.phase === "copy");
|
|
expect(copy.length).toBeGreaterThan(0);
|
|
expect(copy.at(-1)!.bytes).toBe(6 * MiB + 5);
|
|
expect(seen.some((p) => p.phase === "verify" && p.bytes > 0)).toBe(true);
|
|
expect(px.stats().spawned).toBe(1);
|
|
}, 30_000);
|
|
|
|
it("worker 报的 FsError 原样还原(EEXIST / ENOENT)", async () => {
|
|
const t = await tree({ "a.mkv": "new", "b.mkv": "old" });
|
|
const px = new FsProxy({ mode: "subprocess" });
|
|
const e = await px.copy(t.path("a.mkv"), t.path("b.mkv")).catch((x) => x);
|
|
expect(e).toBeInstanceOf(FsError);
|
|
expect(e.code).toBe("EEXIST");
|
|
expect((await px.moveSafe(t.path("nope"), t.path("c")).catch((x) => x)).code).toBe("ENOENT");
|
|
expect(await px.statSafe(t.path("nope"))).toEqual({ kind: "missing" });
|
|
}, 30_000);
|
|
|
|
it("复制中途挂死(屏蔽 SIGTERM)→ 进度停滞超时 → SIGKILL → TIMEOUT;不留最终名半成品,partial 可被清理", async () => {
|
|
const t = await tree({ "src/a.mkv": 8 * MiB, "dst/": null });
|
|
const px = new FsProxy({ mode: "subprocess", ...fast });
|
|
const seen: number[] = [];
|
|
const t0 = Date.now();
|
|
const e = await px
|
|
.copy(
|
|
t.path("src/a.mkv"),
|
|
t.path("dst/a.mkv"),
|
|
{},
|
|
{
|
|
onProgress: (p) => seen.push(p.bytes),
|
|
_test: { hangAfterBytes: 2 * MiB, ignoreTerm: true },
|
|
},
|
|
)
|
|
.catch((x) => x);
|
|
expect(e).toBeInstanceOf(FsError);
|
|
expect(e.code).toBe("TIMEOUT");
|
|
expect(fsErrorClass(e.code)).toBe("retry");
|
|
expect(Date.now() - t0).toBeGreaterThanOrEqual(800);
|
|
expect(seen.some((b) => b > 0)).toBe(true);
|
|
expect(px.stats()).toMatchObject({ timeouts: 1, killed: 1 });
|
|
expect(existsSync(t.path("dst/a.mkv"))).toBe(false);
|
|
// 被 SIGKILL 的 worker 来不及清 partial:留给下次写前清理
|
|
const left = (await readdir(t.path("dst"))).filter((n) => n.endsWith(".uhd-partial"));
|
|
expect(left.length).toBe(1);
|
|
expect(await sweepStalePartials(t.path("dst"), -1)).toHaveLength(1);
|
|
}, 30_000);
|
|
|
|
it("真实挂死的系统调用:哈希 FIFO(open 阻塞)→ TIMEOUT,SIGTERM 即可回收", async () => {
|
|
const t = await tree({});
|
|
const fifo = t.path("hang.fifo");
|
|
execFileSync("mkfifo", [fifo]);
|
|
const px = new FsProxy({ mode: "subprocess", ...fast });
|
|
const e = await px.sha256(fifo).catch((x) => x);
|
|
expect(e.code).toBe("TIMEOUT");
|
|
expect(px.stats().timeouts).toBe(1);
|
|
}, 30_000);
|
|
|
|
it("快操作挂死:stat → error(TIMEOUT) 而非 missing;checkRoot → offline(timeout)", async () => {
|
|
const t = await tree({ "a.mkv": "x" }, { sentinel: true });
|
|
const px = new FsProxy({ mode: "subprocess", ...fast });
|
|
const st = await px.statSafe(t.path("a.mkv"), {}, { _test: { hangAfterBytes: 0 } });
|
|
expect(st).toMatchObject({ kind: "error", code: "TIMEOUT" });
|
|
const h = await px.checkRoot(t.root, undefined, { _test: { hangAfterBytes: 0, ignoreTerm: true } });
|
|
expect(h).toEqual({ kind: "offline", reason: "timeout", code: "TIMEOUT" });
|
|
expect(await px.checkRoot(t.root)).toMatchObject({ kind: "online" });
|
|
}, 30_000);
|
|
|
|
it("取消:AbortSignal → 终止 worker,ABORTED", async () => {
|
|
const t = await tree({ "src/a.mkv": 4 * MiB, "dst/": null });
|
|
const px = new FsProxy({ mode: "subprocess", ...fast, hangTimeoutMs: 60_000 });
|
|
const ac = new AbortController();
|
|
const p = px.copy(
|
|
t.path("src/a.mkv"),
|
|
t.path("dst/a.mkv"),
|
|
{},
|
|
{
|
|
signal: ac.signal,
|
|
_test: { hangAfterBytes: MiB },
|
|
onProgress: (x) => x.bytes > 0 && ac.abort(),
|
|
},
|
|
);
|
|
const e = await p.catch((x) => x);
|
|
expect(e.code).toBe("ABORTED");
|
|
expect(existsSync(t.path("dst/a.mkv"))).toBe(false);
|
|
}, 30_000);
|
|
});
|
|
|
|
describe("FsProxy 启动方式", () => {
|
|
it("deno CLI 下缺省 run fsworker.ts;显式 workerCommand 记为 custom", () => {
|
|
const auto = defaultWorkerCommand();
|
|
expect(auto?.kind).toBe("script");
|
|
expect(auto?.args.at(-1)).toMatch(/fsworker\.ts$/);
|
|
expect(new FsProxy().stats()).toMatchObject({ mode: "subprocess", workerKind: "script" });
|
|
const px = new FsProxy({ workerCommand: { cmd: "/app/umt-server", args: ["--role", "fsworker"] } });
|
|
expect(px.stats()).toMatchObject({ mode: "subprocess", workerKind: "custom" });
|
|
});
|
|
|
|
it("起不来的 worker 命令(auto)回退 in-process 并记原因", async () => {
|
|
const t = await tree({ "a.mkv": "x" });
|
|
const px = new FsProxy({ workerCommand: { cmd: "/nonexistent/umt-server", args: ["--role", "fsworker"] } });
|
|
expect(await px.statSafe(t.path("a.mkv"))).toMatchObject({ kind: "ok" });
|
|
expect(px.stats()).toMatchObject({ mode: "inprocess", fallbackReason: expect.stringMatching(/^spawn_failed/) });
|
|
});
|
|
|
|
it("验收开关只在 UMT_FS_TEST_HOOKS=1 时生效(单独误设 HANG_AFTER_BYTES 无效)", () => {
|
|
const env = (m: Record<string, string>) => (k: string) => m[k];
|
|
expect(fsTestHookFromEnv(env({ UMT_FS_TEST_HANG_AFTER_BYTES: "1024" }))).toBeUndefined();
|
|
expect(fsTestHookFromEnv(env({ UMT_FS_TEST_HANG_AFTER_BYTES: "1024", UMT_FS_TEST_HOOKS: "0" }))).toBeUndefined();
|
|
expect(fsTestHookFromEnv(env({ UMT_FS_TEST_HANG_AFTER_BYTES: "x", UMT_FS_TEST_HOOKS: "1" }))).toBeUndefined();
|
|
expect(fsTestHookFromEnv(env({ UMT_FS_TEST_HANG_AFTER_BYTES: "1024", UMT_FS_TEST_HOOKS: "1" }))).toEqual({
|
|
hangAfterBytes: 1024,
|
|
ignoreTerm: true,
|
|
});
|
|
});
|
|
|
|
it("UMT_FS_TEST_HANG_AFTER_BYTES(容器验收开关)→ 数据类操作卡死 → SIGKILL → TIMEOUT;快操作不受影响", async () => {
|
|
const t = await tree({ "src/a.mkv": 3 * MiB, "dst/": null });
|
|
const px = new FsProxy({ mode: "subprocess", ...fast });
|
|
Deno.env.set("UMT_FS_TEST_HANG_AFTER_BYTES", String(MiB));
|
|
Deno.env.set("UMT_FS_TEST_HOOKS", "1");
|
|
try {
|
|
expect(await px.statSafe(t.path("src/a.mkv"))).toMatchObject({ kind: "ok" });
|
|
const e = await px.copy(t.path("src/a.mkv"), t.path("dst/a.mkv")).catch((x) => x);
|
|
expect(e.code).toBe("TIMEOUT");
|
|
expect(px.stats()).toMatchObject({ timeouts: 1, killed: 1 });
|
|
} finally {
|
|
Deno.env.delete("UMT_FS_TEST_HANG_AFTER_BYTES");
|
|
Deno.env.delete("UMT_FS_TEST_HOOKS");
|
|
}
|
|
}, 30_000);
|
|
});
|
|
|
|
describe("FsProxy(in-process 回退)", () => {
|
|
it("正常复制有进度;FIFO 挂死 → TIMEOUT(看门狗),不等卡住的调用返回", async () => {
|
|
const t = await tree({ "src/a.mkv": 3 * MiB, "dst/": null });
|
|
const px = new FsProxy({ mode: "inprocess", ...fast });
|
|
const seen: FsProgress[] = [];
|
|
const r = await px.copy(t.path("src/a.mkv"), t.path("dst/a.mkv"), {}, { onProgress: (p) => seen.push(p) });
|
|
expect(r.outcome).toBe("committed");
|
|
expect(seen.at(-1)?.bytes).toBe(3 * MiB);
|
|
|
|
const fifo = t.path("hang.fifo");
|
|
execFileSync("mkfifo", [fifo]);
|
|
const e = await px.sha256(fifo).catch((x) => x);
|
|
expect(e.code).toBe("TIMEOUT");
|
|
// 解开卡住的 open,别让测试进程留着阻塞线程
|
|
await writeFile(fifo, "x");
|
|
}, 30_000);
|
|
});
|
|
|
|
describe("错误分类", () => {
|
|
it("TIMEOUT 进 FsErrorCode 与处置类别;ETIMEDOUT 映射为 TIMEOUT", () => {
|
|
const e = Object.assign(new Error("timed out"), { code: "ETIMEDOUT" });
|
|
expect(toFsError(e).code).toBe("TIMEOUT");
|
|
expect(fsErrorClass("TIMEOUT")).toBe("retry");
|
|
expect(fsErrorClass("IO")).toBe("retry");
|
|
expect(fsErrorClass("ENOSPC")).toBe("attention");
|
|
expect(fsErrorClass("EACCES")).toBe("attention");
|
|
expect(fsErrorClass("EEXIST")).toBe("manual");
|
|
expect(fsErrorClass("VERIFY_FAILED")).toBe("manual");
|
|
});
|
|
});
|