CDRIVER-407 only include GLE in write concern when needed

TylerBrock · TylerBrock · commit 7e2c32ac3ce6 · 2014-09-29T18:05:29.000-04:00
diff --git a/src/mongoc/mongoc-cluster.c b/src/mongoc/mongoc-cluster.c
@@ -2565,7 +2565,7 @@ _mongoc_cluster_sendv (mongoc_cluster_t             *cluster,
          gle.query.collection = cmdname;
          gle.query.skip = 0;
          gle.query.n_return = 1;
-         b = _mongoc_write_concern_freeze((void*)write_concern);
+         b = _mongoc_write_concern_get_gle((void*)write_concern);
          gle.query.query = bson_get_data(b);
          gle.query.fields = NULL;
          _mongoc_rpc_gather(&gle, &cluster->iov);
@@ -2704,7 +2704,7 @@ _mongoc_cluster_try_sendv (mongoc_cluster_t             *cluster,
          gle.query.skip = 0;
          gle.query.n_return = 1;
 
-         b = _mongoc_write_concern_freeze ((void *)write_concern);
+         b = _mongoc_write_concern_get_gle ((void *)write_concern);
 
          gle.query.query = bson_get_data (b);
          gle.query.fields = NULL;
diff --git a/src/mongoc/mongoc-write-command.c b/src/mongoc/mongoc-write-command.c
@@ -37,7 +37,7 @@
    (((n)->min_wire_version <= 2) && ((n)->max_wire_version >= 2))
 #define WRITE_CONCERN_DOC(wc) \
    (wc && _mongoc_write_concern_needs_gle ((wc))) ? \
-   (_mongoc_write_concern_freeze((mongoc_write_concern_t*)(wc))) : \
+   (_mongoc_write_concern_get_bson((mongoc_write_concern_t*)(wc))) : \
    (&gEmptyWriteConcern)
 
 
diff --git a/src/mongoc/mongoc-write-concern-private.h b/src/mongoc/mongoc-write-concern-private.h
@@ -39,11 +39,12 @@ struct _mongoc_write_concern_t
    char     *wtag;
    bool      frozen;
    bson_t    compiled;
+   bson_t    compiled_gle;
 };
 
 
-const bson_t *_mongoc_write_concern_freeze  (mongoc_write_concern_t       *write_concern);
-
+const bson_t *_mongoc_write_concern_get_gle   (mongoc_write_concern_t       *write_cocnern);
+const bson_t *_mongoc_write_concern_get_bson  (mongoc_write_concern_t       *write_concern);
 bool          _mongoc_write_concern_needs_gle (const mongoc_write_concern_t *write_concern);
 
 BSON_END_DECLS
diff --git a/src/mongoc/mongoc-write-concern.c b/src/mongoc/mongoc-write-concern.c
@@ -30,6 +30,9 @@ _mongoc_write_concern_warn_frozen (mongoc_write_concern_t *write_concern)
    return write_concern->frozen;
 }
 
+static void
+_mongoc_write_concern_freeze (mongoc_write_concern_t *write_concern);
+
 
 /**
  * mongoc_write_concern_new:
@@ -82,6 +85,7 @@ mongoc_write_concern_destroy (mongoc_write_concern_t *write_concern)
    if (write_concern) {
       if (write_concern->compiled.len) {
          bson_destroy (&write_concern->compiled);
+         bson_destroy (&write_concern->compiled_gle);
       }
 
       bson_free (write_concern->wtag);
@@ -261,62 +265,104 @@ mongoc_write_concern_set_wtag (mongoc_write_concern_t *write_concern,
    }
 }
 
+/**
+ * mongoc_write_concern_get_bson:
+ * @write_concern: A mongoc_write_concern_t.
+ *
+ * This is an internal function.
+ *
+ * Freeze the write concern if necessary and retrieve the encoded bson_t
+ * representing the write concern.
+ *
+ * You may not modify the write concern further after calling this function.
+ *
+ * Returns: A bson_t that should not be modified or freed as it is owned by
+ *    the mongoc_write_concern_t instance.
+ */
+const bson_t *
+_mongoc_write_concern_get_bson (mongoc_write_concern_t *write_concern) {
+   if (!write_concern->frozen) {
+       _mongoc_write_concern_freeze(write_concern);
+   }
+
+   return &write_concern->compiled;
+}
 
 /**
- * mongoc_write_concern_freeze:
+ * mongoc_write_concern_get_gle:
  * @write_concern: A mongoc_write_concern_t.
  *
  * This is an internal function.
  *
- * Freeze the write concern if necessary and compile the getlasterror command
- * associated with it.
+ * Freeze the write concern if necessary and retrieve the encoded bson_t
+ * representing the write concern as a get last error command.
  *
  * You may not modify the write concern further after calling this function.
  *
  * Returns: A bson_t that should not be modified or freed as it is owned by
  *    the mongoc_write_concern_t instance.
  */
 const bson_t *
+_mongoc_write_concern_get_gle (mongoc_write_concern_t *write_concern) {
+   if (!write_concern->frozen) {
+       _mongoc_write_concern_freeze(write_concern);
+   }
+
+   return &write_concern->compiled_gle;
+}
+
+/**
+ * mongoc_write_concern_freeze:
+ * @write_concern: A mongoc_write_concern_t.
+ *
+ * This is an internal function.
+ *
+ * Freeze the write concern if necessary and encode it into a bson_ts which
+ * represent the raw bson form and the get last error command form.
+ *
+ * You may not modify the write concern further after calling this function.
+ */
+static void
 _mongoc_write_concern_freeze (mongoc_write_concern_t *write_concern)
 {
-   bson_t *b;
+   bson_t *compiled;
+   bson_t *compiled_gle;
 
    bson_return_val_if_fail(write_concern, NULL);
 
-   b = &write_concern->compiled;
+   compiled = &write_concern->compiled;
+   compiled_gle = &write_concern->compiled_gle;
 
-   if (!write_concern->frozen) {
-      write_concern->frozen = true;
-
-      bson_init (b);
+   write_concern->frozen = true;
 
-      BSON_APPEND_INT32 (b, "getlasterror", 1);
+   bson_init (compiled);
+   bson_init (compiled_gle);
 
-      if (write_concern->w == MONGOC_WRITE_CONCERN_W_TAG) {
-         BSON_ASSERT (write_concern->wtag);
-         BSON_APPEND_UTF8 (b, "w", write_concern->wtag);
-      } else if (write_concern->w == MONGOC_WRITE_CONCERN_W_MAJORITY) {
-         BSON_APPEND_UTF8 (b, "w", "majority");
-      } else if (write_concern->w == MONGOC_WRITE_CONCERN_W_DEFAULT) {
-         /* Do Nothing */
-      } else if (write_concern->w > 0) {
-         BSON_APPEND_INT32 (b, "w", write_concern->w);
-      }
+   if (write_concern->w == MONGOC_WRITE_CONCERN_W_TAG) {
+      BSON_ASSERT (write_concern->wtag);
+      BSON_APPEND_UTF8 (compiled, "w", write_concern->wtag);
+   } else if (write_concern->w == MONGOC_WRITE_CONCERN_W_MAJORITY) {
+      BSON_APPEND_UTF8 (compiled, "w", "majority");
+   } else if (write_concern->w == MONGOC_WRITE_CONCERN_W_DEFAULT) {
+      /* Do Nothing */
+   } else if (write_concern->w > 0) {
+      BSON_APPEND_INT32 (compiled, "w", write_concern->w);
+   }
 
-      if (write_concern->fsync_) {
-         bson_append_bool(b, "fsync", 5, true);
-      }
+   if (write_concern->fsync_) {
+      bson_append_bool(compiled, "fsync", 5, true);
+   }
 
-      if (write_concern->journal) {
-         bson_append_bool(b, "j", 1, true);
-      }
+   if (write_concern->journal) {
+      bson_append_bool(compiled, "j", 1, true);
+   }
 
-      if (write_concern->wtimeout) {
-         bson_append_int32(b, "wtimeout", 8, write_concern->wtimeout);
-      }
+   if (write_concern->wtimeout) {
+      bson_append_int32(compiled, "wtimeout", 8, write_concern->wtimeout);
    }
 
-   return b;
+   BSON_APPEND_INT32 (compiled_gle, "getlasterror", 1);
+   bson_concat (compiled_gle, compiled);
 }
 
 
diff --git a/tests/test-libmongoc.c b/tests/test-libmongoc.c
@@ -145,6 +145,7 @@ main (int   argc,
    test_rpc_install (&suite);
    test_stream_install (&suite);
    test_uri_install (&suite);
+   test_write_concern_install (&suite);
 #ifdef MONGOC_ENABLE_SSL
    test_x509_install (&suite);
    test_stream_tls_install (&suite);
diff --git a/tests/test-mongoc-write-concern.c b/tests/test-mongoc-write-concern.c
@@ -8,7 +8,8 @@ static void
 test_write_concern_basic (void)
 {
    mongoc_write_concern_t *write_concern;
-   const bson_t *b;
+   const bson_t *gle;
+   const bson_t *bson;
    bson_iter_t iter;
 
    write_concern = mongoc_write_concern_new();
@@ -55,11 +56,19 @@ test_write_concern_basic (void)
     */
    mongoc_write_concern_set_fsync(write_concern, true);
    mongoc_write_concern_set_journal(write_concern, true);
-   b = _mongoc_write_concern_freeze(write_concern);
-   ASSERT(bson_iter_init_find(&iter, b, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
-   ASSERT(bson_iter_init_find(&iter, b, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
-   ASSERT(bson_iter_init_find(&iter, b, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
-   ASSERT(b);
+   gle = _mongoc_write_concern_get_gle(write_concern);
+   ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);
+   ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
+   ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
+   ASSERT(bson_iter_init_find(&iter, gle, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
+   ASSERT(gle);
+
+   bson = _mongoc_write_concern_get_bson(write_concern);
+   ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));
+   ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
+   ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));
+   ASSERT(bson_iter_init_find(&iter, bson, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);
+   ASSERT(bson);
 
    mongoc_write_concern_destroy(write_concern);
 }
diff --git a/tests/test-replica-set.c b/tests/test-replica-set.c
@@ -38,7 +38,7 @@ insert_test_docs (mongoc_collection_t *collection)
       const bson_t *wc;
       char *str;
 
-      wc = _mongoc_write_concern_freeze(write_concern);
+      wc = _mongoc_write_concern_get_gle(write_concern);
       str = bson_as_json(wc, NULL);
       fprintf(stderr, "Write Concern: %s\n", str);
       bson_free(str);
