Asynchronous data exchange with a remote application via SSH

Good day, friends and colleagues. My name is still Dmitry Smirnov, and I still, to my great pleasure, am the developer of the ISPsystem. Some time ago I started working on a completely new project that inspired me a lot, because the new one is in our case the absence of Legacy code and the support of old compilers. Hello, Boost, C ++ 17 and all the other joys of modern development.

It so happened that all my past projects were multithreaded, respectively, I had very little experience with asynchronous solutions. This was the most pleasant for me in this development, in addition to modern powerful tools.

One of the latest related tasks was the need to write a wrapper over the libssh2 library in the realities of an asynchronous application that uses Boost.Asio , and capable of generating no more than two threads. About this and tell.
')


Note: the author assumes that the reader is familiar with the basics of asynchronous development and boost :: asio.

Task

In general, the task was as follows: connect to a remote server using an rsa key or username and password; download a script to the remote machine and run it; read his answers and send him commands through the same connection. In this case, of course, not blocking the flow (which is half of the total possible pool).

Disclaimer : I know that work with SSH is implemented in Poco, but I did not find a way to marry him with Asio, and writing something of my own was more interesting :-).

Initialization

To initialize and minimize the library, I decided to use the usual singleton:


There are in this decision, of course, the pitfalls, according to my favorite reference book, “One Thousand and One Way to Shoot Yourself in the Foot in C ++”. If someone generates a stream that will be forgotten to start eating, and the main one ends earlier, interesting special effects may well arise. But in this case I will not take into account this possibility.

Main entities

After analyzing the example , it becomes clear that for our small library we need three simple entities: a socket, a session, and a pipe. As it is not bad to have synchronous instruments, for the time being we will leave Asio aside.

Let's start with a simple socket:


Now the session:


Since we now have a socket and a session, it would be nice to write a wait function for the socket in libssh2 realities:


Actually, this is practically no different from the above example, except that it uses select instead of poll.

There is a channel. There are several types of channels in libssh2: idle, SCP, direct tcp. We are interested in the simplest, basic channel:


Now that all the basic tools are ready, it remains to establish a connection with the host and perform the manipulations we need. Asynchronous recording to the channel and synchronous, of course, will be very different, but the process of establishing a connection is not.

Therefore, we write the base class:


Now we are ready to write the simplest class for connecting to a remote host and executing some command on it:


Until now, everything that we have written has been simply to bring the examples of libssh2 to a more civilized form. But now, having all the simple tools for synchronous writing data to the channel, we can go to Asio.

Having a standard socket is good, but not very practical if you need to wait for its readiness to read / write asynchronously, while doing your own things. Here comes boost :: asio :: ip :: tcp :: socket, which has a wonderful method:

 async_wait(wait_type, WaitHandler) 

It is wonderfully constructed from a normal socket, for which we have already established a connection in advance and boost :: asio :: io_context - the execution context of our application.



Now we need to start executing any command on the remote host and, as the data comes from it, give it to some callback.

 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(); } 

Thus, by running the command, we transfer control to the TryRead () method.

 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(); }); } 

First of all, we check if the reading process has already been started by some previous call. If not, we begin to expect the readiness of the socket for reading. As a wait handler, the usual lambda with the capture of shared_from_this () is used.

Pay attention to the WantRead () call. Async_wait, as it turned out, also has its flaws, and can just return on timeout. In order not to perform unnecessary actions in this case, I decided to check the socket through poll without a timeout - whether the socket really wants to read now. If not, then we simply run TryRead () again and wait. Otherwise, we immediately proceed to reading and transferring data to the callback.

 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; } 

Thus, an infinite asynchronous read loop from the running application starts. The next step for us is to send instructions to the application:

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

The data transferred to the asynchronous recording and callback will be stored inside the connection. And we will start the next cycle, only this time the entries:


Thus, we will write data to the channel until all of them have been successfully transmitted. Then we will return control to the caller so that you can transfer a new piece of data. So you can not only send instructions to some application on the host, but also, for example, download files of any size in small portions without blocking the thread, which is important.

Using this library, I was able to successfully run a script on a remote server that monitors file system changes, simultaneously reading its output and sending various commands. In general: a very valuable experience adapting the C-style library for a modern C ++ project that uses Boost.

I would be happy to read the advice of more experienced users of Boost.Asio to learn more and improve your solution :-).