Skip to content

SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.

21.5 KB
Raw Blame
package filer

import (
	"bytes"
	"container/list"
	"context"
	"fmt"
	"io"
	"math"
	"strings"
	"sync"
	"time"

	"slices"

	"github.com/seaweedfs/seaweedfs/weed/glog"
	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/security"
	"github.com/seaweedfs/seaweedfs/weed/stats"
	"github.com/seaweedfs/seaweedfs/weed/util"
	util_http "github.com/seaweedfs/seaweedfs/weed/util/http"
	"github.com/seaweedfs/seaweedfs/weed/wdclient"
)

var getLookupFileIdBackoffSchedule = []time.Duration{
	150 * time.Millisecond,
	600 * time.Millisecond,
	1800 * time.Millisecond,
}

var (
	jwtSigningReadKey        security.SigningKey
	jwtSigningReadKeyExpires int
	loadJwtConfigOnce        sync.Once
)

func loadJwtConfig() {
	v := util.GetViper()
	jwtSigningReadKey = security.SigningKey(v.GetString("jwt.signing.read.key"))
	jwtSigningReadKeyExpires = v.GetInt("jwt.signing.read.expires_after_seconds")
	if jwtSigningReadKeyExpires == 0 {
		jwtSigningReadKeyExpires = 60
	}
}

// JwtForVolumeServer generates a JWT token for volume server read operations if jwt.signing.read is configured
func JwtForVolumeServer(fileId string) string {
	loadJwtConfigOnce.Do(loadJwtConfig)
	if len(jwtSigningReadKey) == 0 {
		return ""
	}
	return string(security.GenJwtForVolumeServer(jwtSigningReadKey, jwtSigningReadKeyExpires, fileId))
}

// ChunkReadJwt returns the credential for reading fileId from urlStrings. A
// lookup answers with the volume servers holding the needle or with a filer
// proxying it, never a mix. A proxied chunk is a request to the filer, which
// authorizes it and attaches the volume credential itself, so the token there
// is a filer one.
func ChunkReadJwt(urlStrings []string, fileId string) string {
	if len(urlStrings) > 0 && util_http.IsProxyChunkUrl(urlStrings[0]) {
		return util_http.JwtForFilerServer(false)
	}
	return JwtForVolumeServer(fileId)
}

func HasData(entry *filer_pb.Entry) bool {

	if len(entry.Content) > 0 {
		return true
	}

	return len(entry.GetChunks()) > 0
}

func IsSameData(a, b *filer_pb.Entry) bool {

	if len(a.Content) > 0 || len(b.Content) > 0 {
		return bytes.Equal(a.Content, b.Content)
	}

	return isSameChunks(a.Chunks, b.Chunks)
}

func isSameChunks(a, b []*filer_pb.FileChunk) bool {
	if len(a) != len(b) {
		return false
	}
	sortedA := slices.Clone(a)
	sortedB := slices.Clone(b)
	slices.SortFunc(sortedA, func(i, j *filer_pb.FileChunk) int {
		return strings.Compare(i.ETag, j.ETag)
	})
	slices.SortFunc(sortedB, func(i, j *filer_pb.FileChunk) int {
		return strings.Compare(i.ETag, j.ETag)
	})
	for i := 0; i < len(sortedA); i++ {
		if sortedA[i].ETag != sortedB[i].ETag {
			return false
		}
	}
	return true
}

func NewFileReader(filerClient filer_pb.FilerClient, entry *filer_pb.Entry) io.Reader {
	if len(entry.Content) > 0 {
		return bytes.NewReader(entry.Content)
	}
	return NewChunkStreamReader(filerClient, entry.GetChunks())
}

type DoStreamContent func(writer io.Writer) error

func PrepareStreamContent(masterClient wdclient.HasLookupFileIdFunction, jwtFunc VolumeServerJwtFunction, chunks []*filer_pb.FileChunk, offset int64, size int64) (DoStreamContent, error) {
	return PrepareStreamContentWithThrottler(context.Background(), masterClient, jwtFunc, chunks, offset, size, 0)
}

type VolumeServerJwtFunction func(fileId string) string

// refreshUrls lets a fetch loop relearn a chunk's locations inside a single
// read: drop the cached entry and look it up again, whether every location
// failed or one did while another answered. Nil when there is nothing to
// invalidate against. A cancelled read keeps the cached locations.
func refreshUrls(ctx context.Context, invalidator CacheInvalidator, lookupFn wdclient.LookupFileIdFunctionType, fileId string) util_http.RefreshUrlsFunc {
	if invalidator == nil || lookupFn == nil {
		return nil
	}
	return func() []string {
		if ctx.Err() != nil {
			return nil
		}
		invalidator.InvalidateCache(fileId)
		urls, err := lookupFn(ctx, fileId)
		if err != nil {
			glog.V(0).InfofCtx(ctx, "re-lookup chunk %s: %v", fileId, err)
			return nil
		}
		return urls
	}
}

// retryFetchWithFreshLocations is the shared self-heal for the read paths: when a chunk fetch
// fails, invalidate the cached volume locations, re-lookup, and call refetch only when the
// resolved locations actually changed (so we never retry against the same servers). originalErr
// is returned unchanged when no retry is attempted, so callers surface the real fetch failure.
func retryFetchWithFreshLocations(ctx context.Context, invalidator CacheInvalidator, lookupFn wdclient.LookupFileIdFunctionType, fileId string, oldUrls []string, originalErr error, refetch func(newUrls []string) error) error {
	// the caller may have gone away between its own check and this one; a
	// cancelled read is no evidence the locations are wrong, and callers such
	// as volume.fsck tell an abort from real corruption with errors.Is
	if ctxErr := ctx.Err(); ctxErr != nil {
		return ctxErr
	}
	if invalidator == nil {
		return originalErr
	}

	glog.V(0).InfofCtx(ctx, "read chunk %s failed, invalidating cache and retrying: %v", fileId, originalErr)
	invalidator.InvalidateCache(fileId)

	newUrls, lookupErr := lookupFn(ctx, fileId)
	if lookupErr != nil {
		glog.WarningfCtx(ctx, "failed to re-lookup chunk %s after cache invalidation: %v", fileId, lookupErr)
		return fmt.Errorf("re-lookup chunk %s after cache invalidation: %w", fileId, lookupErr)
	}
	if len(newUrls) == 0 {
		glog.WarningfCtx(ctx, "re-lookup for chunk %s returned no locations, skipping retry", fileId)
		return fmt.Errorf("re-lookup chunk %s returned no locations", fileId)
	}
	if util_http.SameUrls(oldUrls, newUrls) {
		glog.V(0).InfofCtx(ctx, "re-lookup returned same locations for chunk %s, skipping retry", fileId)
		return originalErr
	}

	glog.V(0).InfofCtx(ctx, "retrying read chunk %s with %d new locations", fileId, len(newUrls))
	return refetch(newUrls)
}

func PrepareStreamContentWithThrottler(ctx context.Context, masterClient wdclient.HasLookupFileIdFunction, jwtFunc VolumeServerJwtFunction, chunks []*filer_pb.FileChunk, offset int64, size int64, downloadMaxBytesPs int64) (DoStreamContent, error) {
	glog.V(4).InfofCtx(ctx, "prepare to stream content for chunks: %d", len(chunks))
	visibles, err := NonOverlappingVisibleIntervals(ctx, masterClient.GetLookupFileIdFunction(), chunks, offset, offset+size)
	if err != nil {
		return nil, err
	}
	chunkViews := ViewFromVisibleIntervals(visibles, offset, size)

	fileId2Url := make(map[string][]string)

	for x := chunkViews.Front(); x != nil; x = x.Next {
		chunkView := x.Value
		var urlStrings []string
		var err error
		for _, backoff := range getLookupFileIdBackoffSchedule {
			if err := ctx.Err(); err != nil {
				return nil, err
			}
			urlStrings, err = masterClient.GetLookupFileIdFunction()(ctx, chunkView.FileId)
			if err == nil && len(urlStrings) > 0 {
				break
			}
			if err := ctx.Err(); err != nil {
				return nil, err
			}
			glog.V(4).InfofCtx(ctx, "waiting for chunk: %s", chunkView.FileId)
			timer := time.NewTimer(backoff)
			select {
			case <-ctx.Done():
				if !timer.Stop() {
					<-timer.C
				}
				return nil, ctx.Err()
			case <-timer.C:
			}
		}
		if err != nil {
			glog.V(1).InfofCtx(ctx, "operation LookupFileId %s failed, err: %v", chunkView.FileId, err)
			return nil, err
		} else if len(urlStrings) == 0 {
			errUrlNotFound := fmt.Errorf("operation LookupFileId %s failed, err: urls not found", chunkView.FileId)
			glog.ErrorCtx(ctx, errUrlNotFound)
			return nil, errUrlNotFound
		}
		fileId2Url[chunkView.FileId] = urlStrings
	}

	return func(writer io.Writer) error {
		downloadThrottler := util.NewWriteThrottler(downloadMaxBytesPs)
		remaining := size
		for x := chunkViews.Front(); x != nil; x = x.Next {
			chunkView := x.Value
			if offset < chunkView.ViewOffset {
				gap := chunkView.ViewOffset - offset
				remaining -= gap
				glog.V(4).InfofCtx(ctx, "zero [%d,%d)", offset, chunkView.ViewOffset)
				err := writeZero(writer, gap)
				if err != nil {
					return fmt.Errorf("write zero [%d,%d)", offset, chunkView.ViewOffset)
				}
				offset = chunkView.ViewOffset
			}
			urlStrings := fileId2Url[chunkView.FileId]
			start := time.Now()
			jwt := jwtFunc(chunkView.FileId)
			invalidator, _ := masterClient.(CacheInvalidator)
			written, err := retriedStreamFetchChunkData(ctx, writer, urlStrings, jwt, chunkView.CipherKey, chunkView.IsGzipped, chunkView.IsFullChunk(), chunkView.OffsetInChunk, int(chunkView.ViewSize), refreshUrls(ctx, invalidator, masterClient.GetLookupFileIdFunction(), chunkView.FileId))

			if err != nil && ctx.Err() != nil {
				return ctx.Err()
			}

			// If read failed, try to invalidate cache and re-lookup
			if err != nil && written == 0 {
				err = retryFetchWithFreshLocations(ctx, invalidator, masterClient.GetLookupFileIdFunction(), chunkView.FileId, urlStrings, err, func(newUrls []string) error {
					_, refetchErr := retriedStreamFetchChunkData(ctx, writer, newUrls, jwt, chunkView.CipherKey, chunkView.IsGzipped, chunkView.IsFullChunk(), chunkView.OffsetInChunk, int(chunkView.ViewSize), nil)
					if refetchErr == nil {
						// Update the map so subsequent references use fresh URLs
						fileId2Url[chunkView.FileId] = newUrls
					}
					return refetchErr
				})
			}

			offset += int64(chunkView.ViewSize)
			remaining -= int64(chunkView.ViewSize)
			stats.FilerRequestHistogram.WithLabelValues("chunkDownload").Observe(time.Since(start).Seconds())
			if err != nil {
				stats.FilerHandlerCounter.WithLabelValues("chunkDownloadError").Inc()
				return fmt.Errorf("read chunk: %w", err)
			}
			stats.FilerHandlerCounter.WithLabelValues("chunkDownload").Inc()
			downloadThrottler.MaybeSlowdown(int64(chunkView.ViewSize))
		}
		if remaining > 0 {
			glog.V(4).InfofCtx(ctx, "zero [%d,%d)", offset, offset+remaining)
			err := writeZero(writer, remaining)
			if err != nil {
				return fmt.Errorf("write zero [%d,%d)", offset, offset+remaining)
			}
		}

		return nil
	}, nil
}

// PrepareStreamContentWithPrefetch is like PrepareStreamContentWithThrottler but uses
// concurrent chunk prefetching to overlap network I/O. When prefetchAhead > 1, fetch
// goroutines establish HTTP connections to volume servers ahead of time, streaming data
// through io.Pipe with minimal memory overhead.
//
// prefetchAhead controls the number of chunks fetched concurrently:
//   - 0 or 1: falls back to sequential fetching (same as PrepareStreamContentWithThrottler)
//   - 2+: uses pipe-based prefetch pipeline with that many concurrent fetches
func PrepareStreamContentWithPrefetch(ctx context.Context, masterClient wdclient.HasLookupFileIdFunction, jwtFunc VolumeServerJwtFunction, chunks []*filer_pb.FileChunk, offset int64, size int64, downloadMaxBytesPs int64, prefetchAhead int) (DoStreamContent, error) {
	if prefetchAhead <= 1 {
		return PrepareStreamContentWithThrottler(ctx, masterClient, jwtFunc, chunks, offset, size, downloadMaxBytesPs)
	}

	glog.V(4).InfofCtx(ctx, "prepare to stream content with prefetch=%d for chunks: %d", prefetchAhead, len(chunks))
	visibles, err := NonOverlappingVisibleIntervals(ctx, masterClient.GetLookupFileIdFunction(), chunks, offset, offset+size)
	if err != nil {
		return nil, err
	}
	chunkViews := ViewFromVisibleIntervals(visibles, offset, size)

	fileId2Url := make(map[string][]string)

	for x := chunkViews.Front(); x != nil; x = x.Next {
		chunkView := x.Value
		var urlStrings []string
		var err error
		for _, backoff := range getLookupFileIdBackoffSchedule {
			if err := ctx.Err(); err != nil {
				return nil, err
			}
			urlStrings, err = masterClient.GetLookupFileIdFunction()(ctx, chunkView.FileId)
			if err == nil && len(urlStrings) > 0 {
				break
			}
			if err := ctx.Err(); err != nil {
				return nil, err
			}
			glog.V(4).InfofCtx(ctx, "waiting for chunk: %s", chunkView.FileId)
			timer := time.NewTimer(backoff)
			select {
			case <-ctx.Done():
				if !timer.Stop() {
					<-timer.C
				}
				return nil, ctx.Err()
			case <-timer.C:
			}
		}
		if err != nil {
			glog.V(1).InfofCtx(ctx, "operation LookupFileId %s failed, err: %v", chunkView.FileId, err)
			return nil, err
		} else if len(urlStrings) == 0 {
			errUrlNotFound := fmt.Errorf("operation LookupFileId %s failed, err: urls not found", chunkView.FileId)
			glog.ErrorCtx(ctx, errUrlNotFound)
			return nil, errUrlNotFound
		}
		fileId2Url[chunkView.FileId] = urlStrings
	}

	return func(writer io.Writer) error {
		return streamChunksPrefetched(ctx, writer, chunkViews, fileId2Url, jwtFunc, masterClient, offset, size, downloadMaxBytesPs, prefetchAhead)
	}, nil
}

func StreamContent(masterClient wdclient.HasLookupFileIdFunction, writer io.Writer, chunks []*filer_pb.FileChunk, offset int64, size int64) error {
	streamFn, err := PrepareStreamContent(masterClient, JwtForVolumeServer, chunks, offset, size)
	if err != nil {
		return err
	}
	return streamFn(writer)
}

// ----------------  ReadAllReader ----------------------------------

func writeZero(w io.Writer, size int64) (err error) {
	zeroPadding := make([]byte, 1024)
	var written int
	for size > 0 {
		if size > 1024 {
			written, err = w.Write(zeroPadding)
		} else {
			written, err = w.Write(zeroPadding[:size])
		}
		size -= int64(written)
		if err != nil {
			return
		}
	}
	return
}

// ----------------  ChunkStreamReader ----------------------------------

// A reader buffers recently fetched chunks, not just the last one: readers
// consumed through io.SectionReader (e.g. parallel multipart uploads) keep a
// handful of part-sized windows hot at once, and a single shared buffer would
// refetch a whole chunk on nearly every ReadAt. The bounds cap the memory of
// tiny chunks as well as the total buffered bytes.
const maxBufferedChunks = 16
const maxBufferedChunkBytes = 128 << 20

type bufferedChunk struct {
	offset int64
	data   []byte
}

type ChunkStreamReader struct {
	head              *Interval[*ChunkView]
	chunkView         *Interval[*ChunkView]
	totalSize         int64
	logicOffset       int64
	buffer            []byte
	bufferOffset      int64
	bufferLock        sync.Mutex
	chunk             string
	chunkBuffers      map[int64]*list.Element
	chunkBuffersLru   *list.List
	chunkBuffersBytes int64
	lookupFileId      wdclient.LookupFileIdFunctionType
	sourceErr         error
}

var _ = io.ReadSeeker(&ChunkStreamReader{})
var _ = io.ReaderAt(&ChunkStreamReader{})
var _ = io.Closer(&ChunkStreamReader{})

// doNewChunkStreamReader builds a reader over chunks. If their manifests cannot
// be resolved, the reader fails every read with that error and reports it as its
// SourceError.
func doNewChunkStreamReader(ctx context.Context, lookupFileIdFn wdclient.LookupFileIdFunctionType, chunks []*filer_pb.FileChunk) *ChunkStreamReader {

	chunkViews, err := ViewFromChunks(ctx, lookupFileIdFn, chunks, 0, math.MaxInt64)
	if err != nil {
		return &ChunkStreamReader{
			lookupFileId: lookupFileIdFn,
			sourceErr:    err,
		}
	}

	var totalSize int64
	for x := chunkViews.Front(); x != nil; x = x.Next {
		chunk := x.Value
		totalSize += int64(chunk.ViewSize)
	}

	return &ChunkStreamReader{
		head:         chunkViews.Front(),
		chunkView:    chunkViews.Front(),
		lookupFileId: lookupFileIdFn,
		totalSize:    totalSize,
	}
}

func NewChunkStreamReaderFromFiler(ctx context.Context, masterClient *wdclient.MasterClient, chunks []*filer_pb.FileChunk) *ChunkStreamReader {

	return doNewChunkStreamReader(ctx, masterClient.GetLookupFileIdFunction(), chunks)
}

// NewChunkStreamReaderFromLookup creates a ChunkStreamReader from a lookup function.
// Used by clients that already have a LookupFileIdFunctionType (e.g., from FilerSource).
func NewChunkStreamReaderFromLookup(ctx context.Context, lookupFn wdclient.LookupFileIdFunctionType, chunks []*filer_pb.FileChunk) *ChunkStreamReader {
	return doNewChunkStreamReader(ctx, lookupFn, chunks)
}

func NewChunkStreamReader(filerClient filer_pb.FilerClient, chunks []*filer_pb.FileChunk) *ChunkStreamReader {

	lookupFileIdFn := LookupFn(filerClient)

	return doNewChunkStreamReader(context.Background(), lookupFileIdFn, chunks)
}

func (c *ChunkStreamReader) ReadAt(p []byte, off int64) (n int, err error) {
	c.bufferLock.Lock()
	defer c.bufferLock.Unlock()
	if err = c.prepareBufferFor(off); err != nil {
		return
	}
	c.logicOffset = off
	return c.doRead(p)
}

func (c *ChunkStreamReader) Read(p []byte) (n int, err error) {
	c.bufferLock.Lock()
	defer c.bufferLock.Unlock()
	return c.doRead(p)
}

func (c *ChunkStreamReader) doRead(p []byte) (n int, err error) {
	// fmt.Printf("do read [%d,%d) at %s[%d,%d)\n", c.logicOffset, c.logicOffset+int64(len(p)), c.chunk, c.bufferOffset, c.bufferOffset+int64(len(c.buffer)))
	for n < len(p) {
		// println("read", c.logicOffset)
		if err = c.prepareBufferFor(c.logicOffset); err != nil {
			return
		}
		t := copy(p[n:], c.buffer[c.logicOffset-c.bufferOffset:])
		n += t
		c.logicOffset += int64(t)
	}
	return
}

func (c *ChunkStreamReader) isBufferEmpty() bool {
	return len(c.buffer) <= int(c.logicOffset-c.bufferOffset)
}

func (c *ChunkStreamReader) Seek(offset int64, whence int) (int64, error) {
	c.bufferLock.Lock()
	defer c.bufferLock.Unlock()

	var err error
	switch whence {
	case io.SeekStart:
	case io.SeekCurrent:
		offset += c.logicOffset
	case io.SeekEnd:
		offset = c.totalSize + offset
	}
	if offset > c.totalSize {
		err = io.ErrUnexpectedEOF
	} else {
		c.logicOffset = offset
	}

	return offset, err

}

func insideChunk(offset int64, chunk *ChunkView) bool {
	return chunk.ViewOffset <= offset && offset < chunk.ViewOffset+int64(chunk.ViewSize)
}

func (c *ChunkStreamReader) prepareBufferFor(offset int64) (err error) {
	// a reader without chunk views has a source error only if ViewFromChunks failed
	if c.head == nil && c.sourceErr != nil {
		return c.sourceErr
	}
	// stay in the same chunk
	if c.bufferOffset <= offset && offset < c.bufferOffset+int64(len(c.buffer)) {
		return nil
	}
	// glog.V(2).Infof("c.chunkView: %v buffer:[%d,%d) offset:%d totalSize:%d", c.chunkView, c.bufferOffset, c.bufferOffset+int64(len(c.buffer)), offset, c.totalSize)

	// find a possible chunk view
	p := c.chunkView
	for p != nil {
		chunk := p.Value
		// glog.V(2).Infof("prepareBufferFor check chunk:[%d,%d)", chunk.ViewOffset, chunk.ViewOffset+int64(chunk.ViewSize))
		if insideChunk(offset, chunk) {
			if c.isBufferEmpty() || c.bufferOffset != chunk.ViewOffset {
				c.chunkView = p
				return c.fetchChunkToBuffer(chunk)
			}
		}
		if offset < c.bufferOffset {
			p = p.Prev
		} else {
			p = p.Next
		}
	}

	return io.EOF
}

func (c *ChunkStreamReader) fetchChunkToBuffer(chunkView *ChunkView) error {
	if elem, ok := c.chunkBuffers[chunkView.ViewOffset]; ok {
		buffered := elem.Value.(*bufferedChunk)
		c.chunkBuffersLru.MoveToFront(elem)
		c.buffer = buffered.data
		c.bufferOffset = buffered.offset
		c.chunk = chunkView.FileId
		return nil
	}
	urlStrings, err := c.lookupFileId(context.Background(), chunkView.FileId)
	if err != nil {
		glog.V(1).Infof("operation LookupFileId %s failed, err: %v", chunkView.FileId, err)
		return c.rememberSourceError(err)
	}
	var buffer bytes.Buffer
	// pre-size to the known chunk size; avoids bytes.Buffer's doubling regrowth
	buffer.Grow(int(chunkView.ViewSize))
	var shouldRetry bool
	jwt := ChunkReadJwt(urlStrings, chunkView.FileId)
	for _, urlString := range urlStrings {
		shouldRetry, err = util_http.ReadUrlAsStream(context.Background(), util_http.AppendQueryParameter(urlString, "readDeleted", "true"), jwt, chunkView.CipherKey, chunkView.IsGzipped, chunkView.IsFullChunk(), chunkView.OffsetInChunk, int(chunkView.ViewSize), func(data []byte) {
			buffer.Write(data)
		})
		if !shouldRetry {
			break
		}
		if err != nil {
			glog.V(1).Infof("read %s failed, err: %v", chunkView.FileId, err)
			buffer.Reset()
		} else {
			break
		}
	}
	if err != nil {
		return c.rememberSourceError(err)
	}
	c.buffer = buffer.Bytes()
	c.bufferOffset = chunkView.ViewOffset
	c.chunk = chunkView.FileId
	c.rememberBufferedChunk(chunkView.ViewOffset, c.buffer)

	// glog.V(0).Infof("fetched %s [%d,%d)", chunkView.FileId, chunkView.ViewOffset, chunkView.ViewOffset+int64(chunkView.ViewSize))

	return nil
}

// rememberBufferedChunk caches a fetched chunk by its view offset and evicts
// the least recently used ones past the bounds. The chunk just inserted always
// survives eviction so the read that fetched it can proceed.
func (c *ChunkStreamReader) rememberBufferedChunk(offset int64, data []byte) {
	if c.chunkBuffers == nil {
		c.chunkBuffers = make(map[int64]*list.Element)
		c.chunkBuffersLru = list.New()
	}
	c.chunkBuffers[offset] = c.chunkBuffersLru.PushFront(&bufferedChunk{offset: offset, data: data})
	c.chunkBuffersBytes += int64(len(data))
	for c.chunkBuffersLru.Len() > 1 &&
		(c.chunkBuffersLru.Len() > maxBufferedChunks || c.chunkBuffersBytes > maxBufferedChunkBytes) {
		back := c.chunkBuffersLru.Back()
		evicted := back.Value.(*bufferedChunk)
		c.chunkBuffersLru.Remove(back)
		delete(c.chunkBuffers, evicted.offset)
		c.chunkBuffersBytes -= int64(len(evicted.data))
	}
}

func (c *ChunkStreamReader) rememberSourceError(err error) error {
	if c.sourceErr == nil {
		c.sourceErr = err
	}
	return err
}

// SourceError returns the first lookup or chunk read failure, or nil.
func (c *ChunkStreamReader) SourceError() error {
	c.bufferLock.Lock()
	defer c.bufferLock.Unlock()
	return c.sourceErr
}

// ReaderSourceError returns the SourceError of a reader from NewFileReader, or nil.
func ReaderSourceError(r io.Reader) error {
	if csr, ok := r.(*ChunkStreamReader); ok {
		return csr.SourceError()
	}
	return nil
}

func (c *ChunkStreamReader) Close() error {
	c.bufferLock.Lock()
	defer c.bufferLock.Unlock()
	c.buffer = nil
	c.chunkBuffers = nil
	c.chunkBuffersLru = nil
	c.chunkBuffersBytes = 0
	c.head = nil
	c.chunkView = nil
	return nil
}

func VolumeId(fileId string) string {
	lastCommaIndex := strings.LastIndex(fileId, ",")
	if lastCommaIndex > 0 {
		return fileId[:lastCommaIndex]
	}
	return fileId
}