Rename tree_creator.py to run_test_from_archive.py

tools/isolate/isolate.py

 #!/usr/bin/env python
 # 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.
 
 """Does one of the following depending on the --mode argument:
   check     Verifies all the inputs exist, touches the file specified with
             --result and exits.
   hashtable Puts a manifest file and hard links each of the inputs into the
             output directory.
@@ skipping 13 matching lines @@
 import logging
 import optparse
 import os
 import re
 import stat
 import subprocess
 import sys
 import tempfile
 
 import trace_inputs
-import tree_creator
+import run_test_from_archive
 
 
 def relpath(path, root):
   """os.path.relpath() that keeps trailing slash."""
   out = os.path.relpath(path, root)
   if path.endswith(os.path.sep):
     out += os.path.sep
   return out
 
 
@@ skipping 10 matching lines @@
     logging.info('%s not under %s' % (path, root))
   return path
 
 
 def expand_directories(indir, infiles, blacklist):
   """Expands the directories, applies the blacklist and verifies files exist."""
   logging.debug('expand_directories(%s, %s, %s)' % (indir, infiles, blacklist))
   outfiles = []
   for relfile in infiles:
     if os.path.isabs(relfile):
-      raise tree_creator.MappingError('Can\'t map absolute path %s' % relfile)
+      raise run_test_from_archive.MappingError(
+          'Can\'t map absolute path %s' % relfile)
     infile = os.path.normpath(os.path.join(indir, relfile))
     if not infile.startswith(indir):
-      raise tree_creator.MappingError(
+      raise run_test_from_archive.MappingError(
           'Can\'t map file %s outside %s' % (infile, indir))
 
     if relfile.endswith(os.path.sep):
       if not os.path.isdir(infile):
-        raise tree_creator.MappingError(
+        raise run_test_from_archive.MappingError(
             'Input directory %s must have a trailing slash' % infile)
       for dirpath, dirnames, filenames in os.walk(infile):
         # Convert the absolute path to subdir + relative subdirectory.
         reldirpath = dirpath[len(indir)+1:]
         outfiles.extend(os.path.join(reldirpath, f) for f in filenames)
         for index, dirname in enumerate(dirnames):
           # Do not process blacklisted directories.
           if blacklist(os.path.join(reldirpath, dirname)):
             del dirnames[index]
     else:
       if not os.path.isfile(infile):
-        raise tree_creator.MappingError('Input file %s doesn\'t exist' % infile)
+        raise run_test_from_archive.MappingError(
+            'Input file %s doesn\'t exist' % infile)
       outfiles.append(relfile)
   return outfiles
 
 
 def process_inputs(indir, infiles, need_hash, read_only):
   """Returns a dictionary of input files, populated with the files' mode and
   hash.
 
   The file mode is manipulated if read_only is True. In practice, we only save
   one of 4 modes: 0755 (rwx), 0644 (rw), 0555 (rx), 0444 (r).
@@ skipping 28 matching lines @@
     outdir:    Output directory to create the files in.
     indir:     Root directory the infiles are based in.
     infiles:   List of files to map from |indir| to |outdir|.
     action:    See assert below.
   """
   logging.debug(
       'recreate_tree(%s, %s, %s, %s)' % (outdir, indir, infiles, action))
   logging.info('Mapping from %s to %s' % (indir, outdir))
 
   assert action in (
-      tree_creator.HARDLINK, tree_creator.SYMLINK, tree_creator.COPY)
+      run_test_from_archive.HARDLINK,
+      run_test_from_archive.SYMLINK,
+      run_test_from_archive.COPY)
   outdir = os.path.normpath(outdir)
   if not os.path.isdir(outdir):
     logging.info ('Creating %s' % outdir)
     os.makedirs(outdir)
   # Do not call abspath until the directory exists.
   outdir = os.path.abspath(outdir)
 
   for relfile in infiles:
     infile = os.path.join(indir, relfile)
     outfile = os.path.join(outdir, relfile)
     outsubdir = os.path.dirname(outfile)
     if not os.path.isdir(outsubdir):
       os.makedirs(outsubdir)
-    tree_creator.link_file(outfile, infile, action)
+    run_test_from_archive.link_file(outfile, infile, action)
 
 
 def separate_inputs_command(args, root, files):
   """Strips off the command line from the inputs.
 
   gyp provides input paths relative to cwd. Convert them to be relative to root.
   OptionParser kindly strips off '--' from sys.argv if it's provided and that's
   the first non-arg value. Manually look up if it was present in sys.argv.
   """
   cmd = []
@@ skipping 83 matching lines @@
     outdir, indir, dictfiles, _read_only, _cmd, _relative_cwd, resultfile):
   outdir = outdir or os.path.dirname(resultfile)
   for relfile, properties in dictfiles.iteritems():
     infile = os.path.join(indir, relfile)
     outfile = os.path.join(outdir, properties['sha-1'])
     if os.path.isfile(outfile):
       # Just do a quick check that the file size matches.
       if os.stat(infile).st_size == os.stat(outfile).st_size:
         continue
       # Otherwise, an exception will be raised.
-    tree_creator.link_file(outfile, infile, tree_creator.HARDLINK)
+    run_test_from_archive.link_file(
+        outfile, infile, run_test_from_archive.HARDLINK)
   return 0
 
 
 def MODEremap(
     outdir, indir, dictfiles, read_only, _cmd, _relative_cwd, _resultfile):
   if not outdir:
     outdir = tempfile.mkdtemp(prefix='isolate')
   print 'Remapping into %s' % outdir
   if len(os.listdir(outdir)):
     print 'Can\'t remap in a non-empty directory'
     return 1
-  recreate_tree(outdir, indir, dictfiles.keys(), tree_creator.HARDLINK)
+  recreate_tree(outdir, indir, dictfiles.keys(), run_test_from_archive.HARDLINK)
   if read_only:
-    tree_creator.make_writable(outdir, True)
+    run_test_from_archive.make_writable(outdir, True)
   return 0
 
 
 def MODErun(
     _outdir, indir, dictfiles, read_only, cmd, relative_cwd, _resultfile):
   """Always uses a temporary directory."""
   try:
     outdir = tempfile.mkdtemp(prefix='isolate')
-    recreate_tree(outdir, indir, dictfiles.keys(), tree_creator.HARDLINK)
+    recreate_tree(
+        outdir, indir, dictfiles.keys(), run_test_from_archive.HARDLINK)
     cwd = os.path.join(outdir, relative_cwd)
     if not os.path.isdir(cwd):
       os.makedirs(cwd)
     if read_only:
-      tree_creator.make_writable(outdir, True)
+      run_test_from_archive.make_writable(outdir, True)
 
     logging.info('Running %s, cwd=%s' % (cmd, cwd))
     return subprocess.call(cmd, cwd=cwd)
   finally:
-    tree_creator.rmtree(outdir)
+    run_test_from_archive.rmtree(outdir)
 
 
 def MODEtrace(
     _outdir, indir, _dictfiles, _read_only, cmd, relative_cwd, resultfile):
   """Shortcut to use trace_inputs.py properly.
 
   It constructs the equivalent of dictfiles. It is hardcoded to base the
   checkout at src/.
   """
   logging.info('Running %s, cwd=%s' % (cmd, os.path.join(indir, relative_cwd)))
@@ skipping 99 matching lines @@
   try:
     return isolate(
         options.outdir,
         options.result,
         indir,
         infiles,
         options.mode,
         options.read_only,
         cmd,
         options.from_results)
-  except tree_creator.MappingError, e:
+  except run_test_from_archive.MappingError, e:
     print >> sys.stderr, str(e)
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())