bw.registrar.newChain(newChannelConfig) in WriteConfigBlock

[yfhk]

// WriteConfigBlock should be invoked for blocks which contain a config transaction. // This call will block until the new config has taken effect, then will return // while the block is written asynchronously to disk. func (bw BlockWriter) WriteConfigBlock(block cb.Block, encodedMetadataValue []byte) { ctx, err := utils.ExtractEnvelope(block, 0) if err != nil { logger.Panicf("Told to write a config block, but could not get configtx: %s", err) }

payload, err := utils.UnmarshalPayload(ctx.Payload)
if err != nil {
    logger.Panicf("Told to write a config block, but configtx payload is invalid: %s", err)
}

if payload.Header == nil {
    logger.Panicf("Told to write a config block, but configtx payload header is missing")
}

chdr, err := utils.UnmarshalChannelHeader(payload.Header.ChannelHeader)
if err != nil {
    logger.Panicf("Told to write a config block with an invalid channel header: %s", err)
}

switch chdr.Type {
case int32(cb.HeaderType_ORDERER_TRANSACTION):
    newChannelConfig, err := utils.UnmarshalEnvelope(payload.Data)
    if err != nil {
        logger.Panicf("Told to write a config block with new channel, but did not have config update embedded: %s", err)
    }
    bw.registrar.newChain(newChannelConfig)
case int32(cb.HeaderType_CONFIG):
    configEnvelope, err := configtx.UnmarshalConfigEnvelope(payload.Data)
    if err != nil {
        logger.Panicf("Told to write a config block with new channel, but did not have config envelope encoded: %s", err)
    }

    err = bw.support.Validate(configEnvelope)
    if err != nil {
        logger.Panicf("Told to write a config block with new config, but could not apply it: %s", err)
    }

    bundle, err := bw.support.CreateBundle(chdr.ChannelId, configEnvelope.Config)
    if err != nil {
        logger.Panicf("Told to write a config block with a new config, but could not convert it to a bundle: %s", err)
    }

    bw.support.Update(bundle)
default:
    logger.Panicf("Told to write a config block with unknown header type: %v", chdr.Type)
}

bw.WriteBlock(block, encodedMetadataValue)

}

[yfhk]

func (r Registrar) newChain(configtx cb.Envelope) { ledgerResources := r.newLedgerResources(configtx) ledgerResources.Append(blockledger.CreateNextBlock(ledgerResources, []*cb.Envelope{configtx}))

// Copy the map to allow concurrent reads from broadcast/deliver while the new chainSupport is
newChains := make(map[string]*ChainSupport)
for key, value := range r.chains {
    newChains[key] = value
}

cs := newChainSupport(r, ledgerResources, r.consenters, r.signer)
chainID := ledgerResources.ConfigtxValidator().ChainID()

logger.Infof("Created and starting new chain %s", chainID)

newChains[string(chainID)] = cs
cs.start()

r.chains = newChains

}