Add server/cache support to gaeconfig.

milo/appengine/settings/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 settings
 
 import (
         "fmt"
-        "strings"
 
-        "github.com/golang/protobuf/proto"
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
-        "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/luci_config/server/cfgclient"
+        "github.com/luci/luci-go/luci_config/server/cfgclient/textproto"
         milocfg "github.com/luci/luci-go/milo/common/config"
         "github.com/luci/luci-go/server/router"
 
+        "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 )
 
 // Project is a LUCI project.
 type Project struct {
         // The ID of the project, as per self defined.  This is not the luci-cfg
         // name.
         ID string `gae:"$id"`
         // The luci-cfg name of the project.
         Name string
@@ skipping 11 matching lines @@
         }
         logging.Infof(c, "Successfully completed")
         h.WriteHeader(200)
 }
 
 // Update internal configuration based off luci-cfg.
 // update updates Milo's configuration based off luci config.  This includes
 // scanning through all project and extract all console configs.
 func Update(c context.Context) error {
         cfgName := info.AppID(c) + ".cfg"
-        cfgs, err := config.GetProjectConfigs(c, cfgName, false)
-        if err != nil {
+
+        var (
+                configs []*milocfg.Project
+                metas   []*cfgclient.Meta
+        )
+        if err := cfgclient.Projects(c, cfgclient.AsService, cfgName, textproto.Slice(&configs), &metas); err != nil {
                 logging.WithError(err).Errorf(c, "Encountered error while getting project config for %s", cfgName)
                 return err
         }
+
         // A map of project ID to project.
         projects := map[string]*Project{}
-        for _, cfg := range cfgs {
-                pathParts := strings.SplitN(cfg.ConfigSet, "/", 2)
-                if len(pathParts) != 2 {
-                        return fmt.Errorf("Invalid config path: %s", cfg.Path)
-                }
-                name := pathParts[1]
-                proj := milocfg.Project{}
-                logging.Infof(c, "Prossing %s", name)
-                if err = proto.UnmarshalText(cfg.Content, &proj); err != nil {
-                        logging.WithError(err).Errorf(
-                                c, "Encountered error while processing %s.  Config:\n%s", name, cfg.Content)
-                        return err
-                }
+        for i, proj := range configs {
+                projectName, _, _ := metas[i].ConfigSet.SplitProject()
+
+                logging.Infof(c, "Prossing %s", projectName)
                 if dup, ok := projects[proj.ID]; ok {
                         return fmt.Errorf(
-                                "Duplicate project ID: %s. (%s and %s)", proj.ID, dup.Name, name)
+                                "Duplicate project ID: %s. (%s and %s)", proj.ID, dup.Name, projectName)
                 }
                 p := &Project{
                         ID:   proj.ID,
-                        Name: name,
+                        Name: string(projectName),
                 }
                 projects[proj.ID] = p
-                p.Data, err = proto.Marshal(&proj)
+
+                var err error
+                p.Data, err = proto.Marshal(proj)
                 if err != nil {
                         return err
                 }
         }
 
         // Now load all the data into the datastore.
         projs := make([]*Project, 0, len(projects))
         for _, proj := range projects {
                 projs = append(projs, proj)
         }
-        err = ds.Put(c, projs)
-        if err != nil {
+        if err := ds.Put(c, projs); err != nil {
                 return err
         }
 
         // Delete entries that no longer exist.
         q := ds.NewQuery("Project").KeysOnly(true)
         allProjs := []Project{}
         ds.GetAll(c, q, &allProjs)
         toDelete := []Project{}
         for _, proj := range allProjs {
                 if _, ok := projects[proj.ID]; !ok {
@@ skipping 46 matching lines @@
         if err != nil {
                 return nil, err
         }
         for _, cs := range p.Consoles {
                 if cs.Name == consoleName {
                         return cs, nil
                 }
         }
         return nil, fmt.Errorf("Console %s not found in project %s", consoleName, projName)
 }