mercurial: comparison hgext/bugzilla.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # 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.
-testedwith = 'ships-with-hg-core'
+testedwith = b'ships-with-hg-core'
 configtable = {}
 configitem = registrar.configitem(configtable)
 configitem(
-'bugzilla', 'apikey', default='',
+b'bugzilla', b'apikey', default=b'',
 )
 configitem(
-'bugzilla', 'bzdir', default='/var/www/html/bugzilla',
+b'bugzilla', b'bzdir', default=b'/var/www/html/bugzilla',
 )
 configitem(
-'bugzilla', 'bzemail', default=None,
+b'bugzilla', b'bzemail', default=None,
 )
 configitem(
-'bugzilla', 'bzurl', default='http://localhost/bugzilla/',
+b'bugzilla', b'bzurl', default=b'http://localhost/bugzilla/',
 )
 configitem(
-'bugzilla', 'bzuser', default=None,
+b'bugzilla', b'bzuser', default=None,
 )
 configitem(
-'bugzilla', 'db', default='bugs',
+b'bugzilla', b'db', default=b'bugs',
 )
 configitem(
-'bugzilla',
+b'bugzilla',
-'fixregexp',
+b'fixregexp',
 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+)?))?'
 ),
 )
 configitem(
-'bugzilla', 'fixresolution', default='FIXED',
+b'bugzilla', b'fixresolution', default=b'FIXED',
 )
 configitem(
-'bugzilla', 'fixstatus', default='RESOLVED',
+b'bugzilla', b'fixstatus', default=b'RESOLVED',
 )
 configitem(
-'bugzilla', 'host', default='localhost',
+b'bugzilla', b'host', default=b'localhost',
 )
 configitem(
-'bugzilla', 'notify', default=configitem.dynamicdefault,
+b'bugzilla', b'notify', default=configitem.dynamicdefault,
 )
 configitem(
-'bugzilla', 'password', default=None,
+b'bugzilla', b'password', default=None,
 )
 configitem(
-'bugzilla',
+b'bugzilla',
-'regexp',
+b'regexp',
 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+)?))?'
 ),
 )
 configitem(
-'bugzilla', 'strip', default=0,
+b'bugzilla', b'strip', default=0,
 )
 configitem(
-'bugzilla', 'style', default=None,
+b'bugzilla', b'style', default=None,
 )
 configitem(
-'bugzilla', 'template', default=None,
+b'bugzilla', b'template', default=None,
 )
 configitem(
-'bugzilla', 'timeout', default=5,
+b'bugzilla', b'timeout', default=5,
 )
 configitem(
-'bugzilla', 'user', default='bugs',
+b'bugzilla', b'user', default=b'bugs',
 )
 configitem(
-'bugzilla', 'usermap', default=None,
+b'bugzilla', b'usermap', default=None,
 )
 configitem(
-'bugzilla', 'version', default=None,
+b'bugzilla', b'version', default=None,
 )
 class bzaccess(object):
 '''Base class for access to Bugzilla.'''
 def __init__(self, ui):
 self.ui = ui
-usermap = self.ui.config('bugzilla', 'usermap')
+usermap = self.ui.config(b'bugzilla', b'usermap')
 if usermap:
-self.ui.readconfig(usermap, sections=['usermap'])
+self.ui.readconfig(usermap, sections=[b'usermap'])
 def map_committer(self, user):
 '''map name of committer to Bugzilla user name.'''
-for committer, bzuser in self.ui.configitems('usermap'):
+for committer, bzuser in self.ui.configitems(b'usermap'):
 if committer.lower() == user.lower():
 return bzuser
 return user
 # Methods to be implemented by access classes.
 '''
 @staticmethod
 def sql_buglist(ids):
 '''return SQL-friendly list of bug ids'''
-return '(' + ','.join(map(str, ids)) + ')'
+return b'(' + b','.join(map(str, ids)) + b')'
 _MySQLdb = None
 def __init__(self, ui):
 try:
 import MySQLdb as mysql
 bzmysql._MySQLdb = mysql
 except ImportError as err:
-raise error.Abort(_('python mysql support not available: %s') % err)
+raise error.Abort(
+_(b'python mysql support not available: %s') % err
+)
 bzaccess.__init__(self, ui)
-host = self.ui.config('bugzilla', 'host')
+host = self.ui.config(b'bugzilla', b'host')
-user = self.ui.config('bugzilla', 'user')
+user = self.ui.config(b'bugzilla', b'user')
-passwd = self.ui.config('bugzilla', 'password')
+passwd = self.ui.config(b'bugzilla', b'password')
-db = self.ui.config('bugzilla', 'db')
+db = self.ui.config(b'bugzilla', b'db')
-timeout = int(self.ui.config('bugzilla', 'timeout'))
+timeout = int(self.ui.config(b'bugzilla', b'timeout'))
 self.ui.note(
-_('connecting to %s:%s as %s, password %s\n')
+_(b'connecting to %s:%s as %s, password %s\n')
-% (host, db, user, '*' * len(passwd))
+% (host, db, user, b'*' * 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"
+self.default_notify = b"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))
+self.ui.note(_(b'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))
+self.ui.note(_(b'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"')
+self.run(b'select fieldid from fielddefs where name = "longdesc"')
 ids = self.cursor.fetchall()
 if len(ids) != 1:
-raise error.Abort(_('unknown database schema'))
+raise error.Abort(_(b'unknown database schema'))
 return ids[0][0]
 def filter_real_bug_ids(self, bugs):
 '''filter not-existing bugs from set.'''
 self.run(
-'select bug_id from bugs where bug_id in %s'
+b'select bug_id from bugs where bug_id in %s'
 % bzmysql.sql_buglist(bugs.keys())
 )
 existing = [id for (id,) in self.cursor.fetchall()]
 for id in bugs.keys():
 if id not in existing:
-self.ui.status(_('bug %d does not exist\n') % id)
+self.ui.status(_(b'bug %d does not exist\n') % id)
 del bugs[id]
 def filter_cset_known_bug_ids(self, node, bugs):
 '''filter bug ids that already refer to this changeset from set.'''
 self.run(
 bug_id in %s and thetext like "%%%s%%"'''
 % (bzmysql.sql_buglist(bugs.keys()), short(node))
 )
 for (id,) in self.cursor.fetchall():
 self.ui.status(
-_('bug %d already knows about changeset %s\n')
+_(b'bug %d already knows about changeset %s\n')
 % (id, short(node))
 )
 del bugs[id]
 def notify(self, bugs, committer):
 '''tell bugzilla to send mail.'''
-self.ui.status(_('telling bugzilla to send mail:\n'))
+self.ui.status(_(b'telling bugzilla to send mail:\n'))
 (user, userid) = self.get_bugzilla_user(committer)
 for id in bugs.keys():
-self.ui.status(_('  bug %s\n') % id)
+self.ui.status(_(b'  bug %s\n') % id)
-cmdfmt = self.ui.config('bugzilla', 'notify', self.default_notify)
+cmdfmt = self.ui.config(b'bugzilla', b'notify', self.default_notify)
-bzdir = self.ui.config('bugzilla', 'bzdir')
+bzdir = self.ui.config(b'bugzilla', b'bzdir')
 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}
+cmd = cmdfmt % {b'bzdir': bzdir, b'id': id, b'user': user}
-self.ui.note(_('running notify command %s\n') % cmd)
+self.ui.note(_(b'running notify command %s\n') % cmd)
-fp = procutil.popen('(%s) 2>&1' % cmd, 'rb')
+fp = procutil.popen(b'(%s) 2>&1' % cmd, b'rb')
 out = util.fromnativeeol(fp.read())
 ret = fp.close()
 if ret:
 self.ui.warn(out)
 raise error.Abort(
-_('bugzilla notify command %s') % procutil.explainexit(ret)
+_(b'bugzilla notify command %s') % procutil.explainexit(ret)
 )
-self.ui.status(_('done\n'))
+self.ui.status(_(b'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.ui.note(_(b'looking up user %s\n') % user)
 self.run(
 '''select userid from profiles
 where login_name like %s''',
 user,
 )
 user = self.map_committer(committer)
 try:
 userid = self.get_user_id(user)
 except KeyError:
 try:
-defaultuser = self.ui.config('bugzilla', 'bzuser')
+defaultuser = self.ui.config(b'bugzilla', b'bzuser')
 if not defaultuser:
 raise error.Abort(
-_('cannot find bugzilla user id for %s') % user
+_(b'cannot find bugzilla user id for %s') % user
 )
 userid = self.get_user_id(defaultuser)
 user = defaultuser
 except KeyError:
 raise error.Abort(
-_('cannot find bugzilla user id for %s or %s')
+_(b'cannot find bugzilla user id for %s or %s')
 % (user, defaultuser)
 )
 return (user, userid)
 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.'''
 if len(newstate) > 0:
-self.ui.warn(_("Bugzilla/MySQL cannot update bug state\n"))
+self.ui.warn(_(b"Bugzilla/MySQL cannot update bug state\n"))
 (user, userid) = self.get_bugzilla_user(committer)
 now = time.strftime(r'%Y-%m-%d %H:%M:%S')
 self.run(
 '''insert into longdescs
 '''support for bugzilla 2.18 series.'''
 def __init__(self, ui):
 bzmysql.__init__(self, ui)
 self.default_notify = (
-"cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
+b"cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s"
 )
 class bzmysql_3_0(bzmysql_2_18):
 '''support for bugzilla 3.0 series.'''
 def __init__(self, ui):
 bzmysql_2_18.__init__(self, ui)
 def get_longdesc_id(self):
 '''get identity of longdesc field'''
-self.run('select id from fielddefs where name = "longdesc"')
+self.run(b'select id from fielddefs where name = "longdesc"')
 ids = self.cursor.fetchall()
 if len(ids) != 1:
-raise error.Abort(_('unknown database schema'))
+raise error.Abort(_(b'unknown database schema'))
 return ids[0][0]
 # Bugzilla via XMLRPC interface.
 cookies = []
 def send_cookies(self, connection):
 if self.cookies:
 for cookie in self.cookies:
-connection.putheader("Cookie", cookie)
+connection.putheader(b"Cookie", cookie)
 def request(self, host, handler, request_body, verbose=0):
 self.verbose = verbose
 self.accept_gzip_encoding = False
 response = h.getresponse()
 except AttributeError:
 response = h._conn.getresponse()
 # Add any cookie definitions to our list.
-for header in response.msg.getallmatchingheaders("Set-Cookie"):
+for header in response.msg.getallmatchingheaders(b"Set-Cookie"):
-val = header.split(": ", 1)[1]
+val = header.split(b": ", 1)[1]
-cookie = val.split(";", 1)[0]
+cookie = val.split(b";", 1)[0]
 self.cookies.append(cookie)
 if response.status != 200:
 raise xmlrpclib.ProtocolError(
 host + handler,
 # 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):
-if util.safehasattr(xmlrpclib.Transport, "__init__"):
+if util.safehasattr(xmlrpclib.Transport, b"__init__"):
 xmlrpclib.Transport.__init__(self, use_datetime)
 class cookiesafetransport(cookietransportrequest, xmlrpclib.SafeTransport):
 def __init__(self, use_datetime=0):
-if util.safehasattr(xmlrpclib.Transport, "__init__"):
+if util.safehasattr(xmlrpclib.Transport, b"__init__"):
 xmlrpclib.SafeTransport.__init__(self, use_datetime)
 class bzxmlrpc(bzaccess):
 """Support for access to Bugzilla via the Bugzilla XMLRPC API.
 """
 def __init__(self, ui):
 bzaccess.__init__(self, ui)
-bzweb = self.ui.config('bugzilla', 'bzurl')
+bzweb = self.ui.config(b'bugzilla', b'bzurl')
-bzweb = bzweb.rstrip("/") + "/xmlrpc.cgi"
+bzweb = bzweb.rstrip(b"/") + b"/xmlrpc.cgi"
-user = self.ui.config('bugzilla', 'user')
+user = self.ui.config(b'bugzilla', b'user')
-passwd = self.ui.config('bugzilla', 'password')
+passwd = self.ui.config(b'bugzilla', b'password')
-self.fixstatus = self.ui.config('bugzilla', 'fixstatus')
+self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus')
-self.fixresolution = self.ui.config('bugzilla', 'fixresolution')
+self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution')
 self.bzproxy = xmlrpclib.ServerProxy(bzweb, self.transport(bzweb))
-ver = self.bzproxy.Bugzilla.version()['version'].split('.')
+ver = self.bzproxy.Bugzilla.version()[b'version'].split(b'.')
 self.bzvermajor = int(ver[0])
 self.bzverminor = int(ver[1])
 login = self.bzproxy.User.login(
-{'login': user, 'password': passwd, 'restrict_login': True}
+{b'login': user, b'password': passwd, b'restrict_login': True}
 )
-self.bztoken = login.get('token', '')
+self.bztoken = login.get(b'token', b'')
 def transport(self, uri):
-if util.urlreq.urlparse(uri, "http")[0] == "https":
+if util.urlreq.urlparse(uri, b"http")[0] == b"https":
 return cookiesafetransport()
 else:
 return cookietransport()
 def get_bug_comments(self, id):
 """Return a string with all comment text for a bug."""
 c = self.bzproxy.Bug.comments(
-{'ids': [id], 'include_fields': ['text'], 'token': self.bztoken}
+{b'ids': [id], b'include_fields': [b'text'], b'token': self.bztoken}
 )
-return ''.join([t['text'] for t in c['bugs']['%d' % id]['comments']])
+return b''.join(
+[t[b'text'] for t in c[b'bugs'][b'%d' % id][b'comments']]
+)
 def filter_real_bug_ids(self, bugs):
 probe = self.bzproxy.Bug.get(
 {
-'ids': sorted(bugs.keys()),
+b'ids': sorted(bugs.keys()),
-'include_fields': [],
+b'include_fields': [],
-'permissive': True,
+b'permissive': True,
-'token': self.bztoken,
+b'token': self.bztoken,
 }
 )
-for badbug in probe['faults']:
+for badbug in probe[b'faults']:
-id = badbug['id']
+id = badbug[b'id']
-self.ui.status(_('bug %d does not exist\n') % id)
+self.ui.status(_(b'bug %d does not exist\n') % id)
 del bugs[id]
 def filter_cset_known_bug_ids(self, node, bugs):
 for id in sorted(bugs.keys()):
 if self.get_bug_comments(id).find(short(node)) != -1:
 self.ui.status(
-_('bug %d already knows about changeset %s\n')
+_(b'bug %d already knows about changeset %s\n')
 % (id, short(node))
 )
 del bugs[id]
 def updatebug(self, bugid, newstate, text, committer):
 args = {}
-if 'hours' in newstate:
+if b'hours' in newstate:
-args['work_time'] = newstate['hours']
+args[b'work_time'] = newstate[b'hours']
 if self.bzvermajor >= 4:
-args['ids'] = [bugid]
+args[b'ids'] = [bugid]
-args['comment'] = {'body': text}
+args[b'comment'] = {b'body': text}
-if 'fix' in newstate:
+if b'fix' in newstate:
-args['status'] = self.fixstatus
+args[b'status'] = self.fixstatus
-args['resolution'] = self.fixresolution
+args[b'resolution'] = self.fixresolution
-args['token'] = self.bztoken
+args[b'token'] = self.bztoken
 self.bzproxy.Bug.update(args)
 else:
-if 'fix' in newstate:
+if b'fix' in newstate:
 self.ui.warn(
 _(
-"Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
+b"Bugzilla/XMLRPC needs Bugzilla 4.0 or later "
-"to mark bugs fixed\n"
+b"to mark bugs fixed\n"
 )
 )
-args['id'] = bugid
+args[b'id'] = bugid
-args['comment'] = text
+args[b'comment'] = text
 self.bzproxy.Bug.add_comment(args)
 class bzxmlrpcemail(bzxmlrpc):
 """Read data from Bugzilla via XMLRPC, send updates via email.
 # 4.0 onwards.
 def __init__(self, ui):
 bzxmlrpc.__init__(self, ui)
-self.bzemail = self.ui.config('bugzilla', 'bzemail')
+self.bzemail = self.ui.config(b'bugzilla', b'bzemail')
 if not self.bzemail:
-raise error.Abort(_("configuration 'bzemail' missing"))
+raise error.Abort(_(b"configuration 'bzemail' missing"))
 mail.validateconfig(self.ui)
 def makecommandline(self, fieldname, value):
 if self.bzvermajor >= 4:
-return "@%s %s" % (fieldname, pycompat.bytestr(value))
+return b"@%s %s" % (fieldname, pycompat.bytestr(value))
 else:
-if fieldname == "id":
+if fieldname == b"id":
-fieldname = "bug_id"
+fieldname = b"bug_id"
-return "@%s = %s" % (fieldname, pycompat.bytestr(value))
+return b"@%s = %s" % (fieldname, pycompat.bytestr(value))
 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
 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)
 matches = self.bzproxy.User.get(
-{'match': [user], 'token': self.bztoken}
+{b'match': [user], b'token': self.bztoken}
 )
-if not matches['users']:
+if not matches[b'users']:
-user = self.ui.config('bugzilla', 'user')
+user = self.ui.config(b'bugzilla', b'user')
 matches = self.bzproxy.User.get(
-{'match': [user], 'token': self.bztoken}
+{b'match': [user], b'token': self.bztoken}
 )
-if not matches['users']:
+if not matches[b'users']:
 raise error.Abort(
-_("default bugzilla user %s email not found") % user
+_(b"default bugzilla user %s email not found") % user
 )
-user = matches['users'][0]['email']
+user = matches[b'users'][0][b'email']
-commands.append(self.makecommandline("id", bugid))
+commands.append(self.makecommandline(b"id", bugid))
-text = "\n".join(commands) + "\n\n" + comment
+text = b"\n".join(commands) + b"\n\n" + comment
 _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)
-msg['From'] = user
+msg[b'From'] = user
-msg['To'] = bzemail
+msg[b'To'] = bzemail
-msg['Subject'] = mail.headencode(self.ui, "Bug modification", _charsets)
+msg[b'Subject'] = mail.headencode(
+self.ui, b"Bug modification", _charsets
+)
 sendmail = mail.connect(self.ui)
 sendmail(user, bzemail, msg.as_string())
 def updatebug(self, bugid, newstate, text, committer):
 cmds = []
-if 'hours' in newstate:
+if b'hours' in newstate:
-cmds.append(self.makecommandline("work_time", newstate['hours']))
+cmds.append(self.makecommandline(b"work_time", newstate[b'hours']))
-if 'fix' in newstate:
+if b'fix' in newstate:
-cmds.append(self.makecommandline("bug_status", self.fixstatus))
+cmds.append(self.makecommandline(b"bug_status", self.fixstatus))
-cmds.append(self.makecommandline("resolution", self.fixresolution))
+cmds.append(self.makecommandline(b"resolution", self.fixresolution))
 self.send_bug_modify_email(bugid, cmds, text, committer)
 class NotFound(LookupError):
 pass
 Bugzilla 5.0.
 """
 def __init__(self, ui):
 bzaccess.__init__(self, ui)
-bz = self.ui.config('bugzilla', 'bzurl')
+bz = self.ui.config(b'bugzilla', b'bzurl')
-self.bzroot = '/'.join([bz, 'rest'])
+self.bzroot = b'/'.join([bz, b'rest'])
-self.apikey = self.ui.config('bugzilla', 'apikey')
+self.apikey = self.ui.config(b'bugzilla', b'apikey')
-self.user = self.ui.config('bugzilla', 'user')
+self.user = self.ui.config(b'bugzilla', b'user')
-self.passwd = self.ui.config('bugzilla', 'password')
+self.passwd = self.ui.config(b'bugzilla', b'password')
-self.fixstatus = self.ui.config('bugzilla', 'fixstatus')
+self.fixstatus = self.ui.config(b'bugzilla', b'fixstatus')
-self.fixresolution = self.ui.config('bugzilla', 'fixresolution')
+self.fixresolution = self.ui.config(b'bugzilla', b'fixresolution')
 def apiurl(self, targets, include_fields=None):
-url = '/'.join([self.bzroot] + [pycompat.bytestr(t) for t in targets])
+url = b'/'.join([self.bzroot] + [pycompat.bytestr(t) for t in targets])
 qv = {}
 if self.apikey:
-qv['api_key'] = self.apikey
+qv[b'api_key'] = self.apikey
 elif self.user and self.passwd:
-qv['login'] = self.user
+qv[b'login'] = self.user
-qv['password'] = self.passwd
+qv[b'password'] = self.passwd
 if include_fields:
-qv['include_fields'] = include_fields
+qv[b'include_fields'] = include_fields
 if qv:
-url = '%s?%s' % (url, util.urlreq.urlencode(qv))
+url = b'%s?%s' % (url, util.urlreq.urlencode(qv))
 return url
 def _fetch(self, burl):
 try:
 resp = url.open(self.ui, burl)
 return json.loads(resp.read())
 except util.urlerr.httperror as inst:
 if inst.code == 401:
-raise error.Abort(_('authorization failed'))
+raise error.Abort(_(b'authorization failed'))
 if inst.code == 404:
 raise NotFound()
 else:
 raise
-def _submit(self, burl, data, method='POST'):
+def _submit(self, burl, data, method=b'POST'):
 data = json.dumps(data)
-if method == 'PUT':
+if method == b'PUT':
 class putrequest(util.urlreq.request):
 def get_method(self):
-return 'PUT'
+return b'PUT'
 request_type = putrequest
 else:
 request_type = util.urlreq.request
-req = request_type(burl, data, {'Content-Type': 'application/json'})
+req = request_type(burl, data, {b'Content-Type': b'application/json'})
 try:
 resp = url.opener(self.ui).open(req)
 return json.loads(resp.read())
 except util.urlerr.httperror as inst:
 if inst.code == 401:
-raise error.Abort(_('authorization failed'))
+raise error.Abort(_(b'authorization failed'))
 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:
-burl = self.apiurl(('bug', bugid), include_fields='status')
+burl = self.apiurl((b'bug', bugid), include_fields=b'status')
 try:
 self._fetch(burl)
 except NotFound:
 badbugs.add(bugid)
 for bugid in badbugs:
 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():
-burl = self.apiurl(('bug', bugid, 'comment'), include_fields='text')
+burl = self.apiurl(
+(b'bug', bugid, b'comment'), include_fields=b'text'
+)
 result = self._fetch(burl)
-comments = result['bugs'][pycompat.bytestr(bugid)]['comments']
+comments = result[b'bugs'][pycompat.bytestr(bugid)][b'comments']
-if any(sn in c['text'] for c in comments):
+if any(sn in c[b'text'] for c in comments):
 self.ui.status(
-_('bug %d already knows about changeset %s\n') % (bugid, sn)
+_(b'bug %d already knows about changeset %s\n')
+% (bugid, sn)
 )
 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 = {}
-if 'hours' in newstate:
+if b'hours' in newstate:
-bugmod['work_time'] = newstate['hours']
+bugmod[b'work_time'] = newstate[b'hours']
-if 'fix' in newstate:
+if b'fix' in newstate:
-bugmod['status'] = self.fixstatus
+bugmod[b'status'] = self.fixstatus
-bugmod['resolution'] = self.fixresolution
+bugmod[b'resolution'] = self.fixresolution
 if bugmod:
 # if we have to change the bugs state do it here
-bugmod['comment'] = {
+bugmod[b'comment'] = {
-'comment': text,
+b'comment': text,
-'is_private': False,
+b'is_private': False,
-'is_markdown': False,
+b'is_markdown': False,
 }
-burl = self.apiurl(('bug', bugid))
+burl = self.apiurl((b'bug', bugid))
-self._submit(burl, bugmod, method='PUT')
+self._submit(burl, bugmod, method=b'PUT')
-self.ui.debug('updated bug %s\n' % bugid)
+self.ui.debug(b'updated bug %s\n' % bugid)
 else:
-burl = self.apiurl(('bug', bugid, 'comment'))
+burl = self.apiurl((b'bug', bugid, b'comment'))
 self._submit(
 burl,
-{'comment': text, 'is_private': False, 'is_markdown': False,},
+{
+b'comment': text,
+b'is_private': False,
+b'is_markdown': False,
+},
 )
-self.ui.debug('added comment to bug %s\n' % bugid)
+self.ui.debug(b'added comment to bug %s\n' % bugid)
 def notify(self, bugs, committer):
 '''Force sending of Bugzilla notification emails.
 Only required if the access method does not trigger notification
 class bugzilla(object):
 # supported versions of bugzilla. different versions have
 # different schemas.
 _versions = {
-'2.16': bzmysql,
+b'2.16': bzmysql,
-'2.18': bzmysql_2_18,
+b'2.18': bzmysql_2_18,
-'3.0': bzmysql_3_0,
+b'3.0': bzmysql_3_0,
-'xmlrpc': bzxmlrpc,
+b'xmlrpc': bzxmlrpc,
-'xmlrpc+email': bzxmlrpcemail,
+b'xmlrpc+email': bzxmlrpcemail,
-'restapi': bzrestapi,
+b'restapi': bzrestapi,
 }
 def __init__(self, ui, repo):
 self.ui = ui
 self.repo = repo
-bzversion = self.ui.config('bugzilla', 'version')
+bzversion = self.ui.config(b'bugzilla', b'version')
 try:
 bzclass = bugzilla._versions[bzversion]
 except KeyError:
 raise error.Abort(
-_('bugzilla version %s not supported') % bzversion
+_(b'bugzilla version %s not supported') % bzversion
 )
 self.bzdriver = bzclass(self.ui)
 self.bug_re = re.compile(
-self.ui.config('bugzilla', 'regexp'), re.IGNORECASE
+self.ui.config(b'bugzilla', b'regexp'), re.IGNORECASE
 )
 self.fix_re = re.compile(
-self.ui.config('bugzilla', 'fixregexp'), re.IGNORECASE
+self.ui.config(b'bugzilla', b'fixregexp'), re.IGNORECASE
 )
 self.split_re = re.compile(br'\D+')
 def find_bugs(self, ctx):
 '''return bugs dictionary created from commit comment.
 else:
 m = fixmatch
 start = m.end()
 if m is bugmatch:
 bugmatch = self.bug_re.search(ctx.description(), start)
-if 'fix' in bugattribs:
+if b'fix' in bugattribs:
-del bugattribs['fix']
+del bugattribs[b'fix']
 else:
 fixmatch = self.fix_re.search(ctx.description(), start)
-bugattribs['fix'] = None
+bugattribs[b'fix'] = None
 try:
-ids = m.group('ids')
+ids = m.group(b'ids')
 except IndexError:
 ids = m.group(1)
 try:
-hours = float(m.group('hours'))
+hours = float(m.group(b'hours'))
-bugattribs['hours'] = hours
+bugattribs[b'hours'] = hours
 except IndexError:
 pass
 except TypeError:
 pass
 except ValueError:
-self.ui.status(_("%s: invalid hours\n") % m.group('hours'))
+self.ui.status(_(b"%s: invalid hours\n") % m.group(b'hours'))
 for id in self.split_re.split(ids):
 if not id:
 continue
 bugs[int(id)] = bugattribs
 '''update bugzilla bug with reference to changeset.'''
 def webroot(root):
 '''strip leading prefix of repo root and turn into
 url-safe path.'''
-count = int(self.ui.config('bugzilla', 'strip'))
+count = int(self.ui.config(b'bugzilla', b'strip'))
 root = util.pconvert(root)
 while count > 0:
-c = root.find('/')
+c = root.find(b'/')
 if c == -1:
 break
 root = root[c + 1 :]
 count -= 1
 return root
 mapfile = None
-tmpl = self.ui.config('bugzilla', 'template')
+tmpl = self.ui.config(b'bugzilla', b'template')
 if not tmpl:
-mapfile = self.ui.config('bugzilla', 'style')
+mapfile = self.ui.config(b'bugzilla', b'style')
 if not mapfile and not tmpl:
 tmpl = _(
-'changeset {node|short} in repo {root} refers '
+b'changeset {node|short} in repo {root} refers '
-'to bug {bug}.\ndetails:\n\t{desc|tabindent}'
+b'to bug {bug}.\ndetails:\n\t{desc|tabindent}'
 )
 spec = logcmdutil.templatespec(tmpl, mapfile)
 t = logcmdutil.changesettemplater(self.ui, self.repo, spec)
 self.ui.pushbuffer()
 t.show(
 ctx,
 changes=ctx.changeset(),
 bug=pycompat.bytestr(bugid),
-hgweb=self.ui.config('web', 'baseurl'),
+hgweb=self.ui.config(b'web', b'baseurl'),
 root=self.repo.root,
 webroot=webroot(self.repo.root),
 )
 data = self.ui.popbuffer()
 self.bzdriver.updatebug(
 '''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:
 raise error.Abort(
-_('hook type %s does not pass a changeset id') % hooktype
+_(b'hook type %s does not pass a changeset id') % hooktype
 )
 try:
 bz = bugzilla(ui, repo)
 ctx = repo[node]
 bugs = bz.find_bugs(ctx)
 if bugs:
 for bug in bugs:
 bz.update(bug, bugs[bug], ctx)
 bz.notify(bugs, stringutil.email(ctx.user()))
 except Exception as e:
-raise error.Abort(_('Bugzilla error: %s') % e)
+raise error.Abort(_(b'Bugzilla error: %s') % e)

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43115	4aa72cdf616f