GH-447 Terminate when reversible size exceeds irreversible by 1000 bl…

…ocks. Also refactor terminate-at-block handling.
AntelopeIO · Jul 30, 2024 · 505d835 · 505d835
1 parent 49b2400
commit 505d835
Show file tree

Hide file tree

Showing 3 changed files with 28 additions and 8 deletions.
diff --git a/libraries/chain/controller.cpp b/libraries/chain/controller.cpp
@@ -3523,8 +3523,7 @@ struct controller_impl {
                      const trx_meta_cache_lookup& trx_lookup ) {
       try {
          try {
-            if( conf.terminate_at_block > 0 && conf.terminate_at_block < bsp->block_num() ) { // < since checked before apply
-               ilog("Block ${n} reached configured maximum block ${num}; terminating", ("n", bsp->block_num()-1)("num", conf.terminate_at_block) );
+            if (should_terminate()) {
                shutdown();
                return false;
             }
@@ -3898,6 +3897,8 @@ struct controller_impl {
          consider_voting(bsp, use_thread_pool_t::no);
       }
 
+      // should_terminate() is not thread-safe requires chain_head.block_num()
+      // also when syncing allow many blocks in forkdb queued to be applied
       if (conf.terminate_at_block == 0 || bsp->block_num() <= conf.terminate_at_block) {
          forkdb.add(bsp, ignore_duplicate_t::yes);
          if constexpr (savanna_mode)
@@ -4701,6 +4702,25 @@ struct controller_impl {
       return conf.block_validation_mode == validation_mode::LIGHT || conf.trusted_producers.count(producer);
    }
 
+   bool should_terminate() const {
+      constexpr block_num_type max_reversible_blocks = 1000;
+      block_num_type head_block_num = chain_head.block_num();
+      if (conf.terminate_at_block > 0 && conf.terminate_at_block <= head_block_num) {
+         ilog("Block ${n} reached configured maximum block ${num}; terminating",
+              ("n", head_block_num)("num", conf.terminate_at_block) );
+         return true;
+      }
+      if (!replaying) {
+         block_num_type lib = fork_db_root_block_num();
+         if (lib > 0 && head_block_num >= lib + max_reversible_blocks) {
+            elog("Exceeded max reversible blocks allowed, head ${h} > LIB ${lib} + ${m}",
+                 ("h", head_block_num)("lib", lib)("m", max_reversible_blocks));
+            return true;
+         }
+      }
+      return false;
+   }
+
    bool is_builtin_activated( builtin_protocol_feature_t f )const {
       uint32_t current_block_num = chain_head.block_num();
 
@@ -5480,8 +5500,8 @@ validation_mode controller::get_validation_mode()const {
    return my->conf.block_validation_mode;
 }
 
-uint32_t controller::get_terminate_at_block()const {
-   return my->conf.terminate_at_block;
+bool controller::should_terminate()const {
+   return my->should_terminate();
 }
 
 const apply_handler* controller::find_apply_handler( account_name receiver, account_name scope, action_name act ) const

diff --git a/libraries/chain/include/eosio/chain/controller.hpp b/libraries/chain/include/eosio/chain/controller.hpp
@@ -378,7 +378,8 @@ namespace eosio::chain {
 
          db_read_mode get_read_mode()const;
          validation_mode get_validation_mode()const;
-         uint32_t get_terminate_at_block()const;
+         /// @return true if terminate-at-block or other conditions are met meanly application should terminate
+         bool should_terminate()const;
 
          void set_subjective_cpu_leeway(fc::microseconds leeway);
          std::optional<fc::microseconds> get_subjective_cpu_leeway() const;

diff --git a/plugins/producer_plugin/producer_plugin.cpp b/plugins/producer_plugin/producer_plugin.cpp
@@ -1830,14 +1830,13 @@ producer_plugin_impl::start_block_result producer_plugin_impl::start_block() {
    chain.maybe_switch_forks([this](const transaction_metadata_ptr& trx) { _unapplied_transactions.add_forked(trx); },
                             [this](const transaction_id_type& id) { return _unapplied_transactions.get_trx(id); });
 
-   uint32_t head_block_num = chain.head().block_num();
 
-   if (chain.get_terminate_at_block() > 0 && chain.get_terminate_at_block() <= head_block_num) {
-      ilog("Block ${n} reached configured maximum block ${num}; terminating", ("n",head_block_num)("num", chain.get_terminate_at_block()));
+   if (chain.should_terminate()) {
       app().quit();
       return start_block_result::failed;
    }
 
+   block_num_type             head_block_num    = chain.head().block_num();
    const fc::time_point       now               = fc::time_point::now();
    const block_timestamp_type block_time        = calculate_pending_block_time();
    const uint32_t             pending_block_num = head_block_num + 1;