Feature/tipsetcash (#468)

* tipsetcash update

Signed-off-by: elestrias <[email protected]>

* Tipsetcache_tests

Signed-off-by: elestrias <[email protected]>

* build fix

* include changes

* Remove Events error

Signed-off-by: ortyomka <[email protected]>

Co-authored-by: Alexey <[email protected]>
Co-authored-by: ortyomka <[email protected]>

Author: 3 people

core/miner/impl/miner_impl.cpp

@@ -81,7 +81,7 @@ namespace fc::miner {
     std::shared_ptr<TipsetCache> tipset_cache =
         std::make_shared<TipsetCacheImpl>(
             2 * kGlobalChainConfidence,
-            [=](auto h) { return api->ChainGetTipSetByHeight(h, {}); });
+            api);
     OUTCOME_TRY(events, EventsImpl::createEvents(api, tipset_cache));
     std::shared_ptr<PreCommitPolicy> precommit_policy =
         std::make_shared<BasicPreCommitPolicy>(

core/miner/storage_fsm/CMakeLists.txt

@@ -24,6 +24,7 @@ add_library(tipset_cache
 target_link_libraries(tipset_cache
         tipset
         Boost::boost
+        api
         )
 
 add_library(events

core/miner/storage_fsm/events.hpp

@@ -33,10 +33,4 @@ namespace fc::mining {
                                           ChainEpoch height) = 0;
   };
 
-  enum class EventsError {
-    kNotFoundTipset = 1,
-  };
-
 }  // namespace fc::mining
-
-OUTCOME_HPP_DECLARE_ERROR(fc::mining, EventsError);

core/miner/storage_fsm/impl/events_impl.cpp

@@ -47,14 +47,9 @@ namespace fc::mining {
                                             EpochDuration confidence,
                                             ChainEpoch height) {
     std::unique_lock<std::mutex> lock(mutex_);
-    auto best_tipset = tipset_cache_->best();
+    OUTCOME_TRY(best_tipset, tipset_cache_->best());
 
-    // TODO(ortyomka): [FIL-370] should be updated after update TipSetCache
-    if (!best_tipset) {
-      return EventsError::kNotFoundTipset;
-    }
-
-    ChainEpoch best_height = best_tipset->height();
+    ChainEpoch best_height = best_tipset.height();
 
     if (best_height >= height + confidence) {
       OUTCOME_TRY(tipset, tipset_cache_->getNonNull(height));
@@ -64,13 +59,9 @@ namespace fc::mining {
       OUTCOME_TRY(handler(tipset, best_height));
 
       lock.lock();
-      best_tipset = tipset_cache_->best();
+      OUTCOME_TRYA(best_tipset, tipset_cache_->best());
 
-      // TODO(ortyomka): [FIL-370] should be updated after update TipSetCache
-      if (!best_tipset) {
-        return EventsError::kNotFoundTipset;
-      }
-      best_height = best_tipset->height();
+      best_height = best_tipset.height();
 
       if (best_height >= height + confidence + kGlobalChainConfidence) {
         return outcome::success();
@@ -226,13 +217,3 @@ namespace fc::mining {
   }
 
 }  // namespace fc::mining
-
-OUTCOME_CPP_DEFINE_CATEGORY(fc::mining, EventsError, e) {
-  using fc::mining::EventsError;
-  switch (e) {
-    case (EventsError::kNotFoundTipset):
-      return "Events: not found tipset";
-    default:
-      return "Events: unknown error";
-  }
-}

core/miner/storage_fsm/impl/tipset_cache_impl.cpp

@@ -8,10 +8,9 @@
 #include "primitives/tipset/tipset.hpp"
 
 namespace fc::mining {
-
   TipsetCacheImpl::TipsetCacheImpl(uint64_t capability,
-                                   GetTipsetFunction get_function)
-      : get_function_(std::move(get_function)) {
+                                   std::shared_ptr<FullNodeApi> api)
+      : api_(std::move(api)) {
     cache_.resize(capability);
     start_ = 0;
     len_ = 0;
@@ -85,7 +84,7 @@ namespace fc::mining {
     std::shared_lock lock(mutex_);
 
     if (len_ == 0) {
-      OUTCOME_TRY(tipset, get_function_(height));
+      OUTCOME_TRY(tipset, api_->ChainGetTipSetByHeight(height, {}));
       return *tipset;
     }
 
@@ -105,16 +104,20 @@ namespace fc::mining {
     }
 
     if (height < tail->height()) {
-      OUTCOME_TRY(tipset, get_function_(height));
+      OUTCOME_TRY(tipset, api_->ChainGetTipSetByHeight(height, {}));
       return *tipset;
     }
 
     return cache_[mod(start_ - (head_height - height))];
   }
 
-  boost::optional<Tipset> TipsetCacheImpl::best() const {
+  outcome::result<Tipset> TipsetCacheImpl::best() const {
     std::shared_lock lock(mutex_);
-    return cache_[start_];
+    if (len_ == 0) {
+      OUTCOME_TRY(tipset, api_->ChainHead());
+      return *tipset;
+    }
+    return cache_[start_].value();
   }
 
   int64_t TipsetCacheImpl::mod(int64_t x) {

core/miner/storage_fsm/impl/tipset_cache_impl.hpp

@@ -5,22 +5,20 @@
 
 #pragma once
 
-#include "miner/storage_fsm/tipset_cache.hpp"
-
-#include "primitives/tipset/tipset_key.hpp"
-
 #include <shared_mutex>
+#include "api/full_node/node_api.hpp"
+#include "miner/storage_fsm/tipset_cache.hpp"
 
 namespace fc::mining {
+  using api::FullNodeApi;
 
-  // TODO(ortyomka): [FIL-370] update it
   class TipsetCacheImpl : public TipsetCache {
    public:
     using GetTipsetFunction =
         std::function<outcome::result<primitives::tipset::TipsetCPtr>(
             ChainEpoch)>;
 
-    TipsetCacheImpl(uint64_t capability, GetTipsetFunction get_function);
+    TipsetCacheImpl(uint64_t capability, std::shared_ptr<FullNodeApi> api);
 
     outcome::result<void> add(const Tipset &tipset) override;
 
@@ -30,7 +28,7 @@ namespace fc::mining {
 
     outcome::result<boost::optional<Tipset>> get(ChainEpoch height) override;
 
-    boost::optional<Tipset> best() const override;
+    outcome::result<Tipset> best() const override;
 
    private:
     int64_t mod(int64_t x);
@@ -44,5 +42,7 @@ namespace fc::mining {
     uint64_t len_;
 
     GetTipsetFunction get_function_;
+
+    std::shared_ptr<FullNodeApi> api_;
   };
 }  // namespace fc::mining

core/miner/storage_fsm/tipset_cache.hpp

@@ -50,7 +50,7 @@ namespace fc::mining {
      * Get Head tipset
      * @return head tipset
      */
-    virtual boost::optional<Tipset> best() const = 0;
+    virtual outcome::result<Tipset> best() const = 0;
   };
 
   enum class TipsetCacheError {

test/core/miner/events_test.cpp

@@ -37,25 +37,26 @@ namespace fc::mining {
   /**
    * @given events
    * @when try to add Handler, but tipsetcache cannot get tipset
-   * @then error EventsError::kNotFoundTipset occurs
+   * @then error occurs
    */
   TEST_F(EventsTest, ChainAtNotFoundTipset) {
     Events::HeightHandler height_handler;
     Events::RevertHandler revert_handler;
     EpochDuration confidence = 4;
     ChainEpoch height = 4;
 
-    EXPECT_CALL(*tipset_cache_, best()).WillOnce(testing::Return(boost::none));
+    const auto error = ERROR_TEXT("API_ERROR");
+    EXPECT_CALL(*tipset_cache_, best()).WillOnce(testing::Return(error));
 
     EXPECT_OUTCOME_ERROR(
-        EventsError::kNotFoundTipset,
+        error,
         events_->chainAt(height_handler, revert_handler, confidence, height));
   }
 
   /**
    * @given events, tipset that should be executed immediately
    * @when try to add Handler, but tipsetcache cannot get tipset in second time
-   * @then error EventsError::kNotFoundTipset occurs
+   * @then error occurs
    */
   TEST_F(EventsTest, ChainAtNotFoundTipsetAfterExecution) {
     Events::HeightHandler height_handler =
@@ -66,18 +67,19 @@ namespace fc::mining {
     EpochDuration confidence = 4;
     ChainEpoch height = 4;
 
+    const auto error = ERROR_TEXT("API_ERROR");
     BlockHeader block;
     block.height = 9;
     Tipset tipset(TipsetKey(), {block});
     EXPECT_CALL(*tipset_cache_, best())
         .WillOnce(testing::Return(tipset))
-        .WillOnce(testing::Return(boost::none));
+        .WillOnce(testing::Return(error));
 
     EXPECT_CALL(*tipset_cache_, getNonNull(height))
         .WillOnce(testing::Return(outcome::success(tipset)));
 
     EXPECT_OUTCOME_ERROR(
-        EventsError::kNotFoundTipset,
+        error,
         events_->chainAt(height_handler, revert_handler, confidence, height));
   }
 

test/core/miner/tipset_cache_test.cpp

@@ -9,26 +9,23 @@
 
 #include "testutil/outcome.hpp"
 
-namespace fc::mining {
+#include "testutil/mocks/api.hpp"
 
+namespace fc::mining {
   using primitives::block::BlockHeader;
 
   class TipsetCacheTest : public testing::Test {
    protected:
     virtual void SetUp() {
       capability_ = 4;
-
-      auto getFunc = [&](ChainEpoch epoch)
-          -> outcome::result<primitives::tipset::TipsetCPtr> {
-        return mock_function_(epoch);
-      };
-
-      tipset_cache_ = std::make_shared<TipsetCacheImpl>(capability_, getFunc);
+      tipset_cache_ = std::make_shared<TipsetCacheImpl>(capability_, api_);
     }
 
     uint64_t capability_;
-    TipsetCacheImpl::GetTipsetFunction mock_function_;
     std::shared_ptr<TipsetCache> tipset_cache_;
+    std::shared_ptr<FullNodeApi> api_ = std::make_shared<FullNodeApi>();
+    MOCK_API(api_, ChainHead);
+    MOCK_API(api_, ChainGetTipSetByHeight);
   };
 
   /**
@@ -43,7 +40,7 @@ namespace fc::mining {
     Tipset tipset2(TipsetKey(), {block});
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->add(tipset1));
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->add(tipset2));
-    EXPECT_EQ(tipset_cache_->best(), tipset2);
+    EXPECT_OUTCOME_EQ(tipset_cache_->best(), tipset2);
   }
 
   /**
@@ -84,7 +81,7 @@ namespace fc::mining {
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->add(tipset1));
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->add(tipset2));
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->revert(tipset2));
-    EXPECT_EQ(tipset_cache_->best(), tipset1);
+    EXPECT_OUTCOME_EQ(tipset_cache_->best(), tipset1);
   }
 
   /**
@@ -147,17 +144,9 @@ namespace fc::mining {
     auto tipset2 = std::make_shared<Tipset>(TipsetKey(),
                                             std::vector<BlockHeader>({block2}));
     EXPECT_OUTCOME_TRUE_1(tipset_cache_->add(tipset1));
-    auto is_called = false;
-    mock_function_ = [&](ChainEpoch height)
-        -> outcome::result<primitives::tipset::TipsetCPtr> {
-      if (height != 1) {
-        return TipsetCacheError::kNotInCache;
-      }
-      is_called = true;
-      return tipset2;
-    };
+    EXPECT_CALL(mock_ChainGetTipSetByHeight, Call(1, TipsetKey{}))
+        .WillRepeatedly(testing::Return(tipset2));
     EXPECT_OUTCOME_EQ(tipset_cache_->get(1), *tipset2);
-    ASSERT_TRUE(is_called);
   }
 
   /**
@@ -170,17 +159,9 @@ namespace fc::mining {
     block1.height = 1;
     auto tipset1 = std::make_shared<Tipset>(TipsetKey(),
                                             std::vector<BlockHeader>({block1}));
-    auto is_called = false;
-    mock_function_ = [&](ChainEpoch height)
-        -> outcome::result<primitives::tipset::TipsetCPtr> {
-      if (height != 1) {
-        return TipsetCacheError::kNotInCache;
-      }
-      is_called = true;
-      return tipset1;
-    };
+    EXPECT_CALL(mock_ChainGetTipSetByHeight, Call(1, TipsetKey{}))
+        .WillOnce(testing::Return(tipset1));
     EXPECT_OUTCOME_EQ(tipset_cache_->get(1), *tipset1);
-    ASSERT_TRUE(is_called);
   }
 
   /**
@@ -200,4 +181,18 @@ namespace fc::mining {
     EXPECT_OUTCOME_EQ(tipset_cache_->getNonNull(2), tipset2);
   }
 
+  /**
+   * @given empty tipset_chache
+   * @when try to get tipset from empty tipset_chace
+   * @then success and best have returned Chain Head
+   */
+  TEST_F(TipsetCacheTest, EmptyCache) {
+    BlockHeader block1;
+    block1.height = 1;
+    auto tipset1 = std::make_shared<Tipset>(TipsetKey(),
+                                            std::vector<BlockHeader>({block1}));
+    EXPECT_CALL(mock_ChainHead, Call()).WillOnce(testing::Return(tipset1));
+    EXPECT_OUTCOME_EQ(tipset_cache_->best(), *tipset1);
+  }
+
 }  // namespace fc::mining

test/testutil/mocks/miner/tipset_cache_mock.hpp

@@ -20,6 +20,6 @@ namespace fc::mining {
 
     MOCK_METHOD1(get, outcome::result<boost::optional<Tipset>>(ChainEpoch));
 
-    MOCK_CONST_METHOD0(best, boost::optional<Tipset>());
+    MOCK_CONST_METHOD0(best, outcome::result<Tipset>());
   };
 }  // namespace fc::mining