Node-redis: त्रुटि को फ्लश करने के बाद retry_strategy रीसेट नहीं होता है

retry_strategy के लिए प्रलेखन के माध्यम से, ऐसा प्रतीत होता है कि node_redis केवल तभी पुन: कनेक्ट करने का प्रयास करेगा यदि फ़ंक्शन कोई संख्या देता है।

यदि आप इस फ़ंक्शन से कोई संख्या लौटाते हैं, तो पुनः प्रयास उस समय के ठीक बाद मिलीसेकंड में होगा।

आपके मामले में आप एक गैर नंबर लौटा रहे हैं, जो पुन: कनेक्ट करने के प्रयास के लिए आवश्यकताओं को पूरा नहीं करता है।

यदि आप एक गैर-संख्या लौटाते हैं, तो आगे कोई पुन: प्रयास नहीं होगा और सभी ऑफ़लाइन आदेश त्रुटियों से भर जाते हैं।

मैं जिस प्रवाह की तलाश कर रहा हूं वह है: डिस्कनेक्ट होने पर, 1 सेकंड के अंतराल के साथ 3 बार कनेक्ट करने का पुनः प्रयास करें। यदि तीसरी बार यह अभी भी डिस्कनेक्ट हो गया है, तो इसे सभी बकाया आदेशों को एक त्रुटि के साथ वापस करना चाहिए। मैं नहीं चाहता कि यह पुन: कनेक्ट करने का प्रयास करना बंद करे।

README.md में दिए गए उदाहरण के संशोधित संस्करण के साथ, आप जो खोज रहे हैं उसे प्राप्त करने में सक्षम होना चाहिए। हालांकि, एक बार 3 के अधिकतम प्रयास समाप्त हो जाने के बाद, क्लाइंट स्वचालित रूप से अगले आदेश पर पुन: कनेक्ट करने का प्रयास नहीं करेगा। मेरा मानना ​​है कि आपको मैन्युअल रूप से createClient() फिर से कॉल करने की आवश्यकता होगी।

const client = redis.createClient({
    url: 'redis://localhost:6379',
    retry_strategy: (options) => {
        if (options.times_connected >= 3) {
            // End reconnecting after a specific number of tries and flush all commands with a individual error
            return new Error('Retry attempts exhausted');
        }
        // reconnect after
        return 1000;
    }
});

हां, मैंने प्रयास छोड़ दिए क्योंकि इससे यहां कोई फर्क नहीं पड़ता।

तो मूल रूप से आपका मतलब है:

let client = createClient();
function createClient () {
  return redis.createClient({
    url: 'redis://localhost:6379',
    retry_strategy: (options) => {
      client = createClient();
      return new Error('Retry attempts exhausted');
    }
  });
}

जिसका अर्थ है कि मैं अब अपने कोड में अपने रेडिस क्लाइंट को पास नहीं कर सकता?

आप रेडिस क्लाइंट के सिंगलटन इंस्टेंस को प्रबंधित करने के लिए एक लाइट रैपर बना सकते हैं।

// redisClient.js

let redis = require("redis");

let client = null;

const options = {
    url: 'redis://localhost:6379',
    retry_strategy: (options) => {
        client = null;
        return new Error("Redis client connection dropped.");
    }
};

module.exports = {
    getClient: () => {
        if (client == null) {
            client = redis.createClient(options);
        }
        return client;
    }
};

काम में लाना:

// usage

let client = require("redisClient.js");

client.getClient().get("some key");
client.getClient().set("some key", "some value");

मुझे लगता है कि यह पुनर्प्रयास रणनीति में createClient() को कॉल करने के समान ही है, लेकिन मैं उस पद्धति का बहुत बड़ा प्रशंसक नहीं हूं।

यदि आप getClient() हर समय कॉल करने की आवश्यकता को कम करना चाहते हैं, तो आप एक बड़ा रैपर बना सकते हैं जो सभी रेडिस कॉल को लपेटता है जैसे get() , set() , आदि, और उन तरीकों में से प्रत्येक में getClient() कॉल करें। हालांकि, getClient() यह विधि उत्सुकता के बजाय आलस्य से कनेक्शन प्रबंधित करने का एक बहुत ही सामान्य तरीका है।

निश्चित रूप से, लेकिन फिर यह पुस्तकालय किसी भी पुनः प्रयास की रणनीति क्यों प्रदान करता है यदि आपको इसे किसी अतिरिक्त पुनः प्रयास आवरण में लपेटना है?

मैं लेखक नहीं हूं इसलिए मैं retry_strategy के विशिष्ट कार्यान्वयन के पीछे की प्रेरणाओं के बारे में निश्चित नहीं हूं। नोड_रेडिस के अपने स्वयं के उपयोग में मैंने पाया है कि वर्तमान में उपयोगी होने के लिए retry_strategy की कार्यक्षमता है, लेकिन मैं मानता हूं कि इसमें स्वचालित रूप से पुन: प्रयास करने की क्षमता की कमी है, चाहे कुछ भी हो। मेरे उपयोग में मैंने लगातार retry_strategy से एक नंबर लौटाया है और कभी भी कोई त्रुटि नहीं लौटाता है, क्योंकि मैं हमेशा चाहता हूं कि कनेक्शन का प्रयास किया जाए। हालांकि मैं retry_strategy के भीतर से त्रुटियों को लॉग करता हूं।

इस जैसे किसी और के बारे में क्या राय है? https://github.com/viglucci/node_redis/tree/feature-reconnect-after-flush#retry_strategy -example

var client = redis.createClient({
    retry_strategy: function (options) {
        if (options.error && options.error.code === 'ECONNREFUSED') {
            // End reconnecting on a specific error and flush all commands with a individual error
            return new Error('The server refused the connection');
        }
        if (options.total_retry_time > 1000 * 60 * 60) {
            // End reconnecting after a specific timeout and flush all commands with a individual error
            return new Error('Retry time exhausted');
        }
        // attempt reconnect after retry_delay, and flush any pending commands
        return {
            retry_delay: Math.min(options.attempt * 100, 3000),
            error: new Error('Your custom error.');
        }
    }
});

अवधारणात्मक रूप से बहुत समझ में आता है। इसे दो रणनीतियों में विभाजित करके इसे लागू करने का एक और तरीका हो सकता है:

var client = redis.createClient({
  // this strategy handles the pending redis commands when the connection goes down
  flush_strategy (options) {
    if (options.attempt >= 3) {
      // flush all pending commands with this error
      return new Error('Redis unavailable')
    }
    // let the connection come up again on its own
    return null;
  },
  // this strategy handles the reconnect of a failing redis
  retry_strategy (options) {
    if (options.total_retry_time > 1000 * 60 * 60) {
      // The connection is never going to get up again
      // kill the client with the error event
      return new Error('Retry time exhausted');
    }
    // attempt reconnect after this delay
    return Math.min(options.attempt * 100, 3000)
  }
});

मुझे वास्तव में flush_strategy नाम पसंद नहीं है लेकिन कोई कुछ बेहतर कर सकता है।

ओह दिलचस्प। आप यहां जो सुझाव दे रहे हैं वह वर्तमान retry_strategy का नाम बदलकर connection_strategy और मौजूदा retry_strategy का उपयोग करने जैसा है जिसे आपने flush_strategy रूप में संदर्भित किया है।

var client = redis.createClient({
    // this strategy handles reconnection
    connection_strategy (options) {
        if (options.total_retry_time > 1000 * 60 * 60) {
            // The connection is never going to get up again
            // kill the client with the error event
            return new Error('Retry time exhausted');
        }
        // attempt reconnect after this delay
        return Math.min(options.attempt * 100, 3000)
    },
    // this strategy handles the pending redis commands when the connection goes down
    retry_strategy (options) {
        if (options.attempt >= 3) {
            // flush all pending commands with this error
            return new Error('Redis unavailable');
        }
        // let the client attempt the commands once a connection is available
        return null;
    },
});

कार्यान्वित: https://github.com/viglucci/node_redis/tree/feature-connection-strategy#retry_strategy -example

@ जेनपोट क्या आप उस उपयोग के मामले को विस्तृत कर सकते हैं जहां इसकी आवश्यकता है? मैंने इसे उपयोग में आसान बनाने के लिए विकल्पों की मात्रा कम करने की कोशिश की और retry_strategy पहले से ही एक शक्तिशाली विकल्प है।

@विग्लुची यहां उत्तर देने और अच्छी प्रतिक्रिया देने के लिए धन्यवाद! मैं व्यक्तिगत रूप से किसी वस्तु को वापस करने के आपके सुझाव को पसंद करता हूं यदि इसे लागू किया जाएगा। यह वास्तव में एक महत्वपूर्ण परिवर्तन नहीं होगा, भले ही मैं जल्द ही एक v3 शाखा खोलने की योजना बना रहा हूँ। वर्तमान में कई नई सुविधाओं को लागू करने में बहुत परेशानी होती है और सभी बहिष्कृत चीजों को हटाने से बहुत मदद मिलेगी।

@BridgeAR यह बहुत अधिक है कि अभी, अगर किसी कारण से रेडिस कनेक्शन टूट जाता है, तो मेरे सभी आदेश बस लटक जाते हैं। मान लीजिए कि मेरे पास उस ऑपरेशन के लिए फ़ॉलबैक है जो रेडिस कर रहा है तो वह फ़ॉलबैक भी हैंग हो जाता है। मैं कुछ पुनर्प्रयासों के बाद रेडिस को एक त्रुटि वापस करना चाहता हूं, जिसे मैं फॉलबैक पकड़ सकता हूं और नियोजित कर सकता हूं। इसका मतलब यह नहीं है कि मैं नहीं चाहता कि क्लाइंट कनेक्ट करने का प्रयास करना बंद कर दे। Redis एक मिनट में वापस आ सकता है।

मुझे वर्तमान व्यवहार का बिंदु नहीं दिख रहा है। आप पुनः प्रयास करने वाले हैंडलर में एक त्रुटि लौटाते हैं और फिर आपका ग्राहक हमेशा के लिए मर जाता है। जब तक आप प्रत्येक कमांड के लिए क्लाइंट नहीं बनाते हैं, तब तक उस तरह के व्यवहार की आवश्यकता किसे है?

या मैं उस संभोग के लिए उपयोग के मामले को नहीं देख सकता

@BridgeAR धन्यवाद। ठीक है अगर आपके पास सरल कार्यों के साथ "वी 3 के लिए सड़क" रोडमैप है जैसे कॉन्फ़िगरेशन पैरा के लिए समर्थन हटाएं/बहिष्करण चेतावनियां हटाएं, आदि, विचार पुल अनुरोध सबमिट करने में रुचि रखते हैं। शायद अतिरिक्त रेडिस कमांड के लिए समर्थन जोड़ने जैसे बड़े काम से निपटने में सक्षम नहीं होगा, लेकिन साधारण घर की सफाई की चीजें जो मैं शायद कर सकता था अगर वे पीआर के लिए खुले थे तो एक बार वी 3 फीचर शाखा उपलब्ध थी।

@ विग्लुची मैंने एक सहयोगी के रूप में आमंत्रित किया। मैं जल्द ही एक योजना बनाने जा रहा हूँ

+1 इस समस्या के समाधान के लिए।

मैं एक्सप्रेस का उपयोग कर रहा हूं, और जबकि मेरा retry_strategy अभी भी भविष्य में फिर से प्रयास करने और कनेक्ट करने के लिए पूर्णांक लौटा रहा है, कमांड (और वेब अनुरोध) कुछ फेंकने के बजाय ढेर/बैक-अप जारी रखते हैं ताकि वे प्राप्त कर सकें उनके जीवन के साथ ... और उम्मीद है कि रणनीति को छोड़ने या जो कुछ भी कहने से पहले एक कनेक्शन _ अंततः_ फिर से स्थापित हो गया है।

क्या यह पूरा किया जा सकता है? @Janpot क्या आपको इस स्थिति को हल करने के लिए वर्तमान में कुछ भी उपलब्ध है?

शायद enable_offline_queue और/या retry_unfulfilled_commands विकल्पों के साथ कुछ इसे पूरा कर सकता है?

आपकी कड़ी मेहनत और मदद के लिए सभी को धन्यवाद!

यहां त्वरित अपडेट।
मैंने अपने enable_offline_queue = false को अपने createClient विकल्पों में जोड़ा है, और ऐसा लगता है कि मैंने वही किया है जो मैं चाहता था, जो है:
" retry_strategy फ़ंक्शन के आधार पर मेरे रेडिस सर्वर से पुन: कनेक्ट करने का प्रयास जारी रखें, लेकिन इस बीच क्लाइंट का उपयोग करने के प्रयासों के जवाब में तुरंत त्रुटियां फेंक दें। फिर, यदि पुन: कनेक्ट करने में सक्षम है, तो बस फिर से काम करना शुरू करें ".

FYI करें: get कॉल पर निम्न त्रुटि को दूर करता है: AbortError: SET can't be processed. Stream not writeable.

डीबी और मेरे ऐप के बीच सीधी परत के रूप में मेरे उपयोग के लिए, यह ठीक होना चाहिए। यह जानना अच्छा होगा कि क्या अधिक "मजबूत" समाधान संभव है जहां:

• क्लाइंट retry_strategy आधार पर पुन: कनेक्ट करने का प्रयास जारी रखता है
• क्लाइंट के कॉल/उपभोक्ता/उपयोगकर्ता फिर से कनेक्ट होने पर हैंग नहीं होते हैं
• कमांड को अभी भी कतारबद्ध किया जा सकता है (सशर्त?)

शायद यहाँ पर विचार करने के लिए बहुत सारे कठिन परिदृश्य हैं ...

@न्यूहाउस ,

इसका उल्लेख करने के लिए धन्यवाद। हम अपने आवेदन के लिए समान व्यवहार चाहते थे और आपके समाधान ने कॉलर को तुरंत एक त्रुटि वापस करने के लिए काम किया, लेकिन हमें अनिश्चित काल तक कनेक्ट करने के लिए पुनः प्रयास करने की अनुमति दी।

धन्यवाद @newhouse , मुझे यकीन नहीं है कि मैंने इसे कभी पाया होगा।

आईएमओ यह डिफ़ॉल्ट व्यवहार होना चाहिए, या कम से कम retry_strategy आसपास दस्तावेज़ों में स्पष्ट रूप से कॉल किया जाना चाहिए। मुझे बताएं कि क्या आपको लगता है कि उत्तरार्द्ध उचित है, और मैं दस्तावेज़ों को जोड़ने के लिए एक पीआर खोलूंगा।

@bwhitty किसी से भी एक डॉक्स पीआर का स्वागत किया जाएगा

enable_offline_queue = false का उपयोग करने के साथ एक गोचा यह है कि createClient पर कॉल करने के ठीक बाद भेजे गए आदेश, लेकिन वास्तव में कनेक्शन खोले जाने से पहले भी विफल हो जाएगा।

enable_offline_queue = false का उपयोग करने के साथ एक गोचा यह है कि createClient पर कॉल करने के ठीक बाद भेजे गए आदेश, लेकिन वास्तव में कनेक्शन खोले जाने से पहले भी विफल हो जाएगा।

@jkirkwood लगता है जैसे आप ready ईवेंट (या इसी तरह की उपयुक्त घटना) उत्सर्जित होने तक अपना पहला आदेश भेजने में देरी करना चाहते हैं?