LogDog: Use live object cache for configs.

logdog/server/service/service.go

 // Copyright 2016 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 service
 
 import (
         "flag"
         "fmt"
         "net/http"
@@ skipping 90 matching lines @@
         //
         // Since, in production, this is running under an execution harness such as
         // Kubernetes, the service will restart and load the new configuration. This
         // is easier than implementing in-process configuration updating.
         killCheckInterval clockflag.Duration
         // testConfigFilePath is the path to a local configuration service filesystem
         // (impl/filesystem) root. This is used for testing.
         testConfigFilePath string
         // serviceConfig is the cached service configuration.
         serviceConfig svcconfig.Config
+        configCache   config.MessageCache
 
         // serviceID is the cloud project ID, which is also this service's unique
         // ID. This can be specified by flag or, if on GCE, will automatically be
         // probed from metadata.
         serviceID string
 
         coord logdog.ServicesClient
 }
 
 // Run performs service-wide initialization and invokes the specified run
@@ skipping 203 matching lines @@
         if s.coordinatorInsecure {
                 prpcClient.Options.Insecure = true
         }
         sc := logdog.NewServicesPRPCClient(&prpcClient)
 
         // Wrap the resulting client in a retry harness.
         return retryServicesClient.New(sc, nil), nil
 }
 
 func (s *Service) initConfig(c *context.Context) error {
-        opts := config.CacheOptions{
-                CacheExpiration: projectConfigCacheDuration,
-        }
+        // Set up our in-memory config object cache.
+        s.configCache.Lifetime = projectConfigCacheDuration
 
         // If a testConfigFilePath was specified, use a mock configuration service
         // that loads from a local file.
         var p client.Provider
         if s.testConfigFilePath == "" {
                 ccfg, err := s.coord.GetConfig(*c, &google.Empty{})
                 if err != nil {
                         return err
                 }
 
@@ skipping 26 matching lines @@
         } else {
                 // Test / Local: use filesystem config path.
                 ci, err := filesystem.New(s.testConfigFilePath)
                 if err != nil {
                         return err
                 }
                 p = &testconfig.Provider{Base: ci}
         }
 
         // Add config caching layers.
+        opts := config.CacheOptions{
+                CacheExpiration: projectConfigCacheDuration,
+        }
         *c = opts.WrapBackend(*c, &client.Backend{
                 Provider: p,
         })
 
         // Load our service configuration.
         var meta cfgclient.Meta
         cset, path := s.ServiceConfigPath()
         if err := cfgclient.Get(*c, cfgclient.AsService, cset, path, textproto.Message(&s.serviceConfig), &meta); err != nil {
                 return errors.Annotate(err).Reason("failed to load service config").Err()
         }
@@ skipping 32 matching lines @@
 // project configuration for proj.
 func (s *Service) ProjectConfigPath(proj cfgtypes.ProjectName) (cfgtypes.ConfigSet, string) {
         return cfgtypes.ProjectConfigSet(proj), svcconfig.ProjectConfigPath(s.serviceID)
 }
 
 // ProjectConfig returns the current service's project configuration for proj.
 func (s *Service) ProjectConfig(c context.Context, proj cfgtypes.ProjectName) (*svcconfig.ProjectConfig, error) {
         cset, path := s.ProjectConfigPath(proj)
 
         var pcfg svcconfig.ProjectConfig
-        if err := cfgclient.Get(c, cfgclient.AsService, cset, path, textproto.Message(&pcfg), nil); err != nil {
+        msg, err := s.configCache.Get(c, cset, path, &pcfg)
+        if err != nil {
                 return nil, errors.Annotate(err).Reason("failed to load project config from %(cset)s.%(path)s").
                         D("cset", cset).D("path", path).Err()
         }
-        return &pcfg, nil
+        return msg.(*svcconfig.ProjectConfig), nil
 }
 
 // SetShutdownFunc sets the service shutdown function.
 func (s *Service) SetShutdownFunc(f func()) {
         s.shutdownFunc.Store(f)
 }
 
 func (s *Service) shutdown() {
         v := s.shutdownFunc.Load()
         if f, ok := v.(func()); ok {
@@ skipping 125 matching lines @@
 //
 // An optional permutation function can be provided to modify those Options
 // before the Authenticator is created.
 func (s *Service) TokenSource(c context.Context, f func(o *auth.Options)) (oauth2.TokenSource, error) {
         a, err := s.Authenticator(c, f)
         if err != nil {
                 return nil, err
         }
         return a.TokenSource()
 }