Merge lp:~flimm/python-snippets/gtkcrashhandler into lp:~jonobacon/python-snippets/trunk

[David D Lowe]

[David D Lowe (flimm)]

gtkcrashhandler catches Python exceptions and displays a user-friendly error dialog.

To use, just add this code at the top of your main module:
import gtkcrashhandler
gtkcrashhandler.initialize()

If gtkcrashhandler.py is run, a test exception is thrown and caught.

[Jono Bacon (jonobacon)]

Thanks for the snippet, David! Do you think this should really be in the pygtk dir or would it make better sense to include it in an apport dir?

review: Needs Information

[David D Lowe (flimm)]

The Apport support is optional. I designed the module so that it would work perfectly in systems where Apport is not installed, like Debian.

The error dialog that is displayed is a GtkDialog, which is why I classified this under PyGTK. If PyGTK is not installed, an error message is printed to stderr, and the custom except hook is not activated.

So yes, I think it should be under the pygtk directory.

[Jono Bacon (jonobacon)]

On 03/02/10 03:51, David D Lowe wrote:
> The Apport support is optional. I designed the module so that it would work perfectly in systems where Apport is not installed, like Debian.
>
> The error dialog that is displayed is a GtkDialog, which is why I classified this under PyGTK. If PyGTK is not installed, an error message is printed to stderr, and the custom except hook is not activated.
>
> So yes, I think it should be under the pygtk directory.
>
Great. Sounds reasonable: I can also tag this under multiple categories
anyway. Thanks!

     Jono

--
Jono Bacon
Ubuntu Community Manager
www.ubuntu.com / www.jonobacon.org
www.identi.ca/jonobacon www.twitter.com/jonobacon

[lp:~flimm/python-snippets/gtkcrashhandler]

27. By Jono Bacon on 2010-03-02

Crash handler from David, thanks!

=== added file 'pygtk/gtkcrashhandler.py'
--- pygtk/gtkcrashhandler.py	1970-01-01 00:00:00 +0000
+++ pygtk/gtkcrashhandler.py	2010-03-01 18:44:14 +0000
@@ -0,0 +1,296 @@
+#!/usr/bin/env python
+#
+# [SNIPPET_NAME: GTK Crash Handler]
+# [SNIPPET_CATEGORIES: PyGTK]
+# [SNIPPET_DESCRIPTION: a custom except hook for your applications that catches Python exceptions and displays a GTK dialog]
+# [SNIPPET_AUTHOR: David D. Lowe <[e-mail]>]
+# [SNIPPET_LICENSE: MIT]
+#
+# Copyright 2010 David D. Lowe
+# All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+"""GTK except hook for your applications.
+To use, simply import this module and call gtkcrashhandler.initialize().
+Import this module before calling gtk.main().
+
+If gtkcrashhandler cannot import gtk, pygtk, pango or gobject,
+gtkcrashhandler will print a warning and use the default excepthook.
+
+If you're using multiple threads, use gtkcrashhandler_thread decorator."""
+
+import sys
+import os
+import time
+try:
+    import pygtk
+    pygtk.require("2.0") # not tested on earlier versions
+    import gtk
+    import pango
+    import gobject
+    _gtk_initialized = True
+except Exception:
+    print >> sys.stderr, "gtkcrashhandler could not load GTK 2.0"
+    _gtk_initialized = False
+import traceback
+from gettext import gettext as _
+import threading
+
+APP_NAME = None
+MESSAGE = _("We're terribly sorry. Could you help us fix the problem by " \
+		  "reporting the crash?")
+USE_APPORT = False
+
+_old_sys_excepthook = None # None means that initialize() has not been called
+						   # yet.
+
+def initialize(app_name=None, message=None, use_apport=False):
+    """Initialize the except hook built on GTK.
+
+    Keyword arguments:
+    app_name   -- The current application's name to be read by humans,
+                  untranslated.
+    message    -- A message that will be displayed in the error dialog,
+                  replacing the default message string. Untranslated.
+                  If you don't want a message, pass "".
+    use_apport -- If set to True, gtkcrashhandler will override the settings
+                  in /etc/default/apport and call apport if possible,
+                  silently failing if not.
+                  If set to False, the normal behaviour will be executed,
+                  which may mean Apport kicking in anyway.
+
+    """
+    global APP_NAME, MESSAGE, USE_APPORT, _gtk_initialized, _old_sys_excepthook
+    if app_name:
+    	APP_NAME = _(app_name)
+    if not message is None:
+    	MESSAGE = _(message)
+    if use_apport:
+    	USE_APPORT = use_apport
+    if _gtk_initialized == True and _old_sys_excepthook is None:
+        # save sys.excepthook first, as it may not be sys.__excepthook__
+        # (for example, it might be Apport's python hook)
+        _old_sys_excepthook = sys.excepthook
+        # replace sys.excepthook with our own
+        sys.excepthook = _replacement_excepthook
+
+
+def _replacement_excepthook(type, value, tracebk, thread=None):
+    """This function will replace sys.excepthook."""
+    # create traceback string and print it
+    tb = "".join(traceback.format_exception(type, value, tracebk))
+    if thread:
+        if not isinstance(thread, threading._MainThread):
+            tb = "Exception in thread %s:\n%s" % (thread.getName(), tb)
+    print >> sys.stderr, tb
+
+    # determine whether to add a "Report problem..." button
+    add_apport_button = False
+    global USE_APPORT
+    if USE_APPORT:
+    	# see if this file is from a properly installed distribution package
+        try:
+            from apport.fileutils import likely_packaged
+            try:
+                filename = os.path.realpath(os.path.join(os.getcwdu(),
+                	sys.argv[0]))
+            except:
+                filename = os.path.realpath("/proc/%i/exe" % os.getpid())
+            if not os.path.isfile(filename) or not os.access(filename, os.X_OK):
+                raise Exception()
+            add_apport_button = likely_packaged(filename)
+        except:
+            add_apport_button = False
+
+    res = show_error_window(tb, add_apport_button=add_apport_button)
+
+    if res == 3: # report button clicked
+        # enable apport, overriding preferences
+        try:
+            # create new temporary configuration file, where enabled=1
+            import re
+            from apport.packaging_impl import impl as apport_packaging
+            newconfiguration = "# temporary apport configuration file " \
+                        	   "by gtkcrashhandler.py\n\n"
+            try:
+                for line in open(apport_packaging.configuration):
+                    if re.search('^\s*enabled\s*=\s*0\s*$', line) is None:
+                        newconfiguration += line
+            finally:
+                newconfiguration += "enabled=1"
+            import tempfile
+            tempfile, tempfilename = tempfile.mkstemp()
+            os.write(tempfile, newconfiguration)
+            os.close(tempfile)
+
+            # set apport to use this configuration file, temporarily
+            apport_packaging.configuration = tempfilename
+            # override Apport's ignore settings for this app
+            from apport.report import Report
+            Report.check_ignored = lambda self: False
+        except:
+            pass
+
+    if res in (2, 3): # quit
+        sys.stderr = os.tmpfile()
+        global _old_sys_excepthook
+        _old_sys_excepthook(type, value, tracebk)
+        sys.stderr = sys.__stderr__
+        os._exit(1)
+
+def show_error_window(error_string, add_apport_button=False):
+    """Displays an error dialog, and returns the response ID.
+
+    error_string       -- the error's output (usually a traceback)
+    add_apport_button  -- whether to add a 'report with apport' button
+
+    Returns the response ID of the dialog, 1 for ignore, 2 for close and
+    3 for apport.
+    """
+    # initialize dialog
+    title = _("An error has occurred")
+    global APP_NAME
+    if APP_NAME:
+        title = APP_NAME
+    dialog = gtk.Dialog(title)
+
+    # title Label
+    label = gtk.Label()
+    label.set_markup("<b>" + _("It looks like an error has occurred.") + "</b>")
+    label.set_alignment(0, 0.5)
+    dialog.get_content_area().pack_start(label, False)
+
+    # message Label
+    global MESSAGE
+    text_label = gtk.Label(MESSAGE)
+    text_label.set_alignment(0, 0.5)
+    
+    text_label.set_line_wrap(True)
+    def text_label_size_allocate(widget, rect):
+        """Lets label resize correctly while wrapping text."""
+        widget.set_size_request(rect.width, -1)
+    text_label.connect("size-allocate", text_label_size_allocate)
+    if not MESSAGE == "":
+        dialog.get_content_area().pack_start(text_label, False)
+
+    # TextView with error_string
+    buffer = gtk.TextBuffer()
+    buffer.set_text(error_string)
+    textview = gtk.TextView()
+    textview.set_buffer(buffer)
+    textview.set_editable(False)
+    try:
+        textview.modify_font(pango.FontDescription("monospace 8"))
+    except Exception:
+        print >> sys.stderr, "gtkcrashhandler: modify_font raised an exception"
+
+    # allow scrolling of textview
+    scrolled = gtk.ScrolledWindow()
+    scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+    scrolled.add_with_viewport(textview)
+
+    # hide the textview in an Expander widget
+    expander = gtk.expander_new_with_mnemonic(_("_Details"))
+    expander.add(scrolled)
+    dialog.get_content_area().pack_start(expander, False)
+
+    # add buttons
+    if add_apport_button:
+        dialog.add_button(_("_Report this problem..."), 3)
+    # If we're have multiple threads, or if we're in a GTK callback,
+    # execution can continue normally in other threads, so add button
+    if gtk.main_level() > 0 or threading.activeCount() > 1:
+        dialog.add_button(_("_Ignore the error"), 1)
+    dialog.add_button(("_Close the program"), 2)
+    dialog.set_default_response(2)
+
+    # set dialog aesthetic preferences
+    dialog.set_border_width(12)
+    dialog.get_content_area().set_spacing(4)
+    dialog.set_resizable(False)
+
+    # show the dialog and act on it
+    dialog.show_all()
+    res = dialog.run()
+    dialog.destroy()
+    if res < 0:
+        res = 2
+    return res
+
+
+def gtkcrashhandler_thread(run):
+    """gtkcrashhandler_thread is a decorator for the run() method of 
+    threading.Thread.
+
+    If you forget to use this decorator, exceptions in threads will be
+    printed to standard error output, and GTK's main loop will continue to run.
+
+    #Example 1:
+    class ExampleThread(threading.Thread):
+        @gtkcrashhandler_thread
+        def run(self):
+            1 / 0 # this error will be caught by gtkcrashhandler
+
+    #Example 2:
+    def function(arg):
+        arg / 0 # this error will be caught by gtkcrashhandler
+    threading.Thread(target=gtkcrashhandler_thread(function), args=(1,)).start()
+    """
+    def gtkcrashhandler_wrapped_run(*args, **kwargs):
+        try:
+            run(*args, **kwargs)
+        except Exception, ee:
+            lock = threading.Lock()
+            lock.acquire()
+            tb = sys.exc_info()[2]
+            if gtk.main_level() > 0:
+                gobject.idle_add(
+                    lambda ee=ee, tb=tb, thread=threading.currentThread():
+                    _replacement_excepthook(ee.__class__,ee,tb,thread=thread))
+            else:
+                time.sleep(0.1) # ugly hack, seems like threads that are
+                                # started before running gtk.main() cause
+                                # this one to crash.
+                                # This delay allows gtk.main() to initialize
+                                # properly.
+                                # My advice: run gtk.main() before starting
+                                # any threads or don't run gtk.main() at all
+                _replacement_excepthook(ee.__class__, ee, tb,
+                                        thread=threading.currentThread())
+            lock.release()
+    # return wrapped run if gtkcrashhandler has been initialized
+    global _gtk_initialized, _old_sys_excepthook
+    if _gtk_initialized and _old_sys_excepthook:
+        return gtkcrashhandler_wrapped_run
+    else:
+        return run
+
+if __name__ == "__main__":
+    # throw test exception
+    initialize(app_name="gtkcrashhandler", message="Don't worry, though. This "
+    	"is just a test. To use the code properly, call "
+    	"gtkcrashhandler.initialize() in your PyGTK app to automatically catch "
+    	" any Python exceptions like this.")
+    class DoNotRunException(Exception):
+        def __str__(self):
+            return "gtkcrashhandler.py should imported, not run"
+    raise DoNotRunException()
+