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

[John A Meinel]

This is hopefully a small patch that is easier to review.

It just updates the whats_changed api so that it returns the transaction_id along with the database generation. Hopefully I updated enough of the docs to match it.

It does mean that we have to expose the transaction ids a bit in the test suite, for now I just went with '_get_transaction_log()' and pull out the bit we care about. I don't really want to add another not-for-use-in-production-code api for grabbing it. (You could argue that put_doc could return it.)

Unmerged revisions

=== modified file 'include/u1db/u1db.h'
--- include/u1db/u1db.h	2012-05-17 15:13:42 +0000
+++ include/u1db/u1db.h	2012-05-18 09:33:18 +0000
@@ -198,15 +198,16 @@
  *               get all changes in the database. The integer will be updated
  *               to point at the current generation.
  * @param cb     A callback function. This will be called passing in 'context',
- *               and a document identifier for each document that has been modified.
- *               The doc_id string is transient, so callers must copy it to
- *               their own memory if they want to keep it.
- *               If a document is changed more than once, it is currently
- *               undefined whether this will call cb() once per change, or just
- *               once per doc_id.
+ *               and a document identifier for each document that has been
+ *               modified. This includes the generation and associated
+ *               transaction id for each change. If a document is modified more
+ *               than once, only the most recent change will be given.
+ *               Note that the strings passed are transient, so must be copied
+ *               if callers want to use them after they return.
  * @param context Opaque context, passed back to the caller.
  */
-int u1db_whats_changed(u1database *db, int *gen, void *context, u1db_doc_id_gen_callback cb);
+int u1db_whats_changed(u1database *db, int *gen, void *context,
+                       u1db_trans_info_callback cb);
 
 
 /**

=== 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 09:33:18 +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 09:33:18 +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);
@@ -1108,7 +1108,7 @@
 
 int
 u1db_whats_changed(u1database *db, int *gen, void *context,
-                   int (*cb)(void *, const char *doc_id, int gen))
+                   u1db_trans_info_callback cb)
 {
     int status;
     sqlite3_stmt *statement;
@@ -1116,8 +1116,8 @@
         return -1; // Bad parameters
     }
     status = sqlite3_prepare_v2(db->sql_handle,
-        "SELECT max(generation) as g, doc_id FROM transaction_log"
-        " WHERE generation > ?"
+        "SELECT max(generation) as g, doc_id, transaction_id"
+        " FROM transaction_log WHERE generation > ?"
         " GROUP BY doc_id ORDER BY g",
         -1, &statement, NULL);
     if (status != SQLITE_OK) {
@@ -1131,13 +1131,15 @@
     status = sqlite3_step(statement);
     while (status == SQLITE_ROW) {
         int local_gen;
-        char *doc_id;
+        const char *doc_id;
+        const char *trans_id;
         local_gen = sqlite3_column_int(statement, 0);
         if (local_gen > *gen) {
             *gen = local_gen;
         }
-        doc_id = (char *)sqlite3_column_text(statement, 1);
-        cb(context, doc_id, local_gen);
+        doc_id = (const char *)sqlite3_column_text(statement, 1);
+        trans_id = (const char *)sqlite3_column_text(statement, 2);
+        cb(context, doc_id, local_gen, trans_id);
         status = sqlite3_step(statement);
     }
     if (status == SQLITE_DONE) {
@@ -1315,18 +1317,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 +1340,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 +1358,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 +1377,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 09:33:18 +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 09:33:18 +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;
 }
@@ -301,7 +304,8 @@
 // Callback for whats_changed to map the callback into the sync_exchange
 // doc_ids_to_return array.
 static int
-whats_changed_to_doc_ids(void *context, const char *doc_id, int gen)
+whats_changed_to_doc_ids(void *context, const char *doc_id, int gen,
+                         const char *trans_id)
 {
     struct lh_entry *e;
     struct _whats_changed_doc_ids_state *state;
@@ -543,6 +547,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 +562,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 +595,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 09:33:18 +0000
@@ -57,11 +57,12 @@
 
         :param old_generation: The generation of the database in the old
             state.
-        :return: (cur_generation, [(doc_id, generation),...])
+        :return: (cur_generation, [(doc_id, generation, trans_id),...])
             The current generation of the database, and a list of of
             changed documents since old_generation, represented by tuples
-            with for each document its doc_id and the generation corresponding
-            to the last intervening change and sorted by generation
+            with for each document its doc_id and the generation and
+            transaction id corresponding to the last intervening change and
+            sorted by generation (old changes first)
         """
         raise NotImplementedError(self.whats_changed)
 
@@ -216,29 +217,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 +345,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 +367,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 09:33:18 +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 09:33:18 +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 09:33:18 +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)
@@ -203,7 +207,7 @@
         generation = cur_generation
         for doc_id, trans_id in reversed(relevant_tail):
             if doc_id not in seen:
-                changes.append((doc_id, generation))
+                changes.append((doc_id, generation, trans_id))
                 seen.add(doc_id)
             generation -= 1
         changes.reverse()
@@ -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 09:33:18 +0000
@@ -355,16 +355,17 @@
 
     def whats_changed(self, old_generation=0):
         c = self._db_handle.cursor()
-        c.execute("SELECT generation, doc_id FROM transaction_log"
+        c.execute("SELECT generation, doc_id, transaction_id"
+                  " FROM transaction_log"
                   " WHERE generation > ? ORDER BY generation DESC",
                   (old_generation,))
         results = c.fetchall()
         cur_gen = old_generation
         seen = set()
         changes = []
-        for generation, doc_id in results:
+        for generation, doc_id, trans_id in results:
             if doc_id not in seen:
-                changes.append((doc_id, generation))
+                changes.append((doc_id, generation, trans_id))
                 seen.add(doc_id)
         if changes:
             cur_gen = changes[0][1]  # max generation
@@ -409,26 +410,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 +615,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 09:33:18 +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 09:33:18 +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 09:33:18 +0000
@@ -86,28 +86,28 @@
         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
-        changed_doc_ids = [doc_id for doc_id, _ in changes]
+        changed_doc_ids = [doc_id for doc_id, _, _ in changes]
         # prepare to send all the changed docs
         docs_to_send = self.source.get_docs(changed_doc_ids,
             check_for_conflicts=False)
-        docs_by_generation = zip(docs_to_send, (gen for _, gen in changes))
+        docs_by_generation = zip(docs_to_send, (gen for _, gen, _ in changes))
 
         # exchange documents and try to insert the returned ones with
         # the target, return target synced-up-to 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)
@@ -206,10 +206,10 @@
         self.new_gen = gen
         seen_ids = self.seen_ids
         # changed docs that weren't superseded by or converged with
-        self.changes_to_return = [(doc_id, gen) for (doc_id, gen)  in changes
-                                         if doc_id not in seen_ids or
-                                         # there was a subsequent update
-                                            seen_ids.get(doc_id) < gen]
+        self.changes_to_return = [(doc_id, gen) for (doc_id, gen, _) in changes
+                                  # there was a subsequent update
+                                  if doc_id not in seen_ids or
+                                     seen_ids.get(doc_id) < gen]
         return self.new_gen
 
     def return_docs(self, return_doc_cb):

=== modified file 'u1db/tests/__init__.py'
--- u1db/tests/__init__.py	2012-05-17 15:13:42 +0000
+++ u1db/tests/__init__.py	2012-05-18 09:33:18 +0000
@@ -177,6 +177,10 @@
             seen_transactions.add(transaction_id)
         self.assertEqual(doc_ids, just_ids)
 
+    def getLastTransId(self, db):
+        """Return the transaction id for the last database update."""
+        return self.db._get_transaction_log()[-1][-1]
+
 
 class ServerStateForTests(server_state.ServerState):
     """Used in the test suite, so we don't have to touch disk, etc."""

=== 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 09:33:18 +0000
@@ -61,8 +61,6 @@
     ctypedef int (*u1db_key_callback)(void *context, char *key)
     ctypedef int (*u1db_doc_gen_callback)(void *context,
         u1db_document *doc, int gen)
-    ctypedef int (*u1db_doc_id_gen_callback)(void *context,
-        const_char_ptr doc_id, int gen)
     ctypedef int (*u1db_trans_info_callback)(void *context,
         const_char_ptr doc_id, int gen, const_char_ptr trans_id)
 
@@ -85,7 +83,7 @@
                          int n_revs, const_char_ptr *revs)
     int u1db_delete_doc(u1database *db, u1db_document *doc)
     int u1db_whats_changed(u1database *db, int *gen, void *context,
-                           u1db_doc_id_gen_callback cb)
+                           u1db_trans_info_callback cb)
     int u1db__get_transaction_log(u1database *db, void *context,
                                   u1db_trans_info_callback cb)
     int u1db_get_doc_conflicts(u1database *db, char *doc_id, void *context,
@@ -156,9 +154,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 +190,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)
@@ -253,14 +252,6 @@
 from sqlite3 import dbapi2
 
 
-cdef int _append_doc_gen_to_list(void *context, const_char_ptr doc_id,
-                                 int generation) with gil:
-    a_list = <object>(context)
-    doc = doc_id
-    a_list.append((doc, generation))
-    return 0
-
-
 cdef int _append_trans_info_to_list(void *context, const_char_ptr doc_id,
                                     int generation,
                                     const_char_ptr trans_id) with gil:
@@ -665,22 +656,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):
@@ -952,7 +948,7 @@
         c_generation = generation
         handle_status("whats_changed",
             u1db_whats_changed(self._db, &c_generation, <void*>a_list,
-                               _append_doc_gen_to_list))
+                               _append_trans_info_to_list))
         return c_generation, a_list
 
     def _get_transaction_log(self):
@@ -968,16 +964,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 09:33:18 +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)
@@ -329,13 +330,17 @@
         doc.content = '{"something": "else"}'
         self.db.put_doc(doc)
         self.assertTransactionLog([doc.doc_id, doc.doc_id], self.db)
-        self.assertEqual((2, [(doc.doc_id, 2)]), self.db.whats_changed())
+        last_trans_id = self.getLastTransId(self.db)
+        self.assertEqual((2, [(doc.doc_id, 2, last_trans_id)]),
+                         self.db.whats_changed())
 
     def test_delete_updates_transaction_log(self):
         doc = self.db.create_doc(simple_doc)
         db_gen, _ = self.db.whats_changed()
         self.db.delete_doc(doc)
-        self.assertEqual((2, [(doc.doc_id, 2)]), self.db.whats_changed(db_gen))
+        last_trans_id = self.getLastTransId(self.db)
+        self.assertEqual((2, [(doc.doc_id, 2, last_trans_id)]),
+                         self.db.whats_changed(db_gen))
 
     def test_whats_changed_initial_database(self):
         self.assertEqual((0, []), self.db.whats_changed())
@@ -344,7 +349,9 @@
         doc = self.db.create_doc(simple_doc)
         doc.content = '{"new": "contents"}'
         self.db.put_doc(doc)
-        self.assertEqual((2, [(doc.doc_id, 2)]), self.db.whats_changed())
+        last_trans_id = self.getLastTransId(self.db)
+        self.assertEqual((2, [(doc.doc_id, 2, last_trans_id)]),
+                         self.db.whats_changed())
         self.assertEqual((2, []), self.db.whats_changed(2))
 
     def test_whats_changed_returns_last_edits_ascending(self):
@@ -352,15 +359,19 @@
         doc1 = self.db.create_doc(simple_doc)
         doc.content = '{"new": "contents"}'
         self.db.delete_doc(doc1)
+        delete_trans_id = self.getLastTransId(self.db)
         self.db.put_doc(doc)
-        self.assertEqual((4, [(doc1.doc_id, 3), (doc.doc_id, 4)]),
+        put_trans_id = self.getLastTransId(self.db)
+        self.assertEqual((4, [(doc1.doc_id, 3, delete_trans_id),
+                              (doc.doc_id, 4, put_trans_id)]),
                          self.db.whats_changed())
 
-    def test_whats_changed_doesnt_includ_old_gen(self):
+    def test_whats_changed_doesnt_include_old_gen(self):
         self.db.create_doc(simple_doc)
         self.db.create_doc(simple_doc)
         doc2 = self.db.create_doc(simple_doc)
-        self.assertEqual((3, [(doc2.doc_id, 3)]),
+        last_trans_id = self.getLastTransId(self.db)
+        self.assertEqual((3, [(doc2.doc_id, 3, last_trans_id)]),
                          self.db.whats_changed(2))
 
 
@@ -568,7 +579,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 +590,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 09:33:18 +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 09:33:18 +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 09:33:18 +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 09:33:18 +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 09:33:18 +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')