IPLD selectors stub (#92)

Author: sergkaprovich

core/storage/ipfs/merkledag/impl/merkledag_service_impl.cpp

@@ -6,16 +6,21 @@
 #include "storage/ipfs/merkledag/impl/merkledag_service_impl.hpp"
 
 #include <boost/assert.hpp>
+#include <libp2p/multi/content_identifier_codec.hpp>
 #include "storage/ipfs/merkledag/impl/node_impl.hpp"
 
+using libp2p::multi::ContentIdentifierCodec;
+
 namespace fc::storage::ipfs::merkledag {
-  MerkleDagServiceImpl::MerkleDagServiceImpl(std::shared_ptr<BlockService> service)
+  MerkleDagServiceImpl::MerkleDagServiceImpl(
+      std::shared_ptr<BlockService> service)
       : block_service_{std::move(service)} {
     BOOST_ASSERT_MSG(block_service_ != nullptr,
                      "MerkleDAG service: Block service not connected");
   }
 
-  outcome::result<void> MerkleDagServiceImpl::addNode(std::shared_ptr<const Node> node) {
+  outcome::result<void> MerkleDagServiceImpl::addNode(
+      std::shared_ptr<const Node> node) {
     return block_service_->addBlock(*node);
   }
 
@@ -29,6 +34,30 @@ namespace fc::storage::ipfs::merkledag {
     return block_service_->removeBlock(cid);
   }
 
+  outcome::result<size_t> MerkleDagServiceImpl::select(
+      gsl::span<const uint8_t> root_cid,
+      gsl::span<const uint8_t> selector,
+      std::function<bool(std::shared_ptr<const Node>)> handler) const {
+    std::ignore = selector;
+    OUTCOME_TRY(content_id, ContentIdentifierCodec::decode(root_cid));
+    CID cid{std::move(content_id)};
+    OUTCOME_TRY(root_node, getNode(cid));
+    std::vector<std::shared_ptr<const Node>> node_set{};
+    node_set.emplace_back(std::move(root_node));
+    const auto &links = node_set.front()->getLinks();
+    for (const auto& link : links) {
+      auto request = getNode(link.get().getCID());
+      if (request.has_error()) return ServiceError::UNRESOLVED_LINK;
+      node_set.emplace_back(std::move(request.value()));
+    }
+    size_t sent_count{};
+    for (const auto &node : node_set) {
+      ++sent_count;
+      if (!handler(node)) break;
+    }
+    return sent_count;
+  }
+
   outcome::result<std::shared_ptr<Leaf>> MerkleDagServiceImpl::fetchGraph(
       const CID &cid) const {
     OUTCOME_TRY(node, getNode(cid));
@@ -38,8 +67,9 @@ namespace fc::storage::ipfs::merkledag {
     return root_leaf;
   }
 
-  outcome::result<std::shared_ptr<Leaf>> MerkleDagServiceImpl::fetchGraphOnDepth(
-      const CID &cid, uint64_t depth) const {
+  outcome::result<std::shared_ptr<Leaf>>
+  MerkleDagServiceImpl::fetchGraphOnDepth(const CID &cid,
+                                          uint64_t depth) const {
     OUTCOME_TRY(node, getNode(cid));
     auto leaf = std::make_shared<LeafImpl>(node->content());
     auto result = buildGraph(leaf, node->getLinks(), true, depth, 0);

core/storage/ipfs/merkledag/impl/merkledag_service_impl.hpp

@@ -28,6 +28,12 @@ namespace fc::storage::ipfs::merkledag {
 
     outcome::result<void> removeNode(const CID &cid) override;
 
+    outcome::result<size_t> select(
+        gsl::span<const uint8_t> root_cid,
+        gsl::span<const uint8_t> selector,
+        std::function<bool(std::shared_ptr<const Node> node)> handler)
+        const override;
+
     outcome::result<std::shared_ptr<Leaf>> fetchGraph(
         const CID &cid) const override;
 

core/storage/ipfs/merkledag/merkledag_service.hpp

@@ -43,6 +43,20 @@ namespace fc::storage::ipfs::merkledag {
      */
     virtual outcome::result<void> removeNode(const CID &cid) = 0;
 
+    /**
+     * @brief Get nodes with IPLD-selector
+     * @param root_cid - bytes of the root Node CID
+     * @param selector - IPLD-selector raw bytes
+     * @param handler - receiver of the selected Nodes, should return false to
+     * break receiving process
+     * @return count of the received by handler Nodes
+     */
+    virtual outcome::result<size_t> select(
+        gsl::span<const uint8_t> root_cid,
+        gsl::span<const uint8_t> selector,
+        std::function<bool(std::shared_ptr<const Node> node)> handler)
+        const = 0;
+
     /**
      * @brief Fetcg graph from given root node
      * @param cid - identifier of the root node

test/core/storage/ipfs/merkledag/ipfs_merkledag_service_test.cpp

@@ -194,6 +194,29 @@ TEST_P(CommonFeaturesTest, FetchGraphSuccess) {
   ASSERT_EQ(fetched_structure, data.graph_structure);
 }
 
+/**
+ * @given Pre-generated nodes structure
+ * @when Selecting nodes from DAG service
+ * @then All operations must be successful and
+ *       selected nodes count must be count of root node children + 1 (self)
+ */
+TEST_P(CommonFeaturesTest, GraphSyncSelect) {
+  const size_t nodes_count = data.nodes.front()->getLinks().size() + 1;
+  EXPECT_OUTCOME_TRUE(
+      root_cid, ContentIdentifierCodec::encode(data.nodes.front()->getCID()));
+  std::vector<std::shared_ptr<const Node>> selected_nodes;
+  std::function<bool(std::shared_ptr<const Node>)> handler =
+      [&selected_nodes](std::shared_ptr<const Node> node) -> bool {
+    selected_nodes.emplace_back(std::move(node));
+    return true;
+  };
+  EXPECT_OUTCOME_TRUE(selected_count,
+                      merkledag_service_->select(
+                          root_cid, gsl::span<const uint8_t>{}, handler));
+  ASSERT_EQ(selected_nodes.size(), selected_count);
+  ASSERT_EQ(nodes_count, selected_count);
+}
+
 /**
  * Pre-generated nodes, CIDs and serialized graph structures
  * Reference CIDs was generated by https://github.com/ipfs/go-merkledag