Waafir
Cette page est une traduction automatique en attente de relecture humaine. Elle peut contenir des erreurs.

Annuler un import en cours

Cette recette montre comment annuler un import asynchrone pendant son traitement. Le worker vérifie la présence d'une demande d'annulation à chaque limite de lot ; dès qu'il en détecte une, il s'arrête à la fin du lot en cours et fait passer le statut à cancelled. Les lignes traitées avant l'annulation restent enregistrées — il n'y a aucun lot partiellement écrit à nettoyer ensuite.

Quand annuler

L'endpoint d'annulation est l'outil adapté lorsque vous vous rendez compte en cours de route que l'import est erroné : mauvais fichier, mauvais portefeuille, instantané obsolète, mauvais jour. Déclencheurs typiques :

  • Un tableau de bord de supervision repère que l'import pointe vers le mauvais fichier.
  • Vous avez lancé une reprise d'historique de plusieurs millions de lignes sur le portefeuille de production alors que vous vouliez d'abord l'exécuter à blanc.
  • Un système en amont a signalé le fichier comme corrompu une fois le téléversement terminé.

L'annulation ne remplace pas dryRun: true (voir la recette de validation à blanc). Une fois qu'un import réel est en cours, les lignes réussies avant le point d'annulation sont validées. Vous pouvez compter sur Waafir pour ne pas écrire de lots partiels, mais vous ne pouvez pas revenir en arrière sur des lignes déjà validées ; la bonne pratique consiste à enchaîner avec un import correctif qui ajuste ce qui a été enregistré à tort.

La garantie de limite de lot

Le worker traite les lignes par lots de deux cents. Après chaque lot, il vérifie le statut de l'import ; s'il voit cancelled, il s'arrête là et le statut reste cancelled. La garantie est la suivante :

  • Chaque lot que le worker a commencé avant le signal d'annulation se termine entièrement. Ces lignes sont validées.
  • Chaque lot que le worker n'avait pas encore commencé à l'arrivée du signal d'annulation est ignoré. Ces lignes ne sont pas enregistrées.
  • Il n'existe jamais d'état intermédiaire avec un demi-lot enregistré. Si un lot commence, il se termine.

Le statut final cancelled porte les décomptes de lignes au moment de l'annulation — c'est-à-dire le décompte de ce qui a réellement été validé.

La recette

# 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"],
})

Ce qu'il faut vérifier

Une fois la boucle d'interrogation terminée, status vaut cancelled si le signal d'annulation a atteint le worker avant la fin, ou l'une des valeurs succeeded / partial / failed si le worker a traité tout le fichier avant la vérification de la limite de lot suivante (rare, mais possible pour de petits fichiers).

Le champ rowCountSucceeded correspond au nombre de lignes validées avant l'annulation. Rapprochez ces lignes par identifiant externe (voir la recette de rapprochement) si vous avez besoin d'une liste définitive de ce qui a été enregistré.

Un second DELETE sur le même import renvoie le statut final existant sans émettre à nouveau l'annulation ; l'endpoint est idempotent. Annuler un import déjà dans un état final (ayant déjà atteint succeeded, partial ou failed) est sans effet et renvoie le statut existant.