Allow purify scripts to take a --report_dir argument which specifies where th...

tools/purify/purify_analyze.py

 #!/bin/env python
 # Copyright (c) 2006-2008 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.
 
 # purify_analyze.py
 
 ''' Given a Purify text file, parses messages, normalizes and uniques them.
 If there's an existing baseline of this data, it can compare against that
 baseline and return an error code if there are any new errors not in the
@@ skipping 145 matching lines @@
   pat_ignore = (re.compile('^(Start|Exit)ing'),
                 re.compile('^Program terminated'),
                 re.compile('^Terminating thread'),
                 re.compile('^Message: CryptVerifySignature'))
   # message types that aren't analyzed
   # handled, ignored and continued exceptions will likely never be interesting
   # TODO(erikkay): MPK ("potential" memory leaks) may be worth turning on
   types_excluded = ("EXH", "EXI", "EXC", "MPK")
 
 
-  def __init__(self, files, echo, name=None, source_dir=None, data_dir=None):
+  def __init__(self, files, echo, name=None, source_dir=None, data_dir=None,
+               report_dir=None):
     # The input file we're analyzing.
     self._files = files
+
     # Whether the input file contents should be echoed to stdout.
     self._echo = echo
+
     # A symbolic name for the run being analyzed, often the name of the
     # exe which was purified.
     self._name = name
+    
     # The top of the source code tree of the code we're analyzing.
     # This prefix is stripped from all filenames in stacks for normalization.
     if source_dir:
       purify_message.Stack.SetSourceDir(source_dir)
+
+    script_dir = google.path_utils.ScriptDir()
+
     if data_dir:
       self._data_dir = data_dir
+      self._global_data_dir = os.path.join(script_dir, "data")
     else:
-      self._data_dir = os.path.join(google.path_utils.ScriptDir(), "data")
+      self._data_dir = os.path.join(script_dir, "data")
+      self._global_data_dir = None
+
+    if report_dir:
+      self._report_dir = report_dir
+    else:
+      self._report_dir = os.path.join(script_dir, "latest")
+
     # A map of message_type to a MessageList of that type.
     self._message_lists = {}
     self._ReadIgnoreFile()
 
   def _ReadIgnoreFile(self):
     '''Read a file which is a list of regexps for either the title or the
     top-most visible stack line.
     '''
     self._pat_ignore = []
-    filenames = [os.path.join(self._data_dir, "ignore.txt"),
-        os.path.join(google.path_utils.ScriptDir(), "data", "ignore.txt")]
+    filenames = [os.path.join(self._data_dir, "ignore.txt")]
+    if self._global_data_dir:
+      filenames.append(os.path.join(self._global_data_dir, "ignore.txt"))
     for filename in filenames:
       if os.path.exists(filename):
         f = open(filename, 'r')
         for line in f.readlines():
           if line.startswith("#") or line.startswith("//") or line.isspace():
             continue
           line = line.rstrip()
           pat = re.compile(line)
           if pat:
             self._pat_ignore.append(pat)
@@ skipping 385 matching lines @@
       print "test error counts"
       print "========================"
       tests = test_counts.keys()
       tests.sort()
       for test in tests:
         print "%s: %d" % (test, test_counts[test])
     # make sure stdout is flushed to avoid weird overlaps with logging
     print
     sys.stdout.flush()
 
-  def SaveLatestStrings(self, string_list, key, fname_extra=""):
-    '''Output a list of strings to a file in the "latest" dir.
+  def SaveStrings(self, string_list, key, fname_extra=""):
+    '''Output a list of strings to a file in the report dir.
     '''
-    script_dir = google.path_utils.ScriptDir()
-    path = os.path.join(script_dir, "latest")
-    out = os.path.join(path, "%s_%s%s.txt" % (self._name, key, fname_extra))
+    out = os.path.join(self._report_dir, 
+                       "%s_%s%s.txt" % (self._name, key, fname_extra))
     logging.info("saving %s" % (out))
     try:
       f = open(out, "w+")
       f.write('\n'.join(string_list))
     except IOError, (errno, strerror):
       logging.error("error writing to file %s (%d, %s)" % out, errno, strerror)
     if f:
       f.close()
     return True
 
   def SaveResults(self, path=None, verbose=False):
     ''' Output normalized data to baseline files for future comparison runs.
     Messages are saved in sorted order into a separate file for each message
     type.  See Message.NormalizedStr() for details of what's written.
     '''
     if not path:
-      path = self._data_dir
+      path = self._report_dir
     for key in self._message_lists:
       out = os.path.join(path, "%s_%s.txt" % (self._name, key))
       logging.info("saving %s" % (out))
       f = open(out, "w+")
       list = self._message_lists[key].UniqueMessages()
       # TODO(erikkay): should the count of each message be a diff factor?
       # (i.e. the same error shows up, but more frequently)
       for message in list:
         f.write(message.NormalizedStr(verbose=verbose))
         f.write("\n")
@@ skipping 60 matching lines @@
           msg += line
         else:
           # note that the hash doesn't include the title, see Message.__hash__
           h = hash(msg)
           msgs[h] = title + msg
           title = None
           msg = ""
       logging.info("%s: %d msgs" % (filename, len(msgs)))
     return msgs
 
-  def _SaveLatestGroupSummary(self, message_list):
-    '''Save a summary of message groups and their counts to a file in "latest"
+  def _SaveGroupSummary(self, message_list):
+    '''Save a summary of message groups and their counts to a file in report_dir
     '''
     string_list = []
     groups = message_list.UniqueMessageGroups()
     group_keys = groups.keys()
 
     group_keys.sort(cmp=lambda x,y: len(groups[y]) - len(groups[x]))
     for group in group_keys:
       string_list.append("%s: %d" % (group, len(groups[group])))
 
-    self.SaveLatestStrings(string_list, message_list.GetType(), "_GROUPS")
+    self.SaveStrings(string_list, message_list.GetType(), "_GROUPS")
 
   def CompareResults(self):
     ''' Compares the results from the current run with the baseline data
     stored in data/<name>_<key>.txt returning False if it finds new errors
     that are not in the baseline.  See ReadFile() and SaveResults() for
     details of what's in the original file and what's in the baseline.
     Errors that show up in the baseline but not the current run are not
     considered errors (they're considered "fixed"), but they do suggest
     that the baseline file could be re-generated.'''
     errors = 0
@@ skipping 57 matching lines @@
                      purify_message.GetMessageType(type), type,
                      len(type_errors), len(type_fixes)))
 
       if len(type_errors):
         strs = [current_hashes[x].NormalizedStr(verbose=True) 
                 for x in type_errors]
         logging.error("%d new '%s(%s)' errors found\n%s" % (len(type_errors),
                       purify_message.GetMessageType(type), type, 
                       '\n'.join(strs)))
         strs = [current_hashes[x].NormalizedStr() for x in type_errors]
-        self.SaveLatestStrings(strs, type, "_NEW")
+        self.SaveStrings(strs, type, "_NEW")
         errors += len(type_errors)
 
       if len(type_fixes):
         # we don't have access to the original message, so all we can do is log
         # the non-verbose normalized text
         logging.warning("%d new '%s(%s)' unexpected fixes found\n%s" % (
                         len(type_fixes), purify_message.GetMessageType(type), 
                         type, '\n'.join(type_fixes)))
-        self.SaveLatestStrings(type_fixes, type, "_FIXED")
+        self.SaveStrings(type_fixes, type, "_FIXED")
         fixes += len(type_fixes)
         if len(current_messages) == 0:
           logging.warning("all errors fixed in %s" % baseline_file)
 
       if len(type_fixes) or len(type_errors):
         strs = [baseline_hashes[x] for x in new_baseline]
-        self.SaveLatestStrings(strs, type, "_BASELINE")
+        self.SaveStrings(strs, type, "_BASELINE")
 
       if current_list:
-        self._SaveLatestGroupSummary(current_list)
+        self._SaveGroupSummary(current_list)
 
     if errors:
       logging.error("%d total new errors found" % errors)
       return -1
     else:
       logging.info("no new errors found - yay!")
       if fixes:
         logging.warning("%d total errors unexpectedly fixed" % fixes)
         # magic return code to turn the builder orange (via ReturnCodeCommand)
         return -88
@@ skipping 25 matching lines @@
   parser.add_option("-n", "--name",
                     help="name of the test being run "
                          "(used for output filenames)")
   parser.add_option("", "--data_dir",
                     help="path to where purify data files live")
   parser.add_option("", "--bug_report", default=False,
                     action="store_true",
                     help="print output as an attempted summary of bugs")
   parser.add_option("-v", "--verbose", action="store_true", default=False,
                     help="verbose output - enable debug log messages")
+  parser.add_option("", "--report_dir",
+                    help="path where report files are saved")
 
   (options, args) = parser.parse_args()
   if not len(args) >= 1:
     parser.error("no filename specified")
   filenames = args
 
   if options.verbose:
     google.logging_utils.config_root(level=logging.DEBUG)
   else:
     google.logging_utils.config_root(level=logging.INFO)
   pa = PurifyAnalyze(filenames, options.echo_to_stdout, options.name, 
-                     options.source_dir, options.data_dir)
+                     options.source_dir, options.data_dir, options.report_dir)
   execute_crash = not pa.ReadFile()
   if options.bug_report:
     pa.PrintBugReport()
     pa.PrintSummary(False)
   elif options.memory_in_use:
     pa.PrintMemoryInUse(int(options.byte_filter))
   elif execute_crash:
     retcode = -1
     logging.error("Fatal error during test execution.  Analysis skipped.")
   elif options.validate:
     if pa.CompareResults() != 0:
       retcode = -1
-      script_dir = google.path_utils.ScriptDir()
-      latest_dir = os.path.join(script_dir, "latest")
-      pa.SaveResults(latest_dir)
+      pa.SaveResults()
     pa.PrintSummary()
   elif options.baseline:
     if not pa.SaveResults(verbose=True):
       retcode = -1
     pa.PrintSummary(False)
   else:
     pa.PrintSummary(False)
 
   sys.exit(retcode)
 
 if __name__ == "__main__":
   _main()