Fabric源码阅读与编译

前言

Hyperledger fabric,什么是Hypeledger,什么是Fabric?Hypeledger从字面上的意思是超级账本,它是Linux基金会于2015年12月启动了名为“超级账本”的开源项目，旨在推动各方协作，共同打造基于区块链的企业级分布式账本底层技术，用于构建支撑业务的行业应用和平台，以便支持各种各样的商业应用场景。Fabric是超级账本中的一个项目,为商业区块链应用提供底层支持.Fabric是由IBM、数字资产和Blockstream等三家公司的代码整合而成.

准备工作

1. 环境准备(Ubuntu)

   a. 安装go的开发环境 
   b. 安装git工具及环境配置 
   c. 利用git下载Fabric源码. 
       git clone https://github.com/hyperledger/fabric.git (最好下载在go配置路径的src文件夹下)

2. 技能准备

   2.1 Fabric项目主要是使用go语言进行编写,所有需要具备go语言的基础知识.

   a.基本的go语法知识. 
   b.go的并发知识. 
   c.一定的项目架构的设计模式思想

   2.2 通过Fabric项目部署的peer网络节点间的数据交互是属于不同的service(进程)间的通信,使用的是gRPC(谷歌的远程过程调用协议).所以需要掌握gRPC的基本用法和知识.而交互的数据格式使用的是 Protocol Buffers.

阅读方式-HOW

step 1 了解Fabric项目下的各个模块包的作用,Fabric源码项目是由不同的模块包组成的,了解各个模块包的作用有助于快速查找到你需要阅读的源码类.模块和包划分可参考http://qukuaiwang.com.cn/news/722.html. Fabric项目主要有三大模块peer和Order和fabric-ca,其中fabric-ca模块需要另外下源码.本文讨论的是Fabric的源码,只包括peer和Order两个模块.其他的Fabric源码中的不同的包都是为这两个模块服务.

step 2选定你要阅读和理解的模块部分. 

图中peer和o-service的属于Fabric源码中的模块内容.

---

step 3 模块的源码阅读(举例说明) 
注意:Docker部署Fabric网络需要的镜像是通过编译Fabric的源码的模块部分而来的,比如说,Fabric网络中的Peer镜像是通过make Peer模块的源码而来的. 
eg如果选定的是阅读Order模块的源码,需要对照利用Order模块的源码编译生成的Order Docker镜像来启动的Order容器.

3.1下图是fabric部署的网络节点启动的docker容器展示图.—–图中可以看到最后一个容器启动的信息启动的是Order容器,启动时候运行的命令是"orderer",容器服务开放的端口是7050端口,用于gRPC服务通信. 

3.2 进入到Fabric源码目录的文件夹,找到main.go入口文件. 

3.3 main.go入口文件的代码理解

说明main.go文件中的第三方包 
kingpin - 一个Go(golang)命令行和flag解析器支持子命令.

//命令变量的的初始化,app
var (
    app = kingpin.New("orderer", "Hyperledger Fabric orderer node")
    start   = app.Command("start", "Start the orderer node").Default()
    version = app.Command("version", "Show version information")
)
//入口函数main
func main() {
 //开始解析命令kingpin
    switch kingpin.MustParse(app.Parse(os.Args[1:])) {
    // "start" command
    case start.FullCommand():
        logger.Infof("Starting %s", metadata.GetVersionInfo())
        conf := config.Load()
        initializeLoggingLevel(conf)
        initializeProfilingService(conf)
        grpcServer := initializeGrpcServer(conf)//初始化gPRC服务配置
        initializeLocalMsp(conf)
        signer := localmsp.NewSigner()
        manager := initializeMultiChainManager(conf, signer)
        server := NewServer(manager, signer)
        ab.RegisterAtomicBroadcastServer(grpcServer.Server(), server)
        logger.Info("Beginning to serve requests")
        grpcServer.Start()//启动服务
    // "version" command
    case version.FullCommand():
        fmt.Println(metadata.GetVersionInfo())
    }

}

• 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
• 30

1.Order的Docker容器运行起来的时候初始化命令是”orderer”,而初始化命令参数flag默认的是”start”,start = app.Command("start", "Start the orderer node").Default() 
2.解析命令是switch的是”start” command,运行的是start.FullCommand()分支下的代码,执行的是一些初始化的操作,接下来就可以具体查看Order模块的源码初始化的细节.

参考链接

Protocol Buffers的学习笔记 

gRPC学习笔记

2.。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

源码的编译-Why? 
Fabric源码的编译是建立在已经基本掌握了Fabric的部分模块或者很多模块的代码的基础上.但是为什么要编译Fabric的源码呢,大神们不是已经写好了Fabric这个项目框架并编译好了吗,拿来用不就好了吗?

1.部署Fabric网络的docker容器是通过编译Fabric里的peer/Order/fabric-ca/模块的代码形docker镜像创建的.固有的已编译好的镜像让我们要开发的系统也禁锢住了,每个要开发的应用系统都有自身的特点,我们需要通过编译Fabric的改写的模块代码生成应用系统所需要的镜像.比如说,阿里通过基于OpenJDK定制的TaobaoVM,也是自身编译的软件开发包. 
2.编译Fabric源码可以验证自己的想法,当阅读Fabric源码时候,代码如何的运行只是通过我们理论上的猜想,通过实际的编译代码可以验证我们的猜想. 
3.定位错误,修改bug.源码的编译是建立在Fabric的源码的阅读上的,当系统运行的日志里出现错误时,根据错误提示能定位到源码中的错误点,根据源码能修改bug.

准备工作

1.编译环境的安装,go的安装,Fabric的源码下载,在Fabric的源码的阅读一篇中讲述了. 
2.安装其他必要的组件.

假设GOPATH为/home/gopath该文件夹下有两个文件夹:src用于存放Fabric源码.bin用于存放go编译好的可执行文件. 
2.1安装go的包管理工具gopm. 
export GOPATH=/home/gopath 
go get -u github.com/gpmgo/gopm 
/home/gopath/bin目录下将有gopm,go get是下载和编译的意思 
2.2通过 gopm安装 goimports.(go代码格式化工具,自动修正import的package) 
export GOPATH=/home/gopath 
gopm get -g -d golang.org/x/tools/cmd/goimports 
再使用 go install 安装 goimports 
go install golang.org/x/tools/cmd/goimports 
/home/gopath/bin目录下将有goimports 
2.3安装 gocov(go的单元测试覆盖率检查工具) 
GOPATH=/home/gopath 
gopm get -g -d golang.org/x/tools/cover 
gopm get -g -d github.com/axw/gocov/gocov 
go install github.com/axw/gocov/gocov 
/home/gopath/bin目录下将有gocov 
2.4安装 gocov-xml 
GOPATH=/home/gopath 
gopm get -g -d github.com/AlekSi/gocov-xml 
go install github.com/AlekSi/gocov-xml 
/home/gopath/bin目录下将有 gocov-xml 
2.5安装其他组件 
yum install -y gcc libtool libltdl-dev libtool-ltdl-devel openssl

3.Makefile文件的语法理解. 
Fabric的源码镜像是通过make按照Makefile中文件的编译规则来编译镜像的.

简要介绍Makefile的语法规则. 
3.1 Makefile文件的一般形式. 
target ... : prerequisites ... 
command 
... 
... 
其中…表示多个. 
target是一个目标文件，可以是Object File，也可以是执行文件。也可以是一个标签（Label），make就不会自动去找lable后的文件的依赖性，也就不会自动执行其后所定义的命令。 需要明确使用make Label。才会执行命令。 
prerequisites是要生成target所需要的文件或是目标。 
command也就是make需要执行的命令。（任意的Shell命令） 
说明,上面的一般形式是一个文件的依赖关系.target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。特别的，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。 
3.2依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。 
3.3伪目标使用方法的终端编译命令是make lable,避免当前文件夹下也有文件叫lable。 
伪目标eg: 
.PHONY lable.PHONY避免同名 
lable: 
rm *.o 

终端使用make labe,执行的操作是删除所有的.o文件. 
一般形式的eg : 
main.o : main.c defs.h 
cc -c main.c 
#make最后生成 main.o文件依赖于main.c defs.h两个文件,cc -c main.c执行可执行文件main.c进行编译. 

3.4 Makefile中的第一个目标会被作为其默认目标。

How

1.进入Fabric源码目录/home/gopath/src/hyperledger/fabric.并添加gopath的环境变量,一定要加. 
export GOPATH= /home/gopath 
sudo su 

2.编译生成 protoc-gen-go 
cd $GOPATH 
gopm get -g -d github.com/golang/protobuf/protoc-gen-go 
go install github.com/golang/protobuf/protoc-gen-go 
# /home/gopath/bin出现protoc-gen-go执行文件 
3.根据Fabric源码目录下的Makefile文件中的说明.在源码目录下打开终端,根据下图1中方框的targets伪目标,选择你要编译的target,执行命令make peer/all/orderer... 
 
执行make命令后会在当前文件夹下生成一个build文件夹.编译后的镜像或者可运行工具都是在这个文件夹里找.

编译peer模块的代码示例

说明:peer网络节点启动时运行的命令是peer node start,实际上Fabric网络节点的peer docker容器中执行的便是通过Fabric源码编译的peer可执行文件来操作peer下的命令.本例中在peer节点下通过修改代码并编译来添加test命令. 
1.在/home/gopath/src/hyperledger/fabric/peer下添加test包.并在test包下创建test.go文件.

package test
import (
    "github.com/hyperledger/fabric/common/flogging"
    "github.com/spf13/cobra"
)
var logger = flogging.MustGetLogger("testCommand")
func Cmd() *cobra.Command {
    return testCommond
}
var testCommond = &cobra.Command{
    Use:   "test",
    Short: "test the node.",
    Long:  `test a node that interacts with the network.`,
    Run: func(cmd *cobra.Command, args []string) {
        logger.Info("Build test by JinaWenJun----------------------")
    },
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

2.在/home/gopath/src/hyperledger/fabric/peer下的main.go文件中添加

    mainCmd.AddCommand(version.Cmd())
    mainCmd.AddCommand(node.Cmd())
    mainCmd.AddCommand(chaincode.Cmd(nil))
    mainCmd.AddCommand(clilogging.Cmd(nil))
    mainCmd.AddCommand(channel.Cmd(nil))
    //添加的另外一个test命令,并在前面导入包"github.com/hyperledger/fabric/peer/test"
    mainCmd.AddCommand(test.Cmd())

• 1
• 2
• 3
• 4
• 5
• 6
• 7

3.在源码目录下打开终端进行编译 make peer,在/home/gopath/src/hyperledger/fabric/build/bin下将会生成可执行文件peer.将该文件拷贝到/home/gopath/bin下测试新添加的test 命令.(模拟在peer docker的容器下peer命令的执行). 
4.打开终端,执行peer test 

遇到的问题解决方案

1.终端执行make 命令时,出现没有那个文件或目录如图, 

方法:需要在终端下添加环境变量,执行export GOPATH= /home/gopath

2.当因为网速终端卡住时,需要将Makefile文件中的curl部分删除.手动下载相应的文件chaintool目录/build/bin下面. 
 
3.当出现文件找不到或者命令找不到,如图 

方法:终端执行下面两条命令,将命令复制进去 
cp $GOPATH/bin/protoc-gen-go $GOPATH/src/github.com/hyperledger/fabric/build/docker/gotools/bin/ 

cp $GOPATH/bin/gocov $GOPATH/src/github.com/hyperledger/fabric/build/docker/gotools/bin/

4.当终端make peer出现下图错误时候. 

方法:根据错误提示core/chaincode/ccproviderimpl.go:20:2:不能找到context.进入到相应的文件ccproviderimpl.go修改. 
 
如果在出现提示哪里不能找到”context”到指定的文件下按照上述形式修改即可. 
编译成功: 
相应的 build/bin/文件夹下有peer可执行文件