Quand fermer la connexion à la base de données MongoDB dans Nodejs

Question

Travailler avec Nodejs et MongoDB grâce au pilote natif de Node MongoDB. J'ai besoin de récupérer des documents, de les modifier, puis de les sauvegarder. Voici un exemple :

db.open(function (err, db) {
  db.collection('foo', function (err, collection) {
    var cursor = collection.find({});
    cursor.each(function (err, doc) {
      if (doc != null) {
        doc.newkey = 'foo'; // Make some changes
        db.save(doc); // Update the document
      } else {
        db.close(); // Closing the connection
      }
    });
  });
});

Avec la nature asynchrone, si le processus de mise à jour du document prend plus de temps, alors lorsque le curseur atteint la fin des documents, la connexion à la base de données est fermée. Toutes les mises à jour ne sont pas enregistrées dans la base de données.

Si le db.close() est omis, tous les documents sont correctement mis à jour, mais l'application se bloque, sans jamais sortir.

J'ai vu un post suggérant d'utiliser un compteur pour suivre le nombre de mises à jour, quand il retombe à zéro, alors fermez le db. Mais est-ce que je fais quelque chose de mal ici ? Quelle est la meilleure façon de gérer ce genre de situation ? Est-ce que db.close() doivent être utilisées pour libérer des ressources ? Ou bien une nouvelle connexion à la base de données doit-elle être ouverte ?

Answer 1

Voici une solution potentielle basée sur l'approche du comptage (je ne l'ai pas testée et il n'y a pas de piège à erreurs, mais cela devrait donner une idée).

La stratégie de base est la suivante : Acquérir le compte du nombre d'enregistrements à mettre à jour, sauvegarder chaque enregistrement de manière asynchrone et un callback sur le succès, qui décrémentera le compte et fermera la BD si le compte atteint 0 (lorsque la dernière mise à jour se termine). En utilisant {safe:true} nous pouvons nous assurer que chaque mise à jour est réussie.

Le serveur mongo utilisera un thread par connexion, il est donc bon de a) fermer les connexions inutilisées, ou b) les mettre en commun/réutiliser.

db.open(function (err, db) {
  db.collection('foo', function (err, collection) {
    var cursor = collection.find({});
    cursor.count(function(err,count)){
      var savesPending = count;

      if(count == 0){
        db.close();
        return;
      }

      var saveFinished = function(){
        savesPending--;
        if(savesPending == 0){
          db.close();
        }
      }

      cursor.each(function (err, doc) {
        if (doc != null) {
          doc.newkey = 'foo'; // Make some changes
          db.save(doc, {safe:true}, saveFinished);
        }
      });
    })
  });
});

Answer 2

Il est préférable d'utiliser une connexion mutualisée et d'appeler db.close() dans la fonction de nettoyage à la fin de la vie de votre application :

process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);

Voir http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html

Un peu vieux fil, mais quand même.

Answer 3

J'ai trouvé que l'utilisation du compteur peut s'appliquer à un scénario simple, mais peut être difficile dans des situations compliquées. Voici une solution que j'ai trouvée en fermant la connexion à la base de données lorsque celle-ci est inactive :

var dbQueryCounter = 0;
var maxDbIdleTime = 5000; //maximum db idle time

var closeIdleDb = function(connection){
  var previousCounter = 0;
  var checker = setInterval(function(){
    if (previousCounter == dbQueryCounter && dbQueryCounter != 0) {
        connection.close();
        clearInterval(closeIdleDb);
    } else {
        previousCounter = dbQueryCounter;
    }
  }, maxDbIdleTime);
};

MongoClient.connect("mongodb://127.0.0.1:27017/testdb", function(err, connection)(
  if (err) throw err;
  connection.collection("mycollection").find({'a':{'$gt':1}}).toArray(function(err, docs) {
    dbQueryCounter ++;
  });   
  //do any db query, and increase the dbQueryCounter
  closeIdleDb(connection);
));

Cela peut être une solution générale pour toutes les connexions de base de données. maxDbIdleTime peut être défini comme la même valeur que db query timeout ou plus.

Ce n'est pas très élégant, mais je ne vois pas de meilleure façon de procéder. J'utilise NodeJs pour exécuter un script qui interroge MongoDb et Mysql, et le script traîne là pour toujours si les connexions à la base de données ne sont pas fermées correctement.

Answer 4

Voici un exemple étendu à la réponse donnée par pkopac puisque je devais m'occuper du reste des détails :

const client = new MongoClient(uri);
(async () => await client.connect())();

// use client to work with db
const find = async (dbName, collectionName) => {
  try {
    const collection = client.db(dbName).collection(collectionName);
    const result = await collection.find().toArray()
    return result;
  } catch (err) {
    console.error(err);
  }
}

const cleanup = (event) => { // SIGINT is sent for example when you Ctrl+C a running process from the command line.
  client.close(); // Close MongodDB Connection when Process ends
  process.exit(); // Exit with default success-code '0'.
}

process.on('SIGINT', cleanup);
process.on('SIGTERM', cleanup);

Voici un lien vers la différence entre SIGINT y SIGTERM . J'ai dû ajouter le process.exit() sinon mon serveur web node ne se terminait pas proprement quand on faisait Ctrl + C sur le processus en cours dans la ligne de commande.

Answer 5

Voici une solution que j'ai trouvée. Elle évite d'utiliser toArray et elle est assez courte et douce :

var MongoClient = require('mongodb').MongoClient;

MongoClient.connect("mongodb://localhost:27017/mydb", function(err, db) {
  let myCollection = db.collection('myCollection');
  let query = {}; // fill in your query here
  let i = 0;
  myCollection.count(query, (err, count) => { 
    myCollection.find(query).forEach((doc) => {
      // do stuff here
      if (++i == count) db.close();
    });
  });
});