Refactor CID (#67)

turuslan · web-flow · commit 186399ae7b74 · 2020-01-15T23:06:04.000+03:00
Signed-off-by: turuslan &lt;turuslan.devbox@gmail.com&gt;
diff --git a/core/codec/cbor/cbor_common.hpp b/core/codec/cbor/cbor_common.hpp
@@ -12,6 +12,7 @@
 
 #include "codec/cbor/cbor_errors.hpp"
 #include "common/outcome_throw.hpp"
+#include "primitives/cid/cid.hpp"
 
 namespace fc::codec::cbor {
   constexpr uint64_t kCidTag = 42;
diff --git a/core/codec/cbor/cbor_decode_stream.cpp b/core/codec/cbor/cbor_decode_stream.cpp
@@ -56,7 +56,7 @@ namespace fc::codec::cbor {
   }
 
   CborDecodeStream &CborDecodeStream::operator>>(
-      libp2p::multi::ContentIdentifier &cid) {
+      CID &cid) {
     if (!cbor_value_is_tag(&value_)) {
       outcome::raise(CborDecodeError::INVALID_CBOR_CID);
     }
diff --git a/core/codec/cbor/cbor_decode_stream.hpp b/core/codec/cbor/cbor_decode_stream.hpp
@@ -64,7 +64,7 @@ namespace fc::codec::cbor {
     /** Decodes string */
     CborDecodeStream &operator>>(std::string &str);
     /** Decodes CID */
-    CborDecodeStream &operator>>(libp2p::multi::ContentIdentifier &cid);
+    CborDecodeStream &operator>>(CID &cid);
     /** Creates list container decode substream */
     CborDecodeStream list();
     /** Skips current element */
diff --git a/core/codec/cbor/cbor_encode_stream.cpp b/core/codec/cbor/cbor_encode_stream.cpp
@@ -35,8 +35,7 @@ namespace fc::codec::cbor {
     return *this;
   }
 
-  CborEncodeStream &CborEncodeStream::operator<<(
-      const libp2p::multi::ContentIdentifier &cid) {
+  CborEncodeStream &CborEncodeStream::operator<<(const CID &cid) {
     auto maybe_cid_bytes = libp2p::multi::ContentIdentifierCodec::encode(cid);
     if (maybe_cid_bytes.has_error()) {
       outcome::raise(CborEncodeError::INVALID_CID);
diff --git a/core/codec/cbor/cbor_encode_stream.hpp b/core/codec/cbor/cbor_encode_stream.hpp
@@ -45,7 +45,7 @@ namespace fc::codec::cbor {
     /** Encodes string */
     CborEncodeStream &operator<<(const std::string &str);
     /** Encodes CID */
-    CborEncodeStream &operator<<(const libp2p::multi::ContentIdentifier &cid);
+    CborEncodeStream &operator<<(const CID &cid);
     /** Encodes list container encode substream */
     CborEncodeStream &operator<<(const CborEncodeStream &other);
     /** Encodes map container encode substream map */
diff --git a/core/common/CMakeLists.txt b/core/common/CMakeLists.txt
@@ -41,11 +41,3 @@ add_library(logger
 target_link_libraries(logger
     spdlog::spdlog
     )
-
-add_library(cid
-    cid.cpp
-    )
-target_link_libraries(cid
-    blake2
-    p2p::p2p_cid
-    )
diff --git a/core/primitives/CMakeLists.txt b/core/primitives/CMakeLists.txt
@@ -4,4 +4,5 @@
 #
 
 add_subdirectory(address)
+add_subdirectory(cid)
 add_subdirectory(ticket)
diff --git a/core/primitives/cid/CMakeLists.txt b/core/primitives/cid/CMakeLists.txt
@@ -0,0 +1,12 @@
+#
+# Copyright Soramitsu Co., Ltd. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+
+add_library(cid
+    cid.cpp
+    )
+target_link_libraries(cid
+    blake2
+    p2p::p2p_cid
+    )
diff --git a/core/primitives/cid/cid.cpp b/core/primitives/cid/cid.cpp
@@ -3,10 +3,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "common/cid.hpp"
+#include "primitives/cid/cid.hpp"
 
 #include "crypto/blake2/blake2b160.hpp"
 
+namespace fc {
+  CID::CID()
+      : ContentIdentifier(
+          {}, {}, libp2p::multi::Multihash::create({}, {}).value()) {}
+
+  CID::CID(const ContentIdentifier &cid) : ContentIdentifier(cid) {}
+}  // namespace fc
+
 namespace fc::common {
   outcome::result<CID> getCidOf(gsl::span<const uint8_t> bytes) {
     OUTCOME_TRY(hash_raw, crypto::blake2b::blake2b_256(bytes));
diff --git a/core/primitives/cid/cid.hpp b/core/primitives/cid/cid.hpp
@@ -11,19 +11,22 @@
 #include "common/outcome.hpp"
 
 namespace fc {
-  using CID = libp2p::multi::ContentIdentifier;
+  class CID : public libp2p::multi::ContentIdentifier {
+   public:
+    using ContentIdentifier::ContentIdentifier;
+
+    /**
+     * ContentIdentifier is not default-constructible, but in some cases we need
+     * default value. This value can be used to initialize class member or local
+     * variable. Trying to CBOR encode this value will yield error, to ensure
+     * proper initialization.
+     */
+    CID();
+    CID(const ContentIdentifier &cid);
+  };
 }  // namespace fc
 
 namespace fc::common {
-  /**
-   * CID is not default-constructible, but in some cases we need default value.
-   * This value can be used to initialize class member or local variable. Trying
-   * to CBOR encode this value will yield error, to ensure proper
-   * initialization.
-   */
-  const static inline CID kEmptyCid(
-      {}, {}, libp2p::multi::Multihash::create({}, {}).value());
-
   /// Compute CID from bytes
   outcome::result<CID> getCidOf(gsl::span<const uint8_t> bytes);
 }  // namespace fc::common
diff --git a/core/storage/hamt/hamt.hpp b/core/storage/hamt/hamt.hpp
@@ -12,10 +12,10 @@
 #include <boost/variant.hpp>
 
 #include "codec/cbor/cbor.hpp"
-#include "common/cid.hpp"
 #include "common/outcome_throw.hpp"
 #include "common/visitor.hpp"
 #include "primitives/big_int.hpp"
+#include "primitives/cid/cid.hpp"
 #include "storage/ipfs/datastore.hpp"
 
 namespace fc::storage::hamt {
@@ -70,7 +70,7 @@ namespace fc::storage::hamt {
     for (size_t i = 0; i < n_items; ++i) {
       auto m_item = l_items.map();
       if (m_item.find("0") != m_item.end()) {
-        CID cid = common::kEmptyCid;
+        CID cid;
         m_item.at("0") >> cid;
         node.items.emplace_back(cid);
       } else {
diff --git a/core/storage/ipfs/block.hpp b/core/storage/ipfs/block.hpp
@@ -7,7 +7,7 @@
 #define FILECOIN_STORAGE_IPFS_BLOCK_HPP
 
 #include "common/buffer.hpp"
-#include "common/cid.hpp"
+#include "primitives/cid/cid.hpp"
 
 namespace fc::storage::ipfs {
   /**
diff --git a/core/storage/ipfs/datastore.hpp b/core/storage/ipfs/datastore.hpp
@@ -10,9 +10,9 @@
 
 #include "codec/cbor/cbor.hpp"
 #include "common/buffer.hpp"
-#include "common/cid.hpp"
 #include "common/logger.hpp"
 #include "common/outcome.hpp"
+#include "primitives/cid/cid.hpp"
 #include "storage/ipfs/ipfs_datastore_error.hpp"
 
 namespace fc::storage::ipfs {
diff --git a/core/storage/ipfs/impl/datastore_leveldb.cpp b/core/storage/ipfs/impl/datastore_leveldb.cpp
@@ -16,7 +16,7 @@ namespace fc::storage::ipfs {
      * @return encoded value as Buffer
      */
     inline outcome::result<common::Buffer> encode(
-        const libp2p::multi::ContentIdentifier &value) {
+        const CID &value) {
       OUTCOME_TRY(encoded,
                   libp2p::multi::ContentIdentifierCodec::encode(value));
       return common::Buffer(std::move(encoded));
diff --git a/core/vm/actor/actor.cpp b/core/vm/actor/actor.cpp
@@ -16,40 +16,40 @@ namespace fc::vm::actor {
            && lhs.nonce == rhs.nonce && lhs.balance == rhs.balance;
   }
 
-  bool isBuiltinActor(const ContentIdentifier &code) {
+  bool isBuiltinActor(const CID &code) {
     return code == kStorageMarketCodeCid || code == kStoragePowerCodeCid
            || code == kStorageMinerCodeCid || code == kAccountCodeCid
            || code == kInitCodeCid || code == kMultisigCodeCid
            || code == kPaymentChannelCodeCid;
   }
 
-  bool isSingletonActor(const ContentIdentifier &code) {
+  bool isSingletonActor(const CID &code) {
     return code == kStoragePowerCodeCid || code == kStorageMarketCodeCid
            || code == kInitCodeCid || code == kCronCodeCid;
   }
 
-  const ContentIdentifier kEmptyObjectCid{
-      ContentIdentifier::Version::V1,
+  const CID kEmptyObjectCid{
+      CID::Version::V1,
       libp2p::multi::MulticodecType::Code::DAG_CBOR,
       libp2p::multi::Multihash::create(libp2p::multi::HashType::sha256,
                                        libp2p::crypto::sha256({"\xA0", 1}))
           .value()};
 
-  ContentIdentifier makeRawIdentityCid(const std::string &str) {
+  CID makeRawIdentityCid(const std::string &str) {
     std::vector<uint8_t> bytes{str.begin(), str.end()};
-    return {ContentIdentifier::Version::V1,
+    return {CID::Version::V1,
             libp2p::multi::MulticodecType::Code::RAW,
             libp2p::multi::Multihash::create(libp2p::multi::HashType::identity,
                                              bytes)
                 .value()};
   }
 
-  const ContentIdentifier kAccountCodeCid = makeRawIdentityCid("fil/1/account");
-  const ContentIdentifier kCronCodeCid = makeRawIdentityCid("fil/1/cron");
-  const ContentIdentifier kStoragePowerCodeCid = makeRawIdentityCid("fil/1/power");
-  const ContentIdentifier kStorageMarketCodeCid = makeRawIdentityCid("fil/1/market");
-  const ContentIdentifier kStorageMinerCodeCid = makeRawIdentityCid("fil/1/miner");
-  const ContentIdentifier kMultisigCodeCid = makeRawIdentityCid("fil/1/multisig");
-  const ContentIdentifier kInitCodeCid = makeRawIdentityCid("fil/1/init");
-  const ContentIdentifier kPaymentChannelCodeCid = makeRawIdentityCid("fil/1/paych");
+  const CID kAccountCodeCid = makeRawIdentityCid("fil/1/account");
+  const CID kCronCodeCid = makeRawIdentityCid("fil/1/cron");
+  const CID kStoragePowerCodeCid = makeRawIdentityCid("fil/1/power");
+  const CID kStorageMarketCodeCid = makeRawIdentityCid("fil/1/market");
+  const CID kStorageMinerCodeCid = makeRawIdentityCid("fil/1/miner");
+  const CID kMultisigCodeCid = makeRawIdentityCid("fil/1/multisig");
+  const CID kInitCodeCid = makeRawIdentityCid("fil/1/init");
+  const CID kPaymentChannelCodeCid = makeRawIdentityCid("fil/1/paych");
 }  // namespace fc::vm::actor
diff --git a/core/vm/actor/actor.hpp b/core/vm/actor/actor.hpp
@@ -8,19 +8,18 @@
 
 #include <libp2p/multi/content_identifier_codec.hpp>
 
-#include "common/cid.hpp"
 #include "primitives/address/address.hpp"
 #include "primitives/big_int.hpp"
+#include "primitives/cid/cid.hpp"
 
 namespace fc::vm::actor {
-  using libp2p::multi::ContentIdentifier;
   using primitives::address::Address;
   using primitives::BigInt;
 
   /** Common actor state interface */
   struct Actor {
-    ContentIdentifier code{common::kEmptyCid};
-    ContentIdentifier head{common::kEmptyCid};
+    CID code{};
+    CID head{};
     uint64_t nonce{};
     BigInt balance{};
   };
@@ -43,14 +42,14 @@ namespace fc::vm::actor {
   }
 
   /** Check if code specifies builtin actor implementation */
-  bool isBuiltinActor(const ContentIdentifier &code);
+  bool isBuiltinActor(const CID &code);
 
   /** Check if only one instance of actor should exists */
-  bool isSingletonActor(const ContentIdentifier &code);
+  bool isSingletonActor(const CID &code);
 
-  extern const ContentIdentifier kEmptyObjectCid;
+  extern const CID kEmptyObjectCid;
 
-  extern const ContentIdentifier kAccountCodeCid, kCronCodeCid, kStoragePowerCodeCid,
+  extern const CID kAccountCodeCid, kCronCodeCid, kStoragePowerCodeCid,
       kStorageMarketCodeCid, kStorageMinerCodeCid, kMultisigCodeCid,
       kInitCodeCid, kPaymentChannelCodeCid;
 
diff --git a/core/vm/actor/init_actor.hpp b/core/vm/actor/init_actor.hpp
@@ -6,8 +6,6 @@
 #ifndef CPP_FILECOIN_CORE_VM_ACTOR_INIT_ACTOR_HPP
 #define CPP_FILECOIN_CORE_VM_ACTOR_INIT_ACTOR_HPP
 
-#include <libp2p/multi/content_identifier.hpp>
-
 #include "storage/ipfs/datastore.hpp"
 #include "vm/actor/actor.hpp"
 
@@ -20,7 +18,7 @@ namespace fc::vm::actor {
     outcome::result<Address> addActor(std::shared_ptr<IpfsDatastore> store,
                                       const Address &address);
 
-    ContentIdentifier address_map{common::kEmptyCid};
+    CID address_map{};
     uint64_t next_id{};
   };
 
diff --git a/core/vm/state/state_tree.cpp b/core/vm/state/state_tree.cpp
@@ -17,7 +17,7 @@ namespace fc::vm::state {
       : store_(store), hamt_(store), snapshot_(store) {}
 
   StateTree::StateTree(const std::shared_ptr<IpfsDatastore> &store,
-                       const ContentIdentifier &root)
+                       const CID &root)
       : store_(store), hamt_(store, root), snapshot_(store, root) {}
 
   outcome::result<void> StateTree::set(const Address &address,
@@ -56,7 +56,7 @@ namespace fc::vm::state {
     return std::move(address_id);
   }
 
-  outcome::result<ContentIdentifier> StateTree::flush() {
+  outcome::result<CID> StateTree::flush() {
     OUTCOME_TRY(cid, hamt_.flush());
     snapshot_ = hamt_;
     return std::move(cid);
diff --git a/core/vm/state/state_tree.hpp b/core/vm/state/state_tree.hpp
@@ -11,7 +11,6 @@
 
 namespace fc::vm::state {
   using actor::Actor;
-  using libp2p::multi::ContentIdentifier;
   using primitives::address::Address;
   using storage::hamt::Hamt;
   using storage::ipfs::IpfsDatastore;
@@ -21,7 +20,7 @@ namespace fc::vm::state {
    public:
     explicit StateTree(const std::shared_ptr<IpfsDatastore> &store);
     StateTree(const std::shared_ptr<IpfsDatastore> &store,
-              const ContentIdentifier &root);
+              const CID &root);
     /// Set actor state, does not write to storage
     outcome::result<void> set(const Address &address, const Actor &actor);
     /// Get actor state
@@ -32,7 +31,7 @@ namespace fc::vm::state {
     outcome::result<Address> registerNewAddress(const Address &address,
                                                 const Actor &actor);
     /// Write changes to storage
-    outcome::result<ContentIdentifier> flush();
+    outcome::result<CID> flush();
     /// Revert changes to last flushed state
     outcome::result<void> revert();
 
diff --git a/test/core/codec/cbor/cbor_test.cpp b/test/core/codec/cbor/cbor_test.cpp
diff --git a/test/core/storage/ipfs/blockservice_test.cpp b/test/core/storage/ipfs/blockservice_test.cpp
diff --git a/test/core/storage/ipfs/datastore_integration_test.cpp b/test/core/storage/ipfs/datastore_integration_test.cpp
diff --git a/test/core/storage/ipfs/in_memory_ipfs_datastore_test.cpp b/test/core/storage/ipfs/in_memory_ipfs_datastore_test.cpp
diff --git a/test/core/storage/repository/filesystem_repository_test.cpp b/test/core/storage/repository/filesystem_repository_test.cpp
diff --git a/test/core/vm/actor/invoker_test.cpp b/test/core/vm/actor/invoker_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ namespace fc::codec::cbor {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`CborDecodeStream &CborDecodeStream::operator>>(`
`59`		`- libp2p::multi::ContentIdentifier &cid) {`
	`59`	`+ CID &cid) {`
`60`	`60`	`if (!cbor_value_is_tag(&value_)) {`
`61`	`61`	`outcome::raise(CborDecodeError::INVALID_CBOR_CID);`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,7 @@ namespace fc::codec::cbor {`
`35`	`35`	`return *this;`
`36`	`36`	`}`
`37`	`37`
`38`		`- CborEncodeStream &CborEncodeStream::operator<<(`
`39`		`- const libp2p::multi::ContentIdentifier &cid) {`
	`38`	`+ CborEncodeStream &CborEncodeStream::operator<<(const CID &cid) {`
`40`	`39`	`auto maybe_cid_bytes = libp2p::multi::ContentIdentifierCodec::encode(cid);`
`41`	`40`	`if (maybe_cid_bytes.has_error()) {`
`42`	`41`	`outcome::raise(CborEncodeError::INVALID_CID);`
Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@`
`4`	`4`	`#`
`5`	`5`
`6`	`6`	`add_subdirectory(address)`
	`7`	`+add_subdirectory(cid)`
`7`	`8`	`add_subdirectory(ticket)`