【劉文彬】【源碼解讀】EOS測試插件：txn_test_gen_plugin.cpp

時間 2019-12-04

標籤劉文彬源碼解讀 eos 測試插件 txn test gen plugin.cpp plugin cpp 简体版

原文原文鏈接

原文連接：醒者呆的博客園，https://www.cnblogs.com/Evswa...html

本文內容本屬於《【精解】EOS TPS 多維實測》的內容，但因爲在編寫時篇幅過長，因此我決定將這一部分單獨成文撰寫，以便於理解。
關鍵字：eos, txn_test_gen_plugin, signed_transaction, ordered_action_result, C++, EOS插件算法

txn_test_gen_plugin 插件

這個插件是官方開發用來測試塊打包交易量的，這種方式因爲是直接系統內部調用來模擬transaction，沒有中間通信的損耗，所以效率是很是高的，官方稱經過這個插件測試到了8000的tps結果，而就個人測試結果來說，沒有這麼恐怖，但也能到2000了，熟不知，其餘的測試手段，例如cleos，eosjs可能只有百級的量。下面，咱們一同來研究一下這個插件是如何實現以上功能的，過程當中，咱們也會思考EOS插件的架構體系，以及實現方法。經過本文的學習，若是有好的想法，咱們也能夠本身開發一個功能強大的插件pr給eos，爲EOS社區作出咱們本身的貢獻。json

關於txn_test_gen_plugin插件的使用，很是易於上手，本文不作分析，這方面能夠直接參考官方文檔。

插件的總體架構

插件代碼總體結構中，咱們上面介紹的核心功能的實現函數都是包含在一個結構體struct txn_test_gen_plugin_impl中。剩餘的其餘代碼都是對插件自己的通信進行描述，包括如何調用，如何響應等，以及整個插件的生命週期的控制：網絡

set_program_options，設置參數的階段，是最開始的階段，內容只設置了txn-reference-block-lag的值，默認是0，-1表明最新頭區塊。
plugin_initialize，這一時期就把包含核心功能的結構體txn_test_gen_plugin_impl加載到程序運行時內存中了，同時初始化標誌位txn_reference_block_lag爲txn-reference-block-lag的值。
plugin_startup，咱們經過基礎插件http_plugin的支持得到了http接口的能力，這一時期，就暴露出來本插件的對外接口。
plugin_shutdown，調用stop_generation函數，重置標誌位running爲false，計時器關閉，打印關閉提示日誌。

下面是對外暴露的三個接口之一的stop_generation函數的源碼：架構

void stop_generation() {
    if(!running)
        throw fc::exception(fc::invalid_operation_exception_code);
    timer.cancel();
    running = false;
    ilog("Stopping transaction generation test");
}

接下來，咱們主要集中精力在結構體txn_test_gen_plugin_impl上，研究路線是以剩餘兩個接口分別爲入口進行逐一分析。app

create_test_accounts 接口

關於這個接口，調用方法是curl

curl --data-binary '["eosio", "5KQwrPbwdL6PhXujxW37FSSQZ1JiwsST4cqQzDeyXtP79zkvFD3"]' http://localhost:8888/v1/txn_test_gen/create_test_accounts

傳入的參數是eosio以及其私鑰。咱們進入到函數create_test_accounts中去分析源碼。異步

準備知識

首先，整個函數涉及到的全部transaction都是打包存入到一個vector集合std::vector中去。async

trxs是一個事務集，它包含不少的trx，而其中每個trx包含一個actions集合vector

1、準備帳戶

trxs的第一個trx，內容爲帳戶建立：函數

定義3個帳戶：txn.test.a，txn.test.b, txn.test.t
輔助功能：controller& cc = app().get_plugin<chain_plugin>().chain();，經過cc能夠隨時調用本地區塊鏈上的任意信息。
經過fc::crypto::private_key::regenerate函數分別生成他們的私鑰，要傳入生成祕鑰的seed。
經過私鑰直接調用get_public_key()便可得到公鑰
設置每一個帳戶的owner和active權限對應的公鑰，通常來說他們是相同的
帳戶的建立者均爲咱們外部調用create_test_accounts接口時傳入的帳戶eosio，注意：eosio的私鑰是經過字符串傳入的，要經過fc::crypto::private_key轉換成私鑰對象
將每個帳戶的建立組裝好成爲一個action，存入trx的actions集合中去。
trx的actions成員已經設置完畢，完成剩餘trx的組裝工做，包括
- expiration，經過cc得到當前頭區塊的時間，加上延遲時間，這裏是30s，fc::seconds(30)
- reference_block，值爲經過cc獲取當前的頭區塊，意思爲本transaction的引用區塊，全部的信息是引用的這個區塊爲頭區塊的環境
- sign，簽名，使用的是建立者eosio的私鑰對象，上面咱們已經準備好了，簽名的數據是data的摘要
  - 當前trx的actions中的元素的data並非如文首的transaction中的data的加密串的結構，而是明文的，這裏的加密是數字摘要技術，感興趣的朋友能夠去《應用密碼學初探》進行了解。
  - 摘要的源碼函數是：sig_digest(chain_id, context_free_data)，其中參數使用到了chain_id，而context_free_data就是上面提到的明文data內容，因此它是要與鏈id一塊兒作數字摘要的（這一點我在使用eosjs嘗試本身作摘要的時候並未想到）

這一部分的源碼展現以下：

name newaccountA("txn.test.a");
name newaccountB("txn.test.b");
name newaccountC("txn.test.t");
name creator(init_name);

abi_def currency_abi_def = fc::json::from_string(eosio_token_abi).as<abi_def>();

controller& cc = app().get_plugin<chain_plugin>().chain();
auto chainid = app().get_plugin<chain_plugin>().get_chain_id();

fc::crypto::private_key txn_test_receiver_A_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
fc::crypto::private_key txn_test_receiver_B_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
fc::crypto::private_key txn_test_receiver_C_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'c')));
fc::crypto::public_key  txn_text_receiver_A_pub_key = txn_test_receiver_A_priv_key.get_public_key();
fc::crypto::public_key  txn_text_receiver_B_pub_key = txn_test_receiver_B_priv_key.get_public_key();
fc::crypto::public_key  txn_text_receiver_C_pub_key = txn_test_receiver_C_priv_key.get_public_key();
fc::crypto::private_key creator_priv_key = fc::crypto::private_key(init_priv_key);

//create some test accounts
{
    signed_transaction trx;
    
    //create "A" account
    {
        auto owner_auth   = eosio::chain::authority{1, {{txn_text_receiver_A_pub_key, 1}}, {}};
        auto active_auth  = eosio::chain::authority{1, {{txn_text_receiver_A_pub_key, 1}}, {}};
        trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, newaccount{creator, newaccountA, owner_auth, active_auth});
    }
    //create "B" account
    {
        auto owner_auth   = eosio::chain::authority{1, {{txn_text_receiver_B_pub_key, 1}}, {}};
        auto active_auth  = eosio::chain::authority{1, {{txn_text_receiver_B_pub_key, 1}}, {}};
        trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, newaccount{creator, newaccountB, owner_auth, active_auth});
    }
    //create "txn.test.t" account
    {
        auto owner_auth   = eosio::chain::authority{1, {{txn_text_receiver_C_pub_key, 1}}, {}};
        auto active_auth  = eosio::chain::authority{1, {{txn_text_receiver_C_pub_key, 1}}, {}};
        trx.actions.emplace_back(vector<chain::permission_level>{{creator,"active"}}, newaccount{creator, newaccountC, owner_auth, active_auth});
    }
    trx.expiration = cc.head_block_time() + fc::seconds(30);
    trx.set_reference_block(cc.head_block_id());
    trx.sign(creator_priv_key, chainid);
    trxs.emplace_back(std::move(trx));
}

2、token相關

trxs的第二個trx，內容爲token建立和issue，爲帳戶轉帳爲以後的測試作準備

爲帳戶txn.test.t設置eosio.token合約，以前在操做cleos set contract的時候能夠經過打印結果發現，是有setcode和setabi兩個步驟的。
- setcode handler:
  - 設置handler的帳戶爲txn.test.t
  - 將wasm設置爲handler的code，wasm是經過eosio.token合約的eosio_token_wast文件獲取的，vector<uint8_t> wasm = wast_to_wasm(std::string(eosio_token_wast))
  - 將handler加上相關權限組裝成action裝入trx的actions集合中。
- setabi handler:
  - 設置handler的帳戶爲txn.test.t
  - 設置handler的abi，將文件eosio_token_abi(json格式的)轉成json轉儲爲abi_def結構，而後經過fc::raw::pack操做將結果賦值給abi
  - 將handler加上相關權限組裝成action裝入trx的actions集合中。
使用帳戶txn.test.t建立token，標誌位CUR，總髮行量十億，裝成action裝入trx的actions集合中。
issue CUR 給txn.test.t 600枚CUR，裝成action裝入trx的actions集合中。
從txn.test.t轉帳給txn.test.a 200枚CUR，裝成action裝入trx的actions集合中。
從txn.test.t轉帳給txn.test.b 200枚CUR，裝成action裝入trx的actions集合中。
trx的actions成員已經設置完畢，完成剩餘trx的組裝工做（同上），這裏只介紹不一樣的部分
- max_net_usage_words，指定了網絡資源的最大使用限制爲5000個詞。

這一部分的源碼展現以下：

//set txn.test.t contract to eosio.token & initialize it
{
    signed_transaction trx;
    vector<uint8_t> wasm = wast_to_wasm(std::string(eosio_token_wast));
    setcode handler;
    handler.account = newaccountC;
    handler.code.assign(wasm.begin(), wasm.end());
    trx.actions.emplace_back( vector<chain::permission_level>{{newaccountC,"active"}}, handler);
    
    {
        setabi handler;
        handler.account = newaccountC;
        handler.abi = fc::raw::pack(json::from_string(eosio_token_abi).as<abi_def>());
        trx.actions.emplace_back( vector<chain::permission_level>{{newaccountC,"active"}}, handler);
    }
    {
        action act;
        act.account = N(txn.test.t);
        act.name = N(create);
        act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
        act.data = eosio_token_serializer.variant_to_binary("create", fc::json::from_string("{\"issuer\":\"txn.test.t\",\"maximum_supply\":\"1000000000.0000 CUR\"}}"));
        trx.actions.push_back(act);
    }
    {
        action act;
        act.account = N(txn.test.t);
        act.name = N(issue);
        act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
        act.data = eosio_token_serializer.variant_to_binary("issue", fc::json::from_string("{\"to\":\"txn.test.t\",\"quantity\":\"600.0000 CUR\",\"memo\":\"\"}"));
        trx.actions.push_back(act);
    }
    {
        action act;
        act.account = N(txn.test.t);
        act.name = N(transfer);
        act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
        act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.a\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"));
        trx.actions.push_back(act);
    }
    {
        action act;
        act.account = N(txn.test.t);
        act.name = N(transfer);
        act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
        act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.b\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"));
        trx.actions.push_back(act);
    }
    
    trx.expiration = cc.head_block_time() + fc::seconds(30);
    trx.set_reference_block(cc.head_block_id());
    trx.max_net_usage_words = 5000;
    trx.sign(txn_test_receiver_C_priv_key, chainid);
    trxs.emplace_back(std::move(trx));
}

發起請求

目前trxs集合已經包含了兩個trx元素，其中每一個trx包含了多個action。下面要將trxs推送到鏈上執行

push_transactions函數，遍歷trxs元素，每一個trx單獨發送push_next_transaction
push_next_transaction函數，首先將trx取出經過packed_transaction函數進行組裝成post的結構
packed_transaction函數，經過set_transaction函數對trx進行摘撿，使用pack_transaction函數進行組裝
pack_transaction函數，就是調用了一下上面提過的fc::raw::pack操做，而後經過accept_transaction函數向鏈發起請求
accept_transaction函數，是chain_plugin的一個函數，它內部調用了incoming_transaction_async_method異步發起交易請求。

這部分代碼比較雜，分爲幾個部分：

push_transactions函數：

void push_transactions( std::vector<signed_transaction>&& trxs, const std::function<void(fc::exception_ptr)>& next ) {
    auto trxs_copy = std::make_shared<std::decay_t<decltype(trxs)>>(std::move(trxs));
    push_next_transaction(trxs_copy, 0, next);
}

push_next_transaction函數：

static void push_next_transaction(const std::shared_ptr<std::vector<signed_transaction>>& trxs, size_t index, const std::function<void(const fc::exception_ptr&)>& next ) {
      chain_plugin& cp = app().get_plugin<chain_plugin>();
      cp.accept_transaction( packed_transaction(trxs->at(index)), [=](const fc::static_variant<fc::exception_ptr, transaction_trace_ptr>& result){
         if (result.contains<fc::exception_ptr>()) {
            next(result.get<fc::exception_ptr>());
         } else {
            if (index + 1 < trxs->size()) {
               push_next_transaction(trxs, index + 1, next);
            } else {
               next(nullptr);
            }
         }
      });
   }

packed_transaction函數，set_transaction函數以及pack_transaction函數的代碼都屬於本插件源碼以外的EOS庫源碼，因爲自己代碼量也較少，含義在上面已經徹底解釋過了，這裏再也不粘貼源碼。

accept_transaction函數也是EOS的庫源碼

void chain_plugin::accept_transaction(const chain::packed_transaction& trx, next_function<chain::transaction_trace_ptr> next) {
    my->incoming_transaction_async_method(std::make_shared<packed_transaction>(trx), false, std::forward<decltype(next)>(next));
}

incoming_transaction_async_method(app().get_method<incoming::methods::transaction_async>())

start_generation 接口

該接口的調用方法是：

curl --data-binary '["", 20, 20]' http://localhost:8888/v1/txn_test_gen/start_generation

參數列表爲：

第一個參數爲 salt，通常用於「加鹽」加密算法的值，這裏咱們能夠留空。
第二個參數爲 period，發送交易的間隔時間，單位爲ms，這裏是20。
第三個參數爲 batch_size，每一個發送間隔週期內打包交易的數量，這裏也是20。
翻譯過來就是：每20ms提交20筆交易。

接下來，以start_generation 函數爲入口進行源碼分析。

start_generation 函數

校驗：
- period的取值範圍爲(1, 2500)
- batch_size的取值範圍爲(1, 250)
- batch_size必須是2的倍數，batch_size & 1結果爲假0才能夠，這是一個位運算，與&，因此batch_size的值轉爲二進制時末位不能爲1，因此就是2的倍數便可。
- 對標誌位running的控制。

這部分代碼展現以下：

if(running)
    throw fc::exception(fc::invalid_operation_exception_code);
if(period < 1 || period > 2500)
    throw fc::exception(fc::invalid_operation_exception_code);
if(batch_size < 1 || batch_size > 250)
    throw fc::exception(fc::invalid_operation_exception_code);
if(batch_size & 1)
    throw fc::exception(fc::invalid_operation_exception_code);

running = true;

定義兩個action，分別是：
- 帳戶txn.test.a給txn.test.b轉帳1000枚CUR
- txn.test.b轉給txn.test.a一樣1000枚CUR

這部分代碼展現以下：

//create the actions here
act_a_to_b.account = N(txn.test.t);
act_a_to_b.name = N(transfer);
act_a_to_b.authorization = vector<permission_level>{{name("txn.test.a"),config::active_name}};
act_a_to_b.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string(fc::format_string("{\"from\":\"txn.test.a\",\"to\":\"txn.test.b\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}", fc::mutable_variant_object()("l", salt))));

act_b_to_a.account = N(txn.test.t);
act_b_to_a.name = N(transfer);
act_b_to_a.authorization = vector<permission_level>{{name("txn.test.b"),config::active_name}};
act_b_to_a.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string(fc::format_string("{\"from\":\"txn.test.b\",\"to\":\"txn.test.a\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}", fc::mutable_variant_object()("l", salt))));

接下來，是對參數period和batch_size的儲存爲結構體做用域的變量以供結構體內其餘函數調用，而後打印日誌，最後調用arm_timer函數。

timer_timeout = period; // timer_timeout是結構體的成員變量
batch = batch_size/2; // batch是結構體的成員變量
ilog("Started transaction test plugin; performing ${p} transactions every ${m}ms", ("p", batch_size)("m", period));
arm_timer(boost::asio::high_resolution_timer::clock_type::now());

arm_timer 函數

從start_generation 函數過來，傳入的參數是當前時間now，該函數主要功能是對計時器的初始化操做（計時器與文首的stop_generation函數中的關閉計時器呼應）。具體內容可分爲兩部分：

設定計時器的過時時間，值爲start_generation 接口的參數period與now相加的值，即從如今開始，過period這麼久，當前計時器對象timer就過時。
設定計時器的異步定時任務，任務體直接調用send_transaction函數，對函數的返回值進行處理，若是有報錯信息（通常是服務停止）則調用stop_generation函數關閉插件。
注意stop_generation函數關閉的是定時任務的無限遞歸，停止定時任務，中止發送測試交易。但它並無中止插件服務，咱們仍舊能夠經過再次請求插件接口啓動無限測試交易。

這部分代碼以下：

void arm_timer(boost::asio::high_resolution_timer::time_point s) {
    timer.expires_at(s + std::chrono::milliseconds(timer_timeout));
    timer.async_wait([this](const boost::system::error_code& ec) {
        if(!running || ec)
            return;
        
        send_transaction([this](const fc::exception_ptr& e){
            if (e) {
                elog("pushing transaction failed: ${e}", ("e", e->to_detail_string()));
                stop_generation();
            } else { // 若是沒有終止報錯，則無限遞歸調用arm_timer函數，遞歸時傳入的參數代替上面的now是當前timer對象的過時時間，這樣在新的遞歸調用中，timer的建立會以這個時間再加上period，無間隔繼續執行。
                arm_timer(timer.expires_at());
            }
        });
    });
}

send_transaction 函數

這個函數是本插件的核心功能部分，主要是發送測試交易，對transaction的處理，將咱們上面start_generation 函數中設置的兩個action打包到transaction中去，以及對transaction各項屬性的設置。具體步驟爲：

聲明trxs，併爲其設置大小爲start_generation 接口中batch_size的值。
std::vector<signed_transaction> trxs;
trxs.reserve(2*batch);

接下來，與上面介紹的create_test_accounts 接口的帳戶準備過程相同，準備私鑰公鑰，很少介紹。繼續準備trx的參數：

nonce，是用來賦值context_free_actions的
context_free_actions：官方介紹一大堆，總之就是正常action是須要代價的，要確權，要佔用主網資源什麼的，因此搞了一個context_free_actions，字面意思就是上下文免費的action，這裏權當測試用，填入的數據也是隨機nonce組裝的。
abi_serializer，用來序列化abi的，傳入的system_account_name的abi值，它是在這裏被賦值，然而是在結構體的做用域中被調用的。
reference_block_num的處理，引用區塊，上面咱們也提到過，而這裏面增長了一層判斷，是根據標誌位txn_reference_block_lag的值來比較，也就是說reference_block_num最後的值是最新區塊號減去txn_reference_block_lag的值，可是最小值爲0，不可爲負數。
經過reference_block_num得到reference_block_id

這部分代碼以下：

controller& cc = app().get_plugin<chain_plugin>().chain();
auto chainid = app().get_plugin<chain_plugin>().get_chain_id();

fc::crypto::private_key a_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
fc::crypto::private_key b_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));

static uint64_t nonce = static_cast<uint64_t>(fc::time_point::now().sec_since_epoch()) << 32;
abi_serializer eosio_serializer(cc.db().find<account_object, by_name>(config::system_account_name)->get_abi());

uint32_t reference_block_num = cc.last_irreversible_block_num();
if (txn_reference_block_lag >= 0) {
    reference_block_num = cc.head_block_num();
    if (reference_block_num <= (uint32_t)txn_reference_block_lag) {
        reference_block_num = 0;
    } else {
        reference_block_num -= (uint32_t)txn_reference_block_lag;
    }
}

block_id_type reference_block_id = cc.get_block_id_for_num(reference_block_num);

接下來，就是循環打包trx，咱們設置的batch_size比如是20，如今咱們已有兩個action，每一個action對應一個trx，則循環只須要執行10次，每次執行兩個trx便可實現，每一個trx相關的屬性在上一階段都已準備好。直接看代碼吧。

for(unsigned int i = 0; i < batch; ++i) {
    {
        signed_transaction trx;
        trx.actions.push_back(act_a_to_b);
        trx.context_free_actions.emplace_back(action({}, config::null_account_name, "nonce", fc::raw::pack(nonce++)));
        trx.set_reference_block(reference_block_id);
        trx.expiration = cc.head_block_time() + fc::seconds(30);
        trx.max_net_usage_words = 100;
        trx.sign(a_priv_key, chainid);
        trxs.emplace_back(std::move(trx));
    }
    {
        signed_transaction trx;
        trx.actions.push_back(act_b_to_a);
        trx.context_free_actions.emplace_back(action({}, config::null_account_name, "nonce", fc::raw::pack(nonce++)));
        trx.set_reference_block(reference_block_id);
        trx.expiration = cc.head_block_time() + fc::seconds(30);
        trx.max_net_usage_words = 100;
        trx.sign(b_priv_key, chainid);
        trxs.emplace_back(std::move(trx));
    }
}

最後，執行

push_transactions(std::move(trxs), next);

這個部分與create_test_accounts 接口發起請求的部分一致，這裏再也不重複展現。

總結

到這裏爲止，咱們已經徹底分析透了txn_test_gen_plugin 插件的內容。本文首先從大致上介紹了插件的架構，生命週期，通信請求與返回。接着介紹了核心結構體的內容，而後以對外接口爲入口，沿着一條線將每一個功能的實現完整地研究清楚。經過本文的學習，咱們對於EOS插件的體系有了初步深入的理解，同時咱們也徹底搞清楚了txn_test_gen_plugin 插件的功能，以及它爲何會達到一個比較高的tps的表現。

參考資料

EOSIO/eos
eos官方文檔