NSQ源码分析(二）—— Topic
Topic是NSQ非常重要的概念，本次主要讲述Topic的获取、新建、Topic中消息的轮询、Topic中消息的来源、Topic的删除和退出以及Topic的暂停和取消暂停
topic的相关操作主要在nsq/nsqd/topic.go中
首先看下Topic结构体
type Topic struct {
// 64bit atomic vars need to be first for proper alignment on 32bit platforms
messageCount uint64 //消息数量
sync.RWMutex
name string //topic的名称
channelMap map[string]*Channel //该topic关联的Channel信息
backend BackendQueue //用于接收消息，消息存放到磁盘
memoryMsgChan chan *Message //用于接收消息，消息存放到内存
startChan chan int //用于阻塞messagePump，直到收到startChan信号
exitChan chan int //退出的通道
channelUpdateChan chan int //channel有变更时发送通知的通道
waitGroup util.WaitGroupWrapper
exitFlag int32 //退出
idFactory *guidFactory
ephemeral bool //是否是临时的topic
deleteCallback func(*Topic) //执行删除的函数
deleter sync.Once //只执行一次
paused int32 //是否暂停 1 暂停，0不暂停
pauseChan chan int //发送暂停或取消暂停的消息
ctx *context //上下文，储存nsqd指针
}一、Topic的获取
GetTopic以协程安全执行并返回指向Topic对象的指针（可能是新创建的）
1.从nsqd实例的topicMap中获取，如果有则返回
2.如果topicMap中没有对应的topic信息，则新建topic(调用NewTopic)
3.新建topic后，从nsqlookupd获取对应的channel名称
4.如果channel名称不存在topic的channelMap中，则新建channel
func (n *NSQD) GetTopic(topicName string) *Topic {
// most likely, we already have this topic, so try read lock first.
n.RLock()
//从topicMap中读取，如果有，则返回
t, ok := n.topicMap[topicName]
n.RUnlock()
if ok {
return t
}
//这次用通用锁来处理
n.Lock()
t, ok = n.topicMap[topicName]
if ok {
n.Unlock()
return t
}
//topicMap中没有，则是第一次使用的topic，需要新建
//定义删除函数
deleteCallback := func(t *Topic) {
n.DeleteExistingTopic(t.name)
}
//创建topic
t = NewTopic(topicName, &context{n}, deleteCallback)
n.topicMap[topicName] = t
n.Unlock()
n.logf(LOG_INFO, "TOPIC(%s): created", t.name)
// topic is created but messagePump not yet started
// if loading metadata at startup, no lookupd connections yet, topic started after load
//如果启动时正在加载元数据，没有连接nsqlookupd，topic在加载完元数据后启动
if atomic.LoadInt32(&n.isLoading) == 1 {
return t
}
// if using lookupd, make a blocking call to get the topics, and immediately create them.
// this makes sure that any message received is buffered to the right channels
//获取nsqd所配置的lookupd的http地址
lookupdHTTPAddrs := n.lookupdHTTPAddrs()
if len(lookupdHTTPAddrs) > 0 {
//根据topic名称，从nsqlookupd获取所有关联的channel名称
channelNames, err := n.ci.GetLookupdTopicChannels(t.name, lookupdHTTPAddrs)
if err != nil {
n.logf(LOG_WARN, "failed to query nsqlookupd for channels to pre-create for topic %s - %s", t.name, err)
}
for _, channelName := range channelNames {
if strings.HasSuffix(channelName, "#ephemeral") {//临时的
continue // do not create ephemeral channel with no consumer client
}
t.GetChannel(channelName)
}
} else if len(n.getOpts().NSQLookupdTCPAddresses) > 0 {
n.logf(LOG_ERROR, "no available nsqlookupd to query for channels to pre-create for topic %s", t.name)
}
// now that all channels are added, start topic messagePump
t.Start()
return t
}
ps：提出两个问题可以思考一下
什么时候会调用GetTopic函数？
1.在nsqd启动的时候调用LoadMetadata() 加载元数据时会调用GetTopic用于初始化元数据中的Topic和Channel
2.当生产者PUB消息的时候，会指定topic，这时也会调用GetTopic
为什么topic对应的channel名称要从nsqlookupd中获取？
可以参考：https://blog.csdn.net/skh2015java/article/details/82747450
当消费者消费消息时会指定topic及对应的channel，所以nsqlookupd中维护者topic和channel的对应关系(一对多)
二、Topic的新建
topic分为临时topic和永久topic,临时topic backend变量使用newDummyBackendQueue函数初始化。该函数生成一个无任何功能的dummyBackendQueue结构；
对于永久的topic，backend使用newDiskQueue函数返回diskQueue类型赋值，并开启新的goroutine来进行数据的持久化。
1.初始化Topic结构体
2.对于非临时topic，则初始化topic的backend为diskQueue,diskQueue是记录在磁盘文件中的FIFO队列（当内存队列满的时候会用到该磁盘队列)
3.开启协程调用messagePump函数，messagePump的作用是将受到的队列（内存队列topic中的memoryMsgChan和磁盘队列disQueue）中的消息投递到topic关联的所有channel中
4.通知nsqd新建了topic
func NewTopic(topicName string, ctx *context, deleteCallback func(*Topic)) *Topic {
t := &Topic{
name: topicName,
channelMap: make(map[string]*Channel),
memoryMsgChan: make(chan *Message, ctx.nsqd.getOpts().MemQueueSize), //内存消息队列，有缓存，MemQueueSize默认是10000
startChan: make(chan int, 1),
exitChan: make(chan int),
channelUpdateChan: make(chan int),
ctx: ctx,
paused: 0,
pauseChan: make(chan int),
deleteCallback: deleteCallback,
idFactory: NewGUIDFactory(ctx.nsqd.getOpts().ID),
}
if strings.HasSuffix(topicName, "#ephemeral") { //如果topic的名称以#ephemeral开头，如果是则是临时topic
t.ephemeral = true
t.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...)
}
t.backend = diskqueue.New(
topicName, //topic名称
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,
)
}
t.waitGroup.Wrap(t.messagePump)
//通知nsqd新建了Topic
t.ctx.nsqd.Notify(t)
return t
}messagePump消息轮询
messagePump函数主要作用轮询将内存队列和磁盘队列中的消息投递给该topic关联的所有Channel，channel的更新，暂停或取消暂停及退出等
1.不在Start()函数调用之前接收消息，即不跳出第一个for循环
2.获取所有该topic对应的Channel
3.当topic对应的Channel的数量大于0，并且该topic不是暂停状态时初始化memoryMsgChan和backendChan
4.第二个for循环中的流程
(1)从内存队列或磁盘文件中获取消息，并投递给所有关联的Channel
(2)channel更新
(3)暂停或取消暂停
(4)退出
func (t *Topic) messagePump() {
var msg *Message
var buf []byte
var err error
var chans []*Channel //该topic对应的所有Channel
var memoryMsgChan chan *Message //内存消息队列
var backendChan chan []byte //backend队列
// do not pass messages before Start(), but avoid blocking Pause() or GetChannel()
//不在Start()函数调用之前接收消息
for {
select {
case <-t.channelUpdateChan: //channel update的消息通知
continue
case <-t.pauseChan: //暂停
continue
case <-t.exitChan: //退出
goto exit
case <-t.startChan:
}
break
}
t.RLock()
for _, c := range t.channelMap { //获取所有该topic对应的Channel
chans = append(chans, c)
}
t.RUnlock()
if len(chans) > 0 && !t.IsPaused() { //如果Channel的长度大于0，并且topic不是暂停状态
memoryMsgChan = t.memoryMsgChan //获取内存队列
backendChan = t.backend.ReadChan() //获取backendChan
}
// main message loop
for {
select {
case msg = <-memoryMsgChan: //从内存中获取
case buf = <-backendChan: //从backendChan中获取
msg, err = decodeMessage(buf) //需要将buf解码成msg
if err != nil {
t.ctx.nsqd.logf(LOG_ERROR, "failed to decode message - %s", err)
continue
}
case <-t.channelUpdateChan: //channel更新
chans = chans[:0] //从新获取chans
t.RLock()
for _, c := range t.channelMap {
chans = append(chans, c)
}
t.RUnlock()
if len(chans) == 0 || t.IsPaused() { //如果Channel的个数为0或者topic是暂停，则将memoryMsgChan和backendChan置为nil
memoryMsgChan = nil
backendChan = nil
} else { //负责重新指定memoryMsgChan和backendChan
memoryMsgChan = t.memoryMsgChan
backendChan = t.backend.ReadChan()
}
continue
case <-t.pauseChan: //暂停
if len(chans) == 0 || t.IsPaused() { //如果Channel的个数为0或者topic是暂停，则将memoryMsgChan和backendChan置为nil
memoryMsgChan = nil
backendChan = nil
} else { //负责重新指定memoryMsgChan和backendChan
memoryMsgChan = t.memoryMsgChan
backendChan = t.backend.ReadChan()
}
continue
case <-t.exitChan: //退出
goto exit
}
//以下为处理收到的msg
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)
}
}
}
exit:
t.ctx.nsqd.logf(LOG_INFO, "TOPIC(%s): closing ... messagePump", t.name)
}
三、Topic中消息的获取
topic.go文件中的put函数，是topic中消息的获取来源
上面也提到topic中的消息存在topic中的memoryMsgChan队列中，该队列的默认长度是10000，如果该队列满了，则会将消息存到disQueue磁盘文件中
当生产者PUB消息时，会根据topic的名称，将消息写入到对应topic的队列中
1.如果memoryMsgChan队列没满，则将消息写入该队列
2.如果满了则将消息写入到磁盘中
(1)通过bufferPoolGet函数从buffer池中获取一个buffer，bufferPoolGet及以下bufferPoolPut函数是对sync.Pool的简单包装。 两个函数位于nsqd/buffer_pool.go中。
(2）调用writeMessageToBackend函数将消息写入磁盘。
(3)通过bufferPoolPut函数将buffer归还buffer池。
(4)调用SetHealth函数将writeMessageToBackend的返回值写入errValue变量。 该变量衍生出IsHealthy，GetError和GetHealth3个函数，主要用于测试以及从HTTP API获取nsqd的运行情况（是否发生错误）
func (t *Topic) put(m *Message) error {
select {
case t.memoryMsgChan <- m:
default:
b := bufferPoolGet()
err := writeMessageToBackend(b, m, t.backend)
bufferPoolPut(b)
t.ctx.nsqd.SetHealth(err)
if err != nil {
t.ctx.nsqd.logf(LOG_ERROR,
"TOPIC(%s) ERROR: failed to write message to backend - %s",
t.name, err)
return err
}
}
return nil
}四、Topic的关闭和删除
1.deleted为true，则通知nsqd
2.close(t.exitChan) 退出memoryMsgChan函数
3.如果deleted为true，则
(1)删除该topic对应的channel
(2)channel.Delete()清空队列中的消息并关闭退出
(3)t.Empty()清空内存队列和磁盘文件中的消息
4.如果deleted为false，则
(1)关闭topic对应的channel
(2)调用t.flush()将内存队列memoryMsgChan中的消息写入到磁盘文件中
(3)关闭并退出disQueue（文件中的消息是不删除的）
总结来说：
对于删除操作，需要清空channelMap并删除所有channel，然后删除内存和磁盘中所有未投递的消息。最后关闭backend管理的的磁盘文件。
对于关闭操作，不清空channelMap，只是关闭所有的channel，使用flush函数将所有memoryMsgChan中未投递的消息用writeMessageToBackend保存到磁盘中。最后关闭backend管理的的磁盘文件。
// Delete empties the topic and all its channels and closes
func (t *Topic) Delete() error {
return t.exit(true)
}
// Close persists all outstanding topic data and closes all its channels
func (t *Topic) Close() error {
return t.exit(false)
}
func (t *Topic) exit(deleted bool) error {
if !atomic.CompareAndSwapInt32(&t.exitFlag, 0, 1) {
return errors.New("exiting")
}
if deleted {
t.ctx.nsqd.logf(LOG_INFO, "TOPIC(%s): deleting", t.name)
// since we are explicitly deleting a topic (not just at system exit time)
// de-register this from the lookupd
t.ctx.nsqd.Notify(t)
} else {
t.ctx.nsqd.logf(LOG_INFO, "TOPIC(%s): closing", t.name)
}
close(t.exitChan)
// synchronize the close of messagePump()
t.waitGroup.Wait()
if deleted {
t.Lock()
for _, channel := range t.channelMap {
delete(t.channelMap, channel.name)
channel.Delete()
}
t.Unlock()
// empty the queue (deletes the backend files, too)
t.Empty()
return t.backend.Delete()
}
// close all the channels
for _, channel := range t.channelMap {
err := channel.Close()
if err != nil {
// we need to continue regardless of error to close all the channels
t.ctx.nsqd.logf(LOG_ERROR, "channel(%s) close - %s", channel.name, err)
}
}
// write anything leftover to disk
t.flush()
return t.backend.Close()
}
五、Topic的暂停和取消暂停
topic的暂停和取消暂停主要是通过原子操作topic中的paused字段来实现的，paused的值为1则是暂停，0是非暂停状态
代码比较简单
func (t *Topic) Pause() error {
return t.doPause(true)
}
func (t *Topic) UnPause() error {
return t.doPause(false)
}
func (t *Topic) doPause(pause bool) error {
if pause {
atomic.StoreInt32(&t.paused, 1)
} else {
atomic.StoreInt32(&t.paused, 0)
}
select {
case t.pauseChan <- 1:
case <-t.exitChan:
}
return nil
}
func (t *Topic) IsPaused() bool {
return atomic.LoadInt32(&t.paused) == 1
}