Abschnitt 16 · Lektion 4
Wenn niemand zuhört
Stirbt ein Server mitten in einer Anfrage, wartet der Aufrufer vergeblich auf seine Antwort. Dafür
reicht ein abgelehntes Promise, an dem weder ein await noch ein .catch() hängt. Seit Node 15
beendet es den Prozess, so wie ein error-Ereignis ohne Listener in Lektion 7.3.
Was passiert, wenn niemand zuhört
async function lade() {
throw new Error("Datenbank weg");
}
process.on("exit", (code) => {
console.log(`Der Prozess endet mit Code ${code}`);
});
console.log("vorher");
// Kein await, kein .catch(): das abgelehnte Promise findet niemanden.
lade();
setTimeout(() => console.log("diese Zeile kommt nicht mehr"), 100); lade() wird aufgerufen, ohne await und ohne .catch(). Das Promise lehnt ab, Node sucht
jemanden, der zuständig ist, findet niemanden und beendet den Prozess mit Code 1. Der Timer, der
hundert Millisekunden später etwas ausgeben wollte, kommt nicht mehr dran.
Auf dem Fehlerkanal steht dabei nichts von einem Promise. Node wirft die Ablehnung als gewöhnlichen
Fehler, und dort steht Error: Datenbank weg mit seinem Stacktrace, so wie bei einem throw, das
niemand fängt.
Bis Node 14 gab es dafür nur eine Warnung. Das Programm lief weiter, mit einem Fehler, für den es keinen Plan gab. Ein Abbruch ist die bessere Antwort. Alles, was danach passiert, beruht auf einer Annahme, die gerade widerlegt wurde. Sofort aufzuhören ist von zwei schlechten Möglichkeiten die weniger schlechte.
Der Listener, der alles schlimmer macht
Für beide Fälle gibt es ein Ereignis an process, unhandledRejection für abgelehnte Promises und
uncaughtException für geworfene Fehler, die niemand gefangen hat. Man kann beide als Auffangnetz
benutzen, und das Programm macht dann einfach weiter.
// So nicht. Der Prozess laeuft in einem Zustand weiter, den niemand vorgesehen hat.
let verbindung = { offen: true };
process.on("uncaughtException", (fehler) => {
console.log(`aufgefangen: ${fehler.message}, und weiter geht es`);
});
process.on("exit", (code) => console.log(`Der Prozess endet mit Code ${code}`));
setTimeout(() => {
verbindung = null;
throw new Error("Verbindung verloren");
}, 10);
setTimeout(() => {
console.log(`Zustand danach: verbindung ist ${verbindung}`);
console.log(`Nächster Zugriff: ${verbindung.offen}`);
}, 50); Der Prozess überlebt, mit einer Verbindung, die es nicht mehr gibt. Der nächste Zugriff darauf
scheitert an null, und dieser Folgefehler wird wieder aufgefangen. Am Ende steht Code 0, und von
außen sieht es aus, als sei alles gut gegangen. Wenn du nur den Exit-Code überwachst, merkst du nie
etwas.
Nach einem uncaughtException weiß niemand mehr, in welchem Zustand die Anwendung ist, vielleicht
mitten in einer Transaktion oder mit einer Antwort, von der schon die Hälfte beim Aufrufer ist.
Läuft sie in diesem Zustand weiter, wird aus einem Fehler eine Reihe stiller Falschdaten.
Wofür die Listener da sind
Ein Listener an process ist zum sauberen Aufhören da.
import { createServer, request } from "node:http";
const server = createServer(async (req, res) => {
await new Promise((fertig) => setTimeout(fertig, 200));
console.log("Anfrage fertig");
res.end("ok\n");
});
function herunterfahren(grund, code) {
console.error(`fahre herunter: ${grund}`);
server.close(() => {
console.log("alle Anfragen fertig, Ende");
process.exit(code);
});
// Falls close nie zurueckkommt: nach fuenf Sekunden ist trotzdem Schluss.
setTimeout(() => process.exit(code), 5000).unref();
}
process.on("unhandledRejection", (grund) => herunterfahren(`unbehandelt: ${grund.message}`, 1));
process.on("SIGTERM", () => herunterfahren("SIGTERM", 0));
process.on("exit", (code) => console.log(`Der Prozess endet mit Code ${code}`));
server.listen(3000, () => {
request({ port: 3000, path: "/bericht", agent: false }, (antwort) => antwort.resume()).end();
setTimeout(() => Promise.reject(new Error("Datenbank weg")), 50);
}); Es sind vier Schritte, und sie laufen immer in dieser Reihenfolge:
- Protokollieren, denn das ist die einzige Spur, die von diesem Vorfall bleibt. Im Beispiel geht
die Zeile mit
console.errorauf den Fehlerkanal. - Keine neuen Anfragen mehr annehmen.
server.close()nimmt keine neuen Verbindungen mehr an und lässt die schon laufenden Anfragen zu Ende laufen. - Warten, bis die laufenden fertig sind. Der Callback von
server.close()kommt genau dann. Im Beispiel beginnt das Herunterfahren nach 50 Millisekunden, die Anfrage braucht 200, und trotzdem steht „Anfrage fertig“ vor „alle Anfragen fertig, Ende“. Der Aufrufer, der schon wartete, bekommt seine Antwort. - Beenden, mit einem Code, der stimmt. Nach einem Fehler ist das 1.
Der Timer mit unref() ist die Versicherung dagegen, dass Schritt 3 nie fertig wird. Hängt eine
Anfrage, kommt der Callback nie. Ohne diese fünf Sekunden bliebe der Prozess dann für immer im
Herunterfahren stecken. Mit unref() hält dieser Timer den Prozess nicht künstlich am Leben, wenn
alles gut geht.
SIGTERM ist dieselbe Mechanik von der anderen Seite
Im Beispiel hängt am selben herunterfahren noch ein zweiter Listener, und der ist der Normalfall.
SIGTERM ist das Signal, mit dem eine Umgebung höflich um das Ende bittet, etwa bei einem Neustart,
einem Deployment oder beim Herunterskalieren. Endet der Prozess nicht, folgt nach einer Frist
SIGKILL, und das ist der Stecker.
Vom Fehlerfall unterscheidet sich das nur im Exit-Code. Bei SIGTERM ist 0 richtig, denn niemand
ist abgestürzt. Die vier Schritte sind dieselben, also steht dort auch dieselbe Funktion. Ein Server
ohne eigenen Listener für SIGTERM endet sofort mit Code 143, und die Anfragen, die gerade
unterwegs waren, sind verloren.
Wer den Prozess wieder startet
Stirbt der Server an einem unerwarteten Fehler, übernimmt die Umgebung den Neustart, ein Prozessmanager, ein Container-Dienst oder eine Plattform. Sie merkt, dass der Prozess weg ist, und startet einen neuen, der in einem sauberen Zustand beginnt statt in einem kaputten. Mehr dazu in Lektion 18.4.
Im Reiter Praxis stirbt ein Server an einem Fehler, den niemand fängt, mitten in einer laufenden Anfrage.
Zum Mitnehmen
Ohne await und catch beendet ein abgelehntes Promise den Prozess, und auf dem Fehlerkanal sieht es aus wie ein gewöhnlicher Absturz. Die Listener an process protokollieren, lassen laufende Anfragen fertig werden und beenden dann, nach einem Fehler mit Code 1.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.