Add server/cache support to gaeconfig.

scheduler/appengine/catalog/catalog.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 catalog implements a part that talks to luci-config service to fetch
 // and parse job definitions. Catalog knows about all task types and can
 // instantiate task.Manager's.
 package catalog
 
 import (
         "fmt"
         "net/url"
         "reflect"
         "regexp"
         "strings"
 
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         "github.com/luci/gae/service/info"
-        "github.com/luci/luci-go/common/config"
+        commonConfig "github.com/luci/luci-go/common/config"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/server/config"
+        "github.com/luci/luci-go/server/config/textproto"
 
         "github.com/luci/luci-go/scheduler/appengine/messages"
         "github.com/luci/luci-go/scheduler/appengine/schedule"
         "github.com/luci/luci-go/scheduler/appengine/task"
 )
 
 var (
         // jobIDRe is used to validate job ID field.
         jobIDRe = regexp.MustCompile(`^[0-9A-Za-z_\-\.]{1,100}$`)
 )
@@ skipping 124 matching lines @@
         msg := messages.TaskDefWrapper{}
         if err := proto.Unmarshal(task, &msg); err != nil {
                 return nil, err
         }
         return cat.extractTaskProto(&msg)
 }
 
 func (cat *catalog) GetAllProjects(c context.Context) ([]string, error) {
         // Enumerate all projects that have <config>.cfg. Do not fetch actual configs
         // yet.
-        cfgs, err := config.GetProjectConfigs(c, cat.configFile(c), true)
-        if err != nil {
+        var metas []*config.Meta
+        if err := config.GetAll(c, config.AsService, config.Project, cat.configFile(c), nil, &metas); err != nil {
                 return nil, err
         }
-        out := make([]string, 0, len(cfgs))
-        for _, cfg := range cfgs {
-                // ConfigSet must be "projects/<project-id>". Verify that.
-                chunks := strings.Split(cfg.ConfigSet, "/")
-                if len(chunks) != 2 || chunks[0] != "projects" {
-                        logging.Warningf(c, "Unexpected ConfigSet: %s", cfg.ConfigSet)
+
+        out := make([]string, 0, len(metas))
+        for _, meta := range metas {
+                projectName, _, _ := config.ParseProjectConfigSet(meta.ConfigSet)
+                if projectName == "" {
+                        logging.Warningf(c, "Unexpected ConfigSet: %s", meta.ConfigSet)
                 } else {
-                        out = append(out, chunks[1])
+                        out = append(out, string(projectName))
                 }
         }
         return out, nil
 }
 
 func (cat *catalog) GetProjectJobs(c context.Context, projectID string) ([]Definition, error) {
-        configSetURL, err := config.GetConfigSetLocation(c, "projects/"+projectID)
+        configSet := config.ProjectConfigSet(commonConfig.ProjectName(projectID))
+        configSetURL, err := config.GetConfigSetURL(c, config.AsService, configSet)
         switch err {
         case nil: // Continue
         case config.ErrNoConfig:
                 return nil, nil
         default:
                 return nil, err
         }
 
-        rawCfg, err := config.GetConfig(c, "projects/"+projectID, cat.configFile(c), false)
-        if err == config.ErrNoConfig {
+        var (
+                cfg  messages.ProjectConfig
+                meta config.Meta
+        )
+        switch err := config.Get(c, config.AsService, configSet, cat.configFile(c), textproto.Message(&cfg), &meta); err {
+        case nil:
+                break
+        case config.ErrNoConfig:
                 return nil, nil
-        }
-        if err != nil {
+        default:
                 return nil, err
         }
-        revisionURL := getRevisionURL(configSetURL, rawCfg.Revision, rawCfg.Path)
+
+        revisionURL := getRevisionURL(&configSetURL, meta.Revision, meta.Path)
         if revisionURL != "" {
                 logging.Infof(c, "Importing %s", revisionURL)
         }
-        cfg := messages.ProjectConfig{}
-        if err = proto.UnmarshalText(rawCfg.Content, &cfg); err != nil {
-                return nil, err
-        }
 
         out := make([]Definition, 0, len(cfg.Job)+len(cfg.Trigger))
 
         // Regular jobs, triggered jobs.
         for _, job := range cfg.Job {
                 if job.Disabled {
                         continue
                 }
                 id := "(empty)"
                 if job.Id != "" {
@@ skipping 13 matching lines @@
                 if schedule == "" {
                         schedule = defaultJobSchedule
                 }
                 flavor := JobFlavorTriggered
                 if schedule != "triggered" {
                         flavor = JobFlavorPeriodic
                 }
                 out = append(out, Definition{
                         JobID:       fmt.Sprintf("%s/%s", projectID, job.Id),
                         Flavor:      flavor,
-                        Revision:    rawCfg.Revision,
+                        Revision:    meta.Revision,
                         RevisionURL: revisionURL,
                         Schedule:    schedule,
                         Task:        packed,
                 })
         }
 
         // Triggering jobs.
         for _, trigger := range cfg.Trigger {
                 if trigger.Disabled {
                         continue
@@ skipping 12 matching lines @@
                         logging.Errorf(c, "Failed to marshal the task: %s/%s: %s", projectID, id, err)
                         continue
                 }
                 schedule := trigger.Schedule
                 if schedule == "" {
                         schedule = defaultTriggerSchedule
                 }
                 out = append(out, Definition{
                         JobID:       fmt.Sprintf("%s/%s", projectID, trigger.Id),
                         Flavor:      JobFlavorTrigger,
-                        Revision:    rawCfg.Revision,
+                        Revision:    meta.Revision,
                         RevisionURL: revisionURL,
                         Schedule:    schedule,
                         Task:        packed,
                 })
         }
 
         return out, nil
 }
 
 // configFile returns a name of *.cfg file (inside project's config set) with
@@ skipping 125 matching lines @@
                 field := v.Field(i)
                 if field.Type() == taskType {
                         field.Set(reflect.ValueOf(task))
                         return proto.Marshal(&wrapper)
                 }
         }
         // This can happen only if TaskDefWrapper wasn't updated when a new task type
         // was added. This is a developer's mistake, not a config mistake.
         return nil, fmt.Errorf("could not find a field of type %T in TaskDefWrapper", task)
 }