# bugzilla.py - bugzilla integration for mercurial

#

# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>

# Copyright 2011 Jim Hague <jim.hague@acm.org>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''hooks for integrating with the Bugzilla bug tracker

This hook extension adds comments on bugs in Bugzilla when changesets

that refer to bugs by Bugzilla ID are seen. The comment is formatted using

the Mercurial template mechanism.

The hook does not change bug status.

2. Writing directly to the Bugzilla database. Only Bugzilla installations

   using MySQL are supported. Requires Python MySQLdb.

Writing directly to the database is susceptible to schema changes, and

relies on a Bugzilla contrib script to send out bug change

notification emails. This script runs as the user running Mercurial,

must be run on the host with the Bugzilla install, and requires

permission to read Bugzilla configuration details and the necessary

MySQL user and password to have full access rights to the Bugzilla

database. For these reasons this access mode is now considered

deprecated, and will not be updated for new Bugzilla versions going

forward.

Access via XMLRPC needs a Bugzilla username and password to be specified

in the configuration. Comments are added under that username. Since the

configuration must be readable by all Mercurial users, it is recommended

that the rights of that user are restricted in Bugzilla to the minimum

necessary to add comments.

[bugzilla]

version

  This access type to use. Values recognised are:

regexp

  Regular expression to match bug IDs in changeset commit message.

  Must contain one "()" group. The default expression matches 'Bug

  1234', 'Bug no. 1234', 'Bug number 1234', 'Bugs 1234,5678', 'Bug

  1234 and 5678' and variations thereof. Matching is case insensitive.

style

  The style file to use when formatting comments.

template

  Template to use when formatting comments. Overrides style if

  specified. In addition to the usual Mercurial keywords, the

  extension specifies::

    {bug}       The Bugzilla bug ID.

    {root}      The full pathname of the Mercurial repository.

    {webroot}   Stripped pathname of the Mercurial repository.

    {hgweb}     Base URL for browsing Mercurial repositories.

  Default 'changeset {node|short} in repo {root} refers '

          'to bug {bug}.\\ndetails:\\n\\t{desc|tabindent}'

strip

  The number of path separator characters to strip from the front of the

  Mercurial repository path ('{root}' in templates) to produce '{webroot}'.

  For example, a repository with '{root}' '/var/local/my-project' with a

  strip of 2 gives a value for '{webroot}' of 'my-project'. Default 0.

[web]

baseurl

  Base URL for browsing Mercurial repositories. Referenced from

  templates as {hgweb}.

XMLRPC access mode configuration:

[bugzilla]

bzurl

  The base URL for the Bugzilla installation.

  Default 'http://localhost/bugzilla'.

user

  The username to use to log into Bugzilla via XMLRPC. Default 'bugs'.

password

  The password for Bugzilla login.

MySQL access mode configuration:

[bugzilla]

host

  Hostname of the MySQL server holding the Bugzilla database.

  Default 'localhost'.

db

  Name of the Bugzilla database in MySQL. Default 'bugs'.

user

  Username to use to access MySQL server. Default 'bugs'.

password

  Password to use to access MySQL server.

timeout

  Database connection timeout (seconds). Default 5.

bzuser

  Fallback Bugzilla user name to record comments with, if changeset

  committer cannot be found as a Bugzilla user.

bzdir

   Bugzilla install directory. Used by default notify. Default

   '/var/www/html/bugzilla'.

notify

  The command to run to get Bugzilla to send bug change notification

  emails. Substitutes from a map with 3 keys, 'bzdir', 'id' (bug id)

  and 'user' (committer bugzilla email). Default depends on version;

  from 2.18 it is "cd %(bzdir)s && perl -T contrib/sendbugmail.pl

  %(id)s %(user)s".

Activating the extension::

    [extensions]

    bugzilla =

    [hooks]

    # run bugzilla hook on every change pulled or pushed in here

    incoming.bugzilla = python:hgext.bugzilla.hook

Example configurations:

XMLRPC example configuration. This uses the Bugzilla at

'http://my-project.org/bugzilla', logging in as user 'bugmail@my-project.org'

wityh password 'plugh'. It is used with a collection of Mercurial

repositories in '/var/local/hg/repos/'. ::

    [bugzilla]

    bzurl=http://my-project.org/bugzilla

    user=bugmail@my-project.org

    password=plugh

    version=xmlrpc

    [web]

    baseurl=http://my-project.org/hg

MySQL example configuration. This is for a collection of Mercurial

repositories in '/var/local/hg/repos/' used with a local Bugzilla 3.2

installation in /opt/bugzilla-3.2. The MySQL database is on 'localhost',

the Bugzilla database name is 'bugs' and MySQL is accessed with MySQL

username 'bugs' password 'XYZZY'. ::

    [bugzilla]

    host=localhost

    password=XYZZY

    version=3.0

    bzuser=unknown@domain.com

    bzdir=/opt/bugzilla-3.2

    template=Changeset {node|short} in {root|basename}.

             {hgweb}/{webroot}/rev/{node|short}\\n

             {desc}\\n

    strip=5

    [web]

    baseurl=http://dev.domain.com/hg

    [usermap]

    user@emaildomain.com=user.name@bugzilladomain.com

    Changeset 3b16791d6642 in repository-name.

    http://dev.domain.com/hg/repository-name/rev/3b16791d6642

    Changeset commit comment. Bug 1234.

'''

from mercurial.i18n import _

from mercurial.node import short

import re, time, xmlrpclib

class bzaccess(object):

    '''Base class for access to Bugzilla.'''

    def __init__(self, ui):

        self.ui = ui

        usermap = self.ui.config('bugzilla', 'usermap')

        if usermap:

            self.ui.readconfig(usermap, sections=['usermap'])

    def map_committer(self, user):

        '''map name of committer to Bugzilla user name.'''

        for committer, bzuser in self.ui.configitems('usermap'):

            if committer.lower() == user.lower():

                return bzuser

        return user

    # Methods to be implemented by access classes.

    def filter_real_bug_ids(self, ids):

        '''remove bug IDs that do not exist in Bugzilla from set.'''

        pass

    def filter_cset_known_bug_ids(self, node, ids):

        '''remove bug IDs where node occurs in comment text from set.'''

        pass

    def add_comment(self, bugid, text, committer):

        '''add comment to bug.

        If possible add the comment as being from the committer of

        the changeset. Otherwise use the default Bugzilla user.

        '''

        pass

    def notify(self, ids, committer):

        '''Force sending of Bugzilla notification emails.'''

        pass

# Bugzilla via direct access to MySQL database.

class bzmysql(bzaccess):

    '''Support for direct MySQL access to Bugzilla.

    The earliest Bugzilla version this is tested with is version 2.16.

    If your Bugzilla is version 3.2 or above, you are strongly

    recommended to use the XMLRPC access method instead.

    '''

    @staticmethod

    def sql_buglist(ids):

        '''return SQL-friendly list of bug ids'''

        return '(' + ','.join(map(str, ids)) + ')'

    _MySQLdb = None

    def __init__(self, ui):

        try:

            import MySQLdb as mysql

            bzmysql._MySQLdb = mysql

        except ImportError, err:

            raise util.Abort(_('python mysql support not available: %s') % err)

        bzaccess.__init__(self, ui)

        host = self.ui.config('bugzilla', 'host', 'localhost')

        user = self.ui.config('bugzilla', 'user', 'bugs')

        passwd = self.ui.config('bugzilla', 'password')

        db = self.ui.config('bugzilla', 'db', 'bugs')

        timeout = int(self.ui.config('bugzilla', 'timeout', 5))

        self.ui.note(_('connecting to %s:%s as %s, password %s\n') %

                     (host, db, user, '*' * len(passwd)))

        self.conn = bzmysql._MySQLdb.connect(host=host,

                                                   user=user, passwd=passwd,

                                                   db=db,

                                                   connect_timeout=timeout)

        self.cursor = self.conn.cursor()

        self.longdesc_id = self.get_longdesc_id()

        self.user_ids = {}

        self.default_notify = "cd %(bzdir)s && ./processmail %(id)s %(user)s"

    def run(self, *args, **kwargs):

        '''run a query.'''

        self.ui.note(_('query: %s %s\n') % (args, kwargs))

        try:

            self.cursor.execute(*args, **kwargs)

        except bzmysql._MySQLdb.MySQLError:

            self.ui.note(_('failed query: %s %s\n') % (args, kwargs))

            raise

    def get_longdesc_id(self):

        '''get identity of longdesc field'''

        self.run('select fieldid from fielddefs where name = "longdesc"')

        ids = self.cursor.fetchall()

        if len(ids) != 1:

            raise util.Abort(_('unknown database schema'))

        return ids[0][0]

    def filter_real_bug_ids(self, ids):

        '''filter not-existing bug ids from set.'''

        self.run('select bug_id from bugs where bug_id in %s' %

                 bzmysql.sql_buglist(ids))

        return set([c[0] for c in self.cursor.fetchall()])

    def filter_cset_known_bug_ids(self, node, ids):

        '''filter bug ids that already refer to this changeset from set.'''

        self.run('''select bug_id from longdescs where

                    bug_id in %s and thetext like "%%%s%%"''' %

                 (bzmysql.sql_buglist(ids), short(node)))

        for (id,) in self.cursor.fetchall():

            self.ui.status(_('bug %d already knows about changeset %s\n') %

                           (id, short(node)))

            ids.discard(id)

        return ids

    def notify(self, ids, committer):

        '''tell bugzilla to send mail.'''

        self.ui.status(_('telling bugzilla to send mail:\n'))

        (user, userid) = self.get_bugzilla_user(committer)

        for id in ids:

            self.ui.status(_('  bug %s\n') % id)

            cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)

            bzdir = self.ui.config('bugzilla', 'bzdir', '/var/www/html/bugzilla')

            try:

                # Backwards-compatible with old notify string, which

                # took one string. This will throw with a new format

                # string.

                cmd = cmdfmt % id

            except TypeError:

                cmd = cmdfmt % {'bzdir': bzdir, 'id': id, 'user': user}

            self.ui.note(_('running notify command %s\n') % cmd)

            fp = util.popen('(%s) 2>&1' % cmd)

            out = fp.read()

            ret = fp.close()

            if ret:

                self.ui.warn(out)

                raise util.Abort(_('bugzilla notify command %s') %

                                 util.explain_exit(ret)[0])

        self.ui.status(_('done\n'))

    def get_user_id(self, user):

        '''look up numeric bugzilla user id.'''

        try:

            return self.user_ids[user]

        except KeyError:

            try:

                userid = int(user)

            except ValueError:

                self.ui.note(_('looking up user %s\n') % user)

                self.run('''select userid from profiles

                            where login_name like %s''', user)

                all = self.cursor.fetchall()

                if len(all) != 1:

                    raise KeyError(user)

                userid = int(all[0][0])

            self.user_ids[user] = userid

            return userid

    def get_bugzilla_user(self, committer):

        '''See if committer is a registered bugzilla user. Return

        bugzilla username and userid if so. If not, return default

        bugzilla username and userid.'''

        user = self.map_committer(committer)

        try:

            userid = self.get_user_id(user)

        except KeyError:

            try:

                defaultuser = self.ui.config('bugzilla', 'bzuser')

                if not defaultuser:

                    raise util.Abort(_('cannot find bugzilla user id for %s') %

                                     user)

                userid = self.get_user_id(defaultuser)

                user = defaultuser

            except KeyError:

                raise util.Abort(_('cannot find bugzilla user id for %s or %s') %

                                 (user, defaultuser))

        return (user, userid)