[vpython] Enable base wheels, spec merging.

vpython/application/application.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 application
 
 import (
         "flag"
         "fmt"
         "io/ioutil"
@@ skipping 52 matching lines @@
 type VerificationFunc func(context.Context, string, venv.PackageLoader, *vpythonAPI.Environment)
 
 // Config is an application's default configuration.
 type Config struct {
         // PackageLoader is the package loader to use.
         PackageLoader venv.PackageLoader
 
         // VENVPackage is the VirtualEnv package to use for bootstrap generation.
         VENVPackage vpythonAPI.Spec_Package
 
+        // BaseWheels is the set of wheels to include in the spec. These will always
+        // be merged into the runtime spec and normalized, such that any duplicate
+        // wheels will be deduplicated.
+        BaseWheels []*vpythonAPI.Spec_Package
+
         // RelativePathOverride is a series of forward-slash-delimited paths to
         // directories relative to the "vpython" executable that will be checked
         // for Python targets prior to checking PATH. This allows bundles (e.g., CIPD)
         // that include both the wrapper and a real implementation, to force the
         // wrapper to use the bundled implementation if present.
         //
         // See "github.com/luci/luci-go/common/wrapper/prober.Probe"'s
         // RelativePathOverride member for more information.
         RelativePathOverride []string
 
@@ skipping 111 matching lines @@
                 logging.WithError(err).Warningf(c, "Failed to resolve 'self'")
         }
         a.opts.EnvConfig.LookPathFunc = lp.look
 
         if a.help {
                 return a.showPythonHelp(c, fs, &lp)
         }
 
         c = a.logConfig.Set(c)
 
-        // If an spec path was manually specified, load and use it.
+        // If a spec path was manually specified, load and use it.
         if a.specPath != "" {
                 var sp vpythonAPI.Spec
                 if err := spec.Load(a.specPath, &sp); err != nil {
                         return err
                 }
                 a.opts.EnvConfig.Spec = &sp
         } else if specPath := a.opts.Environ.GetEmpty(DefaultSpecENV); specPath != "" {
                 if err := spec.Load(specPath, &a.opts.DefaultSpec); err != nil {
                         return errors.Annotate(err, "failed to load default specification file (%s) from %s",
                                 DefaultSpecENV, specPath).Err()
@@ skipping 81 matching lines @@
                 opts: vpython.Options{
                         EnvConfig: venv.Config{
                                 BaseDir:           "", // (Determined below).
                                 MaxHashLen:        6,
                                 Package:           cfg.VENVPackage,
                                 PruneThreshold:    cfg.PruneThreshold,
                                 MaxPrunesPerSweep: cfg.MaxPrunesPerSweep,
                                 MaxScriptPathLen:  cfg.MaxScriptPathLen,
                                 Loader:            cfg.PackageLoader,
                         },
+                        BaseWheels: cfg.BaseWheels,
                         WaitForEnv: true,
                         Environ:    env,
                 },
                 logConfig: logging.Config{
                         Level: logging.Error,
                 },
         }
 
         return run(c, func(c context.Context) error {
                 return a.mainImpl(c, os.Args[0], os.Args[1:])
         })
 }