Cancelar una importación en curso
Esta receta muestra cómo cancelar una importación asíncrona mientras todavía se está procesando. El worker comprueba si hay una solicitud de cancelación en cada límite de lote; en cuanto detecta una, se detiene al final del lote en curso y cambia el estado a cancelled. Las filas completadas antes de la cancelación permanecen registradas: no quedan lotes escritos parcialmente que limpiar después.
Cuándo cancelar
El endpoint de cancelación es la herramienta adecuada cuando se da cuenta, a mitad del proceso, de que la importación es incorrecta: el archivo equivocado, la cartera equivocada, una instantánea obsoleta, el día equivocado. Desencadenantes habituales:
- Un panel de monitorización detecta que la importación apunta al archivo equivocado.
- Inició una recarga histórica de varios millones de filas contra la cartera de producción cuando quería ejecutarla primero en modo dry-run.
- Un sistema de origen marcó el archivo como dañado después de que la carga se completara.
La cancelación no sustituye a dryRun: true (consulte la receta de dry-run). Una vez que una importación real está en marcha, las filas que se completan correctamente antes del punto de cancelación quedan confirmadas. Puede confiar en que Waafir no escribirá lotes parciales, pero no puede revertir las filas ya confirmadas; el patrón correcto es realizar después una importación correctiva que ajuste lo que se registró de forma incorrecta.
La garantía del límite de lote
El worker procesa las filas en lotes de doscientas. Después de cada lote comprueba el estado de la importación; si ve cancelled, se detiene ahí y el estado permanece en cancelled. La garantía es:
- Todos los lotes que el worker inició antes de la señal de cancelación se completan por completo. Esas filas quedan confirmadas.
- Todos los lotes que el worker aún no había iniciado cuando llegó la señal de cancelación se omiten. Esas filas no se registran.
- Nunca existe un estado intermedio con medio lote registrado. Si un lote empieza, termina.
El estado final cancelled incluye los recuentos de filas en el momento de la cancelación: es el recuento de lo que realmente se confirmó.
La receta
# 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"],
})Qué verificar
Cuando termina el bucle de sondeo, status es cancelled si la señal de cancelación llegó al worker antes de que terminara, o uno de succeeded / partial / failed si el worker terminó el archivo completo antes de la siguiente comprobación de límite de lote (poco frecuente, pero posible con archivos pequeños).
El campo rowCountSucceeded es el número de filas que se confirmaron antes de la cancelación. Concilie esas filas por ID externo (consulte la receta de conciliación) si necesita una lista definitiva de lo que se registró.
Un segundo DELETE sobre la misma importación devuelve el estado final existente sin volver a emitir la cancelación; el endpoint es idempotente. Cancelar una importación que ya está en un estado final (una que ya llegó a succeeded, partial o failed) no tiene ningún efecto y devuelve el estado existente.