path: root/abrt-triage.py

#!/usr/bin/env python
from pprint import pprint
import re

from backtrace import Backtrace

class Bug(object):
    def __init__(self, bz, id):
        self.bz = bz
        self.id = id
        self._bug = bz.getbug(id)

    def get_backtrace(self):
        # Get the backtrace associated with this ABRT bug, as a Backtrace instance
        a = self._get_backtrace_info()
        if a is None:
            raise NoBacktrace()
        return Backtrace(self.bz.openattachment(a['id']).read())

    def _get_backtrace_info(self):
        for a in self._bug.attachments:
            if a['filename'] == 'backtrace':
                return a

    def get_script(self):
        '''Parse the ABRT report, extracting the script'''
        # print repr(self._bug.longdescs[0]['body'])
        for line in self._bug.longdescs[0]['body'].splitlines():
            m = re.match('cmdline: (.+)', line)
            if m:
                for arg in m.group(1).split()[1:]:
                    if arg.startswith('/'):
                        return arg

    def get_abrt_reason(self):
        for line in self._bug.longdescs[0]['body'].splitlines():
            m = re.match('reason: (.+)', line)
            if m:
                return m.group(1)

    def get_abrt_signal(self):
        reason = self.get_abrt_reason()
        if reason is None:
            return

        m = re.match('Process was terminated by signal ([0-9]+)', reason)
        if m:
            sig = int(m.group(1))
            import signal
            for signame in dir(signal):
                if signame.startswith('SIG'):
                    if getattr(signal, signame) == sig:
                        return signame
            
class NoBacktrace(Exception):
    pass

class UnsupportedComponent(Exception):
    def __init__(self, path, url):
        self.path = path
        self.url = url

def describe_thread(bt, thread):
    if len(bt._threads) == 1:
        return "the program's single thread"
    else:
        return "thread #%i" % thread.index


def characterize_bt(bt, thread, script):
    '''Get (newsubject, commentblurb)'''
    bt_blurb = 'Looking at the backtrace, it looks like '
    function = None
    for (i, frame) in enumerate(thread.framelist):
        # Get function name for deepest point in stack that has one:
        if function is None or function == '??' or function == 'vtable':            
            function = frame.function

        if frame.function == 'abort':
            # print 'got abort!'
            for j in range(i, len(thread.framelist)):
                if thread.framelist[j].function == 'gdk_x_error':
                    return ('Fatal error in gdk_x_error running %s' % script, 
                            (bt_blurb + 'a fatal error happened in frame %(f_idx)s of %(thread)s inside gdk_x_error.'
                             % dict(thread = describe_thread(bt, thread),
                                    f_idx = j)
                             )
                            )

                if thread.framelist[j].function == '__assert_fail':
                    return (('Assertion failure in %s inside %s running %s'
                             % (thread.framelist[j+1].function,
                                thread.framelist[j+2].function,
                                script)
                             ),
                            (bt_blurb + 'an assertion failed inside frame %(f_idx)s of %(thread)s inside %(function)s.'
                             % dict(thread = describe_thread(bt, thread),
                                    f_idx = j,
                                    function = thread.framelist[j+1].function)
                             )
                            )

        if frame.function in ['_XError', '__fortify_fail']:
            function = frame.function
 
        if frame.function in ['IA__g_assertion_message_expr']:
            function = thread.framelist[i+1].function

        if frame.function == 'Py_FatalError':
            if thread.framelist[i+1].function == 'PyEval_RestoreThread':
                    return (('Incorrect thread usage in %s running %s'
                             % (thread.framelist[i+2].function,
                                script)
                             ),
                            (bt_blurb + "an incorrect usage of Python's internal thread API was detected in %(function)s in frame #%(f_idx)s of %(thread)s"
                             % dict(function = thread.framelist[i+2].function,
                                    thread = describe_thread(bt, thread),
                                    f_idx = i+2)
                             )
                            )

        if frame.info == '() from /usr/lib/flash-plugin/libflashplayer.so':
            raise UnsupportedComponent('/usr/lib/flash-plugin/libflashplayer.so', 
                                       'https://fedoraproject.org/wiki/ForbiddenItems#Adobe_Flash_Player')

    bt_blurb += 'the problem occurred in %s' % describe_thread(bt, thread)
    if function:
        bt_blurb += ' in %s' % function

    if function:
        summary = 'Fatal error in "%s" in %s' % (function, script)
    else:
        summary = 'Fatal error in %s' % script

    return (summary, bt_blurb)


def what_provides_file(path):
    #from subprocess import Popen, PIPE
    #p = Popen(['yum', 'whatprovides', path], stdout=PIPE)
    #(stdout, stderr) = p.communicate()
    #print repr(stdout)
    import yum
    for pkg, path in yum.YumBase().searchPackageProvides([path]).iteritems():
        #pprint(pkg.__dict__)
        return pkg.name # this is the subpackage, not the srpm

class Change(object):
    '''
    Class representing a change to be made in Bugzilla.

    Somewhat analogous to a patch to be applied to a source tree.

    Currently only supports printing, but eventually ought to support being
    applied to the bug.

    I want to capture a change as an entity so that you can always do human
    review of the change, rather than automatically pushing blindly via XML-RPC
    '''
    def __init__(self, 
                 newsummary=None,
                 newcomponent=None,
                 comment=None,
                 duplicate_id=None):
        self.comment = comment
        self.newsummary = newsummary
        self.newcomponent = newcomponent
        self.duplicate_id = duplicate_id

    def __str__(self):
        result = ''
        if self.newsummary:
            result += '---- BEGIN SUMMARY ----\n'
            result += self.newsummary
            result += '\n---- END SUMMARY ----\n'

        if self.newcomponent:
            result += '---- BEGIN COMPONENT ----\n'
            result += '"python" -> "%s"\n' % self.newcomponent # is there a way to do this via XML-RPC?
            result += '---- END COMPONENT ----\n'

        if self.comment:
            result += '---- BEGIN COMMENT ----\n'
            result += self.comment
            result += '\n---- END COMMENT ----\n'

        if self.duplicate_id:
            result += '---- MARK AS DUPLICATE OF: %i ----\n' % self.duplicate_id

        return result

class Duplicate(Change):
    def __init__(self, bz, other_bug_id):
        Change.__init__(self, 
                        comment=(
'''Thank you for the bug report. 

This particular bug has already been reported into our bug tracking system, but please feel free to report any further bugs you find.'''),
                        duplicate_id = other_bug_id
                        )                 

def get_change(bz, bug_id):
    bug = Bug(bz, bug_id)

    signal = bug.get_abrt_signal()
    if signal:
        issue = signal
    else:
        issue = 'Crash'

    script = bug.get_script() 
    # script = '/usr/bin/deluged'
    if script:
        pkg = what_provides_file(script)
    else:
        pkg = '(unknown)'

    try:
        bt = bug.get_backtrace()
        (thread, frame) = bt.get_crash_site()
        (newsummary, bt_blurb) = characterize_bt(bt, thread, script)

    except NoBacktrace, e:
        return Change(newsummary='%s running %s' % (issue, script),
                      newcomponent = pkg,
                      comment=('''Thank you for the bug report. 

Unfortunately, without a stack trace from the crash it is impossible to determine what caused the crash. Please see http://fedoraproject.org/wiki/StackTraces for more information about getting a useful stack trace with debugging symbols. Even if you cannot reproduce this crash at will, you can prepare your system now to produce a good stack trace the next time you experience the crash. 

Thank you.
''')
                      )
    except UnsupportedComponent, e:
        return Change(newsummary='%s in %s' % (issue, e.path),
                      comment=('''Thank you for the bug report.

Unfortunately the problem appears to be in %(path)s. 

The Fedora Project only ships and maintains Free and Open Source software. Issues such as these are beyond the control of Fedora developers.  See %(url)s for more information

You may find assistance in the Fedora community support forums or mailing list, or you might consider using a commercially supported product.''' 
                               % dict(path=e.path,
                                      url=e.url)
                               )
                      )

    comment = '''Thank you for reporting this bug.

How reproducable is this problem?  If you run the program from a terminal, is an error message printed?

What version of %(pkg)s do you have installed?

%(bt_blurb)s

Reassigning component from "python" to "%(pkg)s"
''' % dict(pkg=pkg,
           bt_blurb = bt_blurb)

    if newsummary == 'Fatal error in "_XError" in /usr/share/virt-manager/virt-manager.py':
        return Duplicate(bz, 540810)

    ch = Change(newsummary = newsummary,
                newcomponent = pkg,
                comment = comment
                )
    
    print ch
    print '---- BEGIN THREAD ----'
    for id in sorted(thread.frames.keys()):
        f = thread.frames[id]
        if f.address:
            addr = hex(f.address)
        else:
            addr = None
        print '#%i %s %s' % (id, addr, f.function)
    print '---- END THREAD ----'

def main():
    import bugzilla
    bz=bugzilla.Bugzilla(url='https://bugzilla.redhat.com/xmlrpc.cgi')
    import sys
    bug_id = int(sys.argv[1])
    print '---- CHANGES FOR BUG %i ----' % bug_id
    print get_change(bz, bug_id)

main()