[vpython] Verify environment, named installs.

vpython/venv/venv.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 (
         "bytes"
         "encoding/json"
         "io/ioutil"
         "os"
         "os/exec"
         "path/filepath"
         "strings"
         "time"
 
         "github.com/danjacques/gofslock/fslock"
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/vpython/api/vpython"
         "github.com/luci/luci-go/vpython/python"
+        "github.com/luci/luci-go/vpython/spec"
         "github.com/luci/luci-go/vpython/wheel"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/data/stringset"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/system/filesystem"
 )
 
 // EnvironmentVersion is an environment version string. It must advance each
@@ skipping 354 matching lines @@
                         D("path", e.EnvironmentStampPath).
                         Err()
         }
 
         var environment vpython.Environment
         if err := proto.UnmarshalText(string(content), &environment); err != nil {
                 return errors.Annotate(err).Reason("failed to unmarshal vpython.Env stamp from: %(path)s").
                         D("path", e.EnvironmentStampPath).
                         Err()
         }
+        if err := spec.NormalizeEnvironment(&environment); err != nil {
+                return errors.Annotate(err).Reason("failed to normalize stamp environment").Err()
+        }
+
+        // If we are configured with an environment, validate that it matches the
+        // the environment that we just loaded.
+        //
+        // We only consider our environment-defining fields (Spec and Runtime).
+        //
+        // Note that both environments will have been normalized at this point, so
+        // comparison should be reliable.
+        if e.Environment != nil {
+                if !proto.Equal(e.Environment.Spec, environment.Spec) {
+                        return errors.New("environment stamp specification does not match")
+                }
+                if !proto.Equal(e.Environment.Runtime, environment.Runtime) {
+                        return errors.New("environment stamp runtime does not match")
+                }
+        }
         e.Environment = &environment
         return nil
 }
 
 func (e *Env) assertComplete() error {
         // Ensure that the environment has its completion flag.
         switch _, err := os.Stat(e.completeFlagPath); {
         case filesystem.IsNotExist(err):
                 return ErrNotComplete
         case err != nil:
@@ skipping 345 matching lines @@
 // panic, since the locking state can no longer be determined.
 func mustReleaseLock(c context.Context, lock fslock.Handle, fn func() error) error {
         defer func() {
                 if err := lock.Unlock(); err != nil {
                         errors.Log(c, errors.Annotate(err).Reason("failed to release lock").Err())
                         panic(err)
                 }
         }()
         return fn()
 }