[vpython] Incorporate interpreter path/hash.

vpython/venv/config.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 venv
 
 import (
         "fmt"
         "os"
         "path/filepath"
@@ skipping 56 matching lines @@
         //
         // This can be used to enforce "shebang" length limits, whereupon generated
         // VirtualEnv scripts may be generated with a "shebang" (#!) line longer than
         // what is allowed by the operating system.
         MaxScriptPathLen int
 
         // si is the system Python interpreter. It is resolved during
         // "resolvePythonInterpreter".
         si *python.Interpreter
 
+        // rt is the resolved Python runtime.
+        rt vpython.Runtime
+
         // testPreserveInstallationCapability is a testing parameter. If true, the
         // VirtualEnv's ability to install will be preserved after the setup. This is
         // used by the test whell generation bootstrap code.
         testPreserveInstallationCapability bool
 
         // testLeaveReadWrite, if true, instructs the VirtualEnv setup to leave the
         // directory read/write. This makes it easier to manage, and is safe since it
         // is not a production directory.
         testLeaveReadWrite bool
 }
@@ skipping 74 matching lines @@
         e = e.Clone()
         e.Spec = cfg.Spec.Clone()
 
         if err := cfg.Loader.Resolve(c, e); err != nil {
                 return nil, errors.Annotate(err).Reason("failed to resolve packages").Err()
         }
 
         if err := cfg.resolvePythonInterpreter(c, e.Spec); err != nil {
                 return nil, errors.Annotate(err).Reason("failed to resolve system Python interpreter").Err()
         }
+        rt := vpython.Runtime{
+                Path:    cfg.si.Python,
+                Version: e.Spec.PythonVersion,
+        }
+
+        var err error
+        if rt.Hash, err = cfg.si.Hash(); err != nil {
+                return nil, err
+        }
+        e.Runtime = &rt
+        logging.Debugf(c, "Resolved system Python runtime (%s @ %s): %s", rt.Version, rt.Hash, rt.Path)
 
         // Ensure that our base directory exists.
         if err := filesystem.MakeDirs(cfg.BaseDir); err != nil {
                 return nil, errors.Annotate(err).Reason("could not create environment root: %(root)s").
                         D("root", cfg.BaseDir).
                         Err()
         }
 
         // Generate our environment name based on the deterministic hash of its
         // fully-resolved specification.
-        return cfg.envForName(cfg.envNameForSpec(e.Spec), e), nil
+        return cfg.envForName(cfg.envNameForSpec(e.Spec, e.Runtime), e), nil
 }
 
 // EnvName returns the VirtualEnv environment name for the environment that cfg
 // describes.
-func (cfg *Config) envNameForSpec(s *vpython.Spec) string {
-        name := spec.Hash(s, EnvironmentVersion)
+func (cfg *Config) envNameForSpec(s *vpython.Spec, rt *vpython.Runtime) string {
+        name := spec.Hash(s, rt, EnvironmentVersion)
         if cfg.MaxHashLen > 0 && len(name) > cfg.MaxHashLen {
                 name = name[:cfg.MaxHashLen]
         }
         return name
 }
 
 // Prune performs a pruning round on the environment set described by this
 // Config.
 func (cfg *Config) Prune(c context.Context) error {
         if err := prune(c, cfg, nil); err != nil {
                 return errors.Annotate(err).Err()
         }
         return nil
 }
 
 // envForName creates an Env for a named directory.
+//
+// The Environment, e, can be nil; however, code paths that require it may not
+// be called.
 func (cfg *Config) envForName(name string, e *vpython.Environment) *Env {
         // Env-specific root directory: <BaseDir>/<name>
         venvRoot := filepath.Join(cfg.BaseDir, name)
         binDir := venvBinDir(venvRoot)
         return &Env{
                 Config:               cfg,
                 Root:                 venvRoot,
                 Name:                 name,
                 Python:               filepath.Join(binDir, "python"),
                 Environment:          e,
@@ skipping 20 matching lines @@
                         return errors.Annotate(err).Reason("could not find Python for: %(vers)s").
                                 D("vers", specVers).
                                 Err()
                 }
                 cfg.Python = cfg.si.Python
         } else {
                 cfg.si = &python.Interpreter{
                         Python: cfg.Python,
                 }
         }
+        if err := cfg.si.Normalize(); err != nil {
+                return err
+        }
 
         // Confirm that the version of the interpreter matches that which is
         // expected.
         interpreterVers, err := cfg.si.GetVersion(c)
         if err != nil {
                 return errors.Annotate(err).Reason("failed to determine Python version for: %(python)s").
                         D("python", cfg.Python).
                         Err()
         }
         if !specVers.IsSatisfiedBy(interpreterVers) {
                 return errors.Reason("supplied Python version (%(supplied)s) doesn't match specification (%(spec)s)").
                         D("supplied", interpreterVers).
                         D("spec", specVers).
                         Err()
         }
         s.PythonVersion = interpreterVers.String()
 
         // Resolve to absolute path.
         if err := filesystem.AbsPath(&cfg.Python); err != nil {
                 return errors.Annotate(err).Reason("could not get absolute path for: %(python)s").
                         D("python", cfg.Python).
                         Err()
         }
-        logging.Debugf(c, "Resolved system Python interpreter (%s): %s", s.PythonVersion, cfg.Python)
         return nil
 }
 
 func (cfg *Config) systemInterpreter() *python.Interpreter { return cfg.si }