Merge lp:~chipaca/u1db/autoresolver into lp:u1db

[John Lenton]

Automerging of revisions with the same content.

[Samuele Pedroni (pedronis)]

this needs direct put_doc_if_newer level unit tests

review: Needs Fixing

[lp:~chipaca/u1db/autoresolver]

294. By John Lenton on 2012-05-18

add a unit test to put_doc_if_newer

[John Lenton (chipaca)]

Like this?

[lp:~chipaca/u1db/autoresolver]

295. By John Lenton on 2012-05-18

a bit of C code cleanup

296. By John Lenton on 2012-05-18

checked the vector clock is strictly greater on content-based conflict resolution. Also, got rid of spurious prunes.

[Samuele Pedroni (pedronis)]

review: Approve

=== modified file 'src/u1db.c'
--- src/u1db.c	2012-05-18 15:12:42 +0000
+++ src/u1db.c	2012-05-18 16:40:23 +0000
@@ -726,31 +726,26 @@
                        const char *replica_uid, int replica_gen,
                        const char *replica_trans_id, int *state, int *at_gen)
 {
-    const char *stored_content = NULL, *stored_doc_rev = NULL;
+    const char *stored_content = NULL;
+    const char *stored_doc_rev = NULL;
+    const char *local_replica_uid = NULL;
     int status = U1DB_INVALID_PARAMETER, store = 0;
     int stored_content_len;
-    sqlite3_stmt *statement;
+    sqlite3_stmt *statement = NULL;
+    u1db_vectorclock *stored_vc = NULL, *new_vc = NULL;
 
     if (db == NULL || doc == NULL || state == NULL || doc->doc_rev == NULL) {
         return U1DB_INVALID_PARAMETER;
     }
 
     status = u1db__is_doc_id_valid(doc->doc_id);
-    if (status != U1DB_OK) {
-        return status;
-    }
+    if (status != SQLITE_OK) { goto finish; }
     status = sqlite3_exec(db->sql_handle, "BEGIN", NULL, NULL, NULL);
-    if (status != SQLITE_OK) {
-        return status;
-    }
+    if (status != SQLITE_OK) { goto finish; }
     stored_content = NULL;
     status = lookup_doc(db, doc->doc_id, &stored_doc_rev, &stored_content,
                         &stored_content_len, &statement);
-    if (status != SQLITE_OK) {
-        sqlite3_exec(db->sql_handle, "ROLLBACK", NULL, NULL, NULL);
-        sqlite3_finalize(statement);
-        return status;
-    }
+    if (status != SQLITE_OK) { goto finish; }
     if (stored_doc_rev == NULL) {
         status = U1DB_OK;
         *state = U1DB_INSERTED;
@@ -760,7 +755,6 @@
         *state = U1DB_CONVERGED;
         store = 0;
     } else {
-        u1db_vectorclock *stored_vc = NULL, *new_vc = NULL;
         // TODO: u1db__vectorclock_from_str returns NULL if there is an error
         //       in the vector clock, or if we run out of memory... Probably
         //       shouldn't be U1DB_NOMEM
@@ -772,7 +766,6 @@
         new_vc = u1db__vectorclock_from_str(doc->doc_rev);
         if (new_vc == NULL) {
             status = U1DB_NOMEM;
-            u1db__free_vectorclock(&stored_vc);
             goto finish;
         }
         if (u1db__vectorclock_is_newer(new_vc, stored_vc)) {
@@ -785,6 +778,21 @@
             store = 0;
             status = U1DB_OK;
             *state = U1DB_SUPERSEDED;
+        } else if ((doc->content == NULL && stored_content == NULL)
+                   || (doc->content != NULL && stored_content != NULL
+                       && strcmp(doc->content, stored_content) == 0)) {
+            // The contents have converged by divine intervention!
+            status = u1db__vectorclock_maximize(new_vc, stored_vc);
+            if (status != SQLITE_OK) { goto finish; }
+            status = u1db_get_replica_uid(db, &local_replica_uid);
+            if (status != SQLITE_OK) { goto finish; }
+            status = u1db__vectorclock_increment(new_vc, local_replica_uid);
+            if (status != SQLITE_OK) { goto finish; }
+            free(doc->doc_rev);
+            status = u1db__vectorclock_as_str(new_vc, &doc->doc_rev);
+            if (status != SQLITE_OK) { goto finish; }
+            store = 1;
+            *state = U1DB_SUPERSEDED;
         } else {
             // TODO: Handle the case where the vc strings are not identical,
             //       but they are functionally equivalent.
@@ -801,8 +809,6 @@
                 }
             }
         }
-        u1db__free_vectorclock(&stored_vc);
-        u1db__free_vectorclock(&new_vc);
     }
     if (status == U1DB_OK && store) {
         status = write_doc(db, doc->doc_id, doc->doc_rev,
@@ -823,6 +829,8 @@
     } else {
         sqlite3_exec(db->sql_handle, "ROLLBACK", NULL, NULL, NULL);
     }
+    u1db__free_vectorclock(&stored_vc);
+    u1db__free_vectorclock(&new_vc);
     return status;
 }
 

=== modified file 'u1db/backends/__init__.py'
--- u1db/backends/__init__.py	2012-05-18 10:52:37 +0000
+++ u1db/backends/__init__.py	2012-05-18 16:40:23 +0000
@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with u1db.  If not, see <http://www.gnu.org/licenses/>.
 
-""""""
+"""Abstract classes and common implementations for the backends."""
 
 import re
 import uuid
@@ -110,6 +110,13 @@
             # so we should send it back, and we should not generate a
             # conflict
             state = 'superseded'
+        elif cur_doc.content == doc.content:
+            # the documents have been edited to the same thing at both ends
+            doc_vcr.maximize(cur_vcr)
+            doc_vcr.increment(self._replica_uid)
+            doc.rev = doc_vcr.as_str()
+            self._put_and_update_indexes(cur_doc, doc)
+            state = 'superseded'
         else:
             state = 'conflicted'
             if save_conflict:

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2012-05-18 15:12:42 +0000
+++ u1db/tests/test_backends.py	2012-05-18 16:40:23 +0000
@@ -279,6 +279,17 @@
         self.assertEqual('superseded', state)
         self.assertGetDoc(self.db, doc1.doc_id, doc1_rev2, simple_doc, False)
 
+    def test_put_doc_if_newer_automerge(self):
+        doc1 = self.db.create_doc(simple_doc)
+        rev = doc1.rev
+        doc = self.make_document(doc1.doc_id, "whatever:1", doc1.content)
+        state, _ = self.db._put_doc_if_newer(doc, save_conflict=False)
+        self.assertEqual('superseded', state)
+        doc2 = self.db.get_doc(doc1.doc_id)
+        v2 = vectorclock.VectorClockRev(doc2.rev)
+        self.assertTrue(v2.is_newer(vectorclock.VectorClockRev("whatever:1")))
+        self.assertTrue(v2.is_newer(vectorclock.VectorClockRev(rev)))
+
     def test_put_doc_if_newer_already_converged(self):
         orig_doc = '{"new": "doc"}'
         doc1 = self.db.create_doc(orig_doc)
@@ -314,7 +325,7 @@
         # A conflict that isn't saved still records the sync gen, because we
         # don't need to see it again
         doc2 = self.make_document(doc1.doc_id, doc1.rev + '|fourth:1',
-                                  nested_doc)
+                                  '{}')
         self.assertEqual('conflicted',
             self.db._put_doc_if_newer(doc2, save_conflict=False,
                                       replica_uid='other', replica_gen=4,
@@ -591,7 +602,7 @@
                                   replica_trans_id='T-id2')
         # Conflict vs the current update
         doc2 = self.make_document(doc1.doc_id, doc1.rev + '|third:3',
-                                  nested_doc)
+                                  '{}')
         self.assertEqual('conflicted',
             self.db._put_doc_if_newer(doc2, save_conflict=True,
                 replica_uid='other', replica_gen=3,

=== modified file 'u1db/tests/test_sync.py'
--- u1db/tests/test_sync.py	2012-05-17 17:28:19 +0000
+++ u1db/tests/test_sync.py	2012-05-18 16:40:23 +0000
@@ -23,6 +23,7 @@
     errors,
     sync,
     tests,
+    vectorclock,
     )
 from u1db.backends import (
     inmemory,
@@ -397,6 +398,7 @@
 class DatabaseSyncTests(tests.DatabaseBaseTests):
 
     scenarios = sync_scenarios
+    sync = None                 # set by scenarios
 
     def setUp(self):
         super(DatabaseSyncTests, self).setUp()
@@ -417,6 +419,19 @@
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [], 'last_gen': 0}})
 
+    def test_sync_autoresolves(self):
+        doc1 = self.db1.create_doc(simple_doc, doc_id='doc')
+        rev1 = doc1.rev
+        doc2 = self.db2.create_doc(simple_doc, doc_id='doc')
+        rev2 = doc2.rev
+        self.sync(self.db1, self.db2)
+        doc = self.db1.get_doc('doc')
+        self.assertFalse(doc.has_conflicts)
+        self.assertEqual(doc.rev, self.db2.get_doc('doc').rev)
+        v = vectorclock.VectorClockRev(doc.rev)
+        self.assertTrue(v.is_newer(vectorclock.VectorClockRev(rev1)))
+        self.assertTrue(v.is_newer(vectorclock.VectorClockRev(rev2)))
+
     def test_sync_puts_changes(self):
         doc = self.db1.create_doc(simple_doc)
         self.assertEqual(1, self.sync(self.db1, self.db2))