Replace entry.Key interface with string

We only use non-string Keys in tests, so let's change the tests to use
strings also and drop the interface{}.

Author: mostynb

cache/disk/disk.go

@@ -149,20 +149,24 @@ func (c *diskCache) pollCacheAge() {
 func (c *diskCache) updateCacheAgeMetric() {
 	c.mu.Lock()
 
-	key, value := c.lru.getTailItem()
+	key, value, ok := c.lru.getTailItem()
+	if !ok {
+		// No items in the cache.
+		c.mu.Unlock()
+		return
+	}
+
 	age := 0.0
 	validAge := true
 
-	if key != nil {
-		f := c.getElementPath(key, value)
-		ts, err := atime.Stat(f)
+	f := c.getElementPath(key, value)
+	ts, err := atime.Stat(f)
 
-		if err != nil {
-			log.Printf("ERROR: failed to determine time of least recently used cache item: %v, unable to stat %s", err, f)
-			validAge = false
-		} else {
-			age = time.Since(ts).Seconds()
-		}
+	if err != nil {
+		log.Printf("ERROR: failed to determine time of least recently used cache item: %v, unable to stat %s", err, f)
+		validAge = false
+	} else {
+		age = time.Since(ts).Seconds()
 	}
 
 	c.mu.Unlock()
@@ -172,8 +176,8 @@ func (c *diskCache) updateCacheAgeMetric() {
 	}
 }
 
-func (c *diskCache) getElementPath(key Key, value lruItem) string {
-	ks := key.(string)
+func (c *diskCache) getElementPath(key string, value lruItem) string {
+	ks := key
 	hash := ks[len(ks)-sha256.Size*2:]
 	var kind = cache.AC
 	if strings.HasPrefix(ks, "cas") {

cache/disk/disk_test.go

@@ -454,10 +454,10 @@ func TestCacheExistingFiles(t *testing.T) {
 	}
 	testCache := testCacheI.(*diskCache)
 
-	evicted := []Key{}
+	evicted := []string{}
 	origOnEvict := testCache.lru.onEvict
-	testCache.lru.onEvict = func(key Key, value lruItem) {
-		evicted = append(evicted, key.(string))
+	testCache.lru.onEvict = func(key string, value lruItem) {
+		evicted = append(evicted, key)
 		origOnEvict(key, value)
 	}
 

cache/disk/load.go

@@ -583,7 +583,7 @@ func (c *diskCache) loadExistingFiles(maxSizeBytes int64, cc CacheConfig) error
 	// The eviction callback deletes the file from disk.
 	// This function is only called while the lock is not held
 	// by the current goroutine.
-	onEvict := func(key Key, value lruItem) {
+	onEvict := func(key string, value lruItem) {
 		f := c.getElementPath(key, value)
 		c.removeFile(f)
 	}

cache/disk/lru.go

@@ -11,16 +11,8 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 )
 
-// Key is the type used for identifying cache items. For non-test code,
-// this is a string of the form "<keyspace>/<hash>". Some test code uses
-// ints for simplicity.
-//
-// TODO: update the test code to use strings too, then drop all the
-// type assertions.
-type Key interface{}
-
 // EvictCallback is the type of callbacks that are invoked when items are evicted.
-type EvictCallback func(key Key, value lruItem)
+type EvictCallback func(key string, value lruItem)
 
 // SizedLRU is an LRU cache that will keep its total size below maxSize by evicting
 // items.
@@ -96,7 +88,10 @@ type SizedLRU struct {
 }
 
 type entry struct {
-	key   Key
+	// This is used to identify cache items. For non-test code,
+	// this is a string of the form "<keyspace>/<hash>"
+	key string
+
 	value lruItem
 }
 
@@ -175,7 +170,7 @@ func (c *SizedLRU) RegisterMetrics() {
 // Note that this function rounds file sizes up to the nearest
 // BlockSize (4096) bytes, as an estimate of actual disk usage since
 // most linux filesystems default to 4kb blocks.
-func (c *SizedLRU) Add(key Key, value lruItem) (ok bool) {
+func (c *SizedLRU) Add(key string, value lruItem) (ok bool) {
 
 	roundedUpSizeOnDisk := roundUp4k(value.sizeOnDisk)
 
@@ -237,7 +232,7 @@ func (c *SizedLRU) Add(key Key, value lruItem) (ok bool) {
 }
 
 // Get looks up a key in the cache
-func (c *SizedLRU) Get(key Key) (value lruItem, ok bool) {
+func (c *SizedLRU) Get(key string) (value lruItem, ok bool) {
 	if ele, hit := c.cache[key]; hit {
 		c.ll.MoveToFront(ele)
 		return ele.Value.(*entry).value, true
@@ -247,7 +242,7 @@ func (c *SizedLRU) Get(key Key) (value lruItem, ok bool) {
 }
 
 // Remove removes a (key, value) from the cache
-func (c *SizedLRU) Remove(key Key) {
+func (c *SizedLRU) Remove(key string) {
 	if ele, hit := c.cache[key]; hit {
 		c.removeElement(ele)
 		c.gaugeCacheLogicalBytes.Set(float64(c.uncompressedSize))
@@ -409,13 +404,13 @@ func roundUp4k(n int64) int64 {
 }
 
 // Get the back item of the LRU cache.
-func (c *SizedLRU) getTailItem() (Key, lruItem) {
+func (c *SizedLRU) getTailItem() (string, lruItem, bool) {
 	ele := c.ll.Back()
 	if ele != nil {
 		kv := ele.Value.(*entry)
-		return kv.key, kv.value
+		return kv.key, kv.value, true
 	}
-	return nil, lruItem{}
+	return "", lruItem{}, false
 }
 
 // Append an entry to the eviction queue. The entry must have been removed

cache/disk/lru_test.go

@@ -4,6 +4,7 @@ import (
 	"math"
 	"net/http"
 	"reflect"
+	"strconv"
 	"testing"
 
 	testutils "github.com/buchgr/bazel-remote/v2/utils"
@@ -63,33 +64,33 @@ func TestBasics(t *testing.T) {
 
 func TestEviction(t *testing.T) {
 	// Keep track of evictions using the callback
-	var evictions []int
-	onEvict := func(key Key, value lruItem) {
-		evictions = append(evictions, key.(int))
+	var evictions []string
+	onEvict := func(key string, value lruItem) {
+		evictions = append(evictions, key)
 	}
 
 	lru := NewSizedLRU(10*BlockSize, onEvict, 0)
 
 	expectedSizesNumItems := []struct {
 		expBlocks   int64
 		expNumItems int
-		expEvicted  []int
+		expEvicted  []string
 	}{
-		{0, 1, []int{}},           // 0
-		{1, 2, []int{}},           // 0, 1
-		{3, 3, []int{}},           // 0, 1, 2
-		{6, 4, []int{}},           // 0, 1, 2, 3
-		{10, 5, []int{}},          // 0, 1, 2, 3, 4
-		{9, 2, []int{0, 1, 2, 3}}, // 4, 5
-		{6, 1, []int{4, 5}},       // 6
-		{7, 1, []int{6}},          // 7
+		{0, 1, []string{}},                   // 0
+		{1, 2, []string{}},                   // 0, 1
+		{3, 3, []string{}},                   // 0, 1, 2
+		{6, 4, []string{}},                   // 0, 1, 2, 3
+		{10, 5, []string{}},                  // 0, 1, 2, 3, 4
+		{9, 2, []string{"0", "1", "2", "3"}}, // 4, 5
+		{6, 1, []string{"4", "5"}},           // 6
+		{7, 1, []string{"6"}},                // 7
 	}
 
-	var expectedEvictions []int
+	var expectedEvictions []string
 
 	for i, thisExpected := range expectedSizesNumItems {
 		item := lruItem{size: int64(i) * BlockSize, sizeOnDisk: int64(i) * BlockSize}
-		ok := lru.Add(i, item)
+		ok := lru.Add(strconv.Itoa(i), item)
 		if !ok {
 			t.Fatalf("Add: failed adding %d", i)
 		}
@@ -163,13 +164,13 @@ func TestReserveAtCapacity(t *testing.T) {
 
 func TestReserveAtEvictionQueueLimit(t *testing.T) {
 
-	lru := NewSizedLRU(BlockSize*2, func(Key, lruItem) {}, 0)
+	lru := NewSizedLRU(BlockSize*2, func(string, lruItem) {}, 0)
 	lru.maxSizeHardLimit = BlockSize * 3
 
-	blockSize1Key := 7777
+	blockSize1Key := "7777"
 	blockSize1Item := lruItem{size: BlockSize * 1, sizeOnDisk: BlockSize * 1}
 
-	blockSize2Key := 8888
+	blockSize2Key := "8888"
 	blockSize2Item := lruItem{size: BlockSize * 2, sizeOnDisk: BlockSize * 2}
 
 	// Add large item.