bigchaindb源码分析（四）——创建创世区块
根据bigchaindb源码分析（三）所述，在初始化后端存储后，命令bigchaindb start所触发执行的_run_init函数将创建创世区块
# commands/bigchaindb.py
def _run_init():
# Try to access the keypair, throws an exception if it does not exist
b = bigchaindb.Bigchain()
schema.init_database(connection=b.connection)
b.create_genesis_block()
logger.info('Genesis block created.')创建创世区块的具体实现在core.py，其首先查找目前后端存储中已有的区块数目，如果存在区块，则说明创世区块已经创建好，抛出异常返回，否则则新建创世区块，并写入后端存储中
# core.py
def create_genesis_block(self):
blocks_count = backend.query.count_blocks(self.connection)
if blocks_count:
raise exceptions.GenesisBlockAlreadyExistsError('Cannot create the Genesis block')
block = self.prepare_genesis_block()
self.write_block(block)
return block查询已有区块数目
查询已有区块数目代码如下。调用的count_blocks的原型在backend/query.py。该函数有装饰器singledispatch，在源码分析（三）中，我们对该装饰器进行了详细的分析，其作用在于实现根据参数列表的不同类型来调用该函数原型，相当于实现函数多态。
# core.py
blocks_count = backend.query.count_blocks(self.connection)
# backend/query.py
@singledispatch
def count_blocks(connection):
raise NotImplementedError由于形参self.connection实际上为位于bigchaindb.backend.mongodb.connection模块中的MongoDBConnection类，根据源码分析（三），我们可以分析得到真正执行的函数为bigchaindb.backend.mongodb.query中的count_blocks函数，并且实参为MongoDBConnection类的实例
@register_query(MongoDBConnection)
def count_blocks(conn):
return conn.run(
conn.collection('bigchain')
.count())conn.collection('bigchain').count()故将调用MongoDBConnection.collection，conn.run将调用MongoDBConnection.run
# bigchaindb.backend.mongodb.connection.MongoDBConnection
def query(self):
return Lazy()
def collection(self, name):
return self.query()[self.dbname][name]
def run(self, query):
try:
try:
return query.run(self.conn)
except ...
except ...将这些函数组合起来，count_blocks相当于调用了Lazy()[self.dbname]['bigchain'].count().run(self.conn)。其中self.dbname按照我们的配置文件，值为bigchain，而self.conn是一个已经通过了验证的pymongo.MongoClient实例（源码分析（三）中有说明）
这里涉及到了Lazy类，我们就先来看这个类吧
Lazy类位于bigchaindb/utils.py，其代码如下。Lazy类维护了名为stack的list，挡在触发__getattr__、__call__、__getitem__时，会将参数等加入到这个list中，从而形成了一条记录链。而run函数则是对于输入的实参instance，依次执行这个记录链。估计是因为可以暂缓执行记录链（直到调用run），所以才取名为Lazy吧。。
class Lazy:
def __init__(self):
"""Instantiate a new Lazy object."""
self.stack = []
def __getattr__(self, name):
self.stack.append(name)
return self
def __call__(self, *args, **kwargs):
self.stack.append((args, kwargs))
return self
def __getitem__(self, key):
self.stack.append('__getitem__')
self.stack.append(([key], {}))
return self
def run(self, instance):
"""Run the recorded chain of methods on `instance`. Args: instance: an object. """
last = instance
for item in self.stack:
if isinstance(item, str):
last = getattr(last, item)
else:
last = last(*item[0], **item[1])
self.stack = []
return last现在再来仔细分析count_blocks所执行的代码，即Lazy()[self.dbname]['bigchain'].count().run(self.conn)
- 首先，每一次
[]运算符会调用__getitem__，因此，Lazy()[self.dbname]['bigchain']执行完成后，Lazy实例中的stack应该为
['__getitem__', ([self.dbname], {}), '__getitem__', (['bigchain'], {})]- 之后再调用count函数，此时将首先调用
__getattr__来查找名为name的函数，然后调用__call__来调用name函数，因此，Lazy实例中的stack应该为
['__getitem__', ([self.dbname], {}), '__getitem__', (['bigchain'], {}), 'count', ((), {})]- 最后再来调用run函数，run函数已经被定义了，因此不会再调用
__getattr__或者__call__，而是直接执行run函数。run函数首先执行两次__getitem__，然后再执行一次count，故而实际上是把stack中记录的操作重新记录一遍，因此执行的也就为
# ::代表对某个对象进行操作
pymongo.MongoClient::[self.dbname]['bigchain'].count()所以获取区块的数目其实就是查看表bigchain中的记录数目。。那么，为什么要使用Lazy类呢？估计是为了防止在连续调用时数据可能会发生变化而导致某些问题？并不清楚。。以后再来思考这个问题
创建创世区块
若未查找到已有区块，则说明应当要创建创世区块，对应的最外层代码为
# core.py create_genesis_block
block = self.prepare_genesis_block()
self.write_block(block)prepare_genesis_block首先创建一个Transaction类，并指定签名者为本节点（self.me为本节点的公钥），接受者也为本节点，云数据为{'message': 'Hello World from the BigchainDB'}，之后将该事务的operation设置为GENESIS，代表创世区块。bigchaindb中的事务有三类，其中create表示新建资产，transfer表示转移资源，而genesis则特指创世区块。接着再利用sign函数来对事务进行签名
def prepare_genesis_block(self):
"""Prepare a genesis block."""
metadata = {'message': 'Hello World from the BigchainDB'}
transaction = Transaction.create([self.me], [([self.me], 1)],
metadata=metadata)
transaction.operation = 'GENESIS'
transaction = transaction.sign([self.me_private])
# create the block
return self.create_block([transaction])在创建事务完成后，再使用Block类来根据事务创建区块，创建时指明了生成区块的节点（self.me）、时间戳以及投票者。投票者为配置文件中keyring所指定的节点（self.nodes_except_me）以及本节点。区块创建成功后，再使用本节点的私钥进行签名
federation = property(lambda self: set(self.nodes_except_me + [self.me]))
def create_block(self, validated_transactions):
# Prevent the creation of empty blocks
if not validated_transactions:
raise exceptions.OperationError('Empty block creation is not '
'allowed')
voters = list(self.federation)
block = Block(validated_transactions, self.me, gen_timestamp(), voters)
block = block.sign(self.me_private)
return block在区块成功创建并被签名后，bigchaindb首先调用decouple_assets将区块里的事务中的资产asset去重，并设置资产的id为创建该资产的事务的id，之后调用后端存储的write_assets与write_block方法来将资产与事务写入到后端存储中
def write_block(self, block):
# Decouple assets from block
assets, block_dict = block.decouple_assets()
# write the assets
if assets:
self.write_assets(assets)
# write the block
return backend.query.write_block(self.connection, block_dict)
def write_assets(self, assets):
return backend.query.write_assets(self.connection, assets)写资产与写区块的实现代码均位于backend/mongodb/query.py中。根据之前对Lazy类的分析，这两个函数实际上就是分别将资产插入到assets表中、将区块写入到bigchain表中
@register_query(MongoDBConnection)
def write_assets(conn, assets):
try:
return conn.run(
conn.collection('assets')
.insert_many(assets, ordered=False))
except OperationError:
return
@register_query(MongoDBConnection)
def write_block(conn, block_dict):
return conn.run(
conn.collection('bigchain')
.insert_one(block_dict))至此，创建创世区块步骤完成，基本流程也就为：创建事务->对事务签名->根据事务创建区块->对区块进行签名->获取区块里的资产，设置资产的id为事务id->写资产->写事务。关于事务、区块、资产还有目前没有提到的投票的细节，我们之后在调用API写bigchaindb时再来分析
更多精彩内容
