luci_config: Request content only when desired.

luci_config/server/cfgclient/config.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 cfgclient
 
 import (
         "net/url"
 
         "github.com/luci/luci-go/common/config"
@@ skipping 45 matching lines @@
         //
         // Corresponds to auth.AsUser.
         AsUser = Authority(backend.AsUser)
 )
 
 // ServiceURL returns the URL of the config service.
 func ServiceURL(c context.Context) url.URL { return backend.Get(c).ServiceURL(c) }
 
 // Get retrieves a single configuration file.
 //
-// r, if supplied, is a MultiResolver that will load the configuration data.
-// If nil, the configuration data will be discarded (useful if you only care
-// about metas).
+// r, if not nil, is a Resolver that will load the configuration data. If nil,
+// the configuration data will be discarded (useful if you only care about
+// metas).
 //
 // meta, if not nil, will have the configuration's Meta loaded into it on
 // success.
 func Get(c context.Context, a Authority, cs cfgtypes.ConfigSet, path string, r Resolver, meta *Meta) error {
         be := backend.Get(c)
 
         params := backend.Params{
                 Authority: backend.Authority(a),
-                Content:   true,
+                Content:   r != nil,
         }
 
         if fr, ok := r.(FormattingResolver); ok {
                 params.FormatSpec = fr.Format()
         }
 
         item, err := be.Get(c, string(cs), path, params)
         if err != nil {
                 return err
         }
 
         if meta != nil {
                 *meta = *makeMeta(&item.Meta)
         }
         if r == nil {
                 return nil
         }
         return r.Resolve(item)
 }
 
 // Projects retrieves all named project configurations.
 //
-// r, if supplied, is a MultiResolver that will load the configuration data.
+// r, if not nil, is a MultiResolver that will load the configuration data.
 // If nil, the configuration data will be discarded (useful if you only care
 // about metas). If the MultiResolver operates on a slice (which it probably
 // will), each meta and/or error index will correspond to its slice index.
 //
 // If meta is not nil, it will be populated with a slice of *Meta entries
 // for each loaded configuration, in the same order that r receives them. If
 // r resolves to a slice, the indexes for each resolved slice entry and meta
 // entry should align unless r is doing something funky.
 //
 // Two types of failure may happen here. A systemic failure fails to load the
@@ skipping 14 matching lines @@
         return getAll(c, a, backend.GetAllRef, path, r, meta)
 }
 
 func getAll(c context.Context, a Authority, t backend.GetAllTarget, path string, r MultiResolver,
         meta *[]*Meta) error {
 
         be := backend.Get(c)
 
         params := backend.Params{
                 Authority: backend.Authority(a),
-                Content:   true,
+                Content:   r != nil,
         }
 
+        // If we're fetching content, apply a formatting specification.
         if fr, ok := r.(FormattingResolver); ok {
                 params.FormatSpec = fr.Format()
         }
 
         items, err := be.GetAll(c, t, path, params)
         if err != nil {
                 return err
         }
 
         // Load our metas.
@@ skipping 38 matching lines @@
 }
 
 func makeMeta(b *backend.Meta) *Meta {
         return &Meta{
                 ConfigSet:   cfgtypes.ConfigSet(b.ConfigSet),
                 Path:        b.Path,
                 ContentHash: b.ContentHash,
                 Revision:    b.Revision,
         }
 }