Mongoose: "पहले कनेक्ट पर कनेक्ट करने में विफल" के बाद कोई पुन: प्रयास नहीं किया जाता है

पुष्टि कर सकता है।
नोड 6, 7, नेवला (कम से कम 6 महीने), मोंगो 3.2 - 3.4
इसके साथ आता है #4890

मुझे लगता है कि यह एक mongodb-core मुद्दा है। मुझे लगता है कि पहली कोशिश विफल होने पर भी इसे फिर से जोड़ने का प्रयास करना चाहिए, क्योंकि मुझे यकीन नहीं है कि यह बाद के प्रयासों से अलग क्यों होगा।

क्या आप वहां भी इस मुद्दे की रिपोर्ट कर सकते हैं?

यहाँ एक पूर्ण रेप्रो स्क्रिप्ट है:

const mongoose = require('mongoose');
const co = require('co');
mongoose.Promise = global.Promise;
const GITHUB_ISSUE = `gh-5169`;


exec()
  .catch(error => {
    console.error(`Error: ${ error }\n${ error.stack }`);
  });


function exec() {
  return co(function*() {
    const db = mongoose.createConnection(`mongodb://localhost:27017/${ GITHUB_ISSUE }`);
    db.on('error', (error) => {
      console.error(`in an error ${ error }\n${ error.stack }`);
    })
  });
}

रेपो के लिए धन्यवाद। मैंने मोंगोडब-कोर में देखा है। यह ड्राइवर का इच्छित व्यवहार है :

यदि यह होस्ट से कनेक्ट नहीं हो पाता है तो ड्राइवर पहले कनेक्ट पर विफल हो जाएगा। यह अगम्य मेजबानों पर त्वरित विफलता सुनिश्चित करने के लिए डिज़ाइन द्वारा है। पुन: कनेक्ट व्यवहार केवल तभी प्रारंभ होता है जब ड्राइवर ने प्रारंभिक कनेक्ट किया हो।

यह तय करना है कि क्या करना है, यह आवेदन पर निर्भर है। यह डिज़ाइन द्वारा यह सुनिश्चित करने के लिए है कि ड्राइवर तेजी से विफल हो जाता है और वहां नहीं बैठता है जिससे आपको लगता है कि यह वास्तव में काम कर रहा है।

इसलिए मुझे संदेह है कि हमें ड्राइवर से कोई अलग व्यवहार नहीं मिलेगा।

मुझे वास्तव में लगता है कि निम्न स्तर के ड्राइवर के लिए व्यवहार उचित है। यह उन डेवलपर्स की मदद करेगा जो गलती से गलत होस्ट या गलत पोर्ट से कनेक्ट करने का प्रयास करते हैं।

लेकिन अगर हम नेवले में कुछ और डेवलपर-अनुकूल करना चाहते हैं, तो हम इस पर विचार कर सकते हैं:

• जब ऑटो-रीकनेक्ट विकल्प सक्षम होते हैं, तब तक फिर से कनेक्ट करने का प्रयास करते रहें जब तक कि मोंगो सर्वर से संपर्क नहीं किया जा सके (ऊपर लिंक किए गए वर्कअराउंड की तरह कुछ बनाकर)।
• जब नेवला ऐसा कर रहा हो तो लॉग इन करें, इसलिए ऐसे कनेक्शन के मामले में जो कभी स्थापित नहीं होता है, डेवलपर को कम से कम यह पता चल जाएगा कि समस्या कहां है।
  (लॉग को स्थगित किया जा सकता है, उदाहरण के लिए 30 सेकंड। वास्तव में सीधे लॉगिंग के बजाय, मुझे लगता है कि हमें एक सलाहकार error घटना का उत्सर्जन करना चाहिए, लेकिन फिर भी स्वचालित रूप से पुन: कनेक्ट करने का प्रयास करें।)

अगर मुझे सही से याद है, जब मैंने वर्कअराउंड का उपयोग किया और अंत में कुछ असफल प्रयासों के बाद जुड़ा, तो ऐप द्वारा पहले से ही कतारबद्ध प्रश्नों को वांछित के रूप में निष्पादित किया गया। (लेकिन यह फिर से परीक्षण के लायक है।)

मुझे लगता है कि यह वास्तव में एक अच्छा विचार है, मैं इसे एक सुविधा अनुरोध लेबल करूंगा

नहीं, प्रारंभिक कनेक्शन पर तेजी से विफल होना MongoDB ड्राइवरों में एक बहुत ही सुसंगत व्यवहार है और इसका समर्थन करने वाले mongoose के लिए बहुत अधिक लाभ नहीं है।

स्ट्रांगलूप लूपबैक मोंगोडब कनेक्टर की यह हालिया पोस्ट प्रासंगिक हो सकती है। उनका lazyConnect ध्वज समापन बिंदु हिट होने तक पहले कनेक्शन को रोकता है। यदि उस स्थिति में पहला कनेक्शन विफल हो जाता है, तो डिफ़ॉल्ट कनेक्शन हानि सेटिंग्स प्रभावी हो जाएंगी (यह पुनः प्रयास करेगा)।

मेरी रुचि कंटेनर ऑर्केस्ट्रेशन है, जहां "कंटेनर स्टार्टअप ऑर्डर" को अक्सर सेट और अपेक्षित किया जा सकता है लेकिन "सेवा उपलब्धता का क्रम" नहीं हो सकता। एक ऑर्केस्ट्रेशन टूल यह पुष्टि कर सकता है कि मोंगो कंटेनर "ऊपर" है, भले ही मोंगो सेवा अभी तक उपलब्ध नहीं है।

इसलिए, यदि मेरा मोंगो कंटेनर शुरू करने के लिए 1s लेता है, लेकिन सेवा उपलब्ध होने के लिए 5s लेता है, और मेरा ऐप कंटेनर शुरू होने के लिए 1s लेता है और सेवा उपलब्ध होने के लिए 1s लेता है, तो ऐप सेवा मोंगो सेवा से आगे निकल जाएगी, जिससे पहला कनेक्शन विफल हो जाएगा। जैसा कि मूल रूप से वर्णित है ।

डॉकर कंपोज़ दस्तावेज़ में यह कहना है:

कंपोज़ तब तक प्रतीक्षा नहीं करेगा जब तक कि एक कंटेनर "तैयार" नहीं हो जाता है (जो भी आपके विशेष एप्लिकेशन के लिए इसका मतलब है) - केवल तब तक जब तक वह चल रहा हो। इसका एक अच्छा कारण है।

डेटाबेस (उदाहरण के लिए) के तैयार होने की प्रतीक्षा करने की समस्या वास्तव में वितरित सिस्टम की एक बहुत बड़ी समस्या का एक सबसेट है। उत्पादन में, आपका डेटाबेस अनुपलब्ध हो सकता है या किसी भी समय मेजबानों को स्थानांतरित कर सकता है। आपके आवेदन को इस प्रकार की विफलताओं के लिए लचीला होना चाहिए।

इसे संभालने के लिए, आपके एप्लिकेशन को विफलता के बाद डेटाबेस से कनेक्शन को फिर से स्थापित करने का प्रयास करना चाहिए। यदि एप्लिकेशन कनेक्शन का पुन: प्रयास करता है, तो उसे अंततः डेटाबेस से कनेक्ट करने में सक्षम होना चाहिए।

सबसे अच्छा समाधान यह है कि स्टार्टअप पर और जब भी किसी कारण से कनेक्शन खो जाए तो अपने एप्लिकेशन कोड में यह जांच करें।

तो कंटेनर ऑर्केस्ट्रेशन के संदर्भ में यहां एक निश्चित अंतर है, लेकिन ये दोनों रुख मान्य प्रतीत होते हैं:

1. नेवला पहले कनेक्ट पर पुन: प्रयास करने के विकल्प का समर्थन कर सकता है (शायद कुछ सावधान दस्तावेज़ों के साथ गलत करने के लिए डिफ़ॉल्ट), या
2. यदि पहला कनेक्ट विफल हो जाता है, तो पुन: प्रयास करने के लिए कोड लिखने के लिए नेवला डेवलपर पर जिम्मेदारी डाल सकता है।

निश्चित रूप से, एक अंतर है, लेकिन फिर यह तय करने की जिम्मेदारी आप पर आती है कि प्रारंभिक कनेक्शन विफल होने पर पुनः प्रयास करना है या नहीं। सभी नेवले आपको बताते हैं कि यह विफल रहा। यदि आप उत्पादन में (या उस मामले के लिए किसी भी संदर्भ में) डॉकर कंपोज़ का उपयोग करने के लिए संदिग्ध निर्णय लेते हैं, तो प्रारंभिक कनेक्शन विफलताओं को पुनः प्रयास करने के लिए यह आप पर निर्भर है।

रुख 2, यह तब है।

पहली बार कनेक्ट होने पर ऑटो-रीकनेक्शन चाहने वाले किसी भी व्यक्ति के लिए, मैं इसे इस तरह से संभालता हूं:

function createConnection (dbURL, options) {
    var db = mongoose.createConnection(dbURL, options);

    db.on('error', function (err) {
        // If first connect fails because mongod is down, try again later.
        // This is only needed for first connect, not for runtime reconnects.
        // See: https://github.com/Automattic/mongoose/issues/5169
        if (err.message && err.message.match(/failed to connect to server .* on first connect/)) {
            console.log(new Date(), String(err));

            // Wait for a bit, then try to connect again
            setTimeout(function () {
                console.log("Retrying first connect...");
                db.openUri(dbURL).catch(() => {});
                // Why the empty catch?
                // Well, errors thrown by db.open() will also be passed to .on('error'),
                // so we can handle them there, no need to log anything in the catch here.
                // But we still need this empty catch to avoid unhandled rejections.
            }, 20 * 1000);
        } else {
            // Some other error occurred.  Log it.
            console.error(new Date(), String(err));
        }
    });

    db.once('open', function () {
        console.log("Connection to db established.");
    });

    return db;
}

// Use it like
var db = createConnection('mongodb://...', options);
var User = db.model('User', userSchema);

नेवले के लिए <4.11 db.open() बजाय db.openUri()
नेवले 4.11.7 के लिए यह तकनीक काम नहीं करती है।
नेवला 4.13.4 के लिए यह फिर से काम कर रहा है!

संपादित करें 2019/09/02: यहां promiseRetry का उपयोग करके एक छोटा समाधान भी

हाय @ vkarpov15 जब ऐसा होता है तो मोंगोडब-कोर लाइब्रेरी से एक अनहेल्ड रिजेक्शन भी लॉग करें।

MongoError: failed to connect to server [localhost:27017] on first connect [MongoError: connect ECONNREFUSED 127.0.0.1:27017]
    at Pool.<anonymous> (/Users/development/okkralabs/sem-server/services/sem-access/node_modules/mongodb-core/lib/topologies/server.js:336:35)
    at emitOne (events.js:116:13)
    at Pool.emit (events.js:211:7)
    at Connection.<anonymous> (/Users/development/okkralabs/sem-server/services/sem-access/node_modules/mongodb-core/lib/connection/pool.js:280:12)
    at Object.onceWrapper (events.js:317:30)
    at emitTwo (events.js:126:13)
    at Connection.emit (events.js:214:7)
    at Socket.<anonymous> (/Users/development/okkralabs/sem-server/services/sem-access/node_modules/mongodb-core/lib/connection/connection.js:187:49)
    at Object.onceWrapper (events.js:315:30)
    at emitOne (events.js:116:13)
    at Socket.emit (events.js:211:7)
    at emitErrorNT (internal/streams/destroy.js:64:8)
    at _combinedTickCallback (internal/process/next_tick.js:138:11)
    at process._tickCallback (internal/process/next_tick.js:180:9)

इसे पुन: पेश करना आसान है, एक गैर-उपलब्ध MongoDb सर्वर से जुड़ने का प्रयास करें।

(node:2545) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): MongoError: failed to connect to server [localhost:27017] on first connect [MongoError: connect ECONNREFUSED 127.0.0.1:27017]
(node:2545) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

इसे संभालने का कोई तरीका?

@jorgearanda आप किस संस्करण का उपयोग कर रहे हैं और क्या आप कुछ कोड नमूने प्रदान कर सकते हैं?

@vkarpov15 मुझे लगता है कि यह @jorgecuesta के लिए एक संदेश है?

ओह, मेरी गलती। मूर्खतापूर्ण जिथब स्वत: पूर्ण, हाँ, वह

मैं ठीक वैसी ही चीज़ देख रहा हूँ जैसे @jorgecuesta , मैं 4.11.5 का उपयोग कर रहा था और लेकिन 5.0.0-rc2 के साथ इसे देख रहा हूँ। मैं createConnection का उपयोग कर रहा हूं क्योंकि कुछ मॉडल एक ही मोंगो इंस्टेंस पर विभिन्न डेटाबेस का उपयोग कर रहे हैं। यह तब होता है जब मोंगो डाउन होने पर सर्वर शुरू होता है:

2018-01-07 13:05:23-05:00: [INFO] database - reusing existing connectioun for mongodb://localhost/eiss
2018-01-07 13:05:23-05:00: [INFO] database - initializing database connection to: mongodb://localhost/eiss
2018-01-07 13:05:23-05:00: [INFO] database - reusing existing connectioun for mongodb://localhost/eiss
2018-01-07 13:05:23-05:00: [ERROR] database - Mongoose connection error: MongoNetworkError: failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connect ECONNREFUSED 127.0.0.1:27017]
Unhandled rejection MongoNetworkError: failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connect ECONNREFUSED 127.0.0.1:27017]
    at Pool.<anonymous> (/Users/bill/eiss4/js/node_modules/mongoose/node_modules/mongodb-core/lib/topologies/server.js:503:11)
    at emitOne (events.js:116:13)
    at Pool.emit (events.js:211:7)
    at Connection.<anonymous> (/Users/bill/eiss4/js/node_modules/mongoose/node_modules/mongodb-core/lib/connection/pool.js:326:12)
    at Object.onceWrapper (events.js:317:30)
    at emitTwo (events.js:126:13)
    at Connection.emit (events.js:214:7)
    at Socket.<anonymous> (/Users/bill/eiss4/js/node_modules/mongoose/node_modules/mongodb-core/lib/connection/connection.js:245:50)
    at Object.onceWrapper (events.js:315:30)
    at emitOne (events.js:116:13)
    at Socket.emit (events.js:211:7)
    at emitErrorNT (internal/streams/destroy.js:64:8)
    at _combinedTickCallback (internal/process/next_tick.js:138:11)
    at process._tickCallback (internal/process/next_tick.js:180:9)

मॉडल एक कनेक्शन फ़ंक्शन को उस डेटाबेस के नाम से कॉल करते हैं जिसका वे उपयोग कर रहे हैं (नीचे)। जब तक सर्वर शुरू होता है, तब तक मोंगो चल रहा होता है, डेटाबेस को ऊपर और नीचे फिर से जोड़ता है, ठीक है (त्रुटियों को लॉगिंग)। मुझे इस मुद्दे को पढ़ने का एहसास हुआ कि ड्राइवर प्रारंभिक कनेक्शन को अलग तरह से संभालता है, जो कि कष्टप्रद है। मैं @joeytwiddle के समाधान का प्रयास करने जा रहा हूं, लेकिन मुझे संदेह है कि यह

const allConnections = {};

module.exports = function(dbName) {
  const url = 'http://localhost/' + dbName;
  let conn;
  log.info('initializing database connection to: ' + url);

  conn = allConnections[url];
  if (!conn) {
    log.info('creating new connection for ' + url);
    conn = mongoose.createConnection(url, {
      useMongoClient: true,
      autoReconnect: true,
      autoIndex: false,
      reconnectTries: Number.MAX_SAFE_INTEGER
    });    
    // Log database connection events
    conn.on('connected', () => log.info('Mongoose connection open to ' + url));
    conn.on('error', (err) =>  log.error('Mongoose connection error: ' + err));
    conn.on('disconnected', () => log.error('Mongoose connection disconnected'));  
    allConnections[url] = conn;
  }
  else {
    log.info('reusing existing connection for ' + url);
  }
  return conn;
}

@raythree उपरोक्त मामले में आपको ठीक होना चाहिए क्योंकि आपके पास .on('error') । यदि आप विफल होने पर प्रारंभिक कनेक्शन का पुनः प्रयास करना चाहते हैं, तो मैं आपको इसके लिए बस async/प्रतीक्षा का उपयोग करने की सलाह दूंगा

let conn;
for (let i = 0; i < numRetries; ++i) {
  try {
    conn = await mongoose.createConnection(uri);
    break;
  } catch (error) {}
}

@vkarpov15 आपको उत्तर देने में देरी के लिए क्षमा करें, हम 4.11.14 और 4.13.4 . का उपयोग कर रहे हैं

@jorgecuesta mongoose.connect(uri).catch(err => {})

@ vkarpov15 कनेक्ट () रिटर्न कनेक्शन इंस्टेंस सही है?

const connection = mongoose.connect(uri || undefined, {useMongoClient: true});
connection.once('error', (e) => {
  console.error(e, 'mongoose connection error.');
});
connection.once('connected', () => {
  console.log('mongoose connected');
});

5.0.0 में हमने इसे बदल दिया ताकि mongoose.connect() लगातार एक वादा लौटाए। 4.x में यह एक कनेक्शन उदाहरण देता है लेकिन .then() और .catch() ताकि आप इसे await साथ उपयोग कर सकें

हाय @joeytwiddle।

मुझे हेरोकू में तैनाती पर एक ही समस्या है।
MongoNetworkError: failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connect ECONNREFUSED 127.0.0.1:27017]

12 जुलाई, 2017 को आपकी टिप्पणी पर आपने वर्कअराउंड/समाधान दिया। मैं नेवला/नोड के लिए बिल्कुल नया हूँ। क्या आप मुझे बता सकते हैं कि आपका createConnection फ़ंक्शन किस फ़ाइल में जाना चाहिए?

मैं नेवला चला रहा हूँ: ^5.0.10, नोड: v9.4.0
चियर्स

@juancarlucci आप इसे अपनी पसंद की किसी भी फाइल में डाल सकते हैं। एक नेवला उदाहरण प्राप्त करने के लिए बस इसे कॉल करें और अपने मॉडल बनाने के लिए इसका उपयोग करें।

मैंने उपयोग का एक उदाहरण दिखाने के लिए पिछली टिप्पणी को अपडेट किया है।

@joeytwiddle उपयोग उदाहरण के लिए धन्यवाद! चीयर्स।

जब मैं मोंगो से कनेक्ट करने का प्रयास करता हूं तो यह एक त्रुटि फेंकता है:

connection error: { MongoNetworkError: failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connection 0 to localhost:27017 timed out]
    at Pool.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/topologies/server.js:505:11)
    at emitOne (events.js:116:13)
    at Pool.emit (events.js:211:7)
    at Connection.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/connection/pool.js:329:12)
    at Object.onceWrapper (events.js:317:30)
    at emitTwo (events.js:126:13)
    at Connection.emit (events.js:214:7)
    at Socket.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/connection/connection.js:256:10)
    at Object.onceWrapper (events.js:313:30)
    at emitNone (events.js:106:13)
    at Socket.emit (events.js:208:7)
    at Socket._onTimeout (net.js:420:8)
    at ontimeout (timers.js:482:11)
    at tryOnTimeout (timers.js:317:5)
    at Timer.listOnTimeout (timers.js:277:5)
  name: 'MongoNetworkError',
  message: 'failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connection 0 to localhost:27017 timed out]' }
(node:5453) UnhandledPromiseRejectionWarning: MongoNetworkError: failed to connect to server [localhost:27017] on first connect [MongoNetworkError: connection 0 to localhost:27017 timed out]
    at Pool.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/topologies/server.js:505:11)
    at emitOne (events.js:116:13)
    at Pool.emit (events.js:211:7)
    at Connection.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/connection/pool.js:329:12)
    at Object.onceWrapper (events.js:317:30)
    at emitTwo (events.js:126:13)
    at Connection.emit (events.js:214:7)
    at Socket.<anonymous> (/home/wasd_xyz/Desktop/test/node_modules/mongodb-core/lib/connection/connection.js:256:10)
    at Object.onceWrapper (events.js:313:30)
    at emitNone (events.js:106:13)
    at Socket.emit (events.js:208:7)
    at Socket._onTimeout (net.js:420:8)
    at ontimeout (timers.js:482:11)
    at tryOnTimeout (timers.js:317:5)
    at Timer.listOnTimeout (timers.js:277:5)
(node:5453) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). (rejection id: 1)
(node:5453) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

सुडो सेवा मोंगोडब स्थिति

● mongodb.service - MongoDB Database
   Loaded: loaded (/etc/systemd/system/mongodb.service; enabled; vendor preset: 
   Active: active (running) since Sat 2018-06-23 17:13:28 IST; 13min ago
     Docs: https://docs.mongodb.org/manual
 Main PID: 4224 (mongod)
    Tasks: 24 (limit: 4915)
   CGroup: /system.slice/mongodb.service
           └─4224 /usr/bin/mongod --quiet --config /etc/mongod.conf

Jun 23 17:13:28 Inspiron5370 systemd[1]: Started MongoDB Database.

@pranshuchittora क्या आप अपनी MongoDB कॉन्फ़िग फ़ाइल दिखा सकते हैं? सुनिश्चित करें कि पोर्ट 27017 है। साथ ही, लोकलहोस्ट के बजाय 127.0.0.1 का उपयोग करने का प्रयास करें

लोकलहोस्ट के बजाय आईपी से जुड़ने की कोशिश करें जो आपकी समस्या को ठीक कर देगा।

 let local = "mongodb://127.0.0.1:27017/XXX";
      mongoose.connect(
        local,
        { useNewUrlParser: true }
      );

यदि कनेक्ट करने का पहला प्रयास विफल हो जाता है तो यह हमेशा त्रुटि देता है।
आप इसे नीचे का उपयोग करके बायपास कर सकते हैं (उदाहरण के लिए जब आप यह सुनिश्चित करना चाहते हैं कि ऐप/स्क्रिप्ट शुरू होने से पहले डीबी चल रहा है):

नेवला@5.3.16
@types/ [email protected]
@types/ [email protected]

async function waitForMongoDBStart(uri: string, timeoutMs: number) {

    return new Promise( async (resolve, reject) => {

        let endTime = Date.now() + timeoutMs;


        while (true) {

            let connectionError: Error;

            function errorHandler(err: Error) {
                connectionError = err;
            }
            mongoose.connection.once("error", errorHandler);

            await mongoose.connect(uri, {
                connectTimeoutMS: 5000, // This timeout applies only after connected & connection lost
                useNewUrlParser: true,
                useFindAndModify: false
            });

            // Time for error event propagation
            await wait(0);

            if ( ! connectionError) {
                mongoose.connection.removeListener("error", errorHandler);
                return resolve(); // All OK, connected
            }

            if (connectionError.name !== "MongoNetworkError") {
                return reject(`Unable to connect mongoDB. Details: ${connectionError}`);
            }

            if (Date.now() > endTime) {
                return reject(`Unable to connect mongoBD in ${timeoutMs} ms. Details: ${connectionError}`);
            }

        }

    });
}

@ vkarpov15 यह बहुत ही स्पष्ट व्यवहार है। https://mongoosejs.com/docs/connections.html से :

connectTimeoutMS - How long the MongoDB driver will wait 
before failing its initial connection attempt. 
Once Mongoose has successfully connected, connectTimeoutMS is no longer relevant.

दस्तावेज़ीकरण कहता है कि इसे प्रारंभिक कनेक्शन के साथ काम करना चाहिए, लेकिन ऐसा नहीं है। failed to connect to server त्रुटि के साथ यह तुरंत विफल हो जाता है।

यदि यह मोंगोडीबी ड्राइवरों में लगातार व्यवहार है, तो कुछ विकल्प जैसे reconnectOnInitialFail होना अच्छा होगा जो डिफ़ॉल्ट रूप से false

वर्तमान व्यवहार vkarpov15 द्वारा वर्णित इसके विपरीत है -
ConnectImeoutMS पहले कनेक्शन के बाद ही मायने रखता है (पहले कनेक्शन पर)
उम्मीद है कि डीबी शुरू हो गया है और कनेक्शन स्वीकार कर रहा है, अन्यथा तत्काल
त्रुटि फेंक दी गई है)

सोब।, 22 जीयू 2018 ओ 13:03 दिमित्री किरिलुक नोटिफिकेशन @github.com
नपिसा: (ए):

यदि यह मोंगोडीबी ड्राइवरों में लगातार व्यवहार है, तो यह अच्छा होगा
कुछ विकल्प हैं जैसे reconnectOnInitialFail जो गलत होगा
चूक जाना

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/Automattic/mongoose/issues/5169#issuecomment-449565468 ,
या थ्रेड को म्यूट करें
https://github.com/notifications/unsubscribe-auth/ABY-TjgeI2UqVca050y5YY3zi6w7nMkfks5u7h-vgaJpZM4M-1ur
.

--
वोज्शिएक फ़िदेरेक

मोबाइल: +48 516 661 428

अगर मैं सही ढंग से याद करता हूं, तो कनेक्टटाइमआउटएमएस नेटवर्क की स्थिति और ओएस के आधार पर प्रारंभिक कनेक्शन पर मायने रखता है। प्रारंभिक कनेक्शन के बाद ConnectTimeoutMS कब मायने रखता है?

मेरे मामले में, जब मैं Windows 10 और अल्पाइन लिनक्स (संस्करण अज्ञात) पर स्थानीय होस्ट mongod उदाहरण के लिए पहली कोशिश में कनेक्ट करने के लिए सक्षम नहीं था तत्काल त्रुटि फेंक दिया गया था। मोंगोड का उदाहरण अभी शुरू नहीं हुआ है।
लोकलहोस्ट के अलावा अन्य उदाहरण? कोई भी?

@fider @Jokero मैंने आगे खोला, और मैं सही कह रहा हूं, connectTimeoutMS केवल तब तक मायने रखता है जब तक आप एक प्रारंभिक कनेक्शन नहीं बनाते, socketTimeoutMS बाद में इसे संभाल लेता है। यहाँ MongoDB ड्राइवर में प्रासंगिक कोड है:

• https://github.com/mongodb-js/mongodb-core/blob/177e558be28e5505ce1eb4a94b35d05130d34e76/lib/connection/connection.js#L599
• https://github.com/mongodb-js/mongodb-core/blob/177e558be28e5505ce1eb4a94b35d05130d34e76/lib/connection/connection.js#L604

connectTimeoutMS हमेशा उपयोगी नहीं होता क्योंकि आपको आमतौर पर एक DNS त्रुटि या एक कनेक्शन अस्वीकृत त्रुटि मिलेगी। लेकिन अगर आप कहते हैं, एक टीसीपी सर्वर खोलें जो एक बंदरगाह पर सुनता है लेकिन वास्तव में कुछ भी नहीं करता है:

const net = require('net');

const server = net.createServer();

server.listen(27055);

आप देखेंगे कि connectTimeoutMS शुरू हो गया है:

const assert = require('assert');
const mongoose = require('mongoose');
mongoose.set('debug', true);

const { Schema } = mongoose;

run().then(() => console.log('done')).catch(error => console.error(error.stack));

async function run() {
  await mongoose.connect('mongodb://localhost:27055', {
    useNewUrlParser: true,
    connectTimeoutMS: 1000,
    socketTimeoutMS: 25000
  });
} 

$ time node gh-5169.js 
MongoNetworkError: connection 0 to localhost:27055 timed out
    at Socket.<anonymous> (/mongoose/node_modules/mongodb-core/lib/connection/connection.js:259:7)
    at Object.onceWrapper (events.js:313:30)
    at emitNone (events.js:106:13)
    at Socket.emit (events.js:208:7)
    at Socket._onTimeout (net.js:407:8)
    at ontimeout (timers.js:475:11)
    at tryOnTimeout (timers.js:310:5)
    at Timer.listOnTimeout (timers.js:270:5)

real    0m2.293s
user    0m0.271s
sys 0m0.043s
$ 

कभी-कभी नेटवर्क प्रतिबंधों के कारण, MongoDB url अवरुद्ध हो जाता है, अपने नेटवर्क/इंटरनेट स्रोत को बदलने का प्रयास करें।

https://stackoverflow.com/questions/47958683/cannot-connect-to-mongodb-atlas-through-mongo-shell?answertab=active#tab -top

प्रारंभिक संबंध बनाते समय, (कम से कम) तीन चीजें हो सकती हैं:

1. एक मोंगोडब है और कनेक्शन सफल होता है, याय!

2. सर्वर "कनेक्शन अस्वीकृत" का जवाब देता है, जिसका अर्थ है कि इस पोर्ट पर कोई प्रक्रिया सुनने की प्रक्रिया नहीं है, या एक फ़ायरवॉल है जो कनेक्शन को _सक्रिय रूप से अस्वीकार कर देता है। (यह आमतौर पर तुरंत होता है, और मुझे लगता है कि फ़िडर यही अनुभव कर रहा था।)

3. सर्वर बिल्कुल भी प्रतिक्रिया नहीं देता है, उदाहरण के लिए फ़ायरवॉल _पैसेसिवली गिरा हुआ_ पैकेट या उस आईपी पते पर कोई सर्वर नहीं है। (इस मामले में, vkarpov का connectTimeoutMS अंततः चालू हो जाता है।)

तो टाइमआउट हमेशा उपयोग नहीं किया जाता है। इसका उपयोग केवल तभी किया जाता है जब दिए गए समय में कोई स्पष्ट सफलता या विफलता न हो।

यह नेटवर्किंग में आम है, और किसी असहयोगी व्यक्ति से बात करते समय भी। आपके अनुरोध को दो प्रकार की अस्वीकृति मिल सकती है: "नहीं!" तथा .....

ठोस स्पष्टीकरण @joeytwiddle के लिए धन्यवाद: +1:

mongodb+srv का उपयोग करके प्रतिकृति सेट कनेक्शन के साथ इस व्यवहार को कैसे संभालना चाहिए? जब मेरा प्रतिकृति सेट रोलिंग पुनरारंभ परिदृश्य (डेटाबेस अपडेट) में होता है तो मुझे connect ECONNREFUSED 34.238.xxx.xxx:27017 जैसी त्रुटियां मिलनी शुरू हो जाती हैं।

@esetnik क्या आप useUnifiedTopology: true और Mongoose 5.7.5 का उपयोग कर रहे हैं? हमने एक समस्या #8209 की पहचान की है जो संबंधित हो सकती है।

@vkarpov15 हाँ मैं हूँ! पारितोषिक के लिए धन्यवाद। मैं एकीकृत टोपोलॉजी को अक्षम करने के बाद कुछ परीक्षण चलाऊंगा और अपने निष्कर्षों की रिपोर्ट करूंगा।

नमस्ते। मुझे अपने प्रोजेक्ट में ठीक वैसी ही समस्या है। क्या आपको इसका कोई समाधान मिला है?!

@fdmxfarhan कृपया एक अलग मुद्दा खोलें और समस्या टेम्पलेट का पालन करें।