Channel相关的代码主要位于nsqd/channel.go, nsqd/nsqd.go中。
Channel是消费者订阅特定Topic的一种抽象。对于发往Topic的消息，nsqd向该Topic下的所有Channel投递消息，而同一个Channel只投递一次，Channel下如果存在多个消费者，则随机选择一个消费者做投递。这种投递方式可以被用作消费者负载均衡。Channel会将消息进行排列，如果没有消费者读取消息，消息首先会在内存中排队，当量太大时就会被保存到磁盘中。
一、Channel的创建和初始化
1.初始化Channel，初始化topicName，name,memoryMsgChan,ctx,clients及删除函数deleteCallback
2.给e2eProcessingLatencyStream赋值，主要用于统计消息投递的延迟等
3.initPQ函数创建了两个mapinFlightMessages、deferredMessages和两个队列inFlightPQ和deferredPQ。主要用于索引和存放这两类消息
4.初始化backend为diskqueue，磁盘存储的消息文件
5.通知nsqd创建了Channel
func NewChannel(topicName string, channelName string, ctx *context,
deleteCallback func(*Channel)) *Channel {
c := &Channel{
topicName: topicName,
name: channelName,
memoryMsgChan: make(chan *Message, ctx.nsqd.getOpts().MemQueueSize),
clients: make(map[int64]Consumer),
deleteCallback: deleteCallback,
ctx: ctx,
}
if len(ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles) > 0 {
c.e2eProcessingLatencyStream = quantile.New(
ctx.nsqd.getOpts().E2EProcessingLatencyWindowTime,
ctx.nsqd.getOpts().E2EProcessingLatencyPercentiles,
)
}
c.initPQ()
if strings.HasSuffix(channelName, "#ephemeral") {
c.ephemeral = true
c.backend = newDummyBackendQueue()
} else {
dqLogf := func(level diskqueue.LogLevel, f string, args ...interface{}) {
opts := ctx.nsqd.getOpts()
lg.Logf(opts.Logger, opts.logLevel, lg.LogLevel(level), f, args...)
}
// backend names, for uniqueness, automatically include the topic...
backendName := getBackendName(topicName, channelName)
c.backend = diskqueue.New(
backendName,
ctx.nsqd.getOpts().DataPath,
ctx.nsqd.getOpts().MaxBytesPerFile,
int32(minValidMsgLength),
int32(ctx.nsqd.getOpts().MaxMsgSize)+minValidMsgLength,
ctx.nsqd.getOpts().SyncEvery,
ctx.nsqd.getOpts().SyncTimeout,
dqLogf,
)
}
c.ctx.nsqd.Notify(c)
return c
}initPQ函数
initPQ 主要用于索引和存放这两类消息
1.获取队列缓冲长度pgSize 值为 1和MemQueueSize/10的最大值，MemQueueSize的默认值为10000
2.初始化inFlightMessages，存储Message的MessageID和Message的对应关系
3.初始化inFlightPQ队列，正在投递但还没确认投递成功的消息
4.初始化deferredMessages 和 deferredPQ ，deferredPQ 队列是延时消息和投递失败等待指定时间后重新投递的消息
func (c *Channel) initPQ() {
pqSize := int(math.Max(1, float64(c.ctx.nsqd.getOpts().MemQueueSize)/10))
c.inFlightMutex.Lock()
c.inFlightMessages = make(map[MessageID]*Message)
c.inFlightPQ = newInFlightPqueue(pqSize)
c.inFlightMutex.Unlock()
c.deferredMutex.Lock()
c.deferredMessages = make(map[MessageID]*pqueue.Item)
c.deferredPQ = pqueue.New(pqSize)
c.deferredMutex.Unlock()
}
二、Channel中的消息来源
在分析Topic时提到，消息进入Topic的消息循环后会被投递到该Topic下所有的Channel，由Channel的PutMessage函数进行处理。
以下是topic的messagePump函数的片段(源码在nsq/nsqd/topic.go文件中的messagePump函数)
func (t *Topic) messagePump() {
......
for {
......
for i, channel := range chans { //遍历topic的所有的channel
chanMsg := msg
// copy the message because each channel
// needs a unique instance but...
// fastpath to avoid copy if its the first channel
// (the topic already created the first copy)
//复制消息，因为每个channel需要唯一的实例
if i > 0 {
chanMsg = NewMessage(msg.ID, msg.Body)
chanMsg.Timestamp = msg.Timestamp
chanMsg.deferred = msg.deferred
}
if chanMsg.deferred != 0 { //发送延时消息
channel.PutMessageDeferred(chanMsg, chanMsg.deferred)
continue
}
//发送即时消息
err := channel.PutMessage(chanMsg)
if err != nil {
t.ctx.nsqd.logf(LOG_ERROR,
"TOPIC(%s) ERROR: failed to put msg(%s) to channel(%s) - %s",
t.name, msg.ID, channel.name, err)
}
}
}
}从中我们看到topic将Message发送给所有关联的Channels,消息有两种即时消息和延时消息
Channel接收到延时消息的处理流程
1.Channel中的messageCount自增，messageCount也就是消息数量
2.调用StartDeferredTimeout函数，将消息维护到pushDeferredMessage和deferredPQ优先级队列中
func (c *Channel) PutMessageDeferred(msg *Message, timeout time.Duration) {
atomic.AddUint64(&c.messageCount, 1)
c.StartDeferredTimeout(msg, timeout)
}继续来看StartDeferredTimeout函数
将消息添加到deferredMessages 和 deferredPQ 队列中等待投递
1.初始化item，Priority的值为当前时间+延时时间的时间戳
2.调用pushDeferredMessage函数将消息添加到pushDeferredMessage中，pushDeferredMessage该map中储存了MessageID和Message的对应关系
3.调用addToDeferredPQ将item添加到deferredPQ优先级队列中
func (c *Channel) StartDeferredTimeout(msg *Message, timeout time.Duration) error {
absTs := time.Now().Add(timeout).UnixNano()
item := &pqueue.Item{Value: msg, Priority: absTs}
err := c.pushDeferredMessage(item)
if err != nil {
return err
}
c.addToDeferredPQ(item)
return nil
}pushDeferredMessage函数
//向deferredMessages map中添加重新投递的消息信息
func (c *Channel) pushDeferredMessage(item *pqueue.Item) error {
c.deferredMutex.Lock()
// TODO: these map lookups are costly
id := item.Value.(*Message).ID
_, ok := c.deferredMessages[id]
if ok {
c.deferredMutex.Unlock()
return errors.New("ID already deferred")
}
c.deferredMessages[id] = item
c.deferredMutex.Unlock()
return nil
}addToDeferredPQ函数
//向deferredPQ队列中添加元素
func (c *Channel) addToDeferredPQ(item *pqueue.Item) {
c.deferredMutex.Lock()
heap.Push(&c.deferredPQ, item)
c.deferredMutex.Unlock()
}Channel接收到即时消息的处理流程
1.如果文件channel已经退出，则返回错误
2.调用put(m)，将消息写到内存队列memoryMsgChan或磁盘文件中
3.将该channel的消息数量原子性加1
func (c *Channel) PutMessage(m *Message) error {
c.RLock()
defer c.RUnlock()
if c.Exiting() { //channel已经退出
return errors.New("exiting")
}
err := c.put(m)
if err != nil {
return err
}
atomic.AddUint64(&c.messageCount, 1)
return nil
}put函数
1.memoryMsgChan内存队列默认缓冲是10000,如果memoryMsgChan已满，则写入到硬盘中
2.通过bufferPoolGet函数从buffer池中获取一个buffer，bufferPoolGet及以下bufferPoolPut函数是对sync.Pool的简单包装。两个函数位于nsqd/buffer_pool.go中。
3.调用writeMessageToBackend函数将消息写入磁盘文件中。
4.通过bufferPoolPut函数将buffer归还buffer池。
5.调用SetHealth函数将writeMessageToBackend的返回值写入errValue变量。该变量衍生出IsHealthy，GetError和GetHealth3个函数，主要用于测试以及从HTTP API获取nsqd的运行情况（是否发生错误）
func (c *Channel) put(m *Message) error {
select {
case c.memoryMsgChan <- m:
default:
b := bufferPoolGet()
err := writeMessageToBackend(b, m, c.backend)
bufferPoolPut(b)
c.ctx.nsqd.SetHealth(err)
if err != nil {
c.ctx.nsqd.logf(LOG_ERROR, "CHANNEL(%s): failed to write message to backend - %s",
c.name, err)
return err
}
}
return nil
}三、Channel中消息的投递
Channel中的消息是要投递给客户端（消费者），第一节讲到在tcp server监听到有新的客户端连接时会开启一个协程，调用protocol_v2文件中的IOLoop(conn net.Conn)进行客户端读写操作。在IOLoop函数中会开启一个协程调用messagePump函数来轮询将Channel中的消息写给客户端。下面我们主要来看下messagePump函数
源码在nsq/nsqd/protocol_v2.go文件中
处理channel中的消息，channel接收到的消息主要在memoryMsgChan和磁盘文件中
func (p *protocolV2) messagePump(client *clientV2, startedChan chan bool) {
.......
if sampleRate > 0 && rand.Int31n(100) > sampleRate {
continue
}
msg, err := decodeMessage(b)
if err != nil {
p.ctx.nsqd.logf(LOG_ERROR, "failed to decode message - %s", err)
continue
}
msg.Attempts++
subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout)
client.SendingMessage()
err = p.SendMessage(client, msg)
if err != nil {
goto exit
}
flushed = false
case msg := <-memoryMsgChan:
if sampleRate > 0 && rand.Int31n(100) > sampleRate {
continue
}
msg.Attempts++ //投递尝试的次数
subChannel.StartInFlightTimeout(msg, client.ID, msgTimeout)
client.SendingMessage()
err = p.SendMessage(client, msg)
if err != nil {
goto exit
}
flushed = false
}
看到无论是从磁盘中取出的消息还是从内存队列中取出的消息，执行的流程差不多。
1.msg的Attempts自增（消息尝试投递的次数）
2.调用StartInFlightTimeout函数将本条消息msg添加到inFlightMessages和inFlightPQ优先队列中 （inFlightMessages和inFlightPQ存放已投递但不确定是否投递成功的消息）
3.调用SendingMessage函数将clientV2中的InFlightCount和MessageCount自增
4.调用SendMessage函数将消息发送给客户端
四、消息投递后的处理
客户端成功消费一条消息后，会发送一个FIN消息，带上message ID 或者客户端如果消费失败，也会发送一个REQ的请求。IOLoop函数中除了开启一个协程调用messagePump函数轮询的投递Channel中的消息，for循环模块中也在轮询读取从客户端返回的消息。
func (p *protocolV2) IOLoop(conn net.Conn) error {
.....
for {
......
line, err = client.Reader.ReadSlice('\n')
if err != nil {
if err == io.EOF {
err = nil
} else {
err = fmt.Errorf("failed to read command - %s", err)
}
break
}
/*
去除行尾的\n \r,并按空格切分成params
*/
// trim the '\n'
line = line[:len(line)-1]
// optionally trim the '\r'
if len(line) > 0 && line[len(line)-1] == '\r' {
line = line[:len(line)-1]
}
params := bytes.Split(line, separatorBytes)
p.ctx.nsqd.logf(LOG_DEBUG, "PROTOCOL(V2): [%s] %s", client, params)
var response []byte
response, err = p.Exec(client, params)
}
}
消息投送成功的处理
客户端成功消费一条消息后，会发送一个FIN消息。会执行到Exec函数中的FIN流程，最后调用FIN函数
1.获取消息id
2.调用FinishMessage方法，从 inFlightMessages 和 inFlightPQ 队列中移除该消息
3.调用 FinishedMessage将该clientV2的FinishCount增1，InFlightCount减1，并并向ReadStateChan发送一个消息；如果服务端因为RDY限制停止推送消息，收到这个消息后，也会重新查看是否可以继续推送消息。
func (p *protocolV2) FIN(client *clientV2, params [][]byte) ([]byte, error) {
state := atomic.LoadInt32(&client.State)
if state != stateSubscribed && state != stateClosing {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", "cannot FIN in current state")
}
if len(params) < 2 {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", "FIN insufficient number of params")
}
id, err := getMessageID(params[1])
if err != nil {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", err.Error())
}
err = client.Channel.FinishMessage(client.ID, *id)
if err != nil {
return nil, protocol.NewClientErr(err, "E_FIN_FAILED",
fmt.Sprintf("FIN %s failed %s", *id, err.Error()))
}
client.FinishedMessage()
return nil, nil
}消息投递失败的处理
消息投递失败的处理流程主要在REQ函数中
1.获取消息id
2.获取timeoutDuration的值
3.调用RequeueMessage方法，将消息msg 根据消息id从inFlightMessages和inFlightPQ队列中移除，并根据timeoutDuration的值决定将该消息添加到deferredMessages 和 deferredPQ 队列中，还是放到memoryMsgChan或磁盘文件中 并等待下次投递
4.调用RequeuedMessage方法，将clientV2的RequeueCount值增1，将InFlightCount,减1，并并向ReadStateChan发送一个消息
func (p *protocolV2) REQ(client *clientV2, params [][]byte) ([]byte, error) {
state := atomic.LoadInt32(&client.State)
if state != stateSubscribed && state != stateClosing {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", "cannot REQ in current state")
}
if len(params) < 3 {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", "REQ insufficient number of params")
}
id, err := getMessageID(params[1])
if err != nil {
return nil, protocol.NewFatalClientErr(nil, "E_INVALID", err.Error())
}
timeoutMs, err := protocol.ByteToBase10(params[2])
if err != nil {
return nil, protocol.NewFatalClientErr(err, "E_INVALID",
fmt.Sprintf("REQ could not parse timeout %s", params[2]))
}
timeoutDuration := time.Duration(timeoutMs) * time.Millisecond
maxReqTimeout := p.ctx.nsqd.getOpts().MaxReqTimeout
clampedTimeout := timeoutDuration
if timeoutDuration < 0 {
clampedTimeout = 0
} else if timeoutDuration > maxReqTimeout {
clampedTimeout = maxReqTimeout
}
if clampedTimeout != timeoutDuration {
p.ctx.nsqd.logf(LOG_INFO, "PROTOCOL(V2): [%s] REQ timeout %d out of range 0-%d. Setting to %d",
client, timeoutDuration, maxReqTimeout, clampedTimeout)
timeoutDuration = clampedTimeout
}
err = client.Channel.RequeueMessage(client.ID, *id, timeoutDuration)
if err != nil {
return nil, protocol.NewClientErr(err, "E_REQ_FAILED",
fmt.Sprintf("REQ %s failed %s", *id, err.Error()))
}
client.RequeuedMessage()
return nil, nil
}RequeueMessage函数是消息投递失败的主要流程
1.将消息msg 根据消息id从inFlightMessages和inFlightPQ队列中移除
2.如果timeout为0，则将该消息重新添加到memoryMsgChan或磁盘文件中，等待下次投递
3.如果timeout大于0，则将消息添加到deferredMessages 和 deferredPQ 队列中等待重新投递
func (c *Channel) RequeueMessage(clientID int64, id MessageID, timeout time.Duration) error {
// remove from inflight first
msg, err := c.popInFlightMessage(clientID, id)
if err != nil {
return err
}
c.removeFromInFlightPQ(msg)
atomic.AddUint64(&c.requeueCount, 1)
if timeout == 0 {
c.exitMutex.RLock()
if c.Exiting() {
c.exitMutex.RUnlock()
return errors.New("exiting")
}
err := c.put(msg)
c.exitMutex.RUnlock()
return err
}
// deferred requeue
return c.StartDeferredTimeout(msg, timeout)
}
(1)timeout为0的情况（timeout可以理解成消息投递失败后，需要等待多久之后再投递）
调用put函数将消息写到memoryMsgChan或磁盘文件中，前面已经介绍过这个函数，这里就不在详细说明。
func (c *Channel) put(m *Message) error {
select {
case c.memoryMsgChan <- m:
default:
b := bufferPoolGet()
err := writeMessageToBackend(b, m, c.backend)
bufferPoolPut(b)
c.ctx.nsqd.SetHealth(err)
if err != nil {
c.ctx.nsqd.logf(LOG_ERROR, "CHANNEL(%s): failed to write message to backend - %s",
c.name, err)
return err
}
}
return nil
}
(2)timeout大于0的情况
调用StartDeferredTimeout函数将消息写入到pushDeferredMessage 和 deferredPQ中。这个函数在前面Channel中获取延时消息也是调用这个函数。
func (c *Channel) StartDeferredTimeout(msg *Message, timeout time.Duration) error {
absTs := time.Now().Add(timeout).UnixNano()
item := &pqueue.Item{Value: msg, Priority: absTs}
err := c.pushDeferredMessage(item)
if err != nil {
return err
}
c.addToDeferredPQ(item)
return nil
}
五、Channel的暂停和取消暂停
Channel的暂停和取消暂停和Topic的操作一样，由Channel中paused字段的值决定，该字段是原子操作的，paused为1表示暂停状态，0表示未暂停。
func (c *Channel) Pause() error {
return c.doPause(true)
}
func (c *Channel) UnPause() error {
return c.doPause(false)
}
//暂停或取消暂停向客户端发送消息
func (c *Channel) doPause(pause bool) error {
if pause {
atomic.StoreInt32(&c.paused, 1)
} else {
atomic.StoreInt32(&c.paused, 0)
}
c.RLock()
for _, client := range c.clients {
if pause {
client.Pause()
} else {
client.UnPause()
}
}
c.RUnlock()
return nil
}
//返回该Channel是否是暂停状态
func (c *Channel) IsPaused() bool {
return atomic.LoadInt32(&c.paused) == 1
}