예제 #1
0
 def checkPackJustOldRevisions(self):
     eq = self.assertEqual
     raises = self.assertRaises
     loads = self._makeloader()
     # Create a root object.  This can't be an instance of Object,
     # otherwise the pickling machinery will serialize it as a persistent
     # id and not as an object that contains references (persistent ids) to
     # other objects.
     root = Root()
     # Create a persistent object, with some initial state
     obj = self._newobj()
     oid = obj.getoid()
     # Link the root object to the persistent object, in order to keep the
     # persistent object alive.  Store the root object.
     root.obj = obj
     root.value = 0
     revid0 = self._dostoreNP(ZERO, data=dumps(root))
     # Make sure the root can be retrieved
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     # Commit three different revisions of the other object
     obj.value = 1
     revid1 = self._dostoreNP(oid, data=pdumps(obj))
     obj.value = 2
     revid2 = self._dostoreNP(oid, revid=revid1, data=pdumps(obj))
     obj.value = 3
     revid3 = self._dostoreNP(oid, revid=revid2, data=pdumps(obj))
     # Now make sure only the latest revision can be extracted
     raises(KeyError, self._storage.loadSerial, oid, revid1)
     raises(KeyError, self._storage.loadSerial, oid, revid2)
     data = self._storage.loadSerial(oid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
     # Now pack.  The object should stay alive because it's pointed
     # to by the root.
     now = packtime = time.time()
     while packtime <= now:
         packtime = time.time()
     self._storage.pack(packtime, referencesf)
     # Make sure the revisions are gone, but that object zero and revision
     # 3 are still there and correct
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     raises(KeyError, self._storage.loadSerial, oid, revid1)
     raises(KeyError, self._storage.loadSerial, oid, revid2)
     data = self._storage.loadSerial(oid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid, '')
     eq(revid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
예제 #2
0
 def checkPackJustOldRevisions(self):
     eq = self.assertEqual
     raises = self.assertRaises
     loads = self._makeloader()
     # Create a root object.  This can't be an instance of Object,
     # otherwise the pickling machinery will serialize it as a persistent
     # id and not as an object that contains references (persistent ids) to
     # other objects.
     root = Root()
     # Create a persistent object, with some initial state
     obj = self._newobj()
     oid = obj.getoid()
     # Link the root object to the persistent object, in order to keep the
     # persistent object alive.  Store the root object.
     root.obj = obj
     root.value = 0
     revid0 = self._dostoreNP(ZERO, data=dumps(root))
     # Make sure the root can be retrieved
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     # Commit three different revisions of the other object
     obj.value = 1
     revid1 = self._dostoreNP(oid, data=pdumps(obj))
     obj.value = 2
     revid2 = self._dostoreNP(oid, revid=revid1, data=pdumps(obj))
     obj.value = 3
     revid3 = self._dostoreNP(oid, revid=revid2, data=pdumps(obj))
     # Now make sure only the latest revision can be extracted
     raises(KeyError, self._storage.loadSerial, oid, revid1)
     raises(KeyError, self._storage.loadSerial, oid, revid2)
     data = self._storage.loadSerial(oid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
     # Now pack.  The object should stay alive because it's pointed
     # to by the root.
     now = packtime = time.time()
     while packtime <= now:
         packtime = time.time()
     self._storage.pack(packtime, referencesf)
     # Make sure the revisions are gone, but that object zero and revision
     # 3 are still there and correct
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     raises(KeyError, self._storage.loadSerial, oid, revid1)
     raises(KeyError, self._storage.loadSerial, oid, revid2)
     data = self._storage.loadSerial(oid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid, '')
     eq(revid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid)
     eq(pobj.value, 3)
예제 #3
0
    def checkIteratorIsConsistent(self):
        # History free iterators should be consistent
        # until a sync() is done.
        # https://github.com/zodb/relstorage/issues/344
        root = Root()
        self._dostoreNP(ZERO, data=dumps(root))

        storage = self._storage
        it = self._storage.iterator()
        self.assertEqual(1, len(it))
        it.close()

        obj1 = self._newobj()
        oid1 = obj1.getoid()
        storage2 = self._storage.new_instance()
        self._storage = storage2
        self._dostoreNP(oid1, data=dumps(obj1))
        self._storage = storage

        it2 = storage2.iterator()
        self.assertEqual(2, len(it2))
        it2.close()

        it = self._storage.iterator()
        self.assertEqual(1, len(it))
        it.close()

        self._storage.sync()
        it = self._storage.iterator()
        self.assertEqual(2, len(it))
        it.close()

        storage2.close()
예제 #4
0
 def checkPackOnlyOneObject(self):
     eq = self.assertEqual
     raises = self.assertRaises
     loads = self._makeloader()
     # Create a root object.  This can't be an instance of Object,
     # otherwise the pickling machinery will serialize it as a persistent
     # id and not as an object that contains references (persistent ids) to
     # other objects.
     root = Root()
     # Create a persistent object, with some initial state
     obj1 = self._newobj()
     oid1 = obj1.getoid()
     # Create another persistent object, with some initial state.
     obj2 = self._newobj()
     oid2 = obj2.getoid()
     # Link the root object to the persistent objects, in order to keep
     # them alive.  Store the root object.
     root.obj1 = obj1
     root.obj2 = obj2
     root.value = 0
     revid0 = self._dostoreNP(ZERO, data=dumps(root))
     # Make sure the root can be retrieved
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     # Commit three different revisions of the first object
     obj1.value = 1
     revid1 = self._dostoreNP(oid1, data=pdumps(obj1))
     obj1.value = 2
     revid2 = self._dostoreNP(oid1, revid=revid1, data=pdumps(obj1))
     obj1.value = 3
     revid3 = self._dostoreNP(oid1, revid=revid2, data=pdumps(obj1))
     # Now make sure only the latest revision can be extracted
     raises(KeyError, self._storage.loadSerial, oid1, revid1)
     raises(KeyError, self._storage.loadSerial, oid1, revid2)
     data = self._storage.loadSerial(oid1, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     # Now commit a revision of the second object
     obj2.value = 11
     revid4 = self._dostoreNP(oid2, data=pdumps(obj2))
     # And make sure the revision can be extracted
     data = self._storage.loadSerial(oid2, revid4)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid2)
     eq(pobj.value, 11)
     # Now pack just revisions 1 and 2 of object1.  Object1's current
     # revision should stay alive because it's pointed to by the root, as
     # should Object2's current revision.
     now = packtime = time.time()
     while packtime <= now:
         packtime = time.time()
     self._storage.pack(packtime, referencesf)
     # Make sure the revisions are gone, but that object zero, object2, and
     # revision 3 of object1 are still there and correct.
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     raises(KeyError, self._storage.loadSerial, oid1, revid1)
     raises(KeyError, self._storage.loadSerial, oid1, revid2)
     data = self._storage.loadSerial(oid1, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid1, '')
     eq(revid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid2, '')
     eq(revid, revid4)
     eq(loads(data).value, 11)
     data = self._storage.loadSerial(oid2, revid4)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid2)
     eq(pobj.value, 11)
예제 #5
0
 def checkPackOnlyOneObject(self):
     eq = self.assertEqual
     raises = self.assertRaises
     loads = self._makeloader()
     # Create a root object.  This can't be an instance of Object,
     # otherwise the pickling machinery will serialize it as a persistent
     # id and not as an object that contains references (persistent ids) to
     # other objects.
     root = Root()
     # Create a persistent object, with some initial state
     obj1 = self._newobj()
     oid1 = obj1.getoid()
     # Create another persistent object, with some initial state.
     obj2 = self._newobj()
     oid2 = obj2.getoid()
     # Link the root object to the persistent objects, in order to keep
     # them alive.  Store the root object.
     root.obj1 = obj1
     root.obj2 = obj2
     root.value = 0
     revid0 = self._dostoreNP(ZERO, data=dumps(root))
     # Make sure the root can be retrieved
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     # Commit three different revisions of the first object
     obj1.value = 1
     revid1 = self._dostoreNP(oid1, data=pdumps(obj1))
     obj1.value = 2
     revid2 = self._dostoreNP(oid1, revid=revid1, data=pdumps(obj1))
     obj1.value = 3
     revid3 = self._dostoreNP(oid1, revid=revid2, data=pdumps(obj1))
     # Now make sure only the latest revision can be extracted
     raises(KeyError, self._storage.loadSerial, oid1, revid1)
     raises(KeyError, self._storage.loadSerial, oid1, revid2)
     data = self._storage.loadSerial(oid1, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     # Now commit a revision of the second object
     obj2.value = 11
     revid4 = self._dostoreNP(oid2, data=pdumps(obj2))
     # And make sure the revision can be extracted
     data = self._storage.loadSerial(oid2, revid4)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid2)
     eq(pobj.value, 11)
     # Now pack just revisions 1 and 2 of object1.  Object1's current
     # revision should stay alive because it's pointed to by the root, as
     # should Object2's current revision.
     now = packtime = time.time()
     while packtime <= now:
         packtime = time.time()
     self._storage.pack(packtime, referencesf)
     # Make sure the revisions are gone, but that object zero, object2, and
     # revision 3 of object1 are still there and correct.
     data, revid = self._storage.load(ZERO, '')
     eq(revid, revid0)
     eq(loads(data).value, 0)
     raises(KeyError, self._storage.loadSerial, oid1, revid1)
     raises(KeyError, self._storage.loadSerial, oid1, revid2)
     data = self._storage.loadSerial(oid1, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid1, '')
     eq(revid, revid3)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid1)
     eq(pobj.value, 3)
     data, revid = self._storage.load(oid2, '')
     eq(revid, revid4)
     eq(loads(data).value, 11)
     data = self._storage.loadSerial(oid2, revid4)
     pobj = cPickle.loads(data)
     eq(pobj.getoid(), oid2)
     eq(pobj.value, 11)