Plumb in diskcache.

Author: tomwilkie

pkg/chunk/cache/cache.go

@@ -20,29 +20,42 @@ type Cache interface {
 type Config struct {
 	WriteBackGoroutines int
 	WriteBackBuffer     int
+	EnableDiskcache     bool
 
 	memcache       MemcachedConfig
 	memcacheClient MemcachedClientConfig
-
-	disk DiskcacheConfig
+	diskcache      DiskcacheConfig
 }
 
+// RegisterFlags adds the flags required to config this to the given FlagSet.
 func (cfg *Config) RegisterFlags(f *flag.FlagSet) {
+	f.BoolVar(&cfg.EnableDiskcache, "cache.enable-diskcache", false, "Enable on-disk cache")
 	f.IntVar(&cfg.WriteBackGoroutines, "memcache.write-back-goroutines", 10, "How many goroutines to use to write back to memcache.")
 	f.IntVar(&cfg.WriteBackBuffer, "memcache.write-back-buffer", 10000, "How many chunks to buffer for background write back.")
 
 	cfg.memcache.RegisterFlags(f)
 	cfg.memcacheClient.RegisterFlags(f)
-	cfg.disk.RegisterFlags(f)
+	cfg.diskcache.RegisterFlags(f)
 }
 
-func New(cfg Config) Cache {
-	if cfg.memcacheClient.Host == "" {
-		return noopCache{}
+// New creates a new Cache using Config.
+func New(cfg Config) (Cache, error) {
+	caches := []Cache{}
+
+	if cfg.memcacheClient.Host != "" {
+		client := newMemcachedClient(cfg.memcacheClient)
+		caches = append(caches, NewMemcached(cfg.memcache, client))
 	}
 
-	client := newMemcachedClient(cfg.memcacheClient)
-	return NewMemcached(cfg.memcache, client)
+	if cfg.EnableDiskcache {
+		cache, err := NewDiskcache(cfg.diskcache)
+		if err != nil {
+			return nil, err
+		}
+		caches = append(caches, cache)
+	}
+
+	return multiCache(caches), nil
 }
 
 type backgroundCache struct {
@@ -58,8 +71,15 @@ type backgroundWrite struct {
 	buf []byte
 }
 
-func NewBackground(cfg Config) Cache {
+// NewBackground returns a new Cache that does stores on background goroutines.
+func NewBackground(cfg Config) (Cache, error) {
+	cache, err := New(cfg)
+	if err != nil {
+		return nil, err
+	}
+
 	c := &backgroundCache{
+		Cache:    cache,
 		quit:     make(chan struct{}),
 		bgWrites: make(chan backgroundWrite, cfg.WriteBackBuffer),
 	}
@@ -69,7 +89,7 @@ func NewBackground(cfg Config) Cache {
 		go c.writeBackLoop()
 	}
 
-	return c
+	return c, nil
 }
 
 // Stop the background flushing goroutines.
@@ -80,7 +100,7 @@ func (c *backgroundCache) Stop() error {
 	return c.Cache.Stop()
 }
 
-// BackgroundWrite writes chunks for the cache in the background
+// StoreChunk writes chunks for the cache in the background.
 func (c *backgroundCache) StoreChunk(ctx context.Context, key string, buf []byte) error {
 	bgWrite := backgroundWrite{
 		key: key,
@@ -110,16 +130,33 @@ func (c *backgroundCache) writeBackLoop() {
 	}
 }
 
-type noopCache struct{}
+type multiCache []Cache
 
-func (noopCache) StoreChunk(ctx context.Context, key string, buf []byte) error {
+func (m multiCache) StoreChunk(ctx context.Context, key string, buf []byte) error {
+	for _, c := range []Cache(m) {
+		if err := c.StoreChunk(ctx, key, buf); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
-func (noopCache) FetchChunkData(ctx context.Context, keys []string) (found []string, bufs [][]byte, err error) {
+func (m multiCache) FetchChunkData(ctx context.Context, keys []string) ([]string, [][]byte, error) {
+	for _, c := range []Cache(m) {
+		found, bufs, err := c.FetchChunkData(ctx, keys)
+		if err != nil {
+			return nil, nil, err
+		}
+		return found, bufs, nil
+	}
 	return nil, nil, nil
 }
 
-func (noopCache) Stop() error {
+func (m multiCache) Stop() error {
+	for _, c := range []Cache(m) {
+		if err := c.Stop(); err != nil {
+			return err
+		}
+	}
 	return nil
 }

pkg/chunk/chunk_store.go

@@ -76,11 +76,16 @@ func NewStore(cfg StoreConfig, schemaCfg SchemaConfig, storage StorageClient) (*
 		return nil, err
 	}
 
+	cache, err := cache.NewBackground(cfg.CacheConfig)
+	if err != nil {
+		return nil, err
+	}
+
 	return &Store{
 		cfg:     cfg,
 		storage: storage,
 		schema:  schema,
-		cache:   cache.New(cfg.CacheConfig),
+		cache:   cache,
 	}, nil
 }