blob: ea3d4f75894255b5ec8a5abaf415081b43a5df73 [file] [log] [blame]
// Copyright 2017 The LUCI Authors.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
package application
import (
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.
// checkWrapperSentinel is text that will be output by a "vpython" instance if
// checkWrapperENV is set. If an application exits with a non-zero error code
// and outputs this text to STDOUT, then it is considered a "vpython" wrapper.
checkWrapperSentinel = checkWrapperENV + ": vpython wrapper check, exiting with non-zero return code"
func wrapperCheck(env environ.Env) bool {
if env.Get(checkWrapperENV) != "" {
fmt.Fprintln(os.Stdout, checkWrapperSentinel)
return true
return false
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
filter python.LookPathFilter
env environ.Env
lastPath string
lastOutput string
func (lp *lookPath) look(c context.Context, target string, filter python.LookPathFilter) (*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
lp.filter = filter
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 platform.python_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.ParseVersion(lp.lastOutput); 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 -c ...." 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 Python 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.lastOutput. 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) {
// If a version cache exists, current python binary has passed the wrapper
// check before.
if ok, _ := python.CheckVersionCachedExist(path); ok {
return false, nil
env.Set(checkWrapperENV, "1")
// We use 'sys.write' instead of 'print' so this will work for both py2 and
// py3.
cmd := exec.CommandContext(c, path, "-c",
"import platform, sys; sys.stdout.write(platform.python_version())")
cmd.Env = env.Sorted()
output, err := cmd.CombinedOutput()
rc, ok := exitcode.Get(err)
if !ok {
err = errors.Annotate(err, "failed to check if %q is a wrapper", path).Err()
// Retain the last output, so our "look" can reference it to extract the
// version string.
lp.lastPath = path
lp.lastOutput = string(output)
if rc != 0 {
// The target exited with a non-zero error code. It is a wrapper if it
// printed the sentinel text.
isWrapper = strings.TrimSpace(lp.lastOutput) == checkWrapperSentinel
if isWrapper {
// The target was successfully identified as a wrapper. Clear "err", which
// is non-nil b/c of the non-zero exit code, to indicate a successful
// wrapper check.
err = nil
// The target returned non-zero, but didn't identify as a wrapper. It is
// likely something that happens to be named the same thing as the target,
// which is an error.
err = errors.Annotate(err, "wrapper check returned non-zero").Err()
// If this isn't a wrapper, check if it meets our criteria
err = lp.filter(c, &python.Interpreter{Python: path})