NSQ源码分析(三)——disQueue

- 日理万妓 2022-05-13 18:54 235阅读 0赞

disQueue是Topic以及Channel中的内存消息满了以后，消息存放的实现方法，diskQueue实现了文件系统支持的FIFO队列，disQueue也是BackendQueue接口的实现，diskQueue在文件读写给我们提供了很好的学习示例。

BackendQueue接口

// BackendQueue represents the behavior for the secondary message storage system
    type BackendQueue interface {
    	Put([]byte) error   //向文件中写入数据
    	ReadChan() chan []byte //返回一个读的chan
    	Close() error  //关闭
    	Delete() error  //删除
    	Depth() int64  //获取未读消息的个数
    	Empty() error  //清空操作
    }

diskQueue结构体及字段的解释

type diskQueue struct {
    	// 64bit atomic vars need to be first for proper alignment on 32bit platforms
    
    	// run-time state (also persisted to disk)
    	//以下5个字段为元数据
    	readPos      int64  //当前读文件的指针偏移量(从文件的某个位置开始读)
    	writePos     int64   //当前写文件的指针偏移量
    	readFileNum  int64   //当前读的文件编号
    	writeFileNum int64     //当前写的文件编号，用于创建文件名使用，文件编号每新建一个文件会递增1
    	depth        int64   //写一条消息加1，读一条消息减1，可以理解成还未读完的消息数量
    
    	sync.RWMutex
    
    	// instantiation time metadata
    	name            string   //名称
    	dataPath        string  //文件的路径
    	maxBytesPerFile int64 //每个文件的最大字节数
    	minMsgSize      int32   //单条消息的最小字节数，默认是MsgIDLength + 8 + 2 = 26
    	maxMsgSize      int32  //单条消息的最大字节数，默认是1024 * 1024 + minMsgSize
    	syncEvery       int64         // 定期刷新文件的读写次数阈值（默认2500）
    	syncTimeout     time.Duration // 定期刷新文件的时间戳阈值（默认2s）
    	exitFlag        int32
    	needSync        bool   //需要刷新文件
    
    	// keeps track of the position where we have read
    	// (but not yet sent over readChan)
    	nextReadPos     int64    //下次需要读的指针偏移量
    	nextReadFileNum int64   //下次需要读的文件编号
    
    	readFile  *os.File    //当前正在读的文件,如果为nil则读取下一个文件编号的文件
    	writeFile *os.File   //当前正在写的文件,如果为nil则新建文件
    	reader    *bufio.Reader
    	writeBuf  bytes.Buffer
    
    	// exposed via ReadChan()
    	readChan chan []byte  //通过ReadChan()函数暴露出去
    
    	// internal channels
    	writeChan         chan []byte    //写通道
    	writeResponseChan chan error   //写之后返回的结果
    	emptyChan         chan int   //清空文件的通道
    	emptyResponseChan chan error
    	exitChan          chan int
    	exitSyncChan      chan int
    
    	logf AppLogFunc  //处理日志的函数
    }

## 一、diskQueue的创建和初始化 ##

`1.初始化diskQueue实例 2.调用retrieveMetaData函数 从磁盘中恢复diskQueue的状态。diskQueue会定时将自己的状态备份到文件中 3.开启一个协程执行ioLoop函数，ioLoop函数是整个disQueue最核心的方法，作用是实现disQueue的消息循环，定时刷新文件，读写操作功能`

func New(name string, dataPath string, maxBytesPerFile int64,
    	minMsgSize int32, maxMsgSize int32,
    	syncEvery int64, syncTimeout time.Duration, logf AppLogFunc) Interface {
    	d := diskQueue{
    		name:              name,
    		dataPath:          dataPath,
    		maxBytesPerFile:   maxBytesPerFile,
    		minMsgSize:        minMsgSize,
    		maxMsgSize:        maxMsgSize,
    		readChan:          make(chan []byte),
    		writeChan:         make(chan []byte),
    		writeResponseChan: make(chan error),
    		emptyChan:         make(chan int),
    		emptyResponseChan: make(chan error),
    		exitChan:          make(chan int),
    		exitSyncChan:      make(chan int),
    		syncEvery:         syncEvery,
    		syncTimeout:       syncTimeout,
    		logf:              logf,
    	}
    
    	// no need to lock here, nothing else could possibly be touching this instance
    	err := d.retrieveMetaData()
    	if err != nil && !os.IsNotExist(err) {
    		d.logf(ERROR, "DISKQUEUE(%s) failed to retrieveMetaData - %s", d.name, err)
    	}
    
    	go d.ioLoop()
    	return &d
    }

###      retrieveMetaData函数 ###

retrieveMetaData函数记录了disQueue的元数据readPos、writePos、readFileNum、writeFileNum、depth

1.retrieveMetaData()函数用于初始化文件系统，作用是当程序突然中止，文件中的消息未读完，该函数用于初始化读写的文件编号和位置及未读的消息数depth

2.retrieveMetaData函数从磁盘中恢复diskQueue的状态。diskQueue会定时将自己的状态备份到文件中，

3.文件名由metaDataFileName函数确定。retrieveMetaData函数同样通过metaDataFileName函数获得保存状态的文件名并打开。

4.  该文件只有三行，格式为%d\\n%d,%d\\n%d,%d\\n，第一行保存着该diskQueue中未读的消息数量（depth），第二行保存readFileNum和readPos，第三行保存writeFileNum和writePos。

func (d *diskQueue) retrieveMetaData() error {
    	var f *os.File
    	var err error
    
    	fileName := d.metaDataFileName()  //获取文件名
    	f, err = os.OpenFile(fileName, os.O_RDONLY, 0600)
    	if err != nil {
    		return err
    	}
    	defer f.Close()
    
    	var depth int64
    	_, err = fmt.Fscanf(f, "%d\n%d,%d\n%d,%d\n",
    		&depth,
    		&d.readFileNum, &d.readPos,
    		&d.writeFileNum, &d.writePos)
    	if err != nil {
    		return err
    	}
    	atomic.StoreInt64(&d.depth, depth)
    	d.nextReadFileNum = d.readFileNum
    	d.nextReadPos = d.readPos
    
    	return nil
    }

### persistMetaData函数 ###

与retrieveMetaData相对应的是persistMetaData函数，这个函数将运行时的元数据保存到文件用于下次重新构建diskQueue时的恢复。

逻辑基本与retrieveMetaData，此处不再赘述。

func (d *diskQueue) persistMetaData() error {
    	var f *os.File
    	var err error
    
    	fileName := d.metaDataFileName()
    	tmpFileName := fmt.Sprintf("%s.%d.tmp", fileName, rand.Int())
    
    	// write to tmp file
    	f, err = os.OpenFile(tmpFileName, os.O_RDWR|os.O_CREATE, 0600)
    	if err != nil {
    		return err
    	}
    
    	_, err = fmt.Fprintf(f, "%d\n%d,%d\n%d,%d\n",
    		atomic.LoadInt64(&d.depth),
    		d.readFileNum, d.readPos,
    		d.writeFileNum, d.writePos)
    	if err != nil {
    		f.Close()
    		return err
    	}
    	f.Sync()
    	f.Close()
    
    	// atomically rename
    	return os.Rename(tmpFileName, fileName)
    }

## 二、diskQueue的消息循环 ##

ioLoop函数实现了diskQueue的消息循环功能，即轮询读写、刷新文件等操作。

刷新文件的目的：防止突然结束程序后内存中的内容未被提交到磁盘，导致内容丢失

有两种情况下会刷新文件

1.当count达到syncEvery时，即读写的次数累积到syncEvery。刷新文件后count会被置为0

2.定时刷新，每syncTimeOut就会刷新文件

count的变化规则

1.如果一次消息循环中，有读或写操作，count会自增1

2.当count达到syncEvery时，count会置为0，并刷新文件

3.当收到emptyChan消失时，会将count置为0，因为文件已经被删除了

判断文件中有可读的消息

(d.readFileNum < d.writeFileNum) || (d.readPos < d.writePos)  即读的文件编号小于写的文件编号或者读的指针偏移量小于写的指针偏移量

读取文件中的下一条消息需要满足两个条件：

1.文件中有可读的消息

2. d.nextReadPos = d.readPos 即上次读到的消息已经投递出去，需要读取下条新消息

d.nextReadPos 和 d.readPos的区别

nextReadPos是下次要读取消息的偏移量，读取的消息会赋值给dataRead。

当消息读取到之后不一定本次循环一定会执行       case r <- dataRead: 将消息投递出去，也可能会执行其他的case分支。此时nextReadPos是下次要读的消息的位置，而readPos是本次消息读的位置

nextReadPos是下次要读取消息的偏移量，也是消息投递成功后需要读的位置。而readPos当消息投递出去才会等于nextReadPos的值

可以简单理解为：

消息读取前   nextReadPos = readPos

消息已读取，但没有投递出去，nextReadPos是下次消息要读的位置，而readPos仍是本次消息读的开始位置。此时：nextReadPos =  readPos + 本条消息的长度

消息投递成功后： readPos  = nextReadPos   ，将nextReadPos的值赋值给readPos

func (d *diskQueue) ioLoop() {
    	var dataRead []byte
    	var err error
    	var count int64   //读写的累积次数
    	var r chan []byte
    
    	syncTicker := time.NewTicker(d.syncTimeout)
    
    	for {
    		// dont sync all the time :)
    		if count == d.syncEvery {
    			d.needSync = true
    		}
    
    		if d.needSync {
    			err = d.sync()
    			if err != nil {
    				d.logf(ERROR, "DISKQUEUE(%s) failed to sync - %s", d.name, err)
    			}
    			count = 0
    		}
    
    		if (d.readFileNum < d.writeFileNum) || (d.readPos < d.writePos) {  //消息文件中有可以读的消息
    			if d.nextReadPos == d.readPos { //即上次读到的消息已经投递出去，需要读取下条新消息
    				dataRead, err = d.readOne()
    				if err != nil {
    					d.logf(ERROR, "DISKQUEUE(%s) reading at %d of %s - %s",
    						d.name, d.readPos, d.fileName(d.readFileNum), err)
    					d.handleReadError()
    					continue
    				}
    			}
    			r = d.readChan
    		} else {
    			r = nil
    		}
    
    		select {
    		// the Go channel spec dictates that nil channel operations (read or write)
    		// in a select are skipped, we set r to d.readChan only when there is data to read
    		//如果r为空，则这个分支会被跳过。这个特性的使用了select的逻辑，简化了当数据为空时的判断
    		case r <- dataRead:
    			count++
    			// moveForward sets needSync flag if a file is removed
    			d.moveForward()
    		case <-d.emptyChan:
    			d.emptyResponseChan <- d.deleteAllFiles()
    			count = 0
    		case dataWrite := <-d.writeChan:
    			count++
    			d.writeResponseChan <- d.writeOne(dataWrite)
    		case <-syncTicker.C:
    			if count == 0 {
    				// avoid sync when there's no activity
    				continue
    			}
    			d.needSync = true
    		case <-d.exitChan:
    			goto exit
    		}
    	}
    
    exit:
    	d.logf(INFO, "DISKQUEUE(%s): closing ... ioLoop", d.name)
    	syncTicker.Stop()
    	d.exitSyncChan <- 1
    }

## 三、文件写操作 ##

writeOne函数负责将消息写入到文件中

1.如果writeFile为nil，则需要新建文件

2.如果writePos大于0，则设置写的指针偏移量

3.校验消息长度

4.将消息的长度(4个字节) 和 消息作为一条消息写入到文件中

5.改变 writePos 和depth的值

6.如果写的指针偏移量大于每个文件的最大字节数，将writeFileNum递增，并将writeFile置为nil，用于下次写入消息的时候创建文件

func (d *diskQueue) writeOne(data []byte) error {
    	var err error
    
    	if d.writeFile == nil {  //如果writeFile为nil
    		curFileName := d.fileName(d.writeFileNum)  //根据writeFileNum获取文件名称
    		d.writeFile, err = os.OpenFile(curFileName, os.O_RDWR|os.O_CREATE, 0600) //创建文件
    		if err != nil {
    			return err
    		}
    
    		d.logf(INFO, "DISKQUEUE(%s): writeOne() opened %s", d.name, curFileName)
    
    		if d.writePos > 0 {  //如果writePos大于0，则设置写的指针偏移量
    			_, err = d.writeFile.Seek(d.writePos, 0)
    			if err != nil {
    				d.writeFile.Close()
    				d.writeFile = nil
    				return err
    			}
    		}
    	}
    
    	dataLen := int32(len(data))   //本次消息的长度
    
    	if dataLen < d.minMsgSize || dataLen > d.maxMsgSize {  //校验消息长度
    		return fmt.Errorf("invalid message write size (%d) maxMsgSize=%d", dataLen, d.maxMsgSize)
    	}
    
    	d.writeBuf.Reset()  //重置writeBuf缓冲区
    	err = binary.Write(&d.writeBuf, binary.BigEndian, dataLen)  //将数据长度dataLen以二进制大端的形式写入到writeBuf中
    	if err != nil {
    		return err
    	}
    
    	_, err = d.writeBuf.Write(data)   //将data写入到writeBuf缓冲区中
    	if err != nil {
    		return err
    	}
    
    	// only write to the file once
    	_, err = d.writeFile.Write(d.writeBuf.Bytes())  //将writeBuf缓冲区的数据写入到文件中
    	if err != nil {
    		d.writeFile.Close()
    		d.writeFile = nil
    		return err
    	}
    
    	totalBytes := int64(4 + dataLen)
    	d.writePos += totalBytes   //改变writePos（写的偏移量）
    	atomic.AddInt64(&d.depth, 1)  //depth的值加1
    
    	if d.writePos > d.maxBytesPerFile {    //如果写的指针偏移量大于每个文件的最大字节数
    	/*
    	将writeFileNum递增1，用于创建下一个文件使用
    	writePos写的指针偏移量置为0
    	刷新文件
    	关闭文件
    	将writeFile置为nil，那么下次有新消息需要写入文件则会新建文件
    	这个操作的目的是为了防止单个文件过大
    	*/
    		d.writeFileNum++
    		d.writePos = 0
    
    		// sync every time we start writing to a new file
    		err = d.sync()
    		if err != nil {
    			d.logf(ERROR, "DISKQUEUE(%s) failed to sync - %s", d.name, err)
    		}
    
    		if d.writeFile != nil {
    			d.writeFile.Close()
    			d.writeFile = nil
    		}
    	}
    
    	return err
    }

# #

## 四、文件读操作 ##

readOne函数主要用于从文件中读取下一条未读消息

主要流程：

1.如果readFile为nil，则读取新的文件

2.根据readPos获取读的位置，并读取4个字节（即本条消息的长度），然后读取本条消息

3.更新 nextReadPos和nextReadFileNum 的值

4.如果下次需要读的位置大于每个文件的最大值，则将nextReadFileNum递增，nextReadPos置为0，关闭readFile并置为nil。这样下次就会读取下一个文件的消息

5.最后返回本条消息的内容

func (d *diskQueue) readOne() ([]byte, error) {
    	var err error
    	var msgSize int32
    
    	if d.readFile == nil { //如果readFile为nil，则读取新的文件
    	/*
    	获取并打开需要读取的文件
    	*/
    		curFileName := d.fileName(d.readFileNum)
    		d.readFile, err = os.OpenFile(curFileName, os.O_RDONLY, 0600)
    		if err != nil {
    			return nil, err
    		}
    
    		d.logf(INFO, "DISKQUEUE(%s): readOne() opened %s", d.name, curFileName)
    
    		if d.readPos > 0 {//如果readPos大于0，则设置读的指针偏移量
    			_, err = d.readFile.Seek(d.readPos, 0)
    			if err != nil {
    				d.readFile.Close()
    				d.readFile = nil
    				return nil, err
    			}
    		}
    
    		d.reader = bufio.NewReader(d.readFile)  //设置reader
    	}
    
    	err = binary.Read(d.reader, binary.BigEndian, &msgSize)  //从reader中读取4个字节，也就是本条消息的长度
    	if err != nil {
    		d.readFile.Close()
    		d.readFile = nil
    		return nil, err
    	}
    
    	if msgSize < d.minMsgSize || msgSize > d.maxMsgSize {  //校验消息长度
    		// this file is corrupt and we have no reasonable guarantee on
    		// where a new message should begin
    		d.readFile.Close()
    		d.readFile = nil
    		return nil, fmt.Errorf("invalid message read size (%d)", msgSize)
    	}
    
    	readBuf := make([]byte, msgSize)
    	_, err = io.ReadFull(d.reader, readBuf)  //将消息读取到reaBuf中
    	if err != nil {
    		d.readFile.Close()
    		d.readFile = nil
    		return nil, err
    	}
    
    	totalBytes := int64(4 + msgSize)
    
    	// we only advance next* because we have not yet sent this to consumers
    	// (where readFileNum, readPos will actually be advanced)
    	d.nextReadPos = d.readPos + totalBytes   //设置下次需要读的指针偏移量
    	d.nextReadFileNum = d.readFileNum
    
    	// TODO: each data file should embed the maxBytesPerFile
    	// as the first 8 bytes (at creation time) ensuring that
    	// the value can change without affecting runtime
    	if d.nextReadPos > d.maxBytesPerFile {  //如果下次需要读的位置大于每个文件的最大值
    	/*
    	关闭正在读的文件,并置为nil
    	nextReadFileNum递增1
    	nextReadPos置为0
    	*/
    		if d.readFile != nil {
    			d.readFile.Close()
    			d.readFile = nil
    		}
    
    		d.nextReadFileNum++
    		d.nextReadPos = 0
    	}
    
    	return readBuf, nil
    }

## 五、文件刷新 ##

sync函数主要用于刷新文件

1.调用file的Sync()函数，将缓存中的消息持久化到文件中

2.将元数据更新持久化

func (d *diskQueue) sync() error {
    	if d.writeFile != nil {
    		err := d.writeFile.Sync()
    		if err != nil {
    			d.writeFile.Close()
    			d.writeFile = nil
    			return err
    		}
    	}
    
    	err := d.persistMetaData()
    	if err != nil {
    		return err
    	}
    
    	d.needSync = false
    	return nil
    }

以上就是diskQueue文件队列的主要实现流程和方法。