经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 其他 » 区块链 » 查看文章
Fabric1.4源码解析:客户端创建通道过程
来源:cnblogs  作者:触不可及`  时间:2019/7/2 8:42:27  对本文有异议

在使用Fabric创建通道的时候,通常我们执行一条命令完成,这篇文章就解析一下执行这条命令后Fabric源码中执行的流程。

  1. peer channel create -o orderer.example.com:7050 -c mychannel -f ./channel-artifacts/channel.tx --tls true --cafile $ORDERER_CA

整个流程的切入点在fabric/peer/main.go文件中的main()方法 (本文中使用的是Fabric1.4版本,不同版本中内容可能不同)。这个方法中也定义了Peer节点可以执行的命令,有关于版本的:version.Cmd(),关于节点状态的:node.Cmd(),关于链码的:chaincode.Cmd(nil),关于客户端日志的:clilogging.Cmd(nil),最后一个就是关于通道的:channel.Cmd(nil)。所以我们就从这里入手,看一下创建通道的整体流程是什么样的。
点进行后,转到了peer/channel/channel.go文件中第49行,其中定义了Peer节点可以执行的对通道进行操作的相关命令:

  1. func Cmd(cf *ChannelCmdFactory) *cobra.Command {
  2. AddFlags(channelCmd)
  3. #创建通道
  4. channelCmd.AddCommand(createCmd(cf))
  5. #从通道获取区块
  6. channelCmd.AddCommand(fetchCmd(cf))
  7. #加入通道
  8. channelCmd.AddCommand(joinCmd(cf))
  9. #列出当前节点所加入的通道
  10. channelCmd.AddCommand(listCmd(cf))
  11. #签名并更新通道配置信息
  12. channelCmd.AddCommand(updateCmd(cf))
  13. #只对通道配置信息进行签名
  14. channelCmd.AddCommand(signconfigtxCmd(cf))
  15. #获取通道信息
  16. channelCmd.AddCommand(getinfoCmd(cf))
  17. return channelCmd
  18. }

具体的Peer节点命令使用方法可以参考Fabric官方文档,这里不在一一解释。
我们看一下createCmd(cf)方法,该方法转到了peer/channel/create.go文件中第51行,看文件名字就知道和创建通道相关了。

  1. func createCmd(cf *ChannelCmdFactory) *cobra.Command {
  2. createCmd := &cobra.Command{
  3. Use: "create", #使用create关键词创建通道
  4. Short: "Create a channel",
  5. Long: "Create a channel and write the genesis block to a file.", #创建通道并将创世区块写入文件
  6. RunE: func(cmd *cobra.Command, args []string) error {
  7. #这一行命令就是对通道进行创建了,点进行看一下
  8. return create(cmd, args, cf)
  9. },
  10. }
  11. ...
  12. }

create(cmd, args, cf)方法在本文件中第227行:

  1. func create(cmd *cobra.Command, args []string, cf *ChannelCmdFactory) error {
  2. // the global chainID filled by the "-c" command
  3. #官方注释用-c来表明通道ID
  4. if channelID == common.UndefinedParamValue {
  5. #UndefinedParamValue="",如果通道ID等于空
  6. return errors.New("must supply channel ID")
  7. }
  8. // Parsing of the command line is done so silence cmd usage
  9. cmd.SilenceUsage = true
  10. var err error
  11. if cf == nil {
  12. #如果ChannelCmdFactory为空,则初始化一个
  13. cf, err = InitCmdFactory(EndorserNotRequired, PeerDeliverNotRequired, OrdererRequired)
  14. if err != nil {
  15. return err
  16. }
  17. }
  18. #最后将ChannelCmdFactory传入该方法,进行通道的创建
  19. return executeCreate(cf)
  20. }

首先看一下InitCmdFactory()做了哪些工作,在peer/channel/channel.go文件中第126行:

  1. func InitCmdFactory(isEndorserRequired, isPeerDeliverRequired, isOrdererRequired bool) (*ChannelCmdFactory, error) {
  2. #这里的意思就是只能有一个交付源,要么是Peer要么是Orderer
  3. if isPeerDeliverRequired && isOrdererRequired {
  4. return nil, errors.New("ERROR - only a single deliver source is currently supported")
  5. }
  6. var err error
  7. #初始化ChannelCmdFactory,看一下该结构体的内容
  8. cf := &ChannelCmdFactory{}

直接拿到这里来好了:

  1. type ChannelCmdFactory struct {
  2. #用于背书的客户端
  3. EndorserClient pb.EndorserClient
  4. #签名者
  5. Signer msp.SigningIdentity
  6. #用于广播的客户端
  7. BroadcastClient common.BroadcastClient
  8. #用于交付的客户端
  9. DeliverClient deliverClientIntf
  10. #创建用于广播的客户端的工厂
  11. BroadcastFactory BroadcastClientFactory
  12. }

再往下看:

  1. #获取默认的签名者,通常是Peer节点
  2. cf.Signer, err = common.GetDefaultSignerFnc()
  3. if err != nil {
  4. return nil, errors.WithMessage(err, "error getting default signer")
  5. }
  6. cf.BroadcastFactory = func() (common.BroadcastClient, error) {
  7. #根据ChannelCmdFactory结构体中的BroadcastFactory获取BroadcastClient
  8. return common.GetBroadcastClientFnc()
  9. }
  10. // for join and list, we need the endorser as well
  11. #我们这里是完成对通道的创建,所以只使用了最后一个isOrdererRequired
  12. if isEndorserRequired {
  13. #创建一个用于背书的客户端
  14. cf.EndorserClient, err = common.GetEndorserClientFnc(common.UndefinedParamValue, common.UndefinedParamValue)
  15. if err != nil {
  16. return nil, errors.WithMessage(err, "error getting endorser client for channel")
  17. }
  18. }
  19. // for fetching blocks from a peer
  20. if isPeerDeliverRequired {
  21. #从Peer节点创建一个用于交付的客户端
  22. cf.DeliverClient, err = common.NewDeliverClientForPeer(channelID, bestEffort)
  23. if err != nil {
  24. return nil, errors.WithMessage(err, "error getting deliver client for channel")
  25. }
  26. }
  27. // for create and fetch, we need the orderer as well
  28. if isOrdererRequired {
  29. if len(strings.Split(common.OrderingEndpoint, ":")) != 2 {
  30. return nil, errors.Errorf("ordering service endpoint %s is not valid or missing", common.OrderingEndpoint)
  31. }
  32. #从Order节点创建一个一个用于交付的客户端
  33. cf.DeliverClient, err = common.NewDeliverClientForOrderer(channelID, bestEffort)
  34. if err != nil {
  35. return nil, err
  36. }
  37. }
  38. logger.Infof("Endorser and orderer connections initialized")
  39. return cf, nil
  40. }

返回create()方法:

  1. #到了最后一行代码,传入之前创建的ChannelCmdFactory,开始进行通道的创建
  2. return executeCreate(cf)

该方法在peer/channel/create.go文件中的第174行:

  1. #方法比较清晰,一共完成了以下几个步骤
  2. func executeCreate(cf *ChannelCmdFactory) error {
  3. #发送创建通道的Transaction到Order节点
  4. err := sendCreateChainTransaction(cf)
  5. if err != nil {
  6. return err
  7. }
  8. #获取该通道内的创世区块(该过程在Order节点共识完成之后)
  9. block, err := getGenesisBlock(cf)
  10. if err != nil {
  11. return err
  12. }
  13. #序列化区块信息
  14. b, err := proto.Marshal(block)
  15. if err != nil {
  16. return err
  17. }
  18. file := channelID + ".block"
  19. if outputBlock != common.UndefinedParamValue {
  20. file = outputBlock
  21. }
  22. #将区块信息写入本地文件中
  23. err = ioutil.WriteFile(file, b, 0644)
  24. if err != nil {
  25. return err
  26. }
  27. return nil
  28. }

1.Peer节点创建用于创建通道的Envelope文件

首先我们看一下sendCreateChainTransaction()这个方法,又回到了peer/channel/create.go文件中,在第144行:

  1. func sendCreateChainTransaction(cf *ChannelCmdFactory) error {
  2. var err error
  3. #定义了一个Envelope结构体
  4. var chCrtEnv *cb.Envelope

Envelope结构体:

  1. type Envelope struct {
  2. #主要就是保存被序列化的有效载荷
  3. Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
  4. #由创建者进行的签名信息
  5. Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
  6. XXX_NoUnkeyedLiteral struct{} `json:"-"`
  7. XXX_unrecognized []byte `json:"-"`
  8. XXX_sizecache int32 `json:"-"`
  9. }

回到sendCreateChainTransaction()这个方法,继续往下:

  1. if channelTxFile != "" {
  2. #如果指定了channelTxFile,则使用指定的文件创建通道,这个方法很简单,从文件中读取数据,反序列化后返回chCrtEnv.对于我们启动Fabric网络之前曾创建过一个channel.tx文件,指的就是这个
  3. if chCrtEnv, err = createChannelFromConfigTx(channelTxFile); err != nil {
  4. return err
  5. }
  6. } else {
  7. #如果没有指定,则使用默认的配置创建通道,看一下这个方法,在71行
  8. if chCrtEnv, err = createChannelFromDefaults(cf); err != nil {
  9. return err
  10. }
  11. }
  12. -------------------------------createChannelFromDefaults()-------
  13. func createChannelFromDefaults(cf *ChannelCmdFactory) (*cb.Envelope, error) {
  14. #主要就这一个方法,点进去
  15. chCrtEnv, err := encoder.MakeChannelCreationTransaction(channelID, localsigner.NewSigner(), genesisconfig.Load(genesisconfig.SampleSingleMSPChannelProfile))
  16. if err != nil {
  17. return nil, err
  18. }
  19. return chCrtEnv, nil
  20. }

MakeChannelCreationTransaction()方法传入了通道的ID,并创建了一个签名者,以及默认的配置文件,方法在common/tools/configtxgen/encoder/encoder.go文件中第502行:

  1. func MakeChannelCreationTransaction(channelID string, signer crypto.LocalSigner, conf *genesisconfig.Profile) (*cb.Envelope, error) {
  2. #从名字可以看到是使用了默认的配置模板,对各种策略进行配置,里面就不再细看了
  3. template, err := DefaultConfigTemplate(conf)
  4. if err != nil {
  5. return nil, errors.WithMessage(err, "could not generate default config template")
  6. }
  7. #看一下这个方法,从模板中创建一个用于创建通道的Transaction
  8. return MakeChannelCreationTransactionFromTemplate(channelID, signer, conf, template)
  9. }

MakeChannelCreationTransactionFromTemplate()方法在第530行:

  1. func MakeChannelCreationTransactionFromTemplate(channelID string, signer crypto.LocalSigner, conf *genesisconfig.Profile, template *cb.ConfigGroup) (*cb.Envelope, error) {
  2. newChannelConfigUpdate, err := NewChannelCreateConfigUpdate(channelID, conf, template)
  3. ...
  4. #创建一个用于配置更新的结构体
  5. newConfigUpdateEnv := &cb.ConfigUpdateEnvelope{
  6. ConfigUpdate: utils.MarshalOrPanic(newChannelConfigUpdate),
  7. }
  8. if signer != nil {
  9. #如果签名者不为空,创建签名Header
  10. sigHeader, err := signer.NewSignatureHeader()
  11. ...
  12. newConfigUpdateEnv.Signatures = []*cb.ConfigSignature{{
  13. SignatureHeader: utils.MarshalOrPanic(sigHeader),
  14. }}
  15. ...
  16. #进行签名
  17. newConfigUpdateEnv.Signatures[0].Signature, err = signer.Sign(util.ConcatenateBytes(newConfigUpdateEnv.Signatures[0].SignatureHeader, newConfigUpdateEnv.ConfigUpdate))
  18. ...
  19. }
  20. #创建被签名的Envelope,然后一直返回到最外面的方法
  21. return utils.CreateSignedEnvelope(cb.HeaderType_CONFIG_UPDATE, channelID, signer, newConfigUpdateEnv, msgVersion, epoch)
  22. }

到这里,用于创建通道的Envelope已经创建好了,sendCreateChainTransaction()继续往下看:

  1. ...
  2. #该方法主要是对刚刚创建的Envelope进行验证
  3. if chCrtEnv, err = sanityCheckAndSignConfigTx(chCrtEnv); err != nil {
  4. return err
  5. }
  6. var broadcastClient common.BroadcastClient
  7. #验证完成后,创建一个用于广播信息的客户端
  8. broadcastClient, err = cf.BroadcastFactory()
  9. if err != nil {
  10. return errors.WithMessage(err, "error getting broadcast client")
  11. }
  12. defer broadcastClient.Close()
  13. #将创建通道的Envelope信息广播出去
  14. err = broadcastClient.Send(chCrtEnv)
  15. return err
  16. }

到这里,sendCreateChainTransaction()方法结束了,总结一下该方法所做的工作:

  1. 定义了个Envelope结构体
  2. 判断channelTxFile文件(启动网络之前创建的channel.tx)是否存在,一般都是存在的。
  3. 如果存在的话从该文件中读取配置信息,不存在的话从默认的模板创建,最后返回Envelope
  4. 对Envelope文件进行验证
  5. 创建用于广播信息的客户端,将创建的Envelope文件广播出去.

2 Order节点对Envelope文件处理

至于获取创世区块以及将文件保存到本地不再说明,接下来我们看一下Peer节点将创建通道的Envelope广播出去后,Order节点做了什么。
方法在/order/common/server/server.go中第141行:

  1. func (s *server) Broadcast(srv ab.AtomicBroadcast_BroadcastServer) error {
  2. ...
  3. #主要在这一行代码,Handle方法对接收到的信息进行处理
  4. return s.bh.Handle(&broadcastMsgTracer{
  5. AtomicBroadcast_BroadcastServer: srv,
  6. msgTracer: msgTracer{
  7. debug: s.debug,
  8. function: "Broadcast",
  9. },
  10. })
  11. }

对于Handler()方法,在/order/common/broadcast/broadcast.go文件中第66行:

  1. func (bh *Handler) Handle(srv ab.AtomicBroadcast_BroadcastServer) error {
  2. #首先获取消息的源地址
  3. addr := util.ExtractRemoteAddress(srv.Context())
  4. ...
  5. for {
  6. #接收消息
  7. msg, err := srv.Recv()
  8. ...
  9. #处理接收到的消息,我们看一下这个方法
  10. resp := bh.ProcessMessage(msg, addr)
  11. #最后将响应信息广播出去
  12. err = srv.Send(resp)
  13. ...
  14. }
  15. }

ProcessMessage(msg, addr)方法的传入参数为接收到的消息以及消息的源地址,该方法比较重要,是Order节点对消息进行处理的主方法。在第136行:

  1. func (bh *Handler) ProcessMessage(msg *cb.Envelope, addr string) (resp *ab.BroadcastResponse) {
  2. #这个结构体应该理解为记录器,记录消息的相关信息
  3. tracker := &MetricsTracker{
  4. ChannelID: "unknown",
  5. TxType: "unknown",
  6. Metrics: bh.Metrics,
  7. }
  8. defer func() {
  9. // This looks a little unnecessary, but if done directly as
  10. // a defer, resp gets the (always nil) current state of resp
  11. // and not the return value
  12. tracker.Record(resp)
  13. }()
  14. #记录处理消息的开始时间
  15. tracker.BeginValidate()
  16. #该方法获取接收到的消息的Header,并判断是否为配置信息
  17. chdr, isConfig, processor, err := bh.SupportRegistrar.BroadcastChannelSupport(msg)
  18. ...
  19. #由于之前Peer节点发送的为创建通道的信息,所以消息类型为配置信息
  20. if !isConfig {
  21. ...
  22. #而对于普通的交易信息的处理方法这里就不再看了,主要关注于创建通道的消息的处理
  23. } else { // isConfig
  24. logger.Debugf("[channel: %s] Broadcast is processing config update message from %s", chdr.ChannelId, addr)
  25. #到了这里,对配置更新消息进行处理,主要方法,点进行看一下
  26. config, configSeq, err := processor.ProcessConfigUpdateMsg(msg)

ProcessConfigUpdateMsg(msg)方法在orderer/common/msgprocessor/systemchannel.go文件中第84行:

  1. #这个地方有些不懂,为什么会调用systemchannel.ProcessConfigUpdateMsg()而不是standardchannel.ProcessConfigUpdateMsg()方法?是因为这个结构体的原因?
  2. ===========================SystemChannel=======================
  3. type SystemChannel struct {
  4. *StandardChannel
  5. templator ChannelConfigTemplator
  6. }
  7. ===========================SystemChannel=======================
  8. func (s *SystemChannel) ProcessConfigUpdateMsg(envConfigUpdate *cb.Envelope) (config *cb.Envelope, configSeq uint64, err error) {
  9. #首先从消息体中获取通道ID
  10. channelID, err := utils.ChannelID(envConfigUpdate)
  11. ...
  12. #判断获取到的通道ID是否为已经存在的用户通道ID,如果是的话转到StandardChannel中的ProcessConfigUpdateMsg()方法进行处理
  13. if channelID == s.support.ChainID() {
  14. return s.StandardChannel.ProcessConfigUpdateMsg(envConfigUpdate)
  15. }
  16. ...
  17. #由于之前由Peer节点发送的为创建通道的Tx,所以对于通道ID是不存在的,因此到了这个方法,点进行看一下
  18. bundle, err := s.templator.NewChannelConfig(envConfigUpdate)

NewChannelConfig()方法在第215行,比较重要的方法,完成通道的配置:

  1. func (dt *DefaultTemplator) NewChannelConfig(envConfigUpdate *cb.Envelope) (channelconfig.Resources, error) {
  2. #首先反序列化有效载荷
  3. configUpdatePayload, err := utils.UnmarshalPayload(envConfigUpdate.Payload)
  4. ...
  5. #反序列化配置更新信息Envelope
  6. configUpdateEnv, err := configtx.UnmarshalConfigUpdateEnvelope(configUpdatePayload.Data)s
  7. ...
  8. #获取通道头信息
  9. channelHeader, err := utils.UnmarshalChannelHeader(configUpdatePayload.Header.ChannelHeader)
  10. ...
  11. #反序列化配置更新信息
  12. configUpdate, err := configtx.UnmarshalConfigUpdate(configUpdateEnv.ConfigUpdate)
  13. ...
  14. #以下具体的不再说了,就是根据之前定义的各项策略对通道进行配置,具体的策略可以看configtx.yaml文件
  15. consortiumConfigValue, ok := configUpdate.WriteSet.Values[channelconfig.ConsortiumKey]
  16. ...
  17. consortium := &cb.Consortium{}
  18. err = proto.Unmarshal(consortiumConfigValue.Value, consortium)
  19. ...
  20. applicationGroup := cb.NewConfigGroup()
  21. consortiumsConfig, ok := dt.support.ConsortiumsConfig()
  22. ...
  23. consortiumConf, ok := consortiumsConfig.Consortiums()[consortium.Name]
  24. ...
  25. applicationGroup.Policies[channelconfig.ChannelCreationPolicyKey] = &cb.ConfigPolicy{
  26. Policy: consortiumConf.ChannelCreationPolicy(),
  27. }
  28. applicationGroup.ModPolicy = channelconfig.ChannelCreationPolicyKey
  29. #获取当前系统通道配置信息
  30. systemChannelGroup := dt.support.ConfigtxValidator().ConfigProto().ChannelGroup
  31. if len(systemChannelGroup.Groups[channelconfig.ConsortiumsGroupKey].Groups[consortium.Name].Groups) > 0 &&
  32. len(configUpdate.WriteSet.Groups[channelconfig.ApplicationGroupKey].Groups) == 0 {
  33. return nil, fmt.Errorf("Proposed configuration has no application group members, but consortium contains members")
  34. }
  35. if len(systemChannelGroup.Groups[channelconfig.ConsortiumsGroupKey].Groups[consortium.Name].Groups) > 0 {
  36. for orgName := range configUpdate.WriteSet.Groups[channelconfig.ApplicationGroupKey].Groups {
  37. consortiumGroup, ok := systemChannelGroup.Groups[channelconfig.ConsortiumsGroupKey].Groups[consortium.Name].Groups[orgName]
  38. if !ok {
  39. return nil, fmt.Errorf("Attempted to include a member which is not in the consortium")
  40. }
  41. applicationGroup.Groups[orgName] = proto.Clone(consortiumGroup).(*cb.ConfigGroup)
  42. }
  43. }
  44. channelGroup := cb.NewConfigGroup()
  45. #将系统通道配置信息复制
  46. for key, value := range systemChannelGroup.Values {
  47. channelGroup.Values[key] = proto.Clone(value).(*cb.ConfigValue)
  48. if key == channelconfig.ConsortiumKey {
  49. // Do not set the consortium name, we do this later
  50. continue
  51. }
  52. }
  53. for key, policy := range systemChannelGroup.Policies {
  54. channelGroup.Policies[key] = proto.Clone(policy).(*cb.ConfigPolicy)
  55. }
  56. #新的配置信息中Order组配置使用系统通道的配置,同时将定义的application组配置赋值到新的配置信息
  57. channelGroup.Groups[channelconfig.OrdererGroupKey] = proto.Clone(systemChannelGroup.Groups[channelconfig.OrdererGroupKey]).(*cb.ConfigGroup)
  58. channelGroup.Groups[channelconfig.ApplicationGroupKey] = applicationGroup
  59. channelGroup.Values[channelconfig.ConsortiumKey] = &cb.ConfigValue{
  60. Value: utils.MarshalOrPanic(channelconfig.ConsortiumValue(consortium.Name).Value()),
  61. ModPolicy: channelconfig.AdminsPolicyKey,
  62. }
  63. if oc, ok := dt.support.OrdererConfig(); ok && oc.Capabilities().PredictableChannelTemplate() {
  64. channelGroup.ModPolicy = systemChannelGroup.ModPolicy
  65. zeroVersions(channelGroup)
  66. }
  67. #将创建的新的配置打包为Bundle
  68. bundle, err := channelconfig.NewBundle(channelHeader.ChannelId, &cb.Config{
  69. ChannelGroup: channelGroup,
  70. })
  71. ...
  72. return bundle, nil
  73. }

接下来我们回到ProcessConfigUpdateMsg()方法:

  1. ...
  2. #创建一个配置验证器对该方法的传入参数进行验证操作
  3. newChannelConfigEnv, err := bundle.ConfigtxValidator().ProposeConfigUpdate(envConfigUpdate)
  4. ...
  5. #创建一个签名的Envelope,此次为Header类型为HeaderType_CONFIG进行签名
  6. newChannelEnvConfig, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG, channelID, s.support.Signer(), newChannelConfigEnv, msgVersion, epoch)
  7. #创建一个签名的Transaction,此次为Header类型为HeaderType_ORDERER_TRANSACTION进行签名
  8. wrappedOrdererTransaction, err := utils.CreateSignedEnvelope(cb.HeaderType_ORDERER_TRANSACTION, s.support.ChainID(), s.support.Signer(), newChannelEnvConfig, msgVersion, epoch)
  9. ...
  10. #过滤器进行过滤,主要检查是否创建的Transaction过大,以及签名检查,确保Order节点使用正确的证书进行签名
  11. err = s.StandardChannel.filters.Apply(wrappedOrdererTransaction)
  12. ...
  13. #将Transaction返回
  14. return wrappedOrdererTransaction, s.support.Sequence(), nil
  15. }

到这里,消息处理完毕,返回到ProcessMessage()方法:

  1. config, configSeq, err := processor.ProcessConfigUpdateMsg(msg)
  2. ...
  3. #记录消息处理完毕时间
  4. tracker.EndValidate()
  5. #开始进行入队操作
  6. tracker.BeginEnqueue()
  7. #waitReady()是一个阻塞方法,等待入队完成或出现异常
  8. if err = processor.WaitReady(); err != nil {
  9. logger.Warningf("[channel: %s] Rejecting broadcast of message from %s with SERVICE_UNAVAILABLE: rejected by Consenter: %s", chdr.ChannelId, addr, err)
  10. return &ab.BroadcastResponse{Status: cb.Status_SERVICE_UNAVAILABLE, Info: err.Error()}
  11. }
  12. #共识方法,具体看定义的Fabric网络使用了哪种共识
  13. err = processor.Configure(config, configSeq)
  14. ...
  15. #最后返回操作成功的响应
  16. return &ab.BroadcastResponse{Status: cb.Status_SUCCESS}
  17. }

到这里,由客户端发送的创建通道的Transaction就结束了。总共分为两个部分,一个是Peer节点对创建通道的Envelope进行创建的过程,一个是Order节点接收到该Envelope进行配置的过程,最后总结一下整体流程:
Peer节点方:

  1. 创建一个用于创建通道的Transaction
    1. 判断是否存在channel.tx文件,如果有的话直接从文件中读取已配置好的信息,一般都会存在
    2. 没有的话根据默认的模板进行配置
    3. 对刚创建的用于配置更新的Envelope进行相关检查包括各项数据是否为空,创建的通道是否已经存在,配置信息是否正确,以及进行签名,封装为HeaderTypeCONFIG_UPDATEEnvelope
    4. 将创建的Envelope广播出去。
  2. 生成创世区块(该步骤在Order节点成功共识之后)
  3. 将创世区块写入本地文件中

Order节点方:

  1. 接收到该Envelope信息,进行相关验证并判断是否为配置信息
  2. 判断通道Id是否已经存在,如果存在的话为配置更新信息,否则为通道创建信息
  3. Envelope中读取各项策略配置
  4. 对策略配置信息进行验证
  5. Header类型为CONFIG的Envelope进行签名
  6. Header类型为ORDERER_TRANSACTIONEnvelope进行签名生成Transaction
  7. 对生成的Transaction进行过滤,主要是Tx大小,Order节点的证书信息是否正确
  8. 进行入队操作,等待入队完成然后进行共识
  9. 广播成功响应

整个创建通道的过程也是比较长的,能力有限,所以有些地方并没有分析太清晰。不过整体还是可以把握住的。
最后附上参考文档:传送门
以及Fabric源码地址:传送门

原文链接:http://www.cnblogs.com/cbkj-xd/p/11113195.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号