Import wiredtiger: a68890f718f74cdc9e9961bf5b33f5b125e853dd from branch mongodb-4.6

ref: df168fcd37..a68890f718
for: 4.7.0

WT-6592       Avoid marking errors for skipped Python tests due to not-built extension
WT-6653       Rollback/Restart txn before retry in RTS test

3 files changed, 37 insertions, 25 deletions

diff --git a/src/third_party/wiredtiger/import.data b/src/third_party/wiredtiger/import.data
index 37622b8cda6..9bf8a939b70 100644
--- a/src/third_party/wiredtiger/import.data
+++ b/src/third_party/wiredtiger/import.data
@@ -2,5 +2,5 @@
     "vendor": "wiredtiger",
     "github": "wiredtiger/wiredtiger.git",
     "branch": "mongodb-4.6",
-    "commit": "df168fcd373a4afc719f6134f6911a1685178041"
+    "commit": "a68890f718f74cdc9e9961bf5b33f5b125e853dd"
 }
diff --git a/src/third_party/wiredtiger/test/suite/test_rollback_to_stable10.py b/src/third_party/wiredtiger/test/suite/test_rollback_to_stable10.py
index 4a322c61998..12a3daeedfc 100755
--- a/src/third_party/wiredtiger/test/suite/test_rollback_to_stable10.py
+++ b/src/third_party/wiredtiger/test/suite/test_rollback_to_stable10.py
@@ -38,7 +38,7 @@ from time import sleep
 def timestamp_str(t):
     return '%x' % t
 
-def retry_rollback(self, name, code):
+def retry_rollback(self, name, txn_session, code):
     retry_limit = 100
     retries = 0
     completed = False
@@ -46,7 +46,12 @@ def retry_rollback(self, name, code):
     while not completed and retries < retry_limit:
         if retries != 0:
             self.pr("Retrying operation for " + name)
+            if txn_session:
+                txn_session.rollback_transaction()
             sleep(0.1)
+            if txn_session:
+                txn_session.begin_transaction('isolation=snapshot')
+                self.pr("Began new transaction for " + name)
         try:
             code()
             completed = True
@@ -164,13 +169,13 @@ class test_rollback_to_stable10(test_rollback_to_stable_base):
             # Perform several updates in parallel with checkpoint.
             # Rollbacks may occur when checkpoint is running, so retry as needed.
             self.pr("updates")
-            retry_rollback(self, 'update ds1, e',
+            retry_rollback(self, 'update ds1, e', None,
                            lambda: self.large_updates(uri_1, value_e, ds_1, nrows, 70))
-            retry_rollback(self, 'update ds2, e',
+            retry_rollback(self, 'update ds2, e', None,
                            lambda: self.large_updates(uri_2, value_e, ds_2, nrows, 70))
-            retry_rollback(self, 'update ds1, f',
+            retry_rollback(self, 'update ds1, f', None,
                            lambda: self.large_updates(uri_1, value_f, ds_1, nrows, 80))
-            retry_rollback(self, 'update ds2, f',
+            retry_rollback(self, 'update ds2, f', None,
                            lambda: self.large_updates(uri_2, value_f, ds_2, nrows, 80))
         finally:
             done.set()
@@ -271,12 +276,17 @@ class test_rollback_to_stable10(test_rollback_to_stable_base):
         else:
             self.conn.set_timestamp('stable_timestamp=' + timestamp_str(50))
 
-        # Here's the update operation we'll perform, encapsulated so we can easily retry
+        # Here's the update operations we'll perform, encapsulated so we can easily retry
         # it if we get a rollback. Rollbacks may occur when checkpoint is running.
-        def simple_update(cursor, key, value):
-            cursor.set_key(key)
-            cursor.set_value(value)
-            self.assertEquals(cursor.update(), 0)
+        def prepare_range_updates(session, cursor, ds, value, nrows, prepare_config):
+            self.pr("updates")
+            for i in range(1, nrows):
+                key = ds.key(i)
+                cursor.set_key(key)
+                cursor.set_value(value)
+                self.assertEquals(cursor.update(), 0)
+            self.pr("prepare")
+            session.prepare_transaction(prepare_config)
 
         # Create a checkpoint thread
         done = threading.Event()
@@ -289,23 +299,19 @@ class test_rollback_to_stable10(test_rollback_to_stable_base):
             session_p1 = self.conn.open_session()
             cursor_p1 = session_p1.open_cursor(uri_1)
             session_p1.begin_transaction('isolation=snapshot')
-            self.pr("updates 1")
-            for i in range(1, nrows):
-                retry_rollback(self, 'update ds1',
-                               lambda: simple_update(cursor_p1, ds_1.key(i), value_e))
-            self.pr("prepare 1")
-            session_p1.prepare_transaction('prepare_timestamp=' + timestamp_str(69))
+            retry_rollback(self, 'update ds1', session_p1,
+                           lambda: prepare_range_updates(
+                               session_p1, cursor_p1, ds_1, value_e, nrows,
+                               'prepare_timestamp=' + timestamp_str(69)))
 
             # Perform several updates in parallel with checkpoint.
             session_p2 = self.conn.open_session()
             cursor_p2 = session_p2.open_cursor(uri_2)
             session_p2.begin_transaction('isolation=snapshot')
-            self.pr("updates 2")
-            for i in range(1, nrows):
-                retry_rollback(self, 'update ds2',
-                               lambda: simple_update(cursor_p2, ds_2.key(i), value_e))
-            self.pr("prepare 2")
-            session_p2.prepare_transaction('prepare_timestamp=' + timestamp_str(69))
+            retry_rollback(self, 'update ds2', session_p2,
+                           lambda: prepare_range_updates(
+                               session_p2, cursor_p2, ds_2, value_e, nrows,
+                               'prepare_timestamp=' + timestamp_str(69)))
         finally:
             done.set()
             ckpt.join()
diff --git a/src/third_party/wiredtiger/test/suite/wttest.py b/src/third_party/wiredtiger/test/suite/wttest.py
index a0a86731f1c..617a8326582 100755
--- a/src/third_party/wiredtiger/test/suite/wttest.py
+++ b/src/third_party/wiredtiger/test/suite/wttest.py
@@ -227,6 +227,7 @@ class WiredTigerTestCase(unittest.TestCase):
         if hasattr(self, 'scenarios'):
             assert(len(self.scenarios) == len(dict(self.scenarios)))
         unittest.TestCase.__init__(self, *args, **kwargs)
+        self.skipped = False
         if not self._globalSetup:
             WiredTigerTestCase.globalSetup()
 
@@ -253,6 +254,10 @@ class WiredTigerTestCase(unittest.TestCase):
     def buildDirectory(self):
         return self._builddir
 
+    def skipTest(self, reason):
+        self.skipped = True
+        super(WiredTigerTestCase, self).skipTest(reason)
+
     # Return the wiredtiger_open extension argument for
     # any needed shared library.
     def extensionsConfig(self):
@@ -460,9 +465,10 @@ class WiredTigerTestCase(unittest.TestCase):
             for f in files:
                 os.chmod(os.path.join(root, f), 0o666)
         self.pr('passed=' + str(passed))
+        self.pr('skipped=' + str(self.skipped))
 
         # Clean up unless there's a failure
-        if passed and not WiredTigerTestCase._preserveFiles:
+        if (passed and (not WiredTigerTestCase._preserveFiles)) or self.skipped:
             shutil.rmtree(self.testdir, ignore_errors=True)
         else:
             self.pr('preserving directory ' + self.testdir)
@@ -470,7 +476,7 @@ class WiredTigerTestCase(unittest.TestCase):
         elapsed = time.time() - self.starttime
         if elapsed > 0.001 and WiredTigerTestCase._verbose >= 2:
             print("%s: %.2f seconds" % (str(self), elapsed))
-        if not passed:
+        if (not passed) and (not self.skipped):
             print("ERROR in " + str(self))
             self.pr('FAIL')
             self.pr('preserving directory ' + self.testdir)