cipd: shared tag cache

client/cmd/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.
 //
 // Subcommand starting with 'pkg-' are low level commands operating on package
 // files on disk.
 package main
 
@@ skipping 203 matching lines @@
 type commandLineError struct {
         error
 }
 
 // makeCLIError returns new commandLineError.
 func makeCLIError(msg string, args ...interface{}) error {
         return commandLineError{fmt.Errorf(msg, args...)}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ServiceOptions mixin.
+// ClientOptions mixin.
 
-// ServiceOptions defines command line arguments related to communication
-// with the remote service. Subcommands that interact with the network embed it.
-type ServiceOptions struct {
+// ClientOptions defines command line arguments related to CIPD client creation.
+// Subcommands that need a CIPD client embed it.
+type ClientOptions struct {
         authFlags  authcli.Flags
         serviceURL string
+        cacheDir   string
 }
 
-func (opts *ServiceOptions) registerFlags(f *flag.FlagSet) {
+func (opts *ClientOptions) registerFlags(f *flag.FlagSet) {
         f.StringVar(&opts.serviceURL, "service-url", "", "URL of a backend to use instead of the default one.")
+        f.StringVar(&opts.cacheDir, "cache-dir", "", "Directory for shared cache")
         opts.authFlags.Register(f, auth.Options{})
 }
 
-func (opts *ServiceOptions) makeCipdClient(root string) (cipd.Client, error) {
+func (opts *ClientOptions) makeCipdClient(root string) (cipd.Client, error) {
         authOpts, err := opts.authFlags.Options()
         if err != nil {
                 return nil, err
         }
         authOpts.Logger = log
         return cipd.NewClient(cipd.ClientOptions{
                 ServiceURL: opts.serviceURL,
                 Root:       root,
                 Logger:     log,
+                CacheDir:   opts.cacheDir,
                 AuthenticatedClientFactory: func() (*http.Client, error) {
                         return auth.NewAuthenticator(auth.OptionalLogin, authOpts).Client()
                 },
         }), nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // InputOptions mixin.
 
 // PackageVars holds array of '-pkg-var' command line options.
@@ skipping 332 matching lines @@
 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.registerBaseFlags()
                 c.InputOptions.registerFlags(&c.Flags)
                 c.RefsOptions.registerFlags(&c.Flags)
                 c.TagsOptions.registerFlags(&c.Flags)
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.UploadOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type createRun struct {
         Subcommand
         InputOptions
         RefsOptions
         TagsOptions
-        ServiceOptions
+        ClientOptions
         UploadOptions
 }
 
 func (c *createRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 0) {
                 return 1
         }
-        return c.done(buildAndUploadInstance(c.InputOptions, c.RefsOptions, c.TagsOptions, c.ServiceOptions, c.UploadOptions))
+        return c.done(buildAndUploadInstance(c.InputOptions, c.RefsOptions, c.TagsOptions, c.ClientOptions, c.UploadOptions))
 }
 
 func buildAndUploadInstance(inputOpts InputOptions, refsOpts RefsOptions,
-        tagsOpts TagsOptions, serviceOpts ServiceOptions, uploadOpts UploadOptions) (common.Pin, error) {
+        tagsOpts TagsOptions, clientOpts ClientOptions, uploadOpts UploadOptions) (common.Pin, error) {
         f, err := ioutil.TempFile("", "cipd_pkg")
         if err != nil {
                 return common.Pin{}, err
         }
         defer func() {
                 f.Close()
                 os.Remove(f.Name())
         }()
         err = buildInstanceFile(f.Name(), inputOpts)
         if err != nil {
                 return common.Pin{}, err
         }
-        return registerInstanceFile(f.Name(), refsOpts, tagsOpts, serviceOpts, uploadOpts)
+        return registerInstanceFile(f.Name(), refsOpts, tagsOpts, clientOpts, uploadOpts)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // '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.\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.ClientOptions.registerFlags(&c.Flags)
                 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
+        ClientOptions
 
         rootDir  string
         listFile string
 }
 
 func (c *ensureRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 0) {
                 return 1
         }
-        currentPins, _, err := ensurePackages(c.rootDir, c.listFile, false, c.ServiceOptions)
+        currentPins, _, err := ensurePackages(c.rootDir, c.listFile, false, c.ClientOptions)
         return c.done(currentPins, err)
 }
 
-func ensurePackages(root string, desiredStateFile string, dryRun bool, serviceOpts ServiceOptions) ([]common.Pin, cipd.Actions, error) {
+func ensurePackages(root string, desiredStateFile string, dryRun bool, clientOpts ClientOptions) ([]common.Pin, cipd.Actions, error) {
         f, err := os.Open(desiredStateFile)
         if err != nil {
                 return nil, cipd.Actions{}, err
         }
         defer f.Close()
-        client, err := serviceOpts.makeCipdClient(root)
+        client, err := clientOpts.makeCipdClient(root)
         if err != nil {
                 return nil, cipd.Actions{}, err
         }
         defer client.Close()
         desiredState, err := client.ProcessEnsureFile(f)
         if err != nil {
                 return nil, cipd.Actions{}, err
         }
         actions, err := client.EnsurePackages(desiredState, dryRun)
         if err != nil {
@@ skipping 11 matching lines @@
         LongDesc: "Returns 0 exit code iff 'ensure' will do some actions.\n\n" +
                 "Exists to be used from Puppet's Exec 'onlyif' option to trigger " +
                 "'ensure' only if something is out of date. If puppet-check-updates " +
                 "fails with a transient error, it returns non-zero exit code (as usual), " +
                 "so that Puppet doesn't trigger notification chain (that can result in " +
                 "service restarts). On fatal errors it returns 0 to let Puppet run " +
                 "'ensure' for real and catch an error.",
         CommandRun: func() subcommands.CommandRun {
                 c := &checkUpdatesRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 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 checkUpdatesRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         rootDir  string
         listFile string
 }
 
 func (c *checkUpdatesRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 0) {
                 return 1
         }
-        _, actions, err := ensurePackages(c.rootDir, c.listFile, true, c.ServiceOptions)
+        _, actions, err := ensurePackages(c.rootDir, c.listFile, true, c.ClientOptions)
         if err != nil {
                 ret := c.done(actions, err)
                 if errors.IsTransient(err) {
                         return ret // fail as usual
                 }
                 return 0 // on fatal errors ask puppet to run 'ensure' for real
         }
         c.done(actions, nil)
         if actions.Empty() {
                 return 5 // some arbitrary non-zero number, unlikely to show up on errors
         }
         return 0
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'resolve' subcommand.
 
 var cmdResolve = &subcommands.Command{
         UsageLine: "resolve <package or package prefix> [options]",
         ShortDesc: "returns concrete package instance ID given a version",
         LongDesc:  "Returns concrete package instance ID given a version.",
         CommandRun: func() subcommands.CommandRun {
                 c := &resolveRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.StringVar(&c.version, "version", "<version>", "Package version to resolve.")
                 return c
         },
 }
 
 type resolveRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         version string
 }
 
 func (c *resolveRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.doneWithPins(resolveVersion(args[0], c.version, c.ServiceOptions))
+        return c.doneWithPins(resolveVersion(args[0], c.version, c.ClientOptions))
 }
 
-func resolveVersion(packagePrefix, version string, serviceOpts ServiceOptions) ([]pinInfo, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func resolveVersion(packagePrefix, version string, clientOpts ClientOptions) ([]pinInfo, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
         return performBatchOperation(batchOperation{
                 client:        client,
                 packagePrefix: packagePrefix,
                 callback: func(pkg string) (common.Pin, error) {
                         return client.ResolveVersion(pkg, version)
                 },
         })
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'describe' subcommand.
 
 var cmdDescribe = &subcommands.Command{
         UsageLine: "describe <package> [options]",
         ShortDesc: "returns information about a package instance given its version",
         LongDesc: "Returns information about a package instance given its version: " +
                 "who uploaded the instance and when and a list of attached tags.",
         CommandRun: func() subcommands.CommandRun {
                 c := &describeRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.StringVar(&c.version, "version", "<version>", "Package version to describe.")
                 return c
         },
 }
 
 type describeRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         version string
 }
 
 func (c *describeRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.done(describeInstance(args[0], c.version, c.ServiceOptions))
+        return c.done(describeInstance(args[0], c.version, c.ClientOptions))
 }
 
-func describeInstance(pkg, version string, serviceOpts ServiceOptions) (*describeOutput, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func describeInstance(pkg, version string, clientOpts ClientOptions) (*describeOutput, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
 
         // Grab instance ID.
         pin, err := client.ResolveVersion(pkg, version)
         if err != nil {
                 return nil, err
         }
@@ skipping 67 matching lines @@
 // 'set-ref' subcommand.
 
 var cmdSetRef = &subcommands.Command{
         UsageLine: "set-ref <package or package prefix> [options]",
         ShortDesc: "moves a ref to point to a given version",
         LongDesc:  "Moves a ref to point to a given version.",
         CommandRun: func() subcommands.CommandRun {
                 c := &setRefRun{}
                 c.registerBaseFlags()
                 c.RefsOptions.registerFlags(&c.Flags)
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.StringVar(&c.version, "version", "<version>", "Package version to point the ref to.")
                 return c
         },
 }
 
 type setRefRun struct {
         Subcommand
         RefsOptions
-        ServiceOptions
+        ClientOptions
 
         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"))
         }
-        return c.doneWithPins(setRefOrTag(args[0], c.version, c.ServiceOptions,
+        return c.doneWithPins(setRefOrTag(args[0], c.version, c.ClientOptions,
                 func(client cipd.Client, pin common.Pin) error {
                         for _, ref := range c.refs {
                                 if err := client.SetRefWhenReady(ref, pin); err != nil {
                                         return err
                                 }
                         }
                         return nil
                 }))
 }
 
-func setRefOrTag(packagePrefix, version string, serviceOpts ServiceOptions,
+func setRefOrTag(packagePrefix, version string, clientOpts ClientOptions,
         updatePin func(client cipd.Client, pin common.Pin) error) ([]pinInfo, error) {
-        client, err := serviceOpts.makeCipdClient("")
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
 
         // 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,
@@ skipping 35 matching lines @@
 // 'set-tag' subcommand.
 
 var cmdSetTag = &subcommands.Command{
         UsageLine: "set-tag <package or package prefix> -tag=key:value [options]",
         ShortDesc: "tags package of a specific version",
         LongDesc:  "Tags package of a specific version",
         CommandRun: func() subcommands.CommandRun {
                 c := &setTagRun{}
                 c.registerBaseFlags()
                 c.TagsOptions.registerFlags(&c.Flags)
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.StringVar(&c.version, "version", "<version>",
                         "Package version to resolve. Could also be itself a tag or ref")
                 return c
         },
 }
 
 type setTagRun struct {
         Subcommand
         TagsOptions
-        ServiceOptions
+        ClientOptions
 
         version string
 }
 
 func (c *setTagRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
         if len(c.tags) == 0 {
                 return c.done(nil, makeCLIError("at least one -tag must be provided"))
         }
-        return c.done(setRefOrTag(args[0], c.version, c.ServiceOptions,
+        return c.done(setRefOrTag(args[0], c.version, c.ClientOptions,
                 func(client cipd.Client, pin common.Pin) error {
                         return client.AttachTagsWhenReady(pin, c.tags)
                 }))
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'ls' subcommand.
 
 var cmdListPackages = &subcommands.Command{
         UsageLine: "ls [-r] [<prefix string>]",
         ShortDesc: "lists matching packages on the server",
         LongDesc: "Queries the backend for a list of 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.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.BoolVar(&c.recursive, "r", false, "Whether to list packages in subdirectories.")
                 return c
         },
 }
 
 type listPackagesRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         recursive bool
 }
 
 func (c *listPackagesRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 1) {
                 return 1
         }
         path := ""
         if len(args) == 1 {
                 path = args[0]
         }
-        return c.done(listPackages(path, c.recursive, c.ServiceOptions))
+        return c.done(listPackages(path, c.recursive, c.ClientOptions))
 }
 
-func listPackages(path string, recursive bool, serviceOpts ServiceOptions) ([]string, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func listPackages(path string, recursive bool, clientOpts ClientOptions) ([]string, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
         packages, err := client.ListPackages(path, recursive)
         if err != nil {
                 return nil, err
         }
         if len(packages) == 0 {
                 fmt.Println("No matching packages.")
         } else {
                 for _, p := range packages {
                         fmt.Println(p)
                 }
         }
         return packages, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'search' subcommand.
 
 var cmdSearch = &subcommands.Command{
         UsageLine: "search [package] -tag key:value [options]",
         ShortDesc: "searches for package instances by tag",
         LongDesc:  "Searches for package instances by tag, optionally constrained by package name.",
         CommandRun: func() subcommands.CommandRun {
                 c := &searchRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.TagsOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type searchRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
         TagsOptions
 }
 
 func (c *searchRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 1) {
                 return 1
         }
         if len(c.tags) != 1 {
                 return c.done(nil, makeCLIError("exactly one -tag must be provided"))
         }
         packageName := ""
         if len(args) == 1 {
                 packageName = args[0]
         }
-        return c.done(searchInstances(packageName, c.tags[0], c.ServiceOptions))
+        return c.done(searchInstances(packageName, c.tags[0], c.ClientOptions))
 }
 
-func searchInstances(packageName, tag string, serviceOpts ServiceOptions) ([]common.Pin, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func searchInstances(packageName, tag string, clientOpts ClientOptions) ([]common.Pin, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
         pins, err := client.SearchInstances(tag, packageName)
         if err != nil {
                 return nil, err
         }
         if len(pins) == 0 {
                 fmt.Println("No matching packages.")
         } else {
                 fmt.Println("Packages:")
                 for _, pin := range pins {
                         fmt.Printf("  %s\n", pin)
                 }
         }
         return pins, err
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'acl-list' subcommand.
 
 var cmdListACL = &subcommands.Command{
         UsageLine: "acl-list <package subpath>",
         ShortDesc: "lists package path Access Control List",
         LongDesc:  "Lists package path Access Control List.",
         CommandRun: func() subcommands.CommandRun {
                 c := &listACLRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type listACLRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 }
 
 func (c *listACLRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.done(listACL(args[0], c.ServiceOptions))
+        return c.done(listACL(args[0], c.ClientOptions))
 }
 
-func listACL(packagePath string, serviceOpts ServiceOptions) (map[string][]cipd.PackageACL, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func listACL(packagePath string, clientOpts ClientOptions) (map[string][]cipd.PackageACL, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return nil, err
         }
         defer client.Close()
         acls, err := client.FetchACL(packagePath)
         if err != nil {
                 return nil, err
         }
 
         // Split by role, drop empty ACLs.
@@ skipping 45 matching lines @@
         return nil
 }
 
 var cmdEditACL = &subcommands.Command{
         UsageLine: "acl-edit <package subpath> [options]",
         ShortDesc: "modifies package path Access Control List",
         LongDesc:  "Modifies package path Access Control List.",
         CommandRun: func() subcommands.CommandRun {
                 c := &editACLRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.Var(&c.owner, "owner", "Users or groups to grant OWNER role.")
                 c.Flags.Var(&c.writer, "writer", "Users or groups to grant WRITER role.")
                 c.Flags.Var(&c.reader, "reader", "Users or groups to grant READER role.")
                 c.Flags.Var(&c.revoke, "revoke", "Users or groups to remove from all roles.")
                 return c
         },
 }
 
 type editACLRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         owner  principalsList
         writer principalsList
         reader principalsList
         revoke principalsList
 }
 
 func (c *editACLRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.done(nil, editACL(args[0], c.owner, c.writer, c.reader, c.revoke, c.ServiceOptions))
+        return c.done(nil, editACL(args[0], c.owner, c.writer, c.reader, c.revoke, c.ClientOptions))
 }
 
-func editACL(packagePath string, owners, writers, readers, revoke principalsList, serviceOpts ServiceOptions) error {
+func editACL(packagePath string, owners, writers, readers, revoke principalsList, clientOpts ClientOptions) error {
         changes := []cipd.PackageACLChange{}
 
         makeChanges := func(action cipd.PackageACLChangeAction, role string, list principalsList) {
                 for _, p := range list {
                         changes = append(changes, cipd.PackageACLChange{
                                 Action:    action,
                                 Role:      role,
                                 Principal: p,
                         })
                 }
         }
 
         makeChanges(cipd.GrantRole, "OWNER", owners)
         makeChanges(cipd.GrantRole, "WRITER", writers)
         makeChanges(cipd.GrantRole, "READER", readers)
 
         makeChanges(cipd.RevokeRole, "OWNER", revoke)
         makeChanges(cipd.RevokeRole, "WRITER", revoke)
         makeChanges(cipd.RevokeRole, "READER", revoke)
 
         if len(changes) == 0 {
                 return nil
         }
 
-        client, err := serviceOpts.makeCipdClient("")
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return err
         }
         defer client.Close()
         err = client.ModifyACL(packagePath, changes)
         if err != nil {
                 return err
         }
         fmt.Println("ACL changes applied.")
         return nil
@@ skipping 98 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // 'pkg-fetch' subcommand.
 
 var cmdFetch = &subcommands.Command{
         UsageLine: "pkg-fetch <package> [options]",
         ShortDesc: "fetches a package instance file from the repository",
         LongDesc:  "Fetches a package instance file from the repository.",
         CommandRun: func() subcommands.CommandRun {
                 c := &fetchRun{}
                 c.registerBaseFlags()
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.Flags.StringVar(&c.version, "version", "<version>", "Package version to fetch.")
                 c.Flags.StringVar(&c.outputPath, "out", "<path>", "Path to a file to write fetch to.")
                 return c
         },
 }
 
 type fetchRun struct {
         Subcommand
-        ServiceOptions
+        ClientOptions
 
         version    string
         outputPath string
 }
 
 func (c *fetchRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.done(fetchInstanceFile(args[0], c.version, c.outputPath, c.ServiceOptions))
+        return c.done(fetchInstanceFile(args[0], c.version, c.outputPath, c.ClientOptions))
 }
 
-func fetchInstanceFile(packageName, version, instanceFile string, serviceOpts ServiceOptions) (common.Pin, error) {
-        client, err := serviceOpts.makeCipdClient("")
+func fetchInstanceFile(packageName, version, instanceFile string, clientOpts ClientOptions) (common.Pin, error) {
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return common.Pin{}, err
         }
         defer client.Close()
         pin, err := client.ResolveVersion(packageName, version)
         if err != nil {
                 return common.Pin{}, err
         }
 
         out, err := os.OpenFile(instanceFile, os.O_CREATE|os.O_WRONLY, 0666)
@@ skipping 85 matching lines @@
 
 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.registerBaseFlags()
                 c.RefsOptions.registerFlags(&c.Flags)
                 c.TagsOptions.registerFlags(&c.Flags)
-                c.ServiceOptions.registerFlags(&c.Flags)
+                c.ClientOptions.registerFlags(&c.Flags)
                 c.UploadOptions.registerFlags(&c.Flags)
                 return c
         },
 }
 
 type registerRun struct {
         Subcommand
         RefsOptions
         TagsOptions
-        ServiceOptions
+        ClientOptions
         UploadOptions
 }
 
 func (c *registerRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 1, 1) {
                 return 1
         }
-        return c.done(registerInstanceFile(args[0], c.RefsOptions, c.TagsOptions, c.ServiceOptions, c.UploadOptions))
+        return c.done(registerInstanceFile(args[0], c.RefsOptions, c.TagsOptions, c.ClientOptions, c.UploadOptions))
 }
 
 func registerInstanceFile(instanceFile string, refsOpts RefsOptions,
-        tagsOpts TagsOptions, serviceOpts ServiceOptions, uploadOpts UploadOptions) (common.Pin, error) {
+        tagsOpts TagsOptions, clientOpts ClientOptions, uploadOpts UploadOptions) (common.Pin, error) {
         inst, err := local.OpenInstanceFile(instanceFile, "")
         if err != nil {
                 return common.Pin{}, err
         }
         defer inst.Close()
-        client, err := serviceOpts.makeCipdClient("")
+        client, err := clientOpts.makeCipdClient("")
         if err != nil {
                 return common.Pin{}, err
         }
         defer client.Close()
         inspectInstance(inst, false)
         err = client.RegisterInstance(inst, uploadOpts.verificationTimeout)
         if err != nil {
                 return common.Pin{}, err
         }
         err = client.AttachTagsWhenReady(inst.Pin(), tagsOpts.tags)
@@ skipping 89 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:])))
 }