Riscrivere un JSON con open(path,'w') può lasciare il file vuoto, usa os.replace

Un lettore apre l’indice JSON e trova il nulla: JSONDecodeError: Expecting value: line 1 column 1 (char 0)¹.

Due script girano in parallelo. Uno aggiorna un indice di clip video, l’altro lo legge per costruire una pagina. Quasi sempre funziona. A volte il lettore becca il file proprio mentre lo scrittore lo sta riscrivendo e vede un file vuoto. I test sono su Linux con Python 3.10.12, in una cartella temporanea, con output incollati senza modifiche¹.

Le prove mostrano tre fatti. Primo: open(path, 'w') tronca subito il file, prima di qualsiasi byte nuovo. Se un lettore interroga in quel momento, gli errori superano di molto i successi¹. Secondo: se il processo che scrive si interrompe a metà, perdi anche la versione precedente. Resta un frammento, senza nulla a cui tornare¹. Terzo: scrivere su un file temporaneo nello stesso percorso e poi sostituire con os.replace elimina la finestra di vuoto. Con questo cambio, il lettore non incontra file rotti¹.

La causa è pratica. La riscrittura “in place” apre una finestra in cui il file esiste ma è vuoto. Un lettore che lo apre in quel tempo fallisce con l’errore sopra. Non è una corruzione a valle, è tempismo sbagliato¹.

Il rimedio cambia la sequenza. Si scrive tutto su un temporaneo, si forza a disco, poi si sostituisce il file vero. Il lettore vede sempre un file intero, o la versione vecchia o la nuova. Nei test, zero letture spezzate¹.

Esempio minimo in Python:

• scrivi tutto su un file temporaneo nella stessa cartella
• fsync, per assicurare che i dati arrivino a disco
• sostituisci in un colpo con os.replace

Esempio:

import json, os, tempfile

data = {"clips": [...]}
dst = "index.json"

fd, tmp = tempfile.mkstemp(dir=".", prefix=dst + ".", suffix=".tmp")
try:
    with os.fdopen(fd, "w") as f:
        json.dump(data, f)
        f.flush()
        os.fsync(f.fileno())
    os.replace(tmp, dst)
finally:
    try:
        os.remove(tmp)
    except FileNotFoundError:
        pass

Attorno a questo schema l’autore segnala tre trappole, utili a delimitare il perimetro operativo¹:

• lo svuotamento immediato con open(..., 'w'): è l’inconsistenza che vuoi evitare, quindi non riscrivere “in place”;
• l’interruzione a metà: se il writer cade durante la scrittura diretto sul file vero, lasci un frammento e perdi lo stato precedente;
• la finestra di lettura nel mezzo: un lettore che apre tra il troncone e il riempimento vede il vuoto e fallisce.

Checklist essenziale per implementare senza sorprese:

• scrivi su un file temporaneo nello stesso percorso del bersaglio;
• chiudi e fsync il temporaneo prima della sostituzione;
• sostituisci con os.replace, in modo che il passaggio da vecchio a nuovo sia unico per i lettori;
• non usare open(path, 'w') sul file reale;
• non lasciare lettori osservare file parziali, punta sempre al percorso finale già sostituito¹.