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) {
+const cacheDirHelp = "Directory for shared cache. CAVEAT: only one cipd process may access same cache dir simulatenously."

[Vadim Sh., 2016/04/08 01:42:55]

"CAVEAT: only one cipd process may access same cache dir simulatenously"

this is wrong

"no lock files" doesn't mean "no synchronization".

Currently, cache file is replaced atomically when closed. It means the state
will never be corrupted, even in case of concurrent access. The worst case is
some cache entries won't be bumped to the top of the list, it's not a big deal
(it's a cache after all), and it's not an oversight but conscious decision to
avoid lock files. Lock files is a can of worms (esp. across all three
platforms).

+
+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", "", cacheDirHelp)

[Vadim Sh., 2016/04/08 01:42:55]

keep help string inline, like in the rest options here

         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:])))
 }