Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(web): keep indexing cancellation scoped to its run (#1972)

Bingxi Zhao (Frank)54b2ee8e8387
diff --git a/web/components/knowledge/KbIndexingRun.tsx b/web/components/knowledge/KbIndexingRun.tsx
index 39d6da0fb..b4a4e3db6 100644
--- a/web/components/knowledge/KbIndexingRun.tsx
+++ b/web/components/knowledge/KbIndexingRun.tsx
@@ -27,10 +27,11 @@ export default function KbIndexingRun({ kbName, readOnly = false }: { kbName: st
const { t } = useTranslation();
const [open, setOpen] = useState(false);
const [snapshot, setSnapshot] = useState<{ key: string; run: Run | null }>();
- const [error, setError] = useState(false);
+ const [error, setError] = useState<{ key: string; taskId?: string }>();
const [now, setNow] = useState(Date.now() / 1000);
- const [cancelling, setCancelling] = useState(false);
+ const [cancelling, setCancelling] = useState<string>();
const run = snapshot?.key === kbName ? snapshot.run : undefined;
+ const runKey = JSON.stringify([kbName, run?.task_id]);
useEffect(() => {
if (!open) return;
const controller = new AbortController();
@@ -41,11 +42,17 @@ export default function KbIndexingRun({ kbName, readOnly = false }: { kbName: st
if (!response.ok) throw new Error(String(response.status));
const data = await response.json() as { run: Run | null };
if (!controller.signal.aborted) {
- setSnapshot({ key: kbName, run: data.run });
- setError(false);
+ setSnapshot(previous => ({ key: kbName, run: data.run && {
+ ...data.run,
+ // An older poll cannot revoke an accepted cancellation (#1972).
+ cancel_requested: data.run.cancel_requested || Boolean(
+ previous?.key === kbName && previous.run?.task_id === data.run.task_id && previous.run.cancel_requested
+ ),
+ } }));
+ setError(undefined);
setNow(Date.now() / 1000);
}
- } catch { if (!controller.signal.aborted) setError(true); }
+ } catch { if (!controller.signal.aborted) setError({ key: kbName }); }
if (!controller.signal.aborted) timer = setTimeout(() => void poll(), 3000);
};
void poll();
@@ -53,18 +60,20 @@ export default function KbIndexingRun({ kbName, readOnly = false }: { kbName: st
}, [kbName, open]);
const cancel = async () => {
if (!run) return;
- setCancelling(true);
+ setCancelling(runKey);
try {
const response = await apiFetch(`/api/knowledge-bases/${encodeURIComponent(kbName)}/indexing-run/${encodeURIComponent(run.task_id)}/cancel`, { method: "POST" });
if (!response.ok) throw new Error(String(response.status));
- setSnapshot({ key: kbName, run: { ...run, cancel_requested: true } });
- } catch { setError(true); }
- finally { setCancelling(false); }
+ setSnapshot(previous => previous?.key === kbName && previous.run?.task_id === run.task_id
+ ? { ...previous, run: { ...previous.run, cancel_requested: true } }
+ : previous);
+ } catch { setError({ key: kbName, taskId: run.task_id }); }
+ finally { setCancelling(previous => previous === runKey ? undefined : previous); }
};
return <details open={open} className="shrink-0 border-b border-[var(--border)] px-6 py-2 text-xs">
<summary className="cursor-pointer" onClick={(event) => { event.preventDefault(); setOpen((value) => !value); }}>{t("Indexing recovery details")}</summary>
{open && <div className="max-h-56 space-y-2 overflow-auto py-2">
- {error && <p role="alert">{t("Could not read indexing state. Refresh and retry.")}</p>}
+ {error?.key === kbName && (!error.taskId || error.taskId === run?.task_id) && <p role="alert">{t("Could not read indexing state. Refresh and retry.")}</p>}
{run ? <>
<p>{t("Run state")}: {t(`indexingState.${run.state}`, { defaultValue: run.state })} · {t("Current phase")}: {t(`indexingPhase.${run.phase}`, { defaultValue: run.phase })}</p>
<p>{t("Runtime")}: {Math.max(0, Math.floor((run.finished_at || now) - run.started_at))}s · {t("Since activity")}: {Math.max(0, Math.floor(now - run.last_activity_at))}s · {t("Since measurable progress")}: {Math.max(0, Math.floor(now - run.last_progress_at))}s</p>
@@ -75,7 +84,7 @@ export default function KbIndexingRun({ kbName, readOnly = false }: { kbName: st
<p>{t("Retry reuses validated parser outputs. Interrupted embedding stages restart.")}</p>
<ul>{Object.entries(run.documents).map(([name, doc]) => <li className="break-words" key={name}>{name}: {t(`indexingDocument.${doc.status}`, { defaultValue: doc.status })}{doc.parse_reused ? ` · ${t("Parse cache reused")}` : ""}{doc.reason ? ` · ${doc.reason}` : ""}{doc.detail ? ` · ${doc.detail}` : ""}</li>)}</ul>
{run.error && <p role="alert">{run.error}</p>}
- {!readOnly && run.state === "running" && <button className="underline" disabled={cancelling || run.cancel_requested} onClick={() => void cancel()}>{run.cancel_requested ? t("Cancellation pending at a safe boundary") : t("Cancel indexing")}</button>}
+ {!readOnly && run.state === "running" && <button className="underline" disabled={cancelling === runKey || run.cancel_requested} onClick={() => void cancel()}>{run.cancel_requested ? t("Cancellation pending at a safe boundary") : t("Cancel indexing")}</button>}
</> : <p>{run === null ? t("No durable indexing run recorded yet.") : t("Loading...")}</p>}
</div>}
</details>;
diff --git a/web/tests/kb-indexing-run.spec.tsx b/web/tests/kb-indexing-run.spec.tsx
index fc7e265e8..d7788f31b 100644
--- a/web/tests/kb-indexing-run.spec.tsx
+++ b/web/tests/kb-indexing-run.spec.tsx
@@ -1,6 +1,6 @@
import React from "react";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { beforeEach, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
import KbIndexingRun from "@/components/knowledge/KbIndexingRun";
import { apiFetch } from "@/shared/api/client";
@@ -10,6 +10,7 @@ const run = { task_id: "owned", state: "running", phase: "embedding", started_at
last_progress_at: 2, phase_current: 1, phase_total: 1, cancel_requested: false,
documents: { "book.pdf": { status: "unknown", parse_reused: true }, "bad.pdf": { status: "failed", reason: "invalid_output" } } };
beforeEach(() => vi.clearAllMocks());
+afterEach(() => vi.useRealTimers());
it("reads durable outcomes on demand and distinguishes phase completion from readiness", async () => {
vi.mocked(apiFetch).mockResolvedValue(new Response(JSON.stringify({ run })));
render(<KbIndexingRun kbName="kb" />);
@@ -47,3 +48,35 @@ it("shows parser activity without inventing a percent or claiming completion", a
expect(screen.getByText(/Phase progress is indeterminate/)).toBeInTheDocument();
expect(screen.queryByText(/Verified index version/)).not.toBeInTheDocument();
});
+
+it("a delayed cancellation cannot replace a newer indexing run", async () => {
+ vi.useFakeTimers();
+ let acknowledge!: (value: Response) => void;
+ vi.mocked(apiFetch)
+ .mockResolvedValueOnce(new Response(JSON.stringify({ run })))
+ .mockImplementationOnce(() => new Promise(resolve => { acknowledge = resolve; }))
+ .mockResolvedValueOnce(new Response(JSON.stringify({ run: { ...run, task_id: "new", activity: "New run" } })));
+ render(<KbIndexingRun kbName="kb" />);
+ await act(async () => { fireEvent.click(screen.getByText("Indexing recovery details")); });
+ fireEvent.click(screen.getByRole("button", { name: "Cancel indexing" }));
+ await act(async () => { await vi.advanceTimersByTimeAsync(3000); });
+ expect(screen.getByText("Activity: New run")).toBeInTheDocument();
+ await act(async () => { acknowledge(new Response("{}")); });
+ expect(screen.getByText("Activity: New run")).toBeInTheDocument();
+ expect(screen.getByRole("button", { name: "Cancel indexing" })).toBeEnabled();
+});
+
+it("a poll captured before cancellation cannot clear its accepted acknowledgement", async () => {
+ vi.useFakeTimers();
+ let poll!: (value: Response) => void;
+ vi.mocked(apiFetch)
+ .mockResolvedValueOnce(new Response(JSON.stringify({ run })))
+ .mockImplementationOnce(() => new Promise(resolve => { poll = resolve; }))
+ .mockResolvedValueOnce(new Response("{}"));
+ render(<KbIndexingRun kbName="kb" />);
+ await act(async () => { fireEvent.click(screen.getByText("Indexing recovery details")); });
+ await act(async () => { await vi.advanceTimersByTimeAsync(3000); });
+ await act(async () => { fireEvent.click(screen.getByRole("button", { name: "Cancel indexing" })); });
+ await act(async () => { poll(new Response(JSON.stringify({ run }))); });
+ expect(screen.getByRole("button", { name: "Cancellation pending at a safe boundary" })).toBeDisabled();
+});