Add support for core dump archiving on macos

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 704 matching lines @@
       del os.environ['AWS_CREDENTIAL_FILE']
     if self._old_boto:
       del os.environ['BOTO_CONFIG']
 
   def __exit__(self, *_):
     if self._old_aws:
       os.environ['AWS_CREDENTIAL_FILE'] = self._old_aws
     if self._old_boto:
       os.environ['BOTO_CONFIG'] = self._old_boto
 
-class PosixCoredumpEnabler(object):
+class PosixCoreDumpEnabler(object):
   def __init__(self):
     self._old_limits = None
 
   def __enter__(self):
     self._old_limits = resource.getrlimit(resource.RLIMIT_CORE)
-
-    # Bump core limits to unlimited if core_pattern is correctly configured.
-    if CheckLinuxCoreDumpPattern(fatal=False):
-      resource.setrlimit(resource.RLIMIT_CORE, (-1, -1))
+    resource.setrlimit(resource.RLIMIT_CORE, (-1, -1))
 
   def __exit__(self, *_):
     resource.setrlimit(resource.RLIMIT_CORE, self._old_limits)
+
+class LinuxCoreDumpEnabler(PosixCoreDumpEnabler):
+  def __enter__(self):
+    # Bump core limits to unlimited if core_pattern is correctly configured.
+    if CheckLinuxCoreDumpPattern(fatal=False):
+      super(LinuxCoreDumpEnabler, self).__enter__()
+
+  def __exit__(self, *args):
     CheckLinuxCoreDumpPattern(fatal=True)
+    super(LinuxCoreDumpEnabler, self).__exit__(*args)
 
-class WindowsCoredumpEnabler(object):
+class WindowsCoreDumpEnabler(object):
   """Configure Windows Error Reporting to store crash dumps.
 
   The documentation can be found here:
   https://msdn.microsoft.com/en-us/library/windows/desktop/bb787181.aspx
   """
 
   WINDOWS_COREDUMP_FOLDER = r'crashes'
 
   WER_NAME = r'SOFTWARE\Microsoft\Windows\Windows Error Reporting'
   WER_LOCALDUMPS_NAME = r'%s\LocalDumps' % WER_NAME
@@ skipping 22 matching lines @@
             self.winreg.KEY_ALL_ACCESS | sam) as wer:
         with self.winreg.CreateKeyEx(
             self.winreg.HKEY_LOCAL_MACHINE, self.WER_LOCALDUMPS_NAME, 0,
             self.winreg.KEY_ALL_ACCESS | sam) as wer_localdumps:
           # Prevent any modal UI dialog & disable normal windows error reporting
           # TODO(kustermann): Remove this once https://crbug.com/691971 is fixed
           self.winreg.SetValueEx(wer, "DontShowUI", 0, self.winreg.REG_DWORD, 1)
           self.winreg.SetValueEx(wer, "Disabled", 0, self.winreg.REG_DWORD, 1)
 
           coredump_folder = os.path.join(
-              os.getcwd(), WindowsCoredumpEnabler.WINDOWS_COREDUMP_FOLDER)
+              os.getcwd(), WindowsCoreDumpEnabler.WINDOWS_COREDUMP_FOLDER)
 
           # Create the directory which will contain the dumps
           if not os.path.exists(coredump_folder):
             os.mkdir(coredump_folder)
 
           # Do full dumps (not just mini dumps), keep max 100 dumps and specify
           # folder.
           self.winreg.SetValueEx(
               wer_localdumps, "DumpType", 0, self.winreg.REG_DWORD, 2)
           self.winreg.SetValueEx(
@@ skipping 143 matching lines @@
   def _cleanup(self):
     found = False
     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__(os.getcwd())
+class PosixCoreDumpArchiver(BaseCoreDumpArchiver):
+  def __init__(self, search_dir):
+    super(PosixCoreDumpArchiver, self).__init__(search_dir)
 
   def _cleanup(self):
-    found = super(self.__class__, self)._cleanup()
+    found = super(PosixCoreDumpArchiver, self)._cleanup()
     for core in glob.glob(os.path.join(self._search_dir, 'core.*')):
       found = True
-      os.unlink(core)
+      try:
+        os.unlink(core)
+      except:
+        pass
     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 LinuxCoreDumpArchiver(PosixCoreDumpArchiver):
+  def __init__(self):
+    super(LinuxCoreDumpArchiver, self).__init__(os.getcwd())
+
+class MacOSCoreDumpArchiver(PosixCoreDumpArchiver):
+  def __init__(self):
+    super(MacOSCoreDumpArchiver, self).__init__('/cores')
+
 class WindowsCoreDumpArchiver(BaseCoreDumpArchiver):
   def __init__(self):
-    super(self.__class__, self).__init__(os.path.join(
-        os.getcwd(), WindowsCoredumpEnabler.WINDOWS_COREDUMP_FOLDER))
+    super(WindowsCoreDumpArchiver, self).__init__(os.path.join(
+        os.getcwd(), WindowsCoreDumpEnabler.WINDOWS_COREDUMP_FOLDER))
 
   def _cleanup(self):
-    found = super(self.__class__, self)._cleanup()
+    found = super(WindowsCoreDumpArchiver, 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)
+    super(WindowsCoreDumpArchiver, 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,
+                             WindowsCoreDumpEnabler.IMGEXEC_NAME,
                              0,
                              winreg.KEY_READ | wowbit) as handle:
           raise Exception(
               "Found werfault.exe was disabled. Probably by puppet. Too bad! "
               "(For more information see https://crbug.com/691971)")
       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(),
+    return contextlib.nested(LinuxCoreDumpEnabler(),
                              LinuxCoreDumpArchiver())
+  elif osname == 'macos':
+    return contextlib.nested(PosixCoreDumpEnabler(),
+                             MacOSCoreDumpArchiver())
   elif osname == 'win32':
-    return contextlib.nested(WindowsCoredumpEnabler(),
+    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()