Skip to content

fix(pipeline): un verify fallito blocca sync e registry - #47

Merged
Gabrymi93 merged 2 commits into
mainfrom
fix/verify-blocca-sync
Nov 17, 2026
Merged

Gabrymi93 merged 2 commits into
mainfrom
fix/verify-blocca-sync

Conversation

@Gabrymi93

Copy link
Copy Markdown
Member

Sintesi

verify-command oggi è decorativo: se fallisce il job diventa rosso ma auth, sync e registry girano lo stesso. Il gate esiste ma non protegge nulla.

Contesto collegato

Emerso dalla review di dataciviclab/dichiarazioni-italia#61, il primo verify-command che controlla la qualità del dato. Riguarda anche opere-pubbliche (verify-command: "make test"), che ha lo stesso problema da prima.

Il problema

Le condizioni di auth, setup-gcloud, sync e registry sono:

if: ${{ !cancelled() && … }}

!cancelled() è vero anche dopo uno step fallito — ed è scritto apposta nell'header: «se un dataset fallisce… quello che il run ha già prodotto va comunque caricato, altrimenti un timeout sull'ultimo dataset butta via un'ora di lavoro». Giusto per il run, sbagliato per il verify: un audit che trova un drift rende il job rosso e carica comunque i parquet, aprendo anche la PR del registry.

Cosa cambia

steps.verify.outcome != 'failure' sulle cinque condizioni (auth, setup-gcloud, sync flat, sync per-dataset, registry), con id: verify sullo step.

  • verify non configurato → step skipped → outcome ≠ failure → la condizione passa: nessun cambio per i repo che non lo usano.
  • verify fallito → auth/sync/registry saltati → il job resta rosso e non pubblica.
  • run fallito → !cancelled() continua a fare il suo lavoro: si carica quello che c'è.

Checklist

  • YAML valido (yaml.safe_load)
  • Nessun cambio per i chiamanti senza verify-command
  • Il comportamento «run fallito → carica comunque» resta invariato

Verifica

Non eseguibile da qui: la verifica reale è il primo run con verify-command che fallisce. Il test più economico è su dichiarazioni-italia dopo #61, forzando un drift: il job deve restare rosso senza oggetti nuovi su gs://dataciviclab-mart/dichiarazioni-italia/ e senza PR di registry.

Note / rischi

steps.verify esiste solo se lo step è stato valutato: se il job viene cancellato prima, l'espressione è null != 'failure' → vera, ma !cancelled() blocca comunque. Nessun caso in cui la condizione diventi permissiva per errore.

`!cancelled()` è vero anche dopo uno step fallito — è voluto: se un dataset
fallisce, quello che il run ha già prodotto va comunque caricato. Ma la stessa
condizione valeva per il verify, quindi un `verify-command` che controlla la
qualità del dato era decorativo: il job diventava rosso e pubblicava lo stesso
su GCS, aprendo anche la PR del registry.

Ora auth, setup-gcloud, sync (flat e per-dataset) e registry richiedono anche
`steps.verify.outcome != 'failure'`. Con `verify-command` non configurato lo
step è `skipped`, l'outcome non è 'failure' e la condizione passa: nessun
cambio per i repo che non usano il verify.

Riguarda `opere-pubbliche` (`verify-command: "make test"`) e
`dichiarazioni-italia` (#61, audit etichette regione), che oggi hanno un gate
che non protegge nulla.
Review #47: con un `verify-command` configurato il verify aveva
`if: inputs.verify-command != ''` senza `success()`, quindi girava anche su un
run fallito leggendo un `out/` parziale. Quasi sempre falliva, e con
`steps.verify.outcome != 'failure'` bloccava il sync: il comportamento «run
caduto → salva quello che c'è», scritto nell'header, non esisteva più. Per
`opere-pubbliche` è concreto: `make test` include uno smoke che fallisce
proprio quando il run si è fermato prima.

Ora il verify gira solo se il run è andato a buon fine. Due fallimenti, due
semantiche:
  - run caduto      → verify saltato (`skipped`) → auth/sync salvano il
                      salvabile, come prima di #47;
  - dato sbagliato  → verify eseguito su `out/` completo → fallisce → blocca
                      auth, sync e registry.

Aggiornati anche i commenti accanto a verify e a GCS auth, che è la parte che
oggi era implicita.
@Gabrymi93

Copy link
Copy Markdown
Member Author

La decisione è giusta: erano due fallimenti con una semantica sola. Ho preso success().

- name: Verify output
  id: verify
  if: ${{ inputs.verify-command != '' && success() }}
  run: ${{ inputs.verify-command }}

Il ragionamento che mi ha convinto: il gate serve a fermare la pubblicazione quando il run è andato bene e il dato è sbagliato. Su un run rotto la diagnosi è già nel log del run, e opere-pubbliche è il caso concreto — make test include uno smoke che fallisce proprio quando il compose non è in out/, cioè quando il run si è fermato prima.

Semantica risultante:

scenario verify outcome sync/registry
run ok, dato ok eseguito success pubblicano
run ok, dato sbagliato eseguito failure bloccati
run caduto saltato skipped pubblicano il salvabile
verify non configurato saltato skipped pubblicano

L'unica cosa che si perde è la capacità di bloccare un drift trovato in un run parziale — e su un out/ parziale l'audit controlla comunque solo i dataset presenti, quindi il valore era basso.

Ho aggiornato anche i commenti accanto a verify e a GCS auth: era la parte implicita, ed è quella che ha fatto nascere il buco.

Sulla verifica reale

D'accordo, va fatta nella prima settimana. Dopo il merge di #61, il test è: forzare un drift su dichiarazioni-italia e controllare tre cose — job rosso, nessun oggetto nuovo sotto gs://dataciviclab-mart/dichiarazioni-italia/, nessuna PR di registry. È l'unico modo per vedere steps.verify.outcome in azione prima dello schedule di dicembre.

Commit f3d0215.

@Gabrymi93
Gabrymi93 merged commit b53c7ac into main Nov 17, 2026
2 checks passed
@Gabrymi93
Gabrymi93 deleted the fix/verify-blocca-sync branch November 17, 2026 17:44
Gabrymi93 added a commit that referenced this pull request Nov 19, 2026
Review #48: un `exit 1` nello step non ferma i consumatori con `!cancelled()`
— è lo stesso meccanismo dell'incidente, dove il run è fallito alle 17:14:30 e
il sync ha scritto alle 17:15:01. Quindi la guardia aggiunta dava falsa
sicurezza: con `repo-slug` vuoto il job diventava rosso e scriveva lo stesso
alla radice.

Aggiunto `steps.gcs-prefix.outcome != 'failure'` alle condizioni di
`Sync to GCS (flat)`, `Sync to GCS (per-dataset)` e `Registry update PR`, come
si fa già con `steps.verify.outcome != 'failure'`. Commento nello step che lo
dice, così la prossima guardia non ripete l'errore.

L'invariante ora sta in ADR-001 (regola d'oro, punto 5): un output consumato da
uno step `!cancelled()` deve essere prodotto da uno step `!cancelled()`, e il
consumatore deve controllarne l'outcome. È la seconda occorrenza in due PR
(`verify` in #47, `gcs-prefix` qui): scritta, non può diventare la terza.

Corretto anche il conteggio nel body: i path che perdono il prefisso sono 73 su
107 (93 erano le righe di diff), e il path corretto è fermo al 16/11 — quindi
dopo la pulizia serve il rilancio, non è un doppione.
Gabrymi93 added a commit that referenced this pull request Nov 19, 2026
* fix(pipeline): il prefisso GCS si risolve anche su run fallito

Regressione introdotta da #46. Lo step `Resolve GCS prefix` non aveva `if:`,
quindi ereditava `success()`: quando il run falliva veniva **saltato**,
`steps.gcs-prefix.outputs.value` restava vuoto e i due consumatori — che hanno
`!cancelled()` apposta per salvare il salvabile — ricevevano `""`.

Effetto: sync alla RADICE del bucket e registry riscritto senza prefisso.

Successo il 2026-11-19 in open-politica (#121): il run è fallito, il prefisso è
diventato vuoto e la PR di registry #122 ha riscritto 93 righe di path,
togliendo `open-politica/` da tutti gli artifact. Il clean è finito in
`gs://dataciviclab-clean/camera_iter/...` invece di
`gs://dataciviclab-clean/open-politica/camera_iter/...`.

Ora lo step ha `if: ${{ !cancelled() && ... }}`, allineato ai consumatori.
Aggiunto anche un errore esplicito se `sync-prefix: auto` non riesce a
risolvere un `repo-slug`: meglio fallire che scrivere alla radice.

Riguarda tutti i repo chiamanti: il bug si manifestava solo sui run falliti,
quindi su un ramo che si spera raro — e che è esattamente quello in cui
pubblicare nel posto sbagliato fa più danni.

* fix(pipeline): la guardia sul prefisso blocca davvero la scrittura

Review #48: un `exit 1` nello step non ferma i consumatori con `!cancelled()`
— è lo stesso meccanismo dell'incidente, dove il run è fallito alle 17:14:30 e
il sync ha scritto alle 17:15:01. Quindi la guardia aggiunta dava falsa
sicurezza: con `repo-slug` vuoto il job diventava rosso e scriveva lo stesso
alla radice.

Aggiunto `steps.gcs-prefix.outcome != 'failure'` alle condizioni di
`Sync to GCS (flat)`, `Sync to GCS (per-dataset)` e `Registry update PR`, come
si fa già con `steps.verify.outcome != 'failure'`. Commento nello step che lo
dice, così la prossima guardia non ripete l'errore.

L'invariante ora sta in ADR-001 (regola d'oro, punto 5): un output consumato da
uno step `!cancelled()` deve essere prodotto da uno step `!cancelled()`, e il
consumatore deve controllarne l'outcome. È la seconda occorrenza in due PR
(`verify` in #47, `gcs-prefix` qui): scritta, non può diventare la terza.

Corretto anche il conteggio nel body: i path che perdono il prefisso sono 73 su
107 (93 erano le righe di diff), e il path corretto è fermo al 16/11 — quindi
dopo la pulizia serve il rilancio, non è un doppione.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant