Add variable replacement in trace_inputs.py

tools/isolate/trace_inputs.py

 #!/usr/bin/env python
 # coding=utf-8
 # Copyright (c) 2012 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.
 
 """Traces an executable and its child processes and extract the files accessed
 by them.
 
 The implementation uses OS-specific API. The native Kernel logger and the ETL
@@ skipping 365 matching lines @@
       if dense:
         json.dump(data, f, separators=(',',':'))
       else:
         json.dump(data, f, sort_keys=True, indent=2)
 
 
 class Results(object):
   """Results of a trace session."""
 
   class File(object):
-    """A file that was accessed."""
-    def __init__(self, root, path):
+    """A file that was accessed.
+
+    If tainted is true, it means it is not a real path anymore as a variable
+    replacement occured.
+    """
+    def __init__(self, root, path, tainted=False):
       """Represents a file accessed. May not be present anymore."""
       logging.debug('%s(%s, %s)' % (self.__class__.__name__, root, path))
       self.root = root
       self.path = path
 
+      self.tainted = tainted
       self._size = None
       # For compatibility with Directory object interface.
       # Shouldn't be used normally, only exists to simplify algorithms.
       self.nb_files = 1
 
       # Check internal consistency.
       assert path, path
-      assert bool(root) != bool(isabs(path)), (root, path)
-      assert (
+      assert tainted or bool(root) != bool(isabs(path)), (root, path)
+      assert tainted or (
           not os.path.exists(self.full_path) or
           self.full_path == get_native_path_case(self.full_path))
 
     @property
     def existent(self):
       return self.size != -1
 
     @property
     def size(self):
       """File's size. -1 is not existent."""
-      if self._size is None:
+      if self._size is None and not self.tainted:
         try:
           self._size = os.stat(self.full_path).st_size
         except OSError:
           self._size = -1
       return self._size
 
     @property
     def full_path(self):
       if self.root:
         return os.path.join(self.root, self.path)
       return self.path
 
     def flatten(self):
       return {
         'path': self.path,
         'size': self.size,
       }
 
     def strip_root(self, root):
       """Returns a clone of itself with 'root' stripped off."""
       # Check internal consistency.
-      assert isabs(root) and root.endswith(os.path.sep), root
+      assert self.tainted or (isabs(root) and root.endswith(os.path.sep)), root
       if not self.full_path.startswith(root):
         return None
-      out = self.__class__(root, self.full_path[len(root):])
-      # Keep size cache.
-      out._size = self._size
+      return self._clone(root, self.full_path[len(root):], self.tainted)
+
+    def replace_variables(self, variables):
+      """Replaces the root of this File with one of the variables if it matches.
+
+      If a variable replacement occurs, the cloned object becomes tainted.
+      """
+      for variable, root_path in variables.iteritems():
+        if self.path.startswith(root_path):
+          return self._clone(
+              self.root, variable + self.path[len(root_path):], True)
+      # No need to clone, returns ourself.
+      return self
+
+    def _clone(self, new_root, new_path, tainted):
+      """Clones itself keeping meta-data."""
+      out = self.__class__(new_root, new_path, tainted)
+      out._size = self.size
       return out
 
   class Directory(File):
     """A directory of files. Must exist."""
-    def __init__(self, root, path, size, nb_files):
+    def __init__(self, root, path, tainted, size, nb_files):
       """path='.' is a valid value and must be handled appropriately."""
-      super(Results.Directory, self).__init__(root, path)
-      assert not self.path.endswith(os.path.sep)
+      super(Results.Directory, self).__init__(root, path, tainted)
+      assert not self.path.endswith(os.path.sep), self.path
       self.path = self.path + os.path.sep
       self.nb_files = nb_files
       self._size = size
 
     def flatten(self):
       out = super(Results.Directory, self).flatten()
       out['nb_files'] = self.nb_files
       return out
 
+    def _clone(self, new_root, new_path, tainted):
+      """Clones itself keeping meta-data."""
+      return self.__class__(
+          new_root,
+          new_path.rstrip(os.path.sep),
+          tainted,
+          self.size,
+          self.nb_files)
+
   class Process(object):
     """A process that was traced.
 
     Contains references to the files accessed by this process and its children.
     """
     def __init__(
         self, pid, files, executable, command, initial_cwd, children):
       logging.debug('Process(%s, %d, ...)' % (pid, len(files)))
       self.pid = pid
       self.files = sorted(
@@ skipping 2121 matching lines @@
 
   root_prefix = len(root_dir) + 1 if root_dir else 0
   for directory in sorted(buckets, reverse=True):
     actual = set(f for f in os.listdir(directory) if not blacklist(f))
     expected = set(buckets[directory])
     if not (actual - expected):
       parent = os.path.dirname(directory)
       buckets[parent][os.path.basename(directory)] = Results.Directory(
         root_dir,
         directory[root_prefix:],
+        False,
         sum(f.size for f in buckets[directory].itervalues()),
         sum(f.nb_files for f in buckets[directory].itervalues()))
       # Remove the whole bucket.
       del buckets[directory]
 
   # Reverse the mapping with what remains. The original instances are returned,
   # so the cached meta data is kept.
   return sorted(
       sum((x.values() for x in buckets.itervalues()), []),
       key=lambda x: x.path)
@@ skipping 81 matching lines @@
       help='Root directory to base everything off it. Anything outside of this '
            'this directory will not be reported')
   parser.add_option(
       '-j', '--json', action='store_true',
       help='Outputs raw result data as json')
   options, args = parser.parse_args(args)
 
   if options.root_dir:
     options.root_dir = os.path.abspath(options.root_dir)
 
+  variables = dict(options.variables)
   api = get_api()
   try:
     results = load_trace(options.log, options.root_dir, api)
     simplified = extract_directories(options.root_dir, results.files)
+    simplified = [f.replace_variables(variables) for f in simplified]
+
     if options.json:
       write_json(sys.stdout, results.flatten(), False)
     else:
       print('Total: %d' % len(results.files))
       print('Non existent: %d' % len(results.non_existent))
       for f in results.non_existent:
         print('  %s' % f.path)
       print(
           'Interesting: %d reduced to %d' % (
               len(results.existent), len(simplified)))
@@ skipping 80 matching lines @@
       for fn in dir(sys.modules[__name__])
       if fn.startswith('CMD')))
 
   command = get_command_handler(argv[0] if argv else None)
   parser = gen_parser(command)
   return command(parser, argv[1:])
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))