snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/filer/persisted_log_cache.go

@@ -0,0 +1,232 @@
+package filer
+
+import (
+	"bytes"
+	"container/list"
+	"context"
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
+	"github.com/seaweedfs/seaweedfs/weed/util"
+	"github.com/seaweedfs/seaweedfs/weed/wdclient"
+	"golang.org/x/sync/semaphore"
+	"golang.org/x/sync/singleflight"
+)
+
+const (
+	// persistedLogCacheMaxBytes bounds retained entries regardless of subscriber count.
+	persistedLogCacheMaxBytes = 256 << 20
+	// persistedLogCacheLoadBudget bounds in-flight fetch+decode bytes, charged
+	// by chunk size: small chunks load wide, full-size ones cap the peak.
+	persistedLogCacheLoadBudget = 128 << 20
+	// persistedLogCacheIdleTTL frees entries no replay has touched recently, so
+	// the cache holds memory only while subscribers actually replay.
+	persistedLogCacheIdleTTL = 5 * time.Minute
+	// maxLogEntrySize guards the per-entry allocation against a corrupt size prefix.
+	maxLogEntrySize = 1 << 30
+)
+
+// errLogChunkIncomplete reports a chunk that does not start and end on record
+// boundaries; the file is then only readable as a whole byte stream.
+var errLogChunkIncomplete = errors.New("log chunk does not hold whole records")
+
+// persistedLogCache shares decoded metadata-log chunks across concurrent
+// SubscribeMetadata replays. Chunks are immutable (each log flush uploads one
+// whole buffer of complete records as a new chunk), so even the actively
+// written current file shares its flushed chunks. Cached entries are shared
+// read-only; callers must not mutate them.
+type persistedLogCache struct {
+	mu       sync.Mutex
+	ll       *list.List // front = most recently used; values are *logCacheItem
+	index    map[string]*list.Element
+	curBytes int64
+	maxBytes int64
+	sf       singleflight.Group
+	loadSem  *semaphore.Weighted
+}
+
+type logCacheItem struct {
+	key      string // chunk file id
+	entries  []*filer_pb.LogEntry
+	bytes    int64
+	lastUsed time.Time
+}
+
+func newPersistedLogCache(maxBytes int64) *persistedLogCache {
+	c := &persistedLogCache{
+		ll:       list.New(),
+		index:    make(map[string]*list.Element),
+		maxBytes: maxBytes,
+		loadSem:  semaphore.NewWeighted(persistedLogCacheLoadBudget),
+	}
+	// the filer's cache lives for the process lifetime
+	go c.loopEvictIdle()
+	return c
+}
+
+func (c *persistedLogCache) loopEvictIdle() {
+	ticker := time.NewTicker(time.Minute)
+	defer ticker.Stop()
+	for range ticker.C {
+		c.evictIdle(time.Now().Add(-persistedLogCacheIdleTTL))
+	}
+}
+
+// evictIdle drops every entry last used at or before cutoff. Recency order
+// makes the idle entries exactly the tail of the LRU list.
+func (c *persistedLogCache) evictIdle(cutoff time.Time) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	for c.ll.Len() > 0 {
+		el := c.ll.Back()
+		if el.Value.(*logCacheItem).lastUsed.After(cutoff) {
+			break
+		}
+		c.removeElement(el)
+	}
+}
+
+type logLoadResult struct {
+	entries []*filer_pb.LogEntry
+	err     error
+}
+
+// getOrLoad returns the decoded entries for a chunk, loading once on miss and
+// coalescing concurrent misses. Only a clean, complete decode is cached: a
+// chunk-not-found read must be re-probed on later replays, and an incomplete
+// chunk stays with the streaming fallback.
+func (c *persistedLogCache) getOrLoad(fileId string, loadBytes int64, load func() ([]*filer_pb.LogEntry, bool, error)) ([]*filer_pb.LogEntry, error) {
+	if entries, ok := c.lookup(fileId); ok {
+		return entries, nil
+	}
+	v, _, _ := c.sf.Do(fileId, func() (interface{}, error) {
+		if entries, ok := c.lookup(fileId); ok {
+			return logLoadResult{entries: entries}, nil
+		}
+		entries, cacheable, loadErr := c.loadGuarded(loadBytes, load)
+		if loadErr == nil && cacheable {
+			c.store(fileId, entries)
+		}
+		return logLoadResult{entries: entries, err: loadErr}, nil
+	})
+	res := v.(logLoadResult)
+	return res.entries, res.err
+}
+
+func (c *persistedLogCache) loadGuarded(loadBytes int64, load func() ([]*filer_pb.LogEntry, bool, error)) ([]*filer_pb.LogEntry, bool, error) {
+	weight := loadBytes
+	if weight < 1 {
+		weight = 1
+	}
+	if weight > persistedLogCacheLoadBudget {
+		// never exceeds the semaphore size, or the acquire could not succeed
+		weight = persistedLogCacheLoadBudget
+	}
+	if err := c.loadSem.Acquire(context.Background(), weight); err != nil {
+		return nil, false, err
+	}
+	defer c.loadSem.Release(weight)
+	return load()
+}
+
+func (c *persistedLogCache) lookup(fileId string) ([]*filer_pb.LogEntry, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	el, ok := c.index[fileId]
+	if !ok {
+		return nil, false
+	}
+	c.ll.MoveToFront(el)
+	item := el.Value.(*logCacheItem)
+	item.lastUsed = time.Now()
+	return item.entries, true
+}
+
+func (c *persistedLogCache) store(fileId string, entries []*filer_pb.LogEntry) {
+	bytes := estimateEntriesBytes(entries)
+	if bytes > c.maxBytes {
+		// would evict everything else and still not fit; serve unretained
+		return
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if el, ok := c.index[fileId]; ok {
+		c.removeElement(el)
+	}
+	el := c.ll.PushFront(&logCacheItem{key: fileId, entries: entries, bytes: bytes, lastUsed: time.Now()})
+	c.index[fileId] = el
+	c.curBytes += bytes
+	for c.curBytes > c.maxBytes && c.ll.Len() > 1 {
+		c.removeElement(c.ll.Back())
+	}
+}
+
+// removeElement drops an element from both the list and the index. Caller holds mu.
+func (c *persistedLogCache) removeElement(el *list.Element) {
+	item := el.Value.(*logCacheItem)
+	c.ll.Remove(el)
+	delete(c.index, item.key)
+	c.curBytes -= item.bytes
+}
+
+// estimateEntriesBytes is deliberately generous so curBytes does not run under
+// the real retained heap.
+func estimateEntriesBytes(entries []*filer_pb.LogEntry) int64 {
+	total := int64(len(entries)) * 128
+	for _, e := range entries {
+		total += int64(len(e.Data)+len(e.Key)) + 16
+	}
+	return total
+}
+
+// loadLogFileEntries reads one log file chunk from volume servers and decodes
+// its records. fetchWholeChunk handles lookup, retries, cipher and gzip.
+func loadLogFileEntries(masterClient *wdclient.MasterClient, chunk *filer_pb.FileChunk) (entries []*filer_pb.LogEntry, cacheable bool, err error) {
+	bytesBuffer := bytesBufferPool.Get().(*bytes.Buffer)
+	bytesBuffer.Reset()
+	defer bytesBufferPool.Put(bytesBuffer)
+	lookupFileIdFn := func(ctx context.Context, fileId string) (targetUrls []string, err error) {
+		return masterClient.LookupFileId(ctx, fileId)
+	}
+	if fetchErr := fetchWholeChunk(context.Background(), bytesBuffer, lookupFileIdFn, chunk.GetFileIdString(), chunk.CipherKey, chunk.IsCompressed, masterClient); fetchErr != nil {
+		return nil, false, fetchErr
+	}
+	return decodeLogRecords(bytesBuffer.Bytes())
+}
+
+// decodeLogRecords parses size-prefixed LogEntry records. A buffer that stops
+// mid-record, or whose size prefix is garbage (also the symptom of starting
+// mid-record), reports errLogChunkIncomplete with the cleanly decoded prefix.
+// Since UnmarshalVT is permissive enough to accept misaligned bytes,
+// records must also satisfy the writer's invariants: never empty, a positive
+// timestamp, and strictly increasing within one flushed buffer.
+// UnmarshalVT copies all bytes, so the entries do not alias data.
+func decodeLogRecords(data []byte) (entries []*filer_pb.LogEntry, cacheable bool, err error) {
+	var lastTsNs int64
+	for pos := 0; pos < len(data); {
+		if pos+4 > len(data) {
+			return entries, false, errLogChunkIncomplete
+		}
+		size32 := util.BytesToUint32(data[pos : pos+4])
+		if size32 == 0 || size32 > maxLogEntrySize {
+			return entries, false, errLogChunkIncomplete
+		}
+		size := int(size32)
+		if pos+4+size > len(data) {
+			return entries, false, errLogChunkIncomplete
+		}
+		logEntry := &filer_pb.LogEntry{}
+		if unmarshalErr := logEntry.UnmarshalVT(data[pos+4 : pos+4+size]); unmarshalErr != nil {
+			return entries, false, errLogChunkIncomplete
+		}
+		if logEntry.TsNs <= lastTsNs {
+			return entries, false, errLogChunkIncomplete
+		}
+		lastTsNs = logEntry.TsNs
+		entries = append(entries, logEntry)
+		pos += 4 + size
+	}
+	return entries, true, nil
+}