Method readAt

pkg/filestore/blockstore_cache.go:206–260

returns (realOffset, data, error)

(ctx context.Context, offset int64, size int64, readFull bool)

// returns (realOffset, data, error)
func (entry *CacheEntry) readAt(ctx context.Context, offset int64, size int64, readFull bool) (int64, []byte, error) {
	if offset < 0 {
		return 0, nil, fmt.Errorf("offset cannot be negative")
	}
	file, err := entry.loadFileForRead(ctx)
	if err != nil {
		return 0, nil, err
	}
	if readFull {
		size = file.Size - offset
	}
	if offset+size > file.Size {
		size = file.Size - offset
	}
	if file.Opts.Circular {
		realDataOffset := int64(0)
		if file.Size > file.Opts.MaxSize {
			realDataOffset = file.Size - file.Opts.MaxSize
		}
		if offset < realDataOffset {
			truncateAmt := realDataOffset - offset
			offset += truncateAmt
			size -= truncateAmt
		}
		if size <= 0 {
			return realDataOffset, nil, nil
		}
	}
	partMap := file.computePartMap(offset, size)
	dataEntryMap, err := entry.loadDataPartsForRead(ctx, getPartIdxsFromMap(partMap))
	if err != nil {
		return 0, nil, err
	}
	// combine the entries into a single byte slice
	// note that we only want part of the first and last part depending on offset and size
	rtnData := make([]byte, 0, size)
	amtLeftToRead := size
	curReadOffset := offset
	for amtLeftToRead > 0 {
		partIdx := file.partIdxAtOffset(curReadOffset)
		partDataEntry := dataEntryMap[partIdx]
		var partData []byte
		if partDataEntry == nil {
			partData = make([]byte, partDataSize)
		} else {
			partData = partDataEntry.Data[0:partDataSize]
		}
		partOffset := curReadOffset % partDataSize
		amtToRead := minInt64(partDataSize-partOffset, amtLeftToRead)
		rtnData = append(rtnData, partData[partOffset:partOffset+amtToRead]...)
		amtLeftToRead -= amtToRead
		curReadOffset += amtToRead
	}
	return offset, rtnData, nil
}

func prunePartsWithCache(dataEntries map[int]*DataCacheEntry, parts []int) []int {
	var rtn []int