Merged conflict-resolution bug fixes from trunk:

r77078 | gary | 2007-06-25 16:39:45 -0400 (Mon, 25 Jun 2007) | 1 line
r77010 | gary | 2007-06-24 13:19:18 -0400 (Sun, 24 Jun 2007) | 2 lines
r76977 | gary | 2007-06-23 06:57:51 -0400 (Sat, 23 Jun 2007) | 1 line
r76953 | gary | 2007-06-23 00:20:55 -0400 (Sat, 23 Jun 2007) | 1 line

Document conflict resolution. bugfix the situation in which comparing
persistent objects (for instance, as members in BTree set or keys of
BTree) might cause data inconsistency during conflict resolution.
support multidatabase references in conflict resolution.  make it
possible to examine oid and (in some situations) database name of
persistent object references so that I can add some code to
zope.app.keyreference to support these objects (so BTree conflict
resolution can happen at all when keyreferences are used).

NEWS.txt

@@ -14,6 +14,17 @@ General
   apply the garbage collections on those connections in the pool that are
   closed. (This fixed issue 113932.)
 
+- (3.8.0b3) Document conflict resolution (see ZODB/ConflictResolution.txt).
+
+- (3.8.0b3) Bugfix the situation in which comparing persistent objects (for
+  instance, as members in BTree set or keys of BTree) might cause data
+  inconsistency during conflict resolution.
+
+- (3.8.0b3) Support multidatabase references in conflict resolution.
+
+- (3.8.0b3) Make it possible to examine oid and (in some situations) database
+  name of persistent object references during conflict resolution.
+
 ZEO
 ---
 

src/ZODB/ConflictResolution.py

@@ -17,6 +17,8 @@ from cStringIO import StringIO
 from cPickle import Unpickler, Pickler
 from pickle import PicklingError
 
+import zope.interface
+
 from ZODB.POSException import ConflictError
 from ZODB.loglevels import BLATHER
 
@@ -58,7 +60,87 @@ def state(self, oid, serial, prfactory, p=''):
     unpickler.load() # skip the class tuple
     return unpickler.load()
 
-class PersistentReference:
+class IPersistentReference(zope.interface.Interface):
+    '''public contract for references to persistent objects from an object
+    with conflicts.'''
+
+    oid = zope.interface.Attribute(
+        'The oid of the persistent object that this reference represents')
+
+    database_name = zope.interface.Attribute(
+        '''The name of the database of the reference, *if* different.
+
+        If not different, None.''')
+
+    klass = zope.interface.Attribute(
+        '''class meta data.  Presence is not reliable.''')
+
+    weak = zope.interface.Attribute(
+        '''bool: whether this reference is weak''')
+
+    def __cmp__(other):
+        '''if other is equivalent reference, return 0; else raise ValueError.
+        
+        Equivalent in this case means that oid and database_name are the same.
+
+        If either is a weak reference, we only support `is` equivalence, and
+        otherwise raise a ValueError even if the datbase_names and oids are
+        the same, rather than guess at the correct semantics.
+        
+        It is impossible to sort reliably, since the actual persistent
+        class may have its own comparison, and we have no idea what it is.
+        We assert that it is reasonably safe to assume that an object is
+        equivalent to itself, but that's as much as we can say.
+
+        We don't compare on 'is other', despite the
+        PersistentReferenceFactory.data cache, because it is possible to
+        have two references to the same object that are spelled with different
+        data (for instance, one with a class and one without).'''
+
+class PersistentReference(object):
+
+    zope.interface.implements(IPersistentReference)
+
+    weak = False
+    oid = database_name = klass = None
+
+    def __init__(self, data):
+        self.data = data
+        # see serialize.py, ObjectReader._persistent_load
+        if isinstance(data, tuple):
+            self.oid, self.klass = data
+        elif isinstance(data, str):
+            self.oid = data
+        else: # a list
+            reference_type = data[0]
+            # 'm' = multi_persistent: (database_name, oid, klass)
+            # 'n' = multi_oid: (database_name, oid)
+            # 'w' = persistent weakref: (oid)
+            # else it is a weakref: reference_type
+            if reference_type == 'm':
+                self.database_name, self.oid, self.klass = data[1]
+            elif reference_type == 'n':
+                self.database_name, self.oid = data[1]
+            elif reference_type == 'w':
+                self.oid, = data[1]
+                self.weak = True
+            else:
+                assert len(data) == 1, 'unknown reference format'
+                self.oid = data[0]
+                self.weak = True
+
+    def __cmp__(self, other):
+        if self is other or (
+            isinstance(other, PersistentReference) and 
+            self.oid == other.oid and
+            self.database_name == other.database_name and
+            not self.weak and
+            not other.weak):
+            return 0
+        else:
+            raise ValueError(
+                "can't reliably compare against different "
+                "PersistentReferences")
 
     def __repr__(self):
         return "PR(%s %s)" % (id(self), self.data)
@@ -70,15 +152,15 @@ class PersistentReferenceFactory:
 
     data = None
 
-    def persistent_load(self, oid):
+    def persistent_load(self, ref):
         if self.data is None:
             self.data = {}
-
-        r = self.data.get(oid, None)
+        key = tuple(ref) # lists are not hashable; formats are different enough
+        # even after eliminating list/tuple distinction
+        r = self.data.get(key, None)
         if r is None:
-            r = PersistentReference()
-            r.data = oid
-            self.data[oid] = r
+            r = PersistentReference(ref)
+            self.data[key] = r
 
         return r
 

src/ZODB/tests/testconflictresolution.py

+##############################################################################
+#
+# Copyright (c) 2007 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""
+$Id$
+"""
+import unittest
+from zope.testing import doctest, module
+
+def setUp(test):
+    module.setUp(test, 'ConflictResolution_txt')
+
+def tearDown(test):
+    test.globs['db'].close()
+    test.globs['db1'].close()
+    test.globs['db2'].close()
+    module.tearDown(test)
+
+def test_suite():
+    return unittest.TestSuite((
+        doctest.DocFileSuite('../ConflictResolution.txt',
+                             setUp=setUp,
+                             tearDown=tearDown,
+                             optionflags=doctest.INTERPRET_FOOTNOTES,
+                             ),
+        ))
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='test_suite')
+

src/ZODB/tests/util.py

@@ -25,11 +25,61 @@ import time
 import persistent
 import transaction
 from ZODB.MappingStorage import MappingStorage
+from ZODB.ConflictResolution import ConflictResolvingStorage
 from ZODB.DB import DB as _DB
+from ZODB import POSException
 
 def DB(name='Test', **dbargs):
     return _DB(MappingStorage(name), **dbargs)
 
+class ConflictResolvingMappingStorage(
+    MappingStorage, ConflictResolvingStorage):
+
+    def __init__(self, name='ConflictResolvingMappingStorage'):
+        MappingStorage.__init__(self, name)
+        self._old = {}
+
+    def loadSerial(self, oid, serial):
+        self._lock_acquire()
+        try:
+            old_info = self._old[oid]
+            try:
+                return old_info[serial]
+            except KeyError:
+                raise POSException.POSKeyError(oid)
+        finally:
+            self._lock_release()
+
+    def store(self, oid, serial, data, version, transaction):
+        if transaction is not self._transaction:
+            raise POSException.StorageTransactionError(self, transaction)
+
+        if version:
+            raise POSException.Unsupported("Versions aren't supported")
+
+        self._lock_acquire()
+        try:
+            if oid in self._index:
+                oserial = self._index[oid][:8]
+                if serial != oserial:
+                    rdata = self.tryToResolveConflict(
+                        oid, oserial, serial, data)
+                    if rdata is None:
+                        raise POSException.ConflictError(
+                            oid=oid, serials=(oserial, serial), data=data)
+                    else:
+                        data = rdata
+            self._tindex[oid] = self._tid + data
+        finally:
+            self._lock_release()
+        return self._tid
+
+    def _finish(self, tid, user, desc, ext):
+        self._index.update(self._tindex)
+        self._ltid = self._tid
+        for oid, record in self._tindex.items():
+            self._old.setdefault(oid, {})[self._tid] = record[8:]
+
 def commit():
     transaction.commit()