Move "common/config" common types into cfgtypes.

logdog/appengine/coordinator/service.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 coordinator
 
 import (
         "sync"
         "sync/atomic"
         "time"
 
         "github.com/luci/luci-go/appengine/gaeauth/server/gaesigner"
         "github.com/luci/luci-go/common/clock"
-        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/logdog/api/config/svcconfig"
         "github.com/luci/luci-go/logdog/appengine/coordinator/config"
         "github.com/luci/luci-go/logdog/common/storage"
         "github.com/luci/luci-go/logdog/common/storage/archive"
         "github.com/luci/luci-go/logdog/common/storage/bigtable"
         "github.com/luci/luci-go/logdog/common/storage/caching"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/router"
 
         gcps "cloud.google.com/go/pubsub"
         gcst "cloud.google.com/go/storage"
         "golang.org/x/net/context"
         "google.golang.org/api/option"
         "google.golang.org/appengine"
         "google.golang.org/grpc"
         "google.golang.org/grpc/metadata"
@@ skipping 32 matching lines @@
         // 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.
         //
         // Returns the same error codes as config.ProjectConfig.
-        ProjectConfig(context.Context, luciConfig.ProjectName) (*svcconfig.ProjectConfig, error)
+        ProjectConfig(context.Context, cfgtypes.ProjectName) (*svcconfig.ProjectConfig, error)
 
         // Storage returns a Storage instance for the supplied log stream.
         //
         // The caller must close the returned instance if successful.
         StorageForStream(context.Context, *LogStreamState) (Storage, error)
 
         // ArchivalPublisher returns an ArchivalPublisher instance.
         ArchivalPublisher(context.Context) (ArchivalPublisher, error)
 }
 
@@ skipping 13 matching lines @@
 // prodServicesInst is a Service exposing production faciliites. A unique
 // instance is bound to each each request.
 type prodServicesInst struct {
         sync.Mutex
 
         // aeCtx is an AppEngine Context initialized for the current request.
         aeCtx context.Context
 
         // gcfg is the cached global configuration.
         gcfg           *config.Config
-        projectConfigs map[luciConfig.ProjectName]*cachedProjectConfig
+        projectConfigs map[cfgtypes.ProjectName]*cachedProjectConfig
 
         // archivalIndex is the atomically-manipulated archival index for the
         // ArchivalPublisher. This is shared between all ArchivalPublisher instances
         // from this service.
         archivalIndex int32
 
         // pubSubClients is a map of Pub/Sub client singletons generated during this
         // request. Each client is associated with its project, and will be
         // initialized the first time it is requested by getPubSubClient.
         //
@@ skipping 33 matching lines @@
 
         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
+        project cfgtypes.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 {
+func (s *prodServicesInst) getOrCreateCachedProjectConfig(project cfgtypes.ProjectName) *cachedProjectConfig {
         s.Lock()
         defer s.Unlock()
 
         if s.projectConfigs == nil {
-                s.projectConfigs = make(map[luciConfig.ProjectName]*cachedProjectConfig)
+                s.projectConfigs = make(map[cfgtypes.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) {
+func (s *prodServicesInst) ProjectConfig(c context.Context, project cfgtypes.ProjectName) (*svcconfig.ProjectConfig, error) {
         return s.getOrCreateCachedProjectConfig(project).resolve(c)
 }
 
 func (s *prodServicesInst) StorageForStream(c context.Context, lst *LogStreamState) (Storage, error) {
         if !lst.ArchivalState().Archived() {
                 log.Debugf(c, "Log is not archived. Fetching from intermediate storage.")
                 return s.newBigTableStorage(c)
         }
 
         log.Fields{
@@ skipping 338 matching lines @@
 
         // Sign index URL.
         if req.Index {
                 if resp.Index, err = doSign(si.index); err != nil {
                         return nil, errors.Annotate(err).InternalReason("failed to sign index URL").Err()
                 }
         }
 
         return &resp, nil
 }