Merge remote-tracking branch 'origin/master' into refactor/1

Author: turuslan

include/libp2p/multi/multiaddress.hpp

@@ -18,6 +18,10 @@
 #include <libp2p/multi/multiaddress_protocol_list.hpp>
 #include <libp2p/outcome/outcome.hpp>
 
+namespace libp2p {
+  using ProtoAddrVec = std::vector<std::pair<multi::Protocol, std::string>>;
+}  // namespace libp2p
+
 namespace libp2p::multi {
 
   /**
@@ -147,8 +151,7 @@ namespace libp2p::multi {
      * @return list of pairs with a protocol as the first element and the value
      * as the second one
      */
-    std::vector<std::pair<Protocol, std::string>> getProtocolsWithValues()
-        const;
+    ProtoAddrVec getProtocolsWithValues() const;
 
     bool operator==(const Multiaddress &other) const;
 

include/libp2p/muxer/yamux/yamuxed_connection.hpp

@@ -198,6 +198,8 @@ namespace libp2p::connection {
     /// True if waiting for current write operation to complete
     bool is_writing_ = false;
 
+    std::shared_ptr<Bytes> writing_buf_ = std::make_shared<Bytes>();
+
     /// Write queue
     std::deque<WriteQueueItem> write_queue_;
 

include/libp2p/transport/impl/upgrader_session.hpp

@@ -19,7 +19,6 @@ namespace libp2p::transport {
    */
   struct UpgraderSession
       : public std::enable_shared_from_this<UpgraderSession> {
-    using ProtoAddrVec = std::vector<std::pair<multi::Protocol, std::string>>;
     using ConnectionCallback =
         void(outcome::result<std::shared_ptr<connection::CapableConnection>>);
     using HandlerFunc = std::function<ConnectionCallback>;

include/libp2p/transport/tcp/tcp_connection.hpp

@@ -39,9 +39,11 @@ namespace libp2p::transport {
     using ConnectCallback = void(const ErrorCode &, const Tcp::endpoint &);
     using ConnectCallbackFunc = std::function<ConnectCallback>;
 
-    explicit TcpConnection(boost::asio::io_context &ctx);
+    explicit TcpConnection(boost::asio::io_context &ctx, ProtoAddrVec layers);
 
-    TcpConnection(boost::asio::io_context &ctx, Tcp::socket &&socket);
+    TcpConnection(boost::asio::io_context &ctx,
+                  ProtoAddrVec layers,
+                  Tcp::socket &&socket);
 
     /**
      * @brief Resolve service name (DNS).
@@ -122,6 +124,7 @@ namespace libp2p::transport {
     outcome::result<void> saveMultiaddresses();
 
     boost::asio::io_context &context_;
+    ProtoAddrVec layers_;
     Tcp::socket socket_;
     bool initiator_ = false;
     bool connecting_with_timeout_ = false;

include/libp2p/transport/tcp/tcp_listener.hpp

@@ -20,8 +20,6 @@ namespace libp2p::transport {
   class TcpListener : public TransportListener,
                       public std::enable_shared_from_this<TcpListener> {
    public:
-    using ProtoAddrVec = std::vector<std::pair<multi::Protocol, std::string>>;
-
     ~TcpListener() override = default;
 
     TcpListener(boost::asio::io_context &context,

include/libp2p/transport/tcp/tcp_util.hpp

@@ -16,9 +16,7 @@
 namespace libp2p::transport::detail {
   template <typename T>
   inline outcome::result<multi::Multiaddress> makeAddress(
-      T &&endpoint,
-      const std::vector<std::pair<multi::Protocol, std::string>> *layers =
-          nullptr) {
+      T &&endpoint, const ProtoAddrVec *layers = nullptr) {
     try {
       auto address = endpoint.address();
       auto port = endpoint.port();
@@ -97,8 +95,6 @@ namespace libp2p::transport::detail {
     return {host, port};
   }
 
-  using ProtoAddrVec = std::vector<std::pair<multi::Protocol, std::string>>;
-
   // Obtain layers string from provided address
   inline ProtoAddrVec getLayers(const multi::Multiaddress &address) {
     auto v = address.getProtocolsWithValues();

include/libp2p/transport/upgrader.hpp

@@ -22,8 +22,6 @@ namespace libp2p::transport {
    * and using the chosen protocols to actually upgrade the connections
    */
   struct Upgrader {
-    using ProtoAddrVec = std::vector<std::pair<multi::Protocol, std::string>>;
-
     using RawSPtr = std::shared_ptr<connection::RawConnection>;
     using LayerSPtr = std::shared_ptr<connection::LayerConnection>;
     using SecSPtr = std::shared_ptr<connection::SecureConnection>;

src/muxer/yamux/yamuxed_connection.cpp

@@ -649,16 +649,17 @@ namespace libp2p::connection {
   void YamuxedConnection::doWrite(WriteQueueItem packet) {
     assert(!is_writing_);
 
-    auto span = BytesIn(packet.packet);
+    writing_buf_->assign(packet.packet.begin(), packet.packet.end());
     auto cb = [wptr{weak_from_this()},
+               buf{writing_buf_},
                packet = std::move(packet)](outcome::result<size_t> res) {
       if (auto self = wptr.lock()) {
         self->onDataWritten(res, packet.stream_id);
       }
     };
 
     is_writing_ = true;
-    writeReturnSize(connection_, span, cb);
+    writeReturnSize(connection_, *writing_buf_, cb);
   }
 
   void YamuxedConnection::onDataWritten(outcome::result<size_t> res,

src/transport/tcp/tcp_connection.cpp

@@ -23,16 +23,20 @@ namespace libp2p::transport {
   }  // namespace
 
   TcpConnection::TcpConnection(boost::asio::io_context &ctx,
+                               ProtoAddrVec layers,
                                boost::asio::ip::tcp::socket &&socket)
       : context_(ctx),
+        layers_{std::move(layers)},
         socket_(std::move(socket)),
         connection_phase_done_{false},
         deadline_timer_(context_) {
     std::ignore = saveMultiaddresses();
   }
 
-  TcpConnection::TcpConnection(boost::asio::io_context &ctx)
+  TcpConnection::TcpConnection(boost::asio::io_context &ctx,
+                               ProtoAddrVec layers)
       : context_(ctx),
+        layers_{std::move(layers)},
         socket_(context_),
         connection_phase_done_{false},
         deadline_timer_(context_) {}
@@ -281,15 +285,15 @@ namespace libp2p::transport {
       if (!local_multiaddress_) {
         auto endpoint(socket_.local_endpoint(ec));
         if (!ec) {
-          OUTCOME_TRY(addr, detail::makeAddress(endpoint));
-          local_multiaddress_ = std::move(addr);
+          BOOST_OUTCOME_TRY(local_multiaddress_,
+                            detail::makeAddress(endpoint, &layers_));
         }
       }
       if (!remote_multiaddress_) {
         auto endpoint(socket_.remote_endpoint(ec));
         if (!ec) {
-          OUTCOME_TRY(addr, detail::makeAddress(endpoint));
-          remote_multiaddress_ = std::move(addr);
+          BOOST_OUTCOME_TRY(remote_multiaddress_,
+                            detail::makeAddress(endpoint, &layers_));
         }
       }
     } else {

src/transport/tcp/tcp_listener.cpp

@@ -95,8 +95,8 @@ namespace libp2p::transport {
             return self->handle_(ec);
           }
 
-          auto conn =
-              std::make_shared<TcpConnection>(self->context_, std::move(sock));
+          auto conn = std::make_shared<TcpConnection>(
+              self->context_, self->layers_, std::move(sock));
 
           auto session = std::make_shared<UpgraderSession>(
               self->upgrader_, self->layers_, std::move(conn), self->handle_);