server/auth: Add in-process LRU-based cache.

server/auth/cache.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package auth
 
 import (
         "bytes"
         "crypto/sha1"
         "encoding/base64"
         "encoding/gob"
         "fmt"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/common/data/caching/lru"
         "github.com/luci/luci-go/common/data/rand/mathrand"
 )
 
-// delegationTokenCache is used to store delegation tokens in the global cache.
+// delegationTokenCache is used to store delegation tokens in the cache.
 var delegationTokenCache = tokenCache{
         Kind:                "delegation",
         Version:             2,
         ExpRandPercent:      10,
         MinAcceptedLifetime: 5 * time.Minute,
 }
 
-// tokenCache knows how to keep tokens in the global cache.
+// tokenCache knows how to keep tokens in the cache.
 //
-// Uses Config.GlobalCache as a storage backend.
+// Uses Config.Cache as a storage backend.
 //
 // It implements probabilistic early expiration to workaround cache stampede
 // problem for hot items, see Fetch.
 type tokenCache struct {
         // Kind defines the token kind. Will be used as part of the cache key.
         Kind string
 
         // Version defines format of the data. Will be used as part of the cache key.
         //
         // If you change a type behind interface{} in Token field, you MUST bump the
@@ skipping 31 matching lines @@
         }
         ttl := tok.Expiry.Sub(tok.Created)
         if ttl < tc.MinAcceptedLifetime {
                 return fmt.Errorf("refusing to store a token that expires in %s", ttl)
         }
         blob, err := tc.marshal(&tok)
         if err != nil {
                 return err
         }
         cfg := GetConfig(c)
-        if cfg == nil || cfg.GlobalCache == nil {
+        if cfg == nil || cfg.Cache == nil {
                 return ErrNotConfigured
         }
-        return cfg.GlobalCache.Set(c, tc.itemKey(tok.Key), blob, ttl)
+        return cfg.Cache.Set(c, tc.itemKey(tok.Key), blob, ttl)
 }
 
 // Fetch grabs cached token if it hasn't expired yet.
 //
 // Returns (nil, nil) if no such token or it has expired already. If the cached
 // token is close to expiration, this function will randomly return a cache
 // miss. That way if multiple concurrent processes all constantly use the same
 // token, only the most unlucky one will refresh it.
 func (tc *tokenCache) Fetch(c context.Context, key string) (*cachedToken, error) {
         cfg := GetConfig(c)
-        if cfg == nil || cfg.GlobalCache == nil {
+        if cfg == nil || cfg.Cache == nil {
                 return nil, ErrNotConfigured
         }
 
-        blob, err := cfg.GlobalCache.Get(c, tc.itemKey(key))
+        blob, err := cfg.Cache.Get(c, tc.itemKey(key))
         switch {
         case err != nil:
                 return nil, err
         case blob == nil:
                 return nil, nil
         }
 
         tok, err := tc.unmarshal(blob)
         if err != nil {
                 return nil, err
@@ skipping 41 matching lines @@
 
 // unmarshal is reverse of marshal.
 func (tc *tokenCache) unmarshal(blob []byte) (*cachedToken, error) {
         dec := gob.NewDecoder(bytes.NewReader(blob))
         out := &cachedToken{}
         if err := dec.Decode(out); err != nil {
                 return nil, err
         }
         return out, nil
 }
+
+type memoryCache struct {
+        cache *lru.Cache
+}
+
+// MemoryCache creates a new in-memory Cache instance that is built on
+// top of an LRU cache of the specified size.
+func MemoryCache(size int) Cache {
+        return memoryCache{
+                cache: lru.New(size),
+        }
+}
+
+func (mc memoryCache) Get(c context.Context, key string) ([]byte, error) {
+        var item *memoryCacheItem
+        now := clock.Now(c)
+        _ = mc.cache.Mutate(key, func(cur interface{}) interface{} {
+                if cur == nil {
+                        return nil
+                }
+
+                item = cur.(*memoryCacheItem)
+                if now.After(item.exp) {
+                        // Cache item is too old, so expire it.
+                        item = nil
+                }
+                return item
+        })
+        if item == nil {
+                // Cache miss (or expired).
+                return nil, nil
+        }
+        return item.value, nil
+}
+
+func (mc memoryCache) Set(c context.Context, key string, value []byte, exp time.Duration) error {
+        mc.cache.Put(key, &memoryCacheItem{
+                value: value,
+                exp:   clock.Now(c).Add(exp),
+        })
+        return nil
+}
+
+type memoryCacheItem struct {
+        value []byte
+        exp   time.Time
+}