LogDog: Add signed GS URL fetching.

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"
 
         "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/caching"
+        "github.com/luci/luci-go/logdog/common/storage/archive"
+        "github.com/luci/luci-go/logdog/common/storage/bigtable"
         "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"
@@ skipping 14 matching lines @@
 
         // 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
 
+        // BigTable in-memory testing instance.
+        BigTable bigtable.Testing
         // 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() {
@@ skipping 99 matching lines @@
                 },
         }
 
         // 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)
         }
 
+        // Create/install our BigTable memory instance.
+        e.BigTable = bigtable.NewMemoryInstance(c, bigtable.Options{
+                Cache: &e.StorageCache,
+        })
+
         // Add indexes. These should match the indexes defined in the application's
         // "index.yaml".
         indexDefs := [][]string{
                 {"Prefix", "-Created"},
                 {"Name", "-Created"},
                 {"State", "-Created"},
                 {"Purged", "-Created"},
                 {"ProtoVersion", "-Created"},
                 {"ContentType", "-Created"},
                 {"StreamType", "-Created"},
@@ skipping 85 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{
-                GS: func() (gs.Client, error) {
-                        return &e.GSClient, nil
+                ST: func(lst *coordinator.LogStreamState) (coordinator.Storage, error) {
+                        // If we're not archived, return our BigTable storage instance.
+                        if !lst.ArchivalState().Archived() {
+                                return &BigTableStorage{
+                                        Testing: e.BigTable,
+                                }, nil
+                        }
+
+                        opts := archive.Options{
+                                Index:  gs.Path(lst.ArchiveIndexURL),
+                                Stream: gs.Path(lst.ArchiveStreamURL),
+                                Client: &e.GSClient,
+                                Cache:  &e.StorageCache,
+                        }
+
+                        base, err := archive.New(c, opts)
+                        if err != nil {
+                                return nil, err
+                        }
+                        return &ArchivalStorage{
+                                Storage: base,
+                                Opts:    opts,
+                        }, 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)
 }