[vpython] Verify environment, named installs.

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 15 matching lines @@
 //
 // A VirtualEnv is specified based on its resolved vpython.Spec.
 type Config struct {
         // MaxHashLen is the maximum number of hash characters to use in VirtualEnv
         // directory names.
         MaxHashLen int
 
         // BaseDir is the parent directory of all VirtualEnv.
         BaseDir string
 
+        // OverrideName overrides the name of the specified VirtualEnv.
+        //
+        // Because the name is no longer derived from the specification, this will
+        // force revalidation and deletion of any existing content if it is not a
+        // fully defined and matching VirtualEnv
+        OverrideName string
+
         // Package is the VirtualEnv package to install. It must be non-nil and
         // valid. It will be used if the environment specification doesn't supply an
         // overriding one.
         Package vpython.Spec_Package
 
         // Python is the Python interpreter to use. If empty, one will be resolved
         // based on the Spec and the current PATH.
         Python string
 
         // Spec is the specification file to use to construct the VirtualEnv. If
@@ skipping 44 matching lines @@
 
 // WithoutWheels returns a clone of cfg that depends on no additional packages.
 //
 // If cfg is already an empty it will be returned directly.
 func (cfg *Config) WithoutWheels() *Config {
         if !cfg.HasWheels() {
                 return cfg
         }
 
         clone := *cfg
+        clone.OverrideName = ""
         clone.Spec = clone.Spec.Clone()
         clone.Spec.Wheel = nil
         return &clone
 }
 
 // HasWheels returns true if this environment declares wheel dependencies.
 func (cfg *Config) HasWheels() bool {
         return cfg.Spec != nil && len(cfg.Spec.Wheel) > 0
 }
 
@@ skipping 28 matching lines @@
                         if longestPathLen > cfg.MaxScriptPathLen {
                                 return nil, errors.Reason("expected deepest path length (%(len)d) exceeds threshold (%(threshold)d)").
                                         D("len", longestPathLen).
                                         D("threshold", cfg.MaxScriptPathLen).
                                         D("longestPath", longestPath).
                                         Err()
                         }
                 }
         }
 
-        // Ensure and normalize our specification file.
-        if cfg.Spec == nil {
-                cfg.Spec = &vpython.Spec{}
-        } else {
-                cfg.Spec = cfg.Spec.Clone()
-        }
-        if err := spec.Normalize(cfg.Spec, &cfg.Package); err != nil {
-                return nil, errors.Annotate(err).Reason("invalid specification").Err()
-        }
-
-        // Choose our VirtualEnv package.
-        if cfg.Spec.Virtualenv == nil {
-                cfg.Spec.Virtualenv = &cfg.Package
-        }
-
         // Construct a new, independent Environment for this Env.
         e = e.Clone()
-        e.Spec = cfg.Spec.Clone()
+        if cfg.Spec != nil {
+                e.Spec = cfg.Spec.Clone()
+        }
+        if err := spec.NormalizeEnvironment(e); err != nil {
+                return nil, errors.Annotate(err).Reason("invalid environment").Err()
+        }
+
+        // If the environment doesn't specify a VirtualEnv package (expected), use
+        // our default.
+        if e.Spec.Virtualenv == nil {
+                e.Spec.Virtualenv = &cfg.Package
+        }
 
         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,
-        }
+        e.Runtime.Path = cfg.si.Python
+        e.Runtime.Version = e.Spec.PythonVersion
 
         var err error
-        if rt.Hash, err = cfg.si.Hash(); err != nil {
+        if e.Runtime.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)
+        logging.Debugf(c, "Resolved system Python runtime (%s @ %s): %s",
+                e.Runtime.Version, e.Runtime.Hash, e.Runtime.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.Runtime), e), nil
+        envName := cfg.OverrideName
+        if envName == "" {
+                envName = cfg.envNameForSpec(e.Spec, e.Runtime)
+        }
+        env := cfg.envForName(envName, e)
+        return env, nil
 }
 
 // EnvName returns the VirtualEnv environment name for the environment that cfg
 // describes.
 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
@@ skipping 75 matching lines @@
         // 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()
         }
         return nil
 }
 
 func (cfg *Config) systemInterpreter() *python.Interpreter { return cfg.si }