Merge lp:~thisfred/u1db/unconfuse_sync_info into lp:u1db

[Eric Casteleijn]

renamed _get_sync_gen_info and _set_sync_info to _get_replica_gen_and_trans_id and _set_replica_gen_and_trans_id respectively, to not confuse them with the get_sync_info method.

renamed _get_sync_gen_info and _set_sync_info to _get_replica_gen_and_trans_id and _set_replica_gen_and_trans_id respectively, to not confuse them with the get_sync_info method.

[Samuele Pedroni (pedronis)]

141 - generation the other replica was at. See also _get_sync_gen_info.
142 + generation the other replica was at. See also
143 + _replica_gen_and_trans_id.

that should be _get_replica_gen_and_trans_id

review: Approve

[lp:~thisfred/u1db/unconfuse_sync_info]

339. By Eric Casteleijn on 2012-07-03

typo in docstring

=== modified file 'include/u1db/u1db_internal.h'
--- include/u1db/u1db_internal.h	2012-06-22 00:03:55 +0000
+++ include/u1db/u1db_internal.h	2012-07-03 14:37:18 +0000
@@ -300,15 +300,15 @@
  * @param trans_id    (OUT) The transaction id associated with the generation.
  *                    Callers must free the data.
  */
-int u1db__get_sync_gen_info(u1database *db, const char *replica_uid,
-                            int *generation, char **trans_id);
+int u1db__get_replica_gen_and_trans_id(u1database *db, const char *replica_uid,
+                                       int *generation, char **trans_id);
 
 /**
  * Set the known sync generation for another replica.
  *
  */
-int u1db__set_sync_info(u1database *db, const char *replica_uid,
-                        int generation, const char *trans_id);
+int u1db__set_replica_gen_and_trans_id(u1database *db, const char *replica_uid,
+                                       int generation, const char *trans_id);
 
 /**
  * Internal sync api, get the stored information about another machine.

=== modified file 'src/u1db.c'
--- src/u1db.c	2012-06-22 00:03:55 +0000
+++ src/u1db.c	2012-07-03 14:37:18 +0000
@@ -764,7 +764,7 @@
     int status = U1DB_OK;
 
     *state = U1DB_OK;
-    status = u1db__get_sync_gen_info(
+    status = u1db__get_replica_gen_and_trans_id(
         db, replica_uid, &old_generation, &old_trans_id);
     if (status != U1DB_OK)
         goto finish;
@@ -908,7 +908,7 @@
                            (stored_doc_rev != NULL));
     }
     if (status == U1DB_OK && replica_uid != NULL) {
-        status = u1db__set_sync_info(
+        status = u1db__set_replica_gen_and_trans_id(
             db, replica_uid, replica_gen, replica_trans_id);
     }
     if (status == U1DB_OK && at_gen != NULL) {
@@ -1613,8 +1613,8 @@
 
 
 int
-u1db__get_sync_gen_info(u1database *db, const char *replica_uid,
-                        int *generation, char **trans_id)
+u1db__get_replica_gen_and_trans_id(u1database *db, const char *replica_uid,
+                                   int *generation, char **trans_id)
 {
     int status;
     sqlite3_stmt *statement;
@@ -1664,8 +1664,8 @@
 
 
 int
-u1db__set_sync_info(u1database *db, const char *replica_uid,
-                    int generation, const char *trans_id)
+u1db__set_replica_gen_and_trans_id(u1database *db, const char *replica_uid,
+                                   int generation, const char *trans_id)
 {
     int status;
     sqlite3_stmt *statement;

=== modified file 'src/u1db_sync_target.c'
--- src/u1db_sync_target.c	2012-06-18 18:21:38 +0000
+++ src/u1db_sync_target.c	2012-07-03 14:37:18 +0000
@@ -125,7 +125,7 @@
     db = (u1database *)st->implementation;
     status = u1db_get_replica_uid(db, st_replica_uid);
     if (status != U1DB_OK) { goto finish; }
-    status = u1db__get_sync_gen_info(
+    status = u1db__get_replica_gen_and_trans_id(
         db, source_replica_uid, source_gen, source_trans_id);
     if (status != U1DB_OK) { goto finish; }
     status = u1db__get_generation(db, st_gen);
@@ -148,7 +148,8 @@
         if (status != U1DB_OK) { goto finish; }
     }
     db = (u1database *)st->implementation;
-    status = u1db__set_sync_info(db, source_replica_uid, source_gen, trans_id);
+    status = u1db__set_replica_gen_and_trans_id(
+        db, source_replica_uid, source_gen, trans_id);
 finish:
     return status;
 }
@@ -617,7 +618,7 @@
     status = u1db_validate_gen_and_trans_id(
             db, local_gen_known_by_target, local_trans_id_known_by_target);
     if (status != U1DB_OK) { goto finish; }
-    status = u1db__get_sync_gen_info(db, target_uid,
+    status = u1db__get_replica_gen_and_trans_id(db, target_uid,
         &target_gen_known_by_local, &target_trans_id_known_by_local);
     if (status != U1DB_OK) { goto finish; }
     local_target_trans_id = target_trans_id_known_by_local;
@@ -655,7 +656,7 @@
     if (status != U1DB_OK) { goto finish; }
     // Now we successfully sent and received docs, make sure we record the
     // current remote generation
-    status = u1db__set_sync_info(
+    status = u1db__set_replica_gen_and_trans_id(
         db, target_uid, target_gen_known_by_local,
         target_trans_id_known_by_local);
     if (status != U1DB_OK) { goto finish; }

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2012-06-27 18:56:17 +0000
+++ u1db/__init__.py	2012-07-03 14:37:18 +0000
@@ -275,8 +275,9 @@
         from u1db.remote.http_target import HTTPSyncTarget
         return Synchronizer(self, HTTPSyncTarget(url)).sync()
 
-    def _get_sync_gen_info(self, other_replica_uid):
-        """Return the last known information about the other db replica.
+    def _get_replica_gen_and_trans_id(self, other_replica_uid):
+        """Return the last known generation and transaction id for the other db
+        replica.
 
         When you do a synchronization with another replica, the Database keeps
         track of what generation the other database replica was at, and what
@@ -289,21 +290,23 @@
             encountered during synchronization. If we've never synchronized
             with the replica, this is (0, '').
         """
-        raise NotImplementedError(self._get_sync_gen_info)
+        raise NotImplementedError(self._replica_gen_and_trans_id)
 
-    def _set_sync_info(self, other_replica_uid, other_generation,
-                       other_transaction_id):
-        """Set the last-known generation for the other database replica.
+    def _set_replica_gen_and_trans_id(self, other_replica_uid,
+                                      other_generation, other_transaction_id):
+        """Set the last-known generation and transaction id for the other
+        database replica.
 
         We have just performed some synchronization, and we want to track what
-        generation the other replica was at. See also _get_sync_gen_info.
+        generation the other replica was at. See also
+        _get_replica_gen_and_trans_id.
         :param other_replica_uid: The U1DB identifier for the other replica.
         :param other_generation: The generation number for the other replica.
         :param other_transaction_id: The transaction id associated with the
             generation.
         :return: None
         """
-        raise NotImplementedError(self._set_sync_info)
+        raise NotImplementedError(self._set_replica_gen_and_trans_id)
 
     def _put_doc_if_newer(self, doc, save_conflict, replica_uid=None,
                           replica_gen=None, replica_trans_id=None):

=== modified file 'u1db/backends/__init__.py'
--- u1db/backends/__init__.py	2012-06-19 19:36:50 +0000
+++ u1db/backends/__init__.py	2012-07-03 14:37:18 +0000
@@ -119,8 +119,9 @@
         replica, *or* it must be the same and the transaction_id must be the
         same as well.
         """
-        old_generation, old_transaction_id = self._get_sync_gen_info(
-            other_replica_uid)
+        (old_generation,
+         old_transaction_id) = self._get_replica_gen_and_trans_id(
+             other_replica_uid)
         if other_generation < old_generation:
             if cur_vcr.is_newer(other_vcr):
                 return 'superseded'
@@ -174,7 +175,8 @@
             if save_conflict:
                 self._force_doc_sync_conflict(doc)
         if replica_uid is not None and replica_gen is not None:
-            self._do_set_sync_info(replica_uid, replica_gen, replica_trans_id)
+            self._do_set_replica_gen_and_trans_id(
+                replica_uid, replica_gen, replica_trans_id)
         return state, self._get_generation()
 
     def _ensure_maximal_rev(self, cur_rev, extra_revs):

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2012-06-19 19:36:50 +0000
+++ u1db/backends/inmemory.py	2012-07-03 14:37:18 +0000
@@ -54,16 +54,17 @@
         # may be closing it, while another wants to inspect the results.
         pass
 
-    def _get_sync_gen_info(self, other_replica_uid):
+    def _get_replica_gen_and_trans_id(self, other_replica_uid):
         return self._other_generations.get(other_replica_uid, (0, ''))
 
-    def _set_sync_info(self, other_replica_uid, other_generation,
-                       other_transaction_id):
-        self._do_set_sync_info(other_replica_uid, other_generation,
-                               other_transaction_id)
+    def _set_replica_gen_and_trans_id(self, other_replica_uid,
+                                      other_generation, other_transaction_id):
+        self._do_set_replica_gen_and_trans_id(
+            other_replica_uid, other_generation, other_transaction_id)
 
-    def _do_set_sync_info(self, other_replica_uid, other_generation,
-                          other_transaction_id):
+    def _do_set_replica_gen_and_trans_id(self, other_replica_uid,
+                                         other_generation,
+                                         other_transaction_id):
         # TODO: to handle race conditions, we may want to check if the current
         #       value is greater than this new value.
         self._other_generations[other_replica_uid] = (other_generation,
@@ -443,7 +444,8 @@
 class InMemorySyncTarget(CommonSyncTarget):
 
     def get_sync_info(self, source_replica_uid):
-        source_gen, trans_id = self._db._get_sync_gen_info(source_replica_uid)
+        source_gen, trans_id = self._db._get_replica_gen_and_trans_id(
+            source_replica_uid)
         return (self._db._replica_uid, len(self._db._transaction_log),
                 source_gen, trans_id)
 
@@ -451,5 +453,6 @@
                          source_transaction_id):
         if self._trace_hook:
             self._trace_hook('record_sync_info')
-        self._db._set_sync_info(source_replica_uid, source_replica_generation,
-                                source_transaction_id)
+        self._db._set_replica_gen_and_trans_id(
+            source_replica_uid, source_replica_generation,
+            source_transaction_id)

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2012-06-19 19:36:50 +0000
+++ u1db/backends/sqlite_backend.py	2012-07-03 14:37:18 +0000
@@ -460,7 +460,7 @@
             this_doc.has_conflicts = True
             return [this_doc] + conflict_docs
 
-    def _get_sync_gen_info(self, other_replica_uid):
+    def _get_replica_gen_and_trans_id(self, other_replica_uid):
         c = self._db_handle.cursor()
         c.execute("SELECT known_generation, known_transaction_id FROM sync_log"
                   " WHERE replica_uid = ?",
@@ -474,14 +474,15 @@
             trans_id = val[1]
         return other_gen, trans_id
 
-    def _set_sync_info(self, other_replica_uid, other_generation,
-                       other_transaction_id):
+    def _set_replica_gen_and_trans_id(self, other_replica_uid,
+                                      other_generation, other_transaction_id):
         with self._db_handle:
-            self._do_set_sync_info(other_replica_uid, other_generation,
-                                   other_transaction_id)
+            self._do_set_replica_gen_and_trans_id(
+                other_replica_uid, other_generation, other_transaction_id)
 
-    def _do_set_sync_info(self, other_replica_uid, other_generation,
-                          other_transaction_id):
+    def _do_set_replica_gen_and_trans_id(self, other_replica_uid,
+                                         other_generation,
+                                         other_transaction_id):
             c = self._db_handle.cursor()
             c.execute("INSERT OR REPLACE INTO sync_log VALUES (?, ?, ?)",
                       (other_replica_uid, other_generation,
@@ -787,7 +788,8 @@
 class SQLiteSyncTarget(CommonSyncTarget):
 
     def get_sync_info(self, source_replica_uid):
-        source_gen, trans_id = self._db._get_sync_gen_info(source_replica_uid)
+        source_gen, trans_id = self._db._get_replica_gen_and_trans_id(
+            source_replica_uid)
         my_gen = self._db._get_generation()
         return self._db._replica_uid, my_gen, source_gen, trans_id
 
@@ -795,8 +797,9 @@
                          source_replica_transaction_id):
         if self._trace_hook:
             self._trace_hook('record_sync_info')
-        self._db._set_sync_info(source_replica_uid, source_replica_generation,
-                                source_replica_transaction_id)
+        self._db._set_replica_gen_and_trans_id(
+            source_replica_uid, source_replica_generation,
+            source_replica_transaction_id)
 
 
 class SQLitePartialExpandDatabase(SQLiteDatabase):

=== modified file 'u1db/sync.py'
--- u1db/sync.py	2012-06-15 20:56:26 +0000
+++ u1db/sync.py	2012-07-03 14:37:18 +0000
@@ -104,7 +104,7 @@
 
         # this source last-seen database generation for the target
         (target_last_known_gen,
-         target_trans_id) = self.source._get_sync_gen_info(
+         target_trans_id) = self.source._get_replica_gen_and_trans_id(
              self.target_replica_uid)
         if not changes and target_last_known_gen == target_gen:
             return my_gen
@@ -123,7 +123,7 @@
                         self.source._replica_uid, target_last_known_gen,
                         return_doc_cb=self._insert_doc_from_target)
         # record target synced-up-to generation including applying what we sent
-        self.source._set_sync_info(
+        self.source._set_replica_gen_and_trans_id(
             self.target_replica_uid, new_gen, new_trans_id)
 
         # if gapless record current reached generation with target

=== modified file 'u1db/tests/c_backend_wrapper.pyx'
--- u1db/tests/c_backend_wrapper.pyx	2012-06-27 18:56:17 +0000
+++ u1db/tests/c_backend_wrapper.pyx	2012-07-03 14:37:18 +0000
@@ -220,10 +220,10 @@
                                 int has_conflicts, u1db_document **result)
     int u1db__generate_hex_uuid(char *)
 
-    int u1db__get_sync_gen_info(u1database *db, char *replica_uid,
-                                int *generation, char **trans_id)
-    int u1db__set_sync_info(u1database *db, char *replica_uid, int generation,
-                            char *trans_id)
+    int u1db__get_replica_gen_and_trans_id(u1database *db, char *replica_uid,
+                                           int *generation, char **trans_id)
+    int u1db__set_replica_gen_and_trans_id(u1database *db, char *replica_uid,
+                                           int generation, char *trans_id)
     int u1db__sync_get_machine_info(u1database *db, char *other_replica_uid,
                                     int *other_db_rev, char **my_replica_uid,
                                     int *my_db_rev)
@@ -1092,22 +1092,23 @@
             "validate_gen_and_trans_id",
             u1db_validate_gen_and_trans_id(self._db, generation, trans_id))
 
-    def _get_sync_gen_info(self, replica_uid):
+    def _get_replica_gen_and_trans_id(self, replica_uid):
         cdef int generation, status
         cdef char *trans_id = NULL
 
-        status = u1db__get_sync_gen_info(self._db, replica_uid, &generation,
-                                         &trans_id)
-        handle_status("_get_sync_gen_info", status)
+        status = u1db__get_replica_gen_and_trans_id(
+            self._db, replica_uid, &generation, &trans_id)
+        handle_status("_get_replica_gen_and_trans_id", status)
         raw_trans_id = None
         if trans_id != NULL:
             raw_trans_id = trans_id
             free(trans_id)
         return generation, raw_trans_id
 
-    def _set_sync_info(self, replica_uid, generation, trans_id):
-        handle_status("_set_sync_info",
-            u1db__set_sync_info(self._db, replica_uid, generation, trans_id))
+    def _set_replica_gen_and_trans_id(self, replica_uid, generation, trans_id):
+        handle_status("_set_replica_gen_and_trans_id",
+            u1db__set_replica_gen_and_trans_id(
+                self._db, replica_uid, generation, trans_id))
 
     def _sync_exchange(self, docs_info, from_replica_uid, from_machine_rev,
                        last_known_rev):

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2012-06-29 16:18:14 +0000
+++ u1db/tests/test_backends.py	2012-07-03 14:37:18 +0000
@@ -393,7 +393,7 @@
         self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
 
     def test_put_doc_if_newer_newer_generation(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         doc = self.make_document('doc_id', 'other:2', simple_doc)
         state, _ = self.db._put_doc_if_newer(
             doc, save_conflict=False, replica_uid='other', replica_gen=2,
@@ -401,7 +401,7 @@
         self.assertEqual('inserted', state)
 
     def test_put_doc_if_newer_same_generation_same_txid(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         doc = self.make_document('doc_id', 'other:2', simple_doc)
         state, _ = self.db._put_doc_if_newer(
             doc, save_conflict=False, replica_uid='other', replica_gen=1,
@@ -409,7 +409,7 @@
         self.assertEqual('superseded', state)
 
     def test_put_doc_if_newer_wrong_transaction_id(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         doc = self.make_document('doc_id', 'other:1', simple_doc)
         self.assertRaises(
             errors.InvalidTransactionId,
@@ -422,7 +422,7 @@
         doc_rev1 = doc.rev
         doc.set_json(simple_doc)
         self.db.put_doc(doc)
-        self.db._set_sync_info('other', 5, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 5, 'T-sid')
         older_doc = self.make_document(doc.doc_id, doc_rev1, simple_doc)
         state, _ = self.db._put_doc_if_newer(
             older_doc, save_conflict=False, replica_uid='other', replica_gen=3,
@@ -430,7 +430,7 @@
         self.assertEqual('superseded', state)
 
     def test_put_doc_if_newer_old_generation_newer_doc(self):
-        self.db._set_sync_info('other', 5, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 5, 'T-sid')
         doc = self.make_document('doc_id', 'other:1', simple_doc)
         self.assertRaises(
             errors.InvalidGeneration,
@@ -457,7 +457,7 @@
             self.db.validate_gen_and_trans_id, gen + 1, trans_id)
 
     def test_validate_source_gen_and_trans_id_same(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         v1 = vectorclock.VectorClockRev('other:1|self:1')
         v2 = vectorclock.VectorClockRev('other:1|self:1')
         self.assertEqual(
@@ -465,7 +465,7 @@
             self.db._validate_source('other', 1, 'T-sid', v1, v2))
 
     def test_validate_source_gen_newer(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         v1 = vectorclock.VectorClockRev('other:1|self:1')
         v2 = vectorclock.VectorClockRev('other:2|self:2')
         self.assertEqual(
@@ -473,7 +473,7 @@
             self.db._validate_source('other', 2, 'T-whatevs', v1, v2))
 
     def test_validate_source_wrong_txid(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         v1 = vectorclock.VectorClockRev('other:1|self:1')
         v2 = vectorclock.VectorClockRev('other:2|self:2')
         self.assertRaises(
@@ -481,8 +481,8 @@
             self.db._validate_source, 'other', 1, 'T-sad', v1, v2)
 
     def test_validate_source_gen_older_and_vcr_older(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
-        self.db._set_sync_info('other', 2, 'T-sod')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 2, 'T-sod')
         v1 = vectorclock.VectorClockRev('other:1|self:1')
         v2 = vectorclock.VectorClockRev('other:2|self:2')
         self.assertEqual(
@@ -490,8 +490,8 @@
             self.db._validate_source('other', 1, 'T-sid', v2, v1))
 
     def test_validate_source_gen_older_vcr_newer(self):
-        self.db._set_sync_info('other', 1, 'T-sid')
-        self.db._set_sync_info('other', 2, 'T-sod')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 2, 'T-sod')
         v1 = vectorclock.VectorClockRev('other:1|self:1')
         v2 = vectorclock.VectorClockRev('other:2|self:2')
         self.assertRaises(
@@ -500,21 +500,23 @@
 
     def test_put_doc_if_newer_replica_uid(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db._set_sync_info('other', 1, 'T-sid')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-sid')
         doc2 = self.make_document(doc1.doc_id, doc1.rev + '|other:1',
                                   nested_doc)
         self.assertEqual('inserted',
             self.db._put_doc_if_newer(doc2, save_conflict=False,
                                       replica_uid='other', replica_gen=2,
                                       replica_trans_id='T-id2')[0])
-        self.assertEqual((2, 'T-id2'), self.db._get_sync_gen_info('other'))
+        self.assertEqual((2, 'T-id2'), self.db._get_replica_gen_and_trans_id(
+            'other'))
         # Compare to the old rev, should be superseded
         doc2 = self.make_document(doc1.doc_id, doc1.rev, nested_doc)
         self.assertEqual('superseded',
             self.db._put_doc_if_newer(doc2, save_conflict=False,
                                       replica_uid='other', replica_gen=3,
                                       replica_trans_id='T-id3')[0])
-        self.assertEqual((3, 'T-id3'), self.db._get_sync_gen_info('other'))
+        self.assertEqual(
+            (3, 'T-id3'), self.db._get_replica_gen_and_trans_id('other'))
         # 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',
@@ -523,13 +525,16 @@
             self.db._put_doc_if_newer(doc2, save_conflict=False,
                                       replica_uid='other', replica_gen=4,
                                       replica_trans_id='T-id4')[0])
-        self.assertEqual((4, 'T-id4'), self.db._get_sync_gen_info('other'))
+        self.assertEqual(
+            (4, 'T-id4'), self.db._get_replica_gen_and_trans_id('other'))
 
-    def test__get_sync_gen_info(self):
-        self.assertEqual((0, ''), self.db._get_sync_gen_info('other-db'))
-        self.db._set_sync_info('other-db', 2, 'T-transaction')
-        self.assertEqual((2, 'T-transaction'),
-                         self.db._get_sync_gen_info('other-db'))
+    def test__get_replica_gen_and_trans_id(self):
+        self.assertEqual(
+            (0, ''), self.db._get_replica_gen_and_trans_id('other-db'))
+        self.db._set_replica_gen_and_trans_id('other-db', 2, 'T-transaction')
+        self.assertEqual(
+            (2, 'T-transaction'),
+            self.db._get_replica_gen_and_trans_id('other-db'))
 
     def test_put_updates_transaction_log(self):
         doc = self.db.create_doc(simple_doc)
@@ -789,7 +794,7 @@
 
     def test_put_doc_if_newer_replica_uid(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db._set_sync_info('other', 1, 'T-id')
+        self.db._set_replica_gen_and_trans_id('other', 1, 'T-id')
         doc2 = self.make_document(doc1.doc_id, doc1.rev + '|other:1',
                                   nested_doc)
         self.db._put_doc_if_newer(doc2, save_conflict=True,
@@ -802,7 +807,8 @@
             self.db._put_doc_if_newer(doc2, save_conflict=True,
                 replica_uid='other', replica_gen=3,
                 replica_trans_id='T-id3')[0])
-        self.assertEqual((3, 'T-id3'), self.db._get_sync_gen_info('other'))
+        self.assertEqual(
+            (3, 'T-id3'), self.db._get_replica_gen_and_trans_id('other'))
 
     def test_put_doc_if_newer_autoresolve_2(self):
         # this is an ordering variant of _3, but that already works

=== modified file 'u1db/tests/test_c_backend.py'
--- u1db/tests/test_c_backend.py	2012-06-29 17:00:49 +0000
+++ u1db/tests/test_c_backend.py	2012-07-03 14:37:18 +0000
@@ -298,8 +298,8 @@
         exc.insert_doc_from_source(doc, 10, 'T-sid')
         self.assertGetDoc(self.db, 'doc-id', 'replica:1', tests.simple_doc,
                           False)
-        self.assertEqual((10, 'T-sid'),
-                         self.db._get_sync_gen_info('source-uid'))
+        self.assertEqual(
+            (10, 'T-sid'), self.db._get_replica_gen_and_trans_id('source-uid'))
         self.assertEqual(['doc-id'], exc.get_seen_ids())
 
     def test_sync_exchange_conflicted_doc(self):

=== modified file 'u1db/tests/test_http_app.py'
--- u1db/tests/test_http_app.py	2012-06-14 23:28:58 +0000
+++ u1db/tests/test_http_app.py	2012-07-03 14:37:18 +0000
@@ -691,7 +691,7 @@
                          simplejson.loads(resp.body))
 
     def test_get_sync_info(self):
-        self.db0._set_sync_info('other-id', 1, 'T-transid')
+        self.db0._set_replica_gen_and_trans_id('other-id', 1, 'T-transid')
         resp = self.app.get('/db0/sync-from/other-id')
         self.assertEqual(200, resp.status)
         self.assertEqual('application/json', resp.header('content-type'))
@@ -709,8 +709,9 @@
         self.assertEqual(200, resp.status)
         self.assertEqual('application/json', resp.header('content-type'))
         self.assertEqual({'ok': True}, simplejson.loads(resp.body))
-        self.assertEqual((2, 'T-transid'),
-                         self.db0._get_sync_gen_info('other-id'))
+        self.assertEqual(
+            (2, 'T-transid'),
+            self.db0._get_replica_gen_and_trans_id('other-id'))
 
     def test_sync_exchange_send(self):
         entries = {
@@ -721,16 +722,19 @@
             }
 
         gens = []
-        _do_set_sync_info = self.db0._do_set_sync_info
+        _do_set_replica_gen_and_trans_id = self.db0._do_set_replica_gen_and_trans_id
 
         def set_sync_generation_witness(other_uid, other_gen, other_trans_id):
             gens.append((other_uid, other_gen))
-            _do_set_sync_info(other_uid, other_gen, other_trans_id)
+            _do_set_replica_gen_and_trans_id(
+                other_uid, other_gen, other_trans_id)
             self.assertGetDoc(self.db0, entries[other_gen]['id'],
                               entries[other_gen]['rev'],
                               entries[other_gen]['content'], False)
 
-        self.patch(self.db0, '_do_set_sync_info', set_sync_generation_witness)
+        self.patch(
+            self.db0, '_do_set_replica_gen_and_trans_id',
+            set_sync_generation_witness)
 
         args = dict(last_known_generation=0)
         body = ("[\r\n" +

=== modified file 'u1db/tests/test_https.py'
--- u1db/tests/test_https.py	2012-06-29 16:18:14 +0000
+++ u1db/tests/test_https.py	2012-07-03 14:37:18 +0000
@@ -86,7 +86,8 @@
         self.patch(http_client, 'CA_CERTS', self.cacert_pem)
         remote_target = self.getSyncTarget('localhost', 'test')
         remote_target.record_sync_info('other-id', 2, 'T-id')
-        self.assertEqual((2, 'T-id'), db._get_sync_gen_info('other-id'))
+        self.assertEqual(
+            (2, 'T-id'), db._get_replica_gen_and_trans_id('other-id'))
 
     def test_cannot_verify_cert(self):
         if not sys.platform.startswith('linux'):

=== modified file 'u1db/tests/test_remote_sync_target.py'
--- u1db/tests/test_remote_sync_target.py	2012-06-29 16:18:14 +0000
+++ u1db/tests/test_remote_sync_target.py	2012-07-03 14:37:18 +0000
@@ -171,7 +171,7 @@
     def test_get_sync_info(self):
         self.startServer()
         db = self.request_state._create_database('test')
-        db._set_sync_info('other-id', 1, 'T-transid')
+        db._set_replica_gen_and_trans_id('other-id', 1, 'T-transid')
         remote_target = self.getSyncTarget('test')
         self.assertEqual(('test', 0, 1, 'T-transid'),
                          remote_target.get_sync_info('other-id'))
@@ -181,7 +181,8 @@
         db = self.request_state._create_database('test')
         remote_target = self.getSyncTarget('test')
         remote_target.record_sync_info('other-id', 2, 'T-transid')
-        self.assertEqual((2, 'T-transid'), db._get_sync_gen_info('other-id'))
+        self.assertEqual(
+            (2, 'T-transid'), db._get_replica_gen_and_trans_id('other-id'))
 
     def test_sync_exchange_send(self):
         self.startServer()
@@ -239,7 +240,8 @@
                 return_doc_cb=receive_doc)
         self.assertGetDoc(db, 'doc-here', 'replica:1', '{"value": "here"}',
                           False)
-        self.assertEqual((10, 'T-sid'), db._get_sync_gen_info('replica'))
+        self.assertEqual(
+            (10, 'T-sid'), db._get_replica_gen_and_trans_id('replica'))
         self.assertEqual([], other_changes)
         # retry
         trigger_ids = []
@@ -249,7 +251,8 @@
                 return_doc_cb=receive_doc)
         self.assertGetDoc(db, 'doc-here2', 'replica:1', '{"value": "here2"}',
                           False)
-        self.assertEqual((11, 'T-sud'), db._get_sync_gen_info('replica'))
+        self.assertEqual(
+            (11, 'T-sud'), db._get_replica_gen_and_trans_id('replica'))
         self.assertEqual(2, new_gen)
         # bounced back to us
         self.assertEqual(

=== modified file 'u1db/tests/test_sync.py'
--- u1db/tests/test_sync.py	2012-06-29 16:18:14 +0000
+++ u1db/tests/test_sync.py	2012-07-03 14:37:18 +0000
@@ -441,8 +441,10 @@
 
     def test_sync_tracks_db_generation_of_other(self):
         self.assertEqual(0, self.sync(self.db1, self.db2))
-        self.assertEqual((0, ''), self.db1._get_sync_gen_info('test2'))
-        self.assertEqual((0, ''), self.db2._get_sync_gen_info('test1'))
+        self.assertEqual(
+            (0, ''), self.db1._get_replica_gen_and_trans_id('test2'))
+        self.assertEqual(
+            (0, ''), self.db2._get_replica_gen_and_trans_id('test1'))
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [], 'last_gen': 0}})
@@ -641,8 +643,8 @@
         doc = self.db1.create_doc(simple_doc)
         self.assertEqual(1, self.sync(self.db1, self.db2))
         self.assertGetDoc(self.db2, doc.doc_id, doc.rev, simple_doc, False)
-        self.assertEqual(1, self.db1._get_sync_gen_info('test2')[0])
-        self.assertEqual(1, self.db2._get_sync_gen_info('test1')[0])
+        self.assertEqual(1, self.db1._get_replica_gen_and_trans_id('test2')[0])
+        self.assertEqual(1, self.db2._get_replica_gen_and_trans_id('test1')[0])
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [(doc.doc_id, doc.rev)],
                          'source_uid': 'test1',
@@ -654,8 +656,8 @@
         self.db1.create_index('test-idx', 'key')
         self.assertEqual(0, self.sync(self.db1, self.db2))
         self.assertGetDoc(self.db1, doc.doc_id, doc.rev, simple_doc, False)
-        self.assertEqual(1, self.db1._get_sync_gen_info('test2')[0])
-        self.assertEqual(1, self.db2._get_sync_gen_info('test1')[0])
+        self.assertEqual(1, self.db1._get_replica_gen_and_trans_id('test2')[0])
+        self.assertEqual(1, self.db2._get_replica_gen_and_trans_id('test1')[0])
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [(doc.doc_id, doc.rev)],
@@ -681,11 +683,12 @@
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [(doc.doc_id, doc.rev)],
                         'last_gen': 1}})
-        self.assertEqual(1, self.db1._get_sync_gen_info('test2')[0])
+        self.assertEqual(1, self.db1._get_replica_gen_and_trans_id('test2')[0])
         # c2 should not have gotten a '_record_sync_info' call, because the
         # local database had been updated more than just by the messages
         # returned from c2.
-        self.assertEqual((0, ''), self.db2._get_sync_gen_info('test1'))
+        self.assertEqual(
+            (0, ''), self.db2._get_replica_gen_and_trans_id('test1'))
 
     def test_sync_doesnt_update_other_if_nothing_pulled(self):
         self.db1.create_doc(simple_doc)
@@ -696,8 +699,9 @@
             self.fail('SyncTarget.record_sync_info was called')
         self.assertEqual(1, self.sync(self.db1, self.db2,
                                       trace_hook=no_record_sync_info))
-        self.assertEqual(1,
-                         self.db2._get_sync_gen_info(self.db1._replica_uid)[0])
+        self.assertEqual(
+            1,
+            self.db2._get_replica_gen_and_trans_id(self.db1._replica_uid)[0])
 
     def test_sync_ignores_convergence(self):
         doc = self.db1.create_doc(simple_doc)
@@ -840,10 +844,10 @@
         self.sync(self.db2, self.db1)
         self.assertEqual(
             self.db1._get_generation_info(),
-            self.db2._get_sync_gen_info(self.db1._replica_uid))
+            self.db2._get_replica_gen_and_trans_id(self.db1._replica_uid))
         self.assertEqual(
             self.db2._get_generation_info(),
-            self.db1._get_sync_gen_info(self.db2._replica_uid))
+            self.db1._get_replica_gen_and_trans_id(self.db2._replica_uid))
         self.sync(db3, self.db1)
         # update on 2
         doc2 = self.make_document('the-doc', doc1.rev, '{"a": 2}')
@@ -879,17 +883,17 @@
         self.sync(db3, self.db1)
         self.assertEqual(
             self.db1._get_generation_info(),
-            db3._get_sync_gen_info(self.db1._replica_uid))
+            db3._get_replica_gen_and_trans_id(self.db1._replica_uid))
         self.assertEqual(
             db3._get_generation_info(),
-            self.db1._get_sync_gen_info(db3._replica_uid))
+            self.db1._get_replica_gen_and_trans_id(db3._replica_uid))
         self.sync(db3, self.db2)
         self.assertEqual(
             self.db2._get_generation_info(),
-            db3._get_sync_gen_info(self.db2._replica_uid))
+            db3._get_replica_gen_and_trans_id(self.db2._replica_uid))
         self.assertEqual(
             db3._get_generation_info(),
-            self.db2._get_sync_gen_info(db3._replica_uid))
+            self.db2._get_replica_gen_and_trans_id(db3._replica_uid))
         self.assertEqual(3, len(db3.get_doc_conflicts('the-doc')))
         doc1.set_json('{"a": 2}')
         self.db1.put_doc(doc1)
@@ -950,22 +954,22 @@
         self.assertEqual(2, len(self.db2._get_transaction_log()))
         progress1 = []
         progress2 = []
-        _do_set_sync_info = self.db1._do_set_sync_info
+        _do_set_replica_gen_and_trans_id = self.db1._do_set_replica_gen_and_trans_id
 
         def set_sync_generation_witness1(other_uid, other_gen, trans_id):
             progress1.append((other_uid, other_gen,
                 [d for d, t in self.db1._get_transaction_log()[2:]]))
-            _do_set_sync_info(other_uid, other_gen, trans_id)
-        self.patch(self.db1, '_do_set_sync_info',
+            _do_set_replica_gen_and_trans_id(other_uid, other_gen, trans_id)
+        self.patch(self.db1, '_do_set_replica_gen_and_trans_id',
                    set_sync_generation_witness1)
 
-        _do_set_sync_info2 = self.db2._do_set_sync_info
+        _do_set_replica_gen_and_trans_id2 = self.db2._do_set_replica_gen_and_trans_id
 
         def set_sync_generation_witness2(other_uid, other_gen, trans_id):
             progress2.append((other_uid, other_gen,
                 [d for d, t in self.db2._get_transaction_log()[2:]]))
-            _do_set_sync_info2(other_uid, other_gen, trans_id)
-        self.patch(self.db2, '_do_set_sync_info',
+            _do_set_replica_gen_and_trans_id2(other_uid, other_gen, trans_id)
+        self.patch(self.db2, '_do_set_replica_gen_and_trans_id',
                    set_sync_generation_witness2)
 
         db2_url = self.getURL('test2')