Coroutine revamp

include/libp2p/basic/message_read_writer.hpp

@@ -8,6 +8,7 @@
 
 #include <memory>
 
+#include <boost/asio/awaitable.hpp>
 #include <libp2p/basic/readwriter.hpp>
 
 namespace libp2p::basic {
@@ -37,5 +38,18 @@ namespace libp2p::basic {
      * Quantity of bytes written is passed as an argument in case of success
      */
     virtual void write(BytesIn buffer, Writer::WriteCallbackFunc cb) = 0;
+
+    /**
+     * Reads a message that is prepended with its length (coroutine version)
+     * @return awaitable with result containing read bytes or an error
+     */
+    virtual boost::asio::awaitable<ReadCallback> read() = 0;
+
+    /**
+     * Writes a message and preprends its length (coroutine version)
+     * @param buffer - bytes to be written
+     * @return awaitable with result containing number of bytes written or an error
+     */
+    virtual boost::asio::awaitable<outcome::result<size_t>> write(BytesIn buffer) = 0;
   };
 }  // namespace libp2p::basic

include/libp2p/basic/reader.hpp

@@ -9,6 +9,7 @@
 #include <functional>
 #include <vector>
 
+#include <boost/asio/awaitable.hpp>
 #include <libp2p/common/types.hpp>
 #include <libp2p/outcome/outcome.hpp>
 
@@ -54,6 +55,13 @@ namespace libp2p::basic {
      * @param res read result
      * @param cb callback
      */
+
+    virtual boost::asio::awaitable<outcome::result<size_t>> read(
+        BytesOut out, size_t bytes) = 0;
+
+    virtual boost::asio::awaitable<outcome::result<size_t>> readSome(
+        BytesOut out, size_t bytes) = 0;
+
     virtual void deferReadCallback(outcome::result<size_t> res,
                                    ReadCallbackFunc cb) = 0;
   };

include/libp2p/basic/writer.hpp

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <boost/asio/awaitable.hpp>
 #include <functional>
 
 #include <libp2p/common/types.hpp>
@@ -34,6 +35,9 @@ namespace libp2p::basic {
      */
     virtual void writeSome(BytesIn in, size_t bytes, WriteCallbackFunc cb) = 0;
 
+    virtual boost::asio::awaitable<std::error_code> writeSome(BytesIn in,
+                                                              size_t bytes) = 0;
+
     /**
      * @brief Defers reporting error state to callback to avoid reentrancy
      * (i.e. callback will not be called before initiator function returns)

include/libp2p/connection/capable_connection.hpp

@@ -58,6 +58,13 @@ namespace libp2p::connection {
      */
     virtual void newStream(StreamHandlerFunc cb) = 0;
 
+    /**
+     * @brief Opens new stream in a coroutine manner
+     * @return Awaitable result of a new Stream or error
+     */
+    virtual boost::asio::awaitable<outcome::result<std::shared_ptr<Stream>>>
+    newStreamCoroutine() = 0;
+
     /**
      * @brief Set a handler, which is called, when a new stream arrives from the
      * other side

include/libp2p/connection/loopback_stream.hpp

@@ -39,6 +39,11 @@ namespace libp2p::connection {
     outcome::result<libp2p::multi::Multiaddress> remoteMultiaddr()
         const override;
 
+    // Coroutine-based methods
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in, size_t bytes) override;
+
    protected:
     void read(BytesOut out, size_t bytes, ReadCallbackFunc cb) override;
 

include/libp2p/layer/layer_adaptor.hpp

@@ -32,6 +32,14 @@ namespace libp2p::layer {
         std::shared_ptr<connection::LayerConnection> conn,
         LayerConnCallbackFunc cb) const = 0;
 
+    /**
+     * Coroutine version of upgradeInbound
+     * @param conn - connection to be upgraded
+     * @return result with upgraded connection or error
+     */
+    virtual boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>> upgradeInbound(
+        std::shared_ptr<connection::LayerConnection> conn) const = 0;
+
     /**
      * Make a next-layer connection from the current-layer one, using this
      * adaptor
@@ -42,5 +50,15 @@ namespace libp2p::layer {
         const multi::Multiaddress &address,
         std::shared_ptr<connection::LayerConnection> conn,
         LayerConnCallbackFunc cb) const = 0;
+
+    /**
+     * Coroutine version of upgradeOutbound
+     * @param address - multiaddress of the remote peer
+     * @param conn - connection to be upgraded
+     * @return result with upgraded connection or error
+     */
+    virtual boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>> upgradeOutbound(
+        const multi::Multiaddress &address,
+        std::shared_ptr<connection::LayerConnection> conn) const = 0;
   };
 }  // namespace libp2p::layer

include/libp2p/layer/websocket/ssl_connection.hpp

@@ -40,6 +40,13 @@ namespace libp2p::connection {
     void writeSome(BytesIn in, size_t bytes, WriteCallbackFunc cb) override;
     void deferWriteCallback(std::error_code ec, WriteCallbackFunc cb) override;
 
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out,
+                                                         size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(
+        BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in,
+                                                      size_t bytes) override;
+
    private:
     std::shared_ptr<LayerConnection> connection_;
     std::shared_ptr<boost::asio::ssl::context> ssl_context_;

include/libp2p/layer/websocket/ws_adaptor.hpp

@@ -11,6 +11,7 @@
 #include <libp2p/layer/websocket/ws_connection.hpp>
 #include <libp2p/layer/websocket/ws_connection_config.hpp>
 #include <libp2p/network/connection_manager.hpp>
+#include <boost/asio/awaitable.hpp>
 
 namespace libp2p::layer {
 
@@ -25,10 +26,17 @@ namespace libp2p::layer {
     void upgradeInbound(std::shared_ptr<connection::LayerConnection> conn,
                         LayerConnCallbackFunc cb) const override;
 
+    boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>>
+    upgradeInbound(std::shared_ptr<connection::LayerConnection> conn) const override;
+
     void upgradeOutbound(const multi::Multiaddress &address,
                          std::shared_ptr<connection::LayerConnection> conn,
                          LayerConnCallbackFunc cb) const override;
 
+    boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>>
+    upgradeOutbound(const multi::Multiaddress &address,
+                    std::shared_ptr<connection::LayerConnection> conn) const override;
+
    private:
     std::shared_ptr<basic::Scheduler> scheduler_;
     std::shared_ptr<boost::asio::io_context> io_context_;

include/libp2p/layer/websocket/ws_connection.hpp

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <boost/beast/websocket.hpp>
+#include <boost/asio/awaitable.hpp>
 
 #include <libp2p/basic/scheduler.hpp>
 #include <libp2p/common/metrics/instance_count.hpp>
@@ -79,6 +80,13 @@ namespace libp2p::connection {
 
     void deferWriteCallback(std::error_code ec, WriteCallbackFunc cb) override;
 
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out,
+                                                         size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(
+        BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in,
+                                                      size_t bytes) override;
+
    private:
     void setTimerPing();
     void onPong(BytesIn payload);

include/libp2p/layer/websocket/wss_adaptor.hpp

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <libp2p/layer/layer_adaptor.hpp>
+#include <boost/asio/awaitable.hpp>
 
 namespace boost::asio {
   class io_context;
@@ -36,10 +37,17 @@ namespace libp2p::layer {
     void upgradeInbound(std::shared_ptr<connection::LayerConnection> conn,
                         LayerConnCallbackFunc cb) const override;
 
+    boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>>
+    upgradeInbound(std::shared_ptr<connection::LayerConnection> conn) const override;
+
     void upgradeOutbound(const multi::Multiaddress &address,
                          std::shared_ptr<connection::LayerConnection> conn,
                          LayerConnCallbackFunc cb) const override;
 
+    boost::asio::awaitable<outcome::result<std::shared_ptr<connection::LayerConnection>>>
+    upgradeOutbound(const multi::Multiaddress &address,
+                    std::shared_ptr<connection::LayerConnection> conn) const override;
+
    private:
     std::shared_ptr<boost::asio::io_context> io_context_;
     WssCertificate server_certificate_;

include/libp2p/muxer/mplex/mplex_stream.hpp

@@ -10,6 +10,7 @@
 #include <mutex>
 
 #include <boost/asio/streambuf.hpp>
+#include <boost/asio/awaitable.hpp>
 #include <boost/noncopyable.hpp>
 #include <libp2p/connection/stream.hpp>
 #include <libp2p/log/logger.hpp>
@@ -61,6 +62,10 @@ namespace libp2p::connection {
 
     void deferWriteCallback(std::error_code ec, WriteCallbackFunc cb) override;
 
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in, size_t bytes) override;
+
     bool isClosed() const override;
 
     void close(VoidResultHandlerFunc cb) override;

include/libp2p/muxer/mplex/mplexed_connection.hpp

@@ -68,6 +68,10 @@ namespace libp2p::connection {
     void readSome(BytesOut out, size_t bytes, ReadCallbackFunc cb) override;
     void writeSome(BytesIn in, size_t bytes, WriteCallbackFunc cb) override;
 
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in, size_t bytes) override;
+
     void deferReadCallback(outcome::result<size_t> res,
                            ReadCallbackFunc cb) override;
     void deferWriteCallback(std::error_code ec, WriteCallbackFunc cb) override;

include/libp2p/muxer/muxer_adaptor.hpp

@@ -31,5 +31,15 @@ namespace libp2p::muxer {
     virtual void muxConnection(
         std::shared_ptr<connection::SecureConnection> conn,
         CapConnCallbackFunc cb) const = 0;
+
+    /**
+     * Make a muxed connection from the secure one, using this adaptor
+     * (coroutine version)
+     * @param conn - connection to be upgraded
+     * @return awaitable with result containing upgraded connection or error
+     */
+    virtual boost::asio::awaitable<
+        outcome::result<std::shared_ptr<connection::CapableConnection>>>
+    muxConnection(std::shared_ptr<connection::SecureConnection> conn) const = 0;
   };
 }  // namespace libp2p::muxer

include/libp2p/muxer/yamux/yamux.hpp

@@ -32,6 +32,17 @@ namespace libp2p::muxer {
     void muxConnection(std::shared_ptr<connection::SecureConnection> conn,
                        CapConnCallbackFunc cb) const override;
 
+    /**
+     * Make a muxed connection from the secure one, using this adaptor
+     * (coroutine version)
+     * @param conn - connection to be upgraded
+     * @return awaitable with result containing upgraded connection or error
+     */
+    boost::asio::awaitable<
+        outcome::result<std::shared_ptr<connection::CapableConnection>>>
+    muxConnection(
+        std::shared_ptr<connection::SecureConnection> conn) const override;
+
    private:
     MuxedConnectionConfig config_;
     std::shared_ptr<basic::Scheduler> scheduler_;

include/libp2p/muxer/yamux/yamux_stream.hpp

@@ -85,6 +85,14 @@ namespace libp2p::connection {
 
     outcome::result<multi::Multiaddress> remoteMultiaddr() const override;
 
+    // Coroutine-based methods
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out,
+                                                         size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(
+        BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in,
+                                                      size_t bytes) override;
+
     /// Increases send window. Called from Connection
     void increaseSendWindow(size_t delta);
 

include/libp2p/muxer/yamux/yamuxed_connection.hpp

@@ -56,6 +56,9 @@ namespace libp2p::connection {
 
     void newStream(StreamHandlerFunc cb) override;
 
+    boost::asio::awaitable<outcome::result<std::shared_ptr<Stream>>>
+    newStreamCoroutine();
+
     void onStream(NewStreamHandlerFunc cb) override;
 
     outcome::result<peer::PeerId> localPeer() const override;
@@ -78,6 +81,14 @@ namespace libp2p::connection {
                            ReadCallbackFunc cb) override;
     void deferWriteCallback(std::error_code ec, WriteCallbackFunc cb) override;
 
+    // Coroutine-based methods
+    boost::asio::awaitable<outcome::result<size_t>> read(BytesOut out,
+                                                         size_t bytes) override;
+    boost::asio::awaitable<outcome::result<size_t>> readSome(
+        BytesOut out, size_t bytes) override;
+    boost::asio::awaitable<std::error_code> writeSome(BytesIn in,
+                                                      size_t bytes) override;
+
    private:
     using Streams = std::unordered_map<StreamId, std::shared_ptr<YamuxStream>>;
 

include/libp2p/network/impl/listener_manager_impl.hpp

@@ -38,6 +38,9 @@ namespace libp2p::network {
 
     outcome::result<void> listen(const multi::Multiaddress &ma) override;
 
+    boost::asio::awaitable<outcome::result<void>> listenCoroutine(
+        const multi::Multiaddress &ma) override;
+
     std::vector<multi::Multiaddress> getListenAddresses() const override;
 
     std::vector<multi::Multiaddress> getListenAddressesInterfaces()
@@ -49,6 +52,10 @@ namespace libp2p::network {
         outcome::result<std::shared_ptr<connection::CapableConnection>> rconn)
         override;
 
+    void onConnectionCoro(
+        outcome::result<std::shared_ptr<connection::CapableConnection>> rconn)
+        override;
+
    private:
     bool started = false;
 

include/libp2p/network/listener_manager.hpp

@@ -73,6 +73,8 @@ namespace libp2p::network {
      */
     virtual outcome::result<void> listen(const multi::Multiaddress &ma) = 0;
 
+    virtual boost::asio::awaitable<outcome::result<void>> listenCoroutine(
+        const multi::Multiaddress &ma) = 0;
     /**
      * @brief Returns an unmodified list of addresses, added by user.
      */
@@ -98,6 +100,10 @@ namespace libp2p::network {
     virtual void onConnection(
         outcome::result<std::shared_ptr<connection::CapableConnection>>
             rconn) = 0;
+
+    virtual void onConnectionCoro(
+        outcome::result<std::shared_ptr<connection::CapableConnection>>
+            rconn) = 0;
   };
 
 }  // namespace libp2p::network

include/libp2p/protocol_muxer/multiselect.hpp

@@ -29,6 +29,13 @@ namespace libp2p::protocol_muxer::multiselect {
                      bool negotiate_multiselect,
                      ProtocolHandlerFunc cb) override;
 
+    /// Implements coroutine version of ProtocolMuxer API
+    boost::asio::awaitable<outcome::result<peer::ProtocolName>> selectOneOf(
+        std::span<const peer::ProtocolName> protocols,
+        std::shared_ptr<basic::ReadWriter> connection,
+        bool is_initiator,
+        bool negotiate_multistream) override;
+
     /// Simple single stream negotiate procedure
     void simpleStreamNegotiate(
         const std::shared_ptr<connection::Stream> &stream,