Fabric源码阅读与编译

深碍√TFBOYSˉ_ 2022-05-30 12:17 240阅读 0赞

#### 前言 ####

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

#### 准备工作 ####

1.  环境准备(Ubuntu)
    
    > a. [安装go的开发环境][go]  
    > b. [安装git工具及环境配置][git]  
    > c. 利用git下载Fabric源码.  
    > git clone [https://github.com/hyperledger/fabric.git][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的基本用法和知识][gRPC].而交互的数据格式使用的是 [Protocol Buffers][].

#### 阅读方式-HOW ####

> step 1 了解Fabric项目下的各个模块包的作用,Fabric源码项目是由不同的模块包组成的,了解各个模块包的作用有助于快速查找到你需要阅读的源码类.模块和包划分可参考[http://qukuaiwang.com.cn/news/722.html][http_qukuaiwang.com.cn_news_722.html]. Fabric项目主要有三大模块peer和Order和fabric-ca,其中fabric-ca模块需要另外下[源码][Link 1].本文讨论的是Fabric的源码,只包括peer和Order两个模块.其他的Fabric源码中的不同的包都是为这两个模块服务.
> 
> step 2选定你要阅读和理解的模块部分.  
> ![这里写图片描述][SouthEast]  
> 图中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服务通信.`  
![这里写图片描述][SouthEast 1]  
3.2 进入到Fabric源码目录的文件夹,找到main.go入口文件.  
![这里写图片描述][SouthEast 2]

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的学习笔记][Protocol Buffers]

[gRPC学习笔记][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的源码的阅读][Fabric]上的,当系统运行的日志里出现错误时,根据错误提示能定位到源码中的错误点,根据源码能修改bug.

#### 准备工作 ####

1.编译环境的安装,go的安装,Fabric的源码下载,在[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...`  
![这里写图片描述][SouthEast 3]  
`执行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`  
![这里写图片描述][SouthEast 4]

#### 遇到的问题解决方案 ####

1.终端执行make 命令时,出现没有那个文件或目录如图,  
![这里写图片描述][SouthEast 5]  
方法:需要在终端下添加环境变量,执行`export GOPATH= /home/gopath`

2.当因为网速终端卡住时,需要将Makefile文件中的curl部分删除.手动下载相应的文件[chaintool][]目录/build/bin下面.  
![chaintool][chaintool 1]  
3.当出现文件找不到或者命令找不到,如图  
![这里写图片描述][SouthEast 6]  
方法:终端执行下面两条命令,将命令复制进去  
`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出现下图错误时候.  
![这里写图片描述][SouthEast 7]  
方法:根据错误提示`core/chaincode/ccproviderimpl.go:20:2:`不能找到context.进入到相应的文件ccproviderimpl.go修改.  
![这里写图片描述][SouthEast 8]  
如果在出现提示哪里不能找到”context”到指定的文件下按照上述形式修改即可.  
`编译成功:`  
![这里写图片描述][SouthEast 9]相应的 build/bin/文件夹下有peer可执行文件

[go]: http://www.cnblogs.com/kluan/p/6027490.html
[git]: http://blog.csdn.net/u011570979/article/details/23124923
[https_github.com_hyperledger_fabric.git]: https://github.com/hyperledger/fabric.git
[gRPC]: http://blog.csdn.net/u014732537/article/details/78145331
[Protocol Buffers]: http://blog.csdn.net/u014732537/article/details/78145322
[http_qukuaiwang.com.cn_news_722.html]: http://qukuaiwang.com.cn/news/722.html
[Link 1]: https://github.com/hyperledger/fabric-ca.git
[SouthEast]: /images/20220530/b9931e2dba7446fbbebce262e2b665f5.png
[SouthEast 1]: /images/20220530/18a57db139054f29b1be81816b481b81.png
[SouthEast 2]: /images/20220530/bc77a92f4ab94bd1ad736267eedf1c50.png
[Fabric]: http://blog.csdn.net/u014732537/article/details/78157210
[SouthEast 3]: /images/20220530/4b16290af4e94d699365a8ee8b8d1c85.png
[SouthEast 4]: /images/20220530/b3298f1ef24a47cd8314a1c8061b2d7d.png
[SouthEast 5]: /images/20220530/a394f9a32f2949e6826b45cd34a770d4.png
[chaintool]: http://download.csdn.net/download/u014732537/10010177
[chaintool 1]: /images/20220530/57dbadf18d364480b10a440426d0b887.png
[SouthEast 6]: /images/20220530/75603bd960204ae39ceccedf606c04b8.png
[SouthEast 7]: /images/20220530/609527b502264c7ea4f9e322f7ccb3ef.png
[SouthEast 8]: /images/20220530/e2e73c1abd3f4bf594618c71a35eacc2.png
[SouthEast 9]: /images/20220530/9598cc0192ff4aaa81a55d4f788a6290.png