func (s *GossipStateProviderImpl) handleStateRequest(msg comm.ReceivedMessage) {
request := msg.GetGossipMessage().GetStateRequest()
response := &proto.RemoteStateResponse{Payloads: make([]*proto.Payload, 0)}
for _, seqNum := range request.SeqNums {
s.logger.Debug("Reading block ", seqNum, " from the committer service")
blocks := s.committer.GetBlocks([]uint64{seqNum})
if blocks == nil || len(blocks) < 1 {
s.logger.Errorf("Wasn't able to read block with sequence number %d from ledger, skipping....", seqNum)
continue
}
blockBytes, err := pb.Marshal(blocks[0])
if err != nil {
s.logger.Errorf("Could not marshal block: %s", err)
}
if err != nil {
s.logger.Errorf("Could not calculate hash of block: %s", err)
}
response.Payloads = append(response.Payloads, &proto.Payload{
SeqNum: seqNum,
Data: blockBytes,
// TODO: Check hash generation for given block from the ledger
Hash: "",
})
}
// Sending back response with missing blocks
msg.Respond(&proto.GossipMessage{
Content: &proto.GossipMessage_StateResponse{response},
})
}
func (s *GossipStateProviderImpl) handleStateResponse(msg comm.ReceivedMessage) {
response := msg.GetGossipMessage().GetStateResponse()
for _, payload := range response.GetPayloads() {
s.logger.Debugf("Received payload with sequence number %d.", payload.SeqNum)
err := s.payloads.Push(payload)
if err != nil {
s.logger.Warningf("Payload with sequence number %d was received earlier", payload.SeqNum)
}
}
}
func (s *GossipStateProviderImpl) directMessage(msg comm.ReceivedMessage) {
s.logger.Debug("[ENTER] -> directMessage")
defer s.logger.Debug("[EXIT] -> directMessage")
if msg == nil {
s.logger.Error("Got nil message via end-to-end channel, should not happen!")
return
}
incoming := msg.GetGossipMessage()
if incoming.GetStateRequest() != nil {
s.handleStateRequest(msg)
} else if incoming.GetStateResponse() != nil {
s.handleStateResponse(msg)
}
}
func (cs *certStore) handleMessage(msg comm.ReceivedMessage) {
if update := msg.GetGossipMessage().GetDataUpdate(); update != nil {
for _, m := range update.Data {
if !m.IsIdentityMsg() {
cs.logger.Warning("Got a non-identity message:", m, "aborting")
return
}
idMsg := m.GetPeerIdentity()
if err := cs.mcs.ValidateIdentity(api.PeerIdentityType(idMsg.Cert)); err != nil {
cs.logger.Warning("Got invalid certificate:", err)
return
}
}
}
cs.pull.HandleMessage(msg)
}
func (p *pullMediatorImpl) HandleMessage(m comm.ReceivedMessage) {
if m.GetGossipMessage() == nil || !m.GetGossipMessage().IsPullMsg() {
return
}
msg := m.GetGossipMessage()
msgType := msg.GetPullMsgType()
if msgType != p.config.MsgType {
return
}
p.logger.Debug(msg)
itemIds := []string{}
items := []*proto.GossipMessage{}
var pullMsgType PullMsgType
if helloMsg := msg.GetHello(); helloMsg != nil {
pullMsgType = HelloMsgType
p.engine.OnHello(helloMsg.Nonce, m)
}
if digest := msg.GetDataDig(); digest != nil {
itemIds = digest.Digests
pullMsgType = DigestMsgType
p.engine.OnDigest(digest.Digests, digest.Nonce, m)
}
if req := msg.GetDataReq(); req != nil {
itemIds = req.Digests
pullMsgType = RequestMsgType
p.engine.OnReq(req.Digests, req.Nonce, m)
}
if res := msg.GetDataUpdate(); res != nil {
itemIds = make([]string, len(res.Data))
items = make([]*proto.GossipMessage, len(res.Data))
pullMsgType = ResponseMsgType
for i, pulledMsg := range res.Data {
p.msgCons(pulledMsg)
itemIds[i] = p.idExtractor(pulledMsg)
items[i] = pulledMsg
p.Lock()
p.itemId2msg[itemIds[i]] = pulledMsg
p.Unlock()
}
p.engine.OnRes(itemIds, res.Nonce)
}
// Invoke hooks for relevant message type
for _, h := range p.hooksByMsgType(pullMsgType) {
h(itemIds, items, m)
}
}
func (g *gossipServiceImpl) forwardDiscoveryMsg(msg comm.ReceivedMessage) {
defer func() { // can be closed while shutting down
recover()
}()
g.discAdapter.incChan <- msg.GetGossipMessage()
}
func (g *gossipServiceImpl) handleMessage(m comm.ReceivedMessage) {
if g.toDie() {
return
}
g.logger.Info("Entering,", m)
defer g.logger.Info("Exiting")
if m == nil || m.GetGossipMessage() == nil {
return
}
msg := m.GetGossipMessage()
if msg.IsAliveMsg() || msg.IsDataMsg() {
if msg.IsAliveMsg() {
if !g.disSecAdap.ValidateAliveMsg(msg.GetAliveMsg()) {
g.logger.Warning("AliveMessage", m.GetGossipMessage(), "isn't authentic. Discarding it")
return
}
am := msg.GetAliveMsg()
storedIdentity, _ := g.idMapper.Get(common.PKIidType(am.Membership.PkiID))
// If peer's certificate is included inside AliveMessage, and we don't have a mapping between
// its PKI-ID and certificate, create a mapping for it now.
if identity := am.Identity; identity != nil && storedIdentity == nil {
err := g.idMapper.Put(common.PKIidType(am.Membership.PkiID), api.PeerIdentityType(identity))
if err != nil {
g.logger.Warning("Failed adding identity of", am, "into identity store:", err)
return
}
g.logger.Info("Learned identity of", am.Membership.PkiID)
}
}
if msg.IsDataMsg() {
blockMsg := msg.GetDataMsg()
if blockMsg.Payload == nil {
g.logger.Warning("Empty block! Discarding it")
return
}
if err := g.mcs.VerifyBlock(blockMsg); err != nil {
g.logger.Warning("Could not verify block", blockMsg.Payload.SeqNum, "Discarding it")
return
}
}
added := g.msgStore.add(msg)
if added {
g.emitter.Add(msg)
if dataMsg := m.GetGossipMessage().GetDataMsg(); dataMsg != nil {
g.blocksPuller.Add(msg)
g.DeMultiplex(msg)
}
}
}
if selectOnlyDiscoveryMessages(m) {
g.forwardDiscoveryMsg(m)
}
if msg.IsPullMsg() {
switch msgType := msg.GetPullMsgType(); msgType {
case proto.PullMsgType_BlockMessage:
g.blocksPuller.HandleMessage(m)
case proto.PullMsgType_IdentityMsg:
g.certStore.handleMessage(m)
default:
g.logger.Warning("Got invalid pull message type:", msgType)
}
}
}