ubuntu-bots/Bugtracker/plugin.py

# -*- Encoding: utf-8 -*-
###
# Copyright (c) 2005-2007 Dennis Kaarsemaker
# Copyright (c) 2008-2010 Terence Simpson
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of version 2 of the GNU General Public License as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
###

from supybot.commands import *
import supybot.utils as utils
import supybot.ircmsgs as ircmsgs
import supybot.ircutils as ircutils
import supybot.callbacks as callbacks
import supybot.conf as conf
import supybot.registry as registry
import supybot.schedule as schedule
import supybot.log as supylog

#import imaplib
import re, os, time, commands
import xml.dom.minidom as minidom
from htmlentitydefs import entitydefs as entities
import email.FeedParser
import SOAPpy

# All the words below will be censored when reporting bug information
bad_words = set(["fuck","fuk","fucking","fuking","fukin","fuckin","fucked","fuked","fucker","shit","cunt","bastard","nazi","nigger","nigga","cock","bitches","bitch"])

def makeClean(s):
    words = s.split()
    for word in words:
        if word.lower() in bad_words:
            words[words.index(word)] = "<censored>"
    return " ".join(words)

def registerBugtracker(name, url='', description='', trackertype=''):
    conf.supybot.plugins.Bugtracker.bugtrackers().add(name)
    group       = conf.registerGroup(conf.supybot.plugins.Bugtracker.bugtrackers, name)
    URL         = conf.registerGlobalValue(group, 'url', registry.String(url, ''))
    DESC        = conf.registerGlobalValue(group, 'description', registry.String(description, ''))
    TRACKERTYPE = conf.registerGlobalValue(group, 'trackertype', registry.String(trackertype, ''))
    if url:
        URL.setValue(url)
    if description:
        DESC.setValue(description)
    if trackertype:
        if defined_bugtrackers.has_key(trackertype.lower()):
            TRACKERTYPE.setValue(trackertype.lower())
        else:
            raise BugtrackerError("Unknown trackertype: %s" % trackertype)
            
entre = re.compile('&(\S*?);')
def _getnodetxt(node):
    L = []
    for childnode in node.childNodes:
        if childnode.nodeType == childnode.TEXT_NODE:
            L.append(childnode.data)
    val = ''.join(L)
    if node.hasAttribute('encoding'):
        encoding = node.getAttribute('encoding')
        if encoding == 'base64':
            try:
                val = val.decode('base64')
            except:
                val = 'Cannot convert bug data from base64.'
    while entre.search(val):
        entity = entre.search(val).group(1)
        if entity in entities:
            val = entre.sub(entities[entity], val)
        else:
            val = entre.sub('?', val)
    return val

class BugtrackerError(Exception):
    """A bugtracker error"""
    pass

class BugNotFoundError(Exception):
    """Pity, bug isn't there"""
    pass

cvere = re.compile(r'<th.*?Description.*?<td.*?>(.*?)\s*</td>', re.I | re.DOTALL)
class Bugtracker(callbacks.PluginRegexp):
    """Show a link to a bug report with a brief description"""
    threaded = True
    callBefore = ['URL']
    regexps = ['turlSnarfer', 'bugSnarfer', 'oopsSnarfer', 'cveSnarfer']

    def __init__(self, irc):
        callbacks.PluginRegexp.__init__(self, irc)
        self.db = ircutils.IrcDict()
#        self.events = []
        for name in self.registryValue('bugtrackers'):
            registerBugtracker(name)
            group = self.registryValue('bugtrackers.%s' % name.replace('.','\\.'), value=False)
            if group.trackertype() in defined_bugtrackers.keys():
                self.db[name] = defined_bugtrackers[group.trackertype()](name, group.url(), group.description())
            else:
                self.log.warning("Bugtracker: Unknown trackertype: %s (%s)" % (group.trackertype(), name))
        self.shorthand = utils.abbrev(self.db.keys())
        self.shown = {}

#        # Schedule bug reporting
#        #TODO: Remove everything below this line
#        if self.registryValue('imap_server') and self.registryValue('reportercache'):
#            try:
#                schedule.removeEvent(self.name() + '.bugreporter')
#            except:
#                pass
#            schedule.addPeriodicEvent(lambda: self.reportnewbugs(irc),  60, name=self.name() + '.bugreporter')
#            self.events += [self.name() + '.bugreporter']
#            self.log.info('Bugtracker: Adding scheduled event "%s.bugreporter"' % self.name())

    def die(self): #TODO: Remove me
        pass
#        try:
#           for event in self.events:
#                self.log.info('Bugtracker: Removing scheduled event "%s"' % event)
#                schedule.removeEvent(event)
#                schedule.removeEvent(self.name())
#        except:
#            pass

    def is_ok(self, channel, tracker, bug):
        '''Flood/repeat protection'''
        now = time.time()
        for k in self.shown.keys():
            if self.shown[k] < now - self.registryValue('repeatdelay', channel):
                self.shown.pop(k)
        if (channel, tracker, bug) not in self.shown:
            self.shown[(channel, tracker, bug)] = now
            return True
        return False

    def is_new(self, tracker, tag, id): #Depricated
        pass
#        bugreporter_base = self.registryValue('reportercache')
#        if not os.path.exists(os.path.join(bugreporter_base,tag,tracker.name,str(int(id/1000)),str(id))):
#            try:
#                os.makedirs(os.path.join(bugreporter_base,tag,tracker.name,str(int(id/1000))))
#            except:
#                pass
#            fd = open(os.path.join(bugreporter_base,tag,tracker.name,str(int(id/1000)),str(id)),'w')
#            fd.close()
#            return True
#        return False

    def reportnewbugs(self,irc): #Depricated
        pass
#        # Compile list of bugs
#        self.log.info("Bugtracker: Checking for new bugs")
#        bugs = {}
#        if self.registryValue('imap_ssl'):
#            sc = imaplib.IMAP4_SSL(self.registryValue('imap_server'))
#        else:
#            sc = imaplib.IMAP4(self.registryValue('imap_server'))
#        sc.login(self.registryValue('imap_user'), self.registryValue('imap_password'))
#        sc.select('INBOX')
#        new_mail = sc.search(None, '(UNSEEN)')[1][0].split()[:20]
#
#        # Read all new mail
#        for m in new_mail:
#            msg = sc.fetch(m, 'RFC822')[1][0][1]
#            fp = email.FeedParser.FeedParser()
#            sc.store(m, '+FLAGS', "(\Deleted)") # Mark message deleted so we don't have to process it again
#            fp.feed(msg)
#            bug = fp.close()
#            tag = None
#
#            if 'X-Launchpad-Bug' not in bug.keys():
#                self.log.info('Bugtracker: Ignoring e-mail with no detectable bug (Not from Launchpad)')            
#                continue
#            else:
#                tag = bug['X-Launchpad-Bug']
#                if 'distribution=' not in tag and 'product=' not in tag:
#                   self.log.info('Bugtracker: Ignoring e-mail with no detectable bug (no distro/product)')
#                    continue
#                else:
#                    tag = tag.split(';')[0].strip().replace("product=",'').replace("distribution=","")
#
#            if not tag:
#                self.log.info('Bugtracker: Ignoring e-mail with no detectible bug (bad tag)')
#
#            tag = tag[tag.find('+')+1:tag.find('@')]
#            if tag not in bugs:
#                bugs[tag] = {}
#
#            # Determine bugtracker type (currently only Launchpad is supported anyway)
#            if bug['X-Launchpad-Bug']:
#                tracker = self.db['launchpad']
#                id = int(bug['Reply-To'].split()[1])
#                subj = bug['Subject'];
#                if '[NEW]' not in subj: #Not a new bug
#                    continue
#                if self.is_new(tracker, tag, id):
#                    component = bug['X-Launchpad-Bug']
#                    if 'component' in component:
#                        component = component[component.find('component=')+10:]
#                        component = component[:component.find(';')].replace('None','')
#                    else:
#                        component = ''
#                    try:
#                        if component:
#                            bugs[tag][id] = self.get_bug('',tracker, id, False)[0].replace('"','(%s) "' % component, 1)
#                        else:
#                            bugs[tag][id] = self.get_bug('',tracker, id, False)[0]
#                        if '[apport]' in bugs[tag][id]:
#                            bugs[tag].pop(id)
#                    except:
#                        self.log.info("Bugtracker: Unable to get new bug %d" % id)
#                        pass
#            else:
#                self.log.info('Bugtracker: Ignoring e-mail with no detectable bug')
#
#        reported_bugs = 0
#
#        for c in irc.state.channels:
#            tags = self.registryValue('bugReporter', channel=c)
#            if not tags:
#                continue
#            for tag in tags.split(','):
#                if not tag or tag not in bugs.keys():
#                    continue
#                for b in sorted(bugs[tag].keys()):
#                    irc.queueMsg(ircmsgs.privmsg(c,'New bug: #%s' % bugs[tag][b][bugs[tag][b].find('bug ')+4:]))
#                    reported_bugs = reported_bugs+1

    def add(self, irc, msg, args, name, trackertype, url, description):
        """<name> <type> <url> [<description>]

        Add a bugtracker <url> to the list of defined bugtrackers. <type> is the
        type of the tracker (currently only Launchpad, Debbugs, Bugzilla,
        Issuezilla, Mantis and Trac are known). <name> is the name that will be used to
        reference the bugzilla in all commands. Unambiguous abbreviations of
        <name> will be accepted also.  <description> is the common name for the
        bugzilla and will be listed with the bugzilla query; if not given, it
        defaults to <name>.
        """
        name = name.lower()
        if not description:
            description = name
        if url[-1] == '/':
            url = url[:-1]
        trackertype = trackertype.lower()
        if trackertype in defined_bugtrackers:
            self.db[name] = defined_bugtrackers[trackertype](name,url,description)
        else:
            irc.error("Bugtrackers of type '%s' are not understood" % trackertype)
            return
        registerBugtracker(name, url, description, trackertype)
        self.shorthand = utils.abbrev(self.db.keys())
        irc.replySuccess()
    add = wrap(add, [('checkCapability', 'admin'), 'something', 'something', 'url', additional('text')])

    def remove(self, irc, msg, args, name):
        """<abbreviation>

        Remove the bugtracker associated with <abbreviation> from the list of
        defined bugtrackers.
        """
        try:
            name = self.shorthand[name.lower()]
            del self.db[name]
            self.registryValue('bugtrackers').remove(name)
            self.shorthand = utils.abbrev(self.db.keys())
            irc.replySuccess()
        except KeyError:
            s = self.registryValue('replyNoBugtracker', ircutils.isChannel(msg.args[0]) and msg.args[0] or None)
            irc.error(s % name)
    remove = wrap(remove, [('checkCapability', 'admin'), 'text'])

    def rename(self, irc, msg, args, oldname, newname, newdesc):
        """<oldname> <newname>

        Rename the bugtracker associated with <oldname> to <newname>.
        """
        try:
            name = self.shorthand[oldname.lower()]
            group = self.registryValue('bugtrackers.%s' % name.replace('.','\\.'), value=False)
            d = group.description()
            if newdesc:
                d = newdesc
            self.db[newname] = defined_bugtrackers[group.trackertype()](name,group.url(),d)
            registerBugtracker(newname, group.url(), d, group.trackertype())
            del self.db[name]
            self.registryValue('bugtrackers').remove(name)
            self.shorthand = utils.abbrev(self.db.keys())
            irc.replySuccess()
        except KeyError:
            s = self.registryValue('replyNoBugtracker', ircutils.isChannel(msg.args[0]) and msg.args[0] or None)
            irc.error(s % name)
    rename = wrap(rename, [('checkCapability', 'admin'), 'something','something', additional('text')])

    def list(self, irc,  msg, args, name):
        """[abbreviation]

        List defined bugtrackers. If [abbreviation] is specified, list the
        information for that bugtracker.
        """
        if name:
            name = name.lower()
            try:
                name = self.shorthand[name]
                (url, description, type) = (self.db[name].url, self.db[name].description,
                                            self.db[name].__class__.__name__)
                irc.reply('%s: %s, %s [%s]' % (name, description, url, type))
            except KeyError:
                s = self.registryValue('replyNoBugtracker', ircutils.isChannel(msg.args[0]) and msg.args[0] or None)
                irc.error(s % name)
        else:
            if self.db:
                L = self.db.keys()
                L.sort()
                irc.reply(utils.str.commaAndify(L))
            else:
                irc.reply('I have no defined bugtrackers.')
    list = wrap(list, [additional('text')])

    def bugSnarfer(self, irc, msg, match):
        r"""\b(?P<bt>(([a-z0-9]+)?\s+bugs?|[a-z0-9]+):?)\s+#?(?P<bug>\d+(?!\d*[\-\.]\d+)((,|\s*(and|en|et|und|ir))\s*#?\d+(?!\d*[\-\.]\d+))*)"""
        channel = ircutils.isChannel(msg.args[0]) and msg.args[0] or None
        if not self.registryValue('bugSnarfer', channel):
            return
        nbugs = msg.tagged('nbugs')
        if not nbugs: nbugs = 0
        if nbugs >= 5:
            return

        # Don't double on commands
        s = str(msg).split(':')[2]
        if s and s[0] in str(conf.supybot.reply.whenAddressedBy.chars):
            return

        sure_bug = match.group('bt').endswith('bug') or match.group('bt').endswith('bug')

        # Get tracker name
        bugids = match.group('bug')
        reps = ((' ',''),('#',''),('and',','),('en',','),('et',','),('und',','),('ir',','))
        for r in reps:
            bugids = bugids.replace(r[0],r[1])
        bugids = bugids.split(',')[:5-nbugs]

        # Begin HACK
        # strings like "ubuntu 1004" and "ubuntu 1010" are false triggers for us
        # filter out bug number that are 4 numbers, start with '1' and end in '04' or '10
        # (let's fix this for 2020 ;)
        if match.group('bt').lower() == 'ubuntu':
            bugids = filter(lambda bugnum: not (len(bugnum) == 4 and bugnum[0] == '1' and bugnum[2:] in ('04', '10')), bugids)
        # End HACK

        if not sure_bug:
            bugids = [x for x in bugids if int(x) > 100]

        bugids = list(set(bugids)) ## remove dups

        msg.tag('nbugs', nbugs + len(bugids))
        bt = map(lambda x: x.lower(), match.group('bt').split())
        # Strip off trailing ':' from the tracker name. Allows for (LP: #nnnnnn)
        if bt and bt[0].endswith(':'):
            bt[0] = bt[:-1]
        name = ''
        if len(bt) == 1 and not (bt[0] in ['bug','bugs']):
            try:
                name = bt[0]
                tracker = self.db[name]
            except:
                return
        elif len(bt) == 2:
            try:
                name = bt[0]
                tracker = self.db[name]
            except:
                name = ''
                pass
        if not name:
            snarfTarget = self.registryValue('snarfTarget', channel)
            if not snarfTarget:
                self.log.warning("Bugtracker: no snarfTarget for Bugtracker")
                return
            try:
                name = self.shorthand[snarfTarget.lower()]
            except:
               s = self.registryValue('replyNoBugtracker', name)
               irc.error(s % name)
        try:
            tracker = self.db[name]
        except KeyError:
            s = self.registryValue('replyNoBugtracker', name)
            irc.error(s % name)
        else:
            for bugid in bugids:
                bugid = int(bugid)
                try:
                    report = self.get_bug(channel,tracker,bugid,self.registryValue('showassignee', channel))
                except BugNotFoundError:
                    if self.registryValue('replyWhenNotFound'):
                        irc.error("%s bug %d could not be found" % (tracker.description, bugid))
                except BugtrackerError, e:
                    if 'private' in str(e):
                        irc.reply("Bug %d on http://launchpad.net/bugs/%d is private" % (bugid, bugid))
                        return
                    if not sure_bug and bugid < 30:
                        return
                    irc.error(str(e))
                else:
                    for r in report:
                        irc.reply(makeClean(r), prefixNick=False)

    def turlSnarfer(self, irc, msg, match):
        r"(?P<tracker>https?://\S*?)/(?:Bugs/0*|str.php\?L|show_bug.cgi\?id=|bugreport.cgi\?bug=|(?:bugs|\+bug)/|ticket/|tracker/|\S*aid=|bug=)?(?P<bug>\d+)(?P<sfurl>&group_id=\d+&at_id=\d+)?"
        channel = ircutils.isChannel(msg.args[0]) and msg.args[0] or None
        if not self.registryValue('bugSnarfer', channel):
            return
        nbugs = msg.tagged('nbugs')
        if not nbugs: nbugs = 0
        if nbugs >= 5:
            return
        msg.tag('nbugs', nbugs+1)
        try:
            tracker = self.get_tracker(match.group(0),match.group('sfurl'))
            if not tracker:
                return
            report = self.get_bug(channel, tracker, int(match.group('bug')), self.registryValue('showassignee', channel), do_url = False)
        except BugtrackerError, e:
            irc.error(str(e))
        except BugNotFoundError, e:
            irc.error("%s bug %s not found" % (tracker, match.group('bug')))
        else:
            for r in report:
                irc.reply(makeClean(r), prefixNick=False)

    # Only useful for launchpad developers
    def oopsSnarfer(self, irc, msg, match):
        r"(?:https?://pad.lv/){0}?OOPS-(?P<oopsid>\d*[\dA-Z]{3,})"
        channel = ircutils.isChannel(msg.args[0]) and msg.args[0] or None
        if not self.registryValue('bugSnarfer', channel) or not self.registryValue('oopsSnarfer', channel):
            return
        oopsid = match.group(1)
        if oopsid.lower() == "tools":
            return
        if not self.is_ok(channel, 'lpoops', oopsid):
            return
        irc.reply('https://lp-oops.canonical.com/oops.py/?oopsid=' + oopsid, prefixNick=False)

    def cveSnarfer(self, irc, msg, match):
        r"(cve[- ]\d{4}[- ]\d{4})"
        channel = ircutils.isChannel(msg.args[0]) and msg.args[0] or None
        if not self.registryValue('bugSnarfer', channel) or not self.registryValue('cveSnarfer', channel):
            return
        cve = match.group(1).replace(' ','-').upper()
        if not self.is_ok(channel, 'cve', cve):
            return
        url = 'http://cve.mitre.org/cgi-bin/cvename.cgi?name=%s' % cve
        cvedata = utils.web.getUrl(url)
        m = cvere.search(cvedata)
        if m:
            cve = m.group(1).replace('\n', ' ')
            if len(cve) > 380:
                cve = cve[:380] + '...'
            irc.reply("%s (%s)" % (cve,url), prefixNick=False)

#TODO: as we will depend on launchpadlib, we should consider using lazr.uri.URI to do URL parsing
    def get_tracker(self, snarfurl, sfdata):
        snarfurl = snarfurl.replace('sf.net','sourceforge.net')
        snarfhost = snarfurl.replace('http://','').replace('https://','')

        # Begin HACK
        # launchpad.net has many URLs that can confuse us
        # make sure 'bug' in in the URL, somewhere
        if 'launchpad' in snarfhost:
            if not 'bug' in snarfhost: # Not a bug URL
                return None

        if snarfhost.startswith('pad.lv'): # Launchpad URL shortening
            snarfhost = snarfhost[:snarfhost.rfind('/')]
            snarfhost = '/'.join( (_ for _ in snarfhost.split('/') if _) )
            if '/' in snarfhost: # it's not a bug URL
                return None
            return self.db.get('launchpad', None)
        # End HACK

        # At this point, we are only interested in the host part of the URL
        if '/' in snarfurl:
            snarfhost = snarfhost[:snarfhost.index('/')]

        if 'sourceforge.net' in snarfurl: # See below
            return None

        for t in self.db.keys():
            tracker = self.db.get(t, None)
            if not tracker:
                self.log.error("No tracker for key %r" % t)
                continue
            url = tracker.url.replace('http://','').replace('https://','')

            if 'sourceforge.net' in url:
                # sourceforge.net has no API or structured bug exporting, HTML
                # scraping is not good enough. Especially as SF keep changing it
                continue

            if '/' in url:
                url = url[:url.index('/')]
            if url in snarfhost:
                return tracker

        if snarfhost == 'pad.lv': # Launchpad URL shortening
            return self.db.get('lp', None)

        # No tracker found, bummer. Let's try and add one
        if 'show_bug.cgi' in snarfurl:
            tracker = Bugzilla().get_tracker(snarfurl)
            if tracker:
                self.db[tracker.name] = tracker
                self.shorthand = utils.abbrev(self.db.keys())
                return tracker
        return None

    def get_bug(self, channel, tracker, id, do_assignee, do_url = True):
        reports = []
        if not self.is_ok(channel, tracker, id):
            return []
        for r in tracker.get_bug(id):
            showext = self.registryValue('extended', channel)
            extinfo = ''
            if len(r) == 8:
                (bid, product, title, severity, status, assignee, url, extinfo) = r
            else:
                (bid, product, title, severity, status, assignee, url) = r

            severity = severity[0].upper() + severity[1:].lower()
            status = status[0].upper() + status[1:].lower()
            if not do_url:
                url = ''
            if product:
                if showext:
                    reports.append("%s bug %s in %s \"%s\" %s [%s,%s] %s" % (tracker.description, bid, product, 
                                                                          title, extinfo, severity, status, url))
                else:
                    reports.append("%s bug %s in %s \"%s\" [%s,%s] %s" % (tracker.description, bid, product, 
                                                                          title, severity, status, url))
            else:
                if showext:
                    reports.append("%s bug %s \"%s\" %s [%s,%s] %s" % (tracker.description, bid, title, extinfo, severity, status, url))
                else:
                    reports.append("%s bug %s \"%s\" [%s,%s] %s" % (tracker.description, bid, title, severity, status, url))
            if do_assignee and assignee:
                reports[-1] = reports[-1] + (" - Assigned to %s" % assignee)
        return reports

# Define all bugtrackers
class IBugtracker:
    def __init__(self, name=None, url=None, description=None):
        self.name        = name
        self.url         = url
        self.description = description
        self.log         = supylog # Convenience log wrapper

    def get_bug(self, id):
        raise BugTrackerError("Bugtracker class does not implement get_bug")

    def get_tracker(self, url):
        raise BugTrackerError("Bugtracker class does not implement get_tracker")

    def __str__(self):
        return '%s(%s)' % (self.__class__.__name__, self.url)

    def __hash__(self):
        return hash(self.url)

    def __cmp__(self, other): # used implicitly in Bugtracker.is_ok()
        return cmp(hash(self), hash(other))

class Bugzilla(IBugtracker):
    def get_tracker(self, url):
        url = url.replace('show_bug','xml')
        try:
            bugxml = utils.web.getUrl(url)
            tree = minidom.parseString(bugxml)
            url  = str(tree.getElementsByTagName('bugzilla')[0].attributes['urlbase'].childNodes[0].data)
            if url[-1] == '/':
                url = url[:-1]
            name = url[url.find('//') + 2:]
            if '/' in name:
                name = name[:name.find('/')]
            desc = name
            registerBugtracker(name, url, desc, 'bugzilla')
            tracker = Bugzilla(name, url, desc)
            return tracker
        except:
            return None
    def get_bug(self, id):
        url = "%s/xml.cgi?id=%d" % (self.url,id)
        try:
            bugxml = utils.web.getUrl(url)
            zilladom = minidom.parseString(bugxml)
        except Exception, e:
            s = 'Could not parse XML returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        bug_n = zilladom.getElementsByTagName('bug')[0]
        if bug_n.hasAttribute('error'):
            errtxt = bug_n.getAttribute('error')
            if errtxt == 'NotFound':
                raise BugNotFoundError
            s = 'Error getting %s bug #%s: %s' % (self.description, id, errtxt)
            raise BugtrackerError, s
        try:
            title = _getnodetxt(bug_n.getElementsByTagName('short_desc')[0])
            status = _getnodetxt(bug_n.getElementsByTagName('bug_status')[0])
            try:
                status += ": " + _getnodetxt(bug_n.getElementsByTagName('resolution')[0])
            except:
                pass
            component = _getnodetxt(bug_n.getElementsByTagName('component')[0])
            severity = _getnodetxt(bug_n.getElementsByTagName('bug_severity')[0])
            assignee = '(unavailable)'
            try:
                assignee = _getnodetxt(bug_n.getElementsByTagName('assigned_to')[0])
            except:
                pass
        except Exception, e:
            s = 'Could not parse XML returned by %s bugzilla: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        return [(id, component, title, severity, status, assignee, "%s/show_bug.cgi?id=%d" % (self.url, id))]

class Issuezilla(IBugtracker):
    def get_bug(self, id):
        url = "%s/xml.cgi?id=%d" % (self.url,id)
        try:
            bugxml = utils.web.getUrl(url)
            zilladom = minidom.parseString(bugxml)
        except Exception, e:
            s = 'Could not parse XML returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        bug_n = zilladom.getElementsByTagName('issue')[0]
        if not (bug_n.getAttribute('status_code') == '200'):
            if bug_n.getAttribute('status_message') == 'NotFound':
                raise BugNotFoundError
            s = 'Error getting %s bug #%s: %s' % (self.description, id, bug_n.getAttribute('status_message'))
            raise BugtrackerError, s
        try:
            title = _getnodetxt(bug_n.getElementsByTagName('short_desc')[0])
            status = _getnodetxt(bug_n.getElementsByTagName('issue_status')[0])
            try:
                status += ": " + _getnodetxt(bug_n.getElementsByTagName('resolution')[0])
            except:
                pass
            component = _getnodetxt(bug_n.getElementsByTagName('component')[0])
            severity = _getnodetxt(bug_n.getElementsByTagName('issue_type')[0])
            assignee = _getnodetxt(bug_n.getElementsByTagName('assigned_to')[0])
        except Exception, e:
            s = 'Could not parse XML returned by %s bugzilla: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        return [(id, component, title, severity, status, assignee, "%s/show_bug.cgi?id=%d" % (self.url, id))]

class Launchpad(IBugtracker):
    statuses = ["Unknown", "Invalid", "Opinion", "Won't Fix", "Fix Released", "Fix Committed", "New", "Incomplete", "Confirmed", "Triaged", "In Progress"]
    severities = ["Unknown", "Undecided", "Wishlist", "Low", "Medium", "High", "Critical"]

    def __init__(self, *args, **kwargs):
        IBugtracker.__init__(self, *args, **kwargs)
        self.lp = None

        # A word to the wise:
        # The Launchpad API is much better than the /+text interface we currently use,
        # it's faster and easier to get the information we need.
        # The current /+text interface is not really maintained by Launchpad and most,
        # or all, of the Launchpad developers hate it. For this reason, we are dropping
        # support for /+text in the future in favour of launchpadlib.
        # Terence Simpson (tsimpson) 2010-04-20

        try: # Attempt to use launchpadlib, python bindings for the Launchpad API
            from launchpadlib.launchpad import Launchpad
            cachedir = os.path.join(conf.supybot.directories.data.tmp(), 'lpcache')
            if hasattr(Launchpad, 'login_anonymously'):
                self.lp = Launchpad.login_anonymously("Ubuntu Bots - Bugtracker", 'production', cachedir)
            else: #NOTE: Most people should have a launchpadlib new enough for .login_anonymously
                self.lp = Launchpad.login("Ubuntu Bots - Bugtracker", '', '', 'production', cahedir)
        except ImportError:
            # Ask for launchpadlib to be installed
            supylog.warning("Please install python-launchpadlib, the old interface is deprecated")
        except Exception: # Something unexpected happened
            self.lp = None
            supylog.exception("Unknown exception while accessing the Launchpad API")

    def _parse(self, task): #Depricated
        parser = email.FeedParser.FeedParser()
        parser.feed(task)
        return parser.close()

    def get_bug(self, id): #TODO: Remove this method and rename 'get_new_bug' to 'get_bug'
        if self.lp:
            return self.get_bug_new(id)
        return self.get_bug_old(id)

    @classmethod
    def _sort(cls, task1, task2):
        task1_status = task1.status
        task1_importance = task1.importance
        task2_status = task2.status
        task2_importance = task2.importance

        if task1_status not in cls.statuses:
            supylog.error("%r is an unknown status for Launchapd, update %s.statuses" % (task1_status, getattr(cls, '__name__', 'Launchpad')))
            if task2_status not in cls.statuses:
                supylog.error("%r is an unknown status for Launchapd, update %s.statuses" % (task1_status, getattr(cls, '__name__', 'Launchpad')))
                return -1
            return 1

        if task1_importance not in cls.severities:
            supylog.error("%r is an unknown status for Launchapd, update %s.severities" % (task1_importance, getattr(cls, '__name__', 'Launchpad')))
            if task2_importance not in cls.severities:
                supylog.error("%r is an unknown status for Launchapd, update %s.severities" % (task1_importance, getattr(cls, '__name__', 'Launchpad')))
                return -1
            return 1

        if task1_status != task2_status:
            if cls.statuses.index(task1_status) < cls.statuses.index(task2_status):
                return -1
            return 1
        if task1_importance != task2_importance:
            if cls.severities.index(task1_importance) < cls.severities.index(task2_importance):
                return -1
            return 1
        return 0

    @classmethod
    def _old_sort(cls, task1, task2): #Depricated
        # Status sort: 
        try:
            if task1['status'] not in cls.statuses and task2['status'] in cls.statuses: return -1
            if task1['status'] in cls.statuses and task2['status'] not in cls.statuses: return 1
            if task1['importance'] not in cls.severities and task2['importance'] in cls.severities: return -1
            if task1['importance'] in cls.severities and task2['importance'] not in cls.severities: return 1
            if not (task1['status'] == task2['status']):
                if cls.statuses.index(task1['status']) < cls.statuses.index(task2['status']):
                    return -1
                return 1
            if not (task1['importance'] == task2['importance']):
                if cls.severities.index(task1['importance']) < cls.severities.index(task2['importance']):
                    return -1
                return 1
        except: # Launchpad changed again?
            return 0
        return 0

    def get_bug_new(self, id): #TODO: Rename this method to 'get_bug'
        try:
            bugdata = self.lp.bugs[id]
            if bugdata.private:
                raise BugtrackerError, "This bug is private"
            dup = bugdata.duplicate_of
            affected = bugdata.users_affected_count_with_dupes
            heat = bugdata.heat
            tasks = bugdata.bug_tasks

            if tasks.total_size != 1:
                tasks = list(tasks)
                tasks.sort(self._sort)
                taskdata = tasks[-1]
            else:
                taskdata = tasks[0]

            assignee = taskdata.assignee
            t = taskdata.bug_target_display_name #task name

            if assignee: # "Diaplay Name (Launchpad ID)"
                assignee = u"%s (%s)" % (assignee.display_name, assignee.name)
            else:
                assignee = ''

        except Exception, e:
#NOTE: The LP API will raise a lazr.restfulclient.errors.HTTPError with private bugs, so bugdata.private is useless..., do the checking here instead
            if e.__class__.__name__ == 'HTTPError': # messy, but meh
                raise BugtrackerError, e.content # should be 'Bug nnnnn is private'
            elif isinstance(e, KeyError):
                raise BugNotFoundError
            supylog.exception("Error gathering bug data for %s bug %d" % (self.description, id))
            s = 'Could not parse data returned by %s: %s (%s/bugs/%d)' % (self.description, e, self.url, id)
            raise BugtrackerError, s

        extinfo = "(affected: %d, heat: %d)" % (affected, heat)

        if dup:
            dupbug = self.get_bug(dup.id)
            return [(id, t, bugdata.title + (' (dup-of: %d)' % dup.id), taskdata.importance,
                    taskdata.status, assignee, "%s/bugs/%s" % (self.url, id))] + dupbug
        return [(id, t, bugdata.title, taskdata.importance, taskdata.status,
                assignee, "%s/bugs/%s" % (self.url, id), extinfo)]

    def get_bug_old(self, id): #Depricated
        if id == 1:
            raise BugtrackerError, "https://bugs.launchpad.net/ubuntu/+bug/1 (Not reporting large bug)"

        try:
            bugdata = utils.web.getUrl("%s/bugs/%d/+text" % (self.url,id))
        except Exception, e:
            if '404' in str(e):
                raise BugNotFoundError
            s = 'Could not parse data returned by %s: %s (%s/bugs/%d)' % (self.description, e, self.url, id)
            raise BugtrackerError, s
        summary = {}
        # Trap private bugs
        if "<!-- 4a. didn't try to log in last time: -->" in bugdata:
            raise BugtrackerError, "This bug is private"
        try:
            # Split bug data into separate pieces (bug data, task data)
            data     =  bugdata.split('\n\n')
            bugdata  = data[0]
            taskdata = data[1:]
            parser   = email.FeedParser.FeedParser()
            parser.feed(bugdata)
            bugdata = parser.close()
            taskdata = map(self._parse, taskdata)
            taskdata.sort(self._old_sort)
            taskdata = taskdata[-1]
                
        except Exception, e:
            s = 'Could not parse data returned by %s: %s (%s/bugs/%d)' % (self.description, e, self.url, id)
            raise BugtrackerError, s
        # Try and find duplicates
        t = taskdata['task']
        if '(' in t:
            t = t[:t.rfind('(') -1]
        if bugdata['duplicate-of']:
            dupbug = self.get_bug(int(bugdata['duplicate-of']))
            return [(id, t, bugdata['title'] + (' (dup-of: %d)' % dupbug[0][0]), taskdata['importance'], 
                    taskdata['status'], taskdata['assignee'], "%s/bugs/%s" % (self.url, id))] + dupbug
        return [(id, t, bugdata['title'], taskdata['importance'], 
                taskdata['status'], taskdata['assignee'], "%s/bugs/%s" % (self.url, id))]
            
# <rant>
# Debbugs sucks donkeyballs
# * HTML pages are inconsistent
# * Parsing mboxes gets incorrect with cloning perversions (eg with bug 330000)
# * No sane way of accessing bug reports in a machine readable way (bts2ldap
#   has no search on bugid)
# * The damn thing allow incomplete bugs, eg bugs without severity set. WTF?!?
#
# Fortunately bugs.donarmstrong.com has a SOAP interface which we can use.
# </rant>
class Debbugs(IBugtracker):
    def __init__(self, *args, **kwargs):
        IBugtracker.__init__(self, *args, **kwargs)
        self.soap_proxy = SOAPpy.SOAPProxy("bugs.debian.org/cgi-bin/soap.cgi", "Debbugs/SOAP/Status")
        self.soap_proxy.soapaction = "Debbugs/SOAP/Status#get_status"

    def get_bug(self, id):
        bug_url = "http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=%d" % id
        try:
            raw = self.soap_proxy.get_status(id)
        except Exception, e:
            s = 'Could not parse data returned by %s: %s' % (self.description, e)
            raise BugtrackerError, s
        if not raw:
            raise BugNotFoundError
        raw = raw['item']['value']
        try:
            if len(raw['fixed_versions']):
                status = 'Fixed'
            else:
                status = 'Open'
            return [(id, raw['package'], raw['subject'], raw['severity'], status, '', "%s/%s" % (self.url, id))]
        except Exception, e:
            s = 'Could not parse data returned by %s bugtracker: %s (%s)' % (self.description, e, bug_url)
            raise BugtrackerError, s

class Mantis(IBugtracker):
    def __init__(self, *args, **kwargs):
        IBugtracker.__init__(self, *args, **kwargs)
        self.soap_proxy = SOAPpy.SOAPProxy(self.url + "/api/soap/mantisconnect.php", "http://futureware.biz/mantisconnect")
        self.soap_proxy.soapaction = "http://futureware.biz/mantisconnect#mc_issue_get"

    def get_bug(self, id):
        url = self.url + "/view.php?id=%i" % id
        try:
            raw = self.soap_proxy.mc_issue_get('', "", id)
        except Exception, e:
            s = 'Could not parse data returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        if not raw:
            raise BugNotFoundError
        try:
            return [(id, raw['project']['name'], raw['summary'], raw['priority']['name'], raw['resolution']['name'], '', url)]
        except Exception, e:
            s = 'Could not parse data returned by %s bugtracker: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s

# For trac based trackers we get the tab-separated-values format.
# The other option is a comma-separated-values format, but if the description
# has commas, things get tricky.
# This should be more robust than the screen-scraping done previously.
class Trac(IBugtracker):
    def get_bug(self, id): # This is still a little rough, but it works :)
        bug_url = "%s/%d" % (self.url, id)
        try:
            raw = utils.web.getUrl("%s?format=tab" % bug_url)
        except Exception, e:
            if 'HTTP Error 500' in str(e):
                raise BugNotFoundError
            s = 'Could not parse data returned by %s: %s' % (self.description, e, bug_url)
            raise BugtrackerError, s
        raw = raw.replace("\r\n", '\n')
        (headers, rest) = raw.split('\n', 1)
        headers = headers.strip().split('\t')
        rest = rest.strip().split('\t')
        title = status = package = severity = assignee = "Unknown"
        if "summary" in headers:
            title = rest[headers.index("summary")]
        if "status" in headers:
            status = rest[headers.index("status")]
        if "component" in headers:
            package = rest[headers.index("component")]
        if "severity" in headers:
            severity = rest[headers.index("severity")]
        if "owner" in headers:
            assingee = rest[headers.index("owner")]
        if severity == "Unknown" and "priority" in headers:
            severity = rest[headers.index("priority")]

        return [(id, package, title, severity, status, assignee, bug_url)]
        
class WikiForms(IBugtracker):
    def get_bug(self, id):
        def strip_tags(s):
            while '<' in s and '>' in s:
                s = str(s[:s.find('<')]) + str(s[s.find('>')+1:])
            return s

        url = "%s/%05d" % (self.url, id)
        try:
            bugdata = utils.web.getUrl(url)
        except Exception, e:
            if 'HTTP Error 404' in str(e):
                raise BugNotFoundError
            s = 'Could not parse data returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        for l in bugdata.split("\n"):
            l2 = l.lower()
            if '<dt>importance</dt>' in l2:
                severity = 'Importance ' + strip_tags(l[l.find('<dd>')+4:])
            if '<dt>summary</dt>' in l2:
                title = strip_tags(l[l.find('<dd>')+4:])
            if '<dt>status</dt>' in l2:
                status = strip_tags(l[l.find('<dd>')+4:])
            if '<dt>category</dt>' in l2:
                package = strip_tags(l[l.find('<dd>')+4:])
        return [(id, package, title, severity, status, '', "%s/%05d" % (self.url, id))]

class Str(IBugtracker):
    def get_bug(self, id):
        def strip_tags(s):
            while '<' in s and '>' in s:
                s = str(s[:s.find('<')]) + str(s[s.find('>')+1:])
            return s
        url = "%s?L%d" % (self.url, id)
        try:
            bugdata = utils.web.getUrl(url)
        except Exception, e:
            s = 'Could not parse data returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        for l in bugdata.split("\n"):
            l2 = l.lower()
            if 'nowrap>priority:</th>' in l2:
                severity = 'Priority ' + l[l.find(' - ')+3:min(l.find(','),l.find('</td>'))]
            if '>application:</th>' in l2:
                package = l[l.find('<td>')+4:l.find('</td>')]
            if 'nowrap>status:</th>' in l2:
                status = l[l.find(' - ')+3:l.find('</td>')]
            if 'nowrap>summary:</th>' in l2:
                title = l[l.find('<td>')+4:l.find('</td>')]
            if 'nowrap>assigned to:</th>' in l2:
                assignee = strip_tags(l[l.find('<td>')+4:l.find('</td>')])
                if assignee == 'Unassigned':
                    assignee = 'nobody'
        return [(id, package, title, severity, status, assignee, "%s?L%d" % (self.url, id))]
        

sfre = re.compile(r"""
                  .*?
                  <h2>\[.*?\]\s*(?P<title>.*?)</h2>
                  .*?
                  assigned.*?<br>\s+(?P<assignee>\S+)
                  .*?
                  priority.*?(?P<priority>\d+)
                  .*?
                  status.*?<br>\s+(?P<status>\S+)
                  .*?
                  resolution.*?<br>\s+(?P<resolution>\S+)
                  .*?
                  """, re.VERBOSE | re.DOTALL | re.I)
#NOTE: Until sf.net has a way to export formatted bug data, this will remain broken and unmaintained
class Sourceforge(IBugtracker):
    _sf_url = 'http://sf.net/support/tracker.php?aid=%d'
    def get_bug(self, id):
        url = self._sf_url % id
        try:
            bugdata = utils.web.getUrl(url)
        except Exception, e:
            s = 'Could not parse data returned by %s: %s (%s)' % (self.description, e, url)
            raise BugtrackerError, s
        try:
            reo = sfre.search(bugdata)
            status = reo.group('status')
            resolution = reo.group('resolution')
            if not (resolution.lower() == 'none'):
                status += ' ' + resolution
            return [(id, None, reo.group('title'), "Pri: %s" % reo.group('priority'), status, reo.group('assignee'),self._sf_url % id)]
        except:
            raise BugNotFoundError

# Introspection is quite cool
defined_bugtrackers = {}
v = vars()
for k in v.keys():
    if type(v[k]) == type(IBugtracker) and issubclass(v[k], IBugtracker) and not (v[k] == IBugtracker):
        defined_bugtrackers[k.lower()] = v[k]

registerBugtracker('mozilla', 'http://bugzilla.mozilla.org', 'Mozilla', 'bugzilla')
registerBugtracker('ubuntu', 'https://launchpad.net', 'Ubuntu', 'launchpad')
registerBugtracker('gnome', 'http://bugzilla.gnome.org', 'Gnome', 'bugzilla')
registerBugtracker('gnome2', 'http://bugs.gnome.org', 'Gnome', 'bugzilla')
registerBugtracker('kde', 'http://bugs.kde.org', 'KDE', 'bugzilla')
registerBugtracker('ximian', 'http://bugzilla.ximian.com', 'Ximian', 'bugzilla')
registerBugtracker('freedesktop', 'http://bugzilla.freedesktop.org', 'Freedesktop', 'bugzilla')
registerBugtracker('freedesktop2', 'http://bugs.freedesktop.org', 'Freedesktop', 'bugzilla')
registerBugtracker('openoffice', 'http://openoffice.org/issues', 'OpenOffice.org', 'issuezilla')
registerBugtracker('launchpad', 'https://launchpad.net', 'Launchpad', 'launchpad')
registerBugtracker('lp', 'https://launchpad.net', 'Launchpad', 'launchpad')
registerBugtracker('malone', 'https://launchpad.net', 'Launchpad', 'launchpad')
registerBugtracker('debian', 'http://bugs.debian.org', 'Debian', 'debbugs')
registerBugtracker('trac', 'http://trac.edgewall.org/ticket', 'Trac', 'trac')
registerBugtracker('django', 'http://code.djangoproject.com/ticket', 'Django', 'trac')
registerBugtracker('cups', 'http://www.cups.org/str.php', 'CUPS', 'str')
registerBugtracker('gnewsense', 'http://bugs.gnewsense.org/Bugs', 'gNewSense', 'wikiforms')
registerBugtracker('supybot', 'http://sourceforge.net/tracker/?group_id=58965&atid=489447', 'Supybot', 'sourceforge')
registerBugtracker('mantis', "http://www.mantisbt.org/bugs", "Mantis", 'mantis')
registerBugtracker('ubottu', 'https://launchpad.net', 'Ubottu', 'launchpad')
# Don't delete this one
registerBugtracker('sourceforge', 'http://sourceforge.net/tracker/', 'Sourceforge', 'sourceforge')
Class = Bugtracker