[vpython] Implement smart probing.

vpython/python/interpreter.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 python
 
 import (
         "crypto/sha256"
         "encoding/hex"
         "io"
         "os"
         "os/exec"
         "path/filepath"
         "strings"
         "sync"
 
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/system/filesystem"
 
         "golang.org/x/net/context"
 )
 
-type runnerFunc func(cmd *exec.Cmd, capture bool) (string, error)
-
 // Interpreter represents a system Python interpreter. It exposes the ability
 // to use common functionality of that interpreter.
 type Interpreter struct {
         // Python is the path to the system Python interpreter.
         Python string
 
         // cachedVersion is the cached Version for this interpreter. It is populated
         // on the first GetVersion call.
         cachedVersion   *Version
         cachedVersionMu sync.Mutex
@@ skipping 62 matching lines @@
 
         // We use CombinedOutput here becuase Python2 writes the version to STDERR,
         // while Python3+ writes it to STDOUT.
         cmd := i.IsolatedCommand(c, "--version")
         out, err := cmd.CombinedOutput()
         if err != nil {
                 err = errors.Annotate(err).Err()
                 return
         }
 
-        if v, err = parseVersionOutput(strings.TrimSpace(string(out))); err != nil {
-                err = errors.Annotate(err).Err()
+        if v, err = ParseVersionOutput(out); err != nil {
                 return
         }
 
         i.cachedVersion = &v
         return
 }
 
 // Hash returns the SHA256 hash string of this interpreter.
 //
 // The hash value is cached; if called multiple times, the cached value will
@@ skipping 15 matching lines @@
 
                 return hex.EncodeToString(hash.Sum(nil)), nil
         }
 
         i.cachedHashOnce.Do(func() {
                 i.cachedHash, i.cachedHashErr = hashInterpreter(i.Python)
         })
         return i.cachedHash, i.cachedHashErr
 }
 
-func parseVersionOutput(output string) (Version, error) {
+// ParseVersionOutput parses a Version out of the output of a "--version" Python
+// invocation.
+func ParseVersionOutput(output []byte) (Version, error) {
+        s := strings.TrimSpace(string(output))
+
         // Expected output:
         // Python X.Y.Z
-        parts := strings.SplitN(output, " ", 2)
+        parts := strings.SplitN(s, " ", 2)
         if len(parts) != 2 || parts[0] != "Python" {
                 return Version{}, errors.Reason("unknown version output").
-                        D("output", output).
+                        D("output", s).
                         Err()
         }
 
         v, err := ParseVersion(parts[1])
         if err != nil {
                 err = errors.Annotate(err).Reason("failed to parse version from: %(value)q").
                         D("value", parts[1]).
                         Err()
                 return v, err
         }
         return v, nil
 }