func (self *NsqdCoordinator) putMessagesOnSlave(coord *TopicCoordinator, logData CommitLogData, msgs []*nsqd.Message) *CoordErr {
if len(msgs) == 0 {
return ErrPubArgError
}
if logData.LogID != int64(msgs[0].ID) {
return ErrPubArgError
}
var logMgr *TopicCommitLogMgr
// this last log id should be used on slave to avoid the slave switch
// override the leader's prev mpub message id.
// While slave is chosen as leader, the next id should be larger than the last logid.
// Because the mpub maybe already committed after the leader is down, the new leader should begin
// with the last message id + 1 for next message.
lastMsgLogID := int64(msgs[len(msgs)-1].ID)
if logData.LastMsgLogID != lastMsgLogID {
return ErrPubArgError
}
var queueEnd nsqd.BackendQueueEnd
var topic *nsqd.Topic
checkDupOnSlave := func(tc *coordData) bool {
if coordLog.Level() >= levellogger.LOG_DETAIL {
topicName := tc.topicInfo.Name
coordLog.Debugf("pub on slave : %v, msg count: %v", topicName, len(msgs))
}
logMgr = tc.logMgr
if logMgr.IsCommitted(logData.LogID) {
coordLog.Infof("put the already committed log id : %v", logData.LogID)
return true
}
return false
}
doLocalWriteOnSlave := func(tc *coordData) *CoordErr {
var localErr error
var start time.Time
checkCost := coordLog.Level() >= levellogger.LOG_DEBUG
if self.enableBenchCost {
checkCost = true
}
if checkCost {
start = time.Now()
}
topicName := tc.topicInfo.Name
partition := tc.topicInfo.Partition
topic, localErr = self.localNsqd.GetExistingTopic(topicName, partition)
if localErr != nil {
coordLog.Infof("pub on slave missing topic : %v", topicName)
// leave the isr and try re-sync with leader
return &CoordErr{localErr.Error(), RpcErrTopicNotExist, CoordSlaveErr}
}
topic.Lock()
var cost time.Duration
if checkCost {
cost = time.Now().Sub(start)
if cost > time.Millisecond {
coordLog.Infof("prepare write on slave local cost :%v", cost)
}
}
queueEnd, localErr = topic.PutMessagesOnReplica(msgs, nsqd.BackendOffset(logData.MsgOffset))
if checkCost {
cost2 := time.Now().Sub(start)
if cost2 > time.Millisecond {
coordLog.Infof("write local on slave cost :%v, %v", cost, cost2)
}
}
topic.Unlock()
if localErr != nil {
logIndex, lastLogOffset, lastLog, _ := logMgr.GetLastCommitLogOffsetV2()
coordLog.Errorf("put messages on slave failed: %v, slave last logid: %v, data: %v:%v, %v",
localErr, logMgr.GetLastCommitLogID(), logIndex, lastLogOffset, lastLog)
return &CoordErr{localErr.Error(), RpcCommonErr, CoordSlaveErr}
}
return nil
}
doLocalCommit := func() error {
localErr := logMgr.AppendCommitLog(&logData, true)
if localErr != nil {
coordLog.Errorf("write commit log on slave failed: %v", localErr)
return localErr
}
topic.Lock()
topic.UpdateCommittedOffset(queueEnd)
topic.Unlock()
return nil
}
doLocalExit := func(err *CoordErr) {
if err != nil {
coordLog.Warningf("failed to batch put messages on slave: %v", err)
}
}
return self.doWriteOpOnSlave(coord, checkDupOnSlave, doLocalWriteOnSlave, doLocalCommit,
doLocalExit)
}
