Method processMsgEvent

consensus/vbft/service.go:1193–1377

()

}

func (self *Server) processMsgEvent() error {
	select {
	case msg := <-self.msgC:

		log.Debugf("server %d process msg, block %d, type %d, current blk %d",
			self.Index, msg.GetBlockNum(), msg.Type(), self.GetCurrentBlockNo())

		switch msg.Type() {
		case BlockProposalMessage:
			pMsg := msg.(*blockProposalMsg)

			if err := self.validateTxsInProposal(pMsg); err != nil {
				// TODO: report faulty proposal
				return fmt.Errorf("failed to validate tx in proposal: %s", err)
			}

			msgBlkNum := pMsg.GetBlockNum()
			if msgBlkNum == self.GetCurrentBlockNo() {
				// add proposal to block-pool
				if err := self.blockPool.newBlockProposal(pMsg); err != nil {
					if err == errDupProposal {
						// TODO: faulty proposer detected
					}
					log.Errorf("failed to add block proposal (%d): %s", msgBlkNum, err)
					return nil
				}

				if self.isProposer(msgBlkNum, pMsg.Block.getProposer()) {
					// check if agreed on prev-blockhash
					if err := self.verifyPrevBlockHash(msgBlkNum, pMsg); err != nil {
						// continue
						log.Errorf("failed verify prevBlockHash from proposer %d, blk %d",
							pMsg.Block.getProposer(), msgBlkNum)
						return nil
					}

					// stop proposal timer
					self.timer.CancelProposalTimer(msgBlkNum)
					if self.isEndorser(msgBlkNum, self.Index) {
						if err := self.endorseBlock(pMsg, false); err != nil {
							log.Errorf("failed to endorse block proposal (%d): %s", msgBlkNum, err)
						}
					}
				} else {
					if self.isProposer(msgBlkNum, self.Index) {
						for _, msg := range self.msgPool.GetProposalMsgs(msgBlkNum) {
							p := msg.(*blockProposalMsg)
							if p != nil && p.Block.getProposer() == self.Index {
								log.Infof("server %d rebroadcast proposal to %d, blk %d",
									self.Index, pMsg.Block.getProposer(), msgBlkNum)
								self.broadcast(msg)
								break
							}
						}
					}
					// makeProposalTimeout handles non-leader proposals
				}
			} else {