main to 2.0 merge of #1383, #1316, #1330

libraries/chain/controller.cpp

@@ -1274,6 +1274,57 @@ struct controller_impl {
       apply_handlers[receiver][make_pair(contract,action)] = v;
    }
 
+   void set_trx_expiration(signed_transaction& trx) {
+      if (is_builtin_activated(builtin_protocol_feature_t::no_duplicate_deferred_id)) {
+         trx.expiration       = time_point_sec();
+         trx.ref_block_num    = 0;
+         trx.ref_block_prefix = 0;
+      } else {
+         trx.expiration = time_point_sec{
+            pending_block_time() + fc::microseconds(999'999)}; // Round up to nearest second to avoid appearing expired
+         trx.set_reference_block(chain_head.id());
+      }
+   }
+
+   getpeerkeys_res_t get_top_producer_keys(fc::time_point deadline) {
+      try {
+         auto get_getpeerkeys_transaction = [&]() {
+            auto perms = vector<permission_level>{};
+            action act(perms, config::system_account_name, "getpeerkeys"_n, {});
+            signed_transaction trx;
+
+            trx.actions.emplace_back(std::move(act));
+            set_trx_expiration(trx);
+            return trx;
+         };
+
+         auto metadata = transaction_metadata::create_no_recover_keys(
+            std::make_shared<packed_transaction>(get_getpeerkeys_transaction()),
+            transaction_metadata::trx_type::read_only);
+
+         // allow a max of 20ms for getpeerkeys
+         auto trace = push_transaction(metadata, deadline, fc::milliseconds(20), 0, false, 0);
+
+         if( trace->except_ptr )
+            std::rethrow_exception(trace->except_ptr);
+         if( trace->except)
+            throw *trace->except;
+         getpeerkeys_res_t res;
+         if (!trace->action_traces.empty()) {
+            const auto& act_trace = trace->action_traces[0];
+            const auto& retval = act_trace.return_value;
+            if (!retval.empty()) {
+               // in some tests, the system contract is not set and the return value is empty.
+               fc::datastream<const char*> ds(retval.data(), retval.size());
+               fc::raw::unpack(ds, res);
+            }
+         }
+
+         return res;
+      }
+      FC_LOG_AND_RETHROW()
+   }
+
    controller_impl( const controller::config& cfg, controller& s, protocol_feature_set&& pfs, const chain_id_type& chain_id )
    :rnh(),
     self(s),
@@ -1322,9 +1373,6 @@ struct controller_impl {
          const auto& [ block, id] = t;
          wasmif.current_lib(block->block_num());
          vote_processor.notify_lib(block->block_num());
-
-         // update peer public keys from chainbase db 
-         peer_keys_db.update_peer_keys(self, block->block_num());
       });
 
 #define SET_APP_HANDLER( receiver, contract, action) \
@@ -2623,14 +2671,7 @@ struct controller_impl {
       // Deliver onerror action containing the failed deferred transaction directly back to the sender.
       etrx.actions.emplace_back( vector<permission_level>{{gtrx.sender, config::active_name}},
                                  onerror( gtrx.sender_id, gtrx.packed_trx.data(), gtrx.packed_trx.size() ) );
-      if( is_builtin_activated( builtin_protocol_feature_t::no_duplicate_deferred_id ) ) {
-         etrx.expiration = time_point_sec();
-         etrx.ref_block_num = 0;
-         etrx.ref_block_prefix = 0;
-      } else {
-         etrx.expiration = time_point_sec{pending_block_time() + fc::microseconds(999'999)}; // Round up to nearest second to avoid appearing expired
-         etrx.set_reference_block( chain_head.id() );
-      }
+      set_trx_expiration(etrx);
 
       auto& bb = std::get<building_block>(pending->_block_stage);
 
@@ -3339,9 +3380,20 @@ struct controller_impl {
       }
 
       guard_pending.cancel();
+
       return onblock_trace;
    } /// start_block
 
+   void update_peer_keys(fc::time_point deadline) {
+      try {
+         // update peer public keys from chainbase db using a readonly trx
+         auto block_num = chain_head.block_num();
+         if (block_num % 120 == 0) { // update once/minute
+            peer_keys_db.update_peer_keys(get_top_producer_keys(deadline));
+         }
+      } FC_LOG_AND_DROP()
+   }
+
    void assemble_block(bool validating, std::optional<qc_data_t> validating_qc_data, const block_state_ptr& validating_bsp)
    {
       EOS_ASSERT( pending, block_validate_exception, "it is not valid to finalize when there is no pending block");
@@ -4554,12 +4606,13 @@ struct controller_impl {
       return applied_trxs;
    }
 
-   void interrupt_apply_block_transaction() {
-      // Only interrupt transaction if applying a block. Speculative trxs already have a deadline set so they
-      // have limited run time already. This is to allow killing a long-running transaction in a block being
-      // validated.
-      if (!replaying && applying_block) {
-         ilog("Interrupting apply block");
+   void interrupt_transaction() {
+      // Do not interrupt during replay. ctrl-c during replay is handled at block boundaries.
+      // Interrupt both speculative trxs and trxs while applying a block.
+      // This is to allow killing a long-running transaction in a block being validated during apply block.
+      // This also allows killing a trx when a block is received to prioritize block validation.
+      if (!replaying) {
+         dlog("Interrupting trx...");
          main_thread_timer.interrupt_timer();
       }
    }
@@ -4788,14 +4841,7 @@ struct controller_impl {
 
       signed_transaction trx;
       trx.actions.emplace_back(std::move(on_block_act));
-      if( is_builtin_activated( builtin_protocol_feature_t::no_duplicate_deferred_id ) ) {
-         trx.expiration = time_point_sec();
-         trx.ref_block_num = 0;
-         trx.ref_block_prefix = 0;
-      } else {
-         trx.expiration = time_point_sec{pending_block_time() + fc::microseconds(999'999)}; // Round up to nearest second to avoid appearing expired
-         trx.set_reference_block( chain_head.id() );
-      }
+      set_trx_expiration(trx);
 
       return trx;
    }
@@ -5293,6 +5339,10 @@ transaction_trace_ptr controller::start_block( block_timestamp_type when,
                            bs, std::optional<block_id_type>(), deadline );
 }
 
+void controller::update_peer_keys(fc::time_point deadline) {
+   my->update_peer_keys(deadline);
+}
+
 void controller::assemble_and_complete_block( const signer_callback_type& signer_callback ) {
    validate_db_available_size();
 
@@ -5338,8 +5388,8 @@ deque<transaction_metadata_ptr> controller::abort_block() {
    return my->abort_block();
 }
 
-void controller::interrupt_apply_block_transaction() {
-   my->interrupt_apply_block_transaction();
+void controller::interrupt_transaction() {
+   my->interrupt_transaction();
 }
 
 boost::asio::io_context& controller::get_thread_pool() {
@@ -5793,8 +5843,12 @@ void controller::set_peer_keys_retrieval_active(bool active) {
    my->peer_keys_db.set_active(active);
 }
 
-std::optional<public_key_type> controller::get_peer_key(name n) const {
-   return my->peer_keys_db.get_peer_key(n);
+peer_info_t controller::get_peer_info(name n) const {
+   return my->peer_keys_db.get_peer_info(n);
+}
+
+getpeerkeys_res_t controller::get_top_producer_keys(fc::time_point deadline) {
+   return my->get_top_producer_keys(deadline);
 }
 
 db_read_mode controller::get_read_mode()const {

libraries/chain/include/eosio/chain/controller.hpp

@@ -80,6 +80,23 @@ namespace eosio::chain {
       class resource_limits_manager;
    };
 
+   // vector, sorted by rank, of the top-50 producers by `total_votes` (whether
+   // active or not) and their peer key if populated on-chain.
+   // -------------------------------------------------------------------------
+   struct peerkeys_t {
+      name                           producer_name;
+      std::optional<public_key_type> peer_key;
+   };
+   using getpeerkeys_res_t = std::vector<peerkeys_t>;
+
+   struct peer_info_t {
+      // rank by `total_votes` of all producers, active or not, may not match schedule rank
+      uint32_t                       rank{std::numeric_limits<uint32_t>::max()};
+      std::optional<public_key_type> key;
+
+      bool operator==(const peer_info_t&) const = default;
+   };
+
    struct controller_impl;
    using chainbase::database;
    using chainbase::pinnable_mapped_file;
@@ -209,7 +226,7 @@ namespace eosio::chain {
          deque<transaction_metadata_ptr> abort_block();
 
          /// Expected to be called from signal handler, or producer_plugin
-         void interrupt_apply_block_transaction();
+         void interrupt_transaction();
 
        /**
         *
@@ -230,6 +247,7 @@ namespace eosio::chain {
          void assemble_and_complete_block( const signer_callback_type& signer_callback );
          void sign_block( const signer_callback_type& signer_callback );
          void commit_block();
+         void update_peer_keys(fc::time_point deadline);
          void testing_allow_voting(bool val);
          bool get_testing_allow_voting_flag();
          void set_async_voting(async_t val);
@@ -428,7 +446,8 @@ namespace eosio::chain {
          chain_id_type get_chain_id()const;
 
          void set_peer_keys_retrieval_active(bool active);
-         std::optional<public_key_type> get_peer_key(name n) const; // thread safe
+         peer_info_t  get_peer_info(name n) const;  // thread safe
+         getpeerkeys_res_t get_top_producer_keys(fc::time_point deadline); // must be called from main thread
 
          // thread safe
          db_read_mode get_read_mode()const;
@@ -518,3 +537,5 @@ namespace eosio::chain {
    }; // controller
 
 }  /// eosio::chain
+
+FC_REFLECT(eosio::chain::peerkeys_t, (producer_name)(peer_key))

libraries/chain/include/eosio/chain/peer_keys_db.hpp

@@ -13,34 +13,34 @@ namespace eosio::chain {
  */
 class peer_keys_db_t {
 public:
-   struct v0_data {                   // must match the one in eosio.system.hpp
-      std::optional<public_key_type> pubkey;
-   };
-
-   using peer_key_map_t = boost::unordered_flat_map<name, public_key_type, std::hash<name>>;
+   using peer_key_map_t = boost::unordered_flat_map<name, peer_info_t, std::hash<name>>;
+   using new_peers_t    = flat_set<name>;
 
    peer_keys_db_t();
 
    void set_active(bool b) { _active = b; }
 
    // must be called from main thread
-   size_t update_peer_keys(const controller& chain, uint32_t lib_number);
-
-   // safe to be called from any thread
-   std::optional<public_key_type> get_peer_key(name n) const;
+   // return the new peers either:
+   //  - added to the top selected producers (according to "getpeerkeys"_n in system contracts)
+   //  - removed from the top selected producers
+   //  - whose key changed
+   // since the last call to update_peer_keys
+   // ---------------------------------------
+   new_peers_t update_peer_keys(const getpeerkeys_res_t& v);
 
    // safe to be called from any thread
-   size_t size() const;
+   // peers no longer in top selected producers will have a rank of std::numeric_limits<uint32_t>::max()
+   // ----------------------------------------------------------------------------------
+   peer_info_t get_peer_info(name n) const;
 
 private:
    std::optional<uint64_t> _get_version(const chainbase::database& db);
 
    bool               _active = false;       // if not active (the default), no update occurs
-   uint32_t           _block_num = 0;        // below map includes keys registered up to _block_num (inclusive)
    mutable fc::mutex  _m;
-   peer_key_map_t     _peer_key_map GUARDED_BY(_m);
+   peer_key_map_t     _peer_info_map GUARDED_BY(_m);
 };
 
 } // namespace eosio::chain
 
-FC_REFLECT(eosio::chain::peer_keys_db_t::v0_data, (pubkey))