[vpython] Incorporate interpreter path/hash.

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
 
+        // cachedHash is the cached SHA256 hash string of the interpreter's binary
+        // contents. It is populated once, protected by cachedHashOnce.
+        cachedHash     string
+        cachedHashErr  error
+        cachedHashOnce sync.Once
+
         // testCommandHook, if not nil, is called on generated Command results prior
         // to returning them.
         testCommandHook func(*exec.Cmd)
 }
 
+// Normalize normalizes the Interpreter configuration by resolving relative
+// paths into absolute paths and evaluating symlnks.
+func (i *Interpreter) Normalize() error {
+        if err := filesystem.AbsPath(&i.Python); err != nil {
+                return err
+        }
+        resolved, err := filepath.EvalSymlinks(i.Python)
+        if err != nil {
+                return errors.Annotate(err).Reason("could not evaluate symlinks for: %(path)q").
+                        D("path", i.Python).
+                        Err()
+        }
+        i.Python = resolved
+        return nil
+}
+
 // IsolatedCommand returns a configurable exec.Cmd structure bound to this
 // Interpreter.
 //
 // The supplied arguments have several Python isolation flags prepended to them
 // to remove environmental factors such as:
 //      - The user's "site.py".
 //      - The current PYTHONPATH environment variable.
 //      - Compiled ".pyc/.pyo" files.
 func (i *Interpreter) IsolatedCommand(c context.Context, args ...string) *exec.Cmd {
         // Isolate the supplied arguments.
@@ skipping 33 matching lines @@
 
         if v, err = parseVersionOutput(strings.TrimSpace(string(out))); err != nil {
                 err = errors.Annotate(err).Err()
                 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
+// be returned.
+func (i *Interpreter) Hash() (string, error) {
+        hashInterpreter := func(path string) (string, error) {
+                fd, err := os.Open(i.Python)
+                if err != nil {
+                        return "", errors.Annotate(err).Reason("failed to open interpreter").Err()
+                }
+                defer fd.Close()
+
+                hash := sha256.New()
+                if _, err := io.Copy(hash, fd); err != nil {
+                        return "", errors.Annotate(err).Reason("failed to read [%(path)s] for hashing").
+                                D("path", path).
+                                Err()
+                }
+
+                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) {
         // Expected output:
         // Python X.Y.Z
         parts := strings.SplitN(output, " ", 2)
         if len(parts) != 2 || parts[0] != "Python" {
                 return Version{}, errors.Reason("unknown version output").
                         D("output", output).
                         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
 }