run_isolated.py: install CIPD packages

client/isolateserver.py

 #!/usr/bin/env python
 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 """Archives a set of files or directories to an Isolate Server."""
 
 __version__ = '0.4.8'
 
 import base64
@@ skipping 1200 matching lines @@
 
   def __init__(self):
     self._lock = threading_utils.LockWithAssert()
     # Profiling values.
     self._added = []
     self._initial_number_items = 0
     self._initial_size = 0
     self._evicted = []
     self._linked = []
 
+  def __contains__(self, digest):
+    raise NotImplementedError()
+
   def __enter__(self):
     """Context manager interface."""
     return self
 
   def __exit__(self, _exc_type, _exec_value, _traceback):
     """Context manager interface."""
     return False
 
   @property
   def added(self):
@@ skipping 64 matching lines @@
 
   def __init__(self, file_mode_mask=0500):
     """Args:
       file_mode_mask: bit mask to AND file mode with. Default value will make
           all mapped files to be read only.
     """
     super(MemoryCache, self).__init__()
     self._file_mode_mask = file_mode_mask
     self._contents = {}
 
+  def __contains__(self, digest):
+    with self._lock:
+      return digest in self._contents
+
   def cached_set(self):
     with self._lock:
       return set(self._contents)
 
   def cleanup(self):
     pass
 
   def touch(self, digest, size):
     with self._lock:
       return digest in self._contents
@@ skipping 73 matching lines @@
     # The items that must not be evicted during this run since they were
     # referenced.
     self._protected = set()
     # Cleanup operations done by self._load(), if any.
     self._operations = []
     with tools.Profiler('Setup'):
       with self._lock:
         # self._load() calls self._trim() which initializes self._free_disk.
         self._load()
 
+  def __contains__(self, digest):
+    with self._lock:
+      return digest in self._lru
+
   def __enter__(self):
     return self
 
   def __exit__(self, _exc_type, _exec_value, _traceback):
     with tools.Profiler('CleanupTrimming'):
       with self._lock:
         self._trim()
 
         logging.info(
             '%5d (%8dkb) added',
@@ skipping 108 matching lines @@
       # Report to the server that it failed with more details. We'll want to
       # squash them all.
       on_error.report('Failed to hardlink\n%s -> %s' % (path, dest))
 
     if file_mode is not None:
       # Ignores all other bits.
       fs.chmod(dest, file_mode & 0500)
     with self._lock:
       self._linked.append(self._lru[digest])
 
+  def item_path(self, digest):

[M-A Ruel, 2016/06/08 20:37:39]

It's not needed.

[nodir, 2016/06/08 22:35:32]

Done.

+    """Returns a path on disk of the cached item.
+
+    Raises:
+      CacheMiss if the item is not present in cache.
+    """
+    if digest not in self._lru:
+      raise CacheMiss(digest)
+    return self._path(digest)
+
   def _load(self):
     """Loads state of the cache from json file."""
     self._lock.assert_locked()
 
     if not os.path.isdir(self.cache_dir):
       fs.makedirs(self.cache_dir)
     else:
       # Make sure the cache is read-only.
       # TODO(maruel): Calculate the cost and optimize the performance
       # accordingly.
@@ skipping 751 matching lines @@
   dispatcher = subcommand.CommandDispatcher(__name__)
   return dispatcher.execute(OptionParserIsolateServer(), args)
 
 
 if __name__ == '__main__':
   subprocess42.inhibit_os_error_reporting()
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
   sys.exit(main(sys.argv[1:]))