producer_plugin是控制區(qū)塊生產(chǎn)的關(guān)鍵插件。

關(guān)鍵字：producer_plugin，同步區(qū)塊的處理，pending區(qū)塊，生產(chǎn)區(qū)塊，最后不可逆區(qū)塊，生產(chǎn)循環(huán)，生產(chǎn)安排，水印輪次，計時器，確認(rèn)數(shù)

producer_plugin生命周期

EOS的所有plugin都有共同的基類，因此每個plugin的研究都可以從生命周期入手。

①set_program_options

向config.ini文件中增加屬于producer_plugin的配置項。這些配置項如下表所示。

配置項解釋

enable-stale-production	允許區(qū)塊生產(chǎn)，即使鏈?zhǔn)顷惛?#xff0c;即鏈生產(chǎn)的區(qū)塊由于遲到未能被采納進(jìn)鏈。
pause-on-startup	當(dāng)生產(chǎn)暫停時啟動這個節(jié)點(diǎn)
max-transaction-time	執(zhí)行已推送事務(wù)代碼的最長時間限制，過期則判定為無效，默認(rèn)30毫秒
max-irreversible-block-age	當(dāng)前節(jié)點(diǎn)生產(chǎn)區(qū)塊所在鏈的DPOS不可逆區(qū)塊的時間限制，按秒計算，默認(rèn)-1無限制。
producer-name	當(dāng)前節(jié)點(diǎn)的生產(chǎn)者ID，可以被多次指定。
private-key	(已被丟棄，使用以下signature-provider替代)
signature-provider	KV元組使用格式為<public-key>=<provider-spec>，等號前為公鑰，等號后為KEY:私鑰或KEOSD:私鑰。前者為以上公鑰對應(yīng)的私鑰，后者為keosd的可用url并且相關(guān)錢包要被解鎖。
keosd-provider-timeout	發(fā)送區(qū)塊到keosd簽名的最大時間，按毫秒計算。
greylist-account	灰名單，記錄了無法繼承CPU/NET虛擬資源的賬戶列表。
produce-time-offset-us	非最后一個區(qū)塊產(chǎn)生時間的偏移量，按微秒計算。負(fù)值會導(dǎo)致塊更早出去，正值會導(dǎo)致塊更晚出去。
last-block-time-offset-us	最后一個區(qū)塊產(chǎn)生時間的偏移量，按微秒計算。負(fù)值會導(dǎo)致塊更早出去，正值會導(dǎo)致塊更晚出去。
incoming-defer-ratio	當(dāng)兩者都被耗盡時，輸入交易和遞延交易之間的比率。
snapshots-dir	快照目錄的位置(絕對路徑或data目錄相對路徑)

②initialize

插件初始化，第一個階段是通過現(xiàn)有配置項初始化設(shè)置插件。現(xiàn)有配置項來自于配置文件config.ini中producer_plugin相關(guān)配置項與命令行參數(shù)中producer_plugin相關(guān)配置項的交集，同樣的配置項以命令行為準(zhǔn)。現(xiàn)有配置以boost::program_options::variables_map&類型對象options為參數(shù)傳入初始化函數(shù)。配置過程操作的是producer_plugin的私有成員std::shared_ptr<class producer_plugin_impl> my。my指針擁有producer_plugin_impl對象的成員，這些成員都被設(shè)計為與傳入配置項對應(yīng)，逐一設(shè)置即可。
第二個階段是4個遠(yuǎn)程異步調(diào)用的聲明：

• 前兩個通訊模式是訂閱一個channel綁定一個執(zhí)行函數(shù)，一旦嗅到該頻道被發(fā)布則執(zhí)行綁定的函數(shù)。
  • incoming::channels::block，接收區(qū)塊的頻道，該頻道將在bnet_plugin的on_message的on函數(shù)中被發(fā)布，觸發(fā)producer_plugin當(dāng)前的訂閱函數(shù)on_incoming_block，下面詳述。
  • incoming::channels::transaction，接收事務(wù)的頻道，該頻道與上面相同，也將在bnet_plugin的on_message的on函數(shù)中被發(fā)布，觸發(fā)producer_plugin當(dāng)前的訂閱函數(shù)on_incoming_transaction_async，下面詳述。
• 后兩個通訊模式是注冊一個method，供外部程序調(diào)用。
  • incoming::methods::block_sync，接收區(qū)塊的同步方法。該method將在chain_plugin的read_write::push_block函數(shù)中被調(diào)用，這部分內(nèi)容在chain_plugin的文章中有專門的分析。實(shí)際上執(zhí)行的是producer_plugin當(dāng)下注冊的方法on_incoming_block，同上。
  • incoming::methods::transaction_async，接收事務(wù)的同步方法。該method將在chain_plugin的read_write::push_transaction函數(shù)中被調(diào)用，實(shí)際上執(zhí)行的是on_incoming_transaction_async，亦同上。

總結(jié)一下會發(fā)現(xiàn)，在producer_plugin的初始化階段：

• 有兩個處理對象，
  • 接收的區(qū)塊，針對該處理對象，均執(zhí)行函數(shù)on_incoming_block
  • 接收的事務(wù)，針對該處理對象，均執(zhí)行函數(shù)on_incoming_transaction_async
• 有兩個通訊模式，
  • channel的方式，對接的是bnet_plugin
  • method的方式，對接的是chain_plugin

③startup

進(jìn)入插件的啟動階段，首先設(shè)置日志，

const fc::string logger_name("producer_plugin"); fc::logger _log;const fc::string trx_trace_logger_name("transaction_tracing"); fc::logger _trx_trace_log;

分別創(chuàng)建以producer_plugin插件為主的日志對象，以及事務(wù)追蹤"transaction_tracing"為主的日志對象。除了這兩個在插件內(nèi)部新建的日志，還有程序自身日志，例如nodeos，日志信息將打印在nodeos的輸出位置，輸出插件啟動日志。接下來的工作列舉如下：

• 校驗chain的db讀取模式以及本地生產(chǎn)者集合是否為空，根據(jù)不同情況輸出對應(yīng)日志用于提示用戶。
  
• 使用【信號槽技術(shù)】分別連接信號accepted_block(綁定本地處理函數(shù)on_block和信號irreversible_block(綁定本地處理函數(shù)on_irreversible_block，這兩個信號將在controller中被發(fā)射，從而觸發(fā)當(dāng)前信號槽，這兩個處理函數(shù)將在下面詳述。

信號槽的方式，對接的都是controller。

之前討論過多次，由于解耦的模式，信號發(fā)射方和信號槽處理方互不認(rèn)識，因此一個信號被發(fā)射，可以擁有多個信號槽處理方。

• 是針對最后不可逆區(qū)塊的討論，下面詳述。
  
• 如果本地生產(chǎn)者集合不為空時，輸出日志在當(dāng)前為這些生產(chǎn)者啟動區(qū)塊生產(chǎn)工作。如果本地具備生產(chǎn)能力_production_enabled，如果當(dāng)前鏈的頭區(qū)塊號為0，則調(diào)用new_chain_banner(chain)，該函數(shù)下面詳述。
  
• 執(zhí)行定時生產(chǎn)循環(huán)函數(shù)schedule_production_loop，下面詳述。

④shutdown

釋放資源，代碼不多如下：

void producer_plugin::plugin_shutdown() {try {my->_timer.cancel(); // 停止倒計時器} catch(fc::exception& e) {edump((e.to_detail_string())); // 輸出錯誤日志}// 重置釋放連接槽my->_accepted_block_connection.reset();my->_irreversible_block_connection.reset(); }

插件關(guān)閉階段，取消計時器，后面會展開對計時器basic_deadline_timer的研究，重置(調(diào)用析構(gòu)函數(shù))清除上面startup階段啟動的兩個信號槽。

on_incoming_block 函數(shù)

/*** 處理incoming接收到的區(qū)塊。* @param block 已簽名區(qū)塊*/ void on_incoming_block(const signed_block_ptr& block) {fc_dlog(_log, "received incoming block ${id}", ("id", block->id()));// 判斷區(qū)塊時間是否在當(dāng)前節(jié)點(diǎn)的未來7秒之內(nèi)，如果不是，則證明這個區(qū)塊還沒到處理的時間。EOS_ASSERT( block->timestamp < (fc::time_point::now() + fc::seconds(7)), block_from_the_future, "received a block from the future, ignoring it" );// 獲取鏈對象。chain::controller& chain = app().get_plugin<chain_plugin>().chain();/* 如果本地已經(jīng)存在接收的區(qū)塊了，則不必處理，直接返回。*/auto id = block->id();auto existing = chain.fetch_block_by_id( id );if( existing ) { return; }// 啟動多線程驗證區(qū)塊。這個函數(shù)在下面有解釋auto bsf = chain.create_block_state_future( block );// 丟棄pending區(qū)塊chain.abort_block();// 拋出異常，保證重啟定時生產(chǎn)循環(huán)auto ensure = fc::make_scoped_exit([this](){schedule_production_loop();});// 向本地鏈推送新區(qū)塊bool except = false;try {chain.push_block(block);//推送區(qū)塊} catch ( const guard_exception& e ) {// 打印詳細(xì)錯誤日志，并跳出循環(huán)。app().get_plugin<chain_plugin>().handle_guard_exception(e);return;} catch( const fc::exception& e ) {elog((e.to_detail_string()));except = true;} catch ( boost::interprocess::bad_alloc& ) {chain_plugin::handle_db_exhaustion();return;}if( except ) {// rejected_block頻道發(fā)布某區(qū)塊已被拒絕的消息，該頻道已在bnet插件被訂閱，當(dāng)消息發(fā)布，bnet插件會調(diào)用函數(shù)on_bad_block處理被拒區(qū)塊。app().get_channel<channels::rejected_block>().publish( block );return;}// 當(dāng)鏈的頭塊狀態(tài)中時間戳的下一個點(diǎn)大于等于當(dāng)前時間時，本地則具備生產(chǎn)能力。if( chain.head_block_state()->header.timestamp.next().to_time_point() >= fc::time_point::now() ) {_production_enabled = true;}if( fc::time_point::now() - block->timestamp < fc::minutes(5) || (block->block_num() % 1000 == 0) ) {//區(qū)塊時間點(diǎn)已流逝的時間在5分鐘之內(nèi)的情況，或者區(qū)塊號是整千時。輸出日志模板并替換變量的值。ilog("Received block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, conf: ${confs}, latency: ${latency} ms]",// p是生產(chǎn)者，// id是區(qū)塊id截取中間的8到16位輸出，// n是區(qū)塊號，t是區(qū)塊時間，// count是區(qū)塊中事務(wù)的數(shù)量，// lib是鏈最后一個不可逆區(qū)塊號，// confs是區(qū)塊的確認(rèn)數(shù)("p",block->producer)("id",fc::variant(block->id()).as_string().substr(8,16))("n",block_header::num_from_id(block->id()))("t",block->timestamp)// confirmed，是生產(chǎn)者在簽名一個區(qū)塊時向前確認(rèn)的區(qū)塊數(shù)量，默認(rèn)是1,則只確認(rèn)前一個區(qū)塊。// latency，潛伏因素的字面含義。值為當(dāng)前區(qū)塊時間點(diǎn)已流逝的時間。// count是時間庫中的一個特殊函數(shù)，返回某個時間按照某個單位來計數(shù)時的字面值，可以用做跨單位的運(yùn)算。// block_timestamp_type類型定義了區(qū)塊鏈的時間戳的默認(rèn)間隔是500ms，一個周期是2000年。("count",block->transactions.size())("lib",chain.last_irreversible_block_num())("confs", block->confirmed)("latency", (fc::time_point::now() - block->timestamp).count()/1000 ) );} }

關(guān)于block_timestamp_type類型的定義，源碼如下：

typedef block_timestamp<config::block_interval_ms,config::block_timestamp_epoch> block_timestamp_type; ... const static int block_interval_ms = 500; const static uint64_t block_timestamp_epoch = 946684800000ll; // epoch is year 2000.

接著進(jìn)入函數(shù)create_block_state_future，

std::future<block_state_ptr> create_block_state_future( const signed_block_ptr& b ) {EOS_ASSERT( b, block_validate_exception, "null block" );//不能為空塊auto id = b->id();// 已存在區(qū)塊，終止并提示auto existing = fork_db.get_block( id );EOS_ASSERT( !existing, fork_database_exception, "we already know about this block: ${id}", ("id", id) );auto prev = fork_db.get_block( b->previous );// 獲得前一個區(qū)塊，不存在則報錯。EOS_ASSERT( prev, unlinkable_block_exception, "unlinkable block ${id}", ("id", id)("previous", b->previous) );return async_thread_pool( [b, prev]() {// 傳入具體task到異步線程池。const bool skip_validate_signee = false;return std::make_shared<block_state>( *prev, move( b ), skip_validate_signee );} ); }

異步線程池async_thread_pool。傳入task，由當(dāng)前同步的待驗證區(qū)塊以及前一個區(qū)塊組成，返回的是block_state對象。

template<typename F> auto async_thread_pool( F&& f ) {auto task = std::make_shared<std::packaged_task<decltype( f() )()>>( std::forward<F>( f ) );boost::asio::post( *thread_pool, [task]() { (*task)(); } );// 將任務(wù)上傳到線程池，通過boost::asio庫異步分配線程并行處理。return task->get_future(); }

on_incoming_transaction_async 函數(shù)

該函數(shù)的工作是處理接收到的事務(wù)的本地同步，聲明如下：

/*** 處理接收到的事務(wù)的本地同步工作* @param trx 接收的事務(wù)，是打包狀態(tài)的* @param persist_until_expired 標(biāo)志位：事務(wù)是否在過期前被持久化了，bool類型* @param next 回調(diào)函數(shù)next方法。*/ void on_incoming_transaction_async(const packed_transaction_ptr& trx, bool persist_until_expired, next_function<transaction_trace_ptr> next) {}

可以分為三個部分，第一部分是校驗工作。

如果鏈不存在pending區(qū)塊狀態(tài)，則在pending接收事務(wù)結(jié)合中增加接收的事務(wù)待start_block中處理，并中止函數(shù)返回。

接收到的事務(wù)要打包在本地的pending區(qū)塊中，如果不存在pending區(qū)塊，說明本地節(jié)點(diǎn)未開始生產(chǎn)區(qū)塊，所以要插入到pending事務(wù)集合_pending_incoming_transactions中等待start_block來處理。這部分的校驗代碼如下：

chain::controller& chain = app().get_plugin<chain_plugin>().chain();if (!chain.pending_block_state()) {_pending_incoming_transactions.emplace_back(trx, persist_until_expired, next);return; }

第二部分是該函數(shù)定義了一個lambda的內(nèi)部函數(shù)send_response，用于異步發(fā)送響應(yīng)，該內(nèi)部函數(shù)源碼如下：

auto send_response = [this, &trx, &chain, &next](const fc::static_variant<fc::exception_ptr, transaction_trace_ptr>& response) {next(response);if (response.contains<fc::exception_ptr>()) {// 如果響應(yīng)中包含異常指針，則發(fā)布異常信息以及事務(wù)對象到channels::transaction_ack_transaction_ack_channel.publish(std::pair<fc::exception_ptr, packed_transaction_ptr>(response.get<fc::exception_ptr>(), trx));if (_pending_block_mode == pending_block_mode::producing) {// 如果pending區(qū)塊的模式為生產(chǎn)中，則打印出對應(yīng)的debug日志：區(qū)塊被拒絕。fc_dlog(_trx_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is REJECTING tx: ${txid} : ${why} ",("block_num", chain.head_block_num() + 1)("prod", chain.pending_block_state()->header.producer)("txid", trx->id())("why",response.get<fc::exception_ptr>()->what()));} else {// 如果pending區(qū)塊的模式為投機(jī)中，則打印出對應(yīng)的debug日志：投機(jī)行為被拒絕。fc_dlog(_trx_trace_log, "[TRX_TRACE] Speculative execution is REJECTING tx: ${txid} : ${why} ",("txid", trx->id())("why",response.get<fc::exception_ptr>()->what()));}} else {// 響應(yīng)中無異常。發(fā)布空異常信息以及事務(wù)對象到channels::transaction_ack_transaction_ack_channel.publish(std::pair<fc::exception_ptr, packed_transaction_ptr>(nullptr, trx));if (_pending_block_mode == pending_block_mode::producing) {// 仍舊區(qū)分pending區(qū)塊狀態(tài)生產(chǎn)中與投機(jī)行為的不同日志輸出。fc_dlog(_trx_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} is ACCEPTING tx: ${txid}",("block_num", chain.head_block_num() + 1)("prod", chain.pending_block_state()->header.producer)("txid", trx->id()));} else {fc_dlog(_trx_trace_log, "[TRX_TRACE] Speculative execution is ACCEPTING tx: ${txid}",("txid", trx->id()));}}};

這部分代碼很容易拆解，通過publish/subscribe通訊模式，本地發(fā)布頻道信息，交由頻道訂閱者異步處理。
頻道：channels::transaction_ack
publisher：on_incoming_transaction_async ->send_response
subscriber：net_plugin::plugin_startup
binding function：net_plugin_impl::transaction_ack
dispatcher：rejected_transaction/bcast_transaction

在這個異步通訊過程中，要加入校驗代碼。函數(shù)體被調(diào)用時，send_response已經(jīng)收到了處理后的事務(wù)響應(yīng)，同時捕獲了事務(wù)源對象，鏈對象。鏈對象在當(dāng)前程序中應(yīng)該是單例的，不必在此校驗。校驗響應(yīng)事務(wù)是否存在異常信息，如果存在則將異常信息附屬發(fā)布到頻道消息，如果不存在則附屬空異常。

if (response.contains<fc::exception_ptr>()) {_transaction_ack_channel.publish(std::pair<fc::exception_ptr, packed_transaction_ptr>(response.get<fc::exception_ptr>(), trx)); } else {_transaction_ack_channel.publish(std::pair<fc::exception_ptr, packed_transaction_ptr>(nullptr, trx)); }

注意，在發(fā)布完頻道消息以后，要給前臺輸出事務(wù)跟蹤日志。

producer_plugin的startup啟動階段分析過，該插件包含三種日志，事務(wù)跟蹤日志就是其中之一。輸出日志要判斷pending區(qū)塊性質(zhì)是否是正在生產(chǎn)，如果是生產(chǎn)中的區(qū)塊，則打印區(qū)塊號，生產(chǎn)者以及事務(wù)id，如果不是生產(chǎn)中的區(qū)塊而是投機(jī)區(qū)塊(可能被生產(chǎn)也可能被丟棄)，則只打印事務(wù)id。

publish的消息是trx源事務(wù)對象，而不是響應(yīng)對象response。

前兩部分完成以后，本地存在pending區(qū)塊有打包事務(wù)的條件，且發(fā)送響應(yīng)的函數(shù)也有了，準(zhǔn)備工作已經(jīng)做好了。接下來進(jìn)入第三部分，正式開始本地打包接收事務(wù)的工作。工作開始之前，仍舊要先校驗：

• 接收的事務(wù)是否過期，通過比較待打包區(qū)塊時間和接收事務(wù)時間確定事務(wù)是否過期，如果過期則發(fā)送事務(wù)已過期的響應(yīng)信息并終止程序。
• 接收事的務(wù)是否已存在，在本地查找該事務(wù)如果查到則發(fā)送事務(wù)已存在的響應(yīng)信息并終止程序。

這兩個校驗的源碼如下：

auto block_time = chain.pending_block_state()->header.timestamp.to_time_point();//獲得待打包區(qū)塊時間，即鏈pending區(qū)塊頭的時間戳轉(zhuǎn)換而來。 auto id = trx->id(); if( fc::time_point(trx->expiration()) < block_time ) {//如果事務(wù)的過期時間小于區(qū)塊時間，說明區(qū)塊開始打包時事務(wù)已過期。報錯并中止。send_response(std::static_pointer_cast<fc::exception>(std::make_shared<expired_tx_exception>(FC_LOG_MESSAGE(error, "expired transaction ${id}", ("id", id)) )));return; }if( chain.is_known_unexpired_transaction(id) ) {// 如果在鏈db中找到了該事務(wù)，說明已存在，報錯并中止。send_response(std::static_pointer_cast<fc::exception>(std::make_shared<tx_duplicate>(FC_LOG_MESSAGE(error, "duplicate transaction ${id}", ("id", id)) )));return; }

兩個校驗工作結(jié)束以后，要確定接收事務(wù)的code執(zhí)行截止時間。初始化的值是當(dāng)前時間加上本地設(shè)置的最大事務(wù)執(zhí)行時間。但如果本地設(shè)置未限制最大事務(wù)執(zhí)行時間或者pending區(qū)塊是本地正在生產(chǎn)且區(qū)塊時間小于截止時間的，事務(wù)截止時間改為區(qū)塊時間。這段代碼如下：

auto block_time = chain.pending_block_state()->header.timestamp.to_time_point();//獲得待打包區(qū)塊時間，即鏈pending區(qū)塊頭的時間戳轉(zhuǎn)換而來。 auto deadline = fc::time_point::now() + fc::milliseconds(_max_transaction_time_ms);// 算出事務(wù)的code執(zhí)行的截止時間。 bool deadline_is_subjective = false; // 主觀截止日期標(biāo)志位，事務(wù)截止時間為區(qū)塊時間 if (_max_transaction_time_ms < 0 || (_pending_block_mode == pending_block_mode::producing && block_time < deadline) ) {deadline_is_subjective = true; // 主觀截止日期標(biāo)志位設(shè)置為true。deadline = block_time;// 截止時間改為區(qū)塊時間 }

接下來，確認(rèn)了事務(wù)截止時間以后，執(zhí)行推送接收的事務(wù)到區(qū)塊鏈。

// 調(diào)用chain推送事務(wù)，接收結(jié)果儲存在trace對象 auto trace = chain.push_transaction(std::make_shared<transaction_metadata>(*trx), deadline);

trace對象接收了chain的推送事務(wù)的處理結(jié)果。如果判斷該結(jié)果沒有異常則證明處理成功，則要先判斷標(biāo)志位persist_until_expired是否為true，如果為true說明該事務(wù)在過期前已被成功持久化，需要在本地持久化事務(wù)集合對象中插入事務(wù)id，用來保證也能應(yīng)用在未來的投機(jī)區(qū)塊。最后，將trace對象作為響應(yīng)信息發(fā)送出去。源碼如下：

if (persist_until_expired) {// 標(biāo)志位：事務(wù)過期前被持久化// 存儲事務(wù)ID，從而保證它也能應(yīng)用在未來的投機(jī)區(qū)塊(可逆區(qū)塊)。_persistent_transactions.insert(transaction_id_with_expiry{trx->id(), trx->expiration()}); } send_response(trace);// 將事務(wù)推送結(jié)果發(fā)送響應(yīng)。

如果trace結(jié)果包含異常，則要判斷該異常是否是主觀異常。如果是的話，采用上面不存在pending區(qū)塊的處理方式，將事務(wù)插入到pending接收事務(wù)集合中，等待start_block處理，同時按照pending區(qū)塊性質(zhì)輸出日志。如果不是主觀失敗，則直接丟棄事務(wù)，發(fā)送異常信息作為響應(yīng)內(nèi)容。源碼如下：

if (trace->except) {// 異常處理if (failure_is_subjective(*trace->except, deadline_is_subjective)) {// 主觀失敗，在pending接收事務(wù)結(jié)合中增加接收的事務(wù)待start_block中處理，并中止函數(shù)返回。_pending_incoming_transactions.emplace_back(trx, persist_until_expired, next);// 仍舊區(qū)分pending區(qū)塊狀態(tài)生產(chǎn)中與投機(jī)行為的不同日志輸出。if (_pending_block_mode == pending_block_mode::producing) {fc_dlog(_trx_trace_log, "[TRX_TRACE] Block ${block_num} for producer ${prod} COULD NOT FIT, tx: ${txid} RETRYING ",("block_num", chain.head_block_num() + 1)("prod", chain.pending_block_state()->header.producer)("txid", trx->id()));} else {fc_dlog(_trx_trace_log, "[TRX_TRACE] Speculative execution COULD NOT FIT tx: ${txid} RETRYING",("txid", trx->id()));}} else {// 增加異常信息，發(fā)送響應(yīng)。auto e_ptr = trace->except->dynamic_copy_exception();send_response(e_ptr);} }

on_block 函數(shù)

該函數(shù)在controller accepted_block信號處理時有過介紹。下面進(jìn)行詳細(xì)分析，首先是三個校驗：

if( bsp->header.timestamp <= _last_signed_block_time ) return; if( bsp->header.timestamp <= _start_time ) return; if( bsp->block_num <= _last_signed_block_num ) return;

• 如果區(qū)塊時間小于等于最后簽名區(qū)塊時間，則終止退出當(dāng)前函數(shù)。
• 如果區(qū)塊時間小于等于開始時間(初始化為當(dāng)前時間)，則終止退出當(dāng)前函數(shù)。
• 如果區(qū)塊號小于等于最后簽名區(qū)塊號，則退出當(dāng)前函數(shù)。

通過以上三個校驗，可以得知新區(qū)塊要在最后簽名區(qū)塊之后(生產(chǎn)時間要在它之后，區(qū)塊號也要在它之后)，另外新區(qū)塊的生產(chǎn)時間不能是比現(xiàn)在早的時間，必須是之后的時間才可能被當(dāng)下所處理。校驗通過以后，新建活躍生產(chǎn)者賬戶集合active_producers，插入計劃出塊的生產(chǎn)者。

const auto& active_producer_to_signing_key = bsp->active_schedule.producers;flat_set<account_name> active_producers; active_producers.reserve(bsp->active_schedule.producers.size()); for (const auto& p: bsp->active_schedule.producers) {active_producers.insert(p.producer_name); }

接下來處理接收到的由它節(jié)點(diǎn)生產(chǎn)的區(qū)塊。

// 利用set\_intersection取本地生產(chǎn)者與集合active\_producers的交集 std::set_intersection( _producers.begin(), _producers.end(),active_producers.begin(), active_producers.end(),// 將結(jié)果存入一個迭代器make_function_output_iterator，迭代執(zhí)行內(nèi)部函數(shù)boost::make_function_output_iterator( [&]( const chain::account_name& producer )// 如果結(jié)果為空，說明本地生產(chǎn)者沒有出塊權(quán)利不屬于活躍生產(chǎn)者的一份子 {if( producer != bsp->header.producer ) { // 如果交集生產(chǎn)者不等于接收區(qū)塊的生產(chǎn)者，說明是校驗別人生產(chǎn)的區(qū)塊，如果是相等的不必做特殊處理。// 在活躍生產(chǎn)者的key中找到匹配的key(本地生產(chǎn)者賬戶公鑰)auto itr = std::find_if( active_producer_to_signing_key.begin(), active_producer_to_signing_key.end(),[&](const producer_key& k){ return k.producer_name == producer; } );if( itr != active_producer_to_signing_key.end() ) {// 成功找到，否則說明該區(qū)塊不是合法生產(chǎn)者簽名拋棄不處理。auto private_key_itr = _signature_providers.find( itr->block_signing_key );// 獲取本地生產(chǎn)者私鑰if( private_key_itr != _signature_providers.end() ) {auto d = bsp->sig_digest();auto sig = private_key_itr->second( d );// 更新producer插件本地標(biāo)志位_last_signed_block_time = bsp->header.timestamp;_last_signed_block_num = bsp->block_num;// 組裝生產(chǎn)確認(rèn)數(shù)據(jù)字段，包括區(qū)塊id，區(qū)塊摘要，生產(chǎn)者，簽名。發(fā)射信號confirmed\_block。但經(jīng)過搜索，項目中目前沒有對該信號設(shè)置槽connection_self->confirmed_block( { bsp->id, d, producer, sig } );}}} } ) );

在區(qū)塊創(chuàng)建之前要為該區(qū)塊的生產(chǎn)者設(shè)置水印用來標(biāo)示該區(qū)塊的生產(chǎn)者是誰。水印就是一個kv結(jié)構(gòu)對象，例如 _producer_watermarks[new_producer] = new_block_num;

chain::controller& chain = app().get_plugin<chain_plugin>().chain(); const auto hbn = bsp->block_num; // 設(shè)置新區(qū)塊頭信息，水印信息，包括時間戳 auto new_block_header = bsp->header; new_block_header.timestamp = new_block_header.timestamp.next(); new_block_header.previous = bsp->id; auto new_bs = bsp->generate_next(new_block_header.timestamp);

接下來，對于新安裝的生產(chǎn)者，可以設(shè)置他們的水印使他們變?yōu)榛钴S生產(chǎn)者。

if (new_bs.maybe_promote_pending() && bsp->active_schedule.version != new_bs.active_schedule.version) {flat_set<account_name> new_producers;new_producers.reserve(new_bs.active_schedule.producers.size());for( const auto& p: new_bs.active_schedule.producers) {if (_producers.count(p.producer_name) > 0)new_producers.insert(p.producer_name);}for( const auto& p: bsp->active_schedule.producers) {new_producers.erase(p.producer_name);}for (const auto& new_producer: new_producers) {_producer_watermarks[new_producer] = hbn;// 水印map，本地變量，用于指揮計劃出塊的生產(chǎn)者。} }

on_irreversible_block 函數(shù)

在producer_plugin中，該函數(shù)是用來更新不可逆區(qū)塊時間的，這個時間在系統(tǒng)中由一個時間變量_irreversible_block_time控制。

void on_irreversible_block( const signed_block_ptr& lib ) {_irreversible_block_time = lib->timestamp.to_time_point(); }

這個時間變量將用來計算不可逆區(qū)塊時間的流逝時間，即當(dāng)前時間減去該時間變量的結(jié)果，如果結(jié)果為正數(shù)且不小說明很久沒有出現(xiàn)不可逆區(qū)塊了，反之則是剛剛出現(xiàn)不可逆區(qū)塊。

fc::microseconds get_irreversible_block_age() {auto now = fc::time_point::now();if (now < _irreversible_block_time) {return fc::microseconds(0);} else {return now - _irreversible_block_time;} }

last_irreversible 的討論

在producer_plugin的啟動階段，包含一段關(guān)于最后不可逆區(qū)塊的代碼：

const auto lib_num = chain.last_irreversible_block_num();// 獲取當(dāng)前最后不可逆區(qū)塊號 const auto lib = chain.fetch_block_by_number(lib_num); // 獲取最后不可逆區(qū)塊 if (lib) { // 如果最后不可逆區(qū)塊存在my->on_irreversible_block(lib); // 執(zhí)行函數(shù)同步更新本地區(qū)塊的不可逆時間 } else { // 如果最后不可逆區(qū)塊不存在my->_irreversible_block_time = fc::time_point::maximum();// 區(qū)塊不可逆時間設(shè)置為最大值。 }

通常來講，最后不可逆區(qū)塊的存在是被用來定位本地事務(wù)被打包至某個區(qū)塊后是否成功上鏈變?yōu)椴豢赡鏍顟B(tài)，只需要這個區(qū)塊號小于最后不可逆區(qū)塊即可確定。

以上代碼段中if-else語句比較容易理解，是根據(jù)最后不可逆區(qū)塊是否存在對本地區(qū)塊不可逆時間變量_irreversible_block_time的設(shè)置，存在則更新為最后不可逆區(qū)塊的時間，不存在則將其設(shè)置為時間最大值。不存在最后不可逆區(qū)塊意味著鏈數(shù)據(jù)完全是孤立的未經(jīng)任何確認(rèn)的，區(qū)塊鏈的特性也不再存在，因此本地時間變量設(shè)置為了時間的最大值。那么令人費(fèi)解的是上面兩行代碼，首先獲取最后不可逆區(qū)塊號，接著通過該區(qū)塊號獲得區(qū)塊。

controller::last_irreversible_block_num

uint32_t controller::last_irreversible_block_num() const {return std::max(std::max(my->head->bft_irreversible_blocknum, my->head->dpos_irreversible_blocknum), my->snapshot_head_block); }

以上獲取最后不可逆區(qū)塊號函數(shù)的源碼，可以看出是從當(dāng)前區(qū)塊頭的bft不可逆區(qū)塊號、dpos不可逆區(qū)塊號以及快照頭塊的區(qū)塊號三者中選擇最大的一個作為結(jié)果返回。分別來看這三個區(qū)塊號的含義：

• bft不可逆區(qū)塊號，在區(qū)塊頭狀態(tài)結(jié)構(gòu)中的generate_next函數(shù)中有初始化的操作，這個函數(shù)主要是用來通過一個給定的時間生成一個模板的區(qū)塊頭狀態(tài)對象，不包含事務(wù)Merkle根、action Merkle根以及新生產(chǎn)者字段數(shù)據(jù)，因為這些組件是派生自鏈狀態(tài)的。總之，在代碼中查找，發(fā)現(xiàn)bft不可逆區(qū)塊號只有一個初始化為0的賦值動作，原因可能與EOS計劃引入bft而目前還沒有bft有關(guān)系。因此該值為0。
• dpos不可逆區(qū)塊號，controller初始化為0。仍舊在generate_next函數(shù)中找到該字段的初始化值為calc_dpos_last_irreversible()函數(shù)的結(jié)果。
• 快照的頭塊號，初始化是0，如果有快照讀入的話，就是快照的頭區(qū)塊號。

calc_dpos_last_irreversible函數(shù)

該函數(shù)用來計算dpos最后不可逆區(qū)塊。

uint32_t block_header_state::calc_dpos_last_irreversible()const {vector<uint32_t> blocknums; blocknums.reserve( producer_to_last_implied_irb.size() );for( auto& i : producer_to_last_implied_irb ) {blocknums.push_back(i.second);}if( blocknums.size() == 0 ) return 0;std::sort( blocknums.begin(), blocknums.end() );//默認(rèn)從小到大排序。less<int>()return blocknums[ (blocknums.size()-1) / 3 ];// dpos最后不可逆區(qū)塊的判斷條件是必須在池子里面保持有2/3個區(qū)塊號是大于自己的。 }

fetch_block_by_number

signed_block_ptr controller::fetch_block_by_number( uint32_t block_num )const { try {auto blk_state = my->fork_db.get_block_in_current_chain_by_num( block_num );// 從分叉庫中根據(jù)塊號獲取狀態(tài)區(qū)塊。if( blk_state && blk_state->block ) {//狀態(tài)區(qū)塊存在且其block成員也存在return blk_state->block; // 返回其block成員對象。}return my->blog.read_block_by_num(block_num);// 否則的話從block.log日志中獲取區(qū)塊返回。 } FC_CAPTURE_AND_RETHROW( (block_num) ) }

---

重新回到producer_plugin的啟動階段的last_irreversible 的討論。首先通過函數(shù)last_irreversible_block_num從bft和dpos以及快照三個區(qū)塊號中獲取最大的一個，由于目前未引進(jìn)bft且有快照進(jìn)入的概率不高，所以暫定該最后不可逆區(qū)塊號為dpos的那個號。接著用這個區(qū)塊號通過fetch_block_by_number中查找，先在fork_db中查找，如果沒有則在block.log中查找獲得區(qū)塊對象。不過一般fork_db中不應(yīng)該存在不可逆區(qū)塊，如果區(qū)塊變?yōu)椴豢赡鏍顟B(tài)應(yīng)該被立即持久化到block.log，并從fork_db中刪除。

new_chain_banner(chain)

該函數(shù)翻譯過來就是新鏈的條幅，條幅是顯示在日志中的，源碼如下：

void new_chain_banner(const eosio::chain::controller& db) {std::cerr << "\n""*******************************\n""* *\n""* ------ NEW CHAIN ------ *\n""* - Welcome to EOSIO! - *\n""* ----------------------- *\n""* *\n""*******************************\n""\n";if( db.head_block_state()->header.timestamp.to_time_point() < (fc::time_point::now() - fc::milliseconds(200 * config::block_interval_ms))){std::cerr << "Your genesis seems to have an old timestamp\n""Please consider using the --genesis-timestamp option to give your genesis a recent timestamp\n""\n";}return; }

傳入一個鏈對象(controller實(shí)例)，輸出一個字符圖案在日志中，接著校驗genesis的時間戳，如果小于當(dāng)前時間200個間隔周期，則報錯重新設(shè)置genesis的時間戳配置為一個就近的時間。

schedule_production_loop

這是一個對于producer_plugin非常重要的函數(shù)，是出塊節(jié)點(diǎn)按計劃出塊的循環(huán)函數(shù)。在系統(tǒng)多個功能函數(shù)中涉及處理恢復(fù)繼續(xù)按計劃出塊時，多次被調(diào)用到。該函數(shù)中大量使用到了_timer對象，下面先研究_timer。

basic_deadline_timer 的研究

對producer_plugin_impl類的共有成員_timer的追蹤，可以發(fā)現(xiàn)它是basic_deadline_timer類的對象。

該函數(shù)提供了可等待的計時器功能。basic_deadline_timer類模板提供了執(zhí)行阻塞(blocking)或異步等待(asynchronous wait)定時器期滿的能力。截止日期計時器總是處于兩種狀態(tài)之一:“過期”或“未過期”。如果在過期計時器上調(diào)用wait()或async_wait()函數(shù)，則等待操作將立即完成。

使用實(shí)例：

①阻塞等待(blocking wait)

為計時器設(shè)置一個相對時間。

timer.expires_from_now(boost::posix_time::seconds(5));// 從現(xiàn)在開始計時5秒鐘。

等待計時器過期。

timer.wait();

②異步等待(asynchronous wait)

首先要創(chuàng)建一個處理器handler。

void handler(const boost::system::error_code& error) {if (!error){// Timer expired.} }

構(gòu)建一個絕對過期時間的計時器。

boost::asio::deadline_timer timer(io_context, boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));

啟動一個異步等待。

timer.async_wait(handler);

③改變過期時間

當(dāng)存在掛起的異步等待時，更改計時器的過期時間會導(dǎo)致這些等待操作被取消。要確保與計時器關(guān)聯(lián)的操作只執(zhí)行一次，請使用類似的方法：

// boost::asio::basic\_deadline\_timer::expires\_from\_now() 函數(shù)取消任何掛起的異步等待，并返回已取消的異步等待的數(shù)量。如果返回0，則太遲了，且等待處理器已經(jīng)被執(zhí)行，或者即將被執(zhí)行。如果它返回1，那么等待程序會被成功取消。 void on_some_event() // 模擬某事件處理函數(shù) {if (my_timer.expires_from_now(seconds(5)) > 0) {// 取消計時器，啟動一個新的異步等待my_timer.async_wait(on_timeout);} else {// 計時器已過期。} } // 如果一個等待處理程序被取消，傳遞給它的boost::system::error\_code包含值boost::asio::error::operation\_aborted。 void on_timeout(const boost::system::error_code& e) // 超時事件處理函數(shù) {if (e != boost::asio::error::operation_aborted) {計時器未取消，繼續(xù)執(zhí)行操作。} }

回到producer_plugin的shutdown階段中_timer的使用。

my->_timer.cancel();

進(jìn)入basic_deadline_timer::cancel()函數(shù)：

std::size_t cancel() {boost::system::error_code ec;std::size_t s = this->get_service().cancel(this->get_implementation(), ec);boost::asio::detail::throw_error(ec, "cancel");return s; }

該函數(shù)將取消所有正在等待計時器的異步操作。

回到schedule_production_loop函數(shù)。

這一部分是對計時器的設(shè)置。首先重置計時器，獲得鏈對象chain以及弱指針producer_plugin_impl實(shí)例。執(zhí)行start_block，并接收結(jié)果，根據(jù)結(jié)果的不同做不同的處理，該結(jié)果為一個枚舉類型：

enum class start_block_result {succeeded, // 成功failed, // 失敗waiting, // 等待exhausted // 耗盡，該狀態(tài)在producer插件中并沒有顯式使用，而是其他狀態(tài)處理完畢剩余的情況。 };

• 如果是failed，啟動區(qū)塊的返回值是失敗的，那么要輸出提醒日志，同時計時器啟動50毫秒倒計時，異步等待到期以后再次嘗試重新調(diào)用自己schedule_production_loop函數(shù)。
• 如果是waiting，等待中。判斷生產(chǎn)者如果不是空且啟用了生產(chǎn)能力，則調(diào)用延時計劃生產(chǎn)循環(huán)schedule_delayed_production_loop函數(shù)。

bool production_disabled_by_policy() { // 確定生產(chǎn)能力是否被禁用的方式。有以下三種判斷條件，滿足其一即可。return !_production_enabled || _pause_production || (_max_irreversible_block_age_us.count() >= 0 && get_irreversible_block_age() >= _max_irreversible_block_age_us); }

延時計劃生產(chǎn)循環(huán)schedule_delayed_production_loop函數(shù)，主要操作對象是wake_up_time，即該延時操作的喚醒時間。一些列校驗判斷探測出喚醒時間已到達(dá)時，就會調(diào)用回schedule_production_loop函數(shù)。

• 接下來，start_block結(jié)果其他的狀態(tài)情況，即succeeded或者exhausted。當(dāng)pending區(qū)塊模式為生產(chǎn)中時，pending區(qū)塊的模式分為：

enum class pending_block_mode {producing, // 本地生產(chǎn)speculating // 外部確認(rèn)有可能確認(rèn)失敗不一定能成為不可逆，因此是投機(jī)性的。 };

到目前這個分支下，換句話講就是啟動區(qū)塊start_block已經(jīng)成功succeeded了，但是也有可能耗盡exhausted，這兩種情況要通過另外一種判斷，即是否pending區(qū)塊處于生產(chǎn)中的狀態(tài)來做區(qū)分。

pending區(qū)塊模式為生產(chǎn)中producing

• start_block成功succeeded。這部分代碼的工作主要是用來保證區(qū)塊要在截止時間之前被裝運(yùn)上鏈。先校驗一下是否存在pending區(qū)塊。接著計算截止時間并按照該時間啟動計時器：

// 計算截止時間，epoch默認(rèn)是從1970/1/1，從epoch開始計算到pending區(qū)塊的時間加上預(yù)設(shè)的區(qū)塊生產(chǎn)時間偏移量。 auto deadline = chain.pending_block_time().time_since_epoch().count() + (last_block ? _last_block_time_offset_us : _produce_time_offset_us); _timer.expires_at( epoch + boost::posix_time::microseconds( deadline ));// 截止時間加上epoch的時間初始量，按此時間啟動計時器。

現(xiàn)行西歷即格里歷，又譯國瑞歷、額我略歷、格列高利歷、格里高利歷，稱西元。地球每天的自轉(zhuǎn)是有些不規(guī)則的，而且正在緩慢減速。所以，格林尼治時間已經(jīng)不再被作為標(biāo)準(zhǔn)時間使用。現(xiàn)在的標(biāo)準(zhǔn)時間──協(xié)調(diào)世界時（UTC）──由原子鐘提供。

• start_block成功exhausted。仍舊要先檢查是否存在pending區(qū)塊。接著計算預(yù)期時間expect_time，是penging區(qū)塊時間減去一個區(qū)塊間隔時間0.5秒(現(xiàn)在是設(shè)置的0.5秒出一個塊，在config.hpp中可以查到)

auto expect_time = chain.pending_block_time() - fc::microseconds(config::block_interval_us);... config.hpp const static int block_interval_ms = 500; const static int block_interval_us = block_interval_ms*1000;

下面是判斷預(yù)期時間和現(xiàn)在時間的對比，如果預(yù)期時間已過，則將計時器時間調(diào)節(jié)為0(立即執(zhí)行出塊)。如果預(yù)期時間未到，則設(shè)置計時器到預(yù)期時間，等待計時完成。

if (fc::time_point::now() >= expect_time) { // 預(yù)期時間已過_timer.expires_from_now( boost::posix_time::microseconds( 0 )); // 將計時器時間調(diào)節(jié)為0fc_dlog(_log, "Scheduling Block Production on Exhausted Block #${num} immediately", ("num", chain.pending_block_state()->block_num)); } else { // 預(yù)期時間未到_timer.expires_at(epoch + boost::posix_time::microseconds(expect_time.time_since_epoch().count()));fc_dlog(_log, "Scheduling Block Production on Exhausted Block #${num} at ${time}", ("num", chain.pending_block_state()->block_num)("time",expect_time)); // 設(shè)置計時器到預(yù)期時間 }

分別將succeeded以及exhausted狀態(tài)的_timer設(shè)置完畢以后，下面要處理當(dāng)計時器到時的事件處理，即_timer.async_wait函數(shù)。該函數(shù)的參數(shù)為匿名內(nèi)部類組成的異步回調(diào)函數(shù)。

_timer.async_wait([&chain,weak_this,cid=++_timer_corelation_id](const boost::system::error_code& ec) {auto self = weak_this.lock(); // 獲得鎖。if (self && ec != boost::asio::error::operation_aborted && cid == self->_timer_corelation_id) { // 滿足生產(chǎn)區(qū)塊的條件：有鎖且操作未被終止且計時器關(guān)聯(lián)id匹配。// 內(nèi)部要校驗一遍pending區(qū)塊是否存在。auto block_num = chain.pending_block_state() ? chain.pending_block_state()->block_num : 0; // 區(qū)塊號的設(shè)置，若pending區(qū)塊存在則設(shè)置為pending區(qū)塊號，若不存在，則設(shè)置為0。auto res = self->maybe_produce_block(); // 調(diào)用maybe_produce_block()函數(shù)(下面分析)執(zhí)行區(qū)塊的生產(chǎn)，返回生產(chǎn)結(jié)果。fc_dlog(_log, "Producing Block #${num} returned: ${res}", ("num", block_num)("res", res));} });

計時器關(guān)聯(lián)id匹配。_timer_corelation_id的存在源自一個攻擊警報：Boost計時器可能處于一個處理程序尚未執(zhí)行但不可中止的狀態(tài)，這個狀態(tài)給外部攻擊提供了可能。關(guān)聯(lián)id的設(shè)置可以有效防止，處理程序被改變。在處理程序捕獲相關(guān)性ID設(shè)置時，他們必須執(zhí)行檢查匹配全局變量_timer_corelation_id。如果不匹配，則意味著該方法已被調(diào)用，處理程序處于應(yīng)該取消但無法取消的狀態(tài)。

pending區(qū)塊模式為投機(jī)中speculating

這個狀態(tài)下，分兩種情況處理：

• 如果生產(chǎn)者存在且具備生產(chǎn)能力(有可能是備用節(jié)點(diǎn))時，校驗一番以后最終會調(diào)用延時計劃出塊循環(huán)schedule_delayed_production_loop。
• 其他情況則只打印日志，說明創(chuàng)建了投機(jī)區(qū)塊。

maybe_produce_block()函數(shù)

前面提到，schedule_production_loop函數(shù)是出塊者生產(chǎn)區(qū)塊時，調(diào)用start_block函數(shù)并根據(jù)返回結(jié)果設(shè)置計時器_timer，并處理計時完成的處理程序，而最終只有start_block結(jié)果為succeeded以及exhausted狀態(tài)，計時完成以后同時滿足有鎖且操作未被終止且計時器關(guān)聯(lián)id匹配。這全部條件的滿足，最后調(diào)用區(qū)塊生產(chǎn)執(zhí)行函數(shù)maybe_produce_block。

簡單來講，schedule_production_loop函數(shù)就是通過調(diào)用start_block設(shè)置timer，計時完成執(zhí)行maybe_produce_block。所以schedule_production_loop函數(shù)的核心是處理_timer。

下面分析函數(shù)maybe_produce_block：

bool producer_plugin_impl::maybe_produce_block() {// 當(dāng)前作用域退出時回調(diào)schedule_production_loop()繼續(xù)循環(huán)處理出塊工作。auto reschedule = fc::make_scoped_exit([this]{ schedule_production_loop();});try {try {produce_block(); // 實(shí)際調(diào)用函數(shù)produce_block生產(chǎn)區(qū)塊。return true; // 返回true，代表區(qū)塊生產(chǎn)成功，其他異常狀態(tài)均返回false，代表出塊失敗。} catch ( const guard_exception& e ) { // 處理守衛(wèi)異常app().get_plugin<chain_plugin>().handle_guard_exception(e);return false;} FC_LOG_AND_DROP();} catch ( boost::interprocess::bad_alloc&) { // 處理內(nèi)部線程內(nèi)存錯誤異常raise(SIGUSR1);return false;}// 區(qū)塊生產(chǎn)出錯，丟其區(qū)塊。fc_dlog(_log, "Aborting block due to produce_block error");chain::controller& chain = app().get_plugin<chain_plugin>().chain();chain.abort_block(); // 丟其區(qū)塊。return false; }

produce_block函數(shù)

區(qū)塊生產(chǎn)函數(shù)用于處理區(qū)塊生產(chǎn)，前面maybe_produce_block函數(shù)的主要功能集中在“maybe”，所以實(shí)際出塊任務(wù)仍舊交由produce_block處理。

void producer_plugin_impl::produce_block() {// 區(qū)塊生產(chǎn)必須是pending區(qū)塊狀態(tài)為producing，否則輸出錯誤日志：實(shí)際上并沒有真正生產(chǎn)區(qū)塊。EOS_ASSERT(_pending_block_mode == pending_block_mode::producing, producer_exception, "called produce_block while not actually producing");chain::controller& chain = app().get_plugin<chain_plugin>().chain(); // 獲取chain實(shí)例const auto& pbs = chain.pending_block_state(); // 從chain實(shí)例獲取當(dāng)前pending區(qū)塊，如果獲取為空，則輸出錯誤日志：不存在pending區(qū)塊，可能被其他插件毀壞。const auto& hbs = chain.head_block_state(); // 從chain實(shí)例獲取當(dāng)前頭區(qū)塊EOS_ASSERT(pbs, missing_pending_block_state, "pending_block_state does not exist but it should, another plugin may have corrupted it");auto signature_provider_itr = _signature_providers.find( pbs->block_signing_key ); // 通過pending區(qū)塊的區(qū)塊簽名公鑰去內(nèi)存多索引表_signature_providers中差找signature_provider。// 如果未查到有效signature_provider，則輸出錯誤日志：正在嘗試生產(chǎn)一個區(qū)塊，是由一個我們不擁有的私鑰所簽名。EOS_ASSERT(signature_provider_itr != _signature_providers.end(), producer_priv_key_not_found, "Attempting to produce a block for which we don't have the private key");chain.finalize_block(); // 執(zhí)行chain的區(qū)塊完成操作，重置資源(調(diào)用的為controller的finalize_block函數(shù))。chain.sign_block( [&]( const digest_type& d ) { // 調(diào)用controller的sign_block函數(shù)進(jìn)行函數(shù)簽名，參數(shù)為一個回調(diào)函數(shù)。區(qū)塊簽名最終是由block_header_state來做的實(shí)際工作。auto debug_logger = maybe_make_debug_time_logger();return signature_provider_itr->second(d);} );chain.commit_block(); // 仍舊是執(zhí)行controller的commit_block函數(shù)進(jìn)行區(qū)塊提交。block_state_ptr new_bs = chain.head_block_state(); _producer_watermarks[new_bs->header.producer] = chain.head_block_num(); // 設(shè)置水印// 打印生產(chǎn)結(jié)果日志。ilog("Produced block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, confirmed: ${confs}]",("p",new_bs->header.producer)("id",fc::variant(new_bs->id).as_string().substr(0,16))("n",new_bs->block_num)("t",new_bs->header.timestamp)("count",new_bs->block->transactions.size())("lib",chain.last_irreversible_block_num())("confs", new_bs->header.confirmed));}

水印的意義重申一下，是用來給計劃出塊預(yù)先設(shè)置出塊安排的，即安排下一個區(qū)塊的生產(chǎn)者，管理出塊輪次。

produce_block函數(shù)屬于producer_plugin，然而其中核心區(qū)塊處理，例如重置資源準(zhǔn)備、區(qū)塊簽名、提交區(qū)塊都時通過chain_plugin調(diào)用了controller的相關(guān)函數(shù)，而controller只是負(fù)責(zé)管理與數(shù)據(jù)層的交互，數(shù)據(jù)層包括block.log以及及與chainbase的db，區(qū)塊簽名的內(nèi)容是區(qū)塊頭block_header_state來處理。結(jié)構(gòu)拆分如下圖所示：

start_block 函數(shù)

該函數(shù)是producer插件對出塊管理的核心函數(shù)。該函數(shù)通過對時間的控制管理了出塊節(jié)奏，管理出塊輪次。到這里可以得出producer插件的操作對象是pending區(qū)塊，所以該函數(shù)對pending區(qū)塊是本地生產(chǎn)還是外部同步進(jìn)來的做了區(qū)分處理。這其中涉及到一個區(qū)塊同步確認(rèn)的處理，即生產(chǎn)者生產(chǎn)當(dāng)前區(qū)塊時要確認(rèn)多少個區(qū)塊：

• 如果區(qū)塊的生產(chǎn)者不是當(dāng)前節(jié)點(diǎn)的，則假設(shè)沒有確認(rèn)(丟棄這個塊)。
• 如果區(qū)塊的生產(chǎn)者是當(dāng)前節(jié)點(diǎn)上從未產(chǎn)生過的生產(chǎn)者，那么保守的方法就是假定沒有確認(rèn)，確保不會在crash之后重復(fù)簽名。(不過此處有個問題是crash的話，是否要保證水印持久化？否則crash會丟失，答案是肯定的)
• 如果區(qū)塊的生產(chǎn)者是這個節(jié)點(diǎn)上的生產(chǎn)者，這個節(jié)點(diǎn)是知道它生成的最后一個塊的，則安全地設(shè)置它：unless
• 如果區(qū)塊的生產(chǎn)者在該節(jié)點(diǎn)的最后水印中的位置較高，則意味著該區(qū)塊時在一個不同的分叉上。

本函數(shù)大約包含三百多行代碼，用于處理pending區(qū)塊不同情況下的校驗以及動作，包括對區(qū)塊中打包事務(wù)的校驗和處理，最終返回的時start_block_result狀態(tài)，前面有介紹過。

start_block的代碼不在此詳細(xì)分析，但總結(jié)下來可以得出是對pending區(qū)塊的區(qū)塊頭校驗，包括是否是本地生產(chǎn)抑或是外部同步，然后是對pending區(qū)塊內(nèi)事務(wù)的處理，包括如何重置打包接收的事務(wù)。到這部分相當(dāng)于將一個區(qū)塊的頭部信息構(gòu)成以及校驗工作和區(qū)塊體的事務(wù)打包內(nèi)容工作完成了。最后返回一個處理狀態(tài)，如果通過了層層校驗以及無異常的順利處理，則返回啟動區(qū)塊成功的狀態(tài)，如果是時間超時，耗盡了規(guī)定時間則返回exhausted，其他情況則時failed。

總結(jié)

本文分析介紹了producer_plugin的重點(diǎn)功能，研究了其大量內(nèi)部函數(shù)。最初的研究路先是分析該插件的生命周期，然后引申到各個未知或以前未仔細(xì)研究過的調(diào)用的函數(shù)細(xì)節(jié)。其中，涉及到了出塊安排水印、pending區(qū)塊處理、區(qū)塊生產(chǎn)循環(huán)、區(qū)塊的生產(chǎn)者校驗、是否本地或是同步、計時器的相關(guān)知識和應(yīng)用、最后不可逆塊的研究、區(qū)塊生產(chǎn)、區(qū)塊簽名等，另外還涉及到新版本的多線程校驗簽名區(qū)塊的內(nèi)容。研究過程中，也梳理了producer插件與chain插件的交互以及延伸到controller的內(nèi)部函數(shù)的使用。總之，內(nèi)容較多篇幅較長，整體研究脈絡(luò)似乎仍舊不算清晰，但也算是自身知識圖譜的“大數(shù)據(jù)”的一部分，量變引發(fā)質(zhì)變。

更多文章請轉(zhuǎn)到醒者呆的博客園。

轉(zhuǎn)載于:https://www.cnblogs.com/Evsward/p/producerPlugin.html

總結(jié)

以上是生活随笔為你收集整理的EOS生产区块：解析插件producer_plugin的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。