Update variable names.

Author: kev1n80

diskqueue.go

@@ -71,7 +71,7 @@ type diskQueue struct {
 	// instantiation time metadata
 	name                string
 	dataPath            string
-	maxBytesDiskSpace   int64
+	maxBytesDiskSize    int64
 	maxBytesPerFile     int64 // cannot change once created
 	maxBytesPerFileRead int64
 	minMsgSize          int32
@@ -106,7 +106,7 @@ type diskQueue struct {
 	logf AppLogFunc
 
 	// disk limit implementation flag
-	diskLimitFeatIsOn bool
+	enableDiskLimitation bool
 }
 
 // New instantiates an instance of diskQueue, retrieving metadata
@@ -115,43 +115,43 @@ func New(name string, dataPath string, maxBytesPerFile int64,
 	minMsgSize int32, maxMsgSize int32,
 	syncEvery int64, syncTimeout time.Duration, logf AppLogFunc) Interface {
 
-	return NewWithDiskSpace(name, dataPath,
+	return NewWithDiskSize(name, dataPath,
 		0, maxBytesPerFile,
 		minMsgSize, maxMsgSize,
 		syncEvery, syncTimeout, logf)
 }
 
-// Another constructor that allows users to use Disk Space Limit feature
-// If user is not using Disk Space Limit feature, maxBytesDiskSpace will
+// Another constructor that allows users to use Disk Size Limit feature
+// If user is not using Disk Size Limit feature, maxBytesDiskSize will
 // be 0
-func NewWithDiskSpace(name string, dataPath string,
-	maxBytesDiskSpace int64, maxBytesPerFile int64,
+func NewWithDiskSize(name string, dataPath string,
+	maxBytesDiskSize int64, maxBytesPerFile int64,
 	minMsgSize int32, maxMsgSize int32,
 	syncEvery int64, syncTimeout time.Duration, logf AppLogFunc) Interface {
-	diskLimitFeatIsOn := true
-	if maxBytesDiskSpace <= 0 {
-		maxBytesDiskSpace = 0
-		diskLimitFeatIsOn = false
+	enableDiskLimitation := true
+	if maxBytesDiskSize <= 0 {
+		maxBytesDiskSize = 0
+		enableDiskLimitation = false
 	}
 	d := diskQueue{
-		name:              name,
-		dataPath:          dataPath,
-		maxBytesDiskSpace: maxBytesDiskSpace,
-		maxBytesPerFile:   maxBytesPerFile,
-		minMsgSize:        minMsgSize,
-		maxMsgSize:        maxMsgSize,
-		readChan:          make(chan []byte),
-		depthChan:         make(chan int64),
-		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,
-		diskLimitFeatIsOn: diskLimitFeatIsOn,
+		name:                 name,
+		dataPath:             dataPath,
+		maxBytesDiskSize:     maxBytesDiskSize,
+		maxBytesPerFile:      maxBytesPerFile,
+		minMsgSize:           minMsgSize,
+		maxMsgSize:           maxMsgSize,
+		readChan:             make(chan []byte),
+		depthChan:            make(chan int64),
+		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,
+		enableDiskLimitation: enableDiskLimitation,
 	}
 
 	d.start()
@@ -335,7 +335,7 @@ func (d *diskQueue) readOne() ([]byte, error) {
 			stat, err := d.readFile.Stat()
 			if err == nil {
 				d.maxBytesPerFileRead = stat.Size()
-				if d.diskLimitFeatIsOn {
+				if d.enableDiskLimitation {
 					// last 8 bytes are reserved for the number of messages in this file
 					d.maxBytesPerFileRead -= 8
 				}
@@ -437,7 +437,7 @@ func (d *diskQueue) writeOne(data []byte) error {
 	totalBytes := int64(4 + dataLen)
 
 	// check if we reached the file size limit with this message
-	if d.diskLimitFeatIsOn && d.writePos+totalBytes+8 >= d.maxBytesPerFile {
+	if d.enableDiskLimitation && d.writePos+totalBytes+8 >= d.maxBytesPerFile {
 		// write number of messages in binary to file
 		err = binary.Write(&d.writeBuf, binary.BigEndian, d.writeMessages+1)
 		if err != nil {
@@ -458,7 +458,7 @@ func (d *diskQueue) writeOne(data []byte) error {
 
 	fileSize := d.writePos
 
-	if d.diskLimitFeatIsOn {
+	if d.enableDiskLimitation {
 		// save space for the number of messages in this file
 		fileSize += 8
 		d.writeMessages += 1
@@ -520,8 +520,8 @@ func (d *diskQueue) retrieveMetaData() error {
 	}
 	defer f.Close()
 
-	// if user is using disk space limit feature
-	if d.diskLimitFeatIsOn {
+	// if user is using disk size limit feature
+	if d.enableDiskLimitation {
 		_, err = fmt.Fscanf(f, "%d\n%d,%d,%d\n%d,%d,%d\n",
 			&d.depth,
 			&d.readFileNum, &d.readMessages, &d.readPos,
@@ -557,8 +557,8 @@ func (d *diskQueue) persistMetaData() error {
 		return err
 	}
 
-	// if user is using disk space limit feature
-	if d.diskLimitFeatIsOn {
+	// if user is using disk size limit feature
+	if d.enableDiskLimitation {
 		_, err = fmt.Fprintf(f, "%d\n%d,%d,%d\n%d,%d,%d\n",
 			d.depth,
 			d.readFileNum, d.readMessages, d.readPos,

diskqueue_test.go

@@ -259,22 +259,22 @@ type md struct {
 	writePos      int64
 }
 
-func readMetaDataFile(fileName string, retried int, diskLimitFeatIsOn bool) md {
+func readMetaDataFile(fileName string, retried int, enableDiskLimitation bool) md {
 	f, err := os.OpenFile(fileName, os.O_RDONLY, 0600)
 	if err != nil {
 		// provide a simple retry that results in up to
 		// another 500ms for the file to be written.
 		if retried < 9 {
 			retried++
 			time.Sleep(50 * time.Millisecond)
-			return readMetaDataFile(fileName, retried, diskLimitFeatIsOn)
+			return readMetaDataFile(fileName, retried, enableDiskLimitation)
 		}
 		panic(err)
 	}
 	defer f.Close()
 
 	var ret md
-	if diskLimitFeatIsOn {
+	if enableDiskLimitation {
 		_, err = fmt.Fscanf(f, "%d\n%d,%d,%d\n%d,%d,%d\n",
 			&ret.depth,
 			&ret.readFileNum, &ret.readMessages, &ret.readPos,
@@ -348,7 +348,7 @@ func TestDiskQueueSyncAfterReadWithDiskSizeImplementation(t *testing.T) {
 		panic(err)
 	}
 	defer os.RemoveAll(tmpDir)
-	dq := NewWithDiskSpace(dqName, tmpDir, 1<<11, 1<<11, 0, 1<<10, 2500, 50*time.Millisecond, l)
+	dq := NewWithDiskSize(dqName, tmpDir, 1<<11, 1<<11, 0, 1<<10, 2500, 50*time.Millisecond, l)
 	defer dq.Close()
 
 	msgSize := 1000