詳細解析blance transfer示例的建立通道（Channel）和加入節點到通道的過程。

建立Channel

1.首先看app.js的路由函式

var createChannel = require('./app/create-channel.js');
app.post('/channels', async function(req, res) {
    // 接收引數channel名稱和配置檔案的路徑
    // 通道配置交易路徑： ./artifacts/channel/mychannel.tx
    var channelName = req.body.channelName;
    var
 
 channelConfigPath = req.body.channelConfigPath;

    if (!channelName) {
        res.json(getErrorMessage('\'channelName\''));
        return;
    }
    if (!channelConfigPath) {
        res.json(getErrorMessage('\'channelConfigPath\''));
        return;
    }
    // 建立通道(username和orgname引數從token中獲取)
 

    let message = await createChannel.createChannel(channelName, channelConfichannelNamegPath, req.username, req.orgname);
    res.send(message);
});

2.再來看create-channel.js中的createChannel()方法

// 通過傳送交易的方法向orderer節點發送建立channel的請求
var createChannel = async function(channelName, channelConfigPath, username, orgName)
 
 {
    try {
        // 生成組織的客戶端例項
        var client = await helper.getClientForOrg(orgName);

        // 從channel配置交易（mychannel.tx）讀取源位元組
        var envelope = fs.readFileSync(path.join(__dirname, channelConfigPath));
        // 提取channel配置資訊
        var channelConfig = client.extractChannelConfig(envelope);


        // 客戶端使用 組織管理員 的私鑰 簽名，作為背書（endorsement）
        // "../artifacts/channel/crypto-config/peerOrganizations/org1.example.com/users/[email protected]/msp/signcerts"

        // 在內部通過_getSigningIdentity(true)獲取org admin的私鑰 進行簽名 
        let signature = client.signChannelConfig(channelConfig);
        // 請求結構：
        let request = {
            config: channelConfig,
            signatures: [signature],
            name: channelName,
            txId: client.newTransactionID(true)
        };

        // 傳送給orderer節點
        var response = await client.createChannel(request)
        if (response && response.status === 'SUCCESS') {
            logger.debug('Successfully created the channel.');
            let response = {
                success: true,
                message: 'Channel \'' + channelName + '\' created Successfully'
            };
            return response;
        } else {
            throw new Error('Failed to create the channel \'' + channelName + '\'');
        }
    } catch (err) {
        logger.error('Failed to initialize the channel: ' + err.stack ? err.stack : err);
        throw new Error('Failed to initialize the channel: ' + err.toString());
    }
};

加入節點到Channel

1.首先看app.js裡的路由函式

// 首先看app.js中的路由函式
app.post('/channels/:channelName/peers', async function(req, res) {
    // 接收引數 channel名稱（URL中）和peers（body中）
    var channelName = req.params.channelName;
    var peers = req.body.peers;

    if (!channelName) {
        res.json(getErrorMessage('\'channelName\''));
        return;
    }
    if (!peers || peers.length == 0) {
        res.json(getErrorMessage('\'peers\''));
        return;
    }
    // 將peers加入channel
    let message =  await join.joinChannel(channelName, peers, req.username, req.orgname);
    res.send(message);
});

2.然後看join-channel.js中的joinChannel()函式

// 然後看join-channel.js中的joinChannel()函式
var joinChannel = async function(channel_name, peers, username, org_name) {
    var error_message = null;
    var all_eventhubs = [];
    try {
        // 首先建立client物件
        var client = await helper.getClientForOrg(org_name, username);
        //  生成channel物件
        var channel = client.getChannel(channel_name);
        if(!channel) {
            let message = util.format('Channel %s was not defined in the connection profile', channel_name);
            logger.error(message);
            throw new Error(message);
        }

        // 生成基於組織管理員的 TransactionID 物件
        // 該物件包含一個隨機數（nonce）以及t(nonce + signingIdentity)的hash值
        let request = {
            txId :  client.newTransactionID(true) 
        };

        // 從orderer節點獲取創世區塊（genesis block）
        let genesis_block = await channel.getGenesisBlock(request);

        // 告訴節點加入channel，等待每個節點的event hub通知我們節點加入channel成功
        var promises = [];
        var block_registration_numbers = [];
        // 給組織中的每個節點分配一個EventHub物件
        let event_hubs = client.getEventHubsForOrg(org_name);
        #event_hubs.forEach((eh) => {
            #let configBlockPromise = new Promise((resolve, reject) => {
                // 設定超時時間
                #let event_timeout = setTimeout(() => {
                    let message = 'REQUEST_TIMEOUT:' + eh._ep._endpoint.addr;
                    logger.error(message);
                    eh.disconnect();
                    reject(new Error(message));
                }, 60000);
                // 註冊區塊監聽
                #let block_registration_number = eh.registerBlockEvent((block) => {
                    clearTimeout(event_timeout);
                    // 配置區塊中只能有一個交易
                    if (block.data.data.length === 1) {
                        // 一個節點可能屬於多個channel
                        // 所以需要檢驗該區塊是否來自目標channel
                        var channel_header = block.data.data[0].payload.header.channel_header;
                        if (channel_header.channel_id === channel_name) {
                            let message = util.format('EventHub %s has reported a block update for channel %s',eh._ep._endpoint.addr,channel_name);
                            logger.info(message)
                            resolve(message);
                        } else {
                            let message = util.format('Unknown channel block event received from %s',eh._ep._endpoint.addr);
                            logger.error(message);
                            reject(new Error(message));
                        }
                    }
                }, (err) => {
                    clearTimeout(event_timeout);
                    let message = 'Problem setting up the event hub :'+ err.toString();
                    logger.error(message);
                    reject(new Error(message));
                });
                // 每一個client例項對應一個註冊number，後面將作為引數對監聽進行登出
                block_registration_numbers.push(block_registration_number);
                // 儲存EventHub物件，方便後面對事件流斷開連線
                all_eventhubs.push(eh); 
            });
            promises.push(configBlockPromise);
            // 開啟事件流
            eh.connect(); 
        });

        // 封裝加入channel的請求
        let join_request = {
            targets: peers,                             // 要加入channel的節點
            txId: client.newTransactionID(true),        // 基於組織管理員的TransactionID
            block: genesis_block                        // 創世區塊
        };
        // 呼叫SDK中的joinChannel()方法，主要是通過sendProposal()將
        // 加入channel的交易提案發送給背書節點進行背書
        let join_promise = channel.joinChannel(join_request);
        // 儲存返回結果：提案響應（ProposalResponse）的Promise
        promises.push(join_promise);
        let results = await Promise.all(promises);
        logger.debug(util.format('Join Channel RESPONSE : %j', results));

        // 檢查所有Promise返回（包括監聽事件和傳送join請求）
        // 只要有一個結果異常則宣佈join channel失敗
        let peers_results = results.pop();
        for(let i in peers_results) {
            let peer_result = peers_results[i];
            if(peer_result.response && peer_result.response.status == 200) {
                logger.info('Successfully joined peer to the channel %s',channel_name);
            } else {
                let message = util.format('Failed to joined peer to the channel %s',channel_name);
                error_message = message;
                logger.error(message);
            }
        }
        // 檢視事件中心的訊息報告
        for(let i in results) {
            let event_hub_result = results[i];
            let event_hub = event_hubs[i];
            let block_registration_number = block_registration_numbers[i];
            logger.debug('Event results for event hub :%s',event_hub._ep._endpoint.addr);
            if(typeof event_hub_result === 'string') {
                logger.debug(event_hub_result);
            } else {
                if(!error_message) error_message = event_hub_result.toString();
                logger.debug(event_hub_result.toString());
            }
            // 登出事件監聽
            event_hub.unregisterBlockEvent(block_registration_number);
        }
    } catch(error) {
        logger.error('Failed to join channel due to error: ' + error.stack ? error.stack : error);
        error_message = error.toString();
    }

    // 斷開所有event hub事件流
    all_eventhubs.forEach((eh) => {
        eh.disconnect();
    });
};

測試

• 建立channel

  curl -s -X POST \
    http://localhost:4000/channels \
    -H "authorization: Bearer $ORG1_TOKEN" \
    -H "content-type: application/json" \
    -d '{
      "channelName":"mychannel",
      "channelConfigPath":"../artifacts/channel/mychannel.tx"
  }'

• 返回結果

  {"success":true,"message":"Channel 'mychannel' created Successfully"}

• 將Org1中的兩個peer加入channel

  curl -s -X POST \
    http://localhost:4000/channels/mychannel/peers \
    -H "authorization: Bearer $ORG1_TOKEN" \
    -H "content-type: application/json" \
    -d '{
      "peers": ["peer0.org1.example.com","peer1.org1.example.com"]
  }'

• 返回結果

  {"success":true,"message":"Successfully joined peers in organization Org1 to the channel:mychannel"}

總結

建立channel：

• 生成client物件，從channel配置交易mychannel.tx中提取配置資訊
• 利用組織admin的私鑰進行簽名，這個過程相當於背書
• 封裝請求結構（包括channel配置資訊，對配置資訊的簽名，channelName，基於admin的txId), 並呼叫 clinet.createChannel()將請求傳送到orderer節點
• 實際上在內部呼叫orderer.sendBroadcast()，向order service廣播交易，orderer將配置交易打包成區塊後廣播給各記賬節點，記入賬本中。（這個配置區塊就是建立的channel所對應的chain的創世區塊）

加入channel：

• 生成client物件，生成channel物件
• 從orderer節點獲取genesis block （呼叫 orderer.sendDeliver() 介面）
• 對要加入channel的每個peer設定事件區塊監聽，根據指定channel是否生成了新的配置區塊來判斷join channel過程是否成功
• 封裝請求結構（包括 目標peers，基於組織admin的txId，genesis block），呼叫channel.joinChannel()方法，內部是通過peer.sendProposal()將該交易提案發送給背書節點進行背書，返回背書響應Promise
  客戶端將背書過的交易傳送到orderer服務，排序後廣播給記賬節點，將該配置區塊記錄到ledger中，此時EventHub監聽到該事件。
• 加入channel成功後，登出區塊事件監聽，斷開所有event hub事件流。