[vpython] Incorporate interpreter path/hash.

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"
@@ skipping 498 matching lines @@
         }
 
         // Identify the virtualenv directory: will have "virtualenv-" prefix.
         matches, err := filepath.Glob(filepath.Join(pkgDir, "virtualenv-*"))
         if err != nil {
                 return errors.Annotate(err).Reason("failed to glob for 'virtualenv-' directory").Err()
         }
         if len(matches) == 0 {
                 return errors.Reason("no 'virtualenv-' directory provided by package").Err()
         }
+        venvDir := matches[0]
 
         logging.Debugf(c, "Creating VirtualEnv at: %s", e.Root)
         cmd := e.Config.systemInterpreter().IsolatedCommand(c,
                 "virtualenv.py",
                 "--no-download",
                 e.Root)
-        cmd.Dir = matches[0]
+        cmd.Dir = venvDir
         attachOutputForLogging(c, logging.Debug, cmd)
         if err := cmd.Run(); err != nil {
                 return errors.Annotate(err).Reason("failed to create VirtualEnv").Err()
+        }
+
+        logging.Debugf(c, "Making VirtualEnv relocatable at: %s", e.Root)
+        cmd = e.Interpreter().IsolatedCommand(c,
+                "virtualenv.py",
+                "--relocatable",
+                e.Root)
+        cmd.Dir = venvDir
+        attachOutputForLogging(c, logging.Debug, cmd)
+        if err := cmd.Run(); err != nil {
+                return errors.Annotate(err).Reason("failed to create VirtualEnv").Err()
         }
 
         return nil
 }
 
 // getPEP425Tags calls Python's pip.pep425tags package to retrieve the tags.
 //
 // This must be run while "pip" is installed in the VirtualEnv.
 func (e *Env) getPEP425Tags(c context.Context) ([]*vpython.Pep425Tag, error) {
         // This script will return a list of 3-entry lists:
@@ skipping 201 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()
 }