👨🏽‍🎓 🌠 🚯 SSH के माध्यम से एक दूरस्थ अनुप्रयोग के साथ अतुल्यकालिक डेटा विनिमय 👧 😛 👩‍🔬

अच्छे दिन, दोस्तों और सहकर्मियों। मेरा नाम अभी भी दिमित्री स्मिरनोव है, और मैं अभी भी अपने बहुत खुशी के लिए आईएसपीसिस्टम के डेवलपर हूं। कुछ समय पहले, मैंने पूरी तरह से एक नई परियोजना पर काम शुरू किया, जिसने मुझे बहुत प्रेरित किया, क्योंकि नया हमारे मामले में विरासत कोड की कमी और पुराने संकलक के लिए समर्थन है। नमस्कार, बूस्ट, सी ++ 17 और आधुनिक विकास के अन्य सभी खुशियाँ।

ऐसा हुआ कि मेरी सभी पिछली परियोजनाएं क्रमशः बहु-थ्रेडेड थीं, मुझे अतुल्यकालिक समाधानों के साथ बहुत कम अनुभव था। आधुनिक शक्तिशाली साधनों के अलावा, इस विकास में यही मेरे लिए सबसे सुखद बन गया।

अंतिम संबंधित कार्यों में से एक Boost.Asio का उपयोग करते हुए एक अतुल्यकालिक आवेदन की वास्तविकताओं में libssh2 पुस्तकालय पर एक आवरण लिखने की आवश्यकता थी, और दो से अधिक थ्रेड्स को पैदा करने में सक्षम नहीं था। मैं इस बारे में बताऊंगा

नोट: लेखक मानता है कि पाठक अतुल्यकालिक विकास और बढ़ावा के मूल सिद्धांतों से परिचित है :: asio।

कार्य

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

डिस्क्लेमर : मुझे पता है कि पोको एसएसएच के साथ काम करता है, लेकिन मुझे असियो के साथ उससे शादी करने का कोई तरीका नहीं मिला, और मेरे खुद के कुछ :-) लिखना अधिक दिलचस्प था।

प्रारंभ

लाइब्रेरी को आरंभ और कम करने के लिए, मैंने सामान्य सिंगलटन का उपयोग करने का निर्णय लिया:

Init ()

class LibSSH2 { public: static void Init() { static LibSSH2 instance; } private: explicit LibSSH2() { if (libssh2_init(0) != 0) { throw std::runtime_error("libssh2 initialization failed"); } } ~LibSSH2() { std::cout << "shutdown libssh2" << std::endl; libssh2_exit(); } };

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

मुख्य संस्थाएँ

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

चलो एक साधारण सॉकेट से शुरू करते हैं:

सॉकेट

 class Socket { public: explicit Socket() : m_sock(socket(AF_INET, SOCK_STREAM, 0)) { if (m_sock == -1) { throw std::runtime_error("failed to create socket"); } } ~Socket() { close(m_sock); } private: int m_sock = -1; }

अब सत्र:

सत्र

 class Session { public: explicit Session(const bool enable_compression) : m_session(libssh2_session_init()) { if (m_session == nullptr) { throw std::runtime_error("failed to create libssh2 session"); } libssh2_session_set_blocking(m_session, 0); if (enable_compression) { libssh2_session_flag(m_session, LIBSSH2_FLAG_COMPRESS, 1); } } ~Session() { const std::string desc = "Shutting down libssh2 session"; libssh2_session_disconnect(m_session, desc.c_str()); libssh2_session_free(m_session); } private: LIBSSH2_SESSION *m_session; }

चूंकि अब हमारे पास एक सॉकेट और एक सत्र है, इसलिए libssh2 की वास्तविकताओं में एक सॉकेट के लिए प्रतीक्षा फ़ंक्शन लिखना अच्छा होगा:

प्रतीक्षारत गर्तिका

 int WaitSocket() const { pollfd fds{}; fds.fd = sock; fds.events = 0; if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_INBOUND) != 0) { fds.events |= POLLIN; } if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0) { fds.events |= POLLOUT; } return poll(&fds, 1, 10); }

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

चैनल बना हुआ है। Libssh2 में कई प्रकार के चैनल हैं: सरल, एससीपी, डायरेक्ट टीसीपी। हम सबसे सरल, बुनियादी चैनल में रुचि रखते हैं:

चैनल

 class SimpleChannel { public: explicit SimpleChannel(session) { while ((m_channel = libssh2_channel_open_session(session) == nullptr && GetSessionLastError() == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } if (m_channel == nullptr) { throw std::runtime_error("Critical error while opening simple channel"); } } void SendEof() { while (libssh2_channel_send_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } while (libssh2_channel_wait_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } } ~SimpleChannel() { CloseChannel(); } private: void CloseChannel() { int rc; while ((rc = libssh2_channel_close(m_channel)) == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } libssh2_channel_free(m_channel); } LIBSSH2_CHANNEL *m_channel; };

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

इसलिए, हम आधार वर्ग लिखते हैं:

मूल संबंध

 class BaseConnectionImpl { protected: explicit BaseConnectionImpl(const SshConnectData &connect_data) ///<    ,     : m_session(connect_data.enable_compression) , m_connect_data(connect_data) { LibSSH2::Init(); ConnectSocket(); HandShake(); ProcessKnownHosts(); Auth(); } ///       bool CheckSocket(int type) const { pollfd fds{}; fds.fd = m_sock; fds.events = type; return poll(&fds, 1, 0) == 1; } bool WantRead() const { return CheckSocket(POLLIN); } bool WantWrite() const { return CheckSocket(POLLOUT); } /*   ,   ,       *  - . */ void ConnectSocket() {...} void HandShake() {...} void Auth() {...} class Socket m_sock; class Session m_session; class SimpleChannel; SshConnectData m_connect_data; };

अब हम दूरस्थ होस्ट से जुड़ने और उस पर किसी भी कमांड को निष्पादित करने के लिए सबसे सरल वर्ग लिखने के लिए तैयार हैं:

समकालिक संबंध

 class Connection::Impl : public BaseConnectionImpl { public: explicit Impl(const SshConnectData &connect_data) : BaseConnectionImpl(connect_data) {} template <typename Begin> void WriteToChannel(LIBSSH2_CHANNEL *channel, Begin ptr, size_t size) { do { int rc; while ((rc = libssh2_channel_write(channel, ptr, size)) == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } if (rc < 0) { break; } size -= rc; ptr += rc; } while (size != 0); } void ExecuteCommand(const std::string &command, const std::string &in = "") { SimpleChannel channel(*this); int return_code = libssh2_channel_exec(channel, command.c_str()); if (return_code != 0 && return_code != LIBSSH2_ERROR_EAGAIN) { throw std::runtime_error("Critical error while executing ssh command"); } if (!in.empty()) { WriteToChannel(channel, in.c_str(), in.size()); channel.SendEof(); } std::string response; for (;;) { int rc; do { std::array<char, 4096> buffer{}; rc = libssh2_channel_read(channel, buffer.data(), buffer.size()); if (rc > 0) { boost::range::copy(boost::adaptors::slice(buffer, 0, rc), std::back_inserter(response)); } else if (rc < 0 && rc != LIBSSH2_ERROR_EAGAIN) { throw std::runtime_error("libssh2_channel_read error (" + std::to_string(rc) + ")"); } } while (rc > 0); if (rc == LIBSSH2_ERROR_EAGAIN) { WaitSocket(); } else { break; } } } };

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

मानक सॉकेट होना अच्छा है, लेकिन बहुत व्यावहारिक नहीं है यदि आपको प्रक्रिया में अपना व्यवसाय करते समय पढ़ने / लिखने के लिए अतुल्यकालिक रूप से प्रतीक्षा करने की आवश्यकता है। यहाँ बढ़ावा :: asio :: ip :: tcp :: सॉकेट बचाव के लिए आता है, एक अद्भुत विधि है:

 async_wait(wait_type, WaitHandler)

यह एक नियमित सॉकेट से शानदार तरीके से बनाया गया है, जिसके लिए हम पहले से ही कनेक्शन को अग्रिम और बढ़ावा देते हैं :: asio :: io_context - हमारे आवेदन का निष्पादन संदर्भ।

अतुल्यकालिक कनेक्शन निर्माता

 class AsyncConnection::Impl : public BaseConnectionImpl, public std::enable_shared_from_this<AsyncConnection::Impl> { public: Impl(boost::asio::io_context &context, const SshConnectData &connect_data) : BaseConnectionImpl(connect_data) , m_tcp_socket(context, tcp::v4(), m_sock.GetSocket()) { m_tcp_socket.non_blocking(true); } };

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

 void AsyncRun(const std::string &command, CallbackType &&callback) { m_read_callback = std::move(callback); auto ec = libssh2_channel_exec(*m_channel, command.c_str()); TryRead(); }

इस प्रकार, कमांड चलाकर, हम कंट्रोलराइड () विधि में नियंत्रण स्थानांतरित करते हैं।

 void TryRead() { if (m_read_in_progress) { return; } m_tcp_socket.async_wait(tcp::socket::wait_read, [this, self = shared_from_this()](auto ec) { if (WantRead()) { ReadHandler(ec); } if (m_complete) { return; } TryRead(); }); }

सबसे पहले, हम जांचते हैं कि रीडिंग प्रक्रिया पहले से ही कुछ पिछले कॉल से चल रही है या नहीं। यदि नहीं, तो हम पढ़ने के लिए सॉकेट की तत्परता की अपेक्षा करना शुरू करते हैं। Share_from_this () के कैप्चर के साथ एक नियमित लंबो का उपयोग प्रतीक्षा हैंडलर के रूप में किया जाता है।

WantRead () को कॉल पर ध्यान दें। Async_wait, जैसा कि यह निकला, इसकी खामियां भी हैं, और बस टाइमआउट करके वापस आ सकते हैं। इस मामले में अनावश्यक कार्रवाइयों से बचने के लिए, मैंने समय-सीमा के बिना पोल के माध्यम से सॉकेट की जांच करने का फैसला किया - क्या सॉकेट वास्तव में अब पढ़ना चाहता है। यदि नहीं, तो हम सिर्फ TryRead () फिर से चलाते हैं और प्रतीक्षा करते हैं। अन्यथा, हम तुरंत कॉलबैक पर डेटा पढ़ना और स्थानांतरित करना शुरू करते हैं।

 void ReadHandler(const boost::system::error_code &error) { if (error != boost::system::errc::success) { return; } m_read_in_progress = true; int ec = LIBSSH2_ERROR_EAGAIN; std::array<char, 4096> buffer {}; while ((ec = libssh2_channel_read(*m_channel, buffer.data(), buffer.size())) > 0) { std::string tmp; boost::range::copy(boost::adaptors::slice(buffer, 0, ec), std::back_inserter(tmp)); if (m_read_callback != nullptr) { m_read_callback(tmp); } } m_read_in_progress = false; }

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

 void AsyncWrite(const std::string &data, WriteCallbackType &&callback) { m_input += data; m_write_callback = std::move(callback); TryWrite(); }

कनेक्शन के अंदर अतुल्यकालिक रिकॉर्डिंग में स्थानांतरित डेटा और कॉलबैक को सहेजा जाएगा। और अगला चक्र चलाएं, केवल इस बार प्रविष्टियाँ:

रिकॉर्डिंग चक्र

 void TryWrite() { if (m_input.empty() || m_write_in_progress) { return; } m_tcp_socket.async_wait(tcp::socket::wait_write, [this, self = shared_from_this()](auto ec) { if (WantWrite()) { WriteHandler(ec); } if (m_complete) { return; } TryWrite(); }); } void WriteHandler(const boost::system::error_code &error) { if (error != boost::system::errc::success) { return; } m_write_in_progress = true; int ec = LIBSSH2_ERROR_EAGAIN; while (!m_input.empty()) { auto ptr = m_input.c_str(); auto read_size = m_input.size(); while ((ec = libssh2_channel_write(*m_channel, ptr, read_size)) > 0) { read_size -= ec; ptr += ec; } AssertResult(ec); m_input.erase(0, m_input.size() - read_size); if (ec == LIBSSH2_ERROR_EAGAIN) { break; } } if (m_input.empty() && m_write_callback != nullptr) { m_write_callback(); } m_write_in_progress = false; }

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

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

मुझे अधिक अनुभवी Boost.Asio उपयोगकर्ताओं के सुझावों को पढ़ने और मेरे समाधान को बेहतर बनाने के लिए खुशी होगी :-)।

SSH के माध्यम से एक दूरस्थ अनुप्रयोग के साथ अतुल्यकालिक डेटा विनिमय

कार्य

प्रारंभ

मुख्य संस्थाएँ

More articles: