Milo: Buildbucket PubSub ingestion outline

milo/common/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 common
 
 import (
         "fmt"
         "time"
 
@@ skipping 92 matching lines @@
         }
         if msg, ok := item.(ServiceConfig); ok {
                 logging.Infof(c, "loaded config entry from %s", msg.LastUpdated.Format(time.RFC3339))
                 return &msg, nil
         }
         return nil, fmt.Errorf("could not load service config %#v", item)
 }
 
 // UpdateServiceConfig fetches the service config from luci-config
 // and then stores a snapshot of the configuration in datastore.
-func UpdateServiceConfig(c context.Context) error {
+func UpdateServiceConfig(c context.Context) (*config.Settings, error) {
         // Load the settings from luci-config.
         cs := string(cfgclient.CurrentServiceConfigSet(c))
         // Acquire the raw config client.
         lucicfg := backend.Get(c).GetConfigInterface(c, backend.AsService)
         // Our global config name is called settings.cfg.
         cfg, err := lucicfg.GetConfig(c, cs, "settings.cfg", false)
         if err != nil {
-                return fmt.Errorf("could not load settings.cfg from luci-config: %s", err)
+                return nil, fmt.Errorf("could not load settings.cfg from luci-config: %s", err)
         }
         settings := &config.Settings{}
         err = proto.UnmarshalText(cfg.Content, settings)
         if err != nil {
-                return fmt.Errorf("could not unmarshal proto from luci-config:\n%s", cfg.Content)
+                return nil, fmt.Errorf(
+                        "could not unmarshal proto from luci-config:\n%s", cfg.Content)
         }
         newConfig := ServiceConfig{
                 ID:          ServiceConfigID,
                 Text:        cfg.Content,
                 Revision:    cfg.Revision,
                 LastUpdated: time.Now().UTC(),
         }
         newConfig.Data, err = proto.Marshal(settings)
         if err != nil {
-                return fmt.Errorf("could not marshal proto into binary\n%s", newConfig.Text)
+                return nil, fmt.Errorf("could not marshal proto into binary\n%s", newConfig.Text)
         }
 
         // Do the revision check & swap in a datastore transaction.
         err = datastore.RunInTransaction(c, func(c context.Context) error {
                 oldConfig := ServiceConfig{ID: ServiceConfigID}
                 err := datastore.Get(c, &oldConfig)
                 switch err {
                 case datastore.ErrNoSuchEntity:
                         // Might be the first time this has run.
                         logging.WithError(err).Warningf(c, "No existing service config.")
                 case nil:
                         // Continue
                 default:
                         return fmt.Errorf("could not load existing config: %s", err)
                 }
                 // Check to see if we need to update
                 if oldConfig.Revision == newConfig.Revision {
                         logging.Infof(c, "revisions matched (%s), no need to update", oldConfig.Revision)
                         return nil
                 }
                 logging.Infof(c, "revisions differ (old %s, new %s), updating",
                         oldConfig.Revision, newConfig.Revision)
                 return datastore.Put(c, &newConfig)
         }, nil)
 
         if err != nil {
-                return fmt.Errorf("failed to update config entry in transaction", err)
+                return nil, fmt.Errorf("failed to update config entry in transaction", err)
         }
         logging.Infof(c, "successfully updated to new config")
 
-        return nil
+        return settings, nil
 }
 
 // UpdateProjectConfigs internal project configuration based off luci-config.
 // update updates Milo's configuration based off luci config.  This includes
 // scanning through all project and extract all console configs.
 func UpdateProjectConfigs(c context.Context) error {
         cfgName := info.AppID(c) + ".cfg"
 
         var (
                 configs []*config.Project
@@ skipping 93 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)
 }