LogDog: Update to archival V2.

appengine/logdog/coordinator/config/config.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 config
 
 import (
         "errors"
 
         "github.com/golang/protobuf/proto"
@@ skipping 41 matching lines @@
         // Config, is set, is the application's text-format configuration protobuf.
         // This is only used when running under dev-appserver.
         Config string `gae:",noindex"`
 }
 
 // LoadGlobalConfig loads the global configuration from the AppEngine settings.
 //
 // If no global configuration is present, settings.ErrNoSettings will be
 // returned.
 func LoadGlobalConfig(c context.Context) (*GlobalConfig, error) {
-        gc := GlobalConfig{}
-        if err := settings.Get(c, globalConfigSettingsKey, &gc); err != nil {
+        gcfg := GlobalConfig{}

[dnj, 2016/04/11 17:20:04]

This was changed b/c previously we were loading (usually from cache) a test blob
and unmarshalling it each time we wanted to see something. Now we cache it in
Services.

I also removed the GlobalConfig -> Config helper function. Now you get a
GlobalConfig, use it to instantiate a Config, and then use that. This
functionality is wrapped by Services.

+        if err := settings.Get(c, globalConfigSettingsKey, &gcfg); err != nil {
+                // If we're running the dev appserver, install some configuration stubs so
+                // they can be tweaked locally.
+                if err == settings.ErrNoSettings && info.Get(c).IsDevAppServer() {
+                        log.Infof(c, "Setting up development configuration...")
+
+                        if err := gcfg.storeNoValidate(c, "development setup"); err != nil {
+                                log.WithError(err).Warningf(c, "Failed to install development global config stub.")
+                        }
+                        if _, err := getSetupDevConfig(c); err != nil {
+                                log.WithError(err).Warningf(c, "Failed to install development configuration entry stub.")
+                        }
+                }
+
                 return nil, err
         }
-        return &gc, nil
+        return &gcfg, nil
 }
 
 // Store stores the new global configuration.
 func (gcfg *GlobalConfig) Store(c context.Context, why string) error {
         if err := gcfg.Validate(); err != nil {
                 return err
         }
         return gcfg.storeNoValidate(c, why)
 }
 
@@ skipping 72 matching lines @@
 
         // Validate the configuration.
         if err := validateConfig(&cc); err != nil {
                 log.WithError(err).Errorf(c, "Invalid Coordinator configuration.")
                 return nil, settings.ErrNoSettings
         }
 
         return &cc, nil
 }
 
-// Load loads the current configuration from "luci-config".
-func Load(c context.Context) (*svcconfig.Config, error) {
-        gcfg, err := LoadGlobalConfig(c)
-        if err != nil {
-                // If we're running the dev appserver, install some configuration stubs so
-                // they can be tweaked locally.
-                if err == settings.ErrNoSettings {
-                        if info.Get(c).IsDevAppServer() {
-                                log.Infof(c, "Setting up development configuration...")
-                                gcfg = &GlobalConfig{}
-                                if err := gcfg.storeNoValidate(c, "development setup"); err != nil {
-                                        log.WithError(err).Warningf(c, "Failed to install development global config stub.")
-                                }
-                                if _, err := getSetupDevConfig(c); err != nil {
-                                        log.WithError(err).Warningf(c, "Failed to install development configuration entry stub.")
-                                }
-                        }
-                }
-
-                return nil, err
-        }
-        return gcfg.LoadConfig(c)
-}
-
 // validateConfig checks the supplied Coordinator config object to ensure that
 // it meets a minimum configuration standard expected by our endpoitns and
 // handlers.
 func validateConfig(cc *svcconfig.Config) error {
         switch {
         case cc == nil:
                 return errors.New("configuration is nil")
         case cc.GetCoordinator() == nil:
                 return errors.New("no Coordinator configuration")
         default:
@@ skipping 15 matching lines @@
                 return nil, errors.New("no development configuration")
 
         default:
                 return nil, err
         }
 
         return &config.Config{
                 Content: dcfg.Config,
         }, nil
 }