run_isolated: rename cache to isolate_cache

client/run_isolated.py

 #!/usr/bin/env python
 # Copyright 2012 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.
 
 """Runs a command with optional isolated input/output.
 
 Despite name "run_isolated", can run a generic non-isolated command specified as
 args.
 
@@ skipping 331 matching lines @@
     logging.exception('Had difficulties removing out_dir %s: %s', out_dir, e)
   stats = {
     'duration': time.time() - start,
     'items_cold': base64.b64encode(large.pack(cold)),
     'items_hot': base64.b64encode(large.pack(hot)),
   }
   return outputs_ref, success, stats
 
 
 def map_and_run(
-    command, isolated_hash, storage, cache, leak_temp_dir, root_dir,
+    command, isolated_hash, storage, isolate_cache, leak_temp_dir, root_dir,
     hard_timeout, grace_period, bot_file, extra_args, install_packages_fn,
     use_symlinks):
   """Runs a command with optional isolated input/output.
 
   See run_tha_test for argument documentation.
 
   Returns metadata about the result.
   """
+  assert root_dir or root_dir is None
   assert bool(command) ^ bool(isolated_hash)
   result = {
     'duration': None,
     'exit_code': None,
     'had_hard_timeout': False,
     'internal_failure': None,
     'stats': {
     # 'isolated': {
     #    'cipd': {
     #      'duration': 0.,
@@ skipping 19 matching lines @@
     #     ...
     #   ],
     #  'client_package': {'package_name': ..., 'version': ...},
     # },
     'outputs_ref': None,
     'version': 5,
   }
 
   if root_dir:
     file_path.ensure_tree(root_dir, 0700)
-  else:
-    root_dir = os.path.dirname(cache.cache_dir) if cache.cache_dir else None
+  elif isolate_cache.cache_dir:
+    root_dir = os.path.dirname(isolate_cache.cache_dir)
   # See comment for these constants.
   run_dir = make_temp_dir(ISOLATED_RUN_DIR, root_dir)
   # storage should be normally set but don't crash if it is not. This can happen
   # as Swarming task can run without an isolate server.
   out_dir = make_temp_dir(ISOLATED_OUT_DIR, root_dir) if storage else None
   tmp_dir = make_temp_dir(ISOLATED_TMP_DIR, root_dir)
   cwd = run_dir
 
   try:
     cipd_info = install_packages_fn(run_dir)
     if cipd_info:
       result['stats']['cipd'] = cipd_info['stats']
       result['cipd_pins'] = cipd_info['cipd_pins']
 
     if isolated_hash:
       isolated_stats = result['stats'].setdefault('isolated', {})
       bundle, isolated_stats['download'] = fetch_and_map(
           isolated_hash=isolated_hash,
           storage=storage,
-          cache=cache,
+          cache=isolate_cache,
           outdir=run_dir,
           use_symlinks=use_symlinks)
       if not bundle.command:
         # Handle this as a task failure, not an internal failure.
         sys.stderr.write(
             '<The .isolated doesn\'t declare any command to run!>\n'
             '<Check your .isolate for missing \'command\' variable>\n')
         if os.environ.get('SWARMING_TASK_ID'):
           # Give an additional hint when running as a swarming task.
           sys.stderr.write('<This occurs at the \'isolate\' step>\n')
@@ skipping 322 matching lines @@
   auth.add_auth_options(parser)
 
   parser.set_defaults(cache='cache', cipd_cache='cipd_cache')
   return parser
 
 
 def main(args):
   parser = create_option_parser()
   options, args = parser.parse_args(args)
 
-  cache = isolateserver.process_cache_options(options)
+  isolated_cache = isolateserver.process_cache_options(options)
   if options.clean:
     if options.isolated:
       parser.error('Can\'t use --isolated with --clean.')
     if options.isolate_server:
       parser.error('Can\'t use --isolate-server with --clean.')
     if options.json:
       parser.error('Can\'t use --json with --clean.')
-    cache.cleanup()
+    isolated_cache.cleanup()
     return 0
   if not options.no_clean:
-    cache.cleanup()
+    isolated_cache.cleanup()
 
   if not options.isolated and not args:
     parser.error('--isolated or command to run is required.')
 
   auth.process_auth_options(parser, options)
 
   isolateserver.process_isolate_server_options(
     parser, options, True, False)
   if not options.isolate_server:
     if options.isolated:
@@ skipping 13 matching lines @@
       run_dir, cipd.parse_package_args(options.cipd_packages),
       options.cipd_server, options.cipd_client_package,
       options.cipd_client_version, cache_dir=options.cipd_cache)
 
   try:
     command = [] if options.isolated else args
     if options.isolate_server:
       storage = isolateserver.get_storage(
           options.isolate_server, options.namespace)
       with storage:
-        # Hashing schemes used by |storage| and |cache| MUST match.
-        assert storage.hash_algo == cache.hash_algo
+        # Hashing schemes used by |storage| and |isolated_cache| MUST match.
+        assert storage.hash_algo == isolated_cache.hash_algo
         return run_tha_test(
-            command, options.isolated, storage, cache, options.leak_temp_dir,
-            options.json, options.root_dir, options.hard_timeout,
-            options.grace_period, options.bot_file, args, install_packages_fn,
-            options.use_symlinks)
+            command, options.isolated, storage, isolated_cache,
+            options.leak_temp_dir, options.json, options.root_dir,
+            options.hard_timeout, options.grace_period, options.bot_file, args,
+            install_packages_fn, options.use_symlinks)
     return run_tha_test(
-        command, options.isolated, None, cache, options.leak_temp_dir,
+        command, options.isolated, None, isolated_cache, options.leak_temp_dir,
         options.json, options.root_dir, options.hard_timeout,
         options.grace_period, options.bot_file, args, install_packages_fn,
         options.use_symlinks)
   except cipd.Error as ex:
     print >> sys.stderr, ex.message
     return 1
 
 
 if __name__ == '__main__':
   subprocess42.inhibit_os_error_reporting()
   # Ensure that we are always running with the correct encoding.
   fix_encoding.fix_encoding()
   file_path.enable_symlink()
   sys.exit(main(sys.argv[1:]))