cipd: Implement 'init', 'install' and 'installed' subcommands.

go/src/infra/tools/cipd/apps/cipd/main.go

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /*
 Client side of for Chrome Infra Package Deployer.
 
 TODO: write more.
 
 Subcommand starting with 'pkg-' are low level commands operating on package
@@ skipping 48 matching lines @@
 
 // init initializes subcommand state (including global logger). It ensures all
 // required positional and flag-like parameters are set. Returns true if they
 // are, or false (and prints to stderr) if not.
 func (c *Subcommand) init(args []string, minPosCount, maxPosCount int) bool {
         // Check number of expected positional arguments.
         if maxPosCount == 0 && len(args) != 0 {
                 c.printError(makeCLIError("unexpected arguments %v", args))
                 return false
         }
-        if len(args) < minPosCount || len(args) > maxPosCount {
+        if len(args) < minPosCount || (maxPosCount >= 0 && len(args) > maxPosCount) {
                 var err error
                 if minPosCount == maxPosCount {
                         err = makeCLIError("expecting %d positional argument, got %d instead", minPosCount, len(args))
                 } else {
-                        err = makeCLIError(
-                                "expecting from %d to %d positional arguments, got %d instead",
-                                minPosCount, maxPosCount, len(args))
+                        if maxPosCount >= 0 {
+                                err = makeCLIError(
+                                        "expecting from %d to %d positional arguments, got %d instead",
+                                        minPosCount, maxPosCount, len(args))
+                        } else {
+                                err = makeCLIError(
+                                        "expecting at least %d positional arguments, got %d instead",
+                                        minPosCount, len(args))
+                        }
                 }
                 c.printError(err)
                 return false
         }
 
         // Check required unset flags.
         unset := []*flag.Flag{}
         c.Flags.VisitAll(func(f *flag.Flag) {
                 if strings.HasPrefix(f.DefValue, "<") && f.Value.String() == f.DefValue {
                         unset = append(unset, f)
@@ skipping 20 matching lines @@
         log = loggerConfig.Get()
         return true
 }
 
 // printError prints error to stderr (recognizing commandLineError).
 func (c *Subcommand) printError(err error) {
         if _, ok := err.(commandLineError); ok {
                 fmt.Fprintf(os.Stderr, "Bad command line: %s.\n\n", err)
                 c.Flags.Usage()
         } else {
-                fmt.Fprintln(os.Stderr, err)
+                fmt.Fprintf(os.Stderr, "Error: %s.\n", err)
         }
 }
 
 // writeJSONOutput writes result to JSON output file. It returns original error
 // if it is non-nil.
 func (c *Subcommand) writeJSONOutput(result interface{}, err error) error {
         // -json-output flag wasn't specified.
         if c.jsonOutput == "" {
                 return err
         }
@@ skipping 35 matching lines @@
 // process exit code.
 func (c *Subcommand) done(result interface{}, err error) int {
         err = c.writeJSONOutput(result, err)
         if err != nil {
                 c.printError(err)
                 return 1
         }
         return 0
 }
 
+// doneWithPins is a handy shortcut that prints array of pinOrError and deduces

[nodir, 2015/09/21 22:26:59]

it is a slice, but whatever

[Vadim Sh., 2015/09/29 01:43:34]

renamed to "list"

+// process exit code based on presence of errors there.
+func (c *Subcommand) doneWithPins(pins []pinOrError, err error) int {
+        if len(pins) == 0 {
+                fmt.Println("No packages.")
+        } else {
+                printPinsAndError(pins)
+        }
+        ret := c.done(pins, err)
+        if hasErrors(pins) && ret == 0 {
+                return 1
+        }
+        return ret
+}
+
 // commandLineError is used to tag errors related to CLI.
 type commandLineError struct {
         error
 }
 
 // makeCLIError returns new commandLineError.
 func makeCLIError(msg string, args ...interface{}) error {
         return commandLineError{fmt.Errorf(msg, args...)}
 }
 
@@ skipping 233 matching lines @@
 // batchOperation defines what to do with a packages matching a prefix.
 type batchOperation struct {
         client        cipd.Client
         packagePrefix string   // a package name or a prefix
         packages      []string // packages to operate on, overrides packagePrefix
         callback      func(pkg string) (common.Pin, error)
 }
 
 // pinOrError is passed through channels and also dumped to JSON results file.
 type pinOrError struct {
-        Pkg string      `json:"package"`
-        Pin *common.Pin `json:"pin,omitempty"`
-        Err string      `json:"error,omitempty"`
+        Pkg      string      `json:"package"`
+        Pin      *common.Pin `json:"pin,omitempty"`
+        Err      string      `json:"error,omitempty"`
+        Tracking string      `json:"tracking,omitempty"`
 }
 
 // expandPkgDir takes a package name or '<prefix>/' and returns a list
 // of matching packages (asking backend if necessary). Doesn't recurse, returns
 // only direct children.
 func expandPkgDir(c cipd.Client, packagePrefix string) ([]string, error) {
         if !strings.HasSuffix(packagePrefix, "/") {
                 return []string{packagePrefix}, nil
         }
         pkgs, err := c.ListPackages(packagePrefix, false)
@@ skipping 20 matching lines @@
         if len(pkgs) == 0 {
                 var err error
                 pkgs, err = expandPkgDir(op.client, op.packagePrefix)
                 if err != nil {
                         return nil, err
                 }
         }
         return callConcurrently(pkgs, func(pkg string) pinOrError {
                 pin, err := op.callback(pkg)
                 if err != nil {
-                        return pinOrError{pkg, nil, err.Error()}
+                        return pinOrError{pkg, nil, err.Error(), ""}
                 }
-                return pinOrError{pkg, &pin, ""}
+                return pinOrError{pkg, &pin, "", ""}
         }), nil
 }
 
 func callConcurrently(pkgs []string, callback func(pkg string) pinOrError) []pinOrError {
         // Push index through channel to make results ordered as 'pkgs'.
         ch := make(chan struct {
                 int
                 pinOrError
         })
         for idx, pkg := range pkgs {
                 go func(idx int, pkg string) {
                         ch <- struct {
                                 int
                                 pinOrError
                         }{idx, callback(pkg)}
                 }(idx, pkg)
         }
         pins := make([]pinOrError, len(pkgs))
         for i := 0; i < len(pkgs); i++ {
                 res := <-ch
                 pins[res.int] = res.pinOrError
         }
         return pins
 }
 
 func printPinsAndError(pins []pinOrError) {
         hasPins := false
         hasErrors := false
         for _, p := range pins {
-                if p.Err == "" {
+                if p.Err != "" {
+                        hasErrors = true
+                } else if p.Pin != nil {
                         hasPins = true
-                } else {
-                        hasErrors = true
                 }
         }
         if hasPins {
-                fmt.Println("Instances:")
+                fmt.Println("Packages:")
                 for _, p := range pins {
-                        if p.Err == "" {
+                        if p.Err != "" || p.Pin == nil {
+                                continue
+                        }
+                        if p.Tracking == "" {
                                 fmt.Printf("  %s\n", p.Pin)
+                        } else {
+                                fmt.Printf("  %s (tracking %q)\n", p.Pin, p.Tracking)
                         }
                 }
         }
         if hasErrors {
                 fmt.Fprintln(os.Stderr, "Errors:")
                 for _, p := range pins {
                         if p.Err != "" {
-                                fmt.Fprintf(os.Stderr, "  %s\n", p.Err)
+                                fmt.Fprintf(os.Stderr, "  %s: %s.\n", p.Pkg, p.Err)
                         }
                 }
         }
 }
 
 func hasErrors(pins []pinOrError) bool {
         for _, p := range pins {
                 if p.Err != "" {
                         return true
                 }
@@ skipping 49 matching lines @@
         }
         return registerInstanceFile(f.Name(), refsOpts, tagsOpts, serviceOpts)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'ensure' subcommand.
 
 var cmdEnsure = &subcommands.Command{
         UsageLine: "ensure [options]",
         ShortDesc: "installs, removes and updates packages in one go",
-        LongDesc:  "Installs, removes and updates packages in one go.",
+        LongDesc: "Installs, removes and updates packages in one go.\n\n" +
+                "Supposed to be used from scripts and automation. Alternative to 'init', " +
+                "'install' and 'remove'. As such, it doesn't try to discover site root " +
+                "directory on its own.",
         CommandRun: func() subcommands.CommandRun {
                 c := &ensureRun{}
                 c.registerBaseFlags()
                 c.ServiceOptions.registerFlags(&c.Flags)
-                c.Flags.StringVar(&c.rootDir, "root", "<path>", "Path to a installation site root directory.")
+                c.Flags.StringVar(&c.rootDir, "root", "<path>", "Path to an installation site root directory.")
                 c.Flags.StringVar(&c.listFile, "list", "<path>", "A file with a list of '<package name> <version>' pairs.")
                 return c
         },
 }
 
 type ensureRun struct {
         Subcommand
         ServiceOptions
 
         rootDir  string
@@ skipping 47 matching lines @@
         Subcommand
         ServiceOptions
 
         version string
 }
 
 func (c *resolveRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        pins, err := resolveVersion(args[0], c.version, c.ServiceOptions)
-        printPinsAndError(pins)
-        ret := c.done(pins, err)
-        if hasErrors(pins) && ret == 0 {
-                return 1
-        }
-        return ret
+        return c.doneWithPins(resolveVersion(args[0], c.version, c.ServiceOptions))
 }
 
 func resolveVersion(packagePrefix, version string, serviceOpts ServiceOptions) ([]pinOrError, error) {
         client, err := serviceOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         return performBatchOperation(batchOperation{
                 client:        client,
                 packagePrefix: packagePrefix,
@@ skipping 28 matching lines @@
         version string
 }
 
 func (c *setRefRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
         if len(c.refs) == 0 {
                 return c.done(nil, makeCLIError("at least one -ref must be provided"))
         }
-        pins, err := setRef(args[0], c.version, c.RefsOptions, c.ServiceOptions)
-        printPinsAndError(pins)
-        ret := c.done(pins, err)
-        if hasErrors(pins) && ret == 0 {
-                return 1
-        }
-        return ret
+        return c.doneWithPins(setRef(args[0], c.version, c.RefsOptions, c.ServiceOptions))
 }
 
 func setRef(packagePrefix, version string, refsOpts RefsOptions, serviceOpts ServiceOptions) ([]pinOrError, error) {
         client, err := serviceOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
 
         // Do not touch anything if some packages do not have requested version. So
         // resolve versions first and only then move refs.
         pins, err := performBatchOperation(batchOperation{
                 client:        client,
                 packagePrefix: packagePrefix,
                 callback: func(pkg string) (common.Pin, error) {
                         return client.ResolveVersion(pkg, version)
                 },
         })
         if err != nil {
                 return nil, err
         }
         if hasErrors(pins) {
                 printPinsAndError(pins)
-                return nil, fmt.Errorf("can't find %q version in all packages, aborting.", version)
+                return nil, fmt.Errorf("can't find %q version in all packages, aborting", version)
         }
 
         // Prepare for the next batch call.
         packages := []string{}
         pinsToUse := map[string]common.Pin{}
         for _, p := range pins {
                 packages = append(packages, p.Pkg)
                 pinsToUse[p.Pkg] = *p.Pin
         }
 
@@ skipping 11 matching lines @@
                         return pin, nil
                 },
         })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'ls' subcommand.
 
 var cmdListPackages = &subcommands.Command{
         UsageLine: "ls [-r] [<prefix string>]",
-        ShortDesc: "lists matching packages",
+        ShortDesc: "queries backend for a list of matching packages",

[nodir, 2015/09/21 22:26:59]

looks like mentioning impl details. I'd move them to longdesc and leave
shortdesc intact

[Vadim Sh., 2015/09/29 01:43:34]

Done. I wanted to clarify that it lists packages on the backend, no ones
installed locally.

[tandrii(chromium), 2015/09/29 14:21:25]

weak suggestion: maybe then say in short version "on the server" (since this is
cipd-client)

         LongDesc:  "List packages in the given path to which the user has access, optionally recursively.",
         CommandRun: func() subcommands.CommandRun {
                 c := &listPackagesRun{}
                 c.registerBaseFlags()
                 c.ServiceOptions.registerFlags(&c.Flags)
                 c.Flags.BoolVar(&c.recursive, "r", false, "Whether to list packages in subdirectories.")
                 return c
         },
 }
 
@@ skipping 251 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // 'pkg-deploy' subcommand.
 
 var cmdDeploy = &subcommands.Command{
         UsageLine: "pkg-deploy <package instance file> [options]",
         ShortDesc: "deploys a package instance file",
         LongDesc:  "Deploys a *.cipd package instance into a site root.",
         CommandRun: func() subcommands.CommandRun {
                 c := &deployRun{}
                 c.registerBaseFlags()
-                c.Flags.StringVar(&c.rootDir, "root", "<path>", "Path to a installation site root directory.")
+                c.Flags.StringVar(&c.rootDir, "root", "<path>", "Path to an installation site root directory.")
                 return c
         },
 }
 
 type deployRun struct {
         Subcommand
 
         rootDir string
 }
 
@@ skipping 202 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Main.
 
 var application = &subcommands.DefaultApplication{
         Name:  "cipd",
         Title: "Chrome Infra Package Deployer",
         Commands: []*subcommands.Command{
                 subcommands.CmdHelp,
                 cipd_lib.SubcommandVersion,
 
+                // User friendly subcommands that operates within a site root. Implemented
+                // in friendly.go.
+                cmdInit,
+                cmdInstall,
+                cmdInstalled,
+
                 // Authentication related commands.
                 authcli.SubcommandInfo(auth.Options{Logger: log}, "auth-info"),
                 authcli.SubcommandLogin(auth.Options{Logger: log}, "auth-login"),
                 authcli.SubcommandLogout(auth.Options{Logger: log}, "auth-logout"),
 
                 // High level commands.
                 cmdListPackages,
                 cmdCreate,
                 cmdEnsure,
                 cmdResolve,
@@ skipping 45 matching lines @@
                 newArgs = append(newArgs, cmd)
         }
         newArgs = append(newArgs, flags...)
         newArgs = append(newArgs, positional...)
         return newArgs
 }
 
 func main() {
         os.Exit(subcommands.Run(application, fixFlagsPosition(os.Args[1:])))
 }