Google प्रोटोकॉल बफ़र यादृच्छिक संदेश प्रबंधक

एक मुफ्त दिन दिखाई दिया, और मैंने Google :: protobuf पुस्तकालय के साथ खेलने का फैसला किया। यह लाइब्रेरी संरचित डेटा को एन्कोड और डिकोड करने की क्षमता प्रदान करती है। इस लाइब्रेरी के आधार पर, मैं एक साधारण डिस्पैचर का निर्माण करूँगा जो किसी भी संदेश को संसाधित कर सकता है। इस डिस्पैचर की ख़ासियत यह है कि यह भेजे गए संदेशों के प्रकारों को नहीं जानता होगा, और केवल पंजीकृत हैंडलर का उपयोग करके संदेशों को संसाधित करेगा।

प्रोटोबुफ़ पुस्तकालय का संक्षिप्त विवरण

तो, पहले, संक्षिप्त रूप से google :: protobuf पुस्तकालय पर विचार करें, यह दो घटकों में आता है:
वास्तव में पुस्तकालय ही + हेडर फाइलें
* .proto फ़ाइल संकलक - संदेश विवरण से एक C ++ वर्ग उत्पन्न करता है (यह अन्य प्रोग्रामिंग भाषाओं के लिए उत्पन्न करना भी संभव है: जावा, पायथन, आदि)
संदेश का एक विवरण एक अलग फ़ाइल में बनाया गया है जिसमें से कक्षा उत्पन्न होगी, वाक्यविन्यास बहुत सरल है:

package sample.proto; message ServerStatusAnswer { optional int32 threadCount = 1; repeated string listeners = 2; } 

यहां हम ServerStatusAnswer संदेश का वर्णन करते हैं, जिसमें दो वैकल्पिक फ़ील्ड हैं:

• थ्रेडकाउंट - वैकल्पिक पूर्णांक पैरामीटर
• श्रोता - एक वैकल्पिक स्ट्रिंग जिसे कई बार दोहराया जा सकता है

यह विवरण संतुष्ट है, उदाहरण के लिए, निम्न संदेश द्वारा:

 ServerStatusAnswer { threadCount = 3 listeners = { "one", "two" } } 

वास्तव में, प्रोटोबॉफ़ प्रारूप द्विआधारी है, यहां मैंने केवल आसानी से धारणा के लिए एक पठनीय प्रारूप में एक संदेश दिया

संकलक स्वचालित रूप से इस तरह के संदेशों को क्रमबद्ध करने और deserialize करने के लिए C ++ कोड बनाता है। प्रोटोबॉफ़ लाइब्रेरी अतिरिक्त सुविधाएँ भी प्रदान करती है: किसी फाइल को, एक धारा को, एक बफर को क्रमबद्धता।

मैं एक निर्माण प्रणाली के रूप में CMake का उपयोग करता हूं और इसका पहले से ही प्रोटोबॉफ़ समर्थन है:

 cmake_minimum_required(VERSION 2.8) project(ProtobufTests) find_package(Protobuf REQUIRED) include_directories(${PROTOBUF_INCLUDE_DIRS}) include_directories(${CMAKE_CURRENT_BINARY_DIR}) #... set (ProtobufTestsProtoSources Message.proto ServerStatus.proto Echo.proto ) #... PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HDRS ${ProtobufTestsProtoSources}) add_executable(ProtobufTests ${ProtobufTestsSources} ${PROTO_SRCS} ${PROTO_HDRS}) target_link_libraries(ProtobufTests #... ${PROTOBUF_LIBRARY} ) 

PROTOBUF_GENERATE_CPP - यह मैक्रो प्रत्येक * .proto फ़ाइल के लिए प्रोटोक कंपाइलर को कॉल करता है, और असेंबली cpp और h फ़ाइलों को उत्पन्न करता है जो असेंबली में जोड़े जाते हैं।
सब कुछ स्वचालित रूप से किया जाता है, और आपको कोई अतिरिक्त स्क्वैट्स करने की आवश्यकता नहीं है (अंडर निक्स के तहत आपको अतिरिक्त थ्रेड पैकेज और लिंकर के लिए संबंधित ध्वज की आवश्यकता हो सकती है)।

प्रबंधक विवरण

मैंने एक संदेश प्रबंधक लिखने की कोशिश करने का फैसला किया जो किसी प्रकार के संदेश को स्वीकार करता है, उपयुक्त हैंडलर को कॉल करता है और प्राप्त संदेश पर प्रतिक्रिया भेजता है। इस मामले में, डिस्पैचर को उसके भेजे गए संदेशों के प्रकारों को नहीं जानना चाहिए। यह आवश्यक हो सकता है यदि प्रेषणकर्ता ऑपरेशन के दौरान उपयुक्त हैंडलर जोड़ता है या हटाता है (उदाहरण के लिए, उपयुक्त एक्सटेंशन मॉडल, * .dll, * .so लोड करके)।

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

 package sample.proto; message Message { required string id = 1; optional bytes data = 2; } 

हम अपने संदेश को अन्य संदेश के अंदर पैक करेंगे:

• आवश्यक फ़ील्ड आईडी में संदेश के लिए एक विशिष्ट पहचानकर्ता होता है
• वैकल्पिक डेटा फ़ील्ड में हमारा संदेश होता है

इस प्रकार, हमारा प्रेषणकर्ता आईडी फ़ील्ड में संबंधित संदेश हैंडलर की खोज करेगा:

 #ifndef MESSAGEDISPATCHER_H #define MESSAGEDISPATCHER_H #include <map> #include <stdexcept> #include <boost/noncopyable.hpp> #include <boost/smart_ptr/shared_ptr.hpp> #include "message.pb.h" class MessageProcessingError: public std::runtime_error { public: MessageProcessingError(const std::string & e): std::runtime_error(e) { } }; class MessageProcessorBase: private boost::noncopyable { public: virtual ~MessageProcessorBase() { } virtual std::string id() const = 0; virtual sample::proto::Message process(const sample::proto::Message & query) = 0; }; typedef boost::shared_ptr<MessageProcessorBase> MessageProcessorBasePtr; class MessageDispatcher { public: MessageDispatcher(); void addProcessor(MessageProcessorBasePtr processor); sample::proto::Message dispatch(const sample::proto::Message & query); typedef std::map<std::string, MessageProcessorBasePtr> DispatcherImplType; const DispatcherImplType & impl() const; private: DispatcherImplType mImpl; }; #endif // MESSAGEDISPATCHER_H 

लेकिन अब हमें लगता है कि प्रत्येक हैंडलर को नमूना :: प्रोटो :: संदेश संदेश को अपने संदेश में अनपैक करना होगा। और इस प्रक्रिया को ऐसे प्रत्येक हैंडलर के लिए दोहराया जाएगा। हम कोड डुप्लिकेट से बचना चाहते हैं, तो चलिए टाइप एरासुर पैटर्न लेते हैं। यह पैटर्न आपको एक सामान्य इंटरफ़ेस के पीछे संसाधित होने वाली इकाई के प्रकार को छिपाने की अनुमति देता है, हालांकि, प्रत्येक हैंडलर केवल ज्ञात विशिष्ट प्रकार के साथ काम करेगा।

इसलिए कार्यान्वयन बहुत सरल है:

 template <typename ProtoQueryT, typename ProtoAnswerT> class ProtoMessageProcessor: public MessageProcessorBase { public: virtual sample::proto::Message process(const sample::proto::Message & query) { ProtoQueryT underlyingQuery; if (!underlyingQuery.ParseFromString(query.data())) { throw MessageProcessingError("Failed to parse query: " + query.ShortDebugString()); } ProtoAnswerT underlyingAnswer = doProcessing(underlyingQuery); sample::proto::Message a; a.set_id(query.id()); if (!underlyingAnswer.SerializeToString(a.mutable_data())) { throw MessageProcessingError("Failed to prepare answer: " + underlyingAnswer.ShortDebugString()); } return a; } private: virtual ProtoAnswerT doProcessing(const ProtoQueryT & query) = 0; }; 

हम आभासी फ़ंक्शन प्रक्रिया को परिभाषित करते हैं, लेकिन वर्चुअल फ़ंक्शन doProcess भी जोड़ते हैं, जो पहले से ही हमारे विशिष्ट संदेशों के साथ काम करता है! यह तकनीक टेम्पलेट्स के तात्कालिकता के तंत्र पर आधारित है: टेम्पलेट के वास्तविक उपयोग के समय प्रकारों को प्रतिस्थापित किया जाता है, और घोषणा के समय नहीं। और जब से यह वर्ग MessageProcessorBase से विरासत में मिला है, हम इस वर्ग के वंशजों को सुरक्षित रूप से हमारे डिस्पैचर में भेज सकते हैं। यह भी ध्यान दिया जाना चाहिए कि यह वर्ग त्रुटियों के मामले में हमारे विशिष्ट संदेशों को क्रमबद्ध करता है और उनका अपवाद करता है।

खैर, अंत में, मैं इस डिस्पैचर का उपयोग करने का एक उदाहरण दूंगा, उदाहरण के लिए, हमारे पास दो प्रकार के संदेश हैं:

 package sample.proto; message ServerStatusQuery { } message ServerStatusAnswer { optional int32 threadCount = 1; repeated string listeners = 2; } 

 package sample.proto; message EchoQuery { required string msg = 1; } message EchoAnswer { required string echo = 1; } 

जैसा कि आप विवरण से देख सकते हैं, ये संदेश सर्वर की आंतरिक स्थिति (सर्वरस्टैटस) का अनुरोध करते हैं, और बस प्राप्त अनुरोध (इको) लौटाते हैं। स्वयं संचालकों का कार्यान्वयन तुच्छ है, मैं केवल ServerStatus का कार्यान्वयन दूंगा:

 #ifndef SERVERSTATUSMESSAGEPROCESSOR_H #define SERVERSTATUSMESSAGEPROCESSOR_H #include "MessageDispatcher.h" #include "ServerStatus.pb.h" class ServerStatusMessageProcessor: public ProtoMessageProcessor<sample::proto::ServerStatusQuery, sample::proto::ServerStatusAnswer> { public: typedef sample::proto::ServerStatusQuery query_type; typedef sample::proto::ServerStatusAnswer answer_type; ServerStatusMessageProcessor(MessageDispatcher * dispatcher); virtual std::string id() const; private: MessageDispatcher * mDispatcher; virtual answer_type doProcessing(const query_type & query); }; #endif // SERVERSTATUSMESSAGEPROCESSOR_H 

कार्यान्वयन खुद:

 #include "ServerStatusMessageProcessor.h" using namespace sample::proto; ServerStatusMessageProcessor::ServerStatusMessageProcessor(MessageDispatcher * dispatcher) : mDispatcher(dispatcher) { } std::string ServerStatusMessageProcessor::id() const { return "ServerStatus"; } ServerStatusAnswer ServerStatusMessageProcessor::doProcessing(const ServerStatusQuery & query) { ServerStatusAnswer s; s.set_threadcount(10); typedef MessageDispatcher::DispatcherImplType::const_iterator md_iterator; const MessageDispatcher::DispatcherImplType & mdImpl = mDispatcher->impl(); for (md_iterator it = mdImpl.begin(); it != mdImpl.end(); ++it) { s.add_listeners(it->first); } return s; } 

यहां बताया गया है कि यह कैसे काम करता है:

 #include "MessageDispatcher.h" #include "ServerStatusMessageProcessor.h" #include "EchoMessageProcessor.h" #include <iostream> #include <boost/smart_ptr/make_shared.hpp> using namespace sample::proto; int main() { try { MessageDispatcher md; md.addProcessor(boost::make_shared<ServerStatusMessageProcessor>(&md)); md.addProcessor(boost::make_shared<EchoMessageProcessor>()); Message q; q.set_id("ServerStatus"); Message ans = md.dispatch(q); std::cout << "query: " << q.DebugString() << std::endl; std::cout << "answer: " << ans.DebugString() << std::endl; } catch (const std::exception & e) { std::cerr << e.what() << std::endl; } return 0; } 

PS इस लेख को लिखने के लिए उपयोग किया गया था:

• जीसीसी-4.4.5-linux
• cmake-2.8.2
• बढ़ावा-1.42
• Protobuf-2.3.0

उदाहरण github पर पोस्ट किया गया