IPLD format refactor

Author: sergkaprovich

core/primitives/persistent_block/persistent_block.cpp

@@ -15,7 +15,7 @@ namespace fc::primitives::blockchain::block {
     return cid_;
   }
 
-  const common::Buffer  &PersistentBlock::getRawBytes() const {
+  const common::Buffer &PersistentBlock::getRawBytes() const {
     return data_;
   }
 

core/primitives/persistent_block/persistent_block.hpp

@@ -6,10 +6,10 @@
 #ifndef CPP_FILECOIN_CORE_BLOCKCHAIN_BLOCK_PERSISTENT_BLOCK_HPP
 #define CPP_FILECOIN_CORE_BLOCKCHAIN_BLOCK_PERSISTENT_BLOCK_HPP
 
-#include "storage/ipfs/ipfs_block.hpp"
+#include "storage/ipld/ipld_block.hpp"
 
 namespace fc::primitives::blockchain::block {
-  class PersistentBlock : public storage::ipfs::IpfsBlock {
+  class PersistentBlock : public storage::ipld::IPLDBlock {
    public:
     virtual ~PersistentBlock() override = default;
 

core/storage/CMakeLists.txt

@@ -10,6 +10,7 @@ add_subdirectory(filestore)
 add_subdirectory(hamt)
 add_subdirectory(in_memory)
 add_subdirectory(ipfs)
+add_subdirectory(ipld)
 add_subdirectory(keystore)
 add_subdirectory(leveldb)
 add_subdirectory(repository)

core/storage/ipfs/ipfs_block.hpp

@@ -1,34 +1,15 @@
-find_package(Protobuf REQUIRED)
-set(PB_SCHEME "merkledag.proto")
-set(PB_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR})
-
-execute_process(COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} --cpp_out=${PB_BUILD_DIR} ${PB_SCHEME}
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/impl/protobuf
-    RESULT_VARIABLE CMD_OUTPUT
-    )
-
-add_library(ipfs_merkledag_service_protobuf
-    ${PB_BUILD_DIR}/merkledag.pb.h
-    ${PB_BUILD_DIR}/merkledag.pb.cc
-    )
-target_include_directories(ipfs_merkledag_service_protobuf PUBLIC ${PB_BUILD_DIR})
-target_link_libraries(ipfs_merkledag_service_protobuf
-    protobuf::libprotobuf
-    )
-disable_clang_tidy(ipfs_merkledag_service_protobuf)
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
 
 add_library(ipfs_merkledag_service
-    impl/link_impl.cpp
-    impl/node_impl.cpp
     impl/merkledag_service_impl.cpp
-    impl/pb_node_encoder.cpp
-    impl/pb_node_decoder.cpp
     impl/leaf_impl.cpp
     )
 target_link_libraries(ipfs_merkledag_service
-    cid
     Boost::boost
+    ipld_node
     ipfs_blockservice
     ipfs_datastore_in_memory
-    ipfs_merkledag_service_protobuf
     )

core/storage/ipfs/merkledag/CMakeLists.txt

@@ -7,11 +7,13 @@
 
 #include <boost/assert.hpp>
 #include <libp2p/multi/content_identifier_codec.hpp>
-#include "storage/ipfs/merkledag/impl/node_impl.hpp"
+#include "storage/ipld/impl/ipld_node_impl.hpp"
 
 using libp2p::multi::ContentIdentifierCodec;
 
 namespace fc::storage::ipfs::merkledag {
+  using ipld::IPLDNodeImpl;
+
   MerkleDagServiceImpl::MerkleDagServiceImpl(
       std::shared_ptr<IpfsDatastore> service)
       : block_service_{std::move(service)} {
@@ -20,14 +22,14 @@ namespace fc::storage::ipfs::merkledag {
   }
 
   outcome::result<void> MerkleDagServiceImpl::addNode(
-      std::shared_ptr<const Node> node) {
+      std::shared_ptr<const IPLDNode> node) {
     return block_service_->set(node->getCID(), node->getRawBytes());
   }
 
-  outcome::result<std::shared_ptr<Node>> MerkleDagServiceImpl::getNode(
+  outcome::result<std::shared_ptr<IPLDNode>> MerkleDagServiceImpl::getNode(
       const CID &cid) const {
     OUTCOME_TRY(content, block_service_->get(cid));
-    return NodeImpl::createFromRawBytes(content);
+    return IPLDNodeImpl::createFromRawBytes(content);
   }
 
   outcome::result<void> MerkleDagServiceImpl::removeNode(const CID &cid) {
@@ -37,15 +39,15 @@ namespace fc::storage::ipfs::merkledag {
   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::function<bool(std::shared_ptr<const IPLDNode>)> 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{};
+    std::vector<std::shared_ptr<const IPLDNode>> node_set{};
     node_set.emplace_back(std::move(root_node));
     const auto &links = node_set.front()->getLinks();
-    for (const auto& link : links) {
+    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()));
@@ -79,7 +81,7 @@ namespace fc::storage::ipfs::merkledag {
 
   outcome::result<void> MerkleDagServiceImpl::buildGraph(
       const std::shared_ptr<LeafImpl> &root,
-      const std::vector<std::reference_wrapper<const Link>> &links,
+      const std::vector<std::reference_wrapper<const IPLDLink>> &links,
       bool depth_limit,
       const size_t max_depth,
       size_t current_depth) const {
@@ -89,7 +91,7 @@ namespace fc::storage::ipfs::merkledag {
     for (const auto &link : links) {
       auto request = getNode(link.get().getCID());
       if (request.has_error()) return ServiceError::UNRESOLVED_LINK;
-      std::shared_ptr<Node> node = request.value();
+      std::shared_ptr<IPLDNode> node = request.value();
       auto child_leaf = std::make_shared<LeafImpl>(node->content());
       auto build_result = buildGraph(child_leaf,
                                      node->getLinks(),

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

@@ -11,8 +11,11 @@
 #include "storage/ipfs/datastore.hpp"
 #include "storage/ipfs/merkledag/impl/leaf_impl.hpp"
 #include "storage/ipfs/merkledag/merkledag_service.hpp"
+#include "storage/ipld/ipld_link.hpp"
 
 namespace fc::storage::ipfs::merkledag {
+  using ipld::IPLDLink;
+
   class MerkleDagServiceImpl : public MerkleDagService {
    public:
     /**
@@ -21,17 +24,18 @@ namespace fc::storage::ipfs::merkledag {
      */
     explicit MerkleDagServiceImpl(std::shared_ptr<IpfsDatastore> service);
 
-    outcome::result<void> addNode(std::shared_ptr<const Node> node) override;
+    outcome::result<void> addNode(
+        std::shared_ptr<const IPLDNode> node) override;
 
-    outcome::result<std::shared_ptr<Node>> getNode(
+    outcome::result<std::shared_ptr<IPLDNode>> getNode(
         const CID &cid) const override;
 
     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)
+        std::function<bool(std::shared_ptr<const IPLDNode> node)> handler)
         const override;
 
     outcome::result<std::shared_ptr<Leaf>> fetchGraph(
@@ -55,7 +59,7 @@ namespace fc::storage::ipfs::merkledag {
      */
     outcome::result<void> buildGraph(
         const std::shared_ptr<LeafImpl> &root,
-        const std::vector<std::reference_wrapper<const Link>> &links,
+        const std::vector<std::reference_wrapper<const IPLDLink>> &links,
         bool depth_limit,
         size_t max_depth,
         size_t current_depth = 0) const;