cache: factor fs cache into lib/cache

lib/cache/cache.go

@@ -0,0 +1,134 @@
+// Package cache implements a simple cache where the entries are
+// expired after a given time (5 minutes of disuse by default).
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// Cache holds values indexed by string, but expired after a given (5
+// minutes by default).
+type Cache struct {
+	mu             sync.Mutex
+	cache          map[string]*cacheEntry
+	expireRunning  bool
+	expireDuration time.Duration // expire the cache entry when it is older than this
+	expireInterval time.Duration // interval to run the cache expire
+}
+
+// New creates a new cache with the default expire duration and interval
+func New() *Cache {
+	return &Cache{
+		cache:          map[string]*cacheEntry{},
+		expireRunning:  false,
+		expireDuration: 300 * time.Second,
+		expireInterval: 60 * time.Second,
+	}
+}
+
+// cacheEntry is stored in the cache
+type cacheEntry struct {
+	value    interface{} // cached item
+	err      error       // creation error
+	key      string      // key
+	lastUsed time.Time   // time used for expiry
+}
+
+// CreateFunc is called to create new values.  If the create function
+// returns an error it will be cached if ok is true, otherwise the
+// error will just be returned, allowing negative caching if required.
+type CreateFunc func(key string) (value interface{}, ok bool, error error)
+
+// used marks an entry as accessed now and kicks the expire timer off
+// should be called with the lock held
+func (c *Cache) used(entry *cacheEntry) {
+	entry.lastUsed = time.Now()
+	if !c.expireRunning {
+		time.AfterFunc(c.expireInterval, c.cacheExpire)
+		c.expireRunning = true
+	}
+}
+
+// Get gets a value named key either from the cache or creates it
+// afresh with the create function.
+func (c *Cache) Get(key string, create CreateFunc) (value interface{}, err error) {
+	c.mu.Lock()
+	entry, ok := c.cache[key]
+	if !ok {
+		c.mu.Unlock() // Unlock in case Get is called recursively
+		value, ok, err = create(key)
+		if err != nil && !ok {
+			return value, err
+		}
+		entry = &cacheEntry{
+			value: value,
+			key:   key,
+			err:   err,
+		}
+		c.mu.Lock()
+		c.cache[key] = entry
+	}
+	defer c.mu.Unlock()
+	c.used(entry)
+	return entry.value, entry.err
+}
+
+// Put puts an value named key into the cache
+func (c *Cache) Put(key string, value interface{}) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	entry := &cacheEntry{
+		value: value,
+		key:   key,
+	}
+	c.used(entry)
+	c.cache[key] = entry
+}
+
+// GetMaybe returns the key and true if found, nil and false if not
+func (c *Cache) GetMaybe(key string) (value interface{}, found bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	entry, found := c.cache[key]
+	if !found {
+		return nil, found
+	}
+	c.used(entry)
+	return entry.value, found
+}
+
+// cacheExpire expires any entries that haven't been used recently
+func (c *Cache) cacheExpire() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	now := time.Now()
+	for key, entry := range c.cache {
+		if now.Sub(entry.lastUsed) > c.expireDuration {
+			delete(c.cache, key)
+		}
+	}
+	if len(c.cache) != 0 {
+		time.AfterFunc(c.expireInterval, c.cacheExpire)
+		c.expireRunning = true
+	} else {
+		c.expireRunning = false
+	}
+}
+
+// Clear removes everything from the cahce
+func (c *Cache) Clear() {
+	c.mu.Lock()
+	for k := range c.cache {
+		delete(c.cache, k)
+	}
+	c.mu.Unlock()
+}
+
+// Entries returns the number of entries in the cache
+func (c *Cache) Entries() int {
+	c.mu.Lock()
+	entries := len(c.cache)
+	c.mu.Unlock()
+	return entries
+}

lib/cache/cache_test.go

@@ -0,0 +1,174 @@
+package cache
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	called      = 0
+	errSentinel = errors.New("an error")
+	errCached   = errors.New("a cached error")
+)
+
+func setup(t *testing.T) (*Cache, CreateFunc) {
+	called = 0
+	create := func(path string) (interface{}, bool, error) {
+		assert.Equal(t, 0, called)
+		called++
+		switch path {
+		case "/":
+			return "/", true, nil
+		case "/file.txt":
+			return "/file.txt", true, errCached
+		case "/error":
+			return nil, false, errSentinel
+		}
+		panic(fmt.Sprintf("Unknown path %q", path))
+	}
+	c := New()
+	return c, create
+}
+
+func TestGet(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, len(c.cache))
+
+	f, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	assert.Equal(t, 1, len(c.cache))
+
+	f2, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	assert.Equal(t, f, f2)
+}
+
+func TestGetFile(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, len(c.cache))
+
+	f, err := c.Get("/file.txt", create)
+	require.Equal(t, errCached, err)
+
+	assert.Equal(t, 1, len(c.cache))
+
+	f2, err := c.Get("/file.txt", create)
+	require.Equal(t, errCached, err)
+
+	assert.Equal(t, f, f2)
+}
+
+func TestGetError(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, len(c.cache))
+
+	f, err := c.Get("/error", create)
+	require.Equal(t, errSentinel, err)
+	require.Equal(t, nil, f)
+
+	assert.Equal(t, 0, len(c.cache))
+}
+
+func TestPut(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, len(c.cache))
+
+	c.Put("/alien", "slime")
+
+	assert.Equal(t, 1, len(c.cache))
+
+	fNew, err := c.Get("/alien", create)
+	require.NoError(t, err)
+	require.Equal(t, "slime", fNew)
+
+	assert.Equal(t, 1, len(c.cache))
+}
+
+func TestCacheExpire(t *testing.T) {
+	c, create := setup(t)
+
+	c.expireInterval = time.Millisecond
+	assert.Equal(t, false, c.expireRunning)
+
+	_, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	c.mu.Lock()
+	entry := c.cache["/"]
+
+	assert.Equal(t, 1, len(c.cache))
+	c.mu.Unlock()
+	c.cacheExpire()
+	c.mu.Lock()
+	assert.Equal(t, 1, len(c.cache))
+	entry.lastUsed = time.Now().Add(-c.expireDuration - 60*time.Second)
+	assert.Equal(t, true, c.expireRunning)
+	c.mu.Unlock()
+	time.Sleep(10 * time.Millisecond)
+	c.mu.Lock()
+	assert.Equal(t, false, c.expireRunning)
+	assert.Equal(t, 0, len(c.cache))
+	c.mu.Unlock()
+}
+
+func TestClear(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, len(c.cache))
+
+	_, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	assert.Equal(t, 1, len(c.cache))
+
+	c.Clear()
+
+	assert.Equal(t, 0, len(c.cache))
+}
+
+func TestEntries(t *testing.T) {
+	c, create := setup(t)
+
+	assert.Equal(t, 0, c.Entries())
+
+	_, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	assert.Equal(t, 1, c.Entries())
+
+	c.Clear()
+
+	assert.Equal(t, 0, c.Entries())
+}
+
+func TestGetMaybe(t *testing.T) {
+	c, create := setup(t)
+
+	value, found := c.GetMaybe("/")
+	assert.Equal(t, false, found)
+	assert.Nil(t, value)
+
+	f, err := c.Get("/", create)
+	require.NoError(t, err)
+
+	value, found = c.GetMaybe("/")
+	assert.Equal(t, true, found)
+	assert.Equal(t, f, value)
+
+	c.Clear()
+
+	value, found = c.GetMaybe("/")
+	assert.Equal(t, false, found)
+	assert.Nil(t, value)
+}