Waafir
Diese Seite ist eine maschinelle Übersetzung, die noch auf eine menschliche Prüfung wartet. Sie kann Fehler enthalten.

Einen laufenden Import abbrechen

Dieses Rezept zeigt, wie Sie einen asynchronen Import abbrechen, während er noch verarbeitet wird. Der Worker prüft an jeder Batch-Grenze, ob ein Abbruch angefordert wurde; sobald er eine Anforderung sieht, hält er am Ende des laufenden Batches an und setzt den Status auf cancelled. Zeilen, die vor dem Abbruch abgeschlossen wurden, bleiben erhalten – es gibt keine teilweise geschriebenen Batches, die anschließend bereinigt werden müssten.

Wann Sie abbrechen sollten

Der Abbruch-Endpunkt ist das richtige Werkzeug, wenn Sie während der Verarbeitung feststellen, dass der Import falsch ist: die falsche Datei, das falsche Portfolio, ein veralteter Stand, der falsche Tag. Typische Auslöser:

  • Ein Überwachungs-Dashboard bemerkt, dass der Import auf die falsche Datei verweist.
  • Sie haben eine Nachlieferung mit mehreren Millionen Zeilen gegen das Produktivportfolio gestartet, obwohl Sie zuerst einen Probelauf machen wollten.
  • Ein vorgelagertes System hat die Datei nach Abschluss des Uploads als beschädigt markiert.

Ein Abbruch ist kein Ersatz für dryRun: true (siehe das Rezept zum Probelauf). Sobald ein echter Import läuft, werden Zeilen, die vor dem Abbruchzeitpunkt erfolgreich sind, übernommen. Sie können sich darauf verlassen, dass Waafir keine Teil-Batches schreibt, aber Sie können bereits übernommene Zeilen nicht zurückspulen; das richtige Vorgehen ist ein anschließender Korrekturimport, der berichtigt, was falsch angekommen ist.

Die Garantie an der Batch-Grenze

Der Worker verarbeitet Zeilen in Batches zu je zweihundert. Nach jedem Batch prüft er den Importstatus; sieht er cancelled, hält er dort an, und der Status bleibt cancelled. Die Garantie lautet:

  • Jeder Batch, den der Worker vor dem Abbruchsignal begonnen hat, wird vollständig abgeschlossen. Diese Zeilen werden übernommen.
  • Jeder Batch, den der Worker beim Eintreffen des Abbruchsignals noch nicht begonnen hatte, wird übersprungen. Diese Zeilen kommen nicht an.
  • Es gibt nie einen Zwischenzustand, in dem ein halber Batch angekommen ist. Wenn ein Batch beginnt, wird er auch beendet.

Der Endstatus cancelled enthält die Zeilenzählungen zum Zeitpunkt des Abbruchs – also die Anzahl dessen, was tatsächlich übernommen wurde.

Das Rezept

# curl — cancel an in-flight import
set -euo pipefail

PAT="${WAAFIR_PAT}"
BASE_URL="${WAAFIR_BASE_URL:-https://app.waafir.io}"
IMPORT_ID="${1:?supply the import id}"

# Step 1 — DELETE the import. The endpoint returns immediately with the
# (eventual) cancellation in motion. A second DELETE is idempotent —
# already-cancelled imports return the same final status.
curl -fsS -X DELETE "${BASE_URL}/api/v1/monitoring/loan/imports/${IMPORT_ID}" \
  -H "Authorization: Bearer ${PAT}" \
  | jq '{importId, status}'

# Step 2 — wait for the worker to reach the next batch boundary and
# flip to a terminal status.
TERMINAL_PATTERN='succeeded|partial|failed|cancelled'
while :; do
  STATUS=$(curl -fsS "${BASE_URL}/api/v1/monitoring/loan/imports/${IMPORT_ID}" \
    -H "Authorization: Bearer ${PAT}" | jq -r .status)
  echo "import ${IMPORT_ID}: ${STATUS}"
  if echo "$STATUS" | grep -Eq "^(${TERMINAL_PATTERN})$"; then break; fi
  sleep 2
done

# Step 3 — read the final row counts to know how many rows actually committed.
curl -fsS "${BASE_URL}/api/v1/monitoring/loan/imports/${IMPORT_ID}" \
  -H "Authorization: Bearer ${PAT}" \
  | jq '{status, rowCountProcessed, rowCountSucceeded, rowCountFailed}'
// TypeScript — cancel an in-flight import
const PAT = process.env.WAAFIR_PAT!;
const BASE_URL = process.env.WAAFIR_BASE_URL ?? "https://app.waafir.io";
const importId = process.argv[2];
if (!importId) throw new Error("usage: ts-node cancel.ts <importId>");

const auth = { Authorization: `Bearer ${PAT}` };

// Step 1 — DELETE the import; the response confirms the signal was accepted.
const cancelRes = await fetch(`${BASE_URL}/api/v1/monitoring/loan/imports/${importId}`, {
    method: "DELETE",
    headers: auth,
});
if (!cancelRes.ok) throw new Error(`cancel failed: ${cancelRes.status} ${await cancelRes.text()}`);
console.log("cancel accepted:", await cancelRes.json());

// Step 2 — poll for terminal status.
const TERMINAL = new Set(["succeeded", "partial", "failed", "cancelled"]);
type Status = {
    status: string;
    rowCountProcessed: number;
    rowCountSucceeded: number;
    rowCountFailed: number;
};
let final: Status;
while (true) {
    final = (await (await fetch(
        `${BASE_URL}/api/v1/monitoring/loan/imports/${importId}`,
        { headers: auth },
    )).json()) as Status;
    console.log(`import ${importId}: ${final.status}`);
    if (TERMINAL.has(final.status)) break;
    await new Promise((r) => setTimeout(r, 2_000));
}

// Step 3 — what actually landed.
console.log({
    status: final.status,
    rowCountProcessed: final.rowCountProcessed,
    rowCountSucceeded: final.rowCountSucceeded,
    rowCountFailed: final.rowCountFailed,
});
# python — cancel an in-flight import
import os
import sys
import time
import requests

PAT = os.environ["WAAFIR_PAT"]
BASE_URL = os.environ.get("WAAFIR_BASE_URL", "https://app.waafir.io")
import_id = sys.argv[1] if len(sys.argv) > 1 else None
if not import_id:
    raise SystemExit("usage: python cancel.py <importId>")

auth = {"Authorization": f"Bearer {PAT}"}

# Step 1 — DELETE the import.
cancel = requests.delete(
    f"{BASE_URL}/api/v1/monitoring/loan/imports/{import_id}",
    headers=auth,
    timeout=30,
)
cancel.raise_for_status()
print("cancel accepted:", cancel.json())

# Step 2 — poll for terminal status.
terminal = {"succeeded", "partial", "failed", "cancelled"}
while True:
    final = requests.get(
        f"{BASE_URL}/api/v1/monitoring/loan/imports/{import_id}",
        headers=auth,
        timeout=30,
    ).json()
    print(f"import {import_id}: {final['status']}")
    if final["status"] in terminal:
        break
    time.sleep(2)

# Step 3 — what actually landed.
print({
    "status": final["status"],
    "rowCountProcessed": final["rowCountProcessed"],
    "rowCountSucceeded": final["rowCountSucceeded"],
    "rowCountFailed": final["rowCountFailed"],
})

Was Sie überprüfen sollten

Nach dem Ende der Abfrageschleife ist status gleich cancelled, wenn das Abbruchsignal den Worker erreicht hat, bevor er fertig war, oder einer der Werte succeeded / partial / failed, wenn der Worker die gesamte Datei vor der nächsten Prüfung an einer Batch-Grenze abgeschlossen hat (selten, bei kleinen Dateien aber möglich).

Das Feld rowCountSucceeded ist die Anzahl der Zeilen, die vor dem Abbruch übernommen wurden. Gleichen Sie diese Zeilen anhand der externen ID ab (siehe das Rezept zum Abgleich), wenn Sie eine verbindliche Liste dessen benötigen, was angekommen ist.

Ein zweites DELETE auf denselben Import gibt den bestehenden Endstatus zurück, ohne den Abbruch erneut auszulösen; der Endpunkt ist idempotent. Das Abbrechen eines Imports, der bereits einen Endzustand erreicht hat (succeeded, partial oder failed), hat keine Wirkung und gibt den bestehenden Status zurück.