Fix resume retry fallback for truncated direct links
This commit is contained in:
Sucukdeluxe
parent
7c2c8def51
commit
2bd7a187f8
@ -64,6 +64,7 @@ type ActiveTask = {
|
||||
resumable: boolean;
|
||||
nonResumableCounted: boolean;
|
||||
freshRetryUsed?: boolean;
|
||||
resumeHardResetUsed?: boolean;
|
||||
stallRetries?: number;
|
||||
genericErrorRetries?: number;
|
||||
unrestrictRetries?: number;
|
||||
@ -394,6 +395,11 @@ function isFetchFailure(errorText: string): boolean {
|
||||
return text.includes("fetch failed") || text.includes("socket hang up") || text.includes("econnreset") || text.includes("network error");
|
||||
}
|
||||
|
||||
function isResumeHardResetReason(errorText: string): boolean {
|
||||
const text = String(errorText || "");
|
||||
return text.startsWith("resume_download_underflow:");
|
||||
}
|
||||
|
||||
function isPermanentLinkError(errorText: string): boolean {
|
||||
const text = String(errorText || "").toLowerCase();
|
||||
return text.includes("permanent ungültig")
|
||||
@ -1170,6 +1176,7 @@ export class DownloadManager extends EventEmitter {
|
||||
|
||||
private retryStateByItem = new Map<string, {
|
||||
freshRetryUsed: boolean;
|
||||
resumeHardResetUsed: boolean;
|
||||
stallRetries: number;
|
||||
genericErrorRetries: number;
|
||||
unrestrictRetries: number;
|
||||
@ -5539,6 +5546,7 @@ export class DownloadManager extends EventEmitter {
|
||||
retryState.unrestrictRetries = 0;
|
||||
retryState.genericErrorRetries = 0;
|
||||
retryState.freshRetryUsed = false;
|
||||
retryState.resumeHardResetUsed = false;
|
||||
logger.info(`Soft-Reset: Retry-Counter zurückgesetzt für ${item.fileName || itemId} (${Math.floor(staleMs / 60000)} min stale)`);
|
||||
}
|
||||
}
|
||||
@ -5897,6 +5905,7 @@ export class DownloadManager extends EventEmitter {
|
||||
active.abortReason = "none";
|
||||
this.retryStateByItem.set(item.id, {
|
||||
freshRetryUsed: Boolean(active.freshRetryUsed),
|
||||
resumeHardResetUsed: Boolean(active.resumeHardResetUsed),
|
||||
stallRetries: Number(active.stallRetries || 0),
|
||||
genericErrorRetries: Number(active.genericErrorRetries || 0),
|
||||
unrestrictRetries: Number(active.unrestrictRetries || 0)
|
||||
@ -5907,7 +5916,8 @@ export class DownloadManager extends EventEmitter {
|
||||
stallRetries: Number(active.stallRetries || 0),
|
||||
unrestrictRetries: Number(active.unrestrictRetries || 0),
|
||||
genericRetries: Number(active.genericErrorRetries || 0),
|
||||
freshRetryUsed: Boolean(active.freshRetryUsed)
|
||||
freshRetryUsed: Boolean(active.freshRetryUsed),
|
||||
resumeHardResetUsed: Boolean(active.resumeHardResetUsed)
|
||||
});
|
||||
// Caller returns immediately after this; startItem().finally releases the active slot,
|
||||
// so the retry backoff never blocks a worker.
|
||||
@ -5987,12 +5997,14 @@ export class DownloadManager extends EventEmitter {
|
||||
|
||||
const retryState = this.retryStateByItem.get(item.id) || {
|
||||
freshRetryUsed: false,
|
||||
resumeHardResetUsed: false,
|
||||
stallRetries: 0,
|
||||
genericErrorRetries: 0,
|
||||
unrestrictRetries: 0
|
||||
};
|
||||
this.retryStateByItem.set(item.id, retryState);
|
||||
active.freshRetryUsed = retryState.freshRetryUsed;
|
||||
active.resumeHardResetUsed = retryState.resumeHardResetUsed;
|
||||
active.stallRetries = retryState.stallRetries;
|
||||
active.genericErrorRetries = retryState.genericErrorRetries;
|
||||
active.unrestrictRetries = retryState.unrestrictRetries;
|
||||
@ -6471,11 +6483,36 @@ export class DownloadManager extends EventEmitter {
|
||||
error: errorText,
|
||||
abortReason: reason || "none"
|
||||
});
|
||||
const directLinkRetryMatch = errorText.match(/^direct_link_retry_exhausted:(.+)$/);
|
||||
const directLinkRetryMatch = errorText.match(/^(?:Error:\s*)?direct_link_retry_exhausted:(.+)$/);
|
||||
if (directLinkRetryMatch) {
|
||||
const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText).replace(/^Error:\s*/i, "");
|
||||
if (isResumeHardResetReason(exhaustedReason) && !active.resumeHardResetUsed) {
|
||||
active.resumeHardResetUsed = true;
|
||||
item.retries += 1;
|
||||
logger.warn(`Resume-Neustart: item=${item.fileName || item.id}, error=${exhaustedReason}, provider=${item.provider || "?"}`);
|
||||
if (claimedTargetPath) {
|
||||
try {
|
||||
fs.rmSync(claimedTargetPath, { force: true });
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
this.releaseTargetPath(item.id);
|
||||
this.dropItemContribution(item.id);
|
||||
item.lastError = exhaustedReason;
|
||||
item.downloadedBytes = 0;
|
||||
item.totalBytes = null;
|
||||
item.progressPercent = 0;
|
||||
this.queueRetry(item, active, 300, "Resume-Fehler erkannt, kompletter Neuversuch");
|
||||
this.persistSoon();
|
||||
this.emitState();
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (directLinkRetryMatch && active.genericErrorRetries < maxGenericErrorRetries) {
|
||||
active.genericErrorRetries += 1;
|
||||
item.retries += 1;
|
||||
const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText);
|
||||
const exhaustedReason = compactErrorText(directLinkRetryMatch[1] || errorText).replace(/^Error:\s*/i, "");
|
||||
const refreshDelayMs = retryDelayWithJitter(active.genericErrorRetries, 200);
|
||||
logger.warn(
|
||||
`Direktlink erschöpft: item=${item.fileName || item.id}, ` +
|
||||
@ -7486,13 +7523,14 @@ export class DownloadManager extends EventEmitter {
|
||||
throw error;
|
||||
}
|
||||
lastError = compactErrorText(error);
|
||||
const normalizedLastError = lastError.replace(/^Error:\s*/i, "");
|
||||
logAttemptEvent("WARN", "HTTP-Download-Versuch fehlgeschlagen", {
|
||||
attempt,
|
||||
error: lastError,
|
||||
targetPath: effectiveTargetPath
|
||||
});
|
||||
if (lastError.startsWith("range_ignored_on_resume:")) {
|
||||
throw new Error(`direct_link_retry_exhausted:${lastError}`);
|
||||
if (normalizedLastError.startsWith("range_ignored_on_resume:")) {
|
||||
throw new Error(`direct_link_retry_exhausted:${normalizedLastError}`);
|
||||
}
|
||||
if (attempt < maxAttempts) {
|
||||
item.retries += 1;
|
||||
@ -7502,9 +7540,12 @@ export class DownloadManager extends EventEmitter {
|
||||
continue;
|
||||
}
|
||||
if (maxAttemptsBySetting > maxAttempts) {
|
||||
throw new Error(`direct_link_retry_exhausted:${lastError || "Download fehlgeschlagen"}`);
|
||||
const exhaustedError = existingBytes > 0 && normalizedLastError.startsWith("download_underflow:")
|
||||
? `resume_download_underflow:${normalizedLastError.slice("download_underflow:".length)}`
|
||||
: (normalizedLastError || lastError || "Download fehlgeschlagen");
|
||||
throw new Error(`direct_link_retry_exhausted:${exhaustedError}`);
|
||||
}
|
||||
throw new Error(lastError || "Download fehlgeschlagen");
|
||||
throw new Error(normalizedLastError || lastError || "Download fehlgeschlagen");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -473,6 +473,151 @@ describe("download manager", () => {
|
||||
}
|
||||
});
|
||||
|
||||
it("restarts from zero after repeated resume underflow on fresh direct links", async () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
|
||||
tempDirs.push(root);
|
||||
const binary = Buffer.alloc(256 * 1024, 23);
|
||||
const pkgDir = path.join(root, "downloads", "resume-underflow");
|
||||
fs.mkdirSync(pkgDir, { recursive: true });
|
||||
const existingTargetPath = path.join(pkgDir, "resume-underflow.mkv");
|
||||
const partialSize = 96 * 1024;
|
||||
fs.writeFileSync(existingTargetPath, binary.subarray(0, partialSize));
|
||||
|
||||
let unrestrictCalls = 0;
|
||||
const starts: number[] = [];
|
||||
|
||||
const server = http.createServer((req, res) => {
|
||||
const range = String(req.headers.range || "");
|
||||
const match = range.match(/bytes=(\d+)-/i);
|
||||
const start = match ? Number(match[1]) : 0;
|
||||
starts.push(start);
|
||||
|
||||
if (start > 0) {
|
||||
const chunk = binary.subarray(start, Math.min(start + 8192, binary.length));
|
||||
res.statusCode = 206;
|
||||
res.setHeader("Accept-Ranges", "bytes");
|
||||
res.setHeader("Content-Range", `bytes ${start}-${start + chunk.length - 1}/${binary.length}`);
|
||||
res.setHeader("Content-Length", String(chunk.length));
|
||||
res.end(chunk);
|
||||
return;
|
||||
}
|
||||
|
||||
res.statusCode = 200;
|
||||
res.setHeader("Accept-Ranges", "bytes");
|
||||
res.setHeader("Content-Length", String(binary.length));
|
||||
res.end(binary);
|
||||
});
|
||||
|
||||
server.listen(0, "127.0.0.1");
|
||||
await once(server, "listening");
|
||||
|
||||
const address = server.address();
|
||||
if (!address || typeof address === "string") {
|
||||
throw new Error("server address unavailable");
|
||||
}
|
||||
const directUrl = `http://127.0.0.1:${address.port}/resume-underflow`;
|
||||
|
||||
globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
|
||||
const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
|
||||
if (url.includes("/unrestrict/link")) {
|
||||
unrestrictCalls += 1;
|
||||
return new Response(
|
||||
JSON.stringify({
|
||||
download: directUrl,
|
||||
filename: "resume-underflow.mkv",
|
||||
filesize: binary.length
|
||||
}),
|
||||
{
|
||||
status: 200,
|
||||
headers: { "Content-Type": "application/json" }
|
||||
}
|
||||
);
|
||||
}
|
||||
return originalFetch(input, init);
|
||||
};
|
||||
|
||||
try {
|
||||
const session = emptySession();
|
||||
const packageId = "resume-underflow-pkg";
|
||||
const itemId = "resume-underflow-item";
|
||||
const createdAt = Date.now() - 10_000;
|
||||
|
||||
session.packageOrder = [packageId];
|
||||
session.packages[packageId] = {
|
||||
id: packageId,
|
||||
name: "resume-underflow",
|
||||
outputDir: pkgDir,
|
||||
extractDir: path.join(root, "extract", "resume-underflow"),
|
||||
status: "queued",
|
||||
itemIds: [itemId],
|
||||
cancelled: false,
|
||||
enabled: true,
|
||||
createdAt,
|
||||
updatedAt: createdAt
|
||||
};
|
||||
session.items[itemId] = {
|
||||
id: itemId,
|
||||
packageId,
|
||||
url: "https://dummy/resume-underflow",
|
||||
provider: null,
|
||||
status: "queued",
|
||||
retries: 0,
|
||||
speedBps: 0,
|
||||
downloadedBytes: partialSize,
|
||||
totalBytes: binary.length,
|
||||
progressPercent: Math.floor((partialSize / binary.length) * 100),
|
||||
fileName: "resume-underflow.mkv",
|
||||
targetPath: existingTargetPath,
|
||||
resumable: true,
|
||||
attempts: 0,
|
||||
lastError: "",
|
||||
fullStatus: "Wartet",
|
||||
createdAt,
|
||||
updatedAt: createdAt
|
||||
};
|
||||
|
||||
const manager = new DownloadManager(
|
||||
{
|
||||
...defaultSettings(),
|
||||
token: "rd-token",
|
||||
outputDir: path.join(root, "downloads"),
|
||||
extractDir: path.join(root, "extract"),
|
||||
retryLimit: 4,
|
||||
autoExtract: false,
|
||||
autoReconnect: false
|
||||
},
|
||||
session,
|
||||
createStoragePaths(path.join(root, "state"))
|
||||
);
|
||||
|
||||
await manager.start();
|
||||
await waitFor(() => !manager.getSnapshot().session.running, 25000);
|
||||
|
||||
const item = manager.getSnapshot().session.items[itemId];
|
||||
if (item?.status !== "completed") {
|
||||
throw new Error(JSON.stringify({
|
||||
status: item?.status,
|
||||
downloadedBytes: item?.downloadedBytes,
|
||||
totalBytes: item?.totalBytes,
|
||||
retries: item?.retries,
|
||||
lastError: item?.lastError,
|
||||
fullStatus: item?.fullStatus,
|
||||
starts,
|
||||
unrestrictCalls
|
||||
}));
|
||||
}
|
||||
expect(item?.status).toBe("completed");
|
||||
expect(item?.downloadedBytes).toBe(binary.length);
|
||||
expect(unrestrictCalls).toBeGreaterThanOrEqual(2);
|
||||
expect(starts).toContain(partialSize);
|
||||
expect(starts).toContain(0);
|
||||
expect(fs.readFileSync(existingTargetPath).equals(binary)).toBe(true);
|
||||
} finally {
|
||||
server.close();
|
||||
await once(server, "close");
|
||||
}
|
||||
});
|
||||
|
||||
it("assigns unique target paths for same filenames in parallel", async () => {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), "rd-dm-"));
|
||||
tempDirs.push(root);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user