// handles message received with type `mtGubleMessage`
func (cluster *Cluster) handleGubleMessage(cmsg *message) {
if cluster.Router == nil {
return
}
message, err := protocol.ParseMessage(cmsg.Body)
if err != nil {
logger.WithField("err", err).Error("Parsing of guble-message contained in cluster-message failed")
return
}
cluster.Router.HandleMessage(message)
}
// NotifyMsg is invoked each time a message is received by this node of the cluster; it decodes and dispatches the messages.
func (cluster *Cluster) NotifyMsg(msg []byte) {
logger.WithField("msgAsBytes", msg).Debug("NotifyMsg")
cmsg, err := decode(msg)
if err != nil {
logger.WithField("err", err).Error("Decoding of cluster message failed")
return
}
logger.WithFields(log.Fields{
"senderNodeID": cmsg.NodeID,
"type": cmsg.Type,
"body": string(cmsg.Body),
}).Debug("NotifyMsg: Received cluster message")
if cluster.MessageHandler != nil && cmsg.Type == gubleMessage {
pMessage, err := protocol.ParseMessage(cmsg.Body)
if err != nil {
logger.WithField("err", err).Error("Parsing of guble-message contained in cluster-message failed")
return
}
cluster.MessageHandler.HandleMessage(pMessage)
}
}
func (r *Route) handleFetch(router Router) error {
if r.isInvalid() {
return ErrInvalidRoute
}
r.FetchRequest.Partition = r.Path.Partition()
ms, err := router.MessageStore()
if err != nil {
return err
}
var (
lastID uint64
received int
)
REFETCH:
// check if we need to continue fetching
maxID, err := ms.MaxMessageID(r.FetchRequest.Partition)
if err != nil {
return err
}
if r.FetchRequest.StartID > maxID && r.FetchRequest.Direction == store.DirectionForward {
return nil
}
if received >= r.FetchRequest.Count || lastID >= maxID ||
(r.FetchRequest.EndID > 0 && r.FetchRequest.EndID <= lastID) {
return nil
}
r.FetchRequest.Init()
if err := router.Fetch(r.FetchRequest); err != nil {
return err
}
count := r.FetchRequest.Ready()
r.logger.WithField("count", count).Debug("Receiving messages")
for {
select {
case fetchedMessage, open := <-r.FetchRequest.Messages():
if !open {
r.logger.Debug("Fetch channel closed.")
goto REFETCH
}
r.logger.WithField("fetchedMessageID", fetchedMessage.ID).Debug("Fetched message")
message, err := protocol.ParseMessage(fetchedMessage.Message)
if err != nil {
return err
}
r.logger.WithField("messageID", message.ID).Debug("Sending fetched message in channel")
if err := r.Deliver(message); err != nil {
return err
}
lastID = message.ID
received++
case err := <-r.FetchRequest.Errors():
return err
case <-router.Done():
r.logger.Debug("Stopping fetch because the router is shutting down")
return nil
}
}
}
