bugzilla.py
1215 lines
| 41.4 KiB
| text/x-python
|
PythonLexer
/ hgext / bugzilla.py
|
r2192 | # bugzilla.py - bugzilla integration for mercurial | ||
# | ||||
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||||
|
r21542 | # Copyright 2011-4 Jim Hague <jim.hague@acm.org> | ||
|
r2192 | # | ||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r7504 | |||
|
r8935 | '''hooks for integrating with the Bugzilla bug tracker | ||
|
r7504 | |||
|
r9252 | This hook extension adds comments on bugs in Bugzilla when changesets | ||
|
r13801 | that refer to bugs by Bugzilla ID are seen. The comment is formatted using | ||
the Mercurial template mechanism. | ||||
|
r7504 | |||
|
r16222 | The bug references can optionally include an update for Bugzilla of the | ||
|
r16223 | hours spent working on the bug. Bugs can also be marked fixed. | ||
|
r7504 | |||
|
r30923 | Four basic modes of access to Bugzilla are provided: | ||
1. Access via the Bugzilla REST-API. Requires bugzilla 5.0 or later. | ||||
|
r7504 | |||
|
r30923 | 2. Access via the Bugzilla XMLRPC interface. Requires Bugzilla 3.4 or later. | ||
|
r13802 | |||
|
r30923 | 3. Check data via the Bugzilla XMLRPC interface and submit bug change | ||
|
r13802 | via email to Bugzilla email interface. Requires Bugzilla 3.4 or later. | ||
|
r9203 | |||
|
r30923 | 4. Writing directly to the Bugzilla database. Only Bugzilla installations | ||
|
r13801 | using MySQL are supported. Requires Python MySQLdb. | ||
|
r9203 | |||
|
r13801 | 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 | ||||
|
r16222 | forward. Only adding comments is supported in this access mode. | ||
|
r9203 | |||
|
r13801 | 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 | ||||
|
r16223 | necessary to add comments. Marking bugs fixed requires Bugzilla 4.0 and later. | ||
|
r13801 | |||
|
r13871 | Access via XMLRPC/email uses XMLRPC to query Bugzilla, but sends | ||
|
r13802 | email to the Bugzilla email interface to submit comments to bugs. | ||
The From: address in the email is set to the email address of the Mercurial | ||||
user, so the comment appears to come from the Mercurial user. In the event | ||||
|
r17534 | that the Mercurial user email is not recognized by Bugzilla as a Bugzilla | ||
|
r13871 | user, the email associated with the Bugzilla username used to log into | ||
|
r16223 | Bugzilla is used instead as the source of the comment. Marking bugs fixed | ||
works on all supported Bugzilla versions. | ||||
|
r13802 | |||
|
r30923 | Access via the REST-API needs either a Bugzilla username and password | ||
or an apikey specified in the configuration. Comments are made under | ||||
|
r32602 | the given username or the user associated with the apikey in Bugzilla. | ||
|
r30923 | |||
|
r13802 | Configuration items common to all access modes: | ||
|
r9203 | |||
|
r13833 | bugzilla.version | ||
|
r17537 | The access type to use. Values recognized are: | ||
|
r13871 | |||
|
r30923 | :``restapi``: Bugzilla REST-API, Bugzilla 5.0 and later. | ||
|
r13883 | :``xmlrpc``: Bugzilla XMLRPC interface. | ||
:``xmlrpc+email``: Bugzilla XMLRPC and email interfaces. | ||||
:``3.0``: MySQL access, Bugzilla 3.0 and later. | ||||
:``2.18``: MySQL access, Bugzilla 2.18 and up to but not | ||||
including 3.0. | ||||
:``2.16``: MySQL access, Bugzilla 2.16 and up to but not | ||||
including 2.18. | ||||
|
r7985 | |||
|
r13833 | bugzilla.regexp | ||
|
r16223 | Regular expression to match bug IDs for update in changeset commit message. | ||
|
r16222 | It must contain one "()" named group ``<ids>`` containing the bug | ||
IDs separated by non-digit characters. It may also contain | ||||
a named group ``<hours>`` with a floating-point number giving the | ||||
hours worked on the bug. If no named groups are present, the first | ||||
"()" group is assumed to contain the bug IDs, and work time is not | ||||
updated. The default expression matches ``Bug 1234``, ``Bug no. 1234``, | ||||
``Bug number 1234``, ``Bugs 1234,5678``, ``Bug 1234 and 5678`` and | ||||
variations thereof, followed by an hours number prefixed by ``h`` or | ||||
``hours``, e.g. ``hours 1.5``. Matching is case insensitive. | ||||
|
r9203 | |||
|
r16223 | bugzilla.fixregexp | ||
Regular expression to match bug IDs for marking fixed in changeset | ||||
commit message. This must contain a "()" named group ``<ids>` containing | ||||
the bug IDs separated by non-digit characters. It may also contain | ||||
a named group ``<hours>`` with a floating-point number giving the | ||||
hours worked on the bug. If no named groups are present, the first | ||||
"()" group is assumed to contain the bug IDs, and work time is not | ||||
updated. The default expression matches ``Fixes 1234``, ``Fixes bug 1234``, | ||||
``Fixes bugs 1234,5678``, ``Fixes 1234 and 5678`` and | ||||
variations thereof, followed by an hours number prefixed by ``h`` or | ||||
``hours``, e.g. ``hours 1.5``. Matching is case insensitive. | ||||
bugzilla.fixstatus | ||||
The status to set a bug to when marking fixed. Default ``RESOLVED``. | ||||
bugzilla.fixresolution | ||||
The resolution to set a bug to when marking fixed. Default ``FIXED``. | ||||
|
r9203 | |||
|
r13833 | bugzilla.style | ||
|
r9203 | The style file to use when formatting comments. | ||
|
r13833 | bugzilla.template | ||
|
r9252 | Template to use when formatting comments. Overrides style if | ||
specified. In addition to the usual Mercurial keywords, the | ||||
|
r13884 | extension specifies: | ||
|
r9203 | |||
|
r13884 | :``{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. | ||||
|
r7504 | |||
|
r13842 | Default ``changeset {node|short} in repo {root} refers to bug | ||
{bug}.\\ndetails:\\n\\t{desc|tabindent}`` | ||||
|
r9203 | |||
|
r13833 | bugzilla.strip | ||
|
r13841 | 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. | ||||
|
r13801 | |||
|
r13833 | web.baseurl | ||
|
r13801 | Base URL for browsing Mercurial repositories. Referenced from | ||
|
r13896 | templates as ``{hgweb}``. | ||
|
r13801 | |||
|
r13802 | Configuration items common to XMLRPC+email and MySQL access modes: | ||
|
r13833 | bugzilla.usermap | ||
|
r13802 | Path of file containing Mercurial committer email to Bugzilla user email | ||
mappings. If specified, the file should contain one mapping per | ||||
|
r13835 | line:: | ||
committer = Bugzilla user | ||||
|
r13896 | See also the ``[usermap]`` section. | ||
|
r13802 | |||
|
r13836 | The ``[usermap]`` section is used to specify mappings of Mercurial | ||
|
r13834 | committer email to Bugzilla user email. See also ``bugzilla.usermap``. | ||
|
r13835 | Contains entries of the form ``committer = Bugzilla user``. | ||
|
r13802 | |||
|
r30923 | XMLRPC and REST-API access mode configuration: | ||
|
r13801 | |||
|
r13833 | bugzilla.bzurl | ||
|
r13801 | The base URL for the Bugzilla installation. | ||
|
r13841 | Default ``http://localhost/bugzilla``. | ||
|
r13801 | |||
|
r13833 | bugzilla.user | ||
|
r13841 | The username to use to log into Bugzilla via XMLRPC. Default | ||
``bugs``. | ||||
|
r13801 | |||
|
r13833 | bugzilla.password | ||
|
r13801 | The password for Bugzilla login. | ||
|
r30923 | REST-API access mode uses the options listed above as well as: | ||
bugzilla.apikey | ||||
An apikey generated on the Bugzilla instance for api access. | ||||
Using an apikey removes the need to store the user and password | ||||
options. | ||||
|
r13802 | XMLRPC+email access mode uses the XMLRPC access mode configuration items, | ||
and also: | ||||
|
r13833 | bugzilla.bzemail | ||
|
r13802 | The Bugzilla email address. | ||
In addition, the Mercurial email settings must be configured. See the | ||||
|
r13837 | documentation in hgrc(5), sections ``[email]`` and ``[smtp]``. | ||
|
r13802 | |||
|
r13801 | MySQL access mode configuration: | ||
|
r13833 | bugzilla.host | ||
|
r13801 | Hostname of the MySQL server holding the Bugzilla database. | ||
|
r13841 | Default ``localhost``. | ||
|
r13801 | |||
|
r13833 | bugzilla.db | ||
|
r13841 | Name of the Bugzilla database in MySQL. Default ``bugs``. | ||
|
r13801 | |||
|
r13833 | bugzilla.user | ||
|
r13841 | Username to use to access MySQL server. Default ``bugs``. | ||
|
r13801 | |||
|
r13833 | bugzilla.password | ||
|
r13801 | Password to use to access MySQL server. | ||
|
r13833 | bugzilla.timeout | ||
|
r13801 | Database connection timeout (seconds). Default 5. | ||
|
r13833 | bugzilla.bzuser | ||
|
r13801 | Fallback Bugzilla user name to record comments with, if changeset | ||
committer cannot be found as a Bugzilla user. | ||||
|
r13833 | bugzilla.bzdir | ||
|
r13801 | Bugzilla install directory. Used by default notify. Default | ||
|
r13841 | ``/var/www/html/bugzilla``. | ||
|
r13801 | |||
|
r13833 | bugzilla.notify | ||
|
r13801 | The command to run to get Bugzilla to send bug change notification | ||
|
r13841 | 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". | ||||
|
r7504 | |||
|
r9203 | Activating the extension:: | ||
|
r7504 | |||
[extensions] | ||||
|
r10112 | bugzilla = | ||
|
r7504 | |||
[hooks] | ||||
# run bugzilla hook on every change pulled or pushed in here | ||||
incoming.bugzilla = python:hgext.bugzilla.hook | ||||
|
r13801 | Example configurations: | ||
XMLRPC example configuration. This uses the Bugzilla at | ||||
|
r13841 | ``http://my-project.org/bugzilla``, logging in as user | ||
``bugmail@my-project.org`` with password ``plugh``. It is used with a | ||||
|
r13870 | collection of Mercurial repositories in ``/var/local/hg/repos/``, | ||
with a web interface at ``http://my-project.org/hg``. :: | ||||
|
r7504 | |||
|
r13801 | [bugzilla] | ||
bzurl=http://my-project.org/bugzilla | ||||
user=bugmail@my-project.org | ||||
password=plugh | ||||
version=xmlrpc | ||||
|
r13870 | template=Changeset {node|short} in {root|basename}. | ||
{hgweb}/{webroot}/rev/{node|short}\\n | ||||
{desc}\\n | ||||
strip=5 | ||||
|
r13801 | |||
[web] | ||||
baseurl=http://my-project.org/hg | ||||
|
r13802 | XMLRPC+email example configuration. This uses the Bugzilla at | ||
|
r13841 | ``http://my-project.org/bugzilla``, logging in as user | ||
|
r14619 | ``bugmail@my-project.org`` with password ``plugh``. It is used with a | ||
|
r13870 | collection of Mercurial repositories in ``/var/local/hg/repos/``, | ||
with a web interface at ``http://my-project.org/hg``. Bug comments | ||||
are sent to the Bugzilla email address | ||||
|
r13854 | ``bugzilla@my-project.org``. :: | ||
|
r13802 | |||
[bugzilla] | ||||
|
r13870 | bzurl=http://my-project.org/bugzilla | ||
|
r13802 | user=bugmail@my-project.org | ||
password=plugh | ||||
|
r21842 | version=xmlrpc+email | ||
|
r13802 | bzemail=bugzilla@my-project.org | ||
|
r13870 | template=Changeset {node|short} in {root|basename}. | ||
{hgweb}/{webroot}/rev/{node|short}\\n | ||||
{desc}\\n | ||||
strip=5 | ||||
|
r13802 | |||
[web] | ||||
|
r13870 | baseurl=http://my-project.org/hg | ||
[usermap] | ||||
user@emaildomain.com=user.name@bugzilladomain.com | ||||
|
r13802 | |||
|
r13870 | MySQL example configuration. This has 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``. It is used | ||||
with a collection of Mercurial repositories in ``/var/local/hg/repos/``, | ||||
with a web interface at ``http://my-project.org/hg``. :: | ||||
|
r7504 | |||
[bugzilla] | ||||
host=localhost | ||||
password=XYZZY | ||||
version=3.0 | ||||
bzuser=unknown@domain.com | ||||
|
r7618 | bzdir=/opt/bugzilla-3.2 | ||
|
r9204 | template=Changeset {node|short} in {root|basename}. | ||
{hgweb}/{webroot}/rev/{node|short}\\n | ||||
{desc}\\n | ||||
|
r7504 | strip=5 | ||
[web] | ||||
|
r13870 | baseurl=http://my-project.org/hg | ||
|
r7504 | |||
[usermap] | ||||
user@emaildomain.com=user.name@bugzilladomain.com | ||||
|
r13802 | All the above add a comment to the Bugzilla bug record of the form:: | ||
|
r7504 | |||
Changeset 3b16791d6642 in repository-name. | ||||
|
r13870 | http://my-project.org/hg/repository-name/rev/3b16791d6642 | ||
|
r7504 | |||
Changeset commit comment. Bug 1234. | ||||
''' | ||||
|
r2192 | |||
|
r28091 | from __future__ import absolute_import | ||
|
r30923 | import json | ||
|
r28091 | import re | ||
import time | ||||
|
r3891 | from mercurial.i18n import _ | ||
|
r6211 | from mercurial.node import short | ||
|
r28091 | from mercurial import ( | ||
error, | ||||
|
r35906 | logcmdutil, | ||
|
r28091 | mail, | ||
|
r41379 | pycompat, | ||
|
r33393 | registrar, | ||
|
r30923 | url, | ||
|
r28091 | util, | ||
) | ||||
|
r37102 | from mercurial.utils import ( | ||
|
r37138 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r2192 | |||
|
r29432 | xmlrpclib = util.xmlrpclib | ||
|
r29431 | |||
|
r29841 | # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | ||
|
r25186 | # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should | ||
# be specifying the version(s) of Mercurial they are tested with, or | ||||
# leave the attribute unspecified. | ||||
|
r43347 | testedwith = b'ships-with-hg-core' | ||
|
r16743 | |||
|
r33393 | configtable = {} | ||
configitem = registrar.configitem(configtable) | ||||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'apikey', default=b'', | ||
|
r33393 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'bzdir', default=b'/var/www/html/bugzilla', | ||
|
r43346 | ) | ||
configitem( | ||||
|
r43347 | b'bugzilla', b'bzemail', default=None, | ||
|
r33394 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'bzurl', default=b'http://localhost/bugzilla/', | ||
|
r33395 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'bzuser', default=None, | ||
|
r33396 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'db', default=b'bugs', | ||
|
r33397 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', | ||
b'fixregexp', | ||||
|
r43346 | default=( | ||
br'fix(?:es)?\s*(?:bugs?\s*)?,?\s*' | ||||
br'(?:nos?\.?|num(?:ber)?s?)?\s*' | ||||
br'(?P<ids>(?:#?\d+\s*(?:,?\s*(?:and)?)?\s*)+)' | ||||
br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?' | ||||
), | ||||
|
r33399 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'fixresolution', default=b'FIXED', | ||
|
r33400 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'fixstatus', default=b'RESOLVED', | ||
|
r33401 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'host', default=b'localhost', | ||
|
r33402 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'notify', default=configitem.dynamicdefault, | ||
|
r33524 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'password', default=None, | ||
|
r33433 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', | ||
b'regexp', | ||||
|
r43346 | default=( | ||
br'bugs?\s*,?\s*(?:#|nos?\.?|num(?:ber)?s?)?\s*' | ||||
br'(?P<ids>(?:\d+\s*(?:,?\s*(?:and)?)?\s*)+)' | ||||
br'\.?\s*(?:h(?:ours?)?\s*(?P<hours>\d*(?:\.\d+)?))?' | ||||
), | ||||
|
r33462 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'strip', default=0, | ||
|
r33463 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'style', default=None, | ||
|
r33464 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'template', default=None, | ||
|
r33465 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'timeout', default=5, | ||
|
r33466 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'user', default=b'bugs', | ||
|
r33467 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'usermap', default=None, | ||
|
r33468 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'bugzilla', b'version', default=None, | ||
|
r33469 | ) | ||
|
r33393 | |||
|
r43346 | |||
|
r13800 | class bzaccess(object): | ||
'''Base class for access to Bugzilla.''' | ||||
|
r2192 | |||
def __init__(self, ui): | ||||
self.ui = ui | ||||
|
r43347 | usermap = self.ui.config(b'bugzilla', b'usermap') | ||
|
r13800 | if usermap: | ||
|
r43347 | self.ui.readconfig(usermap, sections=[b'usermap']) | ||
|
r13800 | |||
def map_committer(self, user): | ||||
'''map name of committer to Bugzilla user name.''' | ||||
|
r43347 | for committer, bzuser in self.ui.configitems(b'usermap'): | ||
|
r13800 | if committer.lower() == user.lower(): | ||
return bzuser | ||||
return user | ||||
# Methods to be implemented by access classes. | ||||
|
r16221 | # | ||
# 'bugs' is a dict keyed on bug id, where values are a dict holding | ||||
|
r17534 | # updates to bug state. Recognized dict keys are: | ||
|
r16222 | # | ||
# 'hours': Value, float containing work hours to be updated. | ||||
|
r16223 | # 'fix': If key present, bug is to be marked fixed. Value ignored. | ||
|
r16222 | |||
|
r16221 | def filter_real_bug_ids(self, bugs): | ||
'''remove bug IDs that do not exist in Bugzilla from bugs.''' | ||||
|
r13800 | |||
|
r16221 | def filter_cset_known_bug_ids(self, node, bugs): | ||
'''remove bug IDs where node occurs in comment text from bugs.''' | ||||
|
r13800 | |||
|
r16221 | def updatebug(self, bugid, newstate, text, committer): | ||
'''update the specified bug. Add comment text and set new states. | ||||
|
r13800 | |||
If possible add the comment as being from the committer of | ||||
the changeset. Otherwise use the default Bugzilla user. | ||||
''' | ||||
|
r16221 | def notify(self, bugs, committer): | ||
'''Force sending of Bugzilla notification emails. | ||||
Only required if the access method does not trigger notification | ||||
emails automatically. | ||||
''' | ||||
|
r13800 | |||
|
r43346 | |||
|
r13800 | # 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. | ||||
|
r13801 | |||
|
r16226 | If your Bugzilla is version 3.4 or above, you are strongly | ||
|
r13801 | recommended to use the XMLRPC access method instead. | ||
|
r13800 | ''' | ||
@staticmethod | ||||
def sql_buglist(ids): | ||||
'''return SQL-friendly list of bug ids''' | ||||
|
r43347 | return b'(' + b','.join(map(str, ids)) + b')' | ||
|
r13800 | |||
_MySQLdb = None | ||||
def __init__(self, ui): | ||||
try: | ||||
import MySQLdb as mysql | ||||
|
r43346 | |||
|
r13800 | bzmysql._MySQLdb = mysql | ||
|
r25660 | except ImportError as err: | ||
|
r43347 | raise error.Abort( | ||
_(b'python mysql support not available: %s') % err | ||||
) | ||||
|
r13800 | |||
bzaccess.__init__(self, ui) | ||||
|
r43347 | host = self.ui.config(b'bugzilla', b'host') | ||
user = self.ui.config(b'bugzilla', b'user') | ||||
passwd = self.ui.config(b'bugzilla', b'password') | ||||
db = self.ui.config(b'bugzilla', b'db') | ||||
timeout = int(self.ui.config(b'bugzilla', b'timeout')) | ||||
|
r43346 | self.ui.note( | ||
|
r43347 | _(b'connecting to %s:%s as %s, password %s\n') | ||
% (host, db, user, b'*' * len(passwd)) | ||||
|
r43346 | ) | ||
self.conn = bzmysql._MySQLdb.connect( | ||||
host=host, user=user, passwd=passwd, db=db, connect_timeout=timeout | ||||
) | ||||
|
r2192 | self.cursor = self.conn.cursor() | ||
|
r7019 | self.longdesc_id = self.get_longdesc_id() | ||
|
r2192 | self.user_ids = {} | ||
|
r43347 | self.default_notify = b"cd %(bzdir)s && ./processmail %(id)s %(user)s" | ||
|
r2192 | |||
def run(self, *args, **kwargs): | ||||
'''run a query.''' | ||||
|
r43347 | self.ui.note(_(b'query: %s %s\n') % (args, kwargs)) | ||
|
r2192 | try: | ||
self.cursor.execute(*args, **kwargs) | ||||
|
r13800 | except bzmysql._MySQLdb.MySQLError: | ||
|
r43347 | self.ui.note(_(b'failed query: %s %s\n') % (args, kwargs)) | ||
|
r2192 | raise | ||
|
r7019 | def get_longdesc_id(self): | ||
'''get identity of longdesc field''' | ||||
|
r43347 | self.run(b'select fieldid from fielddefs where name = "longdesc"') | ||
|
r7019 | ids = self.cursor.fetchall() | ||
if len(ids) != 1: | ||||
|
r43347 | raise error.Abort(_(b'unknown database schema')) | ||
|
r7019 | return ids[0][0] | ||
|
r16221 | def filter_real_bug_ids(self, bugs): | ||
'''filter not-existing bugs from set.''' | ||||
|
r43346 | self.run( | ||
|
r43347 | b'select bug_id from bugs where bug_id in %s' | ||
|
r43346 | % bzmysql.sql_buglist(bugs.keys()) | ||
) | ||||
|
r16221 | existing = [id for (id,) in self.cursor.fetchall()] | ||
for id in bugs.keys(): | ||||
if id not in existing: | ||||
|
r43347 | self.ui.status(_(b'bug %d does not exist\n') % id) | ||
|
r16221 | del bugs[id] | ||
|
r2192 | |||
|
r16221 | def filter_cset_known_bug_ids(self, node, bugs): | ||
|
r13799 | '''filter bug ids that already refer to this changeset from set.''' | ||
|
r43346 | self.run( | ||
'''select bug_id from longdescs where | ||||
bug_id in %s and thetext like "%%%s%%"''' | ||||
% (bzmysql.sql_buglist(bugs.keys()), short(node)) | ||||
) | ||||
|
r2192 | for (id,) in self.cursor.fetchall(): | ||
|
r43346 | self.ui.status( | ||
|
r43347 | _(b'bug %d already knows about changeset %s\n') | ||
|
r43346 | % (id, short(node)) | ||
) | ||||
|
r16221 | del bugs[id] | ||
|
r2192 | |||
|
r16221 | def notify(self, bugs, committer): | ||
|
r2192 | '''tell bugzilla to send mail.''' | ||
|
r43347 | self.ui.status(_(b'telling bugzilla to send mail:\n')) | ||
|
r7618 | (user, userid) = self.get_bugzilla_user(committer) | ||
|
r16221 | for id in bugs.keys(): | ||
|
r43347 | self.ui.status(_(b' bug %s\n') % id) | ||
cmdfmt = self.ui.config(b'bugzilla', b'notify', self.default_notify) | ||||
bzdir = self.ui.config(b'bugzilla', b'bzdir') | ||||
|
r7618 | try: | ||
# Backwards-compatible with old notify string, which | ||||
# took one string. This will throw with a new format | ||||
# string. | ||||
cmd = cmdfmt % id | ||||
except TypeError: | ||||
|
r43347 | cmd = cmdfmt % {b'bzdir': bzdir, b'id': id, b'user': user} | ||
self.ui.note(_(b'running notify command %s\n') % cmd) | ||||
fp = procutil.popen(b'(%s) 2>&1' % cmd, b'rb') | ||||
|
r37476 | out = util.fromnativeeol(fp.read()) | ||
|
r2192 | ret = fp.close() | ||
if ret: | ||||
self.ui.warn(out) | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'bugzilla notify command %s') % procutil.explainexit(ret) | ||
|
r43346 | ) | ||
|
r43347 | self.ui.status(_(b'done\n')) | ||
|
r2192 | |||
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: | ||||
|
r43347 | self.ui.note(_(b'looking up user %s\n') % user) | ||
|
r43346 | self.run( | ||
'''select userid from profiles | ||||
where login_name like %s''', | ||||
user, | ||||
) | ||||
|
r2192 | all = self.cursor.fetchall() | ||
if len(all) != 1: | ||||
raise KeyError(user) | ||||
userid = int(all[0][0]) | ||||
self.user_ids[user] = userid | ||||
return userid | ||||
|
r7618 | def get_bugzilla_user(self, committer): | ||
|
r13801 | '''See if committer is a registered bugzilla user. Return | ||
|
r7618 | bugzilla username and userid if so. If not, return default | ||
bugzilla username and userid.''' | ||||
|
r2306 | user = self.map_committer(committer) | ||
|
r2192 | try: | ||
|
r2306 | userid = self.get_user_id(user) | ||
|
r2192 | except KeyError: | ||
try: | ||||
|
r43347 | defaultuser = self.ui.config(b'bugzilla', b'bzuser') | ||
|
r2306 | if not defaultuser: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'cannot find bugzilla user id for %s') % user | ||
|
r43346 | ) | ||
|
r2192 | userid = self.get_user_id(defaultuser) | ||
|
r7618 | user = defaultuser | ||
|
r2192 | except KeyError: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'cannot find bugzilla user id for %s or %s') | ||
|
r43346 | % (user, defaultuser) | ||
) | ||||
|
r7618 | return (user, userid) | ||
|
r16221 | def updatebug(self, bugid, newstate, text, committer): | ||
'''update bug state with comment text. | ||||
Try adding comment as committer of changeset, otherwise as | ||||
default bugzilla user.''' | ||||
|
r16222 | if len(newstate) > 0: | ||
|
r43347 | self.ui.warn(_(b"Bugzilla/MySQL cannot update bug state\n")) | ||
|
r16222 | |||
|
r7618 | (user, userid) = self.get_bugzilla_user(committer) | ||
|
r35152 | now = time.strftime(r'%Y-%m-%d %H:%M:%S') | ||
|
r43346 | self.run( | ||
'''insert into longdescs | ||||
|
r2192 | (bug_id, who, bug_when, thetext) | ||
values (%s, %s, %s, %s)''', | ||||
|
r43346 | (bugid, userid, now, text), | ||
) | ||||
self.run( | ||||
'''insert into bugs_activity (bug_id, who, bug_when, fieldid) | ||||
|
r2192 | values (%s, %s, %s, %s)''', | ||
|
r43346 | (bugid, userid, now, self.longdesc_id), | ||
) | ||||
|
r7493 | self.conn.commit() | ||
|
r2192 | |||
|
r43346 | |||
|
r13800 | class bzmysql_2_18(bzmysql): | ||
|
r7618 | '''support for bugzilla 2.18 series.''' | ||
def __init__(self, ui): | ||||
|
r13800 | bzmysql.__init__(self, ui) | ||
|
r41925 | self.default_notify = ( | ||
|
r43347 | b"cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s" | ||
|
r43346 | ) | ||
|
r7618 | |||
|
r13800 | class bzmysql_3_0(bzmysql_2_18): | ||
|
r7019 | '''support for bugzilla 3.0 series.''' | ||
def __init__(self, ui): | ||||
|
r13800 | bzmysql_2_18.__init__(self, ui) | ||
|
r7019 | |||
def get_longdesc_id(self): | ||||
'''get identity of longdesc field''' | ||||
|
r43347 | self.run(b'select id from fielddefs where name = "longdesc"') | ||
|
r7019 | ids = self.cursor.fetchall() | ||
if len(ids) != 1: | ||||
|
r43347 | raise error.Abort(_(b'unknown database schema')) | ||
|
r7019 | return ids[0][0] | ||
|
r43346 | |||
|
r17424 | # Bugzilla via XMLRPC interface. | ||
|
r13801 | |||
|
r43346 | |||
|
r15870 | class cookietransportrequest(object): | ||
"""A Transport request method that retains cookies over its lifetime. | ||||
|
r13801 | |||
The regular xmlrpclib transports ignore cookies. Which causes | ||||
a bit of a problem when you need a cookie-based login, as with | ||||
|
r21542 | the Bugzilla XMLRPC interface prior to 4.4.3. | ||
|
r13801 | |||
|
r15870 | So this is a helper for defining a Transport which looks for | ||
cookies being set in responses and saves them to add to all future | ||||
requests. | ||||
|
r13801 | """ | ||
# Inspiration drawn from | ||||
# http://blog.godson.in/2010/09/how-to-make-python-xmlrpclib-client.html | ||||
# http://www.itkovian.net/base/transport-class-for-pythons-xml-rpc-lib/ | ||||
cookies = [] | ||||
|
r43346 | |||
|
r13801 | def send_cookies(self, connection): | ||
if self.cookies: | ||||
for cookie in self.cookies: | ||||
|
r43347 | connection.putheader(b"Cookie", cookie) | ||
|
r13801 | |||
def request(self, host, handler, request_body, verbose=0): | ||||
self.verbose = verbose | ||||
|
r16193 | self.accept_gzip_encoding = False | ||
|
r13801 | |||
# issue XML-RPC request | ||||
h = self.make_connection(host) | ||||
if verbose: | ||||
h.set_debuglevel(1) | ||||
self.send_request(h, handler, request_body) | ||||
self.send_host(h, host) | ||||
self.send_cookies(h) | ||||
self.send_user_agent(h) | ||||
self.send_content(h, request_body) | ||||
|
r30478 | # Deal with differences between Python 2.6 and 2.7. | ||
|
r13801 | # In the former h is a HTTP(S). In the latter it's a | ||
|
r30478 | # HTTP(S)Connection. Luckily, the 2.6 implementation of | ||
|
r13801 | # HTTP(S) has an underlying HTTP(S)Connection, so extract | ||
# that and use it. | ||||
try: | ||||
response = h.getresponse() | ||||
except AttributeError: | ||||
response = h._conn.getresponse() | ||||
# Add any cookie definitions to our list. | ||||
|
r43347 | for header in response.msg.getallmatchingheaders(b"Set-Cookie"): | ||
val = header.split(b": ", 1)[1] | ||||
cookie = val.split(b";", 1)[0] | ||||
|
r13801 | self.cookies.append(cookie) | ||
if response.status != 200: | ||||
|
r43346 | raise xmlrpclib.ProtocolError( | ||
host + handler, | ||||
response.status, | ||||
response.reason, | ||||
response.msg.headers, | ||||
) | ||||
|
r13801 | |||
payload = response.read() | ||||
parser, unmarshaller = self.getparser() | ||||
parser.feed(payload) | ||||
parser.close() | ||||
return unmarshaller.close() | ||||
|
r43346 | |||
|
r15870 | # The explicit calls to the underlying xmlrpclib __init__() methods are | ||
# necessary. The xmlrpclib.Transport classes are old-style classes, and | ||||
# it turns out their __init__() doesn't get called when doing multiple | ||||
# inheritance with a new-style class. | ||||
class cookietransport(cookietransportrequest, xmlrpclib.Transport): | ||||
def __init__(self, use_datetime=0): | ||||
|
r43385 | if util.safehasattr(xmlrpclib.Transport, "__init__"): | ||
|
r16649 | xmlrpclib.Transport.__init__(self, use_datetime) | ||
|
r15870 | |||
|
r43346 | |||
|
r15870 | class cookiesafetransport(cookietransportrequest, xmlrpclib.SafeTransport): | ||
def __init__(self, use_datetime=0): | ||||
|
r43385 | if util.safehasattr(xmlrpclib.Transport, "__init__"): | ||
|
r16649 | xmlrpclib.SafeTransport.__init__(self, use_datetime) | ||
|
r15870 | |||
|
r43346 | |||
|
r13801 | class bzxmlrpc(bzaccess): | ||
"""Support for access to Bugzilla via the Bugzilla XMLRPC API. | ||||
Requires a minimum Bugzilla version 3.4. | ||||
""" | ||||
def __init__(self, ui): | ||||
bzaccess.__init__(self, ui) | ||||
|
r43347 | bzweb = self.ui.config(b'bugzilla', b'bzurl') | ||
bzweb = bzweb.rstrip(b"/") + b"/xmlrpc.cgi" | ||||
|
r13801 | |||
|
r43347 | user = self.ui.config(b'bugzilla', b'user') | ||
passwd = self.ui.config(b'bugzilla', b'password') | ||||
|
r13801 | |||
|
r43347 | self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus') | ||
self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution') | ||||
|
r16223 | |||
|
r15870 | self.bzproxy = xmlrpclib.ServerProxy(bzweb, self.transport(bzweb)) | ||
|
r43347 | ver = self.bzproxy.Bugzilla.version()[b'version'].split(b'.') | ||
|
r16224 | self.bzvermajor = int(ver[0]) | ||
self.bzverminor = int(ver[1]) | ||||
|
r43346 | login = self.bzproxy.User.login( | ||
|
r43347 | {b'login': user, b'password': passwd, b'restrict_login': True} | ||
|
r43346 | ) | ||
|
r43347 | self.bztoken = login.get(b'token', b'') | ||
|
r13801 | |||
|
r15870 | def transport(self, uri): | ||
|
r43347 | if util.urlreq.urlparse(uri, b"http")[0] == b"https": | ||
|
r15870 | return cookiesafetransport() | ||
else: | ||||
return cookietransport() | ||||
|
r13801 | def get_bug_comments(self, id): | ||
"""Return a string with all comment text for a bug.""" | ||||
|
r43346 | c = self.bzproxy.Bug.comments( | ||
|
r43347 | {b'ids': [id], b'include_fields': [b'text'], b'token': self.bztoken} | ||
|
r43346 | ) | ||
|
r43347 | return b''.join( | ||
[t[b'text'] for t in c[b'bugs'][b'%d' % id][b'comments']] | ||||
) | ||||
|
r13801 | |||
|
r16221 | def filter_real_bug_ids(self, bugs): | ||
|
r43346 | probe = self.bzproxy.Bug.get( | ||
{ | ||||
|
r43347 | b'ids': sorted(bugs.keys()), | ||
b'include_fields': [], | ||||
b'permissive': True, | ||||
b'token': self.bztoken, | ||||
|
r43346 | } | ||
) | ||||
|
r43347 | for badbug in probe[b'faults']: | ||
id = badbug[b'id'] | ||||
self.ui.status(_(b'bug %d does not exist\n') % id) | ||||
|
r16221 | del bugs[id] | ||
|
r13801 | |||
|
r16221 | def filter_cset_known_bug_ids(self, node, bugs): | ||
for id in sorted(bugs.keys()): | ||||
|
r13801 | if self.get_bug_comments(id).find(short(node)) != -1: | ||
|
r43346 | self.ui.status( | ||
|
r43347 | _(b'bug %d already knows about changeset %s\n') | ||
|
r43346 | % (id, short(node)) | ||
) | ||||
|
r16221 | del bugs[id] | ||
|
r13801 | |||
|
r16221 | def updatebug(self, bugid, newstate, text, committer): | ||
|
r16223 | args = {} | ||
|
r43347 | if b'hours' in newstate: | ||
args[b'work_time'] = newstate[b'hours'] | ||||
|
r13801 | |||
|
r16223 | if self.bzvermajor >= 4: | ||
|
r43347 | args[b'ids'] = [bugid] | ||
args[b'comment'] = {b'body': text} | ||||
if b'fix' in newstate: | ||||
args[b'status'] = self.fixstatus | ||||
args[b'resolution'] = self.fixresolution | ||||
args[b'token'] = self.bztoken | ||||
|
r16223 | self.bzproxy.Bug.update(args) | ||
else: | ||||
|
r43347 | if b'fix' in newstate: | ||
|
r43346 | self.ui.warn( | ||
_( | ||||
|
r43347 | b"Bugzilla/XMLRPC needs Bugzilla 4.0 or later " | ||
b"to mark bugs fixed\n" | ||||
|
r43346 | ) | ||
) | ||||
|
r43347 | args[b'id'] = bugid | ||
args[b'comment'] = text | ||||
|
r16223 | self.bzproxy.Bug.add_comment(args) | ||
|
r13801 | |||
|
r43346 | |||
|
r13802 | class bzxmlrpcemail(bzxmlrpc): | ||
"""Read data from Bugzilla via XMLRPC, send updates via email. | ||||
Advantages of sending updates via email: | ||||
1. Comments can be added as any user, not just logged in user. | ||||
|
r16222 | 2. Bug statuses or other fields not accessible via XMLRPC can | ||
potentially be updated. | ||||
|
r16223 | There is no XMLRPC function to change bug status before Bugzilla | ||
4.0, so bugs cannot be marked fixed via XMLRPC before Bugzilla 4.0. | ||||
But bugs can be marked fixed via email from 3.4 onwards. | ||||
|
r13802 | """ | ||
|
r16224 | # The email interface changes subtly between 3.4 and 3.6. In 3.4, | ||
# in-email fields are specified as '@<fieldname> = <value>'. In | ||||
# 3.6 this becomes '@<fieldname> <value>'. And fieldname @bug_id | ||||
# in 3.4 becomes @id in 3.6. 3.6 and 4.0 both maintain backwards | ||||
# compatibility, but rather than rely on this use the new format for | ||||
# 4.0 onwards. | ||||
|
r13802 | def __init__(self, ui): | ||
bzxmlrpc.__init__(self, ui) | ||||
|
r43347 | self.bzemail = self.ui.config(b'bugzilla', b'bzemail') | ||
|
r13802 | if not self.bzemail: | ||
|
r43347 | raise error.Abort(_(b"configuration 'bzemail' missing")) | ||
|
r13802 | mail.validateconfig(self.ui) | ||
|
r16224 | def makecommandline(self, fieldname, value): | ||
if self.bzvermajor >= 4: | ||||
|
r43347 | return b"@%s %s" % (fieldname, pycompat.bytestr(value)) | ||
|
r16224 | else: | ||
|
r43347 | if fieldname == b"id": | ||
fieldname = b"bug_id" | ||||
return b"@%s = %s" % (fieldname, pycompat.bytestr(value)) | ||||
|
r16224 | |||
|
r13802 | def send_bug_modify_email(self, bugid, commands, comment, committer): | ||
'''send modification message to Bugzilla bug via email. | ||||
The message format is documented in the Bugzilla email_in.pl | ||||
specification. commands is a list of command lines, comment is the | ||||
comment text. | ||||
To stop users from crafting commit comments with | ||||
Bugzilla commands, specify the bug ID via the message body, rather | ||||
than the subject line, and leave a blank line after it. | ||||
''' | ||||
user = self.map_committer(committer) | ||||
|
r43346 | matches = self.bzproxy.User.get( | ||
|
r43347 | {b'match': [user], b'token': self.bztoken} | ||
|
r43346 | ) | ||
|
r43347 | if not matches[b'users']: | ||
user = self.ui.config(b'bugzilla', b'user') | ||||
|
r43346 | matches = self.bzproxy.User.get( | ||
|
r43347 | {b'match': [user], b'token': self.bztoken} | ||
|
r43346 | ) | ||
|
r43347 | if not matches[b'users']: | ||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b"default bugzilla user %s email not found") % user | ||
|
r43346 | ) | ||
|
r43347 | user = matches[b'users'][0][b'email'] | ||
commands.append(self.makecommandline(b"id", bugid)) | ||||
|
r13802 | |||
|
r43347 | text = b"\n".join(commands) + b"\n\n" + comment | ||
|
r13802 | |||
_charsets = mail._charsets(self.ui) | ||||
user = mail.addressencode(self.ui, user, _charsets) | ||||
bzemail = mail.addressencode(self.ui, self.bzemail, _charsets) | ||||
msg = mail.mimeencode(self.ui, text, _charsets) | ||||
|
r43347 | msg[b'From'] = user | ||
msg[b'To'] = bzemail | ||||
msg[b'Subject'] = mail.headencode( | ||||
self.ui, b"Bug modification", _charsets | ||||
) | ||||
|
r13802 | sendmail = mail.connect(self.ui) | ||
sendmail(user, bzemail, msg.as_string()) | ||||
|
r16221 | def updatebug(self, bugid, newstate, text, committer): | ||
|
r16222 | cmds = [] | ||
|
r43347 | if b'hours' in newstate: | ||
cmds.append(self.makecommandline(b"work_time", newstate[b'hours'])) | ||||
if b'fix' in newstate: | ||||
cmds.append(self.makecommandline(b"bug_status", self.fixstatus)) | ||||
cmds.append(self.makecommandline(b"resolution", self.fixresolution)) | ||||
|
r16222 | self.send_bug_modify_email(bugid, cmds, text, committer) | ||
|
r13802 | |||
|
r43346 | |||
|
r30923 | class NotFound(LookupError): | ||
pass | ||||
|
r43346 | |||
|
r30923 | class bzrestapi(bzaccess): | ||
"""Read and write bugzilla data using the REST API available since | ||||
Bugzilla 5.0. | ||||
""" | ||||
|
r43346 | |||
|
r30923 | def __init__(self, ui): | ||
bzaccess.__init__(self, ui) | ||||
|
r43347 | bz = self.ui.config(b'bugzilla', b'bzurl') | ||
self.bzroot = b'/'.join([bz, b'rest']) | ||||
self.apikey = self.ui.config(b'bugzilla', b'apikey') | ||||
self.user = self.ui.config(b'bugzilla', b'user') | ||||
self.passwd = self.ui.config(b'bugzilla', b'password') | ||||
self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus') | ||||
self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution') | ||||
|
r30923 | |||
def apiurl(self, targets, include_fields=None): | ||||
|
r43347 | url = b'/'.join([self.bzroot] + [pycompat.bytestr(t) for t in targets]) | ||
|
r30923 | qv = {} | ||
if self.apikey: | ||||
|
r43347 | qv[b'api_key'] = self.apikey | ||
|
r30923 | elif self.user and self.passwd: | ||
|
r43347 | qv[b'login'] = self.user | ||
qv[b'password'] = self.passwd | ||||
|
r30923 | if include_fields: | ||
|
r43347 | qv[b'include_fields'] = include_fields | ||
|
r30923 | if qv: | ||
|
r43347 | url = b'%s?%s' % (url, util.urlreq.urlencode(qv)) | ||
|
r30923 | return url | ||
def _fetch(self, burl): | ||||
try: | ||||
resp = url.open(self.ui, burl) | ||||
|
r43697 | return pycompat.json_loads(resp.read()) | ||
|
r30923 | except util.urlerr.httperror as inst: | ||
if inst.code == 401: | ||||
|
r43347 | raise error.Abort(_(b'authorization failed')) | ||
|
r30923 | if inst.code == 404: | ||
raise NotFound() | ||||
else: | ||||
raise | ||||
|
r43347 | def _submit(self, burl, data, method=b'POST'): | ||
|
r30923 | data = json.dumps(data) | ||
|
r43347 | if method == b'PUT': | ||
|
r43346 | |||
|
r30923 | class putrequest(util.urlreq.request): | ||
def get_method(self): | ||||
|
r43347 | return b'PUT' | ||
|
r43346 | |||
|
r30923 | request_type = putrequest | ||
else: | ||||
request_type = util.urlreq.request | ||||
|
r43347 | req = request_type(burl, data, {b'Content-Type': b'application/json'}) | ||
|
r30923 | try: | ||
resp = url.opener(self.ui).open(req) | ||||
|
r43697 | return pycompat.json_loads(resp.read()) | ||
|
r30923 | except util.urlerr.httperror as inst: | ||
if inst.code == 401: | ||||
|
r43347 | raise error.Abort(_(b'authorization failed')) | ||
|
r30923 | if inst.code == 404: | ||
raise NotFound() | ||||
else: | ||||
raise | ||||
def filter_real_bug_ids(self, bugs): | ||||
'''remove bug IDs that do not exist in Bugzilla from bugs.''' | ||||
badbugs = set() | ||||
for bugid in bugs: | ||||
|
r43347 | burl = self.apiurl((b'bug', bugid), include_fields=b'status') | ||
|
r30923 | try: | ||
self._fetch(burl) | ||||
except NotFound: | ||||
badbugs.add(bugid) | ||||
for bugid in badbugs: | ||||
del bugs[bugid] | ||||
def filter_cset_known_bug_ids(self, node, bugs): | ||||
'''remove bug IDs where node occurs in comment text from bugs.''' | ||||
sn = short(node) | ||||
for bugid in bugs.keys(): | ||||
|
r43347 | burl = self.apiurl( | ||
(b'bug', bugid, b'comment'), include_fields=b'text' | ||||
) | ||||
|
r30923 | result = self._fetch(burl) | ||
|
r43347 | comments = result[b'bugs'][pycompat.bytestr(bugid)][b'comments'] | ||
if any(sn in c[b'text'] for c in comments): | ||||
|
r43346 | self.ui.status( | ||
|
r43347 | _(b'bug %d already knows about changeset %s\n') | ||
% (bugid, sn) | ||||
|
r43346 | ) | ||
|
r30923 | del bugs[bugid] | ||
def updatebug(self, bugid, newstate, text, committer): | ||||
'''update the specified bug. Add comment text and set new states. | ||||
If possible add the comment as being from the committer of | ||||
the changeset. Otherwise use the default Bugzilla user. | ||||
''' | ||||
bugmod = {} | ||||
|
r43347 | if b'hours' in newstate: | ||
bugmod[b'work_time'] = newstate[b'hours'] | ||||
if b'fix' in newstate: | ||||
bugmod[b'status'] = self.fixstatus | ||||
bugmod[b'resolution'] = self.fixresolution | ||||
|
r30923 | if bugmod: | ||
# if we have to change the bugs state do it here | ||||
|
r43347 | bugmod[b'comment'] = { | ||
b'comment': text, | ||||
b'is_private': False, | ||||
b'is_markdown': False, | ||||
|
r30923 | } | ||
|
r43347 | burl = self.apiurl((b'bug', bugid)) | ||
self._submit(burl, bugmod, method=b'PUT') | ||||
self.ui.debug(b'updated bug %s\n' % bugid) | ||||
|
r30923 | else: | ||
|
r43347 | burl = self.apiurl((b'bug', bugid, b'comment')) | ||
|
r43346 | self._submit( | ||
burl, | ||||
|
r43347 | { | ||
b'comment': text, | ||||
b'is_private': False, | ||||
b'is_markdown': False, | ||||
}, | ||||
|
r43346 | ) | ||
|
r43347 | self.ui.debug(b'added comment to bug %s\n' % bugid) | ||
|
r30923 | |||
def notify(self, bugs, committer): | ||||
'''Force sending of Bugzilla notification emails. | ||||
Only required if the access method does not trigger notification | ||||
emails automatically. | ||||
''' | ||||
pass | ||||
|
r43346 | |||
|
r2192 | class bugzilla(object): | ||
# supported versions of bugzilla. different versions have | ||||
# different schemas. | ||||
_versions = { | ||||
|
r43347 | b'2.16': bzmysql, | ||
b'2.18': bzmysql_2_18, | ||||
b'3.0': bzmysql_3_0, | ||||
b'xmlrpc': bzxmlrpc, | ||||
b'xmlrpc+email': bzxmlrpcemail, | ||||
b'restapi': bzrestapi, | ||||
|
r43346 | } | ||
|
r2192 | |||
def __init__(self, ui, repo): | ||||
self.ui = ui | ||||
self.repo = repo | ||||
|
r43347 | bzversion = self.ui.config(b'bugzilla', b'version') | ||
|
r21855 | try: | ||
bzclass = bugzilla._versions[bzversion] | ||||
except KeyError: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'bugzilla version %s not supported') % bzversion | ||
|
r43346 | ) | ||
|
r21855 | self.bzdriver = bzclass(self.ui) | ||
|
r2192 | |||
|
r21855 | self.bug_re = re.compile( | ||
|
r43347 | self.ui.config(b'bugzilla', b'regexp'), re.IGNORECASE | ||
|
r43346 | ) | ||
|
r21855 | self.fix_re = re.compile( | ||
|
r43347 | self.ui.config(b'bugzilla', b'fixregexp'), re.IGNORECASE | ||
|
r43346 | ) | ||
|
r41379 | self.split_re = re.compile(br'\D+') | ||
|
r2192 | |||
|
r16221 | def find_bugs(self, ctx): | ||
'''return bugs dictionary created from commit comment. | ||||
|
r2192 | |||
|
r16221 | Extract bug info from changeset comments. Filter out any that are | ||
|
r13799 | not known to Bugzilla, and any that already have a reference to | ||
the given changeset in their comments. | ||||
''' | ||||
|
r2192 | start = 0 | ||
|
r16222 | hours = 0.0 | ||
|
r16221 | bugs = {} | ||
|
r21855 | bugmatch = self.bug_re.search(ctx.description(), start) | ||
fixmatch = self.fix_re.search(ctx.description(), start) | ||||
|
r2192 | while True: | ||
|
r16222 | bugattribs = {} | ||
|
r16223 | if not bugmatch and not fixmatch: | ||
|
r2192 | break | ||
|
r16223 | if not bugmatch: | ||
m = fixmatch | ||||
elif not fixmatch: | ||||
m = bugmatch | ||||
else: | ||||
if bugmatch.start() < fixmatch.start(): | ||||
m = bugmatch | ||||
else: | ||||
m = fixmatch | ||||
|
r2192 | start = m.end() | ||
|
r16223 | if m is bugmatch: | ||
|
r21855 | bugmatch = self.bug_re.search(ctx.description(), start) | ||
|
r43347 | if b'fix' in bugattribs: | ||
del bugattribs[b'fix'] | ||||
|
r16223 | else: | ||
|
r21855 | fixmatch = self.fix_re.search(ctx.description(), start) | ||
|
r43347 | bugattribs[b'fix'] = None | ||
|
r16223 | |||
|
r16222 | try: | ||
|
r43347 | ids = m.group(b'ids') | ||
|
r16222 | except IndexError: | ||
ids = m.group(1) | ||||
try: | ||||
|
r43347 | hours = float(m.group(b'hours')) | ||
bugattribs[b'hours'] = hours | ||||
|
r16222 | except IndexError: | ||
pass | ||||
except TypeError: | ||||
pass | ||||
except ValueError: | ||||
|
r43347 | self.ui.status(_(b"%s: invalid hours\n") % m.group(b'hours')) | ||
|
r16222 | |||
|
r21855 | for id in self.split_re.split(ids): | ||
|
r10282 | if not id: | ||
continue | ||||
|
r16222 | bugs[int(id)] = bugattribs | ||
|
r16221 | if bugs: | ||
|
r21855 | self.bzdriver.filter_real_bug_ids(bugs) | ||
|
r16221 | if bugs: | ||
|
r21855 | self.bzdriver.filter_cset_known_bug_ids(ctx.node(), bugs) | ||
|
r16221 | return bugs | ||
|
r2192 | |||
|
r16221 | def update(self, bugid, newstate, ctx): | ||
|
r2192 | '''update bugzilla bug with reference to changeset.''' | ||
def webroot(root): | ||||
'''strip leading prefix of repo root and turn into | ||||
url-safe path.''' | ||||
|
r43347 | count = int(self.ui.config(b'bugzilla', b'strip')) | ||
|
r2192 | root = util.pconvert(root) | ||
while count > 0: | ||||
|
r43347 | c = root.find(b'/') | ||
|
r2192 | if c == -1: | ||
break | ||||
|
r43346 | root = root[c + 1 :] | ||
|
r2192 | count -= 1 | ||
return root | ||||
|
r28950 | mapfile = None | ||
|
r43347 | tmpl = self.ui.config(b'bugzilla', b'template') | ||
|
r28950 | if not tmpl: | ||
|
r43347 | mapfile = self.ui.config(b'bugzilla', b'style') | ||
|
r2192 | if not mapfile and not tmpl: | ||
|
r43346 | tmpl = _( | ||
|
r43347 | b'changeset {node|short} in repo {root} refers ' | ||
b'to bug {bug}.\ndetails:\n\t{desc|tabindent}' | ||||
|
r43346 | ) | ||
|
r35906 | spec = logcmdutil.templatespec(tmpl, mapfile) | ||
|
r35972 | t = logcmdutil.changesettemplater(self.ui, self.repo, spec) | ||
|
r3741 | self.ui.pushbuffer() | ||
|
r43346 | t.show( | ||
ctx, | ||||
changes=ctx.changeset(), | ||||
bug=pycompat.bytestr(bugid), | ||||
|
r43347 | hgweb=self.ui.config(b'web', b'baseurl'), | ||
|
r43346 | root=self.repo.root, | ||
webroot=webroot(self.repo.root), | ||||
) | ||||
|
r3741 | data = self.ui.popbuffer() | ||
|
r43346 | self.bzdriver.updatebug( | ||
bugid, newstate, data, stringutil.email(ctx.user()) | ||||
) | ||||
|
r21855 | |||
def notify(self, bugs, committer): | ||||
'''ensure Bugzilla users are notified of bug change.''' | ||||
self.bzdriver.notify(bugs, committer) | ||||
|
r2192 | |||
|
r43346 | |||
|
r2192 | def hook(ui, repo, hooktype, node=None, **kwargs): | ||
'''add comment to bugzilla for each changeset that refers to a | ||||
bugzilla bug id. only add a comment once per bug, so same change | ||||
seen multiple times does not fill bug with duplicate data.''' | ||||
if node is None: | ||||
|
r43346 | raise error.Abort( | ||
|
r43347 | _(b'hook type %s does not pass a changeset id') % hooktype | ||
|
r43346 | ) | ||
|
r2192 | try: | ||
bz = bugzilla(ui, repo) | ||||
|
r6747 | ctx = repo[node] | ||
|
r16221 | bugs = bz.find_bugs(ctx) | ||
if bugs: | ||||
for bug in bugs: | ||||
bz.update(bug, bugs[bug], ctx) | ||||
|
r37102 | bz.notify(bugs, stringutil.email(ctx.user())) | ||
|
r25660 | except Exception as e: | ||
|
r43347 | raise error.Abort(_(b'Bugzilla error: %s') % e) | ||