EOS 代碼架構及分析

由 熱鏈中的人 於 5 月 6, 2018

EOS 簡介

EOS （Enterprise Operation System），企業操作系統，是爲企業級分佈式應用設計的一款區塊鏈操作系統。相比於目前區塊鏈平臺性能低、開發難度大以及手續費高等問題，EOS 擁有高性能處理能力、易於開發以及用戶免費等優勢，極大的滿足企業級的應用需求，被譽爲繼比特幣、以太坊之後區塊鏈 3.0 技術。

EOS 優秀基因的背後是其底層的石墨烯軟件架構所決定的。其實 EOS 不是最早採用石墨烯架構的區塊鏈項目，其創始人 Dan Larimer （綽號 BM）早在 BitShare、Steem 等項目中已經採用該架構，並取得成功。那麼到底什麼是石墨烯架構？官網的解釋如下：

“The Graphene blockchain is not a monolithic application. It is composed of a variety of libraries and executables to provide deployable nodes.”

石墨烯區塊鏈不是一整個應用程序。它是由一系列庫和可執行程序組成，並且用於提供可部署分佈式應用程序的節點。如下圖 1 所示：

石墨烯的關鍵技術之一就是高度模塊化，將內部節點間的分佈式通信能力封裝成插件（plugins），由上層的應用程序（DAPP）動態加載調用，使得應用開發者無需關注區塊鏈底層細節，極大降低了開發難度，同時更具可擴展性。

石墨烯架構採用 DPoS （Delegated proof of stake）共識算法，使得處理性能可以媲美傳統的中心化架構。

EOS 代碼整體架構

EOS 借鑑了圖 1 的石墨烯架構思想，後面又進行了重新開發，主要包括應用層、插件層、庫函數層和智能合約層。

programs （應用層）

cloes：客戶端命令行交互模塊，用於解析用戶命令，根據具體命令請求調用相應的接口，例如查看區塊信息、操作錢包等等。

nodeos：服務器端，也就是區塊生產節點，用於接受客戶端的遠端請求，並打包區塊，主要包含四個插件，chain_plugin、http_plugin、net_plugin、producer_plugin。

keosd：錢包管理模塊，主要包括三個插件，wallet_plugin、wallet_api_plugin、http_plugin。

plugins （插件層）

支持動態加載相關組件，實現了應用層的業務邏輯和區塊鏈底層實現的解耦，同時爲應用開發者提供友好的 API 接口，比較重要的有以下幾個插件：

chain_plugin

http_plugin

net_plugin

producer_plugin

libraries （庫函數層）

爲應用層和插件層提供基礎能力，實現了區塊鏈的底層關鍵技術，例如，交易處理，生產區塊，加密功能，文件 IO 操作，網絡通信能力等等；

appbase

chain

-crypto
-io
-log
-network
-rpc
utilities

constracts （智能合約層）

主要包含一些智能合約的示例代碼。

應用層流程分析

nodeos

從 main 函數開始，程序大致分爲三部分：選項配置、加載插件、啓動程序 ,programs/nodeos/main.cpp：

選項配置

app().set_version(eosio::nodeos::config::version);

auto root = fc::app_path();

app().set_default_data_dir(root / “eosio/nodeos/data” );

app().set_default_config_dir(root / “eosio/nodeos/config” );

應用程序通過 app() 返回一個 application 類的實例對象，這裏採用單例模式，保證整個系統訪問的是同一個全局對象，具體實現：

libraries/appbase/application.cpp

application& application::instance() {

    static application _app;

return _app;

}

application& app() { return application::instance(); }

註冊插件

在加載使用插件前，需要通過 register_plugin() 函數將插件註冊到 application 的 plugins 插件集合中，plugins 是一個 map 容器，通過鍵值對管理插件名稱和插件對象指針，方便通過插件名稱查找插件對象。

/plugins/producer_plugin/producer_plugin.cpp

static appbase::abstract_plugin& _producer_plugin = app().register_plugin();

class application

{

    …

　template

　auto& register_plugin() {

　　auto existing = find_plugin();

if(existing)

return *existing;

auto plug = new Plugin();

plugins[plug->name()].reset(plug);

return *plug;

　}

　…

　map> plugins;

　…

}

加載插件

if(!app().initialize(argc, argv))

    return -1;

initialize() 是一個模版函數，通過遍歷調用各個插件的 plugin_initialize 函數，完成對各個插件的初始化任務，具體實現如下：

class application

{

…

template

bool                 initialize(int argc, char**argv) {

       return initialize_impl(argc, argv, {find_plugin()…});

}

…

}



bool application::initialize_impl(int argc, char**argv, vector
autostart_plugins) {

    …

         for (auto plugin : autostart_plugins)

if (plugin != nullptr && plugin->get_state() == abstract_plugin::registered)

plugin->initialize(options);

    …

}

class plugin : public abstract_plugin {

    …

    virtual void initialize(const variables_map& options) override {

if(_state == registered) {

_state = initialized;

static_cast(this)->plugin_requires([&](auto& plug){ plug.initialize(options);
});

static_cast(this)->plugin_initialize(options);

app().plugin_initialized(*this);

}

assert(_state == initialized);

}

…

}

其中，app().plugin_initialized(*this); 將 plugin 實例加入到 initialized_plugins 集合中，該集合保存已經初始化過的插件實例，後面啓動實例對象時會訪問。

class application

{

         …

vector                  initialized_plugins;

…

}

最後，調用具體 plugin 的初始化函數，例如，producer_plugin 的初始化函數如下：

void producer_plugin::plugin_initialize(const
boost::program_options::variables_map& options)

{

         …

         // 設置生產者信息和私鑰信息

         LOAD_VALUE_SET(options, “producer-name”, my->_producers,
types::account_name)

…

my->_private_keys[key_id_to_wif_pair.first] = key_id_to_wif_pair.second;

         …

}

啓動程序

加載插件後，遍歷調用 initialized_plugins 集合中各個插件實例的 startup() 函數，啓動插件任務，例如 producer_plugin 插件的啓動函數爲 producer_plugin::plugin_startup()，主要功能是循環生產區塊：

void application::startup() {

       for (auto plugin : initialized_plugins)

plugin->startup();

}



class plugin : public abstract_plugin {

       virtual void startup() override {

…

static_cast(this)->plugin_startup();

…

}

}



class producer_plugin : public appbase::plugin {

    …

       virtual void plugin_startup();

…

}



void producer_plugin::plugin_startup()

{

…

my->schedule_production_loop(); // 循環生產區塊

…

}

各個插件初始化並啓動完成後，最後設置應用程序的信號處理函數，用來響應用戶終止動作，例如，ctrl + c：

void application::exec() {

       sigint_set->async_wait

io_serv->run(); // 異步等待信號事件發生。

shutdown() // 應用退出後關閉插件。

}

cleos

cleos 是一個命令行工具，用於和區塊鏈數據交互以及管理錢包，從 main 函數開始，

程序大致分爲三部分：創建主命令和選項、創建子命令和選項、解析用戶參數後調用對應命令的回調函數。

所有命令都必須包含主命令 cleos，然後可以創建子命令和選項，例如 cleos create，同時可以爲子命令繼續創建子命令和選項，例如：

./cleos create account [OPTIONS] creator name OwnerKey ActiveKey

int main( int argc, char**argv ) {

    // 創建主命令 cleos，並添加選項

       CLI::App app{“Command Line Interface to EOSIO Client”};

app.add_option( “-H,–host”, old_host_port, localized(“the host where nodeos is
running”) )->group(“hidden”);

       …

// 爲主命令創建 create 子命令

auto create = app.add_subcommand(“create”, localized(“Create various items, on
and off the blockchain”), false);

…

// 爲 create 子命令創建子命令 account

auto createAccount = create->add_subcommand(“account”, localized(“Create a new
account on the blockchain”), false);

// 解析用戶命令參數，調用對應的回調函數

app.parse(argc, argv);

}

創建主命令

初始化一個 App 類的實例 app，然後通過 add_option 函數，添加命令選項。選項由 Option 類表示，主要包括選項名稱、選項描述、選項的回調函數等等。app 通過 std::vector
options_; 管理多個選項：

Option *add_option(std::string name, callback_t callback, std::string
description = “”, bool defaulted = false) {

    …

options_.emplace_back();

option.reset(new Option(name, description, callback, defaulted, this));

…

}

創建子命令

通過 app.add_subcommand 函數爲主命令創建子命令。子命令也用 App 類表示，保存在 subcommands_ 集合中：

std::vector subcommands_;

App *add_subcommand(std::string name, std::string description = “”, bool help
= true) {

       subcommands_.emplace_back(new App(description, help, detail::dummy));

…

}

通過 set_callback 函數爲子命令設置回調函數，完成相應的功能處理，例如 key 子命令在回調函數中生成公鑰和私鑰，同時可以嵌套的爲子命令創建子命令和選項：

“`. bash

./cleos create key

```.cpp
// create key

create->add_subcommand(“key”, localized(“Create a new keypair and print the
public and private keys”))->set_callback( [](){

         auto pk    = private_key_type::generate();

auto privs = string(pk);

auto pubs  = string(pk.get_public_key());

std::cout << localized(“Private key: ${key}”, (“key”,  privs) ) << std::endl;

std::cout << localized(“Public key: ${key}”, (“key”, pubs ) ) << std::endl;

});

解析用戶參數

設置完所有的命令、選項和回調函數後，開始解析用戶輸入的參數，並匹配到對應的命令，執行相應功能：

try {


       app.parse(argc, argv);
}

將用戶參數解析後保存在 std::vector args 中，通過 parse(args) 做進一步解析：

/// Parses the command line – throws errors

/// This must be called after the options are in but before the rest of the
program.

std::vector parse(int argc, char**argv) {

       name_ = argv[0];

std::vector args;

for(int i = argc – 1; i > 0; i–)

args.emplace_back(argv[i]);

return parse(args);

}

parse 函數完成最終的解析工作，實際上所有的子命令都已經保存在 subcommands 中，解析的過程就是將用戶參數對應的子命令 parsed_ 成員設置爲 true，最後，由 run_callback 函數遍歷 subcommands_，執行對應的回調函數：

std::vector &parse;(std::vector &args;) {

       _validate();

_parse(args);

run_callback();

return args;

}



void _parse(std::vector &args;) {

    parsed_ = true;

while(!args.empty()) {

// 對用戶命令進行逐個解析，識別分類爲子命令、長選項、短選項

_parse_single(args, positional_only);

}

}



void run_callback() {

       pre_callback();

// 調用命令的回調函數，這裏的命令既可以是主命令也可以是子命令

if(callback_)

callback_();

// get_subcommands() 返回匹配到的命令集合，然後遞歸調用子命令的 run_callback

for(App *subc : get_subcommands()) {

subc->run_callback();

}

}

keosd

keosd 錢包管理模塊的處理流程和 nodeos 類似，從 main
函數開始，程序大致分爲三部分：選項配置、加載插件、啓動程序，主要的功能由 wallet_plugin、wallet_api_plugin、http_plugin 這三個插件完成，具體流程不再贅述。

來源鏈接：www.8btc.com

EOS 技術