Reinit before produce new block

disintar · Feb 14, 2024 · 19473bc · 19473bc
1 parent 6b7e33f
commit 19473bc
Show file tree

Hide file tree

Showing 7 changed files with 36 additions and 29 deletions.
diff --git a/crypto/vm/db/DynamicBagOfCellsDb.cpp b/crypto/vm/db/DynamicBagOfCellsDb.cpp
@@ -200,6 +200,7 @@ class DynamicBagOfCellsDbImpl : public DynamicBagOfCellsDb, private ExtCellCreat
   }
 
   td::Status set_loader(std::unique_ptr<CellLoader> loader) override {
+    LOG(WARNING) << "SET LOADER!";
     reset_cell_db_reader();
     loader_ = std::move(loader);
     //cell_db_reader_ = std::make_shared<CellDbReaderImpl>(this);

diff --git a/tddb/td/db/RocksDb.cpp b/tddb/td/db/RocksDb.cpp
@@ -102,11 +102,7 @@ Result<RocksDb> RocksDb::open(std::string path, bool read_only) {
 }
 
 std::unique_ptr<KeyValueReader> RocksDb::snapshot() {
-  if (!last_catch_timeout_ || last_catch_timeout_.is_in_past()) {
-    db_->TryCatchUpWithPrimary();
-    last_catch_timeout_ = td::Timestamp::at(0.1);
-  }
-
+  db_->TryCatchUpWithPrimary();
   auto res = std::make_unique<RocksDb>(clone());
   res->begin_snapshot().ensure();
   return std::move(res);

diff --git a/validator/db/rootdb.cpp b/validator/db/rootdb.cpp
@@ -505,7 +505,7 @@ void RootDb::run_gc(UnixTime mc_ts, UnixTime gc_ts, UnixTime archive_ttl) {
   td::actor::send_closure(archive_db_, &ArchiveManager::run_gc, mc_ts, gc_ts, archive_ttl);
 }
 
-void RootDb::reinit() {
+void RootDb::reinit(td::Promise<td::Unit>) {
   td::actor::send_closure(archive_db_, &ArchiveManager::reinit);
   td::actor::send_closure(cell_db_, &CellDb::reinit);
 }

diff --git a/validator/db/rootdb.hpp b/validator/db/rootdb.hpp
@@ -135,7 +135,7 @@ class RootDb : public Db {
   void set_async_mode(bool mode, td::Promise<td::Unit> promise) override;
 
   void run_gc(UnixTime mc_ts, UnixTime gc_ts, UnixTime archive_ttl) override;
-  void reinit() override;
+  void reinit(td::Promise<td::Unit>) override;
 
  private:
   td::actor::ActorId<ValidatorManager> validator_manager_;

diff --git a/validator/interfaces/db.h b/validator/interfaces/db.h
@@ -120,7 +120,7 @@ class Db : public td::actor::Actor {
   virtual void set_async_mode(bool mode, td::Promise<td::Unit> promise) = 0;
 
   virtual void run_gc(UnixTime mc_ts, UnixTime gc_ts, UnixTime archive_ttl) = 0;
-  virtual void reinit() = 0;
+  virtual void reinit(td::Promise<td::Unit>) = 0;
 };
 
 }  // namespace validator

diff --git a/validator/manager-disk.cpp b/validator/manager-disk.cpp
@@ -1299,10 +1299,8 @@ void ValidatorManagerImpl::receiveLastBlock(td::Result<td::Ref<BlockData>> block
     last_masterchain_time_ = info.gen_utime;
 
     // update DB if needed
-    td::actor::send_closure(db_, &Db::reinit);
     LOG(INFO) << "New MC block: " << last_masterchain_block_id_
               << " at: " << time_to_human(last_masterchain_time_) + ", shards: " << shards_idents;
-    td::actor::send_closure(db_, &Db::reinit);
 
     // Handle wait_block
     while (!shard_client_waiters_.empty()) {
@@ -1320,6 +1318,17 @@ void ValidatorManagerImpl::receiveLastBlock(td::Result<td::Ref<BlockData>> block
   }
 }
 
+void ValidatorManagerImpl::started_final(ton::validator::ValidatorManagerInitResult R) {
+  auto blk = R.handle;
+  auto P = td::PromiseCreator::lambda([validatorInitResult = std::move(R),
+                                       SelfId = actor_id(this)](td::Result<td::Ref<BlockData>> block_result) mutable {
+    td::actor::send_closure(SelfId, &ValidatorManagerImpl::receiveLastBlock, std::move(block_result),
+                            std::move(validatorInitResult));
+  });
+
+  td::actor::send_closure(actor_id(this), &ValidatorManagerImpl::get_block_data_from_db, blk, std::move(P));
+}
+
 void ValidatorManagerImpl::started(ValidatorManagerInitResult R, bool reinited) {
   if (!reinited) {
     last_masterchain_block_handle_ = std::move(R.handle);
@@ -1331,14 +1340,12 @@ void ValidatorManagerImpl::started(ValidatorManagerInitResult R, bool reinited)
     callback_->initial_read_complete(last_masterchain_block_handle_);
   } else {
     if (last_masterchain_block_id_ != R.handle->id()) {
-      auto blk = R.handle;
-      auto P = td::PromiseCreator::lambda([validatorInitResult = std::move(R), SelfId = actor_id(this)](
-                                              td::Result<td::Ref<BlockData>> block_result) mutable {
-        td::actor::send_closure(SelfId, &ValidatorManagerImpl::receiveLastBlock, std::move(block_result),
-                                std::move(validatorInitResult));
-      });
+      auto P = td::PromiseCreator::lambda(
+          [SelfId = actor_id(this), validatorInitResult = std::move(R)](td::Result<td::Unit> f) mutable {
+            td::actor::send_closure(SelfId, &ValidatorManagerImpl::started_final, std::move(validatorInitResult));
+          });
 
-      td::actor::send_closure(actor_id(this), &ValidatorManagerImpl::get_block_data_from_db, blk, std::move(P));
+      td::actor::send_closure(db_, &Db::reinit, std::move(P));
     }
   }
 }
@@ -1400,21 +1407,22 @@ void ValidatorManagerImpl::update_shard_client_state(BlockIdExt masterchain_bloc
   td::actor::send_closure(db_, &Db::update_shard_client_state, masterchain_block_id, std::move(promise));
 }
 
+void ValidatorManagerImpl::update_lite_server_state_final(ton::BlockIdExt shard_client,
+                                                          td::Ref<MasterchainState> state) {
+  LOG(INFO) << "New shard client available: " << shard_client;
+  last_liteserver_block_id_ = shard_client;
+  last_liteserver_state_ = std::move(state);
+}
+
 void ValidatorManagerImpl::update_lite_server_state(BlockIdExt shard_client, td::Ref<MasterchainState> state) {
-  if (last_liteserver_state_.is_null()) {
-    LOG(INFO) << "New shard client available (from null): " << shard_client;
-    last_liteserver_block_id_ = shard_client;
-    last_liteserver_state_ = std::move(state);
-    return;
-  }
+  if (last_liteserver_state_.is_null() || shard_client.seqno() > last_liteserver_block_id_.seqno()) {
+    auto P = td::PromiseCreator::lambda(
+        [SelfId = actor_id(this), client = shard_client, s = std::move(state)](td::Result<td::Unit> R) {
+          td::actor::send_closure(SelfId, &ValidatorManagerImpl::update_lite_server_state_final, client, s);
+        });
 
-  if (shard_client.seqno() > last_liteserver_block_id_.seqno()) {
-    LOG(INFO) << "New shard client available: " << shard_client;
-    last_liteserver_block_id_ = shard_client;
-    last_liteserver_state_ = std::move(state);
+    td::actor::send_closure(db_, &Db::reinit, std::move(P));
   }
-
-  td::actor::send_closure(db_, &Db::reinit);
 }
 
 void ValidatorManagerImpl::get_shard_client_state(bool from_db, td::Promise<BlockIdExt> promise) {

diff --git a/validator/manager-disk.hpp b/validator/manager-disk.hpp
@@ -122,6 +122,7 @@ class ValidatorManagerImpl : public ValidatorManager {
   }
   void validate_block(ReceivedBlock block, td::Promise<BlockHandle> promise) override;
   void update_lite_server_state(BlockIdExt shard_client, td::Ref<MasterchainState> state) override;
+  void update_lite_server_state_final(BlockIdExt shard_client, td::Ref<MasterchainState> state);
   void prevalidate_block(BlockBroadcast broadcast, td::Promise<td::Unit> promise) override;
 
   //void create_validate_block(BlockId block, td::BufferSlice data, td::Promise<Block> promise) = 0;
@@ -314,6 +315,7 @@ class ValidatorManagerImpl : public ValidatorManager {
 
   void start_up() override;
   void started(ValidatorManagerInitResult result, bool reinited = false);
+  void started_final(ValidatorManagerInitResult result);
 
   void write_fake(BlockCandidate candidate, std::vector<BlockIdExt> prev, BlockIdExt last,
                   td::Ref<ValidatorSet> val_set);