Add server/cache support to gaeconfig.

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"
+        configPB "github.com/luci/luci-go/common/proto/config"
         "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/archive"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
         "github.com/luci/luci-go/luci_config/common/cfgtypes"
+        "github.com/luci/luci-go/luci_config/server/cfgclient"
+        "github.com/luci/luci-go/luci_config/server/cfgclient/backend/testconfig"
+        "github.com/luci/luci-go/luci_config/server/cfgclient/textproto"
         "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
 
         // BigTable in-memory testing instance.
         BigTable bigtable.Testing
         // GSClient is the test GSClient instance installed (by default) into
         // Services.
         GSClient GSClient
 
@@ skipping 16 matching lines @@
 
 // JoinGroup adds the named group the to the list of groups for the current
 // identity.
 func (e *Environment) JoinGroup(g string) {
         e.AuthState.IdentityGroups = append(e.AuthState.IdentityGroups, g)
 }
 
 // LeaveAllGroups clears all auth groups that the user is currently a member of.
 func (e *Environment) LeaveAllGroups() {
         e.AuthState.IdentityGroups = nil
-        e.JoinGroup("all")
 }
 
 // ClearCoordinatorConfig removes the Coordinator configuration entry,
 // simulating a missing config.
 func (e *Environment) ClearCoordinatorConfig(c context.Context) {
         configSet, _ := config.ServiceConfigPath(c)
         delete(e.Config, string(configSet))
 }
 
 // ModServiceConfig loads the current service configuration, invokes the
@@ skipping 14 matching lines @@
 
         var pcfg svcconfig.ProjectConfig
         e.modTextProtobuf(c, configSet, configPath, &pcfg, func() {
                 fn(&pcfg)
         })
 }
 
 // IterateTumbleAll iterates all Tumble instances across all namespaces.
 func (e *Environment) IterateTumbleAll(c context.Context) { e.Tumble.IterateAll(c) }
 
-func (e *Environment) modTextProtobuf(c context.Context, configSet cfgtypes.ConfigSet, path string, msg proto.Message, fn func()) {
-        cfg, err := e.ConfigIface.GetConfig(c, string(configSet), path, false)
+func (e *Environment) modTextProtobuf(c context.Context, configSet cfgtypes.ConfigSet, path string,
+        msg proto.Message, fn func()) {
 
-        switch err {
-        case nil:
-                if err := proto.UnmarshalText(cfg.Content, msg); err != nil {
-                        panic(err)
-                }
-
-        case luciConfig.ErrNoConfig:
+        switch err := cfgclient.Get(c, cfgclient.AsService, configSet, path, textproto.Message(msg), nil); err {
+        case nil, cfgclient.ErrNoConfig:
                 break
-
         default:
                 panic(err)
         }
 
         fn()
         e.addConfigEntry(configSet, path, proto.MarshalTextString(msg))
 }
 
 func (e *Environment) addConfigEntry(configSet cfgtypes.ConfigSet, path, content string) {
         cset := e.Config[string(configSet)]
@@ skipping 57 matching lines @@
         }
         ds.GetTestable(c).AddIndexes(indexes...)
 
         // Setup clock.
         e.Clock = clock.Get(c).(testclock.TestClock)
 
         // Install GAE config service settings.
         c = settings.Use(c, settings.New(&settings.MemoryStorage{}))
 
         // Setup luci-config configuration.
-        e.ConfigIface = memory.New(e.Config)
-        c = luciConfig.SetImplementation(c, e.ConfigIface)
+        c = testconfig.WithCommonClient(c, memory.New(e.Config))
 
         // luci-config: Projects.
         projectName := info.AppID(c)
         addProjectConfig := func(proj cfgtypes.ProjectName, access ...string) {
+                projectAccesses := make([]string, len(access))
+
+                // Build our service config. Also builds "projectAccesses".
                 e.ModProjectConfig(c, proj, func(pcfg *svcconfig.ProjectConfig) {
-                        for _, a := range access {
+                        for i, a := range access {
                                 parts := strings.SplitN(a, ":", 2)
                                 group, field := parts[0], &pcfg.ReaderAuthGroups
                                 if len(parts) == 2 {
                                         switch parts[1] {
                                         case "R":
                                                 break
                                         case "W":
                                                 field = &pcfg.WriterAuthGroups
                                         default:
                                                 panic(a)
                                         }
                                 }
                                 *field = append(*field, group)
+                                projectAccesses[i] = fmt.Sprintf("group:%s", group)
+                        }
+                })
+
+                var pcfg configPB.ProjectCfg
+                e.modTextProtobuf(c, cfgtypes.ProjectConfigSet(proj), cfgclient.ProjectConfigPath, &pcfg, func() {
+                        pcfg = configPB.ProjectCfg{
+                                Name:   proto.String(string(proj)),
+                                Access: projectAccesses,
                         }
                 })
         }
         addProjectConfig("proj-foo", "all:R", "all:W")
         addProjectConfig("proj-bar", "all:R", "auth:W")
         addProjectConfig("proj-exclusive", "auth:R", "auth:W")
 
         // Add a project without a LogDog project config.
         e.addConfigEntry("projects/proj-unconfigured", "not-logdog.cfg", "junk")
 
@@ skipping 23 matching lines @@
         tcfg := e.Tumble.GetConfig(c)
         tcfg.TemporalRoundFactor = 0 // Makes test timing easier to understand.
         tcfg.TemporalMinDelay = 0    // Makes test timing easier to understand.
         e.Tumble.UpdateSettings(c, tcfg)
 
         // Install authentication state.
         c = auth.WithState(c, &e.AuthState)
 
         // Setup authentication state.
         e.LeaveAllGroups()
+        e.JoinGroup("all")
 
         // Setup our default Coordinator services.
         e.Services = Services{
                 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
                         }
@@ skipping 24 matching lines @@
 }
 
 // WithProjectNamespace runs f in proj's namespace, bypassing authentication
 // checks.
 func WithProjectNamespace(c context.Context, proj cfgtypes.ProjectName, f func(context.Context)) {
         if err := coordinator.WithProjectNamespace(&c, proj, coordinator.NamespaceAccessAllTesting); err != nil {
                 panic(err)
         }
         f(c)
 }