#!/usr/bin/env python
"""
Import a Bugzilla items into a Trac database.
Requires: Trac 0.9b1 from http://trac.edgewall.org/
Python 2.3 from http://www.python.org/
MySQL >= 3.23 from http://www.mysql.org/
or PostGreSQL 8.4 from http://www.postgresql.org/
or SQLite 3 from http://www.sqlite.org/
Thanks: Mark Rowe <mrowe@bluewire.net.nz>
for original TracDatabase class
Copyright 2004, Dmitry Yusupov <dmitry_yus@yahoo.com>
Many enhancements, Bill Soudan <bill@soudan.net>
Other enhancements, Florent Guillaume <fg@nuxeo.com>
Reworked, Jeroen Ruigrok van der Werven <asmodai@in-nomine.org>
Jeff Moreland <hou5e@hotmail.com>
$Id: bugzilla2trac.py 9282 2010-02-26 10:06:58Z cboos $
"""
import re
###
### Conversion Settings -- edit these before running if desired
###
# Bugzilla version. You can find this in Bugzilla's globals.pl file.
#
# Currently, the following bugzilla versions are known to work:
# 2.11 (2110), 2.16.5 (2165), 2.16.7 (2167), 2.18.3 (2183), 2.19.1 (2191),
# 2.23.3 (2233), 3.04.4 (3044)
#
# If you run this script on a version not listed here and it is successful,
# please file a ticket at http://trac.edgewall.org
#
BZ_VERSION = 3044
# MySQL connection parameters for the Bugzilla database. These can also
# be specified on the command line.
BZ_DB = ""
BZ_HOST = ""
BZ_USER = ""
BZ_PASSWORD = ""
# Path to the Trac environment.
TRAC_ENV = "/usr/local/trac"
# If true, all existing Trac tickets and attachments will be removed
# prior to import.
TRAC_CLEAN = True
# Enclose imported ticket description and comments in a {{{ }}}
# preformat block? This formats the text in a fixed-point font.
PREFORMAT_COMMENTS = False
# Replace bug numbers in comments with #xyz
REPLACE_BUG_NO = False
# Severities
SEVERITIES = [
("blocker", "1"),
("critical", "2"),
("major", "3"),
("normal", "4"),
("minor", "5"),
("trivial", "6")
]
# Priorities
# If using the default Bugzilla priorities of P1 - P5, do not change anything
# here.
# If you have other priorities defined please change the P1 - P5 mapping to
# the order you want. You can also collapse multiple priorities on bugzilla's
# side into the same priority on Trac's side, simply adjust PRIORITIES_MAP.
PRIORITIES = [
("highest", "1"),
("high", "2"),
("normal", "3"),
("low", "4"),
("lowest", "5")
]
# Bugzilla: Trac
# NOTE: Use lowercase.
PRIORITIES_MAP = {
"p1": "highest",
"p2": "high",
"p3": "normal",
"p4": "low",
"p5": "lowest"
}
# By default, all bugs are imported from Bugzilla. If you add a list
# of products here, only bugs from those products will be imported.
PRODUCTS = []
# These Bugzilla products will be ignored during import.
IGNORE_PRODUCTS = []
# These milestones are ignored
IGNORE_MILESTONES = ["---"]
# Don't import user names and passwords into htpassword if
# user is disabled in bugzilla? (i.e. profiles.DisabledText<>'')
IGNORE_DISABLED_USERS = True
# These logins are converted to these user ids
LOGIN_MAP = {
#'some.user@example.com': 'someuser',
}
# These emails are removed from CC list
IGNORE_CC = [
#'loser@example.com',
]
# The 'component' field in Trac can come either from the Product or
# or from the Component field of Bugzilla. COMPONENTS_FROM_PRODUCTS
# switches the behavior.
# If COMPONENTS_FROM_PRODUCTS is True:
# - Bugzilla Product -> Trac Component
# - Bugzilla Component -> Trac Keyword
# IF COMPONENTS_FROM_PRODUCTS is False:
# - Bugzilla Product -> Trac Keyword
# - Bugzilla Component -> Trac Component
COMPONENTS_FROM_PRODUCTS = False
# If COMPONENTS_FROM_PRODUCTS is True, the default owner for each
# Trac component is inferred from a default Bugzilla component.
DEFAULT_COMPONENTS = ["default", "misc", "main"]
# This mapping can assign keywords in the ticket entry to represent
# products or components (depending on COMPONENTS_FROM_PRODUCTS).
# The keyword will be ignored if empty.
KEYWORDS_MAPPING = {
#'Bugzilla_product_or_component': 'Keyword',
"default": "",
"misc": "",
}
# If this is True, products or components are all set as keywords
# even if not mentionned in KEYWORDS_MAPPING.
MAP_ALL_KEYWORDS = True
# Custom field mappings
CUSTOMFIELD_MAP = {
#'Bugzilla_field_name': 'Trac_customfield_name',
#'op_sys': 'os',
#'cf_featurewantedby': 'wanted_by',
#'product': 'product'
}
# Bug comments that should not be imported. Each entry in list should
# be a regular expression.
IGNORE_COMMENTS = [
"^Created an attachment \(id="
]
###########################################################################
### You probably don't need to change any configuration past this line. ###
###########################################################################
# Bugzilla status to Trac status translation map.
#
# NOTE: bug activity is translated as well, which may cause bug
# activity to be deleted (e.g. resolved -> closed in Bugzilla
# would translate into closed -> closed in Trac, so we just ignore the
# change).
#
# There is some special magic for open in the code: if there is no
# Bugzilla owner, open is mapped to 'new' instead.
STATUS_TRANSLATE = {
"unconfirmed": "new",
"open": "assigned",
"resolved": "closed",
"verified": "closed",
"released": "closed"
}
# Translate Bugzilla statuses into Trac keywords. This provides a way
# to retain the Bugzilla statuses in Trac. e.g. when a bug is marked
# 'verified' in Bugzilla it will be assigned a VERIFIED keyword.
STATUS_KEYWORDS = {
"verified": "VERIFIED",
"released": "RELEASED"
}
# Some fields in Bugzilla do not have equivalents in Trac. Changes in
# fields listed here will not be imported into the ticket change history,
# otherwise you'd see changes for fields that don't exist in Trac.
IGNORED_ACTIVITY_FIELDS = ["everconfirmed"]
# Regular expression and its replacement
# this expression will update references to bugs 1 - 99999 that
# have the form "bug 1" or "bug #1"
BUG_NO_RE = re.compile(r"\b(bug #?)([0-9]{1,5})\b", re.I)
BUG_NO_REPL = r"#\2"
###
### Script begins here
###
import os
import sys
import string
import StringIO
import MySQLdb
import MySQLdb.cursors
try:
from trac.env import Environment
except:
from trac.Environment import Environment
from trac.attachment import Attachment
if not hasattr(sys, 'setdefaultencoding'):
reload(sys)
sys.setdefaultencoding('latin1')
# simulated Attachment class for trac.add
#class Attachment:
# def __init__(self, name, data):
# self.filename = name
# self.file = StringIO.StringIO(data.tostring())
# simple field translation mapping. if string not in
# mapping, just return string, otherwise return value
class FieldTranslator(dict):
def __getitem__(self, item):
if not dict.has_key(self, item):
return item
return dict.__getitem__(self, item)
statusXlator = FieldTranslator(STATUS_TRANSLATE)
class TracDatabase(object):
def __init__(self, path):
self.env = Environment(path)
self._db = self.env.get_db_cnx()
self._db.autocommit = False
self.loginNameCache = {}
self.fieldNameCache = {}
from trac.db.api import DatabaseManager
self.using_postgres = DatabaseManager(self.env).connection_uri.startswith("postgres:")
def db(self):
return self._db
def hasTickets(self):
c = self.db().cursor()
c.execute("SELECT count(*) FROM ticket")
return int(c.fetchall()[0][0]) > 0
def assertNoTickets(self):
if self.hasTickets():
raise Exception("Will not modify database with existing tickets!")
def setSeverityList(self, s):
"""Remove all severities, set them to `s`"""
self.assertNoTickets()
c = self.db().cursor()
c.execute("DELETE FROM enum WHERE type='severity'")
for value, i in s:
print " inserting severity '%s' - '%s'" % (value, i)
c.execute("""INSERT INTO enum (type, name, value)
VALUES (%s, %s, %s)""",
("severity", value.encode('utf-8'), i))
self.db().commit()
def setPriorityList(self, s):
"""Remove all priorities, set them to `s`"""
self.assertNoTickets()
c = self.db().cursor()
c.execute("DELETE FROM enum WHERE type='priority'")
for value, i in s:
print " inserting priority '%s' - '%s'" % (value, i)
c.execute("""INSERT INTO enum (type, name, value)
VALUES (%s, %s, %s)""",
("priority", value.encode('utf-8'), i))
self.db().commit()
def setComponentList(self, l, key):
"""Remove all components, set them to `l`"""
self.assertNoTickets()
c = self.db().cursor()
c.execute("DELETE FROM component")
for comp in l:
print " inserting component '%s', owner '%s'" % \
(comp[key], comp['owner'])
c.execute("INSERT INTO component (name, owner) VALUES (%s, %s)",
(comp[key].encode('utf-8'),
comp['owner'].encode('utf-8')))
self.db().commit()
def setVersionList(self, v, key):
"""Remove all versions, set them to `v`"""
self.assertNoTickets()
c = self.db().cursor()
c.execute("DELETE FROM version")
for vers in v:
print " inserting version '%s'" % (vers[key])
c.execute("INSERT INTO version (name) VALUES (%s)",
(vers[key].encode('utf-8'),))
self.db().commit()
def setMilestoneList(self, m, key):
"""Remove all milestones, set them to `m`"""
self.assertNoTickets()
c = self.db().cursor()
c.execute("DELETE FROM milestone")
for ms in m:
milestone = ms[key]
print " inserting milestone '%s'" % (milestone)
c.execute("INSERT INTO milestone (name) VALUES (%s)",
(milestone.encode('utf-8'),))
self.db().commit()
def addTicket(self, id, time, changetime, component, severity, priority,
owner, reporter, cc, version, milestone, status, resolution,
summary, description, keywords, customfields):
c = self.db().cursor()
desc = description.encode('utf-8')
type = "defect"
if SEVERITIES:
if severity.lower() == "enhancement":
severity = "minor"
type = "enhancement"
else:
if priority.lower() == "enhancement":
priority = "minor"
type = "enhancement"
if PREFORMAT_COMMENTS:
desc = '{{{\n%s\n}}}' % desc
if REPLACE_BUG_NO:
if BUG_NO_RE.search(desc):
desc = re.sub(BUG_NO_RE, BUG_NO_REPL, desc)
if PRIORITIES_MAP.has_key(priority):
priority = PRIORITIES_MAP[priority]
print " inserting ticket %s -- %s" % (id, summary)
c.execute("""INSERT INTO ticket (id, type, time, changetime, component,
severity, priority, owner, reporter,
cc, version, milestone, status,
resolution, summary, description,
keywords)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s, %s)""",
(id, type.encode('utf-8'), datetime2epoch(time),
datetime2epoch(changetime), component.encode('utf-8'),
severity.encode('utf-8'), priority.encode('utf-8'), owner,
reporter, cc, version, milestone.encode('utf-8'),
status.lower(), resolution, summary.encode('utf-8'), desc,
keywords))
self.db().commit()
if self.using_postgres:
c.execute("""SELECT SETVAL('ticket_id_seq', MAX(id)) FROM ticket;
SELECT SETVAL('report_id_seq', MAX(id)) FROM report""")
ticket_id = self.db().get_last_id(c, 'ticket')
# add all custom fields to ticket
for name, value in customfields.iteritems():
self.addTicketCustomField(ticket_id, name, value)
return ticket_id
def addTicketCustomField(self, ticket_id, field_name, field_value):
c = self.db().cursor()
if field_value == None:
return
c.execute("""INSERT INTO ticket_custom (ticket, name, value)
VALUES (%s, %s, %s)""",
(ticket_id, field_name.encode('utf-8'), field_value.encode('utf-8')))
self.db().commit()
def addTicketComment(self, ticket, time, author, value):
comment = value.encode('utf-8')
if PREFORMAT_COMMENTS:
comment = '{{{\n%s\n}}}' % comment
if REPLACE_BUG_NO:
if BUG_NO_RE.search(comment):
comment = re.sub(BUG_NO_RE, BUG_NO_REPL, comment)
c = self.db().cursor()
c.execute("""INSERT INTO ticket_change (ticket, time, author, field,
oldvalue, newvalue)
VALUES (%s, %s, %s, %s, %s, %s)""",
(ticket, datetime2epoch(time), author, 'comment', '', comment))
self.db().commit()
def addTicketChange(self, ticket, time, author, field, oldvalue, newvalue):
c = self.db().cursor()
if field == "owner":
if LOGIN_MAP.has_key(oldvalue):
oldvalue = LOGIN_MAP[oldvalue]
if LOGIN_MAP.has_key(newvalue):
newvalue = LOGIN_MAP[newvalue]
if field == "priority":
if PRIORITIES_MAP.has_key(oldvalue.lower()):
oldvalue = PRIORITIES_MAP[oldvalue.lower()]
if PRIORITIES_MAP.has_key(newvalue.lower()):
newvalue = PRIORITIES_MAP[newvalue.lower()]
# Doesn't make sense if we go from highest -> highest, for example.
if oldvalue == newvalue:
return
c.execute("""INSERT INTO ticket_change (ticket, time, author, field,
oldvalue, newvalue)
VALUES (%s, %s, %s, %s, %s, %s)""",
(ticket, datetime2epoch(time), author, field,
oldvalue.encode('utf-8'), newvalue.encode('utf-8')))
self.db().commit()
def addAttachment(self, author, a):
if a['filename'] != '':
description = a['description'].encode('utf-8')
id = a['bug_id']
filename = a['filename'].encode('utf-8')
filedata = StringIO.StringIO(a['thedata'])
filesize = len(filedata.getvalue())
time = a['creation_ts']
print " ->inserting attachment '%s' for ticket %s -- %s" % \
(filename, id, description)
attachment = Attachment(self.env, 'ticket', id)
attachment.author = author
attachment.description = description
attachment.insert(filename, filedata, filesize, datetime2epoch(time))
del attachment
def getLoginName(self, cursor, userid):
if userid not in self.loginNameCache:
cursor.execute("SELECT * FROM profiles WHERE userid = %s", (userid))
loginName = cursor.fetchall()
if loginName:
loginName = loginName[0]['login_name']
else:
print """WARNING: unknown bugzilla userid %d, recording as
anonymous""" % (userid)
loginName = "anonymous"
loginName = LOGIN_MAP.get(loginName, loginName)
self.loginNameCache[userid] = loginName
return self.loginNameCache[userid]
def getFieldName(self, cursor, fieldid):
if fieldid not in self.fieldNameCache:
# fielddefs.fieldid got changed to fielddefs.id in Bugzilla
# 2.23.3.
if BZ_VERSION >= 2233:
cursor.execute("SELECT * FROM fielddefs WHERE id = %s",
(fieldid))
else:
cursor.execute("SELECT * FROM fielddefs WHERE fieldid = %s",
(fieldid))
fieldName = cursor.fetchall()
if fieldName:
fieldName = fieldName[0]['name'].lower()
else:
print "WARNING: unknown bugzilla fieldid %d, \
recording as unknown" % (userid)
fieldName = "unknown"
self.fieldNameCache[fieldid] = fieldName
return self.fieldNameCache[fieldid]
def makeWhereClause(fieldName, values, negative=False):
if not values:
return ''
if negative:
connector, op = ' AND ', '!='
else:
connector, op = ' OR ', '='
clause = connector.join(["%s %s '%s'" % (fieldName, op, value)
for value in values])
return ' (' + clause + ')'
def convert(_db, _host, _user, _password, _env, _force):
activityFields = FieldTranslator()
# account for older versions of bugzilla
print "Using Bugzilla v%s schema." % BZ_VERSION
if BZ_VERSION == 2110:
activityFields['removed'] = "oldvalue"
activityFields['added'] = "newvalue"
# init Bugzilla environment
print "Bugzilla MySQL('%s':'%s':'%s':'%s'): connecting..." % \
(_db, _host, _user, ("*" * len(_password)))
mysql_con = MySQLdb.connect(host=_host,
user=_user, passwd=_password, db=_db, compress=1,
cursorclass=MySQLdb.cursors.DictCursor)
mysql_cur = mysql_con.cursor()
# init Trac environment
print "Trac SQLite('%s'): connecting..." % (_env)
trac = TracDatabase(_env)
# force mode...
if _force == 1:
print "\nCleaning all tickets..."
c = trac.db().cursor()
c.execute("DELETE FROM ticket_change")
trac.db().commit()
c.execute("DELETE FROM ticket")
trac.db().commit()
c.execute("DELETE FROM ticket_custom")
trac.db().commit()
c.execute("DELETE FROM attachment")
attachments_dir = os.path.join(os.path.normpath(trac.env.path),
"attachments")
# Straight from the Python documentation.
for root, dirs, files in os.walk(attachments_dir, topdown=False):
for name in files:
os.remove(os.path.join(root, name))
for name in dirs:
os.rmdir(os.path.join(root, name))
if not os.stat(attachments_dir):
os.mkdir(attachments_dir)
trac.db().commit()
print "All tickets cleaned..."
print "\n0. Filtering products..."
if BZ_VERSION >= 2180:
mysql_cur.execute("SELECT name FROM products")
else:
mysql_cur.execute("SELECT product AS name FROM products")
products = []
for line in mysql_cur.fetchall():
product = line['name']
if PRODUCTS and product not in PRODUCTS:
continue
if product in IGNORE_PRODUCTS:
continue
products.append(product)
PRODUCTS[:] = products
print " Using products", " ".join(PRODUCTS)
print "\n1. Import severities..."
trac.setSeverityList(SEVERITIES)
print "\n2. Import components..."
if not COMPONENTS_FROM_PRODUCTS:
if BZ_VERSION >= 2180:
sql = """SELECT DISTINCT c.name AS name, c.initialowner AS owner
FROM components AS c, products AS p
WHERE c.product_id = p.id AND"""
sql += makeWhereClause('p.name', PRODUCTS)
else:
sql = "SELECT value AS name, initialowner AS owner FROM components"
sql += " WHERE" + makeWhereClause('program', PRODUCTS)
mysql_cur.execute(sql)
components = mysql_cur.fetchall()
for component in components:
component['owner'] = trac.getLoginName(mysql_cur,
component['owner'])
trac.setComponentList(components, 'name')
else:
if BZ_VERSION >= 2180:
sql = ("SELECT p.name AS product, c.name AS comp, "
" c.initialowner AS owner "
"FROM components c, products p "
"WHERE c.product_id = p.id AND" +
makeWhereClause('p.name', PRODUCTS))
else:
sql = ("SELECT program AS product, value AS comp, "
" initialowner AS owner "
"FROM components WHERE" +
makeWhereClause('program', PRODUCTS))
mysql_cur.execute(sql)
lines = mysql_cur.fetchall()
all_components = {} # product -> components
all_owners = {} # product, component -> owner
for line in lines:
product = line['product']
comp = line['comp']
owner = line['owner']
all_components.setdefault(product, []).append(comp)
all_owners[(product, comp)] = owner
component_list = []
for product, components in all_components.items():
# find best default owner
default = None
for comp in DEFAULT_COMPONENTS:
if comp in components:
default = comp
break
if default is None:
default = components[0]
owner = all_owners[(product, default)]
owner_name = trac.getLoginName(mysql_cur, owner)
component_list.append({'product': product, 'owner': owner_name})
trac.setComponentList(component_list, 'product')
print "\n3. Import priorities..."
trac.setPriorityList(PRIORITIES)
print "\n4. Import versions..."
if BZ_VERSION >= 2180:
sql = """SELECT DISTINCTROW v.value AS value
FROM products p, versions v"""
sql += " WHERE v.product_id = p.id AND"
sql += makeWhereClause('p.name', PRODUCTS)
else:
sql = "SELECT DISTINCTROW value FROM versions"
sql += " WHERE" + makeWhereClause('program', PRODUCTS)
mysql_cur.execute(sql)
versions = mysql_cur.fetchall()
trac.setVersionList(versions, 'value')
print "\n5. Import milestones..."
sql = "SELECT DISTINCT value FROM milestones"
sql += " WHERE" + makeWhereClause('value', IGNORE_MILESTONES, negative=True)
mysql_cur.execute(sql)
milestones = mysql_cur.fetchall()
trac.setMilestoneList(milestones, 'value')
print "\n6. Retrieving bugs..."
if BZ_VERSION >= 2180:
sql = """SELECT DISTINCT b.*, c.name AS component, p.name AS product
FROM bugs AS b, components AS c, products AS p """
sql += " WHERE" + makeWhereClause('p.name', PRODUCTS)
sql += " AND b.product_id = p.id"
sql += " AND b.component_id = c.id"
sql += " ORDER BY b.bug_id"
else:
sql = """SELECT DISTINCT b.*, c.value AS component, p.product AS product
FROM bugs AS b, components AS c, products AS p """
sql += " WHERE" + makeWhereClause('p.product', PRODUCTS)
sql += " AND b.product = p.product"
sql += " AND b.component = c.value"
sql += " ORDER BY b.bug_id"
mysql_cur.execute(sql)
bugs = mysql_cur.fetchall()
print "\n7. Import bugs and bug activity..."
for bug in bugs:
bugid = bug['bug_id']
ticket = {}
keywords = []
ticket['id'] = bugid
ticket['time'] = bug['creation_ts']
ticket['changetime'] = bug['delta_ts']
if COMPONENTS_FROM_PRODUCTS:
ticket['component'] = bug['product']
else:
ticket['component'] = bug['component']
if SEVERITIES:
ticket['severity'] = bug['bug_severity']
ticket['priority'] = bug['priority'].lower()
else:
# use bugzilla severities as trac priorities, and ignore bugzilla
# priorities
ticket['severity'] = ''
ticket['priority'] = bug['bug_severity']
ticket['owner'] = trac.getLoginName(mysql_cur, bug['assigned_to'])
ticket['reporter'] = trac.getLoginName(mysql_cur, bug['reporter'])
# pack bugzilla fields into dictionary of trac custom field
# names and values
customfields = {}
for bugfield, customfield in CUSTOMFIELD_MAP.iteritems():
customfields[customfield] = bug[bugfield]
ticket['customfields'] = customfields
mysql_cur.execute("SELECT * FROM cc WHERE bug_id = %s", bugid)
cc_records = mysql_cur.fetchall()
cc_list = []
for cc in cc_records:
cc_list.append(trac.getLoginName(mysql_cur, cc['who']))
cc_list = [cc for cc in cc_list if cc not in IGNORE_CC]
ticket['cc'] = string.join(cc_list, ', ')
ticket['version'] = bug['version']
target_milestone = bug['target_milestone']
if target_milestone in IGNORE_MILESTONES:
target_milestone = ''
ticket['milestone'] = target_milestone
bug_status = bug['bug_status'].lower()
ticket['status'] = statusXlator[bug_status]
ticket['resolution'] = bug['resolution'].lower()
# a bit of extra work to do open tickets
if bug_status == 'open':
if owner != '':
ticket['status'] = 'assigned'
else:
ticket['status'] = 'new'
ticket['summary'] = bug['short_desc']
mysql_cur.execute("SELECT * FROM longdescs WHERE bug_id = %s" % bugid)
longdescs = list(mysql_cur.fetchall())
# check for empty 'longdescs[0]' field...
if len(longdescs) == 0:
ticket['description'] = ''
else:
ticket['description'] = longdescs[0]['thetext']
del longdescs[0]
for desc in longdescs:
ignore = False
for comment in IGNORE_COMMENTS:
if re.match(comment, desc['thetext']):
ignore = True
if ignore:
continue
trac.addTicketComment(ticket=bugid,
time = desc['bug_when'],
author=trac.getLoginName(mysql_cur, desc['who']),
value = desc['thetext'])
mysql_cur.execute("""SELECT * FROM bugs_activity WHERE bug_id = %s
ORDER BY bug_when""" % bugid)
bugs_activity = mysql_cur.fetchall()
resolution = ''
ticketChanges = []
keywords = []
for activity in bugs_activity:
field_name = trac.getFieldName(mysql_cur, activity['fieldid']).lower()
removed = activity[activityFields['removed']]
added = activity[activityFields['added']]
# statuses and resolutions are in lowercase in trac
if field_name == "resolution" or field_name == "bug_status":
removed = removed.lower()
added = added.lower()
# remember most recent resolution, we need this later
if field_name == "resolution":
resolution = added.lower()
add_keywords = []
remove_keywords = []
# convert bugzilla field names...
if field_name == "bug_severity":
if SEVERITIES:
field_name = "severity"
else:
field_name = "priority"
elif field_name == "assigned_to":
field_name = "owner"
elif field_name == "bug_status":
field_name = "status"
if removed in STATUS_KEYWORDS:
remove_keywords.append(STATUS_KEYWORDS[removed])
if added in STATUS_KEYWORDS:
add_keywords.append(STATUS_KEYWORDS[added])
added = statusXlator[added]
removed = statusXlator[removed]
elif field_name == "short_desc":
field_name = "summary"
elif field_name == "product" and COMPONENTS_FROM_PRODUCTS:
field_name = "component"
elif ((field_name == "product" and not COMPONENTS_FROM_PRODUCTS) or
(field_name == "component" and COMPONENTS_FROM_PRODUCTS)):
if MAP_ALL_KEYWORDS or removed in KEYWORDS_MAPPING:
kw = KEYWORDS_MAPPING.get(removed, removed)
if kw:
remove_keywords.append(kw)
if MAP_ALL_KEYWORDS or added in KEYWORDS_MAPPING:
kw = KEYWORDS_MAPPING.get(added, added)
if kw:
add_keywords.append(kw)
if field_name == "component":
# just keep the keyword change
added = removed = ""
elif field_name == "target_milestone":
field_name = "milestone"
if added in IGNORE_MILESTONES:
added = ""
if removed in IGNORE_MILESTONES:
removed = ""
ticketChange = {}
ticketChange['ticket'] = bugid
ticketChange['time'] = activity['bug_when']
ticketChange['author'] = trac.getLoginName(mysql_cur,
activity['who'])
ticketChange['field'] = field_name
ticketChange['oldvalue'] = removed
ticketChange['newvalue'] = added
if add_keywords or remove_keywords:
# ensure removed ones are in old
old_keywords = keywords + [kw for kw in remove_keywords if kw
not in keywords]
# remove from new
keywords = [kw for kw in keywords if kw not in remove_keywords]
# add to new
keywords += [kw for kw in add_keywords if kw not in keywords]
if old_keywords != keywords:
ticketChangeKw = ticketChange.copy()
ticketChangeKw['field'] = "keywords"
ticketChangeKw['oldvalue'] = ' '.join(old_keywords)
ticketChangeKw['newvalue'] = ' '.join(keywords)
ticketChanges.append(ticketChangeKw)
if field_name in IGNORED_ACTIVITY_FIELDS:
continue
# Skip changes that have no effect (think translation!).
if added == removed:
continue
# Bugzilla splits large summary changes into two records.
for oldChange in ticketChanges:
if (field_name == "summary"
and oldChange['field'] == ticketChange['field']
and oldChange['time'] == ticketChange['time']
and oldChange['author'] == ticketChange['author']):
oldChange['oldvalue'] += " " + ticketChange['oldvalue']
oldChange['newvalue'] += " " + ticketChange['newvalue']
break
# cc and attachments.isobsolete sometime appear
# in different activities with same time
if ((field_name == "cc" or field_name == "attachments.isobsolete") \
and oldChange['time'] == ticketChange['time']):
oldChange['newvalue'] += ", " + ticketChange['newvalue']
break
else:
ticketChanges.append (ticketChange)
for ticketChange in ticketChanges:
trac.addTicketChange (**ticketChange)
# For some reason, bugzilla v2.11 seems to clear the resolution
# when you mark a bug as closed. Let's remember it and restore
# it if the ticket is closed but there's no resolution.
if not ticket['resolution'] and ticket['status'] == "closed":
ticket['resolution'] = resolution
bug_status = bug['bug_status']
if bug_status in STATUS_KEYWORDS:
kw = STATUS_KEYWORDS[bug_status]
if kw not in keywords:
keywords.append(kw)
product = bug['product']
if product in KEYWORDS_MAPPING and not COMPONENTS_FROM_PRODUCTS:
kw = KEYWORDS_MAPPING.get(product, product)
if kw and kw not in keywords:
keywords.append(kw)
component = bug['component']
if (COMPONENTS_FROM_PRODUCTS and \
(MAP_ALL_KEYWORDS or component in KEYWORDS_MAPPING)):
kw = KEYWORDS_MAPPING.get(component, component)
if kw and kw not in keywords:
keywords.append(kw)
ticket['keywords'] = string.join(keywords)
ticketid = trac.addTicket(**ticket)
if BZ_VERSION >= 2210:
mysql_cur.execute("SELECT attachments.*, attach_data.thedata "
"FROM attachments, attach_data "
"WHERE attachments.bug_id = %s AND "
"attachments.attach_id = attach_data.id" % bugid)
else:
mysql_cur.execute("SELECT * FROM attachments WHERE bug_id = %s" %
bugid)
attachments = mysql_cur.fetchall()
for a in attachments:
author = trac.getLoginName(mysql_cur, a['submitter_id'])
trac.addAttachment(author, a)
print "\n8. Importing users and passwords..."
if BZ_VERSION >= 2167:
selectlogins = "SELECT login_name, cryptpassword FROM profiles";
if IGNORE_DISABLED_USERS:
selectlogins = selectlogins + " WHERE disabledtext=''"
mysql_cur.execute(selectlogins)
users = mysql_cur.fetchall()
htpasswd = file("htpasswd", 'w')
for user in users:
if LOGIN_MAP.has_key(user['login_name']):
login = LOGIN_MAP[user['login_name']]
else:
login = user['login_name']
htpasswd.write(login + ":" + user['cryptpassword'] + "\n")
htpasswd.close()
print " Bugzilla users converted to htpasswd format, see 'htpasswd'."
print "\nAll tickets converted."
def log(msg):
print "DEBUG: %s" % (msg)
def datetime2epoch(dt) :
import time
return time.mktime(dt.timetuple())
def usage():
print """bugzilla2trac - Imports a bug database from Bugzilla into Trac.
Usage: bugzilla2trac.py [options]
Available Options:
--db <MySQL dbname> - Bugzilla's database name
--tracenv /path/to/trac/env - Full path to Trac db environment
-h | --host <MySQL hostname> - Bugzilla's DNS host name
-u | --user <MySQL username> - Effective Bugzilla's database user
-p | --passwd <MySQL password> - Bugzilla's user password
-c | --clean - Remove current Trac tickets before
importing
-n | --noseverities - import Bugzilla severities as Trac
priorities and forget Bugzilla priorities
--help | help - This help info
Additional configuration options can be defined directly in the script.
"""
sys.exit(0)
def main():
global BZ_DB, BZ_HOST, BZ_USER, BZ_PASSWORD, TRAC_ENV, TRAC_CLEAN
global SEVERITIES, PRIORITIES, PRIORITIES_MAP
if len (sys.argv) > 1:
if sys.argv[1] in ['--help','help'] or len(sys.argv) < 4:
usage()
iter = 1
while iter < len(sys.argv):
if sys.argv[iter] in ['--db'] and iter+1 < len(sys.argv):
BZ_DB = sys.argv[iter+1]
iter = iter + 1
elif sys.argv[iter] in ['-h', '--host'] and iter+1 < len(sys.argv):
BZ_HOST = sys.argv[iter+1]
iter = iter + 1
elif sys.argv[iter] in ['-u', '--user'] and iter+1 < len(sys.argv):
BZ_USER = sys.argv[iter+1]
iter = iter + 1
elif sys.argv[iter] in ['-p', '--passwd'] and iter+1 < len(sys.argv):
BZ_PASSWORD = sys.argv[iter+1]
iter = iter + 1
elif sys.argv[iter] in ['--tracenv'] and iter+1 < len(sys.argv):
TRAC_ENV = sys.argv[iter+1]
iter = iter + 1
elif sys.argv[iter] in ['-c', '--clean']:
TRAC_CLEAN = 1
elif sys.argv[iter] in ['-n', '--noseverities']:
# treat Bugzilla severites as Trac priorities
PRIORITIES = SEVERITIES
SEVERITIES = []
PRIORITIES_MAP = {}
else:
print "Error: unknown parameter: " + sys.argv[iter]
sys.exit(0)
iter = iter + 1
convert(BZ_DB, BZ_HOST, BZ_USER, BZ_PASSWORD, TRAC_ENV, TRAC_CLEAN)
if __name__ == '__main__':
main()
|