[vpython] Implement smart probing.

vpython/application/probe.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 application
+
+import (
+        "os/exec"
+
+        "golang.org/x/net/context"
+
+        "github.com/luci/luci-go/vpython/python"
+
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/system/environ"
+        "github.com/luci/luci-go/common/system/exitcode"
+        "github.com/luci/luci-go/common/system/prober"
+)
+
+const (
+        // CheckWrapperENV is an environment variable that is used to detect if a
+        // given binary is a "vpython" wrapper instance. The "vpython" Main function
+        // will immediately exit with a non-zero return code if this environment
+        // variable is set.
+        //
+        // See checkWrapper for more details.
+        CheckWrapperENV = "VPYTHON_CHECK_WRAPPER"
+)
+
+type lookPath struct {
+        // probeBase is a base prober whose Self and SelfStat fields will be used
+        // during a lookPathImpl call. This ensures that we only have to call
+        // ResolveSelf once for any given application.
+        probeBase prober.Probe
+
+        env               environ.Env
+        lastPath          string
+        lastVersionOutput []byte
+}
+
+func (lp *lookPath) look(c context.Context, target string) (*python.LookPathResult, error) {
+        // Construct our probe, derived it from our "probeBase" and tailored to the
+        // specific "target" we're looking for.
+        probe := lp.probeBase
+        probe.Target = target
+        probe.CheckWrapper = lp.checkWrapper
+
+        var result python.LookPathResult
+        var err error
+        if result.Path, err = probe.Locate(c, "", lp.env.Clone()); err != nil {
+                return nil, err
+        }
+
+        // During probing, we try and capture the output of "--version". If we do,
+        // and if we confirm that the "path" returned by the probe matches "lastPath",
+        // return this version along with the resolution.
+        if result.Path == lp.lastPath {
+                var err error
+                if result.Version, err = python.ParseVersionOutput(lp.lastVersionOutput); err == nil {
+                        logging.Debugf(c, "Detected Python version %q from probe candidate [%s]", result.Version, result.Path)
+                } else {
+                        logging.Debugf(c, "Failed to parse version from probe candidate [%s]: %s", result.Path, err)
+                }
+        }
+
+        return &result, nil
+}
+
+// checkWrapper is a prober.CheckWrapperFunc that detects if a given path is a
+// "vpython" instance.
+//
+// It does this by running it "path --version" with CheckWrapperENV set. If
+// the target is a "vpython" wrapper, it will immediately exit with a non-zero
+// value (see Main). If it is not a valid Python program, its behavior is
+// undefined. If it is a valid Pytohn instance, it will exit with a Python
+// version string.
+//
+// As a side effect, the text output of the last version probe will be stored
+// in lp.lastVersionOutput. The "look" function can pass this value on to
+// the LookPathResult.
+func (lp *lookPath) checkWrapper(c context.Context, path string, env environ.Env) (isWrapper bool, err error) {
+        lp.lastPath = path
+        env.Set(CheckWrapperENV, "1")
+
+        cmd := exec.CommandContext(c, path, "--version")
+        cmd.Env = env.Sorted()
+
+        lp.lastVersionOutput, err = cmd.CombinedOutput()
+        rc, ok := exitcode.Get(err)
+        if !ok {
+                err = errors.Annotate(err).Reason("failed to check if %(path)q is a wrapper").
+                        D("path", path).
+                        Err()
+                return
+        }
+
+        // If "--version" didn't return "0", we determine that this is a wrapper,
+        // since no Python interpreter would return non-zero for "--version".

[iannucci, 2017/06/07 17:40:26]

it might if it failed to load properly though, right? Should we print something
like "IMAWRAPPER" to stdout instead?

[dnj, 2017/06/07 17:43:26]

If it fails to load properly, we should not use it as a candidate anyway. The
net effect of "isWrapper" is to skip that candidate, and I think we would want
to do that with a Python binary that can't run.

Perhaps I should invert this? If I make this check "is candidate" instead of "is
wrapper", then this can prune any non-candidate without being confusing. I think
I'll do that.

[dnj, 2017/06/07 17:45:51]

OTOH if Python is broken, I don't want "vpython" to gloss over it with some
hard-to-track behavior. I'll go with your idea and have it print out a sentinel
string.

+        isWrapper, err = (rc != 0), nil
+        return
+}