Estoy tratando de configurar el MongoDB reconexión automática de función a través de la Mangosta. Cada camino que he tratado de pasar la opción no ha tenido ningún efecto, o al menos la reconnected evento no está siendo emitido.

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 una de estas es la correcta, la reconnected evento debe ser disparada y un mensaje que debe haber iniciado sesión en la consola, sin embargo esto no ocurre nunca.

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

Gracias de antemano

Para cualquiera que esté buscando en esto, echa un vistazo a este y este problema en la mangosta repositorio.

  • Autoreconnect está activado por defecto, así que usted no tiene que permitir a ti mismo. También, para qué adjuntar el oyente para la reconnected evento, y que la simulación de un real vuelva a conectar situación?
  • Estoy adjuntando a dicho evento para el regreso de este createConnection() llamada. Mis eventos están trabajando normalmente con el connected/disconnected eventos.
  • Entonces, ¿cómo son las pruebas de la vuelve a conectar?
  • detener/iniciar el servicio mongodb después de la inicialización de la aplicación.
  • mangosta sólo se vuelve a conectar cuando en realidad el uso de la conexión, así que intenta ejecutar una consulta después de reiniciar mongodb. Me estoy volviendo a conectar-eventos de esa manera (aunque yo uso mongoose.connect() y no createConnection(), tal vez lo que hace la diferencia)
  • Bueno, después de algún tiempo he intentado lo que dijo sin ningún éxito 🙂 Al menos no con éxito el uso de createConnection()
  • Puede ser útil consultar el problema abrí sobre este tema en el proyecto de la página de Github.

InformationsquelleAutor gustavohenke | 2013-04-25

10 Comentarios

  1. 52

    Tenía la misma pregunta que tú, y robertklep la solución no funcionó para mí. He encontrado en MongoDB se detiene el servicio, un evento de error se activa, pero la conexión.readyState es todavía 1 (conectado). Eso puede ser por eso que no la reconexión automática.

    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}});
    • Esto es lo malo de volver a conectar en desconectar. En su lugar debe supervisar el error y vuelva a conectar desde allí
    • Mangosta no se desconecte en caso de error, así que tengo que explícitamente que desconectar para volver a conectar
    • Para aquellos interesados en la lectura de la oficial de la mangosta Connection docs. mongoosejs.com/docs/3.0.x/docs/api.html#connection_Connection
    • ¿El {server:{auto_reconnect:true}} bits causa de la mangosta de volver a conectarse automáticamente cuando se desconecta? Por ejemplo, si el error evento es disparado y se desconecta, no mangosta vuelva a conectar para usted? Si no, ¿por qué no intentar conectar de nuevo, porque creo que es, probablemente, algunos triviales error de comunicación? O ¿su ‘desconectado’ evento despedido en este caso, y que se encarga de la reconexión? Si es así, ¿cuál es auto_reconnect incluso haciendo ya? No has especie de reimplantado?
    • Este enfoque me tiró varios errores y no me funciona
  2. 15

    Arrancados 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();
    • Esto no funciona para mí!
    • Mejor alternativa!
  3. 11

    Recientemente, investigo la auto-reconexión con MongoDB var Mongoose. Hay un problema aquí, al invocar mongoose.connect dentro de disconnected controlador de eventos, dará lugar a un bucle infinito. ¿Por qué la señal SIGINT se bloquea cuando la mangosta reconexión automática.

    Un trabajo en torno a la solución podría ser que el mongoose.connect() sólo será llamado cuando no hay ninguna conexión con MongoDB antes. El auto_reconnect bandera puede hacer mangosta volver a conectar con MongoDB automáticamente. Aquí están los 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);
        });
    });
    • Para mí esta es la mejor respuesta. El bucle infinito era mi problema. Gracias tio
  4. 9

    Sólo por el bien de la posteridad, como la mayoría de estas respuestas son viejos, usted no debería tener que lidiar con este problema, como es ahora horneados en el nodejs mongodb conductor. Para citar kdmon:

    …reconectar ahora se cocía en la mangosta y habilitado de forma predeterminada. Pero puede ser útil saber que la Mangosta por defecto sólo intente conectarse de nuevo por 30 y, a continuación, dar. Establecer el servidor.reconnectTries opción para aumentar el número de veces que la mangosta intentará volver a conectarse. Por ejemplo, usted puede decir mangosta nunca dejar de intentar volver a conectar como este:

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

    Ver conexión docs y las opciones del servidor valores predeterminados para los detalles

    • El problema con este indicador es que se convierte mangosta en las llamadas el bloqueo de llamadas, es decir, no van a regresar hasta que la base de datos de nuevo. En mi caso me estaba llamando la mangosta de expresa aplicación y preferimos a devolver un error, en lugar de bloquear la solicitud.
    • Ojalá fuera verdad. Es true si la conexión se pierde en la mitad de tiempo de ejecución. Pero si el antes intento de conexión falla (porque el mongo DB es hacia abajo), el conductor nunca reintentos.
  5. 3

    Asegúrese de que la mangosta es el único camino que se está conectando a Mongo.
    En mi caso, estoy utilizando connect-mongo para almacenar las sesiones en el Express, pero no tiene auto_reconnect establece en true de forma predeterminada, como de v0.4.0.

  6. 3

    Aquí es una mejora de Clive de la respuesta, 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}});
        }
    
    });
    • ¿Por qué utilizar auto_reconnect: true, no debe ser false, si reconectar manualmente por qué usted necesita para establecer auto_reconnect a true?
    • auto_reconnect: true sólo funciona como se espera si la primera conexión se realiza correctamente. Por alguna razón, si el primer error de conexión, el controlador nunca lo intentó de nuevo. Por lo tanto todas estas soluciones a encontrar aquí. Dicho esto, creo que se puede dejar la opción de salida, ya que el valor predeterminado es true, de todos modos.
    • Algo como esto es lo que terminé usando, excepto que me mudé a la reintentar en una función independiente por lo que podría ser llamado en un principio, como si la inicial de conectar falla.
  7. 3

    @Clive del respuesta fue excelente. Sin embargo, debido a la utilización de mongoose con Promesa me estaba poniendo la siguiente advertencia después de cada intento fallido:

    (nodo:18123) UnhandledPromiseRejectionWarning: no Controlada promesa de rechazo (rechazo de identificación: 1): MongoError: no se pudo conectar al servidor [localhost:27017] en primer lugar conecte

    ES6 versión (con Promesa)

    También he añadido un pequeño tiempo de espera entre reconecta en esta versión (totalmente opcional), para evitar que su pantalla (o su logger) de ser inundado 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 Conexión eventos.

  8. 1

    Después de la lectura de los documentos, estoy bastante seguro de que usted tiene las opciones equivocadas. Las opciones de conexión de cadena debe verse como:

    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
      })

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

    • Las opciones han cambiado en el curso del tiempo. La pregunta ha sido creada hace 4 años.
  9. 1

    A tener después de varios intentos sin una solicitud de bloqueo de reintentar tuve que establecer 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));
  10. 0

    Basa en @zangw respuesta, he terminado con esta base de datos de la función «init» 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 un par de diferencias: he añadido algunas opciones para evitar el cierre de la conexión cuestión – no vuelva a conectar después de 30 auto reintentos, sólo MongoError: Topología fue destruido por cualquier operación y no vuelva a conectar; también he añadido .captura después de conectarse a prevenir no controlada promesa de rechazo):

Dejar respuesta

Please enter your comment!
Please enter your name here