LogDog: Add Storage-layer data caching.

logdog/appengine/coordinator/coordinatorTest/context.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 coordinatorTest
 
 import (
         "fmt"
         "strings"
         "time"
 
-        ds "github.com/luci/gae/service/datastore"
-        "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/clock/testclock"
         luciConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/config/impl/memory"
         "github.com/luci/luci-go/common/data/caching/cacheContext"
         "github.com/luci/luci-go/common/gcloud/gs"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/proto/google"
         "github.com/luci/luci-go/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/appengine/coordinator"
         "github.com/luci/luci-go/logdog/appengine/coordinator/config"
-        "github.com/luci/luci-go/logdog/common/storage"
-        memoryStorage "github.com/luci/luci-go/logdog/common/storage/memory"
+        "github.com/luci/luci-go/logdog/common/storage/caching"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/authtest"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/settings"
         "github.com/luci/luci-go/tumble"
 
+        ds "github.com/luci/gae/service/datastore"
+        "github.com/luci/gae/service/info"
+
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 )
 
 // Environment contains all of the testing facilities that are installed into
 // the Context.
 type Environment struct {
         // Tumble is the Tumble testing instance.
         Tumble tumble.Testing
 
         // Clock is the installed test clock instance.
         Clock testclock.TestClock
 
         // AuthState is the fake authentication state.
         AuthState authtest.FakeState
 
         // Config is the luci-config configuration map that is installed.
         Config map[string]memory.ConfigSet
         // ConfigIface is a reference to the memory config.Interface that Config is
         // installed into.
         ConfigIface luciConfig.Interface
 
         // Services is the set of installed Coordinator services.
         Services Services
 
-        // IntermediateStorage is the memory Intermediate Storage instance
-        // installed (by default) into Services.
-        IntermediateStorage memoryStorage.Storage
         // GSClient is the test GSClient instance installed (by default) into
         // Services.
         GSClient GSClient
         // ArchivalPublisher is the test ArchivalPublisher instance installed (by
         // default) into Services.
         ArchivalPublisher ArchivalPublisher
+
+        // StorageCache is the default storage cache instance.
+        StorageCache StorageCache
 }
 
 // LogIn installs an testing identity into the testing auth state.
 func (e *Environment) LogIn() {
         id, err := identity.MakeIdentity("user:testing@example.com")
         if err != nil {
                 panic(err)
         }
         e.AuthState.Identity = id
 }
@@ skipping 79 matching lines @@
                 cset = make(map[string]string)
                 e.Config[configSet] = cset
         }
         cset[path] = content
 }
 
 // Install creates a testing Context and installs common test facilities into
 // it, returning the Environment to which they're bound.
 func Install() (context.Context, *Environment) {
         e := Environment{
-                Config: make(map[string]memory.ConfigSet),
+                Config:   make(map[string]memory.ConfigSet),
+                GSClient: GSClient{},
+                StorageCache: StorageCache{
+                        Base: &coordinator.StorageCache{},
+                },
         }
 
         // Get our starting context. This installs, among other things, in-memory
         // gae, settings, and logger.
         c := e.Tumble.Context()
         if *testGoLogger {
                 c = logging.SetLevel(gologger.StdConfig.Use(c), logging.Debug)
         }
 
         // Add indexes. These should match the indexes defined in the application's
@@ skipping 94 matching lines @@
         e.Tumble.UpdateSettings(c, tcfg)
 
         // Install authentication state.
         c = auth.WithState(c, &e.AuthState)
 
         // Setup authentication state.
         e.LeaveAllGroups()
 
         // Setup our default Coordinator services.
         e.Services = Services{
-                IS: func() (storage.Storage, error) {
-                        return &e.IntermediateStorage, nil
-                },
                 GS: func() (gs.Client, error) {
                         return &e.GSClient, nil
                 },
                 AP: func() (coordinator.ArchivalPublisher, error) {
                         return &e.ArchivalPublisher, nil
                 },
+                SC: func() caching.Cache {
+                        return &e.StorageCache
+                },
         }
         c = coordinator.WithServices(c, &e.Services)
 
         return cacheContext.Wrap(c), &e
 }
 
 // WithProjectNamespace runs f in proj's namespace, bypassing authentication
 // checks.
 func WithProjectNamespace(c context.Context, proj luciConfig.ProjectName, f func(context.Context)) {
         if err := coordinator.WithProjectNamespace(&c, proj, coordinator.NamespaceAccessAllTesting); err != nil {
                 panic(err)
         }
         f(c)
 }