Add option to collapse symlinks in isolate.py

client/isolate.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.
 
 """Front end tool to operate on .isolate files.
 
 This includes creating, merging or compiling them to generate a .isolated file.
 
 See more information at
@@ skipping 461 matching lines @@
     """Loads state from disk."""
     assert os.path.isabs(isolated_filepath), isolated_filepath
     isolated_basedir = os.path.dirname(isolated_filepath)
     return cls(
         isolated_filepath,
         SavedState.load_file(
             isolatedfile_to_state(isolated_filepath), isolated_basedir))
 
   def load_isolate(
       self, cwd, isolate_file, path_variables, config_variables,
-      extra_variables, blacklist, ignore_broken_items):
+      extra_variables, blacklist, ignore_broken_items, collapse_symlinks):
     """Updates self.isolated and self.saved_state with information loaded from a
     .isolate file.
 
     Processes the loaded data, deduce root_dir, relative_cwd.
     """
     # Make sure to not depend on os.getcwd().
     assert os.path.isabs(isolate_file), isolate_file
     isolate_file = file_path.get_native_path_case(isolate_file)
     logging.info(
-        'CompleteState.load_isolate(%s, %s, %s, %s, %s, %s)',
+        'CompleteState.load_isolate(%s, %s, %s, %s, %s, %s, %s)',
         cwd, isolate_file, path_variables, config_variables, extra_variables,
-        ignore_broken_items)
+        ignore_broken_items, collapse_symlinks)
 
     # Config variables are not affected by the paths and must be used to
     # retrieve the paths, so update them first.
     self.saved_state.update_config(config_variables)
 
     with fs.open(isolate_file, 'r') as f:
       # At that point, variables are not replaced yet in command and infiles.
       # infiles may contain directory entries and is in posix style.
       command, infiles, read_only, isolate_cmd_dir = (
           isolate_format.load_isolate_for_config(
@@ skipping 38 matching lines @@
             '%s; %s'
             % (k, v, self.saved_state.root_dir, dest))
     # Normalize the files based to self.saved_state.root_dir. It is important to
     # keep the trailing os.path.sep at that step.
     infiles = [
       file_path.relpath(
           file_path.normpath(os.path.join(isolate_cmd_dir, f)),
           self.saved_state.root_dir)
       for f in infiles
     ]
-    follow_symlinks = sys.platform != 'win32'
+    follow_symlinks = False
+    if not collapse_symlinks:
+      follow_symlinks = sys.platform != 'win32'
     # Expand the directories by listing each file inside. Up to now, trailing
     # os.path.sep must be kept.
     infiles = isolated_format.expand_directories_and_symlinks(
         self.saved_state.root_dir,
         infiles,
         tools.gen_blacklist(blacklist),
         follow_symlinks,
         ignore_broken_items)
 
     # Finally, update the new data to be able to generate the foo.isolated file,
     # the file that is used by run_isolated.py.
     self.saved_state.update_isolated(command, infiles, read_only, relative_cwd)
     logging.debug(self)
 
-  def files_to_metadata(self, subdir):
+  def files_to_metadata(self, subdir, collapse_symlinks):
     """Updates self.saved_state.files with the files' mode and hash.
 
     If |subdir| is specified, filters to a subdirectory. The resulting .isolated
     file is tainted.
 
     See isolated_format.file_to_metadata() for more information.
     """
     for infile in sorted(self.saved_state.files):
       if subdir and not infile.startswith(subdir):
         self.saved_state.files.pop(infile)
       else:
         filepath = os.path.join(self.root_dir, infile)
         self.saved_state.files[infile] = isolated_format.file_to_metadata(
             filepath,
             self.saved_state.files[infile],
             self.saved_state.read_only,
-            self.saved_state.algo)
+            self.saved_state.algo,
+            collapse_symlinks)
 
   def save_files(self):
     """Saves self.saved_state and creates a .isolated file."""
     logging.debug('Dumping to %s' % self.isolated_filepath)
     self.saved_state.child_isolated_files = chromium_save_isolated(
         self.isolated_filepath,
         self.saved_state.to_isolated(),
         self.saved_state.path_variables,
         self.saved_state.algo)
     total_bytes = sum(
@@ skipping 71 matching lines @@
             complete_state.saved_state.isolate_file,
             isolatedfile_to_state(options.isolated))
         complete_state = CompleteState(
             options.isolated,
             SavedState(complete_state.saved_state.isolated_basedir))
 
   if not skip_update:
     # Then load the .isolate and expands directories.
     complete_state.load_isolate(
         cwd, isolate, options.path_variables, options.config_variables,
-        options.extra_variables, options.blacklist, options.ignore_broken_items)
+        options.extra_variables, options.blacklist, options.ignore_broken_items,
+        options.collapse_symlinks)
 
   # Regenerate complete_state.saved_state.files.
   if subdir:
     subdir = unicode(subdir)
     # This is tricky here. If it is a path, take it from the root_dir. If
     # it is a variable, it must be keyed from the directory containing the
     # .isolate file. So translate all variables first.
     translated_path_variables = dict(
         (k,
           os.path.normpath(os.path.join(complete_state.saved_state.relative_cwd,
             v)))
         for k, v in complete_state.saved_state.path_variables.iteritems())
     subdir = isolate_format.eval_variables(subdir, translated_path_variables)
     subdir = subdir.replace('/', os.path.sep)
 
   if not skip_update:
-    complete_state.files_to_metadata(subdir)
+    complete_state.files_to_metadata(subdir, options.collapse_symlinks)
   return complete_state
 
 
 def create_isolate_tree(outdir, root_dir, files, relative_cwd, read_only):
   """Creates a isolated tree usable for test execution.
 
   Returns the current working directory where the isolated command should be
   started in.
   """
   # Forcibly copy when the tree has to be read only. Otherwise the inode is
@@ skipping 410 matching lines @@
       '-i', '--isolate',
       metavar='FILE',
       help='.isolate file to load the dependency data from')
   add_variable_option(group)
   group.add_option(
       '--ignore_broken_items', action='store_true',
       default=bool(os.environ.get('ISOLATE_IGNORE_BROKEN_ITEMS')),
       help='Indicates that invalid entries in the isolated file to be '
            'only be logged and not stop processing. Defaults to True if '
            'env var ISOLATE_IGNORE_BROKEN_ITEMS is set')
+  group.add_option(
+      '-L', '--collapse_symlinks', action='store_true',
+      help='Treat any symlinks as if they were the normal underlying file')
   parser.add_option_group(group)
 
 
 def add_subdir_option(parser):
   parser.add_option(
       '--subdir',
       help='Filters to a subdirectory. Its behavior changes depending if it '
            'is a relative path as a string or as a path variable. Path '
            'variables are always keyed from the directory containing the '
            '.isolate file. Anything else is keyed on the root directory.')
@@ skipping 82 matching lines @@
     print >> sys.stderr, 'Execution failure: %s' % e
     return 1
 
 
 if __name__ == '__main__':
   subprocess42.inhibit_os_error_reporting()
   fix_encoding.fix_encoding()
   tools.disable_buffering()
   colorama.init()
   sys.exit(main(sys.argv[1:]))