Nella mia esperienza, la maggior parte degli errori in un'applicazione sono bug :
- Errore di sintassi
- Intervallo errore (numero fuori limite)
- Errore di riferimento (variabile non definita utilizzata)
- digita errore
- Asserzioni personalizzate
Questi dovrebbero essere catturati prima che un'applicazione sia in produzione. Se non vengono catturati, in genere l'applicazione si blocca .
Altri tipi di errori possono essere "recuperati da". Gli esempi includono:
- Errore caricamento immagine
- Soluzione: prova a caricare di nuovo alcune volte. E / o visualizzare un'immagine predefinita.
- Errore di rete (più generale)
- Soluzione: riprova. Altrimenti, nessuna soluzione.
- Errore hardware
- Soluzione: avere i server di backup in attesa di essere usati forse
Altri tipi sono nel mezzo:
- Errore di sicurezza: tentativo di accedere a una risorsa senza credenziali o protocollo appropriati.
- Errore memoria insufficiente
- Errori di sistema distribuiti
La domanda è cosa dovresti fare con gli errori in generale in un sistema distribuito, magari concentrandoti solo su quelli di "livello medio". Invece di arresti anomali dell'app.
Forse c'è un approccio standard a questo. Ho sempre interrotto l'app e ho registrato l'errore, che sarebbe poi stato documentato come un bug. Quindi aggiungeremo del codice per evitare che si verifichi un arresto anomalo, risolvendo l'errore in qualche modo (ad esempio se la directory padre non esisteva quando si creava una directory con mkdir , magari passare a mkdir -p ), oppure inviando una notifica all'utente finale per riprovare, provare questo o quello in altro modo, o far loro sapere che abbiamo registrato l'errore.
Ma in un sistema puramente programmatico, non c'è umano a cui riportare l'errore per facilitare la continuazione del processo (anche se potremmo registrare l'errore per il debugging successivo). Invece, il sistema ha bisogno di crash o gestire l'errore .
Questa è la domanda principale:
How to deal with errors in a distributed system.
Se blocchi l'app, potresti perdere un sacco di dati memorizzati in memoria. Quindi, forse prima del crash, fai un dump (specificato dallo sviluppatore dell'applicazione), che può essere usato per "ripristinare" l'app in qualche modo (come il modo in cui il browser Chrome ripristina le tue schede dopo un arresto anomalo in qualche modo). Forse ci sono modi sofisticati per riprendere lo stato poco prima dell'errore, ma non fare ciò che ha causato l'errore questa volta . Non so come funzionerebbe o sarebbe possibile. O forse il sistema agisce "cautamente" su quel percorso di valutazione del codice la prossima volta (fino a quando l'errore non viene corretto), quindi non lo valuta, e restituisce invece una risposta standard che viene spiegata nella base del codice.
Mi sto solo chiedendo quali sono le tecniche generali per gestire gli errori in un sistema distribuito. Come recuperare da loro, o spostarsi (continuare l'elaborazione con try / catch sorta thing), in modo che il sistema non si arresti mai realmente ed è sempre in uno stato pulito noto . Non sono sicuro che sia possibile ma ho pensato di chiedere. Ovviamente non vuoi semplicemente provare / catturare ogni errore e semplicemente ignorarlo, ciò vanificherebbe lo scopo degli errori.