mitmario.dev

Wenn niemand zuhört

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 4 von 7

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

Ein Promise, dem 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.

Der Listener, der weitermacht
// 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.

Sauber aufhören
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:

  1. Protokollieren, denn das ist die einzige Spur, die von diesem Vorfall bleibt. Im Beispiel geht die Zeile mit console.error auf den Fehlerkanal.
  2. Keine neuen Anfragen mehr annehmen. server.close() nimmt keine neuen Verbindungen mehr an und lässt die schon laufenden Anfragen zu Ende laufen.
  3. 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.
  4. 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, kostenlos

Zu 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.