swarming: delete named cache symlinks before workdir

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 472 matching lines @@
 
       # If we have an explicit list of files to return, make sure their
       # directories exist now.
       if storage and outputs:
         isolateserver.create_directories(run_dir, outputs)
 
       command = tools.fix_python_path(command)
       command = process_command(command, out_dir, bot_file)
       file_path.ensure_command_has_abs_path(command, cwd)
 
-      init_named_caches(run_dir)
-
-      sys.stdout.flush()
-      start = time.time()
-      try:
-        result['exit_code'], result['had_hard_timeout'] = run_command(
-            command, cwd, get_command_env(tmp_dir, cipd_info),
-            hard_timeout, grace_period)
-      finally:
-        result['duration'] = max(time.time() - start, 0)
+      with init_named_caches(run_dir):
+        sys.stdout.flush()
+        start = time.time()
+        try:
+          result['exit_code'], result['had_hard_timeout'] = run_command(
+              command, cwd, get_command_env(tmp_dir, cipd_info),
+              hard_timeout, grace_period)
+        finally:
+          result['duration'] = max(time.time() - start, 0)
   except Exception as e:
     # An internal error occurred. Report accordingly so the swarming task will
     # be retried automatically.
     logging.exception('internal failure: %s', e)
     result['internal_failure'] = str(e)
     on_error.report(None)
 
   # Clean up
   finally:
     try:
@@ skipping 78 matching lines @@
     isolated_hash: the SHA-1 of the .isolated file that must be retrieved to
                    recreate the tree of files to run the target executable.
                    The command specified in the .isolated is executed.
                    Mutually exclusive with command argument.
     storage: an isolateserver.Storage object to retrieve remote objects. This
              object has a reference to an isolateserver.StorageApi, which does
              the actual I/O.
     isolate_cache: an isolateserver.LocalCache to keep from retrieving the
                    same objects constantly by caching the objects retrieved.
                    Can be on-disk or in-memory.
-    init_named_caches: a function (run_dir) => void that creates symlinks for
-                      named caches in |run_dir|.
+    init_named_caches: a function (run_dir) => context manager that creates
+                      symlinks for named caches in |run_dir|.
     leak_temp_dir: if true, the temporary directory will be deliberately leaked
                    for later examination.
     result_json: file path to dump result metadata into. If set, the process
                  exit code is always 0 unless an internal error occurred.
     root_dir: path to the directory to use to create the temporary directory. If
               not specified, a random temporary directory is created.
     hard_timeout: kills the process if it lasts more than this amount of
                   seconds.
     grace_period: number of seconds to wait between SIGTERM and SIGKILL.
     extra_args: optional arguments to add to the command stated in the .isolate
@@ skipping 341 matching lines @@
 
   cipd.validate_cipd_options(parser, options)
 
   install_packages_fn = noop_install_packages
   if options.cipd_enabled:
     install_packages_fn = lambda run_dir: install_packages(
         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)
 
+  @contextlib.contextmanager
   def init_named_caches(run_dir):
+    # WARNING: this function depends on "options" variable defined in the outer
+    # function.
     with named_cache_manager.open():
       named_cache_manager.create_symlinks(run_dir, options.named_caches)
+    try:
+      yield
+    finally:
+      if not options.leak_temp_dir:
+        named_cache_manager.delete_symlinks(run_dir, options.named_caches)
 
   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 |isolate_cache| MUST match.
         assert storage.hash_algo == isolate_cache.hash_algo
         return run_tha_test(
@@ skipping 30 matching lines @@
     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:]))