कई साल पहले, C ++ डेवलपर्स को लंबे समय से प्रतीक्षित C ++ 11 मानक प्राप्त हुआ था, जो बहुत सी नई चीजें लाया था। और मुझे रोज़मर्रा के कार्यों में इसके उपयोग पर जल्दी से जाने का शौक था। C ++ 14 और 17 पर जाएं यह नहीं था। ऐसा लगता था कि सुविधाओं का कोई सेट नहीं था जो कि रुचि का होगा। वसंत में, मैंने भाषा के नवाचारों को देखने और कुछ करने की कोशिश करने का फैसला किया। नवाचारों के साथ प्रयोग करने के लिए, आपको अपने लिए एक कार्य करना होगा। मुझे लंबा सोचने की जरूरत नहीं थी। कस्टम डेटा संरचनाओं के साथ अपने आरपीसी को पैरामीटर के रूप में और मैक्रोज़ और कोड पीढ़ी के उपयोग के बिना लिखने का निर्णय लिया गया था - सभी सी ++ में। यह भाषा की नई विशेषताओं के लिए संभव था।

विचार, कार्यान्वयन, रेडिट के साथ प्रतिक्रिया, सुधार - सब कुछ वसंत में दिखाई दिया, शुरुआती गर्मियों में। अंत तक, वे हैबर पर पोस्ट को समाप्त करने में कामयाब रहे।

क्या आपने अपने RPC के बारे में सोचा है? शायद पोस्ट की सामग्री आपको लक्ष्य, विधियों, साधनों को निर्धारित करने और समाप्त एक के पक्ष में निर्णय लेने में मदद करेगी या कुछ खुद को लागू करेगी ...

परिचय

RPC (दूरस्थ प्रक्रिया कॉल) कोई नया विषय नहीं है। विभिन्न प्रोग्रामिंग भाषाओं में कई कार्यान्वयन हैं। कार्यान्वयन विभिन्न डेटा स्वरूपों और परिवहन के साधनों का उपयोग करता है। यह सब कुछ बिंदुओं में परिलक्षित हो सकता है:

सीरियलाइजेशन / Deserialization
ट्रांसपोर्ट
रिमोट विधि निष्पादन
वापसी का परिणाम

कार्यान्वयन वांछित लक्ष्य द्वारा निर्धारित किया जाता है। उदाहरण के लिए, आप अपने आप को एक दूरस्थ विधि को कॉल करने की उच्च गति सुनिश्चित करने और प्रयोज्य को त्यागने का लक्ष्य निर्धारित कर सकते हैं, या इसके विपरीत, लेखन कोड के लिए अधिकतम आराम प्रदान करने के लिए, संभवतः प्रदर्शन में थोड़ा कम कर सकते हैं। लक्ष्य और उपकरण अलग हैं ... मैं आराम और स्वीकार्य प्रदर्शन चाहता था।

कार्यान्वयन

नीचे C ++ 14/17 में RPC को लागू करने के लिए कुछ कदम दिए गए हैं, और कुछ भाषा नवाचारों पर जोर दिया गया है, जिसके कारण यह सामग्री सामने आई है।

सामग्री उन लोगों के लिए अभिप्रेत है जो किसी कारण से अपने आरपीसी में रुचि रखते हैं, और, शायद, अब तक, अतिरिक्त जानकारी की आवश्यकता है। टिप्पणियों में, समान कार्यों के साथ सामना किए गए अन्य डेवलपर्स के अनुभव का विवरण देखना दिलचस्प होगा।

क्रमबद्धता

इससे पहले कि आप कोड लिखना शुरू करें, मैं एक कार्य बनाऊंगा:

सभी विधि पैरामीटर और लौटा हुआ परिणाम टपल के माध्यम से पारित किया जाता है।
खुद को बुलाया तरीके ट्यूपल्स को स्वीकार करने और वापस करने के लिए बाध्य नहीं हैं।
ट्यूपल पैक करने का परिणाम एक बफर होना चाहिए जिसका प्रारूप तय नहीं है

निम्नलिखित एक सरलीकृत स्ट्रिंग क्रमिक कोड है।

string_serializer

namespace rpc::type { using buffer = std::vector<char>; } // namespace rpc::type namespace rpc::packer { class string_serializer final { public: template <typename ... T> type::buffer save(std::tuple<T ... > const &tuple) const { auto str = to_string(tuple, std::make_index_sequence<sizeof ... (T)>{}); return {begin(str), end(str)}; } template <typename ... T> void load(type::buffer const &buffer, std::tuple<T ... > &tuple) const { std::string str{begin(buffer), end(buffer)}; from_string(std::move(str), tuple, std::make_index_sequence<sizeof ... (T)>{}); } private: template <typename T, std::size_t ... I> std::string to_string(T const &tuple, std::index_sequence<I ... >) const { std::stringstream stream; auto put_item = [&stream] (auto const &i) { if constexpr (std::is_same_v<std::decay_t<decltype(i)>, std::string>) stream << std::quoted(i) << ' '; else stream << i << ' '; }; (put_item(std::get<I>(tuple)), ... ); return std::move(stream.str()); } template <typename T, std::size_t ... I> void from_string(std::string str, T &tuple, std::index_sequence<I ... >) const { std::istringstream stream{std::move(str)}; auto get_item = [&stream] (auto &i) { if constexpr (std::is_same_v<std::decay_t<decltype(i)>, std::string>) stream >> std::quoted(i); else stream >> i; }; (get_item(std::get<I>(tuple)), ... ); } }; } // namespace rpc::packer

और मुख्य फंक्शन कोड, जो धारावाहिक के संचालन को प्रदर्शित करता है।

मुख्य समारोह

 int main() { try { std::tuple args{10, std::string{"Test string !!!"}, 3.14}; rpc::packer::string_serializer serializer; auto pack = serializer.save(args); std::cout << "Pack data: " << std::string{begin(pack), end(pack)} << std::endl; decltype(args) params; serializer.load(pack, params); // For test { auto pack = serializer.save(params); std::cout << "Deserialized pack: " << std::string{begin(pack), end(pack)} << std::endl; } } catch (std::exception const &e) { std::cerr << "Error: " << e.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }

मान्यता प्राप्त लहजे

सबसे पहले, आपको उस बफर को निर्धारित करने की आवश्यकता है जिसके साथ पूरे डेटा एक्सचेंज का प्रदर्शन किया जाएगा:

 namespace rpc::type { using buffer = std::vector<char>; } // namespace rpc::type

सीरियलाइज़र में बफ़ल को सहेजने (सहेजने) और इसे बफ़र (लोड) से लोड करने के तरीके हैं

सहेजने की विधि एक टपल लेती है और एक बफर लौटाती है।

 template <typename ... T> type::buffer save(std::tuple<T ... > const &tuple) const { auto str = to_string(tuple, std::make_index_sequence<sizeof ... (T)>{}); return {begin(str), end(str)}; }

एक ट्यूपल मापदंडों की एक चर संख्या के साथ एक टेम्पलेट है। ऐसे पैटर्न C ++ 11 में दिखाई दिए और अच्छी तरह से काम किया। यहां आपको किसी तरह ऐसे टेम्पलेट के सभी तत्वों के माध्यम से जाने की आवश्यकता है। कई विकल्प हो सकते हैं। मैं सी ++ 14 की एक विशेषता का उपयोग करूंगा - पूर्णांक (सूचकांक) का एक क्रम। मेक_इंडेक्स_ परिणाम प्रकार मानक लाइब्रेरी में दिखाई दिया है, जो निम्नलिखित अनुक्रम प्राप्त करने की अनुमति देता है:

 template< class T, T... Ints > class integer_sequence; template<class T, T N> using make_integer_sequence = std::integer_sequence<T, /* a sequence 0, 1, 2, ..., N-1 */ >; template<std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;

C ++ 11 में एक समान लागू किया जा सकता है, और फिर इसे प्रोजेक्ट से प्रोजेक्ट में ले जा सकता है।

सूचकांकों का ऐसा क्रम टपल को "गुजरना" संभव बनाता है:

 template <typename T, std::size_t ... I> std::string to_string(T const &tuple, std::index_sequence<I ... >) const { std::stringstream stream; auto put_item = [&stream] (auto const &i) { if constexpr (std::is_same_v<std::decay_t<decltype(i)>, std::string>) stream << std::quoted(i) << ' '; else stream << i << ' '; }; (put_item(std::get<I>(tuple)), ... ); return std::move(stream.str()); }

To_string विधि नवीनतम C ++ मानकों की कई विशेषताओं का उपयोग करती है।

मान्यता प्राप्त लहजे

C ++ 14 में, लैम्ब्डा कार्यों के लिए मापदंडों के रूप में ऑटो का उपयोग करना संभव हो गया। यह अक्सर पर्याप्त नहीं था, उदाहरण के लिए, मानक पुस्तकालय के एल्गोरिदम के साथ काम करते समय।

C ++ 17 में एक दृढ़ संकल्प दिखाई दिया, जो आपको कोड लिखने की अनुमति देता है जैसे:

 (put_item(std::get<I>(tuple)), ... );

दिए गए अंश में, पुट_टेम लैम्ब्डा फ़ंक्शन को स्थानांतरित किए गए ट्यूपल के प्रत्येक तत्व के लिए कहा जाता है। यह मंच और संकलक से स्वतंत्र अनुक्रम की गारंटी देता है। ऐसा ही कुछ C ++ 11 में लिखा जा सकता है।

 template <typename … T> void unused(T && … ) {} // ... unused(put_item(std::get<I>(tuple)) ... );

लेकिन तत्वों को किस क्रम में संग्रहित किया जाएगा यह कंपाइलर पर निर्भर करेगा।

कई उपनाम C ++ 17 मानक पुस्तकालय में दिखाई दिए, उदाहरण के लिए, decay_t, जिसने फॉर्म के रिकॉर्ड को कम कर दिया:

 typename decay<T>::type

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

संक्षिप्तता की इच्छा ने भाषा का एक और दिलचस्प निर्माण "अगर कॉन्स्ट्रेप" किया है, तो कई निजी विषयों को लिखने से बचा जाता है।

एक दिलचस्प बात है। कई को सिखाया गया है कि कोड स्केलेबिलिटी के मामले में स्विच और इसी तरह के निर्माण बहुत अच्छे नहीं हैं। रन-टाइम / कंपाइल-टाइम पॉलिमोर्फ़िज्म का उपयोग करना और "अतिरिक्त विकल्प" के पक्ष में तर्कों के साथ अधिभार करना बेहतर होता है। और फिर "अगर बाधा" ... कॉम्पैक्टनेस की संभावना हर किसी को इसके प्रति उदासीन नहीं छोड़ती है। भाषा की संभावना का मतलब इसका उपयोग करने की आवश्यकता नहीं है।

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

आप अब के लिए क्रमांकन के वर्णन के साथ रुक सकते हैं। Deserialization (लोड) समान रूप से लागू किया जाता है।

ट्रांसपोर्ट

परिवहन सरल है। यह एक फ़ंक्शन है जो एक बफर को प्राप्त करता है और लौटाता है।

 namespace rpc::type { // ... using executor = std::function<buffer (buffer)>; } // namespace rpc::type

इस तरह के एक ऑब्जेक्ट "निष्पादक" का उपयोग करके std :: bind, lambda फ़ंक्शन आदि का उपयोग करके, आप अपने किसी भी परिवहन कार्यान्वयन का उपयोग कर सकते हैं। इस पद के भीतर परिवहन के कार्यान्वयन के विवरण पर विचार नहीं किया जाएगा। आप पूर्ण आरपीसी कार्यान्वयन पर एक नज़र डाल सकते हैं, जिसका एक लिंक अंत में दिया जाएगा।

ग्राहक

नीचे एक परीक्षण ग्राहक कोड है। क्लाइंट अनुरोधों को जनरेट करता है और उन्हें चयनित ट्रांसपोर्ट को ध्यान में रखते हुए सर्वर पर भेजता है। नीचे दिए गए परीक्षण कोड में, सभी क्लाइंट अनुरोध कंसोल पर प्रदर्शित होते हैं। और कार्यान्वयन के अगले चरण में, क्लाइंट पहले से ही सर्वर से सीधे संवाद करेगा।

ग्राहक

 namespace rpc { template <typename TPacker> class client final { private: class result; public: client(type::executor executor) : executor_{executor} { } template <typename ... TArgs> result call(std::string const &func_name, TArgs && ... args) { auto request = std::make_tuple(func_name, std::forward<TArgs>(args) ... ); auto pack = packer_.save(request); auto responce = executor_(std::move(pack)); return {responce}; } private: using packer_type = TPacker; packer_type packer_; type::executor executor_; class result final { public: result(type::buffer buffer) : buffer_{std::move(buffer)} { } template <typename T> auto as() const { std::tuple<std::decay_t<T>> tuple; packer_.load(buffer_, tuple); return std::move(std::get<0>(tuple)); } private: packer_type packer_; type::buffer buffer_; }; }; } // namespace rpc

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

वर्तमान कार्यान्वयन में, क्लास कंस्ट्रक्टर एक निष्पादित ऑब्जेक्ट को स्वीकार करता है। ठेकेदार खुद के तहत परिवहन के कार्यान्वयन को छुपाता है, और कोड में इस बिंदु पर संभव बनाता है कि प्रक्रियाओं के लिए डेटा के आदान-प्रदान के तरीकों के बारे में नहीं सोचना चाहिए। परीक्षण के मामले में, परिवहन कार्यान्वयन कंसोल के लिए अनुरोध प्रदर्शित करता है।

 auto executor = [] (rpc::type::buffer buffer) { // Print request data std::cout << "Request pack: " << std::string{begin(buffer), end(buffer)} << std::endl; return buffer; };

कस्टम कोड ने अभी तक क्लाइंट के काम के परिणाम का लाभ उठाने की कोशिश नहीं की है, क्योंकि वहाँ नहीं है जहां से इसे प्राप्त करना है।

ग्राहक कॉल विधि:

क्रमिक का उपयोग कर बुलाया विधि और उसके मापदंडों के नाम पैक
निष्पादित ऑब्जेक्ट का उपयोग करके सर्वर को एक अनुरोध भेजता है और एक प्रतिक्रिया प्राप्त करता है
परिणाम प्राप्त करने वाले वर्ग को प्राप्त उत्तर पास करता है

मूल ग्राहक कार्यान्वयन तैयार है। कुछ और बचा है। इसके बारे में बाद में।

सर्वर

सर्वर साइड के कार्यान्वयन के विवरण पर विचार करने के लिए शुरू करने से पहले, मैं क्लाइंट-सर्वर इंटरैक्शन के पूर्ण उदाहरण पर एक त्वरित, विकर्ण देखने का सुझाव देता हूं।

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

क्लाइंट-सर्वर इंटरैक्शन। टेस्ट केस

 #include <cstdint> #include <cstdlib> #include <functional> #include <iomanip> #include <iostream> #include <map> #include <sstream> #include <string> #include <tuple> #include <vector> #include <utility> namespace rpc::type { using buffer = std::vector<char>; using executor = std::function<buffer (buffer)>; } // namespace rpc::type namespace rpc::detail { template <typename> struct function_meta; template <typename TRes, typename ... TArgs> struct function_meta<std::function<TRes (TArgs ... )>> { using result_type = std::decay_t<TRes>; using args_type = std::tuple<std::decay_t<TArgs> ... >; using request_type = std::tuple<std::string, std::decay_t<TArgs> ... >; }; } // namespace rpc::detail namespace rpc::packer { class string_serializer final { public: template <typename ... T> type::buffer save(std::tuple<T ... > const const &tuple) const { auto str = to_string(tuple, std::make_index_sequence<sizeof ... (T)>{}); return {begin(str), end(str)}; } template <typename ... T> void load(type::buffer const &buffer, std::tuple<T ... > &tuple) const { std::string str{begin(buffer), end(buffer)}; from_string(std::move(str), tuple, std::make_index_sequence<sizeof ... (T)>{}); } private: template <typename T, std::size_t ... I> std::string to_string(T const &tuple, std::index_sequence<I ... >) const { std::stringstream stream; auto put_item = [&stream] (auto const &i) { if constexpr (std::is_same_v<std::decay_t<decltype(i)>, std::string>) stream << std::quoted(i) << ' '; else stream << i << ' '; }; (put_item(std::get<I>(tuple)), ... ); return std::move(stream.str()); } template <typename T, std::size_t ... I> void from_string(std::string str, T &tuple, std::index_sequence<I ... >) const { std::istringstream stream{std::move(str)}; auto get_item = [&stream] (auto &i) { if constexpr (std::is_same_v<std::decay_t<decltype(i)>, std::string>) stream >> std::quoted(i); else stream >> i; }; (get_item(std::get<I>(tuple)), ... ); } }; } // namespace rpc::packer namespace rpc { template <typename TPacker> class client final { private: class result; public: client(type::executor executor) : executor_{executor} { } template <typename ... TArgs> result call(std::string const &func_name, TArgs && ... args) { auto request = std::make_tuple(func_name, std::forward<TArgs>(args) ... ); auto pack = packer_.save(request); auto responce = executor_(std::move(pack)); return {responce}; } private: using packer_type = TPacker; packer_type packer_; type::executor executor_; class result final { public: result(type::buffer buffer) : buffer_{std::move(buffer)} { } template <typename T> auto as() const { std::tuple<std::decay_t<T>> tuple; packer_.load(buffer_, tuple); return std::move(std::get<0>(tuple)); } private: packer_type packer_; type::buffer buffer_; }; }; template <typename TPacker> class server final { public: template <typename ... THandler> server(std::pair<char const *, THandler> const & ... handlers) { auto make_executor = [&packer = packer_] (auto const &handler) { auto executor = [&packer, function = std::function{handler}] (type::buffer buffer) { using meta = detail::function_meta<std::decay_t<decltype(function)>>; typename meta::request_type request; packer.load(buffer, request); auto response = std::apply([&function] (std::string const &, auto && ... args) { return function(std::forward<decltype(args)>(args) ... ); }, std::move(request) ); return packer.save(std::make_tuple(std::move(response))); }; return executor; }; (handlers_.emplace(handlers.first, make_executor(handlers.second)), ... ); } type::buffer execute(type::buffer buffer) { std::tuple<std::string> pack; packer_.load(buffer, pack); auto func_name = std::move(std::get<0>(pack)); auto const iter = handlers_.find(func_name); if (iter == end(handlers_)) throw std::runtime_error{"Function \"" + func_name + "\" not found."}; return iter->second(std::move(buffer)); } private: using packer_type = TPacker; packer_type packer_; using handlers_type = std::map<std::string, type::executor>; handlers_type handlers_; }; } // namespace rpc int main() { try { using packer_type = rpc::packer::string_serializer; rpc::server<packer_type> server{ std::pair{"hello", [] (std::string const &s) { std::cout << "Func: \"hello\". Inpur string: " << s << std::endl; return "Hello " + s + "!"; }}, std::pair{"to_int", [] (std::string const &s) { std::cout << "Func: \"to_int\". Inpur string: " << s << std::endl; return std::stoi(s); }} }; auto executor = [&server] (rpc::type::buffer buffer) { return server.execute(std::move(buffer)); }; rpc::client<packer_type> client{std::move(executor)}; std::cout << client.call("hello", std::string{"world"}).as<std::string>() << std::endl; std::cout << "Convert to int: " << client.call("to_int", std::string{"100500"}).as<int>() << std::endl; } catch (std::exception const &e) { std::cerr << "Error: " << e.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }

सर्वर वर्ग के उपरोक्त कार्यान्वयन में, सबसे दिलचस्प बात इसके निर्माता और निष्पादन विधि है।

सर्वर वर्ग निर्माता

 template <typename ... THandler> server(std::pair<char const *, THandler> const & ... handlers) { auto make_executor = [&packer = packer_] (auto const &handler) { auto executor = [&packer, function = std::function{handler}] (type::buffer buffer) { using meta = detail::function_meta<std::decay_t<decltype(function)>>; typename meta::request_type request; packer.load(buffer, request); auto response = std::apply([&function] (std::string const &, auto && ... args) { return function(std::forward<decltype(args)>(args) ... ); }, std::move(request) ); return packer.save(std::make_tuple(std::move(response))); }; return executor; }; (handlers_.emplace(handlers.first, make_executor(handlers.second)), ... ); }

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

सर्वर वर्ग के निर्माता का एक टुकड़ा

 template <typename ... THandler> server(std::pair<char const *, THandler> const & ... handlers) { // … (handlers_.emplace(handlers.first, make_executor(handlers.second)), ... ); }

एक ही प्रकार के कार्यों के नक्शे में बहुत से पारित किए गए विषम हैंडलर डालता है। इसके लिए, कनवल्शन का भी उपयोग किया जाता है, जो इसे std में डालना आसान बनाता है :: पास किए गए हैंडलर के पूरे सेट को बिना लूप और एल्गोरिदम के एक पंक्ति में मैप करें

 (handlers_.emplace(handlers.first, make_executor(handlers.second)), ... );

लैम्ब्डा फ़ंक्शन जो ऑटो को मापदंडों के रूप में उपयोग करने की अनुमति देता है, उसी प्रकार के आवरण को हैंडलर पर लागू करना आसान बनाता है। सर्वर पर उपलब्ध तरीकों के नक्शे में उसी प्रकार के रैप पंजीकृत हैं (std :: map)। अनुरोधों को संसाधित करते समय, इस तरह के कार्ड पर एक खोज की जाती है, और एक ही हैंडलर प्राप्त हैंडलर को कॉल करता है, भले ही प्राप्त मापदंडों और रिटर्न किए गए परिणाम की परवाह किए बिना। Std :: मानक पुस्तकालय में दिखाई देने वाले फ़ंक्शन को लागू करता है, जो उस पर पारित होने वाले फ़ंक्शन को एक ट्यूपल के रूप में पारित मापदंडों से कहता है। Std :: apply फंक्शन को C ++ 11 में भी लागू किया जा सकता है। अब यह "बॉक्स से बाहर" उपलब्ध है और इसे परियोजना से परियोजना में स्थानांतरित करने की कोई आवश्यकता नहीं है।

निष्पादित करने की विधि

 type::buffer execute(type::buffer buffer) { std::tuple<std::string> pack; packer_.load(buffer, pack); auto func_name = std::move(std::get<0>(pack)); auto const iter = handlers_.find(func_name); if (iter == end(handlers_)) throw std::runtime_error{"Function \"" + func_name + "\" not found."}; return iter->second(std::move(buffer)); }

बुलाए गए फ़ंक्शन का नाम पुनर्प्राप्त करता है, पंजीकृत हैंडलर के नक्शे में विधि की खोज करता है, हैंडलर को कॉल करता है और परिणाम देता है। सर्वर क्लास के कंस्ट्रक्टर में तैयार किए गए रैपर में सभी दिलचस्प हैं। किसी ने अपवाद को देखा होगा, और शायद यह सवाल उठता है: "क्या अपवाद किसी तरह से संभाले जाते हैं?" हां, पूर्ण कार्यान्वयन में, जो अंत में संदर्भ द्वारा दिया जाएगा, अपवाद मार्शलिंग प्रदान किया गया है। सामग्री को सरल बनाने के लिए, ग्राहक और सर्वर के बीच अपवाद पारित नहीं किए जाते हैं।

फ़ंक्शन पर एक और नज़र डालें

मुख्य

 int main() { try { using packer_type = rpc::packer::string_serializer; rpc::server<packer_type> server{ std::pair{"hello", [] (std::string const &s) { std::cout << "Func: \"hello\". Inpur string: " << s << std::endl; return "Hello " + s + "!"; }}, std::pair{"to_int", [] (std::string const &s) { std::cout << "Func: \"to_int\". Inpur string: " << s << std::endl; return std::stoi(s); }} }; auto executor = [&server] (rpc::type::buffer buffer) { return server.execute(std::move(buffer)); }; rpc::client<packer_type> client{std::move(executor)}; std::cout << client.call("hello", std::string{"world"}).as<std::string>() << std::endl; std::cout << "Convert to int: " << client.call("to_int", std::string{"100500"}).as<int>() << std::endl; } catch (std::exception const &e) { std::cerr << "Error: " << e.what() << std::endl; return EXIT_FAILURE; } return EXIT_SUCCESS; }

यह पूरे क्लाइंट-सर्वर इंटरैक्शन को कार्यान्वित करता है। सामग्री को जटिल नहीं करने के लिए, क्लाइंट और सर्वर एक प्रक्रिया में काम करते हैं। निष्पादक के कार्यान्वयन की जगह, आप आवश्यक परिवहन का उपयोग कर सकते हैं।

C ++ 17 मानक में, कभी-कभी यह संभव है कि तात्कालिकता पर टेम्पलेट के मापदंडों को निर्दिष्ट न किया जाए। उपरोक्त मुख्य फ़ंक्शन में, सर्वर हैंडलर (std :: pair बिना टेम्पलेट पैरामीटर्स) को पंजीकृत करते समय इसका उपयोग किया जाता है और कोड को सरल बनाता है।

मूल RPC कार्यान्वयन तैयार है। यह कस्टम डेटा संरचनाओं को मापदंडों और वापसी परिणामों के रूप में पारित करने की वादा की गई क्षमता को जोड़ने के लिए बनी हुई है।

कस्टम डेटा संरचनाएँ

प्रक्रिया सीमा के पार डेटा स्थानांतरित करने के लिए, उन्हें किसी चीज़ में क्रमबद्ध करने की आवश्यकता होती है। उदाहरण के लिए, आप एक मानक स्ट्रीम में सब कुछ आउटपुट कर सकते हैं। बहुत कुछ बॉक्स से बाहर का समर्थन किया जाएगा। कस्टम डेटा संरचनाओं के लिए, आपको आउटपुट ऑपरेटरों को स्वयं लागू करना होगा। प्रत्येक संरचना को अपने स्वयं के आउटपुट ऑपरेटर की आवश्यकता होती है। कभी-कभी आप ऐसा नहीं करना चाहते हैं। संरचना के सभी क्षेत्रों के माध्यम से सॉर्ट करने और प्रत्येक क्षेत्र को स्ट्रीम में आउटपुट करने के लिए, आपको कुछ सामान्यीकृत विधि की आवश्यकता होती है। इसमें परावर्तन अच्छी तरह से मदद कर सकता है। यह अभी तक C ++ में नहीं है। आप कोड पीढ़ी और मैक्रोज़ और टेम्पलेट्स के मिश्रण का उपयोग कर सकते हैं। लेकिन यह विचार शुद्ध सी ++ में पुस्तकालय इंटरफ़ेस बनाने के लिए था।

C ++ में अभी तक कोई पूर्ण प्रतिबिंब नहीं है। इसलिए, नीचे दिए गए समाधान का उपयोग कुछ सीमाओं के साथ किया जा सकता है।

समाधान नए C ++ 17 "संरचित बाइंडिंग" सुविधा पर आधारित है। अक्सर संवादों में आप बहुत सारे शब्दजाल पा सकते हैं, इसलिए मैंने रूसी में इस सुविधा के नाम के लिए किसी भी विकल्प से इनकार कर दिया।

नीचे एक समाधान है जो आपको स्थानांतरित डेटा संरचना के क्षेत्रों को ट्यूपल में स्थानांतरित करने की अनुमति देता है।

 template <typename T> auto to_tuple(T &&value) { using type = std::decay_t<T>; if constexpr (is_braces_constructible_v<type, dummy_type, dummy_type, dummy_type>) { auto &&[f1, f2, f3] = value; return std::make_tuple(f1, f2, f3); } else if constexpr (is_braces_constructible_v<type, dummy_type, dummy_type>) { auto &&[f1, f2] = value; return std::make_tuple(f1, f2); } else if constexpr (is_braces_constructible_v<type, dummy_type>) { auto &&[f1] = value; return std::make_tuple(f1); } else { return std::make_tuple(); } }

इंटरनेट पर आप कई समान समाधान पा सकते हैं।

संरचित बाइंडिंग को छोड़कर, यहाँ जो कहा गया था, उसका बहुत कुछ उपयोग किया गया था। To_tuple फ़ंक्शन एक कस्टम प्रकार को स्वीकार करता है, फ़ील्ड की संख्या निर्धारित करता है, और संरचित बाइंडिंग की मदद से संरचना फ़ील्ड्स को tuple में "स्थानांतरित" करता है। और "अगर बाधा" आपको वांछित कार्यान्वयन शाखा का चयन करने की अनुमति देता है। चूंकि C ++ में कोई प्रतिबिंब नहीं है, इसलिए एक पूर्ण समाधान जो कि सभी प्रकारों को ध्यान में रखता है, निर्मित नहीं किया जा सकता है। उपयोग किए गए प्रकारों पर प्रतिबंध हैं। उनमें से एक - प्रकार कस्टम बिल्डरों के बिना होना चाहिए।

To_tuple is_braces_constructible_v का उपयोग करता है। यह प्रकार आपको घुंघराले ब्रेसिज़ का उपयोग करके स्थानांतरित संरचना को शुरू करने की क्षमता निर्धारित करने और खेतों की संख्या निर्धारित करने की अनुमति देता है।

is_braces_constructible_v

 struct dummy_type final { template <typename T> constexpr operator T () noexcept { return *static_cast<T const *>(nullptr); } }; template <typename T, typename ... TArgs> constexpr decltype(void(T{std::declval<TArgs>() ... }), std::declval<std::true_type>()) is_braces_constructible(std::size_t) noexcept; template <typename, typename ... > constexpr std::false_type is_braces_constructible(...) noexcept; template <typename T, typename ... TArgs> constexpr bool is_braces_constructible_v = std::decay_t<decltype(is_braces_constructible<T, TArgs ... >(0))>::value;

उपरोक्त to_tuple फ़ंक्शन उपयोगकर्ता डेटा संरचनाओं को tuples में तीन से अधिक फ़ील्ड नहीं बना सकता है। "स्थानांतरित" संरचना फ़ील्ड की संभावित संख्या बढ़ाने के लिए, आप या तो "कॉन्स्टैक्सप्र" शाखाओं को मन के एक छोटे से समावेश के साथ कॉपी कर सकते हैं, या सरलतम बूस्टर का उपयोग नहीं करने का सहारा ले सकते हैं। यदि आप दूसरे विकल्प का चयन करते हैं, तो कोड को पढ़ना मुश्किल हो जाएगा और बड़ी संख्या में फ़ील्ड्स के साथ संरचनाओं का उपयोग करना संभव होगा।

बढ़ावा देने के साथ to_tuple को लागू करना

 template <typename T> auto to_tuple(T &&value) { using type = std::decay_t<T>; #define NANORPC_TO_TUPLE_LIMIT_FIELDS 64 // you can try to use BOOST_PP_LIMIT_REPEAT #define NANORPC_TO_TUPLE_DUMMY_TYPE_N(_, n, data) \ BOOST_PP_COMMA_IF(n) data #define NANORPC_TO_TUPLE_PARAM_N(_, n, data) \ BOOST_PP_COMMA_IF(n) data ## n #define NANORPC_TO_TUPLE_ITEM_N(_, n, __) \ if constexpr (is_braces_constructible_v<type, \ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_SUB(NANORPC_TO_TUPLE_LIMIT_FIELDS, n), NANORPC_TO_TUPLE_DUMMY_TYPE_N, dummy_type) \ >) { auto &&[ \ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_SUB(NANORPC_TO_TUPLE_LIMIT_FIELDS, n), NANORPC_TO_TUPLE_PARAM_N, f) \ ] = value; return std::make_tuple( \ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_SUB(NANORPC_TO_TUPLE_LIMIT_FIELDS, n), NANORPC_TO_TUPLE_PARAM_N, f) \ ); } else #define NANORPC_TO_TUPLE_ITEMS(n) \ BOOST_PP_REPEAT_FROM_TO(0, n, NANORPC_TO_TUPLE_ITEM_N, nil) NANORPC_TO_TUPLE_ITEMS(NANORPC_TO_TUPLE_LIMIT_FIELDS) { return std::make_tuple(); } #undef NANORPC_TO_TUPLE_ITEMS #undef NANORPC_TO_TUPLE_ITEM_N #undef NANORPC_TO_TUPLE_PARAM_N #undef NANORPC_TO_TUPLE_DUMMY_TYPE_N #undef NANORPC_TO_TUPLE_LIMIT_FIELDS }

यदि आपने कभी C ++ 03 के लिए boost.bind जैसा कुछ करने की कोशिश की है, जहां आपको विभिन्न मापदंडों के साथ कई कार्यान्वयन करने थे, तो to_tuple का उपयोग बूस्टर.प्रोसेसर का कार्यान्वयन अजीब या जटिल नहीं लगता है।

और यदि धारावाहिक में ट्यूपल समर्थन जोड़ा जाता है, तो to_tuple फ़ंक्शन उपयोगकर्ता डेटा संरचनाओं के क्रमांकन को सक्षम करेगा। और उन्हें अपने आरपीसी में मापदंडों के रूप में धोखा देना और परिणाम वापस करना संभव हो जाता है।

उपयोगकर्ता-परिभाषित डेटा संरचनाओं के अलावा, C ++ में अन्य अंतर्निहित प्रकार हैं जिनके लिए मानक स्ट्रीम में आउटपुट लागू नहीं किया गया है। स्ट्रीम में ओवरलोड आउटपुट ऑपरेटरों की संख्या को कम करने की इच्छा एक सामान्यीकृत कोड की ओर ले जाती है जो एक विधि को अधिकांश C ++ कंटेनरों को संसाधित करने की अनुमति देती है, जैसे कि std :: list, std :: वेक्टर, std :: map। SFINAE और std :: enable_if_t के बारे में भूलकर भी आप धारावाहिक का विस्तार जारी रख सकते हैं। इस मामले में, यह किसी भी प्रकार के गुणों को अप्रत्यक्ष रूप से निर्धारित करने के लिए आवश्यक होगा, जैसा कि is_braces_constructible_v के कार्यान्वयन में किया जाता है।

निष्कर्ष

पद के दायरे से बाहर, अपवाद मार्शलिंग, परिवहन, एसटीएल कंटेनरों का क्रमांकन और बहुत कुछ बना रहा।पोस्ट को बहुत जटिल नहीं करने के लिए, केवल सामान्य सिद्धांत दिए गए थे, जिन पर मैं अपनी RPC लाइब्रेरी का निर्माण करने और अपने लिए निर्धारित मूल कार्य को हल करने में सक्षम था - नई C ++ 14/17 सुविधाओं को आज़माने के लिए। और परिणामस्वरूप कार्यान्वयन आपको व्यापक HTTP / HTTPS और का उपयोग करके दूरस्थ विधियों को कॉल करने की अनुमति देता है। इसमें काफी विस्तृत उपयोग उदाहरण हैं। GitHub पर NanoRPC

पुस्तकालय कोड ।

आपका ध्यान के लिए धन्यवाद!

RPC - C ++ 14/17 में नया प्रयास करने का अवसर