[strace] Add support for interrupted calls and proper chdir handling.

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 56 matching lines @@
     cmd = args
     args = []
   if files:
     args = [
       i.decode('utf-8') for i in open(files, 'rb').read().splitlines() if i
     ] + args
   cwd = os.getcwd()
   return [relpath(os.path.join(cwd, arg), root) for arg in args], cmd
 
 
-def isolate(outdir, resultfile, indir, infiles, mode, read_only, cmd):
+def isolate(outdir, resultfile, indir, infiles, mode, read_only, cmd, no_save):
   """Main function to isolate a target with its dependencies.
 
   Arguments:
   - outdir: Output directory where the result is stored. Depends on |mode|.
   - resultfile: File to save the json data.
   - indir: Root directory to be used as the base directory for infiles.
   - infiles: List of files, with relative path, to process.
   - mode: Action to do. See file level docstring.
   - read_only: Makes the temporary directory read only.
   - cmd: Command to execute.
+  - no_save: If True, do not touch resultfile.
 
   Some arguments are optional, dependending on |mode|. See the corresponding
   MODE<mode> function for the exact behavior.
   """
   mode_fn = getattr(sys.modules[__name__], 'MODE' + mode)
   assert mode_fn
+  assert os.path.isabs(resultfile)
 
   infiles = tree_creator.expand_directories(
         indir, infiles, lambda x: re.match(r'.*\.(svn|pyc)$', x))
 
   # Note the relative current directory.
   # In general, this path will be the path containing the gyp file where the
   # target was defined. This relative directory may be created implicitely if a
   # file from this directory is needed to run the test. Otherwise it won't be
   # created and the process creation will fail. It's up to the caller to create
   # this directory manually before starting the test.
   cwd = os.getcwd()
   relative_cwd = os.path.relpath(cwd, indir)
 
   # Workaround make behavior of passing absolute paths.
   cmd = [to_relative(i, indir, cwd) for i in cmd]
 
   if not cmd:
     # Note that it is exactly the reverse of relative_cwd.
     cmd = [os.path.join(os.path.relpath(indir, cwd), infiles[0])]
   if cmd[0].endswith('.py'):
     cmd.insert(0, sys.executable)
 
   # Only hashtable mode really needs the sha-1.
   dictfiles = tree_creator.process_inputs(
       indir, infiles, mode == 'hashtable', read_only)
 
   result = mode_fn(
       outdir, indir, dictfiles, read_only, cmd, relative_cwd, resultfile)
 
-  if result == 0:
+  if result == 0 and not no_save:
     # Saves the resulting file.
     out = {
       'command': cmd,
       'relative_cwd': relative_cwd,
       'files': dictfiles,
+      'read_only': read_only,
     }
     with open(resultfile, 'wb') as f:
       json.dump(out, f, indent=2, sort_keys=True)
   return result
 
 
 def MODEcheck(
     _outdir, _indir, _dictfiles, _read_only, _cmd, _relative_cwd, _resultfile):
   """No-op."""
   return 0
@@ skipping 50 matching lines @@
     tree_creator.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/.
   """
-  gyppath = os.path.relpath(relative_cwd, indir)
-  cwd = os.path.join(indir, relative_cwd)
-  logging.info('Running %s, cwd=%s' % (cmd, cwd))
+  logging.info('Running %s, cwd=%s' % (cmd, os.path.join(indir, relative_cwd)))
   return trace_inputs.trace_inputs(
       '%s.log' % resultfile,
       cmd,
-      cwd,
-      gyppath,
       indir,
-      True)
+      relative_cwd,
+      os.path.dirname(resultfile),  # Guesswork here.
+      False)
 
 
 def get_valid_modes():
   """Returns the modes that can be used."""
   return sorted(
       i[4:] for i in dir(sys.modules[__name__]) if i.startswith('MODE'))
 
 
 def main():
   valid_modes = get_valid_modes()
   parser = optparse.OptionParser(
       usage='%prog [options] [inputs] -- [command line]',
       description=sys.modules[__name__].__doc__)
   parser.allow_interspersed_args = False
   parser.format_description = lambda *_: parser.description
   parser.add_option(
       '-v', '--verbose', action='count', default=0, help='Use multiple times')
   parser.add_option(
       '--mode', choices=valid_modes,
       help='Determines the action to be taken: %s' % ', '.join(valid_modes))
   parser.add_option(
       '--result', metavar='FILE',
-      help='Output file containing the json information about inputs')
+      help='File containing the json information about inputs')
   parser.add_option(
       '--root', metavar='DIR', help='Base directory to fetch files, required')
   parser.add_option(
       '--outdir', metavar='DIR',
       help='Directory used to recreate the tree or store the hash table. '
            'For run and remap, uses a /tmp subdirectory. For the other modes, '
            'defaults to the directory containing --result')
   parser.add_option(
-      '--read-only', action='store_true',
+      '--read-only', action='store_true', default=False,
       help='Make the temporary tree read-only')
   parser.add_option(
+      '--from-results', action='store_true',
+      help='Loads everything from the result file instead of generating it')
+  parser.add_option(
       '--files', metavar='FILE',
       help='File to be read containing input files')
 
   options, args = parser.parse_args()
   level = [logging.ERROR, logging.INFO, logging.DEBUG][min(2, options.verbose)]
   logging.basicConfig(
       level=level,
       format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
 
-  if not options.root:
-    parser.error('--root is required.')
+  if not options.mode:
+    parser.error('--mode is required')
+
   if not options.result:
     parser.error('--result is required.')
+  if options.from_results:
+    if not options.root:
+      options.root = os.getcwd()
+    if args:
+      parser.error('Arguments cannot be used with --from-result')
+    if options.files:
+      parser.error('--files cannot be used with --from-result')
+  else:
+    if not options.root:
+      parser.error('--root is required.')
+
+  options.result = os.path.abspath(options.result)
 
   # Normalize the root input directory.
   indir = os.path.normpath(options.root)
   if not os.path.isdir(indir):
     parser.error('%s is not a directory' % indir)
 
   # Do not call abspath until it was verified the directory exists.
   indir = os.path.abspath(indir)
 
   logging.info('sys.argv: %s' % sys.argv)
   logging.info('cwd: %s' % os.getcwd())
   logging.info('Args: %s' % args)
-  infiles, cmd = separate_inputs_command(args, indir, options.files)
-  if not infiles:
-    parser.error('Need at least one input file to map')
+  if not options.from_results:
+    infiles, cmd = separate_inputs_command(args, indir, options.files)
+    if not infiles:
+      parser.error('Need at least one input file to map')
+  else:
+    data = json.load(open(options.result))
+    cmd = data['command']
+    infiles = data['files'].keys()
+    os.chdir(data['relative_cwd'])
+
   logging.info('infiles: %s' % infiles)
 
   try:
     return isolate(
         options.outdir,
-        os.path.abspath(options.result),
+        options.result,
         indir,
         infiles,
         options.mode,
         options.read_only,
-        cmd)
+        cmd,
+        options.from_results)
   except tree_creator.MappingError, e:
     print >> sys.stderr, str(e)
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())