EOS多节点同步代码分析

时间:2018-07-13作者:klpeng分类:IT综合浏览:900评论:0

EOS version: 1.0.7

一. 配置文件的修改

  EOS的节点同步流程是通过p2p来完成,在nodeos的配置文件config.ini中填写,其默认路径为~/.local/share/eosio/nodeos/config目录下,配置项及其格式如下:

p2p-peer-address = 10.186.11.223:9876
121 p2p-peer-address = 10.186.11.220:9876
122 p2p-peer-address = 10.186.11.141:9876

可以填写多个p2p站点地址。

二.节点同步的chain_id

  每一个节点都唯一分配一个chain_id,如果两个节点的chian_id不相等的话,是无法进行同步的,代码中处理如下:

EOS多节点同步代码分析
void net_plugin_impl::handle_message( connection_ptr c, const handshake_message &msg) {
         ...

if( msg.chain_id != chain_id) {
            elog( "Peer on a different chain. Closing connection");
            c->enqueue( go_away_message(go_away_reason::wrong_chain) );
            return;
         }

         ...
}
EOS多节点同步代码分析

  那么这个chain_id是如何开成的?

  chain_id在chain_plugin中定义,在net_plugin中使用,在chain_plugin中如下定义

//controller.cpp 

EOS多节点同步代码分析
chain_id( cfg.genesis.compute_chain_id() )


//genesis_state.cpp

chain::chain_id_type genesis_state::compute_chain_id() const {

digest_type::encoder enc;
fc::raw::pack( enc, *this );
return chain_id_type{enc.result()};
}

EOS多节点同步代码分析

  这里相当于把整个genesis的数据做了一个类似hash的操作,默认情况下genesis的数据在代码中填写:

EOS多节点同步代码分析
chain_config   initial_configuration = {
      .max_block_net_usage                  = config::default_max_block_net_usage,
      .target_block_net_usage_pct           = config::default_target_block_net_usage_pct,
      .max_transaction_net_usage            = config::default_max_transaction_net_usage,
      .base_per_transaction_net_usage       = config::default_base_per_transaction_net_usage,
      .net_usage_leeway                     = config::default_net_usage_leeway,
      .context_free_discount_net_usage_num  = config::default_context_free_discount_net_usage_num,
      .context_free_discount_net_usage_den  = config::default_context_free_discount_net_usage_den,

      .max_block_cpu_usage                  = config::default_max_block_cpu_usage,
      .target_block_cpu_usage_pct           = config::default_target_block_cpu_usage_pct,
      .max_transaction_cpu_usage            = config::default_max_transaction_cpu_usage,
      .min_transaction_cpu_usage            = config::default_min_transaction_cpu_usage,

      .max_transaction_lifetime             = config::default_max_trx_lifetime,
      .deferred_trx_expiration_window       = config::default_deferred_trx_expiration_window,
      .max_transaction_delay                = config::default_max_trx_delay,
      .max_inline_action_size               = config::default_max_inline_action_size,
      .max_inline_action_depth              = config::default_max_inline_action_depth,
      .max_authority_depth                  = config::default_max_auth_depth,
   };
EOS多节点同步代码分析

  还可以通过nodeos命令行参数--genesis-json加载一个指定的配置文件genesis.json,其内容一般如下格式:

EOS多节点同步代码分析
{
  "initial_timestamp": "2018-03-02T12:00:00.000",
  "initial_key": "EOS8Znrtgwt8TfpmbVpTKvA2oB8Nqey625CLN8bCN3TEbgx86Dsvr",
  "initial_configuration": {
    "max_block_net_usage": 1048576,
    "target_block_net_usage_pct": 1000,
    "max_transaction_net_usage": 524288,
    "base_per_transaction_net_usage": 12,
    "net_usage_leeway": 500,
    "context_free_discount_net_usage_num": 20,
    "context_free_discount_net_usage_den": 100,
    "max_block_cpu_usage": 100000,
    "target_block_cpu_usage_pct": 500,
    "max_transaction_cpu_usage": 50000,
    "min_transaction_cpu_usage": 100,
    "max_transaction_lifetime": 3600,
    "deferred_trx_expiration_window": 600,
    "max_transaction_delay": 3888000,
    "max_inline_action_size": 4096,
    "max_inline_action_depth": 4,
    "max_authority_depth": 6,
    "max_generated_transaction_count": 16
  },
  "initial_chain_id": "0000000000000000000000000000000000000000000000000000000000000000"
}
EOS多节点同步代码分析

  所以,节点之间能同步的条件是参数配置需要完全相当的。

四.区块同步数据流

  数据同步涉及几个消息:

  handshake_message,  //hello握手信息,
  chain_size_message,  //暂未看到使用
  go_away_message //停止同步消息
  time_message,  // 时间戳相关
  notice_message,  //区块和事务状态同步
  request_message,  //请求发送区块同步,带有区块的num数据
  sync_request_message,  //在request_message基础上加了一个定时器做超时处理
  signed_block,      // 具体的区块数据
  packed_transaction    //事务同步处理

 

  现在假设有一个节点M,它的p2p-peer-address对就有三个地址a、b、c,现在数据同步的流程基本上有下面几个步骤.

 

  1.handshake_message处理流程

    首先,M结点会向a、b、c循环发起连接并发送一条握手信息,这条信息是一个名为struct handshake_message,定义如下:

EOS多节点同步代码分析
struct handshake_message {
      uint16_t                   network_version = 0; //net version, require  M == a == b == c      chain_id_type              chain_id; // M == a == b == c      fc::sha256                 node_id; ///< used to identify peers and prevent self-connect
      chain::public_key_type     key; ///< authentication key; may be a producer or peer key, or empty
      tstamp                     time;
      fc::sha256                 token; ///< digest of time to prove we own the private key of the key above
      chain::signature_type      sig; ///< signature for the digest
      string                     p2p_address;
      uint32_t                   last_irreversible_block_num = 0;
      block_id_type              last_irreversible_block_id;
      uint32_t                   head_num = 0;
      block_id_type              head_id;
      string                     os;
      string                     agent;
      int16_t                    generation;
   };
EOS多节点同步代码分析

包括了对通信的基本要求的参数,该消息初始化后会将其放入名为write_queue的消息队列中,最后消息是使用asio::async_write进行发送,发送消息的成功与否是通过回调来处理的。

EOS多节点同步代码分析
void connection::do_queue_write() {

...
while (write_queue.size() > 0) {
         auto& m = write_queue.front();
         bufs.push_back(boost::asio::buffer(*m.buff));
         out_queue.push_back(m);
         write_queue.pop_front();
      }
      boost::asio::async_write(*socket, bufs, [c](boost::system::error_code ec, std::size_t w) {
 try {
        for (auto& m: conn->out_queue) {
                  m.callback(ec, w);
               }

while (conn->out_queue.size() > 0) {
                  conn->out_queue.pop_front();
               }
               conn->enqueue_sync_block();
               conn->do_queue_write();

    }
...
}
EOS多节点同步代码分析

对端收到handshake_message的消息后处理如下代码:

EOS多节点同步代码分析
void sync_manager::recv_handshake (connection_ptr c, const handshake_message &msg) {
    controller& cc = chain_plug->chain();
      uint32_t lib_num = cc.last_irreversible_block_num( );
      uint32_t peer_lib = msg.last_irreversible_block_num;
      reset_lib_num(c);
      c->syncing = false;

      //--------------------------------
      // sync need checks; (lib == last irreversible block)
      //
      // 0. my head block id == peer head id means we are all caugnt up block wise
      // 1. my head block num < peer lib - start sync locally
      // 2. my lib > peer head num - send an last_irr_catch_up notice if not the first generation
      //
      // 3  my head block num <= peer head block num - update sync state and send a catchup request
      // 4  my head block num > peer block num ssend a notice catchup if this is not the first generation
      //
      //-----------------------------

      uint32_t head = cc.head_block_num( );
      block_id_type head_id = cc.head_block_id();
      if (head_id == msg.head_id) {
      ...  
    }
        
    ...
}
EOS多节点同步代码分析

梳理流程:

  • 两个节点历史区块id相等,不进行同步;
  • A节点区块的head_block_num小于B节点不可逆区块的head_block_num,则B给A发送消息notice_message,消息中包含A节点所需要同步的区块范围,每次同步块数为sync_req_span,此参数在genesis.json中设置或者是程度初始的;
  • A节点不可逆区块的head_block_num大于B节点区块的head_block_num,则A给B发送消息notice_message,消息中包含可逆与不可逆区块的block_num;
  • A节点区块的head_block_num小于B节点的head_block_num,A节点会产生一个request_message消息发送给B; 

2.go_away_message

  一般在某些异常情况下节点A会断开与其它节点的同步,会发送一个go_away_message,会带有一个错误码:

EOS多节点同步代码分析
  enum go_away_reason {
    no_reason, ///< no reason to go away
    self, ///< the connection is to itself
    duplicate, ///< the connection is redundant
    wrong_chain, ///< the peer's chain id doesn't match
    wrong_version, ///< the peer's network version doesn't match
    forked, ///< the peer's irreversible blocks are different
    unlinkable, ///< the peer sent a block we couldn't use
    bad_transaction, ///< the peer sent a transaction that failed verification
    validation, ///< the peer sent a block that failed validation
    benign_other, ///< reasons such as a timeout. not fatal but warrant resetting
    fatal_other, ///< a catch-all for errors we don't have discriminated
    authentication ///< peer failed authenicatio
  };
EOS多节点同步代码分析

3.time_message

  这个消息应该是发送一个带有几个时间标志的keeplive消息包,目前设置的是每32秒发送一次。

 

4.notice_message

  这个消息定义如下:

struct notice_message {
    notice_message () : known_trx(), known_blocks() {}
    ordered_txn_ids known_trx;
    ordered_blk_ids known_blocks;
  };

  它包含了区块的信息和交易信息,也即对可逆区块,可逆事务,不可逆区块,不可逆事务都可以通过这个消息处理。比如,节点A把本地节点最新区块和事务信息(block_num)发送给节点B,节点B收到后会将本地的区块和事务信息(block_num)进行比较,根据比较的结果决定谁给谁传输数据。

 

5.request_message

  A节点请求端分为四种,节点B做为接收端,分别给予的应答如下:

   对于区块:

  • catch_up:B节点把本地的所有可逆的区块打包发给节点A; 
  • normal:根据A节点vector里面的区块id,在本地(B节点)不可逆的区块中进行查找,如果找到了就把该区块就发给A;

  对于事务:

  • catch_up:B节点把A节点所需要的可逆的transaction id 并且自己本地有的数据发送给A;
  • normal:  B节点把A节点所需要的不可逆的transaction id 并且自己本地有的数据发送给A;

6.sync_request_message

  此消息是在request_message实现基础上加了一个5S的定时器,同步消息在5S内没有得到应答会取消当前同步后再重新要求同步;

7.signed_block

  这里发送的是具体的区块数据,一般是收到request_message或者 sync_request_message消息后把本节点的区块发给对方;

EOS多节点同步代码分析
 bool connection::enqueue_sync_block() {
      controller& cc = app().find_plugin<chain_plugin>()->chain();
      if (!peer_requested)
         return false;
      uint32_t num = ++peer_requested->last;
      bool trigger_send = num == peer_requested->start_block;
      if(num == peer_requested->end_block) {
         peer_requested.reset();
      }
      try {
      //从本地取出区块数据 signed_block_ptr sb
= cc.fetch_block_by_number(num); if(sb) {
       //放入消息队列并异步发送 enqueue(
*sb, trigger_send); return true; } } catch ( ... ) { wlog( "write loop exception" ); } return false; }
EOS多节点同步代码分析

 

8.packed_transaction

  节点A把多个transacton放在一起进行打包发送,收到packed_transaction消息的节点会对其进行各种校验,如果校验结果正确,会把数据缓存到本地,然后再对本端所有p2p-peer-address的地址进行广播。所以对于多个transaction的数据,在这里就实现了在多个地址之间相互快速传播的功能。

EOS多节点同步代码分析
void net_plugin_impl::handle_message( connection_ptr c, const packed_transaction &msg) {
      fc_dlog(logger, "got a packed transaction, cancel wait");
      peer_ilog(c, "received packed_transaction");
      if( sync_master->is_active(c) ) {
         fc_dlog(logger, "got a txn during sync - dropping");
         return;
      }
      transaction_id_type tid = msg.id();

    //收到数据后取异步定时器 c
->cancel_wait(); if(local_txns.get<by_id>().find(tid) != local_txns.end()) { fc_dlog(logger, "got a duplicate transaction - dropping"); return; }
    //将数据保存到本地的缓存中 dispatcher
->recv_transaction(c, tid); uint64_t code = 0;

    //对数据进行校验,然后把结果传递给回调函数 chain_plug
->accept_transaction(msg, [=](const static_variant<fc::exception_ptr, transaction_trace_ptr>& result) { if (result.contains<fc::exception_ptr>()) { auto e_ptr = result.get<fc::exception_ptr>(); if (e_ptr->code() != tx_duplicate::code_value && e_ptr->code() != expired_tx_exception::code_value) elog("accept txn threw ${m}",("m",result.get<fc::exception_ptr>()->to_detail_string())); peer_elog(c, "bad packed_transaction : ${m}", ("m",result.get<fc::exception_ptr>()->what())); } else { auto trace = result.get<transaction_trace_ptr>();
         if (!trace->except) { fc_dlog(logger, "chain accepted transaction");
        
          //对其它p2p-peer-address进行广播,数据互传 dispatcher
->bcast_transaction(msg); return; } peer_elog(c, "bad packed_transaction : ${m}", ("m",trace->except->what())); }       //数据校给失败,本地缓存数据回滚 dispatcher->rejected_transaction(tid); }); }
原文:https://www.cnblogs.com/hbright/p/9287669.html
打赏
文章版权声明:除非注明,否则均为彭超的博客原创文章,转载或复制请以超链接形式并注明出处。
相关推荐

发表评论:

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

猜你喜欢