Waafir
Esta página é uma tradução automática pendente de revisão humana. Pode conter erros.

Cancelar uma importação em andamento

Esta receita mostra como cancelar uma importação assíncrona enquanto ela ainda está sendo processada. O worker verifica se há um pedido de cancelamento a cada limite de lote; ao encontrá-lo, para no fim do lote em andamento e muda o status para cancelled. As linhas concluídas antes do cancelamento permanecem gravadas — não há lotes gravados pela metade para limpar depois.

Quando cancelar

O endpoint de cancelamento é a ferramenta certa quando você percebe, com a importação em andamento, que ela está errada: o arquivo errado, o portfólio errado, um snapshot desatualizado, o dia errado. Gatilhos típicos:

  • Um painel de monitoramento detecta que o arquivo errado foi apontado para a importação.
  • Você iniciou uma carga retroativa de milhões de linhas no portfólio de produção quando pretendia fazer antes uma execução de teste.
  • Um sistema de origem sinalizou o arquivo como corrompido depois que o upload foi concluído.

O cancelamento não substitui dryRun: true (consulte a receita de execução de teste). Depois que uma importação real está em execução, as linhas que têm sucesso antes do ponto de cancelamento são confirmadas. Você pode contar com o Waafir para não gravar lotes parciais, mas não pode desfazer linhas já confirmadas; o padrão correto é fazer em seguida uma importação corretiva que ajuste o que foi gravado de forma errada.

A garantia do limite de lote

O worker processa as linhas em lotes de duzentas. Após cada lote, ele verifica o status da importação; se encontrar cancelled, para ali e o status permanece cancelled. A garantia é:

  • Todo lote que o worker iniciou antes do sinal de cancelamento é concluído por inteiro. Essas linhas são confirmadas.
  • Todo lote que o worker ainda não havia iniciado quando o sinal de cancelamento chegou é ignorado. Essas linhas não são gravadas.
  • Nunca existe um estado intermediário com meio lote gravado. Se um lote começa, ele termina.

O status terminal cancelled traz as contagens de linhas no momento do cancelamento — ou seja, a contagem do que foi efetivamente confirmado.

A receita

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

O que verificar

Depois que o loop de consulta termina, status é cancelled se o sinal de cancelamento chegou ao worker antes de ele terminar, ou succeeded / partial / failed se o worker concluiu o arquivo inteiro antes da verificação no próximo limite de lote (raro, mas possível com arquivos pequenos).

O campo rowCountSucceeded é o número de linhas confirmadas antes do cancelamento. Concilie essas linhas por ID externo (consulte a receita de conciliação) se precisar de uma lista definitiva do que foi gravado.

Um segundo DELETE na mesma importação retorna o status terminal existente sem reemitir o cancelamento; o endpoint é idempotente. Cancelar uma importação já terminal (que já chegou a succeeded, partial ou failed) não tem efeito e retorna o status existente.