P2P: Add gossip of BP peers

libraries/chain/controller.cpp

@@ -1286,7 +1286,7 @@ struct controller_impl {
       }
    }
 
-   getpeerkeys_res_t get_top_producer_keys(fc::time_point deadline) {
+   getpeerkeys_res_t get_top_producer_keys() {
       try {
          auto get_getpeerkeys_transaction = [&]() {
             auto perms = vector<permission_level>{};
@@ -1303,7 +1303,7 @@ struct controller_impl {
             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);
+         auto trace = push_transaction(metadata, fc::time_point::maximum(), fc::milliseconds(20), 0, false, 0);
 
          if( trace->except_ptr )
             std::rethrow_exception(trace->except_ptr);
@@ -3237,6 +3237,11 @@ struct controller_impl {
 
       auto& bb = std::get<building_block>(pending->_block_stage);
 
+      // limit to complete type to avoid multiple calls per block number due to speculative blocks
+      if (pending->_block_status == controller::block_status::complete) {
+         update_peer_keys();
+      }
+
       transaction_trace_ptr onblock_trace;
 
       // block status is either ephemeral or incomplete. Modify state of speculative block only if we are building a
@@ -3384,12 +3389,16 @@ struct controller_impl {
       return onblock_trace;
    } /// start_block
 
-   void update_peer_keys(fc::time_point deadline) {
+   void update_peer_keys() {
+      // if syncing or replaying old blocks don't bother updating peer keys
+      if (!peer_keys_db.is_active() || fc::time_point::now() - chain_head.timestamp() > fc::minutes(5))
+         return;
+
       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));
+         auto block_num = chain_head.block_num() + 1;
+         if (peer_keys_db.should_update(block_num)) { // update once/minute
+            // update peer public keys from chainbase db using a readonly trx
+            peer_keys_db.update_peer_keys(block_num, get_top_producer_keys());
          }
       } FC_LOG_AND_DROP()
    }
@@ -5339,10 +5348,6 @@ 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();
 
@@ -5839,16 +5844,20 @@ chain_id_type controller::get_chain_id()const {
    return my->chain_id;
 }
 
-void controller::set_peer_keys_retrieval_active(bool active) {
-   my->peer_keys_db.set_active(active);
+void controller::set_peer_keys_retrieval_active(flat_set<account_name> configured_bp_peers) {
+   my->peer_keys_db.set_active(std::move(configured_bp_peers));
 }
 
-peer_info_t controller::get_peer_info(name n) const {
+std::optional<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);
+bool controller::configured_peer_keys_updated() {
+   return my->peer_keys_db.configured_peer_keys_updated();
+}
+
+getpeerkeys_res_t controller::get_top_producer_keys() {
+   return my->get_top_producer_keys();
 }
 
 db_read_mode controller::get_read_mode()const {

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

@@ -247,7 +247,6 @@ 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);
@@ -445,9 +444,11 @@ namespace eosio::chain {
 
          chain_id_type get_chain_id()const;
 
-         void set_peer_keys_retrieval_active(bool active);
-         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
+         void set_peer_keys_retrieval_active(flat_set<account_name> configured_bp_peers);
+         std::optional<peer_info_t> get_peer_info(name n) const;  // thread safe
+         bool configured_peer_keys_updated(); // thread safe
+         // used for testing, only call with an active pending block from main thread
+         getpeerkeys_res_t get_top_producer_keys();
 
          // thread safe
          db_read_mode get_read_mode()const;

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

@@ -16,28 +16,37 @@ class peer_keys_db_t {
    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();
+   peer_keys_db_t() = default;
 
-   void set_active(bool b) { _active = b; }
+   // called on startup with configured bp peers of the node
+   void set_active(new_peers_t configured_bp_peers) {
+      _configured_bp_peers = std::move(configured_bp_peers);
+      _active = true;
+   }
 
-   // must be called from main thread
-   // 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, _active only modified on startup
+   bool is_active() const { return _active; }
+
+   // must be called from the main thread
+   // return true if update_peer_keys should be called with new map of peer keys
+   bool should_update(block_num_type block_num) { return _active && (_last_block_num == 0 || block_num % 120 == 0); }
+
+   // must be called from main thread, only call if should_update() returns true
+   void update_peer_keys(block_num_type block_num, const getpeerkeys_res_t& v);
 
    // safe to be called from any thread
-   // 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;
+   std::optional<peer_info_t> get_peer_info(name n) const;
 
-private:
-   std::optional<uint64_t> _get_version(const chainbase::database& db);
+   // safe to be called from any thread
+   // returns true if configured bp peers modified, also resets flag so next call returns false until updated again
+   bool configured_peer_keys_updated();
 
+private:
    bool               _active = false;       // if not active (the default), no update occurs
+   block_num_type     _last_block_num = 0;
+   new_peers_t        _configured_bp_peers;  // no updates occurs
+   std::atomic<bool>  _configured_bp_peers_updated{false};
+
    mutable fc::mutex  _m;
    peer_key_map_t     _peer_info_map GUARDED_BY(_m);
 };

libraries/chain/peer_keys_db.cpp

@@ -3,34 +3,40 @@
 
 namespace eosio::chain {
 
-peer_keys_db_t::peer_keys_db_t() : _active(false) {}
-
-peer_info_t peer_keys_db_t::get_peer_info(name n) const {
+std::optional<peer_info_t> peer_keys_db_t::get_peer_info(name n) const {
    fc::lock_guard g(_m);
    assert(_active);
    if (auto it = _peer_info_map.find(n); it != _peer_info_map.end())
-      return it->second;
-   return peer_info_t{};
+      return std::optional<peer_info_t>(it->second);
+   return std::optional<peer_info_t>{};
+}
+
+bool peer_keys_db_t::configured_peer_keys_updated() {
+   return _configured_bp_peers_updated.exchange(false);
 }
 
-peer_keys_db_t::new_peers_t peer_keys_db_t::update_peer_keys(const getpeerkeys_res_t& v) {
-   if (!_active || v.empty())
-      return {};
+void peer_keys_db_t::update_peer_keys(block_num_type block_num, const getpeerkeys_res_t& v) {
+   assert(_active);
+   _last_block_num = block_num;
+
+   if (v.empty())
+      return;
 
    // create hash_map of current top selected producers (according to "getpeerkeys"_n in system contracts)
    // ----------------------------------------------------------------------------------------------------
    peer_key_map_t current;
    for (size_t i=0; i<v.size(); ++i)
       current[v[i].producer_name] = peer_info_t{static_cast<uint32_t>(i), v[i].peer_key};
 
+   bool configured_bp_peers_updated = false;
    fc::lock_guard g(_m);
-   new_peers_t res;
 
    // remove those that aren't among the top producers anymore
    // --------------------------------------------------------
    for (auto it = _peer_info_map.begin(); it != _peer_info_map.end(); ) {
       if (!current.contains(it->first)) {
-         res.insert(it->first);
+         if (_configured_bp_peers.contains(it->first))
+            configured_bp_peers_updated = true;
          it = _peer_info_map.erase(it);
       } else {
          ++it;
@@ -42,11 +48,13 @@ peer_keys_db_t::new_peers_t peer_keys_db_t::update_peer_keys(const getpeerkeys_r
    for (auto& pi : current) {
       if (!_peer_info_map.contains(pi.first) || _peer_info_map[pi.first] != pi.second) {
          _peer_info_map[pi.first] = pi.second;
-         res.insert(pi.first);
+         if (_configured_bp_peers.contains(pi.first))
+            configured_bp_peers_updated = true;
       }
    }
-
-   return res;
+
+   if (configured_bp_peers_updated)
+      _configured_bp_peers_updated = true;
 }
 
 } // namespace eosio::chain