issue2551142 - Import ... unique constraint failure.

Full title: Import of retired node with username after active node
fails with unique constraint failure.

Fix this in two ways:

1) sort export on keyname, retired status so that retired nodes for a
   given keyname are before the acive node in the export file.

This stops generating a broken export.

2) handle importing a broken export by deactivating/fixing up/clearing
the active record's unique index entry temporarily. Redo the
import of the retired node and resetting the active record to active.

The fixup changes the unique index (keyvalue, __retired__) from
(keyvalue, 0) to (keyvalue, -1). Then it retries the failed import of
a retired record with keyvalue. I use -1 in case something goes wrong,
It makes the record stand out in the database allowing hand recovery
if needed. Rather than using -1 I could just use the id of the record
like a normal retirement does.

If the retry of the import fails (raises exception), reset the active
record from -1 back to 0 and raise the exception.

If it succeeds, reset the active record from -1 back to 0 and continue
the import process.

Reset __retired__ from -1 to 0 on every import. I don't think the
performance loss from resetting on every exception matters as there
should be very few exceptions. Also this makes the code more
understandable.  There is no reason to leave the -1 value in place and
do a bulk rest of -1 to 0 after the class csv file is loaded.

Also if a fixup is needed it is logged at level info with the rest of
the database logging. Also success of the fixup is logged. Fixup
failure generates a propagated exception.

Author: rouilj

CHANGES.txt

@@ -131,6 +131,8 @@ Fixed:
   item with duplicate key. Fix incorrect error message when using
   roundup-admin to restore a user when the username is aleady in use.
   (John Rouillard)
+- issue2551142 - Import of retired node with username after active
+  node fails with unique constraint failure. (John Rouillard)
 
 Features:
 - issue2550522 - Add 'filter' command to command-line

roundup/admin.py

@@ -1319,8 +1319,23 @@ class colon_separated(csv.excel):
             fields.append('is retired')
             writer.writerow(fields)
 
-            # all nodes for this class
-            for nodeid in cl.getnodeids():
+            # If a node has a key, sort all nodes by key
+            # with retired nodes first. Retired nodes
+            # must occur before a non-retired node with
+            # the same key. Otherwise you get an
+            # IntegrityError: UNIQUE constraint failed:
+            #     _class.__retired__, _<class>._<keyname>
+            # on imports to rdbms.
+            all_nodes = cl.getnodeids()
+
+            classkey = cl.getkey()
+            if classkey: # False sorts before True, so negate is_retired
+                keysort = lambda i: (cl.get(i, classkey),
+                                     not cl.is_retired(i))
+                all_nodes.sort(key=keysort)
+            # if there is no classkey no need to sort
+
+            for nodeid in all_nodes:
                 if self.verbose:
                     sys.stdout.write('\rExporting %s - %s' % 
                                      (classname, nodeid))

roundup/backends/rdbms_common.py

@@ -3113,6 +3113,9 @@ def import_list(self, propnames, proplist):
 
             Return the nodeid of the node imported.
         """
+
+        logger = logging.getLogger('roundup.hyperdb.backend')
+
         if self.db.journaltag is None:
             raise DatabaseError(_('Database open read-only'))
         properties = self.getprops()
@@ -3168,19 +3171,57 @@ def import_list(self, propnames, proplist):
         if newid is None:
             newid = self.db.newid(self.classname)
 
+        activeid = None
+        has_node = False
+
+        # use the arg for __retired__ to cope with any odd database type
+        # conversion (hello, sqlite)
+        retired_sql = 'update _%s set __retired__=%s where id=%s'%(
+            self.classname, self.db.arg, self.db.arg)
+
         # insert new node or update existing?
-        if not self.hasnode(newid):
-            self.db.addnode(self.classname, newid, d) # insert
-        else:
-            self.db.setnode(self.classname, newid, d) # update
+        # if integrity error raised try to recover
+        try:
+            has_node = self.hasnode(newid)
+            if not has_node:
+                self.db.addnode(self.classname, newid, d) # insert
+            else:
+                self.db.setnode(self.classname, newid, d) # update
+        # Blech, different db's return different exceptions
+        # so I can't list them here as some might not be defined
+        # on a given system. So capture all exceptions from the
+        # code above and try to correct it. If it's correctable its
+        # some form of Uniqueness Failure/Integrity Error otherwise
+        # undo the fixup and pass on the error.
+        except Exception as e:
+            logger.info('Attempting to handle import exception '
+                        'for id %s: %s' % (newid,e))
+
+            keyname = self.db.user.getkey()
+            if has_node or not keyname:  # Not an integrity error
+                raise
+            activeid = self.db.user.lookup(d[keyname])
+            self.db.sql(retired_sql, (-1, activeid)) # clear the active node
+            # this can only happen on an addnode, so retry
+            try:
+                # if this raises an error, let it propagate upward
+                self.db.addnode(self.classname, newid, d) # insert
+            except Exception:
+                # undo the database change
+                self.db.sql(retired_sql, (0, activeid)) # clear the active node
+                raise # propagate
+            logger.info('Successfully handled import exception '
+                        'for id %s which conflicted with %s' % (
+                            newid, activeid))
 
         # retire?
         if retire:
-            # use the arg for __retired__ to cope with any odd database type
-            # conversion (hello, sqlite)
-            sql = 'update _%s set __retired__=%s where id=%s'%(self.classname,
-                self.db.arg, self.db.arg)
-            self.db.sql(sql, (newid, newid))
+            self.db.sql(retired_sql, (newid, newid))
+
+        if activeid:
+            # unretire the active node
+            self.db.sql(retired_sql, ('0', activeid))
+
         return newid
 
     def export_journals(self):

test/db_test_base.py

@@ -235,6 +235,10 @@ def filteringSetupTransitiveSearch(self, classname='issue'):
 
 class DBTest(commonDBTest):
 
+    @pytest.fixture(autouse=True)
+    def inject_fixtures(self, caplog):
+        self._caplog = caplog
+
     def testRefresh(self):
         self.db.refresh_database()
 
@@ -2808,6 +2812,27 @@ def testImportExport(self):
         self.db.user.retire('3')
         self.db.issue.retire('2')
 
+        # Key fields must be unique. There can only be one unretired
+        # object with a given key value. When importing verify that
+        # having the unretired object with a key value before a retired
+        # object with the same key value is handled properly.
+
+        # Since the order of the exported objects is not consistant
+        # across backends, we sort the objects by id (as an int) and
+        # make sure that the active (non-retired) entry sorts before
+        # the retired entry.
+        active_dupe_id = self.db.user.create(username="duplicate",
+                                             roles='User',
+            password=password.Password('sekrit'), address='[email protected]')
+        self.db.user.retire(active_dupe_id) # allow us to create second dupe
+
+        retired_dupe_id = self.db.user.create(username="duplicate",
+                                              roles='User',
+            password=password.Password('sekrit'), address='[email protected]')
+        self.db.user.retire(retired_dupe_id)
+        self.db.user.restore(active_dupe_id) # unretire lower numbered id
+        self.db.commit()
+
         # grab snapshot of the current database
         orig = {}
         origj = {}
@@ -2825,29 +2850,64 @@ def testImportExport(self):
             # grab the export
             export = {}
             journals = {}
+            active_dupe_id_first = -1 # -1 unknown, False or True
             for cn,klass in self.db.classes.items():
                 names = klass.export_propnames()
                 cl = export[cn] = [names+['is retired']]
-                for id in klass.getnodeids():
+                classname = klass.classname
+                nodeids =  klass.getnodeids()
+                # sort to enforce retired/unretired order
+                nodeids.sort(key=int)
+                for id in nodeids:
+                    if (classname == 'user' and 
+                       id == retired_dupe_id and 
+                       active_dupe_id_first == -1):
+                       active_dupe_id_first = False
+                    if (classname == 'user' and 
+                       id == active_dupe_id and 
+                       active_dupe_id_first == -1):
+                        active_dupe_id_first = True
                     cl.append(klass.export_list(names, id))
                     if hasattr(klass, 'export_files'):
                         klass.export_files('_test_export', id)
                 journals[cn] = klass.export_journals()
 
             self.nukeAndCreate()
 
+            if not active_dupe_id_first:
+                # verify that the test is configured properly to
+                # trigger the exception code to handle uniqueness
+                # failure.
+                self.fail("Setup failure: active user id not first.")
+
             # import
-            for cn, items in export.items():
-                klass = self.db.classes[cn]
-                names = items[0]
-                maxid = 1
-                for itemprops in items[1:]:
-                    id = int(klass.import_list(names, itemprops))
-                    if hasattr(klass, 'import_files'):
-                        klass.import_files('_test_export', str(id))
-                    maxid = max(maxid, id)
-                self.db.setid(cn, str(maxid+1))
-                klass.import_journals(journals[cn])
+            with self._caplog.at_level(logging.INFO,
+                                       logger="roundup.hyperdb.backend"):
+            # not supported in python2, so use caplog rather than len(log)
+            #  X in log[0] ... 
+            #    with self.assertLogs('roundup.hyperdb.backend',
+            #                     level="INFO") as log:
+              for cn, items in export.items():
+                  klass = self.db.classes[cn]
+                  names = items[0]
+                  maxid = 1
+                  for itemprops in items[1:]:
+                      id = int(klass.import_list(names, itemprops))
+                      if hasattr(klass, 'import_files'):
+                          klass.import_files('_test_export', str(id))
+                      maxid = max(maxid, id)
+                  self.db.setid(cn, str(maxid+1))
+                  klass.import_journals(journals[cn])
+
+            if self.db.dbtype != 'anydbm':
+                # no logs or fixup needed under anydbm
+                self.assertEqual(2, len(self._caplog.record_tuples))
+                self.assertIn('Attempting to handle import exception for id 7:',
+                              self._caplog.record_tuples[0][2])
+                self.assertIn('Successfully handled import exception for id 7 '
+                              'which conflicted with 6',
+                              self._caplog.record_tuples[1][2])
+
             # This is needed, otherwise journals won't be there for anydbm
             self.db.commit()
         finally:
@@ -2895,7 +2955,7 @@ def testImportExport(self):
         # make sure id counters are set correctly
         maxid = max([int(id) for id in self.db.user.list()])
         newid = int(self.db.user.create(username='testing'))
-        assert newid > maxid
+        self.assertGreater(newid, maxid)
 
     # test import/export via admin interface
     def testAdminImportExport(self):