Add more debugging support to coredump archiving code

tools/utils.py

 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 # This file contains a set of utilities functions used by other Python-based
 # scripts.
 
 import commands
 import contextlib
 import datetime
@@ skipping 682 matching lines @@
     os.chdir(self._old_cwd)
 
 
 class UnexpectedCrash(object):
   def __init__(self, test, pid, binary):
     self.test = test
     self.pid = pid
     self.binary = binary
 
   def __str__(self):
-    return "%s: %s %s" % (self.test, self.binary, self.pid)
+    return "Crash(%s: %s %s)" % (self.test, self.binary, self.pid)
 
 class SiteConfigBotoFileDisabler(object):
   def __init__(self):
     self._old_aws = None
     self._old_boto = None
 
   def __enter__(self):
     self._old_aws = os.environ.get('AWS_CREDENTIAL_FILE', None)
     self._old_boto = os.environ.get('BOTO_CONFIG', None)
 
@@ skipping 110 matching lines @@
 
 class BaseCoreDumpArchiver(object):
   """This class reads coredumps file written by UnexpectedCrashDumpArchiver
   into the current working directory and uploads all cores and binaries
   listed in it into Cloud Storage (see tools/testing/dart/test_progress.dart).
   """
 
   # test.dart will write a line for each unexpected crash into this file.
   _UNEXPECTED_CRASHES_FILE = "unexpected-crashes"
 
-  def __init__(self):
+  def __init__(self, search_dir):
     self._bucket = 'dart-temp-crash-archive'
     self._binaries_dir = os.getcwd()
+    self._search_dir = search_dir
 
   def __enter__(self):
     # Cleanup any stale files
     if self._cleanup():
       print "WARNING: Found and removed stale coredumps"
 
   def __exit__(self, *_):
     try:
       crashes = self._find_unexpected_crashes()
       if crashes:
@@ skipping 17 matching lines @@
     files = set()
     missing = []
     for crash in crashes:
       files.add(crash.binary)
       core = self._find_coredump_file(crash)
       if core:
         files.add(core)
       else:
         missing.append(crash)
     self._upload(files)
+
     if missing:
-      raise Exception('Missing crash dumps for: %s' % ', '.join(
-          [str(c) for c in missing]))
+      self._report_missing_crashes(missing, throw=True)
+
+  def _report_missing_crashes(self, missing, throw=True):
+    missing_as_string = ', '.join([str(c) for c in missing])
+    other_files = list(glob.glob(os.path.join(self._search_dir, '*')))
+    print >> sys.stderr, (
+        "Could not find crash dumps for '%s' in search directory '%s'.\n"
+        "Existing files which *did not* match the pattern inside the search "
+        "directory are are:\n  %s"
+        % (missing_as_string, self._search_dir, '\n  '.join(other_files)))
+    if throw:
+      raise Exception('Missing crash dumps for: %s' % missing_as_string)
 
   def _upload(self, files):
     bot_utils = GetBotUtils()
     gsutil = bot_utils.GSUtil()
     storage_path = '%s/%s/' % (self._bucket, uuid.uuid4())
     gs_prefix = 'gs://%s' % storage_path
     http_prefix = 'https://storage.cloud.google.com/%s' % storage_path
 
     print '\n--- Uploading into %s (%s) ---' % (gs_prefix, http_prefix)
     for file in files:
@@ skipping 40 matching lines @@
     if os.path.exists(BaseCoreDumpArchiver._UNEXPECTED_CRASHES_FILE):
       os.unlink(BaseCoreDumpArchiver._UNEXPECTED_CRASHES_FILE)
       found = True
     for binary in glob.glob(os.path.join(self._binaries_dir, 'binary.*')):
       found = True
       os.unlink(binary)
     return found
 
 class LinuxCoreDumpArchiver(BaseCoreDumpArchiver):
   def __init__(self):
-    super(self.__class__, self).__init__()
-    self._search_dir = os.getcwd()
+    super(self.__class__, self).__init__(os.getcwd())
 
   def _cleanup(self):
     found = super(self.__class__, self)._cleanup()
     for core in glob.glob(os.path.join(self._search_dir, 'core.*')):
       found = True
       os.unlink(core)
     return found
 
   def _find_coredump_file(self, crash):
     core_filename = os.path.join(self._search_dir, 'core.%s' % crash.pid)
     if os.path.exists(core_filename):
       return core_filename
 
 class WindowsCoreDumpArchiver(BaseCoreDumpArchiver):
   def __init__(self):
-    super(self.__class__, self).__init__()
-    self._search_dir = os.path.join(
-        os.getcwd(), WindowsCoredumpEnabler.WINDOWS_COREDUMP_FOLDER)
+    super(self.__class__, self).__init__(os.path.join(
+        os.getcwd(), WindowsCoredumpEnabler.WINDOWS_COREDUMP_FOLDER))
 
   def _cleanup(self):
     found = super(self.__class__, self)._cleanup()
     for core in glob.glob(os.path.join(self._search_dir, '*')):
       found = True
       os.unlink(core)
     return found
 
   def _find_coredump_file(self, crash):
     pattern = os.path.join(self._search_dir, '*.%s.*' % crash.pid)
     for core_filename in glob.glob(pattern):
       return core_filename
 
+  def _report_missing_crashes(self, missing, throw=True):
+    # Let's only print the debugging information and not throw. We'll do more
+    # validation for werfault.exe and throw afterwards.
+    super(self.__class__, self)._report_missing_crashes(missing, throw=False)
+
+    # Let's check again for the image execution options for werfault. Maybe
+    # puppet came a long during testing and reverted our change.
+    try:
+      import winreg
+    except ImportError:
+      import _winreg as winreg
+    for wowbit in [winreg.KEY_WOW64_64KEY, winreg.KEY_WOW64_32KEY]:
+      try:
+         with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
+                             WindowsCoredumpEnabler.IMGEXEC_NAME,
+                             0,
+                             winreg.KEY_READ | wowbit) as handle:
+          raise Exception(
+              "Found werfault.exe was disabled. Probably by puppet. Too bad")
+      except OSError:
+        # If the open did not work the werfault.exe execution setting is as it
+        # should be.
+        pass
+
+    if throw:
+      missing_as_string = ', '.join([str(c) for c in missing])
+      raise Exception('Missing crash dumps for: %s' % missing_as_string)
+
 @contextlib.contextmanager
 def NooptCoreDumpArchiver():
   yield
 
 
 def CoreDumpArchiver(args):
   enabled = '--copy-coredumps' in args
 
   if not enabled:
     return NooptCoreDumpArchiver()
 
   osname = GuessOS()
   if osname == 'linux':
     return contextlib.nested(PosixCoredumpEnabler(),
                              LinuxCoreDumpArchiver())
   elif osname == 'win32':
     return contextlib.nested(WindowsCoredumpEnabler(),
                              WindowsCoreDumpArchiver())
   else:
     # We don't have support for MacOS yet.
     assert osname == 'macos'
     return NooptCoreDumpArchiver()
 
 if __name__ == "__main__":
   import sys
   Main()