func newBlock(env []*common.Envelope, blockNum uint64, previousHash []byte) *common.Block {
block := common.NewBlock(blockNum, previousHash)
for i := 0; i < len(env); i++ {
txEnvBytes, _ := proto.Marshal(env[i])
block.Data.Data = append(block.Data.Data, txEnvBytes)
}
block.Header.DataHash = block.Data.Hash()
return block
}
// ConstructBlock constructs a block from a list of transactions
func (c *Consenter) ConstructBlock(transactions ...*common.Envelope) *common.Block {
logger.Debugf("Construct a block based on the transactions")
block := common.NewBlock(c.blockNum, c.previousHash)
for _, tx := range transactions {
txEnvBytes, _ := proto.Marshal(tx)
block.Data.Data = append(block.Data.Data, txEnvBytes)
}
block.Header.DataHash = block.Data.Hash()
c.blockNum++
c.previousHash = block.Header.Hash()
return block
}
func endTxSimulation(chainID string, txsim ledger.TxSimulator, payload []byte, commit bool, prop *pb.Proposal) error {
txsim.Done()
if lgr := peer.GetLedger(chainID); lgr != nil {
if commit {
var txSimulationResults []byte
var err error
//get simulation results
if txSimulationResults, err = txsim.GetTxSimulationResults(); err != nil {
return err
}
// assemble a (signed) proposal response message
resp, err := putils.CreateProposalResponse(prop.Header, prop.Payload, txSimulationResults, nil, nil, signer)
if err != nil {
return err
}
// get the envelope
env, err := putils.CreateSignedTx(prop, signer, resp)
if err != nil {
return err
}
envBytes, err := putils.GetBytesEnvelope(env)
if err != nil {
return err
}
//create the block with 1 transaction
block := common.NewBlock(1, []byte{})
block.Data.Data = [][]byte{envBytes}
//commit the block
if err := lgr.Commit(block); err != nil {
return err
}
}
}
return nil
}
// Only exposed for testing purposes - commit the tx simulation so that
// a deploy transaction is persisted and that chaincode can be invoked.
// This makes the endorser test self-sufficient
func (e *Endorser) commitTxSimulation(proposal *pb.Proposal, chainID string, signer msp.SigningIdentity, pResp *pb.ProposalResponse) error {
tx, err := putils.CreateSignedTx(proposal, signer, pResp)
if err != nil {
return err
}
lgr := peer.GetLedger(chainID)
if lgr == nil {
return fmt.Errorf("failure while looking up the ledger")
}
txBytes, err := proto.Marshal(tx)
if err != nil {
return err
}
block := common.NewBlock(1, []byte{})
block.Data.Data = [][]byte{txBytes}
block.Header.DataHash = block.Data.Hash()
if err = lgr.Commit(block); err != nil {
return err
}
return nil
}
func TestNewGossipStateProvider_SendingManyMessages(t *testing.T) {
ledgerPath := "/tmp/tests/ledger/"
defer os.RemoveAll(ledgerPath)
bootstrapSetSize := 5
bootstrapSet := make([]*peerNode, 0)
for i := 0; i < bootstrapSetSize; i++ {
committer := newCommitter(i, ledgerPath+"node/")
bootstrapSet = append(bootstrapSet, newPeerNode(newGossipConfig(i, 100), committer))
}
defer func() {
for _, p := range bootstrapSet {
p.shutdown()
}
}()
msgCount := 10
for i := 1; i <= msgCount; i++ {
rawblock := pcomm.NewBlock(uint64(i), []byte{})
if bytes, err := pb.Marshal(rawblock); err == nil {
payload := &proto.Payload{uint64(i), "", bytes}
bootstrapSet[0].s.AddPayload(payload)
} else {
t.Fail()
}
}
standartPeersSize := 10
peersSet := make([]*peerNode, 0)
for i := 0; i < standartPeersSize; i++ {
committer := newCommitter(standartPeersSize+i, ledgerPath+"node/")
peersSet = append(peersSet, newPeerNode(newGossipConfig(standartPeersSize+i, 100, 0, 1, 2, 3, 4), committer))
}
defer func() {
for _, p := range peersSet {
p.shutdown()
}
}()
waitUntilTrueOrTimeout(t, func() bool {
for _, p := range peersSet {
if len(p.g.GetPeers()) != bootstrapSetSize+standartPeersSize-1 {
logger.Debug("[XXXXXXX]: Peer discovery has not finished yet")
return false
}
}
logger.Debug("[AAAAAA]: All peer discovered each other!!!")
return true
}, 30*time.Second)
logger.Debug("[!!!!!]: Waiting for all blocks to arrive.")
waitUntilTrueOrTimeout(t, func() bool {
logger.Debug("[*****]: Trying to see all peers get all blocks")
for _, p := range peersSet {
height, err := p.commit.LedgerHeight()
if height != uint64(msgCount) || err != nil {
logger.Debug("[XXXXXXX]: Ledger height is at: ", height)
return false
}
}
logger.Debug("[#####]: All peers have same ledger height!!!")
return true
}, 60*time.Second)
}
func createTestBlock() *common.Block {
block := common.NewBlock(1, []byte{})
block.Data.Data = [][]byte{[]byte("tx1"), []byte("tx2")}
block.Header.DataHash = block.Data.Hash()
return block
}