Method sweepLocked

internal/cache/persistent_lru_cache.go:292–327

+checklocks:c.listCacheMutex

(ctx context.Context)

// +checklocks:c.listCacheMutex
func (c *PersistentCache) sweepLocked(ctx context.Context) {
	var (
		unsuccessfulDeletes     []blob.Metadata
		unsuccessfulDeleteBytes int64
		now                     = c.timeNow()
	)

	for len(c.listCache.data) > 0 && (c.aboveSoftLimit(unsuccessfulDeleteBytes) || c.aboveHardLimit(unsuccessfulDeleteBytes)) {
		// examine the oldest cache item without removing it from the heap.
		oldest := c.listCache.data[0]

		if age := now.Sub(oldest.Timestamp); age < c.sweep.MinSweepAge && !c.aboveHardLimit(unsuccessfulDeleteBytes) {
			// the oldest item is below the specified minimal sweep age and we're below the hard limit, stop here
			break
		}

		heap.Pop(&c.listCache)

		if delerr := c.cacheStorage.DeleteBlob(ctx, oldest.BlobID); delerr != nil {
			log(ctx).Warnw("unable to remove cache item", "cache", c.description, "item", oldest.BlobID, "err", delerr)

			// accumulate unsuccessful deletes to be pushed back into the heap
			// later so we do not attempt deleting the same blob multiple times
			//
			// after this we keep draining from the heap until we bring down
			// c.listCache.DataSize() to zero
			unsuccessfulDeletes = append(unsuccessfulDeletes, oldest)
			unsuccessfulDeleteBytes += oldest.Length
		}
	}

	// put all unsuccessful deletes back into the heap
	for _, m := range unsuccessfulDeletes {
		heap.Push(&c.listCache, m)
	}
}

func (c *PersistentCache) initialScan(ctx context.Context) error {
	timer := timetrack.StartTimer()