LogDog: Add Storage-layer data caching.

logdog/appengine/coordinator/service.go

 // Copyright 2015 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 coordinator
 
 import (
         "net/http"
         "sync"
         "sync/atomic"
 
         "github.com/luci/luci-go/appengine/gaemiddleware"
         luciConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/gcloud/pubsub"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/appengine/coordinator/config"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
+        "github.com/luci/luci-go/logdog/common/storage/caching"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/router"
 
         gcps "cloud.google.com/go/pubsub"
         "golang.org/x/net/context"
         "google.golang.org/api/option"
         "google.golang.org/grpc"
         "google.golang.org/grpc/metadata"
 )
 
@@ skipping 26 matching lines @@
         // Storage returns an intermediate storage instance for use by this service.
         //
         // The caller must close the returned instance if successful.
         IntermediateStorage(context.Context) (storage.Storage, error)
 
         // GSClient instantiates a Google Storage client.
         GSClient(context.Context) (gs.Client, error)
 
         // ArchivalPublisher returns an ArchivalPublisher instance.
         ArchivalPublisher(context.Context) (ArchivalPublisher, error)
+
+        // StorageCache returns the storage cache instance to use, or nil for no
+        // caching.
+        StorageCache() caching.Cache
 }
 
 // ProdServices is middleware chain used by Coordinator services.
 //
 // It sets up basic GAE functionality as well as installs a production Services
 // instance.
 func ProdServices() router.MiddlewareChain {
         return gaemiddleware.BaseProd().Extend(func(c *router.Context, next router.Handler) {
                 c.Context = WithServices(c.Context, &prodServicesInst{})
                 next(c)
@@ skipping 123 matching lines @@
         // calls.
         c = metadata.NewContext(c, nil)
 
         st, err := bigtable.New(c, bigtable.Options{
                 Project:  bt.Project,
                 Instance: bt.Instance,
                 LogTable: bt.LogTableName,
                 ClientOptions: []option.ClientOption{
                         option.WithGRPCDialOption(grpc.WithPerRPCCredentials(creds)),
                 },
+                Cache: s.StorageCache(),
         })
         if err != nil {
                 log.WithError(err).Errorf(c, "Failed to create BigTable instance.")
                 return nil, err
         }
         return st, nil
 }
 
 func (s *prodServicesInst) GSClient(c context.Context) (gs.Client, error) {
         // Get an Authenticator bound to the token scopes that we need for
@@ skipping 47 matching lines @@
         // value as a sentinel that the archival index has wrapped.
         //
         // This is reasonable, as it is very unlikely that a single request will issue
         // more than MaxInt32 archival tasks.
         v := atomic.AddInt32(&s.archivalIndex, 1) - 1
         if v < 0 {
                 panic("archival index has wrapped")
         }
         return uint64(v)
 }
+
+var storageCacheSingleton StorageCache
+
+func (s *prodServicesInst) StorageCache() caching.Cache { return &storageCacheSingleton }