Ticket #1462: bugzilla2trac.py.6.diff

bugzilla2trac.py

@@ -3 +3 @@
 """
 Import a Bugzilla items into a Trac database.
 
-Requires:  Trac 0.7.1 from http://trac.edgewall.com/
+Requires:  Trac 0.9b1 from http://trac.edgewall.com/
            Python 2.3 from http://www.python.org/
            MySQL >= 3.23 from http://www.mysql.org/
 
@@ -13 +13 @@
 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@tendra.org>
+
+$Id$
 """
 
+import re
+
 ###
 ### Conversion Settings -- edit these before running if desired
 ###
@@ -22 +28 @@
 # Bugzilla version.  You can find this in Bugzilla's globals.pl file.
 #
 # Currently, the following bugzilla versions are known to work:
-#   2.11
+#   2.11 (2110), 2.16.5 (2165), 2.18.3 (2183), 2.19.1 (2191)
 #
 # If you run this script on a version not listed here and it is successful,
-# please report it to the Trac mailing list so we can update the list.
-BZ_VERSION = '2.16.5'
+# please report it to the Trac mailing list and drop a note to
+# asmodai@tendra.org so we can update the list.
+BZ_VERSION = 2180
 
 # MySQL connection parameters for the Bugzilla database.  These can also 
 # be specified on the command line.
-BZ_DB = ''
-BZ_HOST = 'localhost'
-BZ_USER = ''
-BZ_PASSWORD = ''
+BZ_DB = ""
+BZ_HOST = ""
+BZ_USER = ""
+BZ_PASSWORD = ""
 
 # Path to the Trac environment.
-TRAC_ENV = ''
+TRAC_ENV = "/usr/local/trac"
 
 # If true, all existing Trac tickets and attachments will be removed 
 # prior to import.
-TRAC_CLEAN = False
+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 = []
 
-# Trac doesn't have the concept of a product.  Instead, this script can
-# assign keywords in the ticket entry to represent products.
-#
-# ex. PRODUCT_KEYWORDS = { 'product1' : 'PRODUCT1_KEYWORD' }
-PRODUCT_KEYWORDS = {}
+# These milestones are ignored
+IGNORE_MILESTONES = ["---"]
 
+# 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
+
+
 # Bug comments that should not be imported.  Each entry in list should
 # be a regular expression.
 IGNORE_COMMENTS = [
-   '^Created an attachment \(id='
+   "^Created an attachment \(id="
 ]
 
 ###########################################################################
@@ -76 +158 @@
 # 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'
+  "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'
+  "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']
+IGNORED_ACTIVITY_FIELDS = ["everconfirmed"]
 
+# Regular expression and its replacement
+BUG_NO_RE = re.compile(r"\b(bug #?)([0-9])")
+BUG_NO_REPL = r"#\2"
+
 ###
 ### Script begins here
 ###
 
 import os
-import re
 import sys
 import string
 import StringIO
 
 import MySQLdb
 import MySQLdb.cursors
-import trac.env
+try:
+    from trac.env import Environment
+except:
+    from trac.Environment import Environment
+from trac.attachment import Attachment
 
 if not hasattr(sys, 'setdefaultencoding'):
     reload(sys)
@@ -116 +205 @@
 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())
+#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
@@ -134 +223 @@
 
 class TracDatabase(object):
     def __init__(self, path):
-        self.env = trac.env.Environment(path)
+        self.env = Environment(path)
         self._db = self.env.get_db_cnx()
         self._db.autocommit = False
         self.loginNameCache = {}
@@ -145 +234 @@
     
     def hasTickets(self):
         c = self.db().cursor()
-        c.execute('''SELECT count(*) FROM Ticket''')
+        c.execute("SELECT count(*) FROM Ticket")
         return int(c.fetchall()[0][0]) > 0
 
     def assertNoTickets(self):
@@ -157 +246 @@
         self.assertNoTickets()
         
         c = self.db().cursor()
-        c.execute("""DELETE FROM enum WHERE type='severity'""")
+        c.execute("DELETE FROM enum WHERE type='severity'")
         for value, i in s:
-            print "inserting severity ", value, " ", i
-            c.execute("""INSERT INTO enum (type, name, value) VALUES (%s, %s, %s)""",
-                      "severity", value.encode('utf-8'), i)
+            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):
@@ -169 +259 @@
         self.assertNoTickets()
         
         c = self.db().cursor()
-        c.execute("""DELETE FROM enum WHERE type='priority'""")
+        c.execute("DELETE FROM enum WHERE type='priority'")
         for value, i in s:
-            print "inserting priority ", value, " ", i
-            c.execute("""INSERT INTO enum (type, name, value) VALUES (%s, %s, %s)""",
-                      "priority",
-                      value.encode('utf-8'),
-                      i)
+            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()
 
     
@@ -184 +273 @@
         self.assertNoTickets()
         
         c = self.db().cursor()
-        c.execute("""DELETE FROM component""")
+        c.execute("DELETE FROM component")
         for comp in l:
-            print "inserting component '",comp[key],"', owner",  comp['owner']
-            c.execute("""INSERT INTO component (name, owner) VALUES (%s, %s)""",
-                      comp[key].encode('utf-8'), comp['owner'].encode('utf-8'))
+            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):
@@ -196 +287 @@
         self.assertNoTickets()
         
         c = self.db().cursor()
-        c.execute("""DELETE FROM version""")
+        c.execute("DELETE FROM version")
         for vers in v:
-            print "inserting version ", vers[key]
-            c.execute("""INSERT INTO version (name) VALUES (%s)""",
-                      vers[key].encode('utf-8'))
+            print "  inserting version '%s'" % (vers[key])
+            c.execute("INSERT INTO version (name) VALUES (%s)", (vers[key],))
         self.db().commit()
         
     def setMilestoneList(self, m, key):
@@ -208 +298 @@
         self.assertNoTickets()
         
         c = self.db().cursor()
-        c.execute("""DELETE FROM milestone""")
+        c.execute("DELETE FROM milestone")
         for ms in m:
-            print "inserting milestone ", ms[key]
-            c.execute("""INSERT INTO milestone (name) VALUES (%s)""",
-                      ms[key].encode('utf-8'))
+            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,
+    def addTicket(self, id, time, changetime, component, severity, priority,
+                  owner, reporter, cc, version, milestone, status, resolution,
                   summary, description, keywords):
         c = self.db().cursor()
         
         desc = description.encode('utf-8')
+        type = "defect"
         
+        if severity.lower() == "enhancement":
+                severity = "minor"
+                type = "enhancement"
+        
         if PREFORMAT_COMMENTS:
           desc = '{{{\n%s\n}}}' % desc
 
-        print "inserting ticket %s -- %s" % (id, summary)
-        c.execute("""INSERT INTO ticket (id, 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)""",
-                  id, time.strftime('%s'), changetime.strftime('%s'), 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)
+        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'), time.strftime('%s'),
+                   changetime.strftime('%s'), 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()
-        return self.db().db.sqlite_last_insert_rowid()
+        return self.db().get_last_id(c, 'ticket')
     
     def addTicketComment(self, ticket, time, author, value):
         comment = value.encode('utf-8')
@@ -249 +353 @@
         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, time.strftime('%s'), author, 'comment', '', comment)
+        c.execute("""INSERT INTO ticket_change (ticket, time, author, field,
+                                                oldvalue, newvalue)
+                                        VALUES (%s, %s, %s, %s, %s, %s)""",
+                  (ticket, time.strftime('%s'), author, 'comment', '', comment))
         self.db().commit()
 
     def addTicketChange(self, ticket, time, author, field, oldvalue, newvalue):
         c = self.db().cursor()
-        c.execute("""INSERT INTO ticket_change (ticket, time, author, field, oldvalue, newvalue)
-                                 VALUES        (%s, %s, %s, %s, %s, %s)""",
-                  ticket, time.strftime('%s'), author, field, oldvalue.encode('utf-8'), newvalue.encode('utf-8'))
+
+        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, time.strftime('%s'), author, field,
+                   oldvalue.encode('utf-8'), newvalue.encode('utf-8')))
         self.db().commit()
         
-    def addAttachment(self, id, attachment, description, author):
-        print 'inserting attachment for ticket %s -- %s' % (id, description)
-        attachment.filename = attachment.filename.encode('utf-8')
-        self.env.create_attachment(self.db(), 'ticket', str(id), attachment, description.encode('utf-8'),
-            author, 'unknown')
+    def addAttachment(self, author, a):
+        description = a['description'].encode('utf-8')
+        id = a['bug_id']
+        filename = a['filename'].encode('utf-8')
+        filedata = StringIO.StringIO(a['thedata'].tostring())
+        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, time.strftime('%s'))
+        del attachment
         
     def getLoginName(self, cursor, userid):
         if userid not in self.loginNameCache:
-            cursor.execute("SELECT * FROM profiles WHERE userid = %s" % userid)
+            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'
+                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:
-            cursor.execute("SELECT * FROM fielddefs WHERE fieldid = %s" % fieldid)
+            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'
+                print "WARNING: unknown bugzilla fieldid %d, \
+                                recording as unknown" % (userid)
+                fieldName = "unknown"
 
             self.fieldNameCache[fieldid] = fieldName
 
         return self.fieldNameCache[fieldid]
 
-def productFilter(fieldName, products):
-    first = True
-    result = ''
-    for product in products:
-        if not first: 
-            result += " or "
-        first = False
-        result += "%s = '%s'" % (fieldName, product)
-    return result
+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
-    if BZ_VERSION == '2.11':
-        print 'Using Buzvilla v%s schema.' % BZ_VERSION
-        activityFields['removed'] = 'oldvalue'
-        activityFields['added'] = 'newvalue'
+    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, _password)
+    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)
@@ -330 +468 @@
 
     # force mode...
     if _force == 1:
-        print "cleaning all tickets..."
+        print "\nCleaning all tickets..."
         c = trac.db().cursor()
-        c.execute("""DELETE FROM ticket_change""")
+        c.execute("DELETE FROM ticket_change")
         trac.db().commit()
-        c.execute("""DELETE FROM ticket""")
+        
+        c.execute("DELETE FROM ticket")
         trac.db().commit()
-        c.execute("""DELETE FROM attachment""")
-        os.system('rm -rf %s' % trac.env.get_attachments_dir())
-        os.mkdir(trac.env.get_attachments_dir())
+        
+        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
-    print "1. import severities..."
-    severities = (('blocker', '1'), ('critical', '2'), ('major', '3'), ('normal', '4'),
-        ('minor', '5'), ('trivial', '6'), ('enhancement', '7'))
-    trac.setSeverityList(severities)
+    print "\n0. Filtering products..."
+    mysql_cur.execute("SELECT 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
-    print "2. import components..."
-    sql = "SELECT value, initialowner AS owner FROM components"
-    if PRODUCTS:
-       sql += " WHERE %s" % productFilter('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, 'value')
+    print "\n1. Import severities..."
+    trac.setSeverityList(SEVERITIES)
 
-    print
-    print "3. import priorities..."
-    priorities = (('P1', '1'), ('P2', '2'), ('P3', '3'), ('P4', '4'), ('P5', '5'))
-    trac.setPriorityList(priorities)
+    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:
+        sql = """SELECT program AS product, value AS comp, initialowner AS owner
+                   FROM components"""
+        sql += " 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
-    print "4. import versions..."
-    sql = "SELECT DISTINCTROW value FROM versions"
-    if PRODUCTS:
-       sql += " WHERE %s" % productFilter('program', PRODUCTS)
+    print "\n3. Import priorities..."
+    trac.setPriorityList(PRIORITIES)
+
+    print "\n4. Import versions..."
+    if BZ_VERSION >= 2180:
+        sql = """SELECT DISTINCTROW versions.value AS value
+                               FROM products, versions"""
+        sql += " WHERE" + makeWhereClause('products.name', PRODUCTS)
+    else:
+