mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 04:50:52 +00:00
Pause then resume was flaky: soft resume cleared lifecycle epochs so stale paused events re-applied, soft failures always rehomed to dedicated-resume (panel queue vanished, "reconnecting" then stuck paused), and concurrent range soft-drain only waited 1.5s before "still finishing". Soft resume now stamps bridge lifecycle epochs, only hard-reconnects when the live stream is gone, dedicated resume reuses terminal/parked transports (including ephemeral hosts), and deferred sparse settle runs in the background with a longer resume wait for in-flight ranges.
248 lines
9.3 KiB
TypeScript
248 lines
9.3 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import type { TransferTask } from "../../../domain/models";
|
|
import {
|
|
softPauseTransfer,
|
|
softResumeTransfer,
|
|
type TransferControlHost,
|
|
} from "./globalSftpTransferControl";
|
|
import {
|
|
isTransferPauseLatched,
|
|
resetTransferPauseLatchesForTests,
|
|
} from "./transferPauseLatch";
|
|
import {
|
|
registerTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
unregisterTransferWalk,
|
|
} from "./transferWalkRegistry";
|
|
|
|
function makeTask(id: string, status: TransferTask["status"] = "transferring"): TransferTask {
|
|
return {
|
|
id,
|
|
fileName: `${id}.bin`,
|
|
sourcePath: `/src/${id}`,
|
|
targetPath: `/dst/${id}`,
|
|
sourceConnectionId: "local",
|
|
targetConnectionId: "remote",
|
|
direction: "upload",
|
|
status,
|
|
totalBytes: 100,
|
|
transferredBytes: 10,
|
|
speed: 1,
|
|
startTime: 1,
|
|
isDirectory: false,
|
|
resumable: true,
|
|
};
|
|
}
|
|
|
|
function createHost(initial: TransferTask[], bridge?: TransferControlHost["getBridge"]): {
|
|
host: TransferControlHost;
|
|
getTasks: () => TransferTask[];
|
|
} {
|
|
let tasks = initial.map((t) => ({ ...t }));
|
|
return {
|
|
getTasks: () => tasks,
|
|
host: {
|
|
getTasks: () => tasks,
|
|
setTasks: (next) => { tasks = next; },
|
|
getBridge: bridge ?? (() => undefined),
|
|
},
|
|
};
|
|
}
|
|
|
|
test("softPauseTransfer latches and paints paused for a live directory walk without a panel", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("dir");
|
|
const { host, getTasks } = createHost([
|
|
{ ...makeTask("dir"), isDirectory: true, progressMode: "files", totalBytes: 5, transferredBytes: 1 },
|
|
{ ...makeTask("c1"), parentTaskId: "dir" },
|
|
]);
|
|
|
|
const outcome = await softPauseTransfer(host, "dir");
|
|
assert.equal(outcome, "paused");
|
|
assert.equal(getTasks().find((t) => t.id === "dir")?.status, "paused");
|
|
assert.equal(isTransferPauseLatched("dir"), true);
|
|
|
|
unregisterTransferWalk("dir");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("softResumeTransfer with live walk paints transferring without requiring bridge success", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("dir");
|
|
const { host, getTasks } = createHost([
|
|
{ ...makeTask("dir", "paused"), isDirectory: true, progressMode: "files", totalBytes: 5, transferredBytes: 1, speed: 0 },
|
|
]);
|
|
|
|
const handled = await softResumeTransfer(host, "dir");
|
|
assert.equal(handled.handled, true);
|
|
assert.equal(getTasks().find((t) => t.id === "dir")?.status, "transferring");
|
|
assert.equal(isTransferPauseLatched("dir"), false);
|
|
|
|
unregisterTransferWalk("dir");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("single-file softResume with live walk + bridge resume fail returns false (no false transferring)", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("file-1");
|
|
const { host, getTasks } = createHost(
|
|
[{ ...makeTask("file-1", "paused"), transferredBytes: 10, speed: 0 }],
|
|
() => ({
|
|
resumeTransfer: async () => ({ success: false, reason: "not active" }),
|
|
pauseTransfer: async () => ({ success: true, checkpointBytes: 10, lifecycleEpoch: 1 }),
|
|
}),
|
|
);
|
|
|
|
const handled = await softResumeTransfer(host, "file-1");
|
|
assert.equal(handled.handled, false, "must not soft-succeed when every bridge resume fails");
|
|
assert.match(handled.reason || "", /not active/i);
|
|
// Must not paint transferring — hard reconnect path must remain available.
|
|
assert.notEqual(getTasks().find((t) => t.id === "file-1")?.status, "transferring");
|
|
|
|
unregisterTransferWalk("file-1");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("directory softResume with live walk and no bridge success still rejoins", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("dir-2");
|
|
const { host, getTasks } = createHost(
|
|
[{ ...makeTask("dir-2", "paused"), isDirectory: true, progressMode: "files", totalBytes: 3, transferredBytes: 1, speed: 0 }],
|
|
() => ({
|
|
resumeTransfer: async () => ({ success: false, reason: "not active" }),
|
|
}),
|
|
);
|
|
|
|
const handled = await softResumeTransfer(host, "dir-2");
|
|
assert.equal(handled.handled, true);
|
|
assert.equal(getTasks().find((t) => t.id === "dir-2")?.status, "transferring");
|
|
// lifecycleEpoch cleared so child stream progress is accepted
|
|
assert.equal(getTasks().find((t) => t.id === "dir-2")?.lifecycleEpoch, undefined);
|
|
|
|
unregisterTransferWalk("dir-2");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("single-file softPause demotes dead streams instead of painting paused", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
const { host, getTasks } = createHost(
|
|
[makeTask("dead-file", "transferring")],
|
|
() => ({
|
|
pauseTransfer: async () => ({ success: false, reason: "Transfer is no longer active" }),
|
|
}),
|
|
);
|
|
|
|
const outcome = await softPauseTransfer(host, "dead-file");
|
|
assert.equal(outcome, "interrupted");
|
|
const row = getTasks().find((t) => t.id === "dead-file");
|
|
assert.equal(row?.status, "interrupted");
|
|
assert.equal(row?.reconnectRequired, true);
|
|
assert.match(row?.error || "", /no longer active/i);
|
|
assert.equal(isTransferPauseLatched("dead-file"), false);
|
|
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("soft resume without bridge lifecycleEpoch keeps a monotonic epoch (no stale re-pause)", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
const { host, getTasks } = createHost(
|
|
[{ ...makeTask("no-epoch", "paused"), lifecycleEpoch: 3, speed: 0 }],
|
|
() => ({
|
|
// Older bridges returned only { success: true } — must not clear epoch.
|
|
resumeTransfer: async () => ({ success: true }),
|
|
}),
|
|
);
|
|
|
|
const result = await softResumeTransfer(host, "no-epoch");
|
|
assert.equal(result.handled, true);
|
|
const row = getTasks().find((t) => t.id === "no-epoch");
|
|
assert.equal(row?.status, "transferring");
|
|
assert.equal(row?.lifecycleEpoch, 4, "must advance past pause epoch when bridge omits epoch");
|
|
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("soft pause/resume stamps bridge lifecycleEpoch so later progress is not stale-dropped", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
let bridgeEpoch = 0;
|
|
const { host, getTasks } = createHost(
|
|
[makeTask("stream", "transferring")],
|
|
() => ({
|
|
pauseTransfer: async () => {
|
|
bridgeEpoch += 1;
|
|
return { success: true, checkpointBytes: 10, lifecycleEpoch: bridgeEpoch };
|
|
},
|
|
resumeTransfer: async () => {
|
|
bridgeEpoch += 1;
|
|
return { success: true, lifecycleEpoch: bridgeEpoch };
|
|
},
|
|
}),
|
|
);
|
|
|
|
// Double soft-pause (second hits already-paused — still returns bridge epoch).
|
|
await softPauseTransfer(host, "stream");
|
|
await softPauseTransfer(host, "stream");
|
|
const pausedEpoch = getTasks().find((t) => t.id === "stream")?.lifecycleEpoch;
|
|
assert.ok(typeof pausedEpoch === "number" && pausedEpoch > 0);
|
|
|
|
const handled = await softResumeTransfer(host, "stream");
|
|
assert.equal(handled.handled, true);
|
|
const resumed = getTasks().find((t) => t.id === "stream");
|
|
assert.equal(resumed?.status, "transferring");
|
|
// Bridge-aligned: must equal last resume bridge epoch, not control-plane bumps.
|
|
assert.equal(resumed?.lifecycleEpoch, bridgeEpoch);
|
|
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
test("directory softResume stamps bridge epoch only on successIds; queued siblings clear epoch", async () => {
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("folder-mix");
|
|
const { host, getTasks } = createHost(
|
|
[
|
|
{ ...makeTask("folder-mix", "paused"), isDirectory: true, progressMode: "files", totalBytes: 3, transferredBytes: 1, speed: 0, lifecycleEpoch: 9 },
|
|
{ ...makeTask("live-child", "paused"), parentTaskId: "folder-mix", transferredBytes: 50, speed: 0, lifecycleEpoch: 9 },
|
|
{ ...makeTask("queued-child", "queued"), parentTaskId: "folder-mix", transferredBytes: 0, speed: 0, lifecycleEpoch: 9 },
|
|
],
|
|
() => ({
|
|
resumeTransfer: async (id: string) => {
|
|
if (id === "live-child") return { success: true, lifecycleEpoch: 4 };
|
|
return { success: false, reason: "not active" };
|
|
},
|
|
}),
|
|
);
|
|
|
|
const handled = await softResumeTransfer(host, "folder-mix");
|
|
assert.equal(handled.handled, true);
|
|
const parent = getTasks().find((t) => t.id === "folder-mix");
|
|
const live = getTasks().find((t) => t.id === "live-child");
|
|
const queued = getTasks().find((t) => t.id === "queued-child");
|
|
assert.equal(parent?.status, "transferring");
|
|
assert.equal(parent?.lifecycleEpoch, 4, "parent gets max of successful child bridge epochs");
|
|
assert.equal(live?.status, "transferring");
|
|
assert.equal(live?.lifecycleEpoch, 4, "resumed child keeps its bridge epoch");
|
|
assert.equal(queued?.status, "queued");
|
|
assert.equal(queued?.lifecycleEpoch, undefined, "non-resumed sibling must not inherit parent resume epoch");
|
|
|
|
unregisterTransferWalk("folder-mix");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|