mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-21 07:32:54 +00:00
* fix(sftp): keep bulk queues and large-file resume responsive * fix(sftp): preserve resume compatibility and timeout cleanup * test(sftp): verify fixture cleanup in fresh environments * fix: address Codex review on PR #3226 * fix(sftp): remove blocking periodic history persistence --------- Co-authored-by: netcatty-bot <308658023+netcatty-bot@users.noreply.github.com>
133 lines
5.7 KiB
TypeScript
133 lines
5.7 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import {
|
|
createGlobalSftpTransferScheduler,
|
|
} from "./globalTransferScheduler";
|
|
|
|
test("scheduler limits each remote host independently", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
const releases: Array<() => void> = [];
|
|
let active = 0;
|
|
let maxActive = 0;
|
|
let id = 0;
|
|
const run = (ownerId: string, hostId: string) => scheduler.run(ownerId, `${ownerId}-${id += 1}`, [hostId], () => 1, async () => {
|
|
active += 1;
|
|
maxActive = Math.max(maxActive, active);
|
|
await new Promise<void>((resolve) => releases.push(resolve));
|
|
active -= 1;
|
|
});
|
|
|
|
const jobs = [run("a", "host-a"), run("a", "host-a"), run("b", "host-b")];
|
|
while (releases.length < 2) await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(maxActive, 2);
|
|
releases.splice(0).forEach((release) => release());
|
|
while (releases.length < 1) await new Promise((resolve) => setImmediate(resolve));
|
|
releases.splice(0).forEach((release) => release());
|
|
await jobs;
|
|
assert.equal(maxActive, 2);
|
|
});
|
|
|
|
test("scheduler alternates owners when both have queued work", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
const order: string[] = [];
|
|
let releaseFirst: (() => void) | undefined;
|
|
|
|
const first = scheduler.run("a", "a1", ["host"], () => 1, async () => {
|
|
order.push("a1");
|
|
await new Promise<void>((resolve) => { releaseFirst = resolve; });
|
|
});
|
|
const a2 = scheduler.run("a", "a2", ["host"], () => 1, async () => { order.push("a2"); });
|
|
const b1 = scheduler.run("b", "b1", ["host"], () => 1, async () => { order.push("b1"); });
|
|
|
|
while (!releaseFirst) await new Promise((resolve) => setImmediate(resolve));
|
|
releaseFirst();
|
|
await Promise.all([first, a2, b1]);
|
|
assert.deepEqual(order, ["a1", "b1", "a2"]);
|
|
});
|
|
|
|
test("prioritize moves a queued transfer ahead of fairness ordering", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
const order: string[] = [];
|
|
let releaseFirst: (() => void) | undefined;
|
|
const first = scheduler.run("a", "a1", ["host"], () => 1, async () => {
|
|
order.push("a1");
|
|
await new Promise<void>((resolve) => { releaseFirst = resolve; });
|
|
});
|
|
const b1 = scheduler.run("b", "b1", ["host"], () => 1, async () => { order.push("b1"); });
|
|
const a2 = scheduler.run("a", "a2", ["host"], () => 1, async () => { order.push("a2"); });
|
|
scheduler.prioritize("a2");
|
|
while (!releaseFirst) await new Promise((resolve) => setImmediate(resolve));
|
|
releaseFirst();
|
|
await Promise.all([first, b1, a2]);
|
|
assert.deepEqual(order, ["a1", "a2", "b1"]);
|
|
});
|
|
|
|
test("queued work stays paused until resumed and can be cancelled", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
const order: string[] = [];
|
|
let releaseFirst: (() => void) | undefined;
|
|
const first = scheduler.run("a", "a1", ["host"], () => 1, async () => {
|
|
await new Promise<void>((resolve) => { releaseFirst = resolve; });
|
|
});
|
|
const paused = scheduler.run("b", "b1", ["host"], () => 1, async () => { order.push("b1"); });
|
|
const cancelled = scheduler.run("c", "c1", ["host"], () => 1, async () => { order.push("c1"); });
|
|
assert.equal(scheduler.pause("b1"), true);
|
|
assert.equal(scheduler.cancel("c1"), true);
|
|
while (!releaseFirst) await new Promise((resolve) => setImmediate(resolve));
|
|
releaseFirst();
|
|
await first;
|
|
await assert.rejects(cancelled, /Transfer cancelled/);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.deepEqual(order, []);
|
|
assert.equal(scheduler.resume("b1"), true);
|
|
await paused;
|
|
assert.deepEqual(order, ["b1"]);
|
|
});
|
|
|
|
test("enqueuing a large blocked batch does not repeatedly inspect the existing queue", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
let release: (() => void) | undefined;
|
|
let limitReads = 0;
|
|
const readLimit = () => { limitReads += 1; return 1; };
|
|
const blocker = scheduler.run("panel", "active", ["host"], readLimit, () => (
|
|
new Promise<void>((resolve) => { release = resolve; })
|
|
));
|
|
const count = 2_000;
|
|
const completed: number[] = [];
|
|
const jobs = Array.from({ length: count }, (_, index) => scheduler.run(
|
|
"panel", `queued-${index}`, ["host"], readLimit,
|
|
async () => { completed.push(index); },
|
|
));
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const readsWhileBlocked = limitReads;
|
|
release?.();
|
|
await Promise.all([blocker, ...jobs]);
|
|
|
|
assert.deepEqual(completed, Array.from({ length: count }, (_, index) => index));
|
|
assert.ok(readsWhileBlocked <= count * 3,
|
|
`a blocked batch should be inspected linearly, got ${readsWhileBlocked} limit reads for ${count} files`);
|
|
});
|
|
|
|
test("large batches of immediately completed files yield to user input", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
let completed = 0;
|
|
const count = 1_000;
|
|
const inputTurn = new Promise<number>((resolve) => setTimeout(() => resolve(completed), 0));
|
|
const jobs = Array.from({ length: count }, (_, index) => scheduler.run(
|
|
"panel", `tiny-${index}`, ["host"], () => 2, async () => { completed += 1; },
|
|
));
|
|
const completedAtInput = await inputTurn;
|
|
await Promise.all(jobs);
|
|
assert.ok(completedAtInput < count, "input must run before the entire batch drains");
|
|
assert.equal(completed, count);
|
|
});
|
|
|
|
test("a synchronous job failure releases its slot for queued work", async () => {
|
|
const scheduler = createGlobalSftpTransferScheduler();
|
|
const failed = scheduler.run("panel", "failed", ["host"], () => 1, () => { throw new Error("read failed"); });
|
|
const next = scheduler.run("panel", "next", ["host"], () => 1, async () => "completed");
|
|
await assert.rejects(failed, /read failed/);
|
|
assert.equal(await next, "completed");
|
|
});
|