[Zope-Checkins] CVS: ZODB3/BDBStorage/tests - test_autopack.py:1.9

Barry Warsaw barry@wooz.org
Mon, 27 Jan 2003 16:16:30 -0500


Update of /cvs-repository/ZODB3/BDBStorage/tests
In directory cvs.zope.org:/tmp/cvs-serv21542

Modified Files:
	test_autopack.py 
Log Message:
Back port race condition tests.


=== ZODB3/BDBStorage/tests/test_autopack.py 1.8 => 1.9 ===
--- ZODB3/BDBStorage/tests/test_autopack.py:1.8	Tue Jan 21 14:22:39 2003
+++ ZODB3/BDBStorage/tests/test_autopack.py	Mon Jan 27 16:16:27 2003
@@ -12,8 +12,6 @@
 #
 ##############################################################################
 
-from __future__ import nested_scopes
-
 import os
 import time
 import unittest
@@ -55,9 +53,9 @@
 class TestAutopackBase(BerkeleyTestBase):
     def _config(self):
         config = BerkeleyConfig()
-        # Autopack every 3 seconds, 6 seconds into the past, no classic packs
-        config.frequency = 3
-        config.packtime = 6
+        # Autopack every 1 second, 2 seconds into the past, no classic packs
+        config.frequency = 1
+        config.packtime = 2
         config.classicpack = 0
         return config
 
@@ -66,7 +64,7 @@
         # BAW: this uses a non-public interface
         packtime = storage._autopacker._nextcheck
         while packtime == storage._autopacker._nextcheck:
-            time.sleep(1)
+            time.sleep(0.1)
 
     def _mk_dbhome(self, dir):
         # Create the storage
@@ -100,8 +98,8 @@
         unless(storage.loadSerial(oid, revid1))
         unless(storage.loadSerial(oid, revid2))
         unless(storage.loadSerial(oid, revid3))
-        # Should be enough time for the revisions to get packed away
-        time.sleep(10)
+        # Two more autopacks ought to be enough to pack away old revisions
+        self._wait_for_next_autopack()
         self._wait_for_next_autopack()
         # The first two revisions should now be gone, but the third should
         # still exist because it's the current revision, and we haven't done a
@@ -117,9 +115,10 @@
 
     def _config(self):
         config = BerkeleyConfig()
-        # Autopack every 3 seconds, 6 seconds into the past, no classic packs
-        config.frequency = 3
-        config.packtime = 6
+        # Autopack every 1 second, 2 seconds into the past, classic packing
+        # every time.
+        config.frequency = 1
+        config.packtime = 2
         config.classicpack = 1
         return config
 
@@ -141,8 +140,8 @@
         unless(storage.loadSerial(oid, revid1))
         unless(storage.loadSerial(oid, revid2))
         unless(storage.loadSerial(oid, revid3))
-        # Should be enough time for the revisions to get packed away
-        time.sleep(10)
+        # Two more autopacks ought to be enough to pack away old revisions
+        self._wait_for_next_autopack()
         self._wait_for_next_autopack()
         # The first two revisions should now be gone, but the third should
         # still exist because it's the current revision, and we haven't done a
@@ -282,6 +281,113 @@
         # clean up any outstanding transactions
         get_transaction().abort()
 
+    def _getPackThread(self, storage):
+        raise NotImplemented
+
+    def testRaceCondition(self):
+        unless = self.failUnless
+        storage = self._storage
+        db = DB(storage)
+        conn = db.open()
+        root = conn.root()
+        # Start by storing a root reachable object.
+        obj1 = C()
+        obj1.value = 888
+        root.obj1 = obj1
+        txn = get_transaction()
+        txn.note('root -> obj1')
+        txn.commit()
+        # Now, start a transaction, store an object, but don't yet complete
+        # the transaction.  This will ensure that the second object has a tid
+        # < packtime, but it won't be root reachable yet.
+        obj2 = C()
+        t = Transaction()
+        storage.tpc_begin(t)
+        obj2sn = storage.store('\0'*7 + '\2', ZERO, zodb_pickle(obj2), '', t)
+        # Now, acquire the condvar lock and start a thread that will do a
+        # pack, up to the _sweep call.  Wait for the _mark() call to
+        # complete.
+        now = time.time()
+        while now == time.time():
+            time.sleep(0.1)
+        self._cv.acquire()
+        packthread = self._getPackThread(storage)
+        packthread.start()
+        self._cv.wait()
+        # Now that the _mark() has finished, complete the transaction, which
+        # links the object to root.
+        root.obj2 = obj2
+        rootsn = storage.getSerial(ZERO)
+        rootsn = storage.store(ZERO, rootsn, zodb_pickle(root), '', t)
+        storage.tpc_vote(t)
+        storage.tpc_finish(t)
+        # And notify the pack thread that it can do the sweep and collect
+        self._cv.notify()
+        self._cv.wait()
+        # We're done with the condvar and the thread
+        self._cv.release()
+        packthread.join()
+        # Now make sure that all the interesting objects are still available
+        rootsn = storage.getSerial(ZERO)
+        obj1sn = storage.getSerial('\0'*7 + '\1')
+        obj2sn = storage.getSerial('\0'*7 + '\2')
+        # obj1 revision was written before the second revision of the root
+        unless(obj1sn < rootsn)
+        unless(rootsn == obj2sn)
+        unless(obj1sn < obj2sn)
+
+    def testEarlierRaceCondition(self):
+        unless = self.failUnless
+        storage = self._storage
+        db = DB(storage)
+        conn = db.open()
+        root = conn.root()
+        # Start by storing a root reachable object.
+        obj1 = C()
+        obj1.value = 888
+        root.obj1 = obj1
+        txn = get_transaction()
+        txn.note('root -> obj1')
+        txn.commit()
+        # Now, start a transaction, store an object, but don't yet complete
+        # the transaction.  This will ensure that the second object has a tid
+        # < packtime, but it won't be root reachable yet.
+        obj2 = C()
+        t = Transaction()
+        storage.tpc_begin(t)
+        # Now, acquire the condvar lock and start a thread that will do a
+        # pack, up to the _sweep call.  Wait for the _mark() call to
+        # complete.
+        now = time.time()
+        while now == time.time():
+            time.sleep(0.1)
+        self._cv.acquire()
+        packthread = self._getPackThread(storage)
+        packthread.start()
+        self._cv.wait()
+        obj2sn = storage.store('\0'*7 + '\2', ZERO, zodb_pickle(obj2), '', t)
+        # Now that the _mark() has finished, complete the transaction, which
+        # links the object to root.
+        root.obj2 = obj2
+        rootsn = storage.getSerial(ZERO)
+        rootsn = storage.store(ZERO, rootsn, zodb_pickle(root), '', t)
+        storage.tpc_vote(t)
+        storage.tpc_finish(t)
+        # And notify the pack thread that it can do the sweep and collect
+        self._cv.notify()
+        self._cv.wait()
+        # We're done with the condvar and the thread
+        self._cv.release()
+        packthread.join()
+        # Now make sure that all the interesting objects are still available
+        rootsn = storage.getSerial(ZERO)
+        obj1sn = storage.getSerial('\0'*7 + '\1')
+        obj2sn = storage.getSerial('\0'*7 + '\2')
+        # obj1 revision was written before the second revision of the root
+        unless(obj1sn < rootsn)
+        unless(rootsn == obj2sn)
+        unless(obj1sn < obj2sn)
+
 
 
 # Subclass which does ugly things to _dopack so we can actually test the race
@@ -362,57 +468,8 @@
 class TestFullClassicPackRaceCondition(RaceConditionBase):
     ConcreteStorage = SynchronizedFullStorage
 
-    def testRaceCondition(self):
-        unless = self.failUnless
-        storage = self._storage
-        db = DB(storage)
-        conn = db.open()
-        root = conn.root()
-        # Start by storing a root reachable object.
-        obj1 = C()
-        obj1.value = 888
-        root.obj1 = obj1
-        txn = get_transaction()
-        txn.note('root -> obj1')
-        txn.commit()
-        # Now, start a transaction, store an object, but don't yet complete
-        # the transaction.  This will ensure that the second object has a tid
-        # < packtime, but it won't be root reachable yet.
-        obj2 = C()
-        t = Transaction()
-        storage.tpc_begin(t)
-        obj2sn = storage.store('\0'*7 + '\2', ZERO, zodb_pickle(obj2), '', t)
-        # Now, acquire the condvar lock and start a thread that will do a
-        # pack, up to the _sweep call.  Wait for the _mark() call to
-        # complete.
-        now = time.time()
-        while now == time.time():
-            time.sleep(0.5)
-        self._cv.acquire()
-        packthread = FullPackThread(storage)
-        packthread.start()
-        self._cv.wait()
-        # Now that the _mark() has finished, complete the transaction, which
-        # links the object to root.
-        root.obj2 = obj2
-        rootsn = storage.getSerial(ZERO)
-        rootsn = storage.store(ZERO, rootsn, zodb_pickle(root), '', t)
-        storage.tpc_vote(t)
-        storage.tpc_finish(t)
-        # And notify the pack thread that it can do the sweep and collect
-        self._cv.notify()
-        self._cv.wait()
-        # We're done with the condvar and the thread
-        self._cv.release()
-        packthread.join()
-        # Now make sure that all the interesting objects are still available
-        rootsn = storage.getSerial(ZERO)
-        obj1sn = storage.getSerial('\0'*7 + '\1')
-        obj2sn = storage.getSerial('\0'*7 + '\2')
-        # obj1 revision was written before the second revision of the root
-        unless(obj1sn < rootsn)
-        unless(rootsn == obj2sn)
-        unless(obj1sn < obj2sn)
+    def _getPackThread(self, storage):
+        return FullPackThread(storage)
 
 
 
@@ -469,57 +526,8 @@
 class TestMinimalClassicPackRaceCondition(RaceConditionBase):
     ConcreteStorage = SynchronizedMinimalStorage
 
-    def testRaceCondition(self):
-        unless = self.failUnless
-        storage = self._storage
-        db = DB(storage)
-        conn = db.open()
-        root = conn.root()
-        # Start by storing a root reachable object.
-        obj1 = C()
-        obj1.value = 888
-        root.obj1 = obj1
-        txn = get_transaction()
-        txn.note('root -> obj1')
-        txn.commit()
-        # Now, start a transaction, store an object, but don't yet complete
-        # the transaction.  This will ensure that the second object has a tid
-        # < packtime, but it won't be root reachable yet.
-        obj2 = C()
-        t = Transaction()
-        storage.tpc_begin(t)
-        obj2sn = storage.store('\0'*7 + '\2', ZERO, zodb_pickle(obj2), '', t)
-        # Now, acquire the condvar lock and start a thread that will do a
-        # pack, up to the _sweep call.  Wait for the _mark() call to
-        # complete.
-        now = time.time()
-        while now == time.time():
-            time.sleep(0.5)
-        self._cv.acquire()
-        packthread = MinimalPackThread(storage)
-        packthread.start()
-        self._cv.wait()
-        # Now that the _mark() has finished, complete the transaction, which
-        # links the object to root.
-        root.obj2 = obj2
-        rootsn = storage.getSerial(ZERO)
-        rootsn = storage.store(ZERO, rootsn, zodb_pickle(root), '', t)
-        storage.tpc_vote(t)
-        storage.tpc_finish(t)
-        # And notify the pack thread that it can do the sweep and collect
-        self._cv.notify()
-        self._cv.wait()
-        # We're done with the condvar and the thread
-        self._cv.release()
-        packthread.join()
-        # Now make sure that all the interesting objects are still available
-        rootsn = storage.getSerial(ZERO)
-        obj1sn = storage.getSerial('\0'*7 + '\1')
-        obj2sn = storage.getSerial('\0'*7 + '\2')
-        # obj1 revision was written before the second revision of the root
-        unless(obj1sn < rootsn)
-        unless(rootsn == obj2sn)
-        unless(obj1sn < obj2sn)
+    def _getPackThread(self, storage):
+        return MinimalPackThread(storage)