Node Fehler behandeln wenn Datenbank timeout hat

[Aua (Gast)]

Hi Leute,

ich bastele ja nun schon einige Zeit mit Docker und node.js. Als Basis 
benutze ich dieses Tutorial und alles funktioniert inzwischen prima. Ich 
habe auch die Datenbank so eingebunden wie hier beschrieben.

https://bezkoder.com/node-js-rest-api-express-mysql/

Gestern Abend habe ich dann gesehen, dass es plötzlich (ohne dass ich 
auf die Datenbank zugegriffen hätte) diesen Fehler gab (siehe unten). 
Aber da der ja nicht von meinem code oder meinen Aktivitäten ausging - 
wie kann ich den abfangen / behandeln? c_db ist der Datenbank-Container 
und c_node der für node

c_db      | 2021-07-26 23:04:43 3 [Warning] Aborted connection 3 to db: 'db_XXX' user: 'u_XXX' host: '172.18.0.3' (Got timeout reading communication packets)
c_node    | node:events:371
c_node    |       throw er; // Unhandled 'error' event
c_node    |       ^
c_node    | 
c_node    | Error: read ECONNRESET
c_node    |     at TCP.onStreamRead (node:internal/stream_base_commons:211:20)
c_node    | Emitted 'error' event on Connection instance at:
c_node    |     at Connection._handleProtocolError (/home/node/app/node_modules/mysql/lib/Connection.js:423:8)
c_node    |     at Protocol.emit (node:events:394:28)
c_node    |     at Protocol._delegateError (/home/node/app/node_modules/mysql/lib/protocol/Protocol.js:398:10)
c_node    |     at Protocol.handleNetworkError (/home/node/app/node_modules/mysql/lib/protocol/Protocol.js:371:10)
c_node    |     at Connection._handleNetworkError (/home/node/app/node_modules/mysql/lib/Connection.js:418:18)
c_node    |     at Socket.emit (node:events:394:28)
c_node    |     at emitErrorNT (node:internal/streams/destroy:157:8)
c_node    |     at emitErrorCloseNT (node:internal/streams/destroy:122:3)
c_node    |     at processTicksAndRejections (node:internal/process/task_queues:83:21) {
c_node    |   errno: -104,
c_node    |   code: 'ECONNRESET',
c_node    |   syscall: 'read',
c_node    |   fatal: true
c_node    | }
c_node exited with code 1

[Εrnst B. (ernst)]

try { ... } catch (...) { ... }

https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Statements/try...catch

oder, speziell auf das MySQL-Modul bezogen:

myConnection.on('error',(e) => { 
   console.log("MySQL-Fehler wurde nicht abgefangen",e); 
   process.exit(1); 
});

[Aua (Gast)]

Try-catch kenne ich und habe es auch schon benutzt. Das Ding ist hier: 
Ich wusste nicht, wo ich es hätte hinschreiben sollen - um die gesamte 
server.js? Ich hatte inzwischen erstmal so probiert und den Fehler 
gefangen (Deine Vorgabe ist spezifischer)

process.on('uncaughtException', function(err) {
  console.error(err.stack);
  console.log('catched - NODE can run on.');
});

So wie ich das sehe, wird das connection-"Objekt?" in der db.js erzeugt 
und dann nur in der "customer.model.js" benutzt, also die server.js weiß 
davon gar nichts?

Jedenfalls - was ich erreichen will: Derzeit (ohne die o.g. Änderung) 
stürzt das Programm ab, sobald die Datenbank nur kurz nicht zur 
Verfügung steht. Ich würde in dem Fall gerne nach einer Minute 
versuchen, neu zu verbinden.

Für mein Verständnis müsste ich dann in der o.g. Funktion ein callback 
in einer Minute vereinbaren, und da neu verbinden. Aber wenn der 
Programmteil in der server.js steht, dann weiß die ja gar nichts von der 
Objektinstanz innerhalb des Moduls..?

PS: Ich bin ja auf dem langen Weg vom Abschreiben zum Verstehen und Du 
hast mit schon sehr geholfen, danke!

[🐧 DPA 🐧 (Gast)]

https://www.npmjs.com/package/mysql#error-handling
> Last but not least: If a fatal errors occurs and there are no pending
> callbacks, or a normal error occurs which has no callback belonging to it,
> the error is emitted as an 'error' event on the connection object. This is
> demonstrated in the example below:

#!/usr/bin/env node
connection.on('error', function(err) {
  console.log(err.code); // 'ER_BAD_DB_ERROR'
});

Oft ist es aber von Vorteil, einen Connection Pool zu haben. Da hat man 
dann immer ein paar Verbindungen auf Vorrat. Man holt sich daraus dann 
immer erst eine Verbindung, wenn man gerade eine braucht. Wenn dann da 
zwischendrin mal eine Abbricht, ist das oft nicht so schlimm.
https://www.npmjs.com/package/mysql#pooling-connections oder 
https://www.npmjs.com/package/generic-pool

Man sollte dann aber auch noch mit Transactions arbeiten, damit man bei 
Komplexeren Sachen nichts halbfertiges hat. Fast alles in Transactions 
wird bei Fehlern und Verbindungsabbrüchen rückgängig gemacht / bzw. erst 
beim Commit übernommen. Wobei, bei sowas simplem wie in deinem 
Beispiellink (nur ein Query pro Funktion / Rest call) kann man sich das 
auch sparen. Das Beispiel ist aber auch sehr schlecht geeignet, da 
nachträglich noch Transaktionen nachzurüsten, weil man da die DB 
Verbindung mit der Transaktion nicht mitgeben kann.

Das holen von Verbindungen, das Verwalten von Transactions, usw. packe 
ich mir gerne in Hilfsfunktionen, damit ich aquire, release, commit, 
rollback, etc. nicht vergesse. Ich mache dann alle DB Funktionen gerne 
async. z.B.

// (alles ungetestet)

const pf = (t,f)=>promisify((...x)=>t[f](...x)); // Like promisify, but preserve this

async function connection_helper(c, callback){
  if(c) return c;
  const connection = await pf(pool,'getConnection');
  try {
    await callback(connection);
  } finally {
    connection.release();
  }
}

const transaction_private = Symbol('transaction');
async function transaction_helper(connection, callback){
  if(!connection[transaction_private])
    connection[transaction_private] = {sp: null, id: 0};
  const id = connection[transaction_private].id;
  connection[transaction_private].id = connection[transaction_private].id + 1 |0;
  const current_savepoint = {id};
  const old_savepoint = connection[transaction_private].sp;
  connection[transaction_private].sp = current_savepoint;
  // Transaction oder Savepoint starten
  if(old_savepoint){
    await pf(connection,'query')(`SAVEPOINT sp_${current_savepoint.id}`);
  }else{
    await pf(connection,'beginTransaction')();
  }
  wrong_savepoint: {
    try {
      const result = await callback(connection);
      if(connection[transaction_private].sp !== current_savepoint)
        break wrong_savepoint;
      try {
        // Release savepoint or commit if none
        if(old_savepoint){
          await pf(connection,'query')(`RELEASE SAVEPOINT sp_${current_savepoint.id}`);
        }else{
          await pf(connection,'commit')();
        }
      } finally {
        if(connection[transaction_private].sp !== current_savepoint)
          break wrong_savepoint;
      }
      return result;
    } catch(e) {
      if(connection[transaction_private].sp !== current_savepoint)
        break wrong_savepoint;
      try {
        if(old_savepoint){
          await pf(connection,'query')(`ROLLBACK TO SAVEPOINT sp_${current_savepoint.id}`);
        }else{
          await pf(connection,'rollback')();
        }
      } finally {
        if(connection[transaction_private].sp !== current_savepoint)
          break wrong_savepoint;
        throw e;
      }
    } finally {
      if(connection[transaction_private].sp !== current_savepoint)
        break wrong_savepoint;
      connection[transaction_private].sp = old_savepoint;
    }
    return;
  }
  try {
    connection[transaction_private].sp = null;
    connection.destroy(); // Something went very wrong. Terminate connection, that should roll back any pending transactions, and makes sure nothing else is done on this connection
  } finally {
    throw new Error("Unexpected savepoint. Make sure not to call these functions in paralel, and don't forget to use await everywhere!");
  }
}

Und dann:

async function do_something(c, bla){
  return connection_helper(c, async c=>{
    let result = await pf(db,'query')("SELECT bla FROM bla WHERE x=?", [bla]);
    return result[0].bla;
  });
}

async function do_something_2(c, bla){
  return connection_helper(c, c=>transaction_helper(c, async()=>{
    await pf(db,'query')("UPDATE bla2 SET x=?", [bla]);
    await pf(db,'query')("UPDATE bla3 SET x=?", [bla]);
  }));
}

async function do_something_complex(c){
  return connection_helper(c, c=>transaction_helper(c, async()=>{
    let result = await do_something(db, 123);
    await do_something_2(db, result);
  }));
}

[🐧 DPA 🐧 (Gast)]

Edit: Transaction Deadlocks sind im Code oben noch nicht behandelt. 
Sowas in der Art:

  async function db_deadlock_retry(func, count=20){
    let i=0;
    for(let i=0; !count || i<count; i++){
      try {
        return await func();
      } catch(error) {
        if(error.code == 'ER_LOCK_DEADLOCK'){
          console.info("Got "+error.code+"...");
          continue;
        }
        throw error;
      }
    }
  }

Sollte man aber nur in der toplevel transaction machen, nicht für 
einzelne savepoints.

[Aua (Gast)]

zu "connection pool" hatte ich etwas gelesen, das hilft mir aber nicht, 
wenn die Datenbank ein paar Minuten "weg" ist (z.B. Server wird neu 
gestartet) und dann wiederkommt.

[🐧 DPA 🐧 (Gast)]

Man muss sich halt die Verbindung erst dann holen, wenn man sie auch 
braucht, und danach wieder freigeben oder schliessen. Wenn die DB weg 
ist, man was machen will, und es deshalb Fehler gibt, muss man es dann 
halt später nochmal versuchen, wenn die DB wieder da ist.

[Aua (Gast)]

Ich habe jetzt mal ein Mini-Testprogramm geschrieben, db.js ist gebause 
wie im Tutorial oben:

[code]
const express = require("express");
const app = express();
app.use(express.json());
app.use(express.urlencoded());

// catch database connection errors. ToDo: do more specific on 
ECONNRESET
process.on('uncaughtException', function(err) {
  console.error(err.stack);
  console.log('catched - NODE can run on.');
})

// db connection
var sql = require("./models/db.js");

app.get("/", (req, res) => {
  sql.query("SELECT * FROM customers", function(err, result) {
    if (err) {res.json({err})} else {res.json({ result })};
  });
});

// set port, listen for requests
app.listen(3133, () => {
  console.log("Server is running on port 3133.");
});
[code]

Das funktioniert, und wenn ich die Datenbank abschalte, gibt es sofort 
einen Fehler, den ich ja abfange, also der "server" läuft weiter. Aber 
was muss ich wie mit der Connection tun, damit es wieder funktioniert, 
sobald die DB wieder da ist?

Momentan erhalte ich da den Fehler: PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR

habe schon versucht vor sql.query zu schreiben
sql.destroy();
sql.connect();

aber das hat nicht funktioniert..

[Aua (Gast)]

Was ich inzwischen noch gelesen habe: Man muss nach einem solchen Fehler 
ein neues Connection-Objekt benutzen - aber wie mache ich das (wie 
kriege ich es ganz tot), bzw. wie stelle ich sicher, dass er nicht immer 
wieder durch die Modul-Verwendung das alte benutzt?

[Εrnst B. (ernst)]

Aua schrieb:
> Was ich inzwischen noch gelesen habe: Man muss nach einem solchen Fehler
> ein neues Connection-Objekt benutzen

das "Wie" stand weiter oben:

🐧 DPA 🐧 schrieb:
> Oft ist es aber von Vorteil, einen Connection Pool zu haben.

da kümmert sich dann das "Pool-Verwaltungs-Objekt" darum, dass du immer 
eine funktionierende Verbindung bekommst.

https://www.npmjs.com/package/mysql#pooling-connections

[🐧 DPA 🐧 (Gast)]

Indem du bei db.js keine bereits geöffnete Verbindung exportierst, 
sondern stattdessen Funktionen, mit denen du dir eine Verbindung holst, 
und/oder sie wieder frei gibst.

Eine ganz Primitive Methode (mit ES5 old style callbacks stat 
async/await):

#!node
function aquireDBConnection(callback){
  const connection = mysql.createConnection({
    host: dbConfig.HOST,
    user: dbConfig.USER,
    password: dbConfig.PASSWORD,
    database: dbConfig.DB
  });

  // open the MySQL connection
  connection.connect(error => {
    if (error) return callback(error);
    console.log("Successfully connected to the database.");
    callback(null, connection);
  });
}

function releaseDBConnection(connection){
  connection.end();
}

module.exports = {aquireDBConnection, releaseDBConnection};

(Da nimmt man statdessen aber besser einen connection pool, der auch 
gleich solche Methoden schon anbietet. Das ist nur illustratorisch.).

Und dann:

#!node
var {aquireDBConnection, releaseDBConnection} = require("./models/db.js");

app.get("/", (req, res) => {
  aquireDBConnection(function(error, sql){ // get a connection before using it
    if (error) throw error;
    sql.query("SELECT * FROM customers", function(err, result) {
      releaseDBConnection(sql); // Connection no longer needed, release it
      if (err) {res.json({err})} else {res.json({ result })};
    });
  });
});

In meinem ersten post ist viel async / await zucker, um das Freigeben 
von Verbindungen und error handling wegzuabstrahieren.

[Aua (Gast)]

Der connection pool hat's gebracht, und ich musste nur wenig ändern. Die 
db.js aus dem Beispiel/tutorial oben sieht jetzt so aus / alles schick:

const mysql = require("mysql");
const dbConfig = require("../config/db.config.js");

// Create a connection to the database
const connection = mysql.createPool({
  //ToDo:increase later
  connectionLimit: 2,
  host: dbConfig.HOST,
  user: dbConfig.USER,
  password: dbConfig.PASSWORD,
  database: dbConfig.DB
});

/*
// open the MySQL connection
connection.connect(error => {
  if (error) throw error;
  console.log("Successfully connected to the database.");
});
*/

module.exports = connection;