मुझे लगता है कि यह एक अच्छा सुझाव है। मैं व्यावहारिक कोड लिखने में पब/उप के बारे में काफी उलझन में हूं

इसके लिए +1, मुझे async libev pub/sub . के साथ कठिनाइयां आ रही हैं

ng लिए फ़्लैग किया गया।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "hiredis/hiredis.h"
#include "hiredis/async.h"
#include "hiredis/adapters/libevent.h"

void onMessage(redisAsyncContext *c, void *reply, void *privdata) {
    redisReply *r = reply;
    if (reply == NULL) return;

    if (r->type == REDIS_REPLY_ARRAY) {
        for (int j = 0; j < r->elements; j++) {
            printf("%u) %s\n", j, r->element[j]->str);
        }
    }
}

int main (int argc, char **argv) {
    signal(SIGPIPE, SIG_IGN);
    struct event_base *base = event_base_new();

    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
    if (c->err) {
        printf("error: %s\n", c->errstr);
        return 1;
    }

    redisLibeventAttach(c, base);
    redisAsyncCommand(c, onMessage, NULL, "SUBSCRIBE testtopic");
    event_base_dispatch(base);
    return 0;
}

उबंटू 14.04 पर, इस उदाहरण को सफलतापूर्वक संकलित करने के लिए libevent-dev पुस्तकालयों को स्थापित करने की आवश्यकता है। साथ ही, संकलन के दौरान -levent ध्वज को पारित करने की आवश्यकता है।

दस्तावेज़ीकरण में समस्या यह है कि यह कहीं भी नहीं लिखा है कि आप किसी चीज़ के लिए SUBSCRIBE कर सकते हैं, लेकिन फिर अन्य घटनाओं की सदस्यता लेने के अलावा और कुछ नहीं कर सकते।

कुछ इस तरह का प्रयास करें

redisAsyncCommand(c, onMessage, NULL, "SUBSCRIBE testtopic");
redisAsyncCommand(c, onAnotherMessage, NULL, "SUBSCRIBE anothertopic");
redisAsyncCommand(c, onReply, NULL, "SET toto 5");
redisAsyncCommand(c, onReply, NULL, "PUBLISH testtopic \"hello\"");
redisAsyncCommand(c, onReply, NULL, "GET toto");

और केवल 2 पहले आदेश ही काम करेंगे। दूसरा REDIS_OK साथ प्रतिक्रिया करता है लेकिन onReply() कॉलबैक को NULL उत्तर मिलता है।

चीजों को सही ढंग से करने का एकमात्र तरीका 2 रेडिस संदर्भों का उपयोग करना है, एक सब्सक्राइबर्स (और मॉनिटर) के लिए, दूसरा बाकी के लिए। शायद इस सीमा को दर्शाने के लिए दस्तावेज़ को अद्यतन किया जाना चाहिए?

क्या प्रत्येक एपीआई के लिए कोई डॉक्टर है?

जब सॉकेट अंततः बंद हो जाता है तो आप किसी ईवेंट को कैप्चर कैसे करते हैं?

जब सॉकेट अंततः बंद हो जाता है तो आप किसी ईवेंट को कैप्चर कैसे करते हैं?

या आप कैसे तेजी से टाइमआउट का पता लगाते हैं और एक नया कनेक्शन फिर से करते हैं? उदाहरण के लिए यदि बीच में फ़ायरवॉल कनेक्शन बंद कर देता है और बाद में पैकेट छोड़ देता है।

उस कनेक्शन पर केवल सदस्यता लेने से यह असंभव हो जाता है क्योंकि मैं समझता हूं कि टाइमआउट की जांच के लिए कुछ भेजना है। इसके अलावा टीसीपी रखवाले एएसवाईएनसी के साथ मौजूद नहीं लगते हैं और वैसे भी डॉकटर कंटेनर के अंदर लिनक्स पर ठीक से कॉन्फ़िगर करना मुश्किल होता है उदाहरण के लिए (अंतराल, पुनः प्रयास, आदि)

आम तौर पर टीसीपी सॉकेट के साथ आप सॉकेट पर एक छोटा पढ़ने/लिखने का समय समाप्त कर सकते हैं और कुछ भेजने के बाद आप देख सकते हैं कि यह समय समाप्त हो गया है और जल्दी से किसी अन्य सर्वर से फिर से कनेक्ट करने का प्रयास करें या कुछ और करें ...

अगर कुछ और था जो अतुल्यकालिक रूप से एक पिंग कमांड भेज सकता है और डिस्कनेक्शन को ट्रिगर करने के लिए पढ़ने/लिखने के टाइमआउट को कॉन्फ़िगर कर सकता है जो अच्छा होगा।

@ गेरपोर्गल
अपने स्वयं के कार्यान्वयन में मैंने redisAsyncSetDiconnectCallback का उपयोग किया मैंने इस तंत्र पर शोध नहीं किया है कि यह कैसे काम करता है।
https://github.com/nidhhoggr/temproxy_sentinel/commit/602e07cfdbd57a307ff008e8e9d41909ac34b004

मेरे मामले में डिस्कनेक्ट घटना को इस मामले के लिए पर्याप्त तेजी से (या कुछ मामलों में बिल्कुल नहीं) निकाल दिया जाता है, जिसे मैं हमेशा "साइलेंट डिस्कनेक्शन" कहता हूं, आम तौर पर इसमें लंबा समय लगता है (मैंने 5 से अधिक इंतजार किया मिनट और घटना कभी नहीं मिली, लेकिन फिर 10-15 मिनट के बाद मुझे आखिरकार एक मिल गया)

विषय के बारे में कुछ और पढ़ने के बाद, मैंने देखा कि आप सदस्यता लेते समय भी पिंग कमांड कर सकते हैं, और इस पोस्ट को इस तरह का उल्लेख मिला है कि आप अपने स्वयं के पिंग प्रतिक्रिया ईवेंट की सदस्यता ले सकते हैं जैसे कि यह एक प्रकाशित संदेश था:
https://github.com/redis/hiredis/issues/351

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

सामान्य संदेश वितरण को अतुल्यकालिक रूप से संभालने के दौरान आप पिंग के लिए टाइमर घटनाओं का उपयोग करके लिबवेंट और हायरडिस का उपयोग करके एक पूर्ण एसिंक सदस्यता कार्यान्वयन कर सकते हैं।

@ गेरपोर्गल
यह बहुत मददगार था!
किसी भी मौके से आपने की-स्पेस इवेंट नोटिफिकेशन के लिए उसी redisAsyncCommand/Async संदर्भ तंत्र का उपयोग करने का प्रयास किया?
मैं उस हिस्से को काम करने की कोशिश कर रहा हूं; लेकिन दुर्भाग्य से संदेश नहीं मिल रहा है।

क्या आपने यह कोशिश की है?

redis-cli config set notify-keyspace-events KEA

redisAsyncCommand(c, subscribeCallback, NULL, "PSUBSCRIBE __key*__:*");

@ जो-एट-स्टार्टअपमीडिया
धन्यवाद! मैंने पहले ही यह कोशिश कर ली है .. और ऐसा लगता है कि मैं वापस आ रहा हूं, पहले प्रतिक्रिया की सदस्यता लें।
डेटा में कोई भी अपडेट वास्तव में कॉलबैक में प्राप्त नहीं होता है।
यहाँ नमूना कोड है:

`

SUBSCRIBE_CHANNEL "SUBSCRIBE URLC_Updates" को परिभाषित करें

SUBSCRIBE_KEYEVENT परिभाषित करें "PSUBSCRIBE '__key __: '"

SCAN_DB परिभाषित करें "SCAN %d COUNT 100"

QUERY_KEY परिभाषित करें "%s प्राप्त करें"

शून्य
onPubsubMessage (redisAsyncContext * c, शून्य * उत्तर, शून्य * निजी डेटा)
{
redisReply *r = (redisReply *) उत्तर;
अगर (उत्तर == NULL) वापसी;

/* What if reply type is something else... */
if (r->type == REDIS_REPLY_ARRAY) {

    for (int j = 0; j < r->elements; j++) {
        if (r->element[j]->type == REDIS_REPLY_STRING) { 
            myPubsubFile.open(PUBSUB_FILE, fstream::in | fstream::out | fstream::app);
            myPubsubFile << r->element[j]->str << endl;
            myPubsubFile.close();
        } else if (r->element[j]->type == REDIS_REPLY_INTEGER) {
            cout << "Integer : "<< r->element[j]->integer << endl;
        }
    }
}
return;

}
शून्य
onKeyspaceMessage (redisAsyncContext * c, शून्य * उत्तर, शून्य * निजी डेटा)
{
redisReply *r = (redisReply *) उत्तर;
अगर (उत्तर == NULL) वापसी;

cout << "Got keyspace event notification from REDIS.. " << endl;

/* What if reply type is something else... */
if (r->type == REDIS_REPLY_ARRAY) {
    cout << "Type is an array.. " << endl;
    cout << "Number of elements here: " << r->elements << endl;

    for (int j = 0; j < r->elements; j++) {
        cout << "\t\t Type for element : " << r->element[j]->type << endl;
        if (r->element[j]->type == REDIS_REPLY_STRING) {
            cout << "\t\t\t" << r->element[j]->str << endl;
        } else if (r->element[j]->type == REDIS_REPLY_INTEGER) {
            cout << "\t\t\t" << "Integer : "<< r->element[j]->integer << endl;
        }   
    }   
} else {
    cout << "This is the type for response : " << r->type << endl;
}   
return;

}
शून्य*
pubsubRecipient(void* arg)
{
स्ट्रक्चर इवेंट_बेस * बेस = इवेंट_बेस_न्यू ();

redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
if (c->err) {
    printf("error: %s\n", c->errstr);
    return NULL;
}   

redisLibeventAttach(c, base);
redisAsyncCommand(c, onPubsubMessage    , NULL, SUBSCRIBE_CHANNEL);
redisAsyncCommand(c, onKeyspaceMessage  , NULL, SUBSCRIBE_KEYEVENT);

`

PS कॉन्फ़िगरेशन भाग, जो REDIS में की-स्पेस नोटिफिकेशन को सक्षम करता है, एक अलग प्रक्रिया में है; और मैं उस कॉन्फ़िगरेशन का प्रभाव देख सकता हूं, जब मैं अलग टर्मिनल में रेडिस-क्ली का उदाहरण चलाता हूं।

क्षमा करें अगर मुझे यहां कुछ याद आ रहा है लेकिन आपकी मुख्य घटना सदस्यता स्ट्रिंग है:

 "PSUBSCRIBE 'key*:*'"

क्या उस पैटर्न से मेल खाने के लिए इसे निम्नलिखित में नहीं बदला जाना चाहिए?

"PSUBSCRIBE __key*__:*"

Ohk .. कुछ अजीब इस संपादक के साथ चल रहा है ... जब मैं नकल की और मेरी कोड चिपकाया आसपास कुंजी अंडरस्कोर उपस्थित थे।

फिर भी, ऐसा लगता है कि मुद्दा मेरे _ _ कुंजी * _ _ पैटर्न के आसपास था -> '' <- (एकल उद्धरण)।
redis-cli उन्हें बिना किसी समस्या के स्वीकार करता है; लेकिन जब हम इसे रेडिस कमांड के जरिए भेजते हैं, तो यहां कुछ गड़बड़ है।

पुराने मुद्दों से गुजरना। एक उदाहरण सदियों पहले विकी में जोड़ा गया था (धन्यवाद @aluiken)