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所示：

image.png

石墨烯的關鍵技術之一就是高度模塊化，將內部節點間的分布式通信能力封裝成插件（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。

image.png

plugins（插件層）

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

chain_plugin
http_plugin
net_plugin
producer_plugin
libraries（庫函數層）
為應用層和插件層提供基礎能力，實現了區塊鏈的底層關鍵技術，例如，交易處理，生產區塊，加密功能，文件IO操作，網絡通信能力等等；

appbase
chain
fc
-crypto
-io
-log
-network
-rpc
utilities
constracts（智能合約層）
主要包含一些智能合約的示例代碼。

應用層流程分析
nodeos
從main函數開始，程序大致分為三部分：選項配置、加載插件、啟動程序,programs/nodeos/main.cpp：

image.png

選項配置
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<producer_plugin>();
class application
{
…
template<typename Plugin>
auto& register_plugin() {
auto existing = find_plugin<Plugin>();
if(existing)
return *existing;
auto plug = new Plugin();
plugins[plug->name()].reset(plug);
return *plug;
}
…
map<string, std::unique_ptr<abstract_plugin>> plugins;
…
}
加載插件
if(!app().initialize<chain_plugin, http_plugin, net_plugin, producer_plugin>(argc, argv))
return -1;

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

class application
{
…
template<typename… Plugin>
bool                 initialize(int argc, char** argv) {
return initialize_impl(argc, argv, {find_plugin<Plugin>()…});
}
…
}
bool application::initialize_impl(int argc, char** argv, vector<abstract_plugin*> 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<Impl*>(this)->plugin_requires([&](auto& plug){ plug.initialize(options); });
static_cast<Impl*>(this)->plugin_initialize(options);
app().plugin_initialized(*this);
}
assert(_state == initialized);
}
…
}

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

class application
{
…
vector<abstract_plugin*>                  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<Impl*>(this)->plugin_startup();
…
}
}
class producer_plugin : public appbase::plugin<producer_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<Option_p> 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<App_p> 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子命令在回調函數中生成公鑰和私鑰，同時可以嵌套的為子命令創建子命令和選項：

# ./cleos create key
// 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<std::string> 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<std::string> parse(int argc, char **argv) {
name_ = argv[0];
std::vector<std::string> 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<std::string> &parse(std::vector<std::string> &args) {
_validate();
_parse(args);
run_callback();
return args;
}
void _parse(std::vector<std::string> &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這三個插件完成，具體流程不再贅述。

image.png