[vpython] Allow default spec via enviornment.

vpython/spec/load.go

 // Copyright 2017 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 spec
 
 import (
         "bufio"
         "io/ioutil"
         "os"
@@ skipping 24 matching lines @@
 const CommonName = "common" + Suffix
 
 const (
         // DefaultInlineBeginGuard is the default loader InlineBeginGuard value.
         DefaultInlineBeginGuard = "[VPYTHON:BEGIN]"
         // DefaultInlineEndGuard is the default loader InlineEndGuard value.
         DefaultInlineEndGuard = "[VPYTHON:END]"
 )
 
 // Load loads an specification file text protobuf from the supplied path.
-func Load(path string) (*vpython.Spec, error) {
+func Load(path string, spec *vpython.Spec) error {
         content, err := ioutil.ReadFile(path)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to load file from: %(path)s").
+                return errors.Annotate(err).Reason("failed to load file from: %(path)s").
                         D("path", path).
                         Err()
         }
 
-        spec, err := Parse(string(content))
-        if err != nil {
-                return nil, errors.Annotate(err).Err()
-        }
-        return spec, nil
+        return Parse(string(content), spec)
 }
 
 // Parse loads a specification message from a content string.
-func Parse(content string) (*vpython.Spec, error) {
-        var spec vpython.Spec
-        if err := cproto.UnmarshalTextML(content, &spec); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to unmarshal vpython.Spec").Err()
+func Parse(content string, spec *vpython.Spec) error {
+        if err := cproto.UnmarshalTextML(content, spec); err != nil {
+                return errors.Annotate(err).Reason("failed to unmarshal vpython.Spec").Err()
         }
-        return &spec, nil
+        return nil
 }
 
 // Loader implements the generic ability to load a "vpython" spec file.
 type Loader struct {
         // InlineBeginGuard is a string that signifies the beginning of an inline
         // specification. If empty, DefaultInlineBeginGuard will be used.
         InlineBeginGuard string
         // InlineEndGuard is a string that signifies the end of an inline
         // specification. If empty, DefaultInlineEndGuard will be used.
         InlineEndGuard string
@@ skipping 82 matching lines @@
 // script's location, looking for a file named CommonName. If it finds one, it
 // will use that as the specification file. This enables scripts to implicitly
 // share an specification.
 func (l *Loader) LoadForScript(c context.Context, path string, isModule bool) (*vpython.Spec, error) {
         // Partner File: Try loading the spec from an adjacent file.
         specPath, err := l.findForScript(path, isModule)
         if err != nil {
                 return nil, errors.Annotate(err).Reason("failed to scan for filesystem spec").Err()
         }
         if specPath != "" {
-                switch sp, err := Load(specPath); {
-                case err != nil:
-                        return nil, errors.Annotate(err).Reason("failed to load specification file").
-                                D("specPath", specPath).
-                                Err()
+                var spec vpython.Spec
+                if err := Load(specPath, &spec); err != nil {
+                        return nil, err
+                }
 
-                case sp != nil:
-                        logging.Infof(c, "Loaded specification from: %s", specPath)
-                        return sp, nil
-                }
+                logging.Infof(c, "Loaded specification from: %s", specPath)
+                return &spec, nil
         }
 
         // Inline: Try and parse the main script for the spec file.
         mainScript := path
         if isModule {
                 // Module.
                 mainScript = filepath.Join(mainScript, "__main__.py")
         }
-        switch sp, err := l.parseFrom(mainScript); {
+        switch spec, err := l.parseFrom(mainScript); {
         case err != nil:
                 return nil, errors.Annotate(err).Reason("failed to parse inline spec from: %(script)s").
                         D("script", mainScript).
                         Err()
 
-        case sp != nil:
+        case spec != nil:
                 logging.Infof(c, "Loaded inline spec from: %s", mainScript)
-                return sp, nil
+                return spec, nil
         }
 
         // Common: Try and identify a common specification file.
         switch path, err := l.findCommonWalkingFrom(filepath.Dir(mainScript)); {
         case err != nil:
                 return nil, err
 
         case path != "":
-                spec, err := Load(path)
-                if err != nil {
+                var spec vpython.Spec
+                if err := Load(path, &spec); err != nil {
                         return nil, err
                 }
 
                 logging.Infof(c, "Loaded common spec from: %s", path)
-                return spec, nil
+                return &spec, nil
         }
 
         // Couldn't identify a specification file.
         return nil, nil
 }
 
 func (l *Loader) findForScript(path string, isModule bool) (string, error) {
         if !isModule {
                 path += Suffix
                 if st, err := os.Stat(path); err != nil || st.IsDir() {
@@ skipping 108 matching lines @@
                                         line = ""
                                 }
                         } else {
                                 line = strings.TrimPrefix(line, prefix)
                         }
                         content[i] = line
                 }
         }
 
         // Process the resulting file.
-        spec, err := Parse(strings.Join(content, "\n"))
-        if err != nil {
+        var spec vpython.Spec
+        if err := Parse(strings.Join(content, "\n"), &spec); err != nil {
                 return nil, errors.Annotate(err).Reason("failed to parse spec file from: %(path)s").
                         D("path", path).
                         Err()
         }
-        return spec, nil
+        return &spec, nil
 }
 
 func (l *Loader) findCommonWalkingFrom(startDir string) (string, error) {
         // Walk until we hit root.
         prevDir := ""
         for prevDir != startDir {
                 checkPath := filepath.Join(startDir, CommonName)
 
                 switch _, err := os.Stat(checkPath); {
                 case err == nil:
@@ skipping 19 matching lines @@
                         }
                 }
 
                 // Walk up a directory.
                 startDir, prevDir = filepath.Dir(startDir), startDir
         }
 
         // Couldn't find the file.
         return "", nil
 }