Add server/cache support to gaeconfig.

appengine/gaeconfig/settings.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 gaeconfig
 
 import (
         "errors"
         "fmt"
         "net/url"
         "strconv"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/server/settings"
 )
 
 // DefaultExpire is a reasonable default expiration value.
 const DefaultExpire = 10 * time.Minute
 
+type dsCacheMode string
+
+const (
+        dsCacheDisabled dsCacheMode = ""
+        dsCacheEnabled  dsCacheMode = "Enabled"
+        dsCacheStrict   dsCacheMode = "Strict"
+)
+
+const dsCacheDisabledSetting = "Disabled"
+
 // Settings are stored in the datastore via appengine/gaesettings package.
 type Settings struct {
         // ConfigServiceURL is URL of luci-config service to fetch configs from.
         ConfigServiceURL string `json:"config_service_url"`
 
         // CacheExpirationSec is how long to hold configs in local cache.
         CacheExpirationSec int `json:"cache_expiration_sec"`
+
+        // DatastoreCacheMode, is the datastore caching mode.
+        DatastoreCacheMode dsCacheMode `json:"datastore_enabled"`
 }
 
 // FetchCachedSettings fetches Settings from the settings store.
 //
 // Uses in-process global cache to avoid hitting datastore often. The cache
 // expiration time is 1 min (see gaesettings.expirationTime), meaning
 // the instance will refetch settings once a minute (blocking only one unlucky
 // request to do so).
 //
 // Returns errors only if there's no cached value (i.e. it is the first call
 // to this function in this process ever) and datastore operation fails.
 func FetchCachedSettings(c context.Context) (Settings, error) {
         s := Settings{}
         switch err := settings.Get(c, settingsKey, &s); err {
         case nil:
                 return s, nil
         case settings.ErrNoSettings:
                 return DefaultSettings(), nil
         default:
                 return Settings{}, err
         }
 }
 
+func mustFetchCachedSettings(c context.Context) *Settings {
+        settings, err := FetchCachedSettings(c)
+        if err != nil {
+                panic(err)
+        }
+        return &settings
+}
+
 // DefaultSettings returns Settings to use if setting store is empty.
 func DefaultSettings() Settings {
         return Settings{
                 CacheExpirationSec: int(DefaultExpire.Seconds()),
+                DatastoreCacheMode: dsCacheDisabled,
         }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // UI for settings.
 
 // settingsKey is used internally to identify gaeconfig settings in settings
 // store.
 const settingsKey = "gaeconfig"
 
@@ skipping 38 matching lines @@
                         Validator: func(v string) error {
                                 if i, err := strconv.Atoi(v); err != nil || i < 0 {
                                         return errors.New("expecting a non-negative integer")
                                 }
                                 return nil
                         },
                         Help: `<p>For better performance configuration files fetched from remote
 service are cached in memcache for specified amount of time. Set it to 0 to
 disable local cache.</p>`,
                 },
+                {
+                        ID:    "DatastoreCacheMode",
+                        Title: "Enable datastore-backed config caching",
+                        Type:  settings.UIFieldChoice,
+                        ChoiceVariants: []string{
+                                dsCacheDisabledSetting,
+                                string(dsCacheEnabled),
+                                string(dsCacheStrict),
+                        },
+                        Help: `<p>For better performance and resilience against configuration
+service outages, the local datastore can be used as a backing cache. When
+enabled, an additional <strong>Strict</strong> mode is available where expired
+datastore entries will error instead of fail-open to the config service.</p>`,
+                },
         }, nil
 }
 
 func (settingsUIPage) ReadSettings(c context.Context) (map[string]string, error) {
         s := DefaultSettings()
         err := settings.GetUncached(c, settingsKey, &s)
         if err != nil && err != settings.ErrNoSettings {
                 return nil, err
         }
+
+        cacheMode := string(s.DatastoreCacheMode)
+        if cacheMode == string(dsCacheDisabled) {
+                cacheMode = dsCacheDisabledSetting
+        }
+
         return map[string]string{
                 "ConfigServiceURL":   s.ConfigServiceURL,
                 "CacheExpirationSec": strconv.Itoa(s.CacheExpirationSec),
+                "DatastoreCacheMode": cacheMode,
         }, nil
 }
 
 func (settingsUIPage) WriteSettings(c context.Context, values map[string]string, who, why string) error {
-        modified := Settings{}
-        modified.ConfigServiceURL = values["ConfigServiceURL"]
+        dsMode := dsCacheMode(values["DatastoreCacheMode"])
+        if dsMode == dsCacheDisabledSetting {
+                dsMode = dsCacheDisabled
+        }
+
+        modified := Settings{
+                ConfigServiceURL:   values["ConfigServiceURL"],
+                DatastoreCacheMode: dsMode,
+        }
 
         var err error
         modified.CacheExpirationSec, err = strconv.Atoi(values["CacheExpirationSec"])
         if err != nil {
                 return err
         }
 
         return settings.SetIfChanged(c, settingsKey, &modified, who, why)
 }
 
 func init() {
         settings.RegisterUIPage(settingsKey, settingsUIPage{})
 }