IPLD CR fix

sergkaprovich · sergkaprovich · commit 6daa5235bb0d · 2020-02-25T15:21:19.000+03:00
diff --git a/core/crypto/CMakeLists.txt b/core/crypto/CMakeLists.txt
@@ -5,6 +5,7 @@
 
 add_subdirectory(blake2)
 add_subdirectory(bls)
+add_subdirectory(hasher)
 add_subdirectory(murmur)
 add_subdirectory(randomness)
 add_subdirectory(vrf)
diff --git a/core/crypto/hasher/CMakeLists.txt b/core/crypto/hasher/CMakeLists.txt
@@ -0,0 +1,11 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+add_library(filecoin_hasher
+    hasher.cpp
+    )
+target_link_libraries(filecoin_hasher
+    blake2
+    )
diff --git a/core/crypto/hasher/hasher.cpp b/core/crypto/hasher/hasher.cpp
@@ -0,0 +1,33 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "hasher.hpp"
+
+#include <libp2p/crypto/sha/sha256.hpp>
+#include "crypto/blake2/blake2b160.hpp"
+
+namespace fc::crypto {
+  std::map<Hasher::HashType, Hasher::HashMethod> Hasher::methods_{
+      {HashType::sha256, Hasher::sha2_256},
+      {HashType::blake2b_256, Hasher::blake2b_256}};
+
+  Hasher::Multihash Hasher::calculate(HashType hash_type,
+                                      gsl::span<const uint8_t> buffer) {
+    HashMethod hash_method = methods_.at(hash_type);
+    return std::invoke(hash_method, buffer);
+  }
+
+  Hasher::Multihash Hasher::sha2_256(gsl::span<const uint8_t> buffer) {
+    auto digest = libp2p::crypto::sha256(buffer);
+    auto multi_hash = Multihash::create(HashType::sha256, digest);
+    return multi_hash.value();
+  }
+
+  Hasher::Multihash Hasher::blake2b_256(gsl::span<const uint8_t> buffer) {
+    auto digest = crypto::blake2b::blake2b_256(buffer);
+    auto multi_hash = Multihash::create(HashType::blake2b_256, digest);
+    return multi_hash.value();
+  }
+}  // namespace fc::crypto
diff --git a/core/crypto/hasher/hasher.hpp b/core/crypto/hasher/hasher.hpp
@@ -0,0 +1,48 @@
+/**
+ * Copyright Soramitsu Co., Ltd. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef FILECOIN_CORE_CRYPTO_HASHER_HPP
+#define FILECOIN_CORE_CRYPTO_HASHER_HPP
+
+#include <map>
+
+#include <libp2p/multi/multihash.hpp>
+
+namespace fc::crypto {
+    /**
+     * @class Supported methods:
+     *        sha2-256
+     *        blakeb2-256
+     */
+  class Hasher {
+   protected:
+    using HashType = libp2p::multi::HashType;
+    using Multihash = libp2p::multi::Multihash;
+    using HashMethod = Multihash (*)(gsl::span<const uint8_t>);
+
+   private:
+    static std::map<HashType, HashMethod> methods_;
+
+   public:
+    static Multihash calculate(HashType hash_type,
+                               gsl::span<const uint8_t> buffer);
+
+    /**
+     * @brief Calculate SHA2-256 hash
+     * @param buffer - source data
+     * @return SHA2-256 hash
+     */
+    static Multihash sha2_256(gsl::span<const uint8_t> buffer);
+
+    /**
+     * @brief Calculate Blake2b-256 hash
+     * @param buffer - source data
+     * @return Blake2b-256 hash
+     */
+    static Multihash blake2b_256(gsl::span<const uint8_t> buffer);
+  };
+}  // namespace fc::crypto
+
+#endif
diff --git a/core/storage/ipld/CMakeLists.txt b/core/storage/ipld/CMakeLists.txt
@@ -27,7 +27,7 @@ add_library(ipld_block
     )
 target_link_libraries(ipld_block
     cid
-    blake2
+    filecoin_hasher
     )
 
 add_library(ipld_link
diff --git a/core/storage/ipld/impl/ipld_block_impl.cpp b/core/storage/ipld/impl/ipld_block_impl.cpp
@@ -5,20 +5,11 @@
 
 #include "storage/ipld/impl/ipld_block_impl.hpp"
 
-#include <libp2p/crypto/sha/sha256.hpp>
-#include <libp2p/multi/multihash.hpp>
-#include "crypto/blake2/blake2b160.hpp"
+#include "crypto/hasher/hasher.hpp"
 
 namespace fc::storage::ipld {
-  using crypto::blake2b::Blake2b256Hash;
-  using libp2p::common::Hash256;
-  using libp2p::multi::Multihash;
 
-  std::map<HashType, IPLDBlockImpl::HashMethod> IPLDBlockImpl::hash_methods_{
-      {HashType::sha256, IPLDBlockImpl::hash_sha2_256},
-      {HashType::blake2b_256, IPLDBlockImpl::hash_blake2b_256}};
-
-    IPLDBlockImpl::IPLDBlockImpl(CID::Version version,
+  IPLDBlockImpl::IPLDBlockImpl(CID::Version version,
                                HashType hash_type,
                                ContentType content_type)
       : cid_version_{version},
@@ -27,39 +18,23 @@ namespace fc::storage::ipld {
 
   const CID &IPLDBlockImpl::getCID() const {
     if (!cid_) {
-      HashMethod hash_method = hash_methods_.at(cid_hash_type_);
-      const common::Buffer &raw_data = getRawBytes();
-      std::vector<uint8_t> digest = std::invoke(hash_method, raw_data);
-      auto multi_hash = Multihash::create(cid_hash_type_, digest);
-      CID id{cid_version_, content_type_, std::move(multi_hash.value())};
+      auto multi_hash =
+          crypto::Hasher::calculate(cid_hash_type_, getRawBytes());
+      CID id{cid_version_, content_type_, std::move(multi_hash)};
       cid_ = std::move(id);
     }
     return cid_.value();
   }
 
-    const common::Buffer &IPLDBlockImpl::getRawBytes() const {
-      if (!raw_bytes_) {
-        raw_bytes_ = getBlockContent();
-      }
-      return raw_bytes_.value();
-    }
-
-    void IPLDBlockImpl::clearCache() const {
-      cid_ = boost::none;
-      raw_bytes_ = boost::none;
+  const common::Buffer &IPLDBlockImpl::getRawBytes() const {
+    if (!raw_bytes_) {
+      raw_bytes_ = getBlockContent();
     }
-
-  std::vector<uint8_t> IPLDBlockImpl::hash_sha2_256(
-      const common::Buffer &data) {
-    Hash256 digest = libp2p::crypto::sha256(data.toVector());
-    return {std::make_move_iterator(digest.begin()),
-            std::make_move_iterator((digest.end()))};
+    return raw_bytes_.value();
   }
 
-  std::vector<uint8_t> IPLDBlockImpl::hash_blake2b_256(
-      const common::Buffer &data) {
-    Blake2b256Hash digest = crypto::blake2b::blake2b_256(data.toVector());
-    return {std::make_move_iterator(digest.begin()),
-            std::make_move_iterator((digest.end()))};
+  void IPLDBlockImpl::clearCache() const {
+    cid_ = boost::none;
+    raw_bytes_ = boost::none;
   }
 }  // namespace fc::storage::ipld
diff --git a/core/storage/ipld/impl/ipld_block_impl.hpp b/core/storage/ipld/impl/ipld_block_impl.hpp
@@ -10,10 +10,8 @@
 #include <vector>
 
 #include <boost/optional.hpp>
-
 #include <libp2p/multi/hash_type.hpp>
 #include <libp2p/multi/multicodec_type.hpp>
-
 #include "common/buffer.hpp"
 #include "primitives/cid/cid.hpp"
 #include "storage/ipld/ipld_block.hpp"
@@ -48,30 +46,12 @@ namespace fc::storage::ipld {
     void clearCache() const;
 
    private:
-    using HashMethod = std::vector<uint8_t> (*)(const common::Buffer &);
-
     CID::Version cid_version_;
     HashType cid_hash_type_;
     ContentType content_type_;
 
     mutable boost::optional<CID> cid_;
     mutable boost::optional<common::Buffer> raw_bytes_;
-
-    static std::map<HashType, HashMethod> hash_methods_;
-
-    /**
-     * @brief Calculate SHA-256 hash
-     * @param data - bytes to hash
-     * @return SHA-256 digest
-     */
-    static std::vector<uint8_t> hash_sha2_256(const common::Buffer &data);
-
-    /**
-     * @brief Calculate Blake2b-256 hash
-     * @param data - bytes to hash
-     * @return Blake2b-256 digest
-     */
-    static std::vector<uint8_t> hash_blake2b_256(const common::Buffer &data);
   };
 }  // namespace fc::storage::ipld
 
diff --git a/core/storage/ipld/impl/ipld_node_decoder_pb.hpp b/core/storage/ipld/impl/ipld_node_decoder_pb.hpp
@@ -11,7 +11,7 @@
 #include <gsl/span>
 #include "common/buffer.hpp"
 #include "common/outcome.hpp"
-#include "ipld_node.pb.h"
+#include "ipld_node.pb.h" //TODO: Sergey Kaprovich FIL-150
 
 namespace fc::storage::ipld {
   /**
diff --git a/core/storage/ipld/ipld_node.hpp b/core/storage/ipld/ipld_node.hpp
@@ -8,80 +8,79 @@
 
 #include <functional>
 #include <memory>
-#include <vector>
 #include <string>
+#include <vector>
 
 #include "common/buffer.hpp"
 #include "common/outcome.hpp"
-#include "storage/ipld/ipld_link.hpp"
 #include "storage/ipld/ipld_block.hpp"
+#include "storage/ipld/ipld_link.hpp"
 
 namespace fc::storage::ipld {
+  /**
+   * @interface MerkleDAG service node
+   */
+  class IPLDNode : public virtual IPLDBlock {
+   public:
+    virtual ~IPLDNode() = default;
     /**
-     * @interface MerkleDAG service node
+     * @brief Total size of the data including the total sizes of references
+     * @return Cumulative size in bytes
      */
-    class IPLDNode : public virtual IPLDBlock {
-    public:
-
-        virtual ~IPLDNode() = default;
-        /**
-         * @brief Total size of the data including the total sizes of references
-         * @return Cumulative size in bytes
-         */
-        virtual size_t size() const = 0;
+    virtual size_t size() const = 0;
 
-        /**
-         * @brief Assign Node's content
-         * @param input - data bytes
-         * @return operation result
-         */
-        virtual void assign(common::Buffer input) = 0;
+    /**
+     * @brief Assign Node's content
+     * @param input - data bytes
+     * @return operation result
+     */
+    virtual void assign(common::Buffer input) = 0;
 
-        /**
-         * @brief Get Node data
-         * @return content bytes
-         */
-        virtual const common::Buffer &content() const = 0;
+    /**
+     * @brief Get Node data
+     * @return content bytes
+     */
+    virtual const common::Buffer &content() const = 0;
 
-        /**
-         * @brief Add link to the child node
-         * @param name - name of the child node
-         * @param node - child object to link
-         * @return operation result
-         */
-        virtual outcome::result<void> addChild(const std::string &name,
-                                               std::shared_ptr<const IPLDNode> node) = 0;
+    /**
+     * @brief Add link to the child node
+     * @param name - name of the child node
+     * @param node - child object to link
+     * @return operation result
+     */
+    virtual outcome::result<void> addChild(
+        const std::string &name, std::shared_ptr<const IPLDNode> node) = 0;
 
-        /**
-         * @brief Get particular link to the child node
-         * @param name - id of the link
-         * @return Requested link of error, if link not found
-         */
-        virtual outcome::result<std::reference_wrapper<const IPLDLink>> getLink(
-            const std::string &name) const = 0;
+    /**
+     * @brief Get particular link to the child node
+     * @param name - id of the link
+     * @return Requested link of error, if link not found
+     */
+    virtual outcome::result<std::reference_wrapper<const IPLDLink>> getLink(
+        const std::string &name) const = 0;
 
-        /**
-         * @brief Remove link to the child node
-         * @param name - name of the child node
-         * @return operation result
-         */
-        virtual void removeLink(const std::string &name) = 0;
+    /**
+     * @brief Remove link to the child node
+     * @param name - name of the child node
+     * @return operation result
+     */
+    virtual void removeLink(const std::string &name) = 0;
 
-        /**
-         * @brief Insert link to the child node
-         * @param link - object to add
-         */
-        virtual void addLink(const IPLDLink &link) = 0;
+    /**
+     * @brief Insert link to the child node
+     * @param link - object to add
+     */
+    virtual void addLink(const IPLDLink &link) = 0;
 
-        virtual std::vector<std::reference_wrapper<const IPLDLink>> getLinks()
+    virtual std::vector<std::reference_wrapper<const IPLDLink>> getLinks()
         const = 0;
-    };
+  };
 
-    /**
-     * @class Possible Node errors
-     */
-    enum class IPLDNodeError : int { LINK_NOT_FOUND, INVALID_RAW_DATA };
-}  // namespace fc::storage::ipfs::merkledag
+  /**
+   * @class Possible Node errors
+   */
+  enum class IPLDNodeError { LINK_NOT_FOUND = 1, INVALID_RAW_DATA };
+}  // namespace fc::storage::ipld
 
 OUTCOME_HPP_DECLARE_ERROR(fc::storage::ipld, IPLDNodeError)
 

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ add_library(ipld_block`
`27`	`27`	`)`
`28`	`28`	`target_link_libraries(ipld_block`
`29`	`29`	`cid`
`30`		`- blake2`
	`30`	`+ filecoin_hasher`
`31`	`31`	`)`
`32`	`32`
`33`	`33`	`add_library(ipld_link`