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借鉴了图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
fc
-crypto
-io
-log
-network
-rpc
utilities
constracts（智能合约层）
主要包含一些智能合约的示例代码。
应用层流程分析
nodeos
从main函数开始，程序大致分为三部分：选项配置、加载插件、启动程序,programs/nodeos/main.cpp：
选项配置
|
1
2
3
4
|
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类的实例对象，这里采用单例模式，保证整个系统访问的是同一个全局对象，具体实现：
|
1
2
3
4
5
6
|
libraries/appbase/application.cpp
application& application::instance() {
static
application _app;
return
_app;
}
application& app() { return
application::instance(); }
|
注册插件
在加载使用插件前，需要通过register_plugin()函数将插件注册到application的plugins插件集合中，plugins是一个map容器，通过键值对管理插件名称和插件对象指针，方便通过插件名称查找插件对象。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/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;
…
}
|
加载插件
|
1
2
|
if(!app().initialize(argc, argv))
return
-1;
|
initialize()是一个模版函数，通过遍历调用各个插件的plugin_initialize函数，完成对各个插件的初始化任务，具体实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class
application
{
…
templatebool 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集合中，该集合保存已经初始化过的插件实例，后面启动实例对象时会访问。
|
1
2
3
4
5
6
|
class
application
{
…
vector initialized_plugins;
…
}
|
最后，调用具体plugin的初始化函数，例如，producer_plugin的初始化函数如下：
|
1
2
3
4
5
6
7
8
9
|
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()，主要功能是循环生产区块：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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：
|
1
2
3
4
5
|
void
application::exec() {
sigint_set->async_wait
io_serv->run(); // 异步等待信号事件发生。
shutdown() // 应用退出后关闭插件。
}
|
cleos
cleos是一个命令行工具，用于和区块链数据交互以及管理钱包，从main函数开始，
程序大致分为三部分：创建主命令和选项、创建子命令和选项、解析用户参数后调用对应命令的回调函数。
所有命令都必须包含主命令cleos，然后可以创建子命令和选项，例如cleos create，同时可以为子命令继续创建子命令和选项，例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
./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::vectoroptions_; 管理多个选项：
|
1
2
3
4
5
6
|
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_集合中：
|
1
2
3
4
5
|
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子命令在回调函数中生成公钥和私钥，同时可以嵌套的为子命令创建子命令和选项：
|
1
2
3
4
5
6
7
8
9
|
# ./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;
});
|
解析用户参数
设置完所有的命令、选项和回调函数后，开始解析用户输入的参数，并匹配到对应的命令，执行相应功能：
|
1
2
3
|
try
{
app.parse(argc, argv);
}
|
将用户参数解析后保存在std::vectorargs中，通过parse(args)做进一步解析：
|
1
2
3
4
5
6
7
8
9
|
/// 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_，执行对应的回调函数：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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这三个插件完成，具体流程不再赘述。
