cipd: Add -tag option to 'create' and 'pkg-register' subcomands.

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 204 matching lines @@
                 }
                 return out, nil
         }
 
         // All command line options are missing.
         reportError("-pkg-def or -name/-in are required")
         return out, cmdErr
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// TagsOptions mixin.
+
+// Tags holds array of '-tag' command line options.
+type Tags []string
+
+func (tags *Tags) String() string {
+        // String() for empty vars used in -help output.
+        if len(*tags) == 0 {
+                return "key:value"
+        }
+        return strings.Join(*tags, " ")
+}
+
+// Set is called by 'flag' package when parsing command line options.
+func (tags *Tags) Set(value string) error {
+        err := cipd.ValidateInstanceTag(value)
+        if err != nil {
+                return err
+        }
+        *tags = append(*tags, value)
+        return nil
+}
+
+// TagsOptions defines command line arguments for commands that accept a set
+// of tags.
+type TagsOptions struct {
+        // Set of tags to attach to the package instance.
+        tags Tags
+}
+
+func (opts *TagsOptions) registerFlags(f *flag.FlagSet) {
+        opts.tags = []string{}
+        f.Var(&opts.tags, "tag", "tag to attach to the package instance")
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // JSONOutputOptions mixin.
 
 // PackageInfo is put into JSON output by subcommands. It describes a built
 // package instance.
 type PackageInfo struct {
         Package    string `json:"package"`
         InstanceID string `json:"instance_id"`
 }
 
 // JSONOutputOptions define -json-output option that is used to return
@@ skipping 47 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // 'create' subcommand.
 
 var cmdCreate = &subcommands.Command{
         UsageLine: "create [options]",
         ShortDesc: "builds and uploads a package instance file",
         LongDesc:  "Builds and uploads a package instance file.",
         CommandRun: func() subcommands.CommandRun {
                 c := &createRun{}
                 c.InputOptions.registerFlags(&c.Flags)
+                c.TagsOptions.registerFlags(&c.Flags)
                 c.ServiceOptions.registerFlags(&c.Flags)
                 c.JSONOutputOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type createRun struct {
         subcommands.CommandRunBase
         InputOptions
+        TagsOptions
         ServiceOptions
         JSONOutputOptions
 }
 
 func (c *createRun) Run(a subcommands.Application, args []string) int {
         if !checkCommandLine(args, c.GetFlags(), 0) {
                 return 1
         }
-        info, err := buildAndUploadInstance(c.InputOptions, c.ServiceOptions)
+        info, err := buildAndUploadInstance(c.InputOptions, c.TagsOptions, c.ServiceOptions)
         err = c.writeJSONOutput(&info, err)
         if err != nil {
                 reportError("Error while uploading the package: %s", err)
                 return 1
         }
         return 0
 }
 
-func buildAndUploadInstance(inputOpts InputOptions, serviceOpts ServiceOptions) (PackageInfo, error) {
+func buildAndUploadInstance(inputOpts InputOptions, tagsOpts TagsOptions, serviceOpts ServiceOptions) (PackageInfo, error) {
         f, err := ioutil.TempFile("", "cipd_pkg")
         if err != nil {
                 return PackageInfo{}, err
         }
         defer func() {
                 f.Close()
                 os.Remove(f.Name())
         }()
         err = buildInstanceFile(f.Name(), inputOpts)
         if err != nil {
                 return PackageInfo{}, err
         }
-        return registerInstanceFile(f.Name(), serviceOpts)
+        return registerInstanceFile(f.Name(), tagsOpts, serviceOpts)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'ensure' subcommand.
 
 var cmdEnsure = &subcommands.Command{
         UsageLine: "ensure [options]",
         ShortDesc: "installs, removes and updates packages",
         LongDesc:  "Installs, removes and updates packages.",
         CommandRun: func() subcommands.CommandRun {
@@ skipping 478 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'pkg-register' subcommand.
 
 var cmdRegister = &subcommands.Command{
         UsageLine: "pkg-register <package instance file>",
         ShortDesc: "uploads and registers package instance in the package repository",
         LongDesc:  "Uploads and registers package instance in the package repository.",
         CommandRun: func() subcommands.CommandRun {
                 c := &registerRun{}
+                c.TagsOptions.registerFlags(&c.Flags)
                 c.ServiceOptions.registerFlags(&c.Flags)
                 c.JSONOutputOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type registerRun struct {
         subcommands.CommandRunBase
+        TagsOptions
         ServiceOptions
         JSONOutputOptions
 }
 
 func (c *registerRun) Run(a subcommands.Application, args []string) int {
         if !checkCommandLine(args, c.GetFlags(), 1) {
                 return 1
         }
-        info, err := registerInstanceFile(args[0], c.ServiceOptions)
+        info, err := registerInstanceFile(args[0], c.TagsOptions, c.ServiceOptions)
         err = c.writeJSONOutput(&info, err)
         if err != nil {
                 reportError("Error while registering the package: %s", err)
                 return 1
         }
         return 0
 }
 
-func registerInstanceFile(instanceFile string, serviceOpts ServiceOptions) (PackageInfo, error) {
+func registerInstanceFile(instanceFile string, tagsOpts TagsOptions, serviceOpts ServiceOptions) (PackageInfo, error) {
         inst, err := cipd.OpenInstanceFile(instanceFile, "")
         if err != nil {
                 return PackageInfo{}, err
         }
         defer inst.Close()
         client, err := serviceOpts.makeClient()
         if err != nil {
                 return PackageInfo{}, err
         }
         logging.Infof("Registering package %s:%s", inst.PackageName(), inst.InstanceID())
         info := inspectInstance(inst, false)
         return info, cipd.RegisterInstance(cipd.RegisterInstanceOptions{
                 PackageInstance: inst,
+                Tags:            tagsOpts.tags,
                 UploadOptions: cipd.UploadOptions{
                         ServiceURL: serviceOpts.serviceURL,
                         Client:     client,
                 },
         })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Main.
 
@@ skipping 21 matching lines @@
                 cmdDeploy,
                 cmdFetch,
                 cmdInspect,
                 cmdRegister,
         },
 }
 
 func main() {
         os.Exit(subcommands.Run(application, nil))
 }