Feature: user agent repo

include/libp2p/host/basic_host.hpp

@@ -227,9 +227,11 @@ namespace libp2p::host {
     /**
      * Get list of protocols that were passed to `listenProtocol`.
      */
-    StreamProtocols getSupportedProtocols() const;
+    [[nodiscard]] StreamProtocols getSupportedProtocols() const;
 
-    size_t getConnectedPeerCount() const;
+    [[nodiscard]] std::vector<PeerId> getConnectedPeers() const;
+
+    [[nodiscard]] size_t getConnectedPeerCount() const;
 
    private:
     std::shared_ptr<peer::IdentityManager> idmgr_;

include/libp2p/injector/host_injector.hpp

@@ -24,6 +24,7 @@
 #include <libp2p/peer/key_repository/inmem_key_repository.hpp>
 #include <libp2p/peer/peer_repository.hpp>
 #include <libp2p/peer/protocol_repository/inmem_protocol_repository.hpp>
+#include <libp2p/peer/user_agent_repository/inmem_user_agent_repository.hpp>
 #include <libp2p/protocol/gossip/config.hpp>
 #include <libp2p/protocol_muxer/multiselect.hpp>
 
@@ -98,6 +99,7 @@ namespace libp2p::injector {
         di::bind<peer::KeyRepository>.to<peer::InmemKeyRepository>(),
         di::bind<peer::AddressRepository>.to<peer::InmemAddressRepository>(),
         di::bind<peer::ProtocolRepository>.to<peer::InmemProtocolRepository>(),
+        di::bind<peer::UserAgentRepository>.to<peer::InmemUserAgentRepository>(),
         di::bind<protocol_muxer::ProtocolMuxer>.to<protocol_muxer::multiselect::Multiselect>(),
         di::bind<crypto::validator::KeyValidator>.to<crypto::validator::KeyValidatorImpl>(),
         di::bind<crypto::CryptoProvider>.to<crypto::CryptoProviderImpl>(),

include/libp2p/network/connection_manager.hpp

@@ -58,7 +58,9 @@ namespace libp2p::network {
         const peer::PeerId &peer_id,
         const std::shared_ptr<connection::CapableConnection> &conn);
 
-    size_t getConnectedPeerCount() const;
+    [[nodiscard]] std::vector<PeerId> getConnectedPeers() const;
+
+    [[nodiscard]] size_t getConnectedPeerCount() const;
 
    private:
     std::unordered_map<peer::PeerId, std::unordered_set<ConnectionSPtr>>

include/libp2p/peer/peer_repository.hpp

@@ -13,6 +13,7 @@
 #include <libp2p/peer/peer_id.hpp>
 #include <libp2p/peer/peer_info.hpp>
 #include <libp2p/peer/protocol_repository.hpp>
+#include <libp2p/peer/user_agent_repository.hpp>
 
 namespace libp2p::peer {
   /**
@@ -21,9 +22,10 @@ namespace libp2p::peer {
    */
   class PeerRepository {
    public:
-    PeerRepository(std::shared_ptr<AddressRepository> addrRepo,
-                   std::shared_ptr<KeyRepository> keyRepo,
-                   std::shared_ptr<ProtocolRepository> protocolRepo);
+    PeerRepository(std::shared_ptr<AddressRepository> addr_repo,
+                   std::shared_ptr<KeyRepository> key_repo,
+                   std::shared_ptr<ProtocolRepository> protocol_repo,
+                   std::shared_ptr<UserAgentRepository> uagent_repo);
     /**
      * @brief Getter for an address repository.
      * @return associated instance of an address repository.
@@ -42,11 +44,17 @@ namespace libp2p::peer {
      */
     ProtocolRepository &getProtocolRepository();
 
+    /**
+     * @brief Getter for a user-agent repository.
+     * @return associated instance of a protocol repository.
+     */
+    UserAgentRepository &getUserAgentRepository();
+
     /**
      * @brief Returns set of peer ids known by this peer repository.
      * @return unordered set of peers
      */
-    std::unordered_set<PeerId> getPeers() const;
+    [[nodiscard]] std::unordered_set<PeerId> getPeers() const;
 
     /**
      * @brief Derive a PeerInfo object from the PeerId; can be useful, for
@@ -55,11 +63,12 @@ namespace libp2p::peer {
      * @param peer_id to get PeerInfo for
      * @return PeerInfo
      */
-    PeerInfo getPeerInfo(const PeerId &peer_id) const;
+    [[nodiscard]] PeerInfo getPeerInfo(const PeerId &peer_id) const;
 
    private:
     std::shared_ptr<AddressRepository> addr_;
     std::shared_ptr<KeyRepository> key_;
     std::shared_ptr<ProtocolRepository> proto_;
+    std::shared_ptr<UserAgentRepository> uagent_;
   };
 }  // namespace libp2p::peer

include/libp2p/peer/user_agent_repository.hpp

@@ -0,0 +1,56 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+#include <libp2p/peer/peer_id.hpp>
+
+namespace libp2p::peer {
+
+  /**
+   * @brief Storage for mapping between peer and its known protocols.
+   */
+  class UserAgentRepository {
+   public:
+    virtual ~UserAgentRepository() = default;
+
+    /**
+     * @brief Set agent for a peer.
+     * @param p peer
+     * @param agent type of agent-name
+     * @return peer error, if no peer {@param p} found
+     */
+    virtual void setUserAgent(const PeerId &p, std::string_view ua) = 0;
+
+    /**
+     * @brief Removes user-agent of the peer.
+     * @param p peer
+     * @return peer error, if no peer {@param p} found
+     */
+    virtual void unsetUserAgent(const PeerId &) = 0;
+
+    /**
+     * @brief Get user-agent by given peer {@param p}
+     * @param p peer
+     * @return user-agent (may be "unknown") or peer error, if no peer
+     * {@param p} found
+     */
+    [[nodiscard]] virtual std::optional<std::string> getUserAgent(
+        const PeerId &p) const = 0;
+
+    /**
+     * @brief Returns set of peer ids known by this repository.
+     * @return unordered set of peers
+     */
+    [[nodiscard]] virtual std::unordered_set<PeerId> getPeers() const = 0;
+  };
+
+}  // namespace libp2p::peer

include/libp2p/peer/user_agent_repository/inmem_user_agent_repository.hpp

@@ -0,0 +1,37 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <optional>
+#include <unordered_map>
+
+#include <libp2p/peer/user_agent_repository.hpp>
+
+namespace libp2p::peer {
+
+  /**
+   * @brief In-memory implementation of UserAgent repository. For each peer
+   * stores UserAgent data.
+   */
+  class InmemUserAgentRepository : public UserAgentRepository {
+   public:
+    ~InmemUserAgentRepository() override = default;
+
+    void setUserAgent(const PeerId &p, std::string_view ua) override;
+
+    void unsetUserAgent(const PeerId &p) override;
+
+    [[nodiscard]] std::optional<std::string> getUserAgent(
+        const PeerId &p) const override;
+
+    [[nodiscard]] std::unordered_set<PeerId> getPeers() const override;
+
+   private:
+    std::unordered_map<PeerId, std::string> db_;
+  };
+
+}  // namespace libp2p::peer

src/CMakeLists.txt

@@ -41,6 +41,7 @@ target_link_libraries(libp2p
         p2p_inmem_address_repository
         p2p_inmem_key_repository
         p2p_inmem_protocol_repository
+        p2p_inmem_user_agent_repository
         p2p_key_validator
         p2p_listener_manager
         p2p_literals

src/host/basic_host.cpp

@@ -239,6 +239,10 @@ namespace libp2p::host {
     return listener_->getSupportedProtocols();
   }
 
+  std::vector<PeerId> BasicHost::getConnectedPeers() const {
+    return connection_manager_->getConnectedPeers();
+  }
+
   size_t BasicHost::getConnectedPeerCount() const {
     return connection_manager_->getConnectedPeerCount();
   }

src/network/connection_manager.cpp

@@ -7,6 +7,7 @@
 #include <libp2p/network/connection_manager.hpp>
 
 #include <algorithm>
+#include <ranges>
 
 namespace libp2p::network {
 
@@ -166,6 +167,11 @@ namespace libp2p::network {
     }
   }
 
+  std::vector<PeerId> ConnectionManager::getConnectedPeers() const {
+    return connections_ | std::views::keys
+         | std::ranges::to<std::vector<PeerId>>();
+  }
+
   size_t ConnectionManager::getConnectedPeerCount() const {
     return connections_.size();
   }

src/peer/CMakeLists.txt

@@ -7,6 +7,7 @@
 add_subdirectory(address_repository)
 add_subdirectory(key_repository)
 add_subdirectory(protocol_repository)
+add_subdirectory(user_agent_repository)
 
 libp2p_add_library(p2p_peer_errors
     errors.cpp

src/peer/peer_repository.cpp

@@ -23,13 +23,16 @@ namespace libp2p::peer {
   PeerRepository::PeerRepository(
       std::shared_ptr<AddressRepository> addr_repo,
       std::shared_ptr<KeyRepository> key_repo,
-      std::shared_ptr<ProtocolRepository> protocol_repo)
+      std::shared_ptr<ProtocolRepository> protocol_repo,
+      std::shared_ptr<UserAgentRepository> uagent_repository)
       : addr_(std::move(addr_repo)),
         key_(std::move(key_repo)),
-        proto_(std::move(protocol_repo)) {
+        proto_(std::move(protocol_repo)) ,
+        uagent_(std::move(uagent_repository)) {
     BOOST_ASSERT(addr_ != nullptr);
     BOOST_ASSERT(key_ != nullptr);
     BOOST_ASSERT(proto_ != nullptr);
+    BOOST_ASSERT(uagent_ != nullptr);
   }
 
   AddressRepository &PeerRepository::getAddressRepository() {
@@ -44,6 +47,10 @@ namespace libp2p::peer {
     return *proto_;
   }
 
+  UserAgentRepository &PeerRepository::getUserAgentRepository() {
+    return *uagent_;
+  }
+
   std::unordered_set<PeerId> PeerRepository::getPeers() const {
     std::unordered_set<PeerId> peers;
     merge_sets<PeerId>(peers, addr_->getPeers());

src/peer/user_agent_repository/CMakeLists.txt

@@ -0,0 +1,15 @@
+#
+# Copyright Quadrivium LLC
+# All Rights Reserved
+# SPDX-License-Identifier: Apache-2.0
+#
+
+libp2p_add_library(p2p_inmem_user_agent_repository
+        inmem_user_agent_repository.cpp
+    )
+target_link_libraries(p2p_inmem_user_agent_repository
+    Boost::boost
+    p2p_peer_errors
+    p2p_multihash
+    p2p_peer_id
+    )

src/peer/user_agent_repository/inmem_user_agent_repository.cpp

@@ -0,0 +1,38 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <libp2p/peer/user_agent_repository/inmem_user_agent_repository.hpp>
+
+#include <ranges>
+
+#include <libp2p/peer/errors.hpp>
+
+namespace libp2p::peer {
+
+  void InmemUserAgentRepository::setUserAgent(const PeerId &p,
+                                              std::string_view ua) {
+    db_.insert_or_assign(p, ua);
+  }
+
+  void InmemUserAgentRepository::unsetUserAgent(const PeerId &p) {
+    db_.erase(p);
+  }
+
+  std::optional<std::string> InmemUserAgentRepository::getUserAgent(
+      const PeerId &p) const {
+    if (auto it = db_.find(p); it != db_.end()) {
+      return it->second;
+    }
+    return std::nullopt;
+  }
+
+  std::unordered_set<PeerId> InmemUserAgentRepository::getPeers() const {
+    return db_
+         | std::ranges::views::transform([](const auto &p) { return p.first; })
+         | std::ranges::to<std::unordered_set<PeerId>>();
+  }
+
+}  // namespace libp2p::peer

src/protocol/identify/identify.cpp

@@ -120,6 +120,8 @@ namespace libp2p::protocol {
           .upsertAddresses(
               peer_id, message.listen_addresses, peer::ttl::kRecentlyConnected)
           .value();
+      auto &user_agent_repo = peer_repo.getUserAgentRepository();
+      user_agent_repo.setUserAgent(peer_id, message.agent_version);
 
       host_->getBus().getChannel<OnIdentifyChannel>().publish(message);
       co_return outcome::success();

src/protocol/ping.cpp

@@ -102,7 +102,7 @@ namespace libp2p::protocol {
     }
     auto stream = stream_result.value();
     auto res = co_await ping(stream, timeout);
-    stream->close();
+    std::ignore = stream->close();
     co_return res;
   }