cipd: shared tag cache

client/cmd/cipd/friendly.go

 // Copyright 2015 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.
 
 package main
 
 import (
         "encoding/json"
         "errors"
         "flag"
@@ skipping 71 matching lines @@
 // Config file parsing.
 
 // installationSiteConfig is stored in .cipd/config.json.
 type installationSiteConfig struct {
         // ServiceURL is https://<hostname> of a backend to use by default.
         ServiceURL string
         // DefaultVersion is what version to install if not specified.
         DefaultVersion string
         // TrackedVersions is mapping package name -> version to use in 'update'.
         TrackedVersions map[string]string
+        // CacheDir contains shared cache.
+        CacheDir string
 }
 
 // read loads JSON from given path.
 func (c *installationSiteConfig) read(path string) error {
         *c = installationSiteConfig{}
         r, err := os.Open(path)
         if err != nil {
                 return err
         }
         defer r.Close()
@@ skipping 90 matching lines @@
         fmt.Printf("Site root initialized at %s.\n", rootDir)
         return site, nil
 }
 
 // initClient initializes cipd.Client to use to talk to backend. Can be called
 // only once. Use it directly via site.client.
 func (site *installationSite) initClient(authFlags authcli.Flags) (err error) {
         if site.client != nil {
                 return errors.New("client is already initialized")
         }
-        serviceOpts := ServiceOptions{
+        clientOpts := ClientOptions{
                 authFlags:  authFlags,
                 serviceURL: site.cfg.ServiceURL,
+                cacheDir:   site.cfg.CacheDir,
         }
-        site.client, err = serviceOpts.makeCipdClient(site.siteRoot)
+        site.client, err = clientOpts.makeCipdClient(site.siteRoot)
         return
 }
 
 // closeClient closes the underlying cipd.Client if necessary.
 func (site *installationSite) closeClient() {
         if site.client != nil {
                 site.client.Close()
                 site.client = nil
         }
 }
@@ skipping 158 matching lines @@
                 "Unless -force is given, the new site root directory should be empty (or " +
                 "do not exist at all) and not be under some other existing site root. " +
                 "The command will create <root>/.cipd subdirectory with some " +
                 "configuration files. This directory is used by CIPD client to keep " +
                 "track of what is installed in the site root.",
         CommandRun: func() subcommands.CommandRun {
                 c := &initRun{}
                 c.registerBaseFlags()
                 c.Flags.BoolVar(&c.force, "force", false, "Create the site root even if the directory is not empty or already under another site root directory.")
                 c.Flags.StringVar(&c.serviceURL, "service-url", "", "URL of a backend to use instead of the default one.")
+                c.Flags.StringVar(&c.cacheDir, "cache-dir", "", "Directory for shared cache")
                 return c
         },
 }
 
 type initRun struct {
         Subcommand
 
         force      bool
         serviceURL string
+        cacheDir   string
 }
 
 func (c *initRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, 1) {
                 return 1
         }
         rootDir := "."
         if len(args) == 1 {
                 rootDir = args[0]
         }
         site, err := initInstallationSite(rootDir, c.force)
         if err != nil {
                 return c.done(nil, err)
         }
         err = site.modifyConfig(func(cfg *installationSiteConfig) error {
                 cfg.ServiceURL = c.serviceURL
+                cfg.CacheDir = c.cacheDir
                 return nil
         })
         return c.done(site.siteRoot, err)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 'install' subcommand.
 
 var cmdInstall = &subcommands.Command{
         UsageLine: "install <package> [<version>] [options]",
@@ skipping 76 matching lines @@
 func (c *installedRun) Run(a subcommands.Application, args []string) int {
         if !c.init(args, 0, -1) {
                 return 1
         }
         site, err := getInstallationSite(c.rootDir)
         if err != nil {
                 return c.done(nil, err)
         }
         return c.doneWithPins(site.installedPackages(args))
 }