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"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/luci_config/common/cfgtypes"
+        "github.com/luci/luci-go/luci_config/server/cfgclient"
+        "github.com/luci/luci-go/luci_config/server/cfgclient/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 21 matching lines @@
         GetTaskManager(m proto.Message) task.Manager
 
         // UnmarshalTask takes a serialized task definition (as in Definition.Task),
         // unmarshals and validates it, and returns proto.Message that represent
         // the concrete task to run (e.g. SwarmingTask proto). It can be passed to
         // corresponding task.Manager.
         UnmarshalTask(task []byte) (proto.Message, error)
 
         // GetAllProjects returns a list of all known project ids.
         //
-        // It assumes there's config.Interface implementation installed in
+        // It assumes there's cfgclient implementation installed in
         // the context, will panic if it's not there.
         GetAllProjects(c context.Context) ([]string, error)
 
         // GetProjectJobs returns a list of scheduler jobs defined within a project or
         // empty list if no such project.
         //
-        // It assumes there's config.Interface implementation installed in
+        // It assumes there's cfgclient implementation installed in
         // the context, will panic if it's not there.
         GetProjectJobs(c context.Context, projectID string) ([]Definition, error)
 }
 
 // JobFlavor describes a category of jobs.
 type JobFlavor int
 
 const (
         // JobFlavorPeriodic is a regular job (Swarming, Buildbucket) that runs on
         // a schedule or via a trigger.
@@ skipping 75 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 []*cfgclient.Meta
+        if err := cfgclient.Projects(c, cfgclient.AsService, 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, _, _ := meta.ConfigSet.SplitProject()
+                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 := cfgtypes.ProjectConfigSet(cfgtypes.ProjectName(projectID))
+        configSetURL, err := cfgclient.GetConfigSetURL(c, cfgclient.AsService, configSet)
         switch err {
         case nil: // Continue
-        case config.ErrNoConfig:
+        case cfgclient.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 cfgclient.Meta
+        )
+        switch err := cfgclient.Get(c, cfgclient.AsService, configSet, cat.configFile(c), textproto.Message(&cfg), &meta); err {
+        case nil:
+                break
+        case cfgclient.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)
 }