LogDog: enable services to fetch project configs

appengine/logdog/coordinator/service.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package coordinator
 
 import (
         "net/http"
         "sync"
         "sync/atomic"
 
         "github.com/julienschmidt/httprouter"
         gaeauthClient "github.com/luci/luci-go/appengine/gaeauth/client"
         "github.com/luci/luci-go/appengine/logdog/coordinator/config"
+        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/common/proto/logdog/svcconfig"
         "github.com/luci/luci-go/server/logdog/storage"
         "github.com/luci/luci-go/server/logdog/storage/bigtable"
         "github.com/luci/luci-go/server/middleware"
         "golang.org/x/net/context"
         "google.golang.org/cloud"
         gcps "google.golang.org/cloud/pubsub"
         "google.golang.org/grpc/metadata"
 )
 
 // Services is a set of support services used by Coordinator.
 //
 // Each Services instance is valid for a singel request, but can be re-used
 // throughout that request. This is advised, as the Services instance may
 // optionally cache values.
 //
 // Services methods are goroutine-safe.
 //
 // By default, a production set of services will be used. However, this can be
 // overridden for testing to mock the service layer.
 type Services interface {
         // Config returns the current instance and application configuration
         // instances.
         //
         // The production instance will cache the results for the duration of the
         // request.
         Config(context.Context) (*config.Config, error)
 
+        // ProjectConfig returns the project configuration for the named project.
+        //
+        // The production instance will cache the results for the duration of the
+        // request.
+        ProjectConfig(context.Context, luciConfig.ProjectName) (*svcconfig.ProjectConfig, error)
+
         // 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)
@@ skipping 13 matching lines @@
 func UseProdServices(c context.Context) context.Context {
         return WithServices(c, &prodServicesInst{})
 }
 
 // prodServicesInst is a Service exposing production faciliites. A unique
 // instance is bound to each each request.
 type prodServicesInst struct {
         sync.Mutex
 
         // gcfg is the cached global configuration.
-        gcfg *config.Config
+        gcfg           *config.Config
+        projectConfigs map[luciConfig.ProjectName]*cachedProjectConfig
 
         // archivalIndex is the atomically-manipulated archival index for the
         // ArchivalPublisher. This is shared between all ArchivalPublisher instances
         // from this service.
         archivalIndex int32
 }
 
-// Config returns the current instance and application configuration instances.
-//
-// After a success, successive calls will return a cached result.
 func (s *prodServicesInst) Config(c context.Context) (*config.Config, error) {
         s.Lock()
         defer s.Unlock()
 
         // Load/cache the global config.
         if s.gcfg == nil {
                 var err error
                 s.gcfg, err = config.Load(c)
                 if err != nil {
                         return nil, err
                 }
         }
 
         return s.gcfg, nil
 }
 
+// cachedProjectConfig is a singleton instance that holds a project config
+// state. It is populated when resolve is called, and is goroutine-safe for
+// read-only operations.
+type cachedProjectConfig struct {
+        sync.Once
+
+        project luciConfig.ProjectName
+        pcfg    *svcconfig.ProjectConfig
+        err     error
+}
+
+func (cp *cachedProjectConfig) resolve(c context.Context) (*svcconfig.ProjectConfig, error) {
+        // Load the project config exactly once. This will be cached for the remainder
+        // of this request.
+        //
+        // If multiple goroutines attempt to load it, exactly one will, and the rest
+        // will block. All operations after this Once must be read-only.
+        cp.Do(func() {
+                cp.pcfg, cp.err = config.ProjectConfig(c, cp.project)
+        })
+        return cp.pcfg, cp.err
+}
+
+func (s *prodServicesInst) getOrCreateCachedProjectConfig(project luciConfig.ProjectName) *cachedProjectConfig {
+        s.Lock()
+        defer s.Unlock()
+
+        if s.projectConfigs == nil {
+                s.projectConfigs = make(map[luciConfig.ProjectName]*cachedProjectConfig)
+        }
+        cp := s.projectConfigs[project]
+        if cp == nil {
+                cp = &cachedProjectConfig{
+                        project: project,
+                }
+                s.projectConfigs[project] = cp
+        }
+        return cp
+}
+
+func (s *prodServicesInst) ProjectConfig(c context.Context, project luciConfig.ProjectName) (*svcconfig.ProjectConfig, error) {
+        return s.getOrCreateCachedProjectConfig(project).resolve(c)
+}
+
 func (s *prodServicesInst) IntermediateStorage(c context.Context) (storage.Storage, error) {
         cfg, err := s.Config(c)
         if err != nil {
                 return nil, err
         }
 
         // Is BigTable configured?
         if cfg.Storage == nil {
                 return nil, errors.New("no storage configuration")
         }
@@ skipping 114 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)
 }