cipd: shared tag cache

client/cipd/client.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 cipd implements client side of Chrome Infra Package Deployer.
 //
 // Binary package file format (in free form representation):
 //   <binary package> := <zipped data>
 //   <zipped data> := DeterministicZip(<all input files> + <manifest json>)
 //   <manifest json> := File{
@@ skipping 301 matching lines @@
 
 // ClientOptions is passed to NewClient factory function.
 type ClientOptions struct {
         // ServiceURL is root URL of the backend service.
         ServiceURL string
 
         // Root is a site root directory (a directory where packages will be
         // installed to). It also hosts .cipd/* directory that tracks internal state
         // of installed packages and keeps various cache files. 'Root' can be an empty
         // string if the client is not going to be used to deploy or remove local
-        // packages. In that case caches are also disabled.
+        // packages. If both Root and CacheDir are empty, tag cache is disabled.
         Root string
 
         // Logger is a logger to use for logs (null-logger by default).
         Logger logging.Logger
 
         // AuthenticatedClientFactory lazily creates http.Client to use for making
         // RPC requests.
         AuthenticatedClientFactory HTTPClientFactory
 
         // AnonymousClientFactory lazily creates http.Client to use for making
         // requests to storage.
         AnonymousClientFactory HTTPClientFactory
 
         // UserAgent is put into User-Agent HTTP header with each request.
         UserAgent string
+
+        // CacheDir is a directory for shared cache. If empty, tags are cached
+        // inside the site root. If both Root and CacheDir are empty, tag cache
+        // is disabled.
+        CacheDir string
 }
 
 // NewClient initializes CIPD client object.
 func NewClient(opts ClientOptions) Client {
         if opts.ServiceURL == "" {
                 opts.ServiceURL = ServiceURL
         }
         if opts.Logger == nil {
                 opts.Logger = logging.Null()
         }
@@ skipping 30 matching lines @@
 
         // storage knows how to upload and download raw binaries using signed URLs.
         // Thread safe.
         storage storage
 
         // deployer knows how to install packages to local file system. Thread safe.
         deployer local.Deployer
 
         // tagCache is used to cache (pkgname, tag) -> instanceID mapping.
         // Thread safe, but lazily initialized under lock.
-        tagCache *internal.TagCache
+        tagCache     *internal.TagCache
+        tagCacheInit sync.Once
 
         // authClient is a lazily created http.Client to use for authenticated
         // requests. Thread safe, but lazily initialized under lock.
         authClient *http.Client
 
         // anonClient is a lazily created http.Client to use for anonymous requests.
         // Thread safe, but lazily initialized under lock.
         anonClient *http.Client
 }
 
@@ skipping 18 matching lines @@
                         *c, err = fac()
                 }
                 return *c, err
         }()
         if err != nil {
                 return nil, err
         }
         return httpClient.Do(req)
 }
 
-// tagCachePath returns path to a tag cache file or "" if no root dir.
+// tagCachePath returns path to a tag cache file or "" if tag cache is disabled.
 func (client *clientImpl) tagCachePath() string {
-        if client.Root == "" {
+        var dir string
+        switch {
+        case client.CacheDir != "":
+                dir = client.CacheDir
+
+        case client.Root != "":
+                dir = filepath.Join(client.Root, local.SiteServiceDir)
+
+        default:
                 return ""
         }
-        return filepath.Join(client.Root, local.SiteServiceDir, "tagcache.db")
+
+        return filepath.Join(dir, "tagcache.db")
 }
 
 // getTagCache lazy-initializes tagCache instance and returns it.
 func (client *clientImpl) getTagCache() *internal.TagCache {
-        client.lock.Lock()
-        defer client.lock.Unlock()
-        if client.tagCache == nil {
+        client.tagCacheInit.Do(func() {
                 if path := client.tagCachePath(); path != "" {
                         var err error
                         client.tagCache, err = internal.LoadTagCacheFromFile(path)
                         if err != nil {
                                 client.Logger.Warningf("cipd: failed to load tag cache - %s", err)
                         }
                 }
                 if client.tagCache == nil {
                         client.tagCache = &internal.TagCache{}
                 }
-        }
+        })
         return client.tagCache
 }
 
 // closeTagCache dumps any changes made to tag cache to disk, if necessary.
 // Must be called under lock.
 func (client *clientImpl) closeTagCache() {
         path := client.tagCachePath()
         if client.tagCache == nil || path == "" || !client.tagCache.Dirty() {
                 client.tagCache = nil
                 return
@@ skipping 558 matching lines @@
 }
 
 // buildInstanceIDMap builds mapping {package name -> instance ID}.
 func buildInstanceIDMap(pins []common.Pin) map[string]string {
         out := map[string]string{}
         for _, p := range pins {
                 out[p.PackageName] = p.InstanceID
         }
         return out
 }