vpython: Add application entry point.

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"
+        "io/ioutil"
+        "os"
+        "path/filepath"
+        "time"
+
+        "github.com/luci/luci-go/vpython"
+        "github.com/luci/luci-go/vpython/api/env"
+        "github.com/luci/luci-go/vpython/filesystem"
+        "github.com/luci/luci-go/vpython/python"
+        "github.com/luci/luci-go/vpython/spec"
+        "github.com/luci/luci-go/vpython/venv"
+
+        "github.com/luci/luci-go/common/cli"
+        "github.com/luci/luci-go/common/errors"
+        "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/logging/gologger"
+        "github.com/luci/luci-go/common/system/environ"
+
+        "github.com/maruel/subcommands"
+        "github.com/mitchellh/go-homedir"
+        "golang.org/x/net/context"
+)
+
+// An A is an application's default configuration.

[iannucci, 2017/02/23 02:24:22]

why not Config (e.g. application.Config) or Defaults (application.Defaults).

[dnj, 2017/03/11 18:07:40]

Made "Config".

+type A struct {
+        // PackageLoader is the package loader to use.

[iannucci, 2017/02/23 02:24:22]

no documented default values?

[dnj, 2017/03/11 18:07:40]

Nope, no default values at all!

The counterpart of this the main app entry point, which uses this package to
create defaults.

+        PackageLoader venv.PackageLoader
+
+        // VENVPackage is the VirtualEnv package to use for bootstrap generation.
+        VENVPackage env.Spec_Package
+
+        // PruneThreshold, if > 0, is the maximum age of a VirtualEnv before it
+        // becomes candidate for pruning. If <= 0, no pruning will be performed.
+        //
+        // See venv.Config's PruneThreshold.
+        PruneThreshold time.Duration
+        // PruneLimit, if > 0, is the maximum number of VirtualEnv that should be
+        // pruned passively. If <= 0, no limit will be applied.
+        //
+        // See venv.Config's PruneLimit.
+        PruneLimit int

[iannucci, 2017/02/23 02:24:22]

same comments as venv.Config about defaults and naming and such.

[dnj, 2017/03/11 18:07:40]

Done.

+
+        // Opts is the set of configured options.
+        Opts vpython.Options
+}
+
+func (a *A) mainDev(c context.Context) error {
+        app := cli.Application{
+                Name:  "vpython",
+                Title: "VirtualEnv Python Bootstrap (Development Mode)",
+                Context: func(context.Context) context.Context {
+                        // Discard the entry Context and use the one passed to us.

[iannucci, 2017/02/23 02:24:22]

why? testing?

maybe docstring this func?

edit: oh, that's gnarly :(. We should really consider switching from subcommands
or making it truly nestable. Topic for another time I suppose.

[dnj, 2017/03/11 18:07:40]

OR... giving subcommands actual Context awareness instead of bolting it on, but
yes :)

+                        c := c
+
+                        // Install our A instance into the Context.
+                        c = withApplication(c, a)
+
+                        // Drop down to Info level debugging.
+                        if logging.GetLevel(c) > logging.Info {
+                                c = logging.SetLevel(c, logging.Info)
+                        }
+                        return c
+                },
+                Commands: []*subcommands.Command{
+                        subcommands.CmdHelp,
+                        subcommandInstall,
+                },
+        }
+
+        return python.Error(subcommands.Run(&app, a.Opts.Args))
+}
+
+func (a *A) mainImpl(c context.Context, args []string) error {
+        logConfig := logging.Config{
+                Level: logging.Warning,
+        }
+
+        hdir, err := homedir.Dir()
+        if err != nil {
+                return errors.Annotate(err).Reason("failed to get user home directory").Err()
+        }
+
+        a.Opts = vpython.Options{
+                EnvConfig: venv.Config{
+                        BaseDir:        filepath.Join(hdir, ".vpython"),
+                        MaxHashLen:     6,
+                        Package:        a.VENVPackage,
+                        PruneThreshold: a.PruneThreshold,
+                        PruneLimit:     a.PruneLimit,
+                        Loader:         a.PackageLoader,
+                },
+                WaitForEnv: true,
+                Environ:    environ.System(),
+        }
+        var specPath string
+        var devMode bool
+
+        fs := flag.NewFlagSet("", flag.ExitOnError)
+        fs.BoolVar(&devMode, "dev", devMode,
+                "Enter development / subcommand mode (use 'help' for more options).")
+        fs.StringVar(&a.Opts.EnvConfig.Python, "python", a.Opts.EnvConfig.Python,
+                "Path to system Python interpreter to use. Default is found on PATH.")
+        fs.StringVar(&a.Opts.WorkDir, "workdir", a.Opts.WorkDir,
+                "Working directory to run the Python interpreter in. Default is current working directory.")
+        fs.StringVar(&a.Opts.EnvConfig.BaseDir, "root", a.Opts.EnvConfig.BaseDir,
+                "Path to virtual enviornment root directory. Default is the working directory. "+
+                        "If explicitly set to empty string, a temporary directory will be used and cleaned up "+
+                        "on completion.")
+        fs.StringVar(&specPath, "spec", specPath,
+                "Path to enviornment specification file to load. Default probes for one.")
+        logConfig.AddFlags(fs)
+
+        if err := fs.Parse(args); err != nil {
+                if err == flag.ErrHelp {
+                        return nil
+                }
+                return errors.Annotate(err).Reason("failed to parse flags").Err()
+        }
+        a.Opts.Args = fs.Args()
+
+        c = logConfig.Set(c)
+
+        // If an spec path was manually specified, load and use it.
+        if specPath != "" {
+                var err error
+                if a.Opts.EnvConfig.Spec, err = spec.Load(specPath); err != nil {
+                        return errors.Annotate(err).Reason("failed to load environment specification file (-env) from: %(path)s").
+                                D("path", specPath).
+                                Err()
+                }
+        }
+
+        // If an empty BaseDir was specified, use a temporary directory and clean it
+        // up on completion.
+        if a.Opts.EnvConfig.BaseDir == "" {
+                tdir, err := ioutil.TempDir("", "vpython")
+                if err != nil {
+                        return errors.Annotate(err).Reason("failed to create temporary directory").Err()
+                }
+                defer func() {
+                        logging.Debugf(c, "Removing temporary directory: %s", tdir)
+                        if terr := filesystem.RemoveAll(tdir); terr != nil {
+                                logging.WithError(terr).Warningf(c, "Failed to clean up temporary directory; leaking: %s", tdir)
+                        }
+                }()
+                a.Opts.EnvConfig.BaseDir = tdir
+        }
+
+        // Development mode (subcommands).
+        if devMode {
+                return a.mainDev(c)
+        }
+
+        if err := vpython.Run(c, a.Opts); err != nil {
+                return errors.Annotate(err).Err()
+        }
+        return nil
+}
+
+// Main is the main application entry point.
+func (a *A) Main(c context.Context) int {
+        c = gologger.StdConfig.Use(c)
+        c = logging.SetLevel(c, logging.Warning)
+
+        return run(c, func(c context.Context) error {
+                return a.mainImpl(c, os.Args[1:])
+        })
+}