node.js - multiple - mongoose npm

Opción Mongoose autoReconnect

Question

Estoy intentando configurar la función de reconexión automática MongoDB a través de Mongoose. Cada vez que he intentado pasar la opción no ha tenido ningún efecto, o al menos no se está emitiendo el evento reconnected .

Lo que he intentado:

mongoose.createConnection("mongodb://localhost:27017/test", { auto_reconnect: true });
mongoose.createConnection("mongodb://localhost:27017/test", { autoReconnect: true });
mongoose.createConnection("mongodb://localhost:27017/test", { server: { auto_reconnect: true } });
mongoose.createConnection("mongodb://localhost:27017/test", { server: { autoReconnect: true } });

Si uno de estos es correcto, reconnected debe activar el evento reconnected y se debe registrar un mensaje en la consola, sin embargo, esto nunca ocurre.

Si hay un retraso antes de la reconexión, ¿alguien sabe cómo configurarlo?

Gracias por adelantado

Para cualquiera que esté investigando esto, eche un vistazo a this y this problema en el repositorio de mangostas.

Answer 1

Aquí hay una mejora de la respuesta de Clive que establece un mínimo de 5 segundos entre intentos de conexión.

var db = mongoose.connection;
var lastReconnectAttempt; //saves the timestamp of the last reconnect attempt
db.on(''error'', function(error) {
    console.error(''Error in MongoDb connection: '' + error);
    mongoose.disconnect();
});
db.on(''disconnected'', function() {
    console.log(''MongoDB disconnected!'');
    var now = new Date().getTime();
    // check if the last reconnection attempt was too early
    if (lastReconnectAttempt && now-lastReconnectAttempt<5000) {
        // if it does, delay the next attempt
        var delay = 5000-(now-lastReconnectAttempt);
        console.log(''reconnecting to MongoDB in '' + delay + "mills");
        setTimeout(function() {
            console.log(''reconnecting to MongoDB'');
            lastReconnectAttempt=new Date().getTime();
            mongoose.connect(dbURI, {server:{auto_reconnect:true}});
        },delay);
    }
    else {
        console.log(''reconnecting to MongoDB'');
        lastReconnectAttempt=now;
        mongoose.connect(dbURI, {server:{auto_reconnect:true}});
    }

});

Answer 2

Asegúrate de que la mangosta también sea la única forma de conectarte a Mongo. En mi caso, estoy usando connect-mongo para almacenar sesiones en Express, pero no tiene auto_reconnect establecido en true de forma predeterminada, a partir de v0.4.0.

Answer 3

Basado en @zangw answer, he terminado con esta función init de base de datos para mi aplicación

const mongoose = require(''mongoose'')
const RETRY_TIMEOUT = 3000

module.exports = function initDB () {
  mongoose.Promise = global.Promise
  const options = {
    autoReconnect: true,
    useMongoClient: true,
    keepAlive: 30000,
    reconnectInterval: RETRY_TIMEOUT,
    reconnectTries: 10000
  }

  let isConnectedBefore = false

  const connect = function () {
    return mongoose.connect(process.env.MONGODB_URL, options)
      .catch(err => console.error(''Mongoose connect(...) failed with err: '', err))
  }

  connect()

  mongoose.connection.on(''error'', function () {
    console.error(''Could not connect to MongoDB'')
  })

  mongoose.connection.on(''disconnected'', function () {
    console.error(''Lost MongoDB connection...'')
    if (!isConnectedBefore) {
      setTimeout(() => connect(), RETRY_TIMEOUT)
    }
  })
  mongoose.connection.on(''connected'', function () {
    isConnectedBefore = true
    console.info(''Connection established to MongoDB'')
  })

  mongoose.connection.on(''reconnected'', function () {
    console.info(''Reconnected to MongoDB'')
  })

  // Close the Mongoose connection, when receiving SIGINT
  process.on(''SIGINT'', function () {
    mongoose.connection.close(function () {
      console.warn(''Force to close the MongoDB connection after SIGINT'')
      process.exit(0)
    })
  })
}

Hay algunas diferencias: he agregado algunas opciones para evitar el problema de cierre de la conexión: no volver a conectar después de 30 reintentos automáticos, solo MongoError: la topología se destruyó para cualquier operación y no se volvió a conectar; también he agregado .catch después de la conexión para evitar el rechazo no prometido de la promesa):

Answer 4

Desplumado de http://bites.goodeggs.com/posts/reconnecting-to-mongodb-when-mongoose-connect-fails-at-startup/

Esto funcionó para mí:

var mongoose = require(''mongoose'')
var mongoUrl = "mongodb://localhost:27017/test"

var connectWithRetry = function() {
  return mongoose.connect(mongoUrl, function(err) {
    if (err) {
      console.error(''Failed to connect to mongo on startup - retrying in 5 sec'', err);
      setTimeout(connectWithRetry, 5000);
    }
  });
};
connectWithRetry();

Answer 5

Después de leer los documentos, estoy bastante seguro de que tienes las opciones equivocadas. La cadena de opciones de conexión debe verse así:

mongoose.connect("mongodb://localhost:27017/db", {
    socketOptions: {
      // This option is on by default, but why not set it explicitly
      autoReconnect: true
    },
    // This options is 1 second by default, its possible the ha
    // takes longer than 30 seconds to recover.
    reconnectInterval: 5000,
    // This options is 30 by default, why not make it 60
    reconnectTries: 60
  })

Verifique esta página: http://mongoosejs.com/docs/api.html

Answer 6

La answer @ Clive fue excelente. No obstante, debido al uso de la mongoose con Promise recibí la siguiente advertencia después de cada intento fallido:

(node: 18123) UnhandledPromiseRejectionWarning: rechazo de promesa no controlada (id de rechazo: 1): MongoError: no se pudo conectar al servidor [localhost: 27017] en la primera conexión

Versión ES6 (con promesa)

También agregué un pequeño tiempo de espera entre las reconexiones en esta versión (completamente opcional), para evitar que su pantalla (o su registrador) se inunde de mensajes repetidos.

import mongoose from ''mongoose'';

mongoose.Promise = Promise; // Set mongoose to use ES6 Promises.

const dbURI = ''mongodb://127.0.0.1:27017/myDb'';
const reconnectTimeout = 5000; // ms.

function connect() {
  mongoose.connect(dbURI, { auto_reconnect: true })
    .catch(() => {}); // Catch the warning, no further treatment is required
                      // because the Connection events are already doing this
                      // for us.
}

const db = mongoose.connection;

db.on(''connecting'', () => {
  console.info(''Connecting to MongoDB...'');
});

db.on(''error'', (error) => {
  console.error(`MongoDB connection error: ${error}`);
  mongoose.disconnect();
});

db.on(''connected'', () => {
  console.info(''Connected to MongoDB!'');
});

db.once(''open'', () => {
  console.info(''MongoDB connection opened!'');
});

db.on(''reconnected'', () => {
  console.info(''MongoDB reconnected!'');
});

db.on(''disconnected'', () => {
  console.error(`MongoDB disconnected! Reconnecting in ${reconnectTimeout / 1000}s...`);
  setTimeout(() => connect(), reconnectTimeout);
});

connect();

Más información sobre eventos de mongoosejs.com/docs/3.0.x/docs/api.html#connection_Connection .

Answer 7

Para tener múltiples reintentos sin solicitar bloqueo mientras bufferMaxEntries: 0 a intentarlo tuve que configurar bufferMaxEntries: 0 :

const dbUri = ''mongodb://localhost/some_db'';
const dbOptions = {
    useMongoClient: true,
    autoReconnect: true,
    reconnectTries: Number.MAX_VALUE,
    bufferMaxEntries: 0
};

mongoose.connect(dbUri, dbOptions).catch(err => process.exit(1));

Answer 8

Recientemente, investigué la reconexión automática con MongoDB var Mongoose . Hay un problema aquí, al invocar mongoose.connect dentro del controlador de eventos disconnected , se activará el bucle infinito. Por qué la señal SIGINT está bloqueada cuando la mangosta se vuelve a conectar automáticamente .

Una solución alternativa podría ser que mongoose.connect() solo se invoque cuando no haya conexión con MongoDB . La bandera de auto_reconnect podría hacer que la mangosta se vuelva a conectar con MongoDB automáticamente. Aquí hay fragmentos de código.

var mongoose = require(''mongoose'');

var isConnectedBefore = false;
var connect = function() {
    mongoose.connect(''mongodb://localhost/'' + + ''test_dev'', {server: { auto_reconnect: true }});
};
connect();

mongoose.connection.on(''error'', function() {
    console.log(''Could not connect to MongoDB'');
});

mongoose.connection.on(''disconnected'', function(){
    console.log(''Lost MongoDB connection...'');
    if (!isConnectedBefore)
        connect();
});
mongoose.connection.on(''connected'', function() {
    isConnectedBefore = true;
    console.log(''Connection established to MongoDB'');
});

mongoose.connection.on(''reconnected'', function() {
    console.log(''Reconnected to MongoDB'');
});

// Close the Mongoose connection, when receiving SIGINT
process.on(''SIGINT'', function() {
    mongoose.connection.close(function () {
        console.log(''Force to close the MongoDB conection'');
        process.exit(0);
    });
});

Answer 9

Solo por el bien de la posteridad, ya que la mayoría de estas respuestas son antiguas, ya no debería tener que lidiar con este problema, ya que ahora está integrado en el controlador nodejs mongodb. Para citar kdmon :

... la reconexión está ahora convertida en mangosta y habilitada por defecto. Pero podría ser útil saber que Mongoose de forma predeterminada solo intentará volver a conectarse durante 30 segundos y luego se dará por vencido. Establezca la opción server.reconnectTries para aumentar la cantidad de veces que Mangoose intentará volver a conectarse. Por ejemplo, puedes decirle a la mangosta que nunca deje de intentar reconectarse así:

mongoose.connect(uri, { server: { reconnectTries: Number.MAX_VALUE } });

Vea los documentos de conexión y los valores predeterminados de las opciones del servidor para más detalles

Answer 10

Tenía la misma pregunta que tú, y la solución de robertklep tampoco me funcionaba. Descubrí que cuando el servicio MongoDB se detiene, se desencadena un evento de error, pero connection.readyState sigue siendo 1 (conectado). Esa puede ser la razón por la cual no se reconectó automáticamente.

Esto es lo que tengo ahora:

  var db = mongoose.connection;

  db.on(''connecting'', function() {
    console.log(''connecting to MongoDB...'');
  });

  db.on(''error'', function(error) {
    console.error(''Error in MongoDb connection: '' + error);
    mongoose.disconnect();
  });
  db.on(''connected'', function() {
    console.log(''MongoDB connected!'');
  });
  db.once(''open'', function() {
    console.log(''MongoDB connection opened!'');
  });
  db.on(''reconnected'', function () {
    console.log(''MongoDB reconnected!'');
  });
  db.on(''disconnected'', function() {
    console.log(''MongoDB disconnected!'');
    mongoose.connect(dbURI, {server:{auto_reconnect:true}});
  });
  mongoose.connect(dbURI, {server:{auto_reconnect:true}});