Merge lp:~jameinel/u1db/sync_info_999574 into lp:u1db

[John A Meinel]

This is a step along the path of getting transaction_ids included in synchronization.

The basic overview is that it gets transaction_ids added to get_sync_info and set_sync_info, which means it also has to be added to the _get_sync_generation and _set_sync_generation code. Because it is no longer just setting a generation counter, I wanted to change the api names.

I'm not very happy with the new names "_get_sync_gen_info()" and "_set_sync_info()". I was hoping to have the Database names be clearly distinct from the SyncTarget names (currently get_sync_info() and record_sync_info()). I would be ok with _get_sync_info() but it means that the difference is only in an underscore.

Calling it _get_sync_generation_and_transaction_id() is just not reasonable. The db table is currently called 'sync_log'. Maybe "_get_sync_state()" ? We don't want _get_sync_log because we aren't storing history. And possibly the table should be renamed as well.

The next steps are going to be adding the transaction ids to _put_doc_if_newer and whats_changed, which probably also means some sort of insert_from_source, insert_from_target changes.

[Eric Casteleijn (thisfred)]

Looks good

review: Approve

=== modified file 'include/u1db/u1db_internal.h'
--- include/u1db/u1db_internal.h	2012-05-17 15:13:42 +0000
+++ include/u1db/u1db_internal.h	2012-05-18 08:52:17 +0000
@@ -65,10 +65,14 @@
      *                          target, matches st_replica_uid
      * @param source_gen        (OUT) The last generation of source_replica_uid
      *                          that st has synchronized with.
+     * @param trans_id          (OUT) The transaction id associated with the
+     *                          source generation, the memory must be freed by
+     *                          the caller.
      */
     int (*get_sync_info)(u1db_sync_target *st,
         const char *source_replica_uid,
-        const char **st_replica_uid, int *st_gen, int *source_gen);
+        const char **st_replica_uid, int *st_gen, int *source_gen,
+        char **trans_id);
     /**
      * Set the synchronization information about another replica.
      *
@@ -78,9 +82,10 @@
      *                              want to synchronize from.
      * @param source_gen        The last generation of source_replica_uid
      *                          that st has synchronized with.
+     * @param trans_id          The transaction id associated with source_gen
      */
     int (*record_sync_info)(u1db_sync_target *st,
-        const char *source_replica_uid, int source_gen);
+        const char *source_replica_uid, int source_gen, const char *trans_id);
 
     /**
      * Send documents to the target, and receive the response.
@@ -249,16 +254,18 @@
  * @param replica_uid The identifier for the other database
  * @param generation  (OUT) The last generation that we know we synchronized
  *                    with the other database.
+ * @param trans_id    (OUT) The transaction id associated with the generation.
+ *                    Callers must free the data.
  */
-int u1db__get_sync_generation(u1database *db, const char *replica_uid,
-                              int *generation);
+int u1db__get_sync_gen_info(u1database *db, const char *replica_uid,
+                            int *generation, char **trans_id);
 
 /**
  * Set the known sync generation for another replica.
  *
  */
-int u1db__set_sync_generation(u1database *db, const char *replica_uid,
-                              int generation);
+int u1db__set_sync_info(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-05-17 15:26:01 +0000
+++ src/u1db.c	2012-05-18 08:52:17 +0000
@@ -810,7 +810,7 @@
                            (stored_doc_rev != NULL));
     }
     if (status == U1DB_OK && replica_uid != NULL) {
-        status = u1db__set_sync_generation(db, replica_uid, replica_gen);
+        status = u1db__set_sync_info(db, replica_uid, replica_gen, "T-sid");
     }
     if (status == U1DB_OK && at_gen != NULL) {
         status = u1db__get_generation(db, at_gen);
@@ -1315,18 +1315,22 @@
 
 
 int
-u1db__get_sync_generation(u1database *db, const char *replica_uid,
-                          int *generation)
+u1db__get_sync_gen_info(u1database *db, const char *replica_uid,
+                        int *generation, char **trans_id)
 {
     int status;
     sqlite3_stmt *statement;
+    const char *tmp;
 
-    if (db == NULL || replica_uid == NULL || generation == NULL) {
+    if (db == NULL || replica_uid == NULL || generation == NULL
+        || trans_id == NULL)
+    {
         return U1DB_INVALID_PARAMETER;
     }
     status = sqlite3_prepare_v2(db->sql_handle,
-        "SELECT known_generation FROM sync_log WHERE replica_uid = ?", -1,
-        &statement, NULL);
+        "SELECT known_generation, known_transaction_id"
+        " FROM sync_log WHERE replica_uid = ?",
+        -1, &statement, NULL);
     if (status != SQLITE_OK) { goto finish; }
     status = sqlite3_bind_text(statement, 1, replica_uid, -1, SQLITE_TRANSIENT);
     if (status != SQLITE_OK) { goto finish; }
@@ -1334,10 +1338,17 @@
     if (status == SQLITE_DONE) {
         status = SQLITE_OK;
         *generation = 0;
+        *trans_id = strdup("");
     } else if (status == SQLITE_ROW) {
         *generation = sqlite3_column_int(statement, 0);
+        // Note: We may want to handle the column containing NULL
+        tmp = (const char *)sqlite3_column_text(statement, 1);
+        *trans_id = strdup(tmp);
         status = SQLITE_OK;
     }
+    if (*trans_id == NULL) {
+        status = U1DB_NOMEM;
+    }
 finish:
     sqlite3_finalize(statement);
     return status;
@@ -1345,8 +1356,8 @@
 
 
 int
-u1db__set_sync_generation(u1database *db, const char *replica_uid,
-                          int generation)
+u1db__set_sync_info(u1database *db, const char *replica_uid,
+                    int generation, const char *trans_id)
 {
     int status;
     sqlite3_stmt *statement;
@@ -1364,7 +1375,7 @@
     if (status != SQLITE_OK) { goto finish; }
     status = sqlite3_bind_int(statement, 2, generation);
     if (status != SQLITE_OK) { goto finish; }
-    status = sqlite3_bind_text(statement, 3, "", -1, SQLITE_TRANSIENT);
+    status = sqlite3_bind_text(statement, 3, trans_id, -1, SQLITE_TRANSIENT);
     if (status != SQLITE_OK) { goto finish; }
     status = sqlite3_step(statement);
     if (status == SQLITE_DONE) {

=== modified file 'src/u1db_http_sync_target.c'
--- src/u1db_http_sync_target.c	2012-05-09 16:09:04 +0000
+++ src/u1db_http_sync_target.c	2012-05-18 08:52:17 +0000
@@ -34,17 +34,18 @@
 
 static int st_http_get_sync_info(u1db_sync_target *st,
         const char *source_replica_uid,
-        const char **st_replica_uid, int *st_gen, int *source_gen);
+        const char **st_replica_uid, int *st_gen, int *source_gen,
+        char **trans_id);
 
 static int st_http_record_sync_info(u1db_sync_target *st,
-        const char *source_replica_uid, int source_gen);
+        const char *source_replica_uid, int source_gen, const char *trans_id);
 
 static int st_http_get_sync_exchange(u1db_sync_target *st,
                          const char *source_replica_uid,
                          int source_gen,
                          u1db_sync_exchange **exchange);
 static int st_http_sync_exchange(u1db_sync_target *st,
-                      const char *source_replica_uid, 
+                      const char *source_replica_uid,
                       int n_docs, u1db_document **docs,
                       int *generations, int *target_gen, void *context,
                       u1db_doc_gen_callback cb);
@@ -355,7 +356,8 @@
 static int
 st_http_get_sync_info(u1db_sync_target *st,
         const char *source_replica_uid,
-        const char **st_replica_uid, int *st_gen, int *source_gen)
+        const char **st_replica_uid, int *st_gen, int *source_gen,
+        char **trans_id)
 {
     struct _http_state *state;
     struct _http_request req = {0};
@@ -451,6 +453,15 @@
         goto finish;
     }
     *source_gen = json_object_get_int(obj);
+    obj = json_object_object_get(json, "source_transaction_id");
+    if (obj == NULL) {
+        status = U1DB_INVALID_HTTP_RESPONSE;
+        goto finish;
+    }
+    *trans_id = strdup(json_object_get_string(obj));
+    if (*trans_id == NULL) {
+        status = U1DB_NOMEM;
+    }
 finish:
     if (req.header_buffer != NULL) {
         free(req.header_buffer);
@@ -508,7 +519,7 @@
 
 static int
 st_http_record_sync_info(u1db_sync_target *st,
-        const char *source_replica_uid, int source_gen)
+        const char *source_replica_uid, int source_gen, const char *trans_id)
 {
     struct _http_state *state;
     struct _http_request req = {0};
@@ -537,6 +548,8 @@
         goto finish;
     }
     json_object_object_add(json, "generation", json_object_new_int(source_gen));
+    json_object_object_add(json, "transaction_id",
+                           json_object_new_string(trans_id));
     raw_body = json_object_to_json_string(json);
     raw_len = strlen(raw_body);
     req.state = state;
@@ -561,7 +574,7 @@
     status = curl_easy_setopt(state->curl, CURLOPT_INFILESIZE_LARGE,
                               (curl_off_t)req.num_put_bytes);
     if (status != CURLE_OK) { goto finish; }
-    status = maybe_sign_url(st, "PUT", url, &headers); 
+    status = maybe_sign_url(st, "PUT", url, &headers);
     if (status != U1DB_OK) { goto finish; }
 
     // Now actually send the data

=== modified file 'src/u1db_sync_target.c'
--- src/u1db_sync_target.c	2012-05-17 13:25:42 +0000
+++ src/u1db_sync_target.c	2012-05-18 08:52:17 +0000
@@ -23,10 +23,11 @@
 
 static int st_get_sync_info(u1db_sync_target *st,
         const char *source_replica_uid,
-        const char **st_replica_uid, int *st_gen, int *source_gen);
+        const char **st_replica_uid, int *st_gen, int *source_gen,
+        char **trans_id);
 
 static int st_record_sync_info(u1db_sync_target *st,
-        const char *source_replica_uid, int source_gen);
+        const char *source_replica_uid, int source_gen, const char *trans_id);
 
 static int st_sync_exchange(u1db_sync_target *st,
                           const char *source_replica_uid, int n_docs,
@@ -100,7 +101,8 @@
 
 static int
 st_get_sync_info(u1db_sync_target *st, const char *source_replica_uid,
-        const char **st_replica_uid, int *st_gen, int *source_gen)
+        const char **st_replica_uid, int *st_gen, int *source_gen,
+        char **trans_id)
 {
     int status = U1DB_OK;
     u1database *db;
@@ -119,7 +121,8 @@
     db = (u1database *)st->implementation;
     status = u1db_get_replica_uid(db, st_replica_uid);
     if (status != U1DB_OK) { goto finish; }
-    status = u1db__get_sync_generation(db, source_replica_uid, source_gen);
+    status = u1db__get_sync_gen_info(db, source_replica_uid, source_gen,
+                                     trans_id);
     if (status != U1DB_OK) { goto finish; }
     status = u1db__get_generation(db, st_gen);
 finish:
@@ -129,7 +132,7 @@
 
 static int
 st_record_sync_info(u1db_sync_target *st, const char *source_replica_uid,
-                    int source_gen)
+                    int source_gen, const char *trans_id)
 {
     int status;
     u1database *db;
@@ -141,7 +144,7 @@
         if (status != U1DB_OK) { goto finish; }
     }
     db = (u1database *)st->implementation;
-    status = u1db__set_sync_generation(db, source_replica_uid, source_gen);
+    status = u1db__set_sync_info(db, source_replica_uid, source_gen, trans_id);
 finish:
     return status;
 }
@@ -543,6 +546,8 @@
     struct _whats_changed_doc_ids_state to_send_state = {0};
     struct _return_doc_state return_doc_state = {0};
     const char *target_uid, *local_uid;
+    char *target_trans_id_known_by_local = NULL;
+    char *local_trans_id_known_by_target = NULL;
     int target_gen, local_gen;
     int local_gen_known_by_target, target_gen_known_by_local;
 
@@ -556,10 +561,10 @@
     if (status != U1DB_OK) { goto finish; }
     // fprintf(stderr, "Local uid: %s\n", local_uid);
     status = target->get_sync_info(target, local_uid, &target_uid, &target_gen,
-                                   &local_gen_known_by_target);
+                   &local_gen_known_by_target, &local_trans_id_known_by_target);
     if (status != U1DB_OK) { goto finish; }
-    status = u1db__get_sync_generation(db, target_uid,
-                                       &target_gen_known_by_local);
+    status = u1db__get_sync_gen_info(db, target_uid,
+        &target_gen_known_by_local, &target_trans_id_known_by_local);
     if (status != U1DB_OK) { goto finish; }
     local_gen = local_gen_known_by_target;
 
@@ -589,17 +594,24 @@
     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_generation(db, target_uid,
-                                       target_gen_known_by_local);
+    status = u1db__set_sync_info(db, target_uid, target_gen_known_by_local,
+                                 "T-sid");
     if (status != U1DB_OK) { goto finish; }
     if (return_doc_state.num_inserted > 0 &&
             ((*local_gen_before_sync + return_doc_state.num_inserted)
               == local_gen))
     {
-        status = target->record_sync_info(target, local_uid, local_gen);
+        status = target->record_sync_info(target, local_uid, local_gen,
+                                          "T-sid");
         if (status != U1DB_OK) { goto finish; }
     }
 finish:
+    if (local_trans_id_known_by_target != NULL) {
+        free(local_trans_id_known_by_target);
+    }
+    if (target_trans_id_known_by_local != NULL) {
+        free(target_trans_id_known_by_local);
+    }
     if (to_send_state.doc_ids_to_return != NULL) {
         int i;
 

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2012-05-17 13:22:20 +0000
+++ u1db/__init__.py	2012-05-18 08:52:17 +0000
@@ -216,29 +216,35 @@
         from u1db.remote.http_target import HTTPSyncTarget
         return Synchronizer(self, HTTPSyncTarget(url)).sync()
 
-    def _get_sync_generation(self, other_replica_uid):
-        """Return the last known database generation of the other db replica.
+    def _get_sync_gen_info(self, other_replica_uid):
+        """Return the last known information about 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.
-        This way we only have to request data that is newer.
+        track of what generation the other database replica was at, and what
+        the associated transaction id was.  This is used to determine what data
+        needs to be sent, and if two databases are claiming to be the same
+        replica.
 
         :param other_replica_uid: The identifier for the other replica.
-        :return: The generation we encountered during synchronization. If we've
-            never synchronized with the replica, this is 0.
+        :return: (gen, trans_id) The generation and transaction id we
+            encountered during synchronization. If we've never synchronized
+            with the replica, this is (0, '').
         """
-        raise NotImplementedError(self._get_sync_generation)
+        raise NotImplementedError(self._get_sync_gen_info)
 
-    def _set_sync_generation(self, other_replica_uid, other_generation):
+    def _set_sync_info(self, other_replica_uid, other_generation,
+                       other_transaction_id):
         """Set the last-known generation 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_generation.
+        generation the other replica was at. See also _get_sync_gen_info.
         :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_generation)
+        raise NotImplementedError(self._set_sync_info)
 
     def _put_doc_if_newer(self, doc, save_conflict, replica_uid=None,
                           replica_gen=None):
@@ -338,11 +344,13 @@
         :param source_replica_uid: Another replica which we might have
             synchronized with in the past.
         :return: (target_replica_uid, target_replica_generation,
-                  source_replica_last_known_generation)
+                  source_replica_last_known_generation,
+                  source_replica_last_known_transaction_id)
         """
         raise NotImplementedError(self.get_sync_info)
 
-    def record_sync_info(self, source_replica_uid, source_replica_generation):
+    def record_sync_info(self, source_replica_uid, source_replica_generation,
+                         source_replica_transaction_id):
         """Record tip information for another replica.
 
         After sync_exchange has been processed, the caller will have
@@ -358,6 +366,8 @@
         :param source_replica_uid: The identifier for the source replica.
         :param source_replica_generation:
              The database generation for the source replica.
+        :param source_replica_transaction_id: The transaction id associated
+            with the source replica generation.
         :return: None
         """
         raise NotImplementedError(self.record_sync_info)

=== modified file 'u1db/backends/__init__.py'
--- u1db/backends/__init__.py	2012-05-17 14:44:25 +0000
+++ u1db/backends/__init__.py	2012-05-18 08:52:17 +0000
@@ -115,7 +115,7 @@
             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_generation(replica_uid, replica_gen)
+            self._do_set_sync_info(replica_uid, replica_gen, 'T-sid')
         return state, self._get_generation()
 
     def _ensure_maximal_rev(self, cur_rev, extra_revs):

=== modified file 'u1db/backends/dbschema.sql'
--- u1db/backends/dbschema.sql	2012-05-17 13:59:05 +0000
+++ u1db/backends/dbschema.sql	2012-05-18 08:52:17 +0000
@@ -1,17 +1,17 @@
 -- Database schema
 CREATE TABLE transaction_log (
     generation INTEGER PRIMARY KEY AUTOINCREMENT,
-    doc_id TEXT,
-    transaction_id TEXT
+    doc_id TEXT NOT NULL,
+    transaction_id TEXT NOT NULL
 );
 CREATE TABLE document (
     doc_id TEXT PRIMARY KEY,
-    doc_rev TEXT,
+    doc_rev TEXT NOT NULL,
     content TEXT
 );
 CREATE TABLE document_fields (
-    doc_id TEXT,
-    field_name TEXT,
+    doc_id TEXT NOT NULL,
+    field_name TEXT NOT NULL,
     value TEXT
 );
 CREATE INDEX document_fields_field_value_doc_idx

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2012-05-17 14:44:25 +0000
+++ u1db/backends/inmemory.py	2012-05-18 08:52:17 +0000
@@ -45,16 +45,20 @@
         # may be closing it, while another wants to inspect the results.
         pass
 
-    def _get_sync_generation(self, other_replica_uid):
-        return self._other_generations.get(other_replica_uid, 0)
-
-    def _set_sync_generation(self, other_replica_uid, other_generation):
-        self._do_set_sync_generation(other_replica_uid, other_generation)
-
-    def _do_set_sync_generation(self, other_replica_uid, other_generation):
+    def _get_sync_gen_info(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 _do_set_sync_info(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
+        self._other_generations[other_replica_uid] = (other_generation,
+                                                      other_transaction_id)
 
     def get_sync_target(self):
         return InMemorySyncTarget(self)
@@ -334,12 +338,13 @@
 class InMemorySyncTarget(CommonSyncTarget):
 
     def get_sync_info(self, source_replica_uid):
-        source_gen = self._db._get_sync_generation(source_replica_uid)
-        return (
-            self._db._replica_uid, len(self._db._transaction_log), source_gen)
+        source_gen, trans_id = self._db._get_sync_gen_info(source_replica_uid)
+        return (self._db._replica_uid, len(self._db._transaction_log),
+                source_gen, trans_id)
 
-    def record_sync_info(self, source_replica_uid, source_replica_generation):
+    def record_sync_info(self, source_replica_uid, source_replica_generation,
+                         source_transaction_id):
         if self._trace_hook:
             self._trace_hook('record_sync_info')
-        self._db._set_sync_generation(source_replica_uid,
-                                      source_replica_generation)
+        self._db._set_sync_info(source_replica_uid, source_replica_generation,
+                                source_transaction_id)

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2012-05-17 15:13:42 +0000
+++ u1db/backends/sqlite_backend.py	2012-05-18 08:52:17 +0000
@@ -409,26 +409,32 @@
             this_doc.has_conflicts = True
             return [this_doc] + conflict_docs
 
-    def _get_sync_generation(self, other_replica_uid):
+    def _get_sync_gen_info(self, other_replica_uid):
         c = self._db_handle.cursor()
-        c.execute("SELECT known_generation FROM sync_log"
+        c.execute("SELECT known_generation, known_transaction_id FROM sync_log"
                   " WHERE replica_uid = ?",
                   (other_replica_uid,))
         val = c.fetchone()
         if val is None:
             other_gen = 0
+            trans_id = ''
         else:
             other_gen = val[0]
-        return other_gen
+            trans_id = val[1]
+        return other_gen, trans_id
 
-    def _set_sync_generation(self, other_replica_uid, other_generation):
+    def _set_sync_info(self, other_replica_uid, other_generation,
+                       other_transaction_id):
         with self._db_handle:
-            self._do_set_sync_generation(other_replica_uid, other_generation)
+            self._do_set_sync_info(other_replica_uid, other_generation,
+                                   other_transaction_id)
 
-    def _do_set_sync_generation(self, other_replica_uid, other_generation):
+    def _do_set_sync_info(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, ''))
+                      (other_replica_uid, other_generation,
+                       other_transaction_id))
 
     def _put_doc_if_newer(self, doc, save_conflict, replica_uid=None,
                           replica_gen=None):
@@ -608,15 +614,16 @@
 class SQLiteSyncTarget(CommonSyncTarget):
 
     def get_sync_info(self, source_replica_uid):
-        source_gen = self._db._get_sync_generation(source_replica_uid)
+        source_gen, trans_id = self._db._get_sync_gen_info(source_replica_uid)
         my_gen = self._db._get_generation()
-        return self._db._replica_uid, my_gen, source_gen
+        return self._db._replica_uid, my_gen, source_gen, trans_id
 
-    def record_sync_info(self, source_replica_uid, source_replica_generation):
+    def record_sync_info(self, source_replica_uid, source_replica_generation,
+                         source_replica_transaction_id):
         if self._trace_hook:
             self._trace_hook('record_sync_info')
-        self._db._set_sync_generation(source_replica_uid,
-                                      source_replica_generation)
+        self._db._set_sync_info(source_replica_uid, source_replica_generation,
+                                source_replica_transaction_id)
 
 
 class SQLitePartialExpandDatabase(SQLiteDatabase):

=== modified file 'u1db/remote/http_app.py'
--- u1db/remote/http_app.py	2012-05-15 13:01:47 +0000
+++ u1db/remote/http_app.py	2012-05-18 08:52:17 +0000
@@ -290,12 +290,14 @@
         self.responder.send_response_json(target_replica_uid=result[0],
                                      target_replica_generation=result[1],
                                      source_replica_uid=self.source_replica_uid,
-                                     source_replica_generation=result[2])
+                                     source_replica_generation=result[2],
+                                     source_transaction_id=result[3])
 
     @http_method(generation=int,
                  content_as_args=True, no_query=True)
-    def put(self, generation):
-        self.target.record_sync_info(self.source_replica_uid, generation)
+    def put(self, generation, transaction_id):
+        self.target.record_sync_info(self.source_replica_uid, generation,
+                                     transaction_id)
         self.responder.send_response_json(ok=True)
 
     # Implements the same logic as LocalSyncTarget.sync_exchange

=== modified file 'u1db/remote/http_target.py'
--- u1db/remote/http_target.py	2012-05-13 09:56:59 +0000
+++ u1db/remote/http_target.py	2012-05-18 08:52:17 +0000
@@ -42,12 +42,14 @@
         self._ensure_connection()
         res, _ = self._request_json('GET', ['sync-from', source_replica_uid])
         return (res['target_replica_uid'], res['target_replica_generation'],
-                res['source_replica_generation'])
+                res['source_replica_generation'], res['source_transaction_id'])
 
-    def record_sync_info(self, source_replica_uid, source_replica_generation):
+    def record_sync_info(self, source_replica_uid, source_replica_generation,
+                         source_transaction_id):
         self._ensure_connection()
         self._request_json('PUT', ['sync-from', source_replica_uid], {},
-                                  {'generation': source_replica_generation})
+                              {'generation': source_replica_generation,
+                               'transaction_id': source_transaction_id})
 
     def _parse_sync_stream(self, data, return_doc_cb):
         parts = data.splitlines()  # one at a time

=== modified file 'u1db/sync.py'
--- u1db/sync.py	2012-05-17 13:36:08 +0000
+++ u1db/sync.py	2012-05-18 08:52:17 +0000
@@ -86,20 +86,20 @@
         if (cur_gen == start_generation + self.num_inserted
             and self.num_inserted > 0):
             self.sync_target.record_sync_info(self.source._replica_uid,
-                                              cur_gen)
+                                              cur_gen, 'T-sid')
 
     def sync(self, callback=None):
         """Synchronize documents between source and target."""
         sync_target = self.sync_target
         # get target identifier, its current generation,
         # and its last-seen database generation for this source
-        (self.target_replica_uid, target_gen,
-         target_my_gen) = sync_target.get_sync_info(self.source._replica_uid)
+        (self.target_replica_uid, target_gen, target_my_gen,
+         target_my_trans_id) = sync_target.get_sync_info(self.source._replica_uid)
         # what's changed since that generation and this current gen
         my_gen, changes = self.source.whats_changed(target_my_gen)
 
         # this source last-seen database generation for the target
-        target_last_known_gen = self.source._get_sync_generation(
+        target_last_known_gen, target_trans_id = self.source._get_sync_gen_info(
             self.target_replica_uid)
         if not changes and target_last_known_gen == target_gen:
             return my_gen
@@ -115,7 +115,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_generation(self.target_replica_uid, new_gen)
+        self.source._set_sync_info(self.target_replica_uid, new_gen, 'T-sid')
 
         # if gapless record current reached generation with target
         self._record_sync_info_with_the_target(my_gen)

=== modified file 'u1db/tests/c_backend_wrapper.pyx'
--- u1db/tests/c_backend_wrapper.pyx	2012-05-17 15:13:42 +0000
+++ u1db/tests/c_backend_wrapper.pyx	2012-05-18 08:52:17 +0000
@@ -156,9 +156,10 @@
     ctypedef struct u1db_sync_target:
         int (*get_sync_info)(u1db_sync_target *st,
             char *source_replica_uid,
-            const_char_ptr *st_replica_uid, int *st_gen, int *source_gen) nogil
+            const_char_ptr *st_replica_uid, int *st_gen, int *source_gen,
+            char **source_trans_id) nogil
         int (*record_sync_info)(u1db_sync_target *st,
-            char *source_replica_uid, int source_gen) nogil
+            char *source_replica_uid, int source_gen, char *trans_id) nogil
         int (*sync_exchange)(u1db_sync_target *st,
                              char *source_replica_uid, int n_docs,
                              u1db_document **docs, int *generations,
@@ -191,10 +192,10 @@
                                            char *content, int has_conflicts)
     int u1db__generate_hex_uuid(char *)
 
-    int u1db__get_sync_generation(u1database *db, char *replica_uid,
-                                  int *generation)
-    int u1db__set_sync_generation(u1database *db, char *replica_uid,
-                                  int generation)
+    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__sync_get_machine_info(u1database *db, char *other_replica_uid,
                                     int *other_db_rev, char **my_replica_uid,
                                     int *my_db_rev)
@@ -665,22 +666,27 @@
     def get_sync_info(self, source_replica_uid):
         cdef const_char_ptr st_replica_uid = NULL
         cdef int st_gen = 0, source_gen = 0, status
+        cdef char *trans_id = NULL
 
         self._check()
         assert self._st.get_sync_info != NULL, "get_sync_info is NULL?"
         with nogil:
             status = self._st.get_sync_info(self._st, source_replica_uid,
-                &st_replica_uid, &st_gen, &source_gen)
+                &st_replica_uid, &st_gen, &source_gen, &trans_id)
         handle_status("get_sync_info", status)
-        return (safe_str(st_replica_uid), st_gen, source_gen)
+        res_trans_id = None
+        if trans_id != NULL:
+            res_trans_id = trans_id
+            free(trans_id)
+        return (safe_str(st_replica_uid), st_gen, source_gen, res_trans_id)
 
-    def record_sync_info(self, source_replica_uid, source_gen):
+    def record_sync_info(self, source_replica_uid, source_gen, source_trans_id):
         cdef int status
         self._check()
         assert self._st.record_sync_info != NULL, "record_sync_info is NULL?"
         with nogil:
             status = self._st.record_sync_info(self._st, source_replica_uid,
-                                               source_gen)
+                                               source_gen, source_trans_id)
         handle_status("record_sync_info", status)
 
     def _get_sync_exchange(self, source_replica_uid, source_gen):
@@ -968,16 +974,22 @@
             u1db__get_generation(self._db, &generation))
         return generation
 
-    def _get_sync_generation(self, replica_uid):
-        cdef int generation
-
-        handle_status("_get_sync_generation",
-            u1db__get_sync_generation(self._db, replica_uid, &generation))
-        return generation
-
-    def _set_sync_generation(self, replica_uid, generation):
-        handle_status("_set_sync_generation",
-            u1db__set_sync_generation(self._db, replica_uid, generation))
+    def _get_sync_gen_info(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)
+        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 _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-05-17 14:44:25 +0000
+++ u1db/tests/test_backends.py	2012-05-18 08:52:17 +0000
@@ -296,19 +296,19 @@
 
     def test_put_doc_if_newer_replica_uid(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db._set_sync_generation('other', 1)
+        self.db._set_sync_info('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)[0])
-        self.assertEqual(2, self.db._get_sync_generation('other'))
+        self.assertEqual(2, self.db._get_sync_gen_info('other')[0])
         # 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)[0])
-        self.assertEqual(3, self.db._get_sync_generation('other'))
+        self.assertEqual(3, self.db._get_sync_gen_info('other')[0])
         # 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',
@@ -316,12 +316,13 @@
         self.assertEqual('conflicted',
             self.db._put_doc_if_newer(doc2, save_conflict=False,
                                       replica_uid='other', replica_gen=4)[0])
-        self.assertEqual(4, self.db._get_sync_generation('other'))
+        self.assertEqual(4, self.db._get_sync_gen_info('other')[0])
 
-    def test__get_sync_generation(self):
-        self.assertEqual(0, self.db._get_sync_generation('other-db'))
-        self.db._set_sync_generation('other-db', 2)
-        self.assertEqual(2, self.db._get_sync_generation('other-db'))
+    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_put_updates_transaction_log(self):
         doc = self.db.create_doc(simple_doc)
@@ -568,7 +569,7 @@
 
     def test_put_doc_if_newer_replica_uid(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db._set_sync_generation('other', 1)
+        self.db._set_sync_info('other', 1, 'T-sid')
         doc2 = self.make_document(doc1.doc_id, doc1.rev + '|other:1',
                                   nested_doc)
         self.db._put_doc_if_newer(doc2, save_conflict=True,
@@ -579,7 +580,7 @@
         self.assertEqual('conflicted',
             self.db._put_doc_if_newer(doc2, save_conflict=True,
                 replica_uid='other', replica_gen=3)[0])
-        self.assertEqual(3, self.db._get_sync_generation('other'))
+        self.assertEqual(3, self.db._get_sync_gen_info('other')[0])
 
     def test_put_refuses_to_update_conflicted(self):
         doc1 = self.db.create_doc(simple_doc)

=== modified file 'u1db/tests/test_c_backend.py'
--- u1db/tests/test_c_backend.py	2012-05-17 13:30:51 +0000
+++ u1db/tests/test_c_backend.py	2012-05-18 08:52:17 +0000
@@ -201,7 +201,8 @@
         exc.insert_doc_from_source(doc, 10)
         self.assertGetDoc(self.db, 'doc-id', 'replica:1', tests.simple_doc,
                           False)
-        self.assertEqual(10, self.db._get_sync_generation('source-uid'))
+        self.assertEqual((10, 'T-sid'),
+                         self.db._get_sync_gen_info('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-05-17 13:36:08 +0000
+++ u1db/tests/test_http_app.py	2012-05-18 08:52:17 +0000
@@ -664,24 +664,26 @@
                          simplejson.loads(resp.body))
 
     def test_get_sync_info(self):
-        self.db0._set_sync_generation('other-id', 1)
+        self.db0._set_sync_info('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'))
         self.assertEqual(dict(target_replica_uid='db0',
                               target_replica_generation=0,
                               source_replica_uid='other-id',
-                              source_replica_generation=1),
+                              source_replica_generation=1,
+                              source_transaction_id='T-transid'),
                               simplejson.loads(resp.body))
 
     def test_record_sync_info(self):
         resp = self.app.put('/db0/sync-from/other-id',
-                            params='{"generation": 2}',
-                            headers={'content-type': 'application/json'})
+            params='{"generation": 2, "transaction_id": "T-transid"}',
+            headers={'content-type': 'application/json'})
         self.assertEqual(200, resp.status)
         self.assertEqual('application/json', resp.header('content-type'))
         self.assertEqual({'ok': True}, simplejson.loads(resp.body))
-        self.assertEqual(self.db0._get_sync_generation('other-id'), 2)
+        self.assertEqual((2, 'T-transid'),
+                         self.db0._get_sync_gen_info('other-id'))
 
     def test_sync_exchange_send(self):
         entries = {
@@ -692,16 +694,15 @@
             }
 
         gens = []
-        _do_set_sync_generation = self.db0._do_set_sync_generation
-        def set_sync_generation_witness(other_uid, other_gen):
+        _do_set_sync_info = self.db0._do_set_sync_info
+        def set_sync_generation_witness(other_uid, other_gen, other_trans_id):
             gens.append((other_uid, other_gen))
-            _do_set_sync_generation(other_uid, other_gen)
+            _do_set_sync_info(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_generation',
-                   set_sync_generation_witness)
+        self.patch(self.db0, '_do_set_sync_info', 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-05-17 15:13:31 +0000
+++ u1db/tests/test_https.py	2012-05-18 08:52:17 +0000
@@ -83,8 +83,8 @@
         db = self.request_state._create_database('test')
         self.patch(http_client, 'CA_CERTS', self.cacert_pem)
         remote_target = self.getSyncTarget('localhost', 'test')
-        remote_target.record_sync_info('other-id', 2)
-        self.assertEqual(db._get_sync_generation('other-id'), 2)
+        remote_target.record_sync_info('other-id', 2, 'T-id')
+        self.assertEqual((2, 'T-id'), db._get_sync_gen_info('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-05-17 13:36:08 +0000
+++ u1db/tests/test_remote_sync_target.py	2012-05-18 08:52:17 +0000
@@ -164,17 +164,17 @@
     def test_get_sync_info(self):
         self.startServer()
         db = self.request_state._create_database('test')
-        db._set_sync_generation('other-id', 1)
+        db._set_sync_info('other-id', 1, 'T-transid')
         remote_target = self.getSyncTarget('test')
-        self.assertEqual(('test', 0, 1),
+        self.assertEqual(('test', 0, 1, 'T-transid'),
                          remote_target.get_sync_info('other-id'))
 
     def test_record_sync_info(self):
         self.startServer()
         db = self.request_state._create_database('test')
         remote_target = self.getSyncTarget('test')
-        remote_target.record_sync_info('other-id', 2)
-        self.assertEqual(db._get_sync_generation('other-id'), 2)
+        remote_target.record_sync_info('other-id', 2, 'T-transid')
+        self.assertEqual((2, 'T-transid'), db._get_sync_gen_info('other-id'))
 
     def test_sync_exchange_send(self):
         self.startServer()
@@ -222,7 +222,7 @@
                 return_doc_cb=receive_doc)
         self.assertGetDoc(db, 'doc-here', 'replica:1', '{"value": "here"}',
                           False)
-        self.assertEqual(10, db._get_sync_generation('replica'))
+        self.assertEqual((10, 'T-sid'), db._get_sync_gen_info('replica'))
         self.assertEqual([], other_changes)
         # retry
         trigger_ids = []
@@ -232,7 +232,7 @@
                 return_doc_cb=receive_doc)
         self.assertGetDoc(db, 'doc-here2', 'replica:1', '{"value": "here2"}',
                           False)
-        self.assertEqual(11, db._get_sync_generation('replica'))
+        self.assertEqual((11, 'T-sid'), db._get_sync_gen_info('replica'))
         self.assertEqual(2, new_gen)
         # bounced back to us
         self.assertEqual([('doc-here', 'replica:1', '{"value": "here"}', 1)],

=== modified file 'u1db/tests/test_sync.py'
--- u1db/tests/test_sync.py	2012-05-17 14:44:25 +0000
+++ u1db/tests/test_sync.py	2012-05-18 08:52:17 +0000
@@ -141,17 +141,18 @@
         self.assertIsNot(None, self.st)
 
     def test_get_sync_info(self):
-        self.assertEqual(('test', 0, 0), self.st.get_sync_info('other'))
+        self.assertEqual(('test', 0, 0, ''), self.st.get_sync_info('other'))
 
     def test_create_doc_updates_sync_info(self):
-        self.assertEqual(('test', 0, 0), self.st.get_sync_info('other'))
+        self.assertEqual(('test', 0, 0, ''), self.st.get_sync_info('other'))
         doc = self.db.create_doc(simple_doc)
-        self.assertEqual(('test', 1, 0), self.st.get_sync_info('other'))
+        self.assertEqual(('test', 1, 0, ''), self.st.get_sync_info('other'))
 
     def test_record_sync_info(self):
-        self.assertEqual(('test', 0, 0), self.st.get_sync_info('replica'))
-        self.st.record_sync_info('replica', 10)
-        self.assertEqual(('test', 0, 10), self.st.get_sync_info('replica'))
+        self.assertEqual(('test', 0, 0, ''), self.st.get_sync_info('replica'))
+        self.st.record_sync_info('replica', 10, 'T-transid')
+        self.assertEqual(('test', 0, 10, 'T-transid'),
+                         self.st.get_sync_info('replica'))
 
     def test_sync_exchange(self):
         docs_by_gen = [
@@ -162,7 +163,7 @@
         self.assertGetDoc(self.db, 'doc-id', 'replica:1', simple_doc, False)
         self.assertTransactionLog(['doc-id'], self.db)
         self.assertEqual(([], 1), (self.other_changes, new_gen))
-        self.assertEqual(10, self.st.get_sync_info('replica')[-1])
+        self.assertEqual(10, self.st.get_sync_info('replica')[2])
 
     def test_sync_exchange_deleted(self):
         doc = self.db.create_doc('{}')
@@ -175,7 +176,7 @@
         self.assertGetDoc(self.db, doc.doc_id, edit_rev, None, False)
         self.assertTransactionLog([doc.doc_id, doc.doc_id], self.db)
         self.assertEqual(([], 2), (self.other_changes, new_gen))
-        self.assertEqual(10, self.st.get_sync_info('replica')[-1])
+        self.assertEqual(10, self.st.get_sync_info('replica')[2])
 
     def test_sync_exchange_push_many(self):
         docs_by_gen = [
@@ -188,7 +189,7 @@
         self.assertGetDoc(self.db, 'doc-id2', 'replica:1', nested_doc, False)
         self.assertTransactionLog(['doc-id', 'doc-id2'], self.db)
         self.assertEqual(([], 2), (self.other_changes, new_gen))
-        self.assertEqual(11, self.st.get_sync_info('replica')[-1])
+        self.assertEqual(11, self.st.get_sync_info('replica')[2])
 
     def test_sync_exchange_refuses_conflicts(self):
         doc = self.db.create_doc(simple_doc)
@@ -345,7 +346,7 @@
         self.assertGetDoc(self.db, doc.doc_id, doc.rev, simple_doc, False)
         self.assertTransactionLog([doc.doc_id], self.db)
         self.assertEqual(([], 1), (self.other_changes, new_gen))
-        self.assertEqual(10, self.st.get_sync_info(db2._replica_uid)[-1])
+        self.assertEqual(10, self.st.get_sync_info(db2._replica_uid)[2])
 
     def test__set_trace_hook(self):
         called = []
@@ -353,7 +354,7 @@
             called.append(state)
         self.set_trace_hook(cb)
         self.st.sync_exchange([], 'replica', 0, self.receive_doc)
-        self.st.record_sync_info('replica', 0)
+        self.st.record_sync_info('replica', 0, 'T-sid')
         self.assertEqual(['before whats_changed',
                           'after whats_changed',
                           'before get_docs',
@@ -410,8 +411,8 @@
 
     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_generation('test2'))
-        self.assertEqual(0, self.db2._get_sync_generation('test1'))
+        self.assertEqual((0, ''), self.db1._get_sync_gen_info('test2'))
+        self.assertEqual((0, ''), self.db2._get_sync_gen_info('test1'))
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [], 'last_gen': 0}})
@@ -420,8 +421,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_generation('test2'))
-        self.assertEqual(1, self.db2._get_sync_generation('test1'))
+        self.assertEqual(1, self.db1._get_sync_gen_info('test2')[0])
+        self.assertEqual(1, self.db2._get_sync_gen_info('test1')[0])
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [(doc.doc_id, doc.rev)],
                          'source_uid': 'test1',
@@ -433,8 +434,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_generation('test2'))
-        self.assertEqual(1, self.db2._get_sync_generation('test1'))
+        self.assertEqual(1, self.db1._get_sync_gen_info('test2')[0])
+        self.assertEqual(1, self.db2._get_sync_gen_info('test1')[0])
         self.assertLastExchangeLog(self.db2,
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [(doc.doc_id, doc.rev)],
@@ -459,11 +460,11 @@
             {'receive': {'docs': [], 'last_known_gen': 0},
              'return': {'docs': [(doc.doc_id, doc.rev)],
                         'last_gen': 1}})
-        self.assertEqual(1, self.db1._get_sync_generation('test2'))
+        self.assertEqual(1, self.db1._get_sync_gen_info('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_generation('test1'))
+        self.assertEqual((0, ''), self.db2._get_sync_gen_info('test1'))
 
     def test_sync_doesnt_update_other_if_nothing_pulled(self):
         doc = self.db1.create_doc(simple_doc)
@@ -474,7 +475,7 @@
         self.assertEqual(1, self.sync(self.db1, self.db2,
                                       trace_hook=no_record_sync_info))
         self.assertEqual(1,
-                         self.db2._get_sync_generation(self.db1._replica_uid))
+                         self.db2._get_sync_gen_info(self.db1._replica_uid)[0])
 
     def test_sync_ignores_convergence(self):
         doc = self.db1.create_doc(simple_doc)
@@ -707,20 +708,20 @@
         self.assertEqual(2, len(self.db2._get_transaction_log()))
         progress1 = []
         progress2 = []
-        _do_set_sync_generation1 = self.db1._do_set_sync_generation
-        def set_sync_generation_witness1(other_uid, other_gen):
+        _do_set_sync_info = self.db1._do_set_sync_info
+        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_generation1(other_uid, other_gen)
-        self.patch(self.db1, '_do_set_sync_generation',
+            _do_set_sync_info(other_uid, other_gen, trans_id)
+        self.patch(self.db1, '_do_set_sync_info',
                    set_sync_generation_witness1)
 
-        _do_set_sync_generation2 = self.db2._do_set_sync_generation
-        def set_sync_generation_witness2(other_uid, other_gen):
+        _do_set_sync_info2 = self.db2._do_set_sync_info
+        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_generation2(other_uid, other_gen)
-        self.patch(self.db2, '_do_set_sync_generation',
+            _do_set_sync_info2(other_uid, other_gen, trans_id)
+        self.patch(self.db2, '_do_set_sync_info',
                    set_sync_generation_witness2)
 
         db2_url = self.getURL('test2')