Add .clean_trace() to the APIs to delete the stale traces.

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.
 
 """Runs strace or dtrace on a test and processes the logs to extract the
 dependencies from the source tree.
 
 Automatically extracts directories where all the files are used to make the
@@ skipping 371 matching lines @@
         logging.debug(
             '_handle_file(%d, %s) -> %s' % (pid, old_filepath, filepath))
       else:
         logging.debug('_handle_file(%d, %s)' % (pid, filepath))
       if filepath not in self.files and filepath not in self.non_existent:
         if os.path.isfile(filepath):
           self.files.add(filepath)
         else:
           self.non_existent.add(filepath)
 
+  @staticmethod
+  def clean_trace(logname):
+    """Deletes the old log."""
+    if os.path.isfile(logname):
+      os.remove(logname)

[MAD, 2012/05/11 18:51:38]

Shouldn't we try to catch these?

"On Windows, attempting to remove a file that is in use causes an exception to
be raised"

And if so, instead of repeating this code in all classes, why not have a method
to retrieve all log file names in an array and iterate over it with a single
exception proof remove file implementation... No?

[M-A Ruel, 2012/05/11 18:57:25]

I prefer the script to crash if the files can't be removed. Since it'll fail
later anyway.

BTW, you meant line 1029. line 396 is never executed on windows.
Exceptions are only an issue on Windows. And I want them to be fatal anyway. I
also prefer the caller to not have to do anything with the function result.

+
   @classmethod
   def gen_trace(cls, cmd, cwd, logname, output):
     """Runs strace on an executable."""
     logging.info('gen_trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
     stdout = stderr = None
     if output:
       stdout = subprocess.PIPE
       stderr = subprocess.STDOUT
     traces = ','.join(cls.Context.traces())
     trace_cmd = ['strace', '-f', '-e', 'trace=%s' % traces, '-o', logname]
@@ skipping 290 matching lines @@
           logging.debug('_handle_file(%d, %s)' % (pid, filepath))
         if os.path.isfile(filepath):
           self.files.add(filepath)
         else:
           self.non_existent.add(filepath)
 
     @staticmethod
     def _handle_ignored(_ppid, pid, function, args, result):
       logging.debug('%d %s(%s) = %s' % (pid, function, args, result))
 
+  @staticmethod
+  def clean_trace(logname):
+    """Deletes the old log."""
+    if os.path.isfile(logname):
+      os.remove(logname)
+
   @classmethod
   def gen_trace(cls, cmd, cwd, logname, output):
     """Runs dtrace on an executable."""
     logging.info('gen_trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
     logging.info('Running: %s' % cmd)
     signal = 'Go!'
     logging.debug('Our pid: %d' % os.getpid())
 
     # Part 1: start the child process.
     stdout = stderr = None
@@ skipping 294 matching lines @@
         self.IGNORED.add(os.environ[i])
 
     # Also add their short path name equivalents.
     for i in list(self.IGNORED):
       self.IGNORED.add(GetShortPathName(i))
 
     # Add this one last since it has no short path name equivalent.
     self.IGNORED.add('\\systemroot')
     self.IGNORED = tuple(sorted(self.IGNORED))
 
+  @staticmethod
+  def clean_trace(logname):
+    """Deletes the old log."""
+    if os.path.isfile(logname):
+      os.remove(logname)
+    if os.path.isfile(logname + '.etl'):
+      os.remove(logname + '.etl')
+
   @classmethod
   def gen_trace(cls, cmd, cwd, logname, output):
     logging.info('gen_trace(%s, %s, %s, %s)' % (cmd, cwd, logname, output))
     # Use "logman -?" for help.
 
     etl = logname + '.etl'
 
     stdout = stderr = None
     if output:
       stdout = subprocess.PIPE
@@ skipping 305 matching lines @@
 
   Arguments:
   - logfile: file to write to.
   - cmd: command to run.
   - cwd: current directory to start the process in.
   - api: a tracing api instance.
   - output: if True, returns output, otherwise prints it at the console.
   """
   cmd = fix_python_path(cmd)
   assert os.path.isabs(cmd[0]), cmd[0]
-  if os.path.isfile(logfile):
-    os.remove(logfile)
+  api.clean_trace(logfile)
   return api.gen_trace(cmd, cwd, logfile, output)
 
 
 def load_trace(logfile, root_dir, api):
   """Loads a trace file and returns the processed file lists.
 
   Arguments:
   - logfile: file to load.
   - root_dir: root directory to use to determine if a file is relevant to the
               trace or not.
@@ skipping 125 matching lines @@
       os.path.abspath(options.log),
       args,
       options.root_dir,
       options.cwd,
       options.product_dir,
       options.force)
 
 
 if __name__ == '__main__':
   sys.exit(main())