static mongoc_write_concern_t *
create_commit_retry_wc (const mongoc_write_concern_t *existing_wc)
{
mongoc_write_concern_t *wc;
int32_t wtimeout;
wc = existing_wc ? mongoc_write_concern_copy (existing_wc)
: mongoc_write_concern_new ();
wtimeout = mongoc_write_concern_get_wtimeout (wc);
/* Transactions spec: "If the modified write concern does not include a
* wtimeout value, drivers MUST also apply wtimeout: 10000 to the write
* concern in order to avoid waiting forever if the majority write concern
* cannot be satisfied." */
if (wtimeout <= 0) {
wtimeout = MONGOC_DEFAULT_WTIMEOUT_FOR_COMMIT_RETRY;
}
/* Transactions spec: "If the transaction is using a write concern that is
* not the server default, any other write concern options MUST be left as-is
* when applying w:majority. */
mongoc_write_concern_set_wmajority (wc, wtimeout);
return wc;
}
static void
test_write_concern_wtimeout_validity (void)
{
mongoc_write_concern_t *write_concern = mongoc_write_concern_new();
/* Test defaults */
ASSERT(write_concern);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
/* mongoc_write_concern_set_wtimeout() ignores invalid wtimeout */
mongoc_write_concern_set_wtimeout(write_concern, -1);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
/* mongoc_write_concern_set_wmajority() ignores invalid wtimeout */
mongoc_write_concern_set_wmajority(write_concern, -1);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_MAJORITY);
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 0);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_is_valid (write_concern));
/* Manually assigning a negative wtimeout will make the write concern invalid */
write_concern->wtimeout = -1;
ASSERT(!mongoc_write_concern_is_valid (write_concern));
mongoc_write_concern_destroy(write_concern);
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *b;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
/*
* Test defaults.
*/
assert(write_concern);
assert(!mongoc_write_concern_get_fsync(write_concern));
assert(!mongoc_write_concern_get_journal(write_concern));
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, TRUE);
assert(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, FALSE);
assert(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, TRUE);
assert(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, FALSE);
assert(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
assert(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
assert(mongoc_write_concern_get_wmajority(write_concern));
assert(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
assert(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
assert(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
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);
mongoc_write_concern_destroy(write_concern);
}
static void
test_write_concern_basic (void)
{
mongoc_write_concern_t *write_concern;
const bson_t *gle;
const bson_t *bson;
bson_iter_t iter;
write_concern = mongoc_write_concern_new();
BEGIN_IGNORE_DEPRECATIONS;
/*
* Test defaults.
*/
ASSERT(write_concern);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
ASSERT(!mongoc_write_concern_get_journal(write_concern));
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_fsync(write_concern, true);
ASSERT(mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_fsync(write_concern, false);
ASSERT(!mongoc_write_concern_get_fsync(write_concern));
mongoc_write_concern_set_journal(write_concern, true);
ASSERT(mongoc_write_concern_get_journal(write_concern));
mongoc_write_concern_set_journal(write_concern, false);
ASSERT(!mongoc_write_concern_get_journal(write_concern));
/*
* Test changes to w.
*/
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(!mongoc_write_concern_get_wmajority(write_concern));
mongoc_write_concern_set_wmajority(write_concern, 1000);
ASSERT(mongoc_write_concern_get_wmajority(write_concern));
ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 1000);
mongoc_write_concern_set_wtimeout(write_concern, 0);
ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));
mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);
ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);
mongoc_write_concern_set_w(write_concern, 3);
ASSERT(mongoc_write_concern_get_w(write_concern) == 3);
/*
* Check generated bson.
*/
mongoc_write_concern_set_fsync(write_concern, true);
mongoc_write_concern_set_journal(write_concern, true);
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);
END_IGNORE_DEPRECATIONS;
}
int
main ()
{
bson_t empty = BSON_INITIALIZER;
const bson_t *doc;
bson_t *to_insert = BCON_NEW ("x", BCON_INT32 (1));
const bson_t *err_doc;
bson_error_t error;
const char *uri_string;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_collection_t *coll;
mongoc_change_stream_t *stream;
mongoc_write_concern_t *wc = mongoc_write_concern_new ();
bson_t opts = BSON_INITIALIZER;
bool r;
mongoc_init ();
uri_string = "mongodb://"
"localhost:27017,localhost:27018,localhost:"
"27019/db?replicaSet=rs0";
uri = mongoc_uri_new_with_error (uri_string, &error);
if (!uri) {
fprintf (stderr,
"failed to parse URI: %s\n"
"error message: %s\n",
uri_string,
error.message);
return EXIT_FAILURE;
}
client = mongoc_client_new_from_uri (uri);
if (!client) {
return EXIT_FAILURE;
}
coll = mongoc_client_get_collection (client, "db", "coll");
stream = mongoc_collection_watch (coll, &empty, NULL);
mongoc_write_concern_set_wmajority (wc, 10000);
mongoc_write_concern_append (wc, &opts);
r = mongoc_collection_insert_one (coll, to_insert, &opts, NULL, &error);
if (!r) {
fprintf (stderr, "Error: %s\n", error.message);
return EXIT_FAILURE;
}
while (mongoc_change_stream_next (stream, &doc)) {
char *as_json = bson_as_relaxed_extended_json (doc, NULL);
fprintf (stderr, "Got document: %s\n", as_json);
bson_free (as_json);
}
if (mongoc_change_stream_error_document (stream, &error, &err_doc)) {
if (!bson_empty (err_doc)) {
fprintf (stderr,
"Server Error: %s\n",
bson_as_relaxed_extended_json (err_doc, NULL));
} else {
fprintf (stderr, "Client Error: %s\n", error.message);
}
return EXIT_FAILURE;
}
bson_destroy (to_insert);
mongoc_write_concern_destroy (wc);
bson_destroy (&opts);
mongoc_change_stream_destroy (stream);
mongoc_collection_destroy (coll);
mongoc_uri_destroy (uri);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
static void
_mongoc_uri_build_write_concern (mongoc_uri_t *uri) /* IN */
{
mongoc_write_concern_t *write_concern;
const char *str;
bson_iter_t iter;
int32_t wtimeoutms;
int value;
BSON_ASSERT (uri);
write_concern = mongoc_write_concern_new ();
if (bson_iter_init_find_case (&iter, &uri->options, "safe") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_w (write_concern,
bson_iter_bool (&iter) ? 1 : MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
wtimeoutms = mongoc_uri_get_option_as_int32(uri, "wtimeoutms", 0);
if (bson_iter_init_find_case (&iter, &uri->options, "journal") &&
BSON_ITER_HOLDS_BOOL (&iter)) {
mongoc_write_concern_set_journal (write_concern, bson_iter_bool (&iter));
}
if (bson_iter_init_find_case (&iter, &uri->options, "w")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
value = bson_iter_int32 (&iter);
switch (value) {
case MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED:
case MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED:
/* Warn on conflict, since write concern will be validated later */
if (mongoc_write_concern_get_journal(write_concern)) {
MONGOC_WARNING("Journal conflicts with w value [w=%d].", value);
}
mongoc_write_concern_set_w(write_concern, value);
break;
default:
if (value > 0) {
mongoc_write_concern_set_w (write_concern, value);
if (value > 1) {
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
break;
}
MONGOC_WARNING ("Unsupported w value [w=%d].", value);
break;
}
} else if (BSON_ITER_HOLDS_UTF8 (&iter)) {
str = bson_iter_utf8 (&iter, NULL);
if (0 == strcasecmp ("majority", str)) {
mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
} else {
mongoc_write_concern_set_wtag (write_concern, str);
mongoc_write_concern_set_wtimeout (write_concern, wtimeoutms);
}
} else {
BSON_ASSERT (false);
}
}
uri->write_concern = write_concern;
}
static bool hippo_mongo_driver_manager_apply_wc(mongoc_uri_t *uri, const Array options)
{
int32_t wtimeoutms;
mongoc_write_concern_t *new_wc;
const mongoc_write_concern_t *old_wc;
if (!(old_wc = mongoc_uri_get_write_concern(uri))) {
throw MongoDriver::Utils::throwRunTimeException("mongoc_uri_t does not have a write concern");
return false;
}
if (options.size() == 0) {
return true;
}
if (
!options.exists(s_MongoDBDriverManager_journal) &&
!options.exists(s_MongoDBDriverManager_safe) &&
!options.exists(s_MongoDBDriverManager_w) &&
!options.exists(s_MongoDBDriverManager_wtimeoutms)
) {
return true;
}
wtimeoutms = mongoc_write_concern_get_wtimeout(old_wc);
new_wc = mongoc_write_concern_copy(old_wc);
if (options.exists(s_MongoDBDriverManager_safe) && options[s_MongoDBDriverManager_safe].isBoolean()) {
mongoc_write_concern_set_w(new_wc, options[s_MongoDBDriverManager_safe].toBoolean() ? 1 : MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
if (options.exists(s_MongoDBDriverManager_wtimeoutms) && options[s_MongoDBDriverManager_wtimeoutms].isInteger()) {
wtimeoutms = (int32_t) options[s_MongoDBDriverManager_wtimeoutms].toInt64();
}
if (options.exists(s_MongoDBDriverManager_journal) && options[s_MongoDBDriverManager_journal].isBoolean()) {
mongoc_write_concern_set_journal(new_wc, !!options[s_MongoDBDriverManager_journal].toBoolean());
}
if (options.exists(s_MongoDBDriverManager_w)) {
if (options[s_MongoDBDriverManager_w].isInteger()) {
int32_t value = (int32_t) options[s_MongoDBDriverManager_w].toInt64();
switch (value) {
case MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED:
case MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED:
mongoc_write_concern_set_w(new_wc, value);
break;
default:
if (value > 0) {
mongoc_write_concern_set_w(new_wc, value);
break;
}
throw MongoDriver::Utils::throwInvalidArgumentException("Unsupported w value: " + Variant(value).toString());
mongoc_write_concern_destroy(new_wc);
return false;
}
} else if (options[s_MongoDBDriverManager_w].isString()) {
const char *str = options[s_MongoDBDriverManager_w].toString().c_str();
if (0 == strcasecmp("majority", str)) {
mongoc_write_concern_set_wmajority(new_wc, wtimeoutms);
} else {
mongoc_write_concern_set_wtag(new_wc, str);
}
}
}
/* Only set wtimeout if it's still applicable; otherwise, clear it. */
if (mongoc_write_concern_get_w(new_wc) > 1 ||
mongoc_write_concern_get_wmajority(new_wc) ||
mongoc_write_concern_get_wtag(new_wc)) {
mongoc_write_concern_set_wtimeout(new_wc, wtimeoutms);
} else {
mongoc_write_concern_set_wtimeout(new_wc, 0);
}
if (mongoc_write_concern_get_journal(new_wc)) {
int32_t w = mongoc_write_concern_get_w(new_wc);
if (w == MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED || w == MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED) {
throw MongoDriver::Utils::throwInvalidArgumentException("Journal conflicts with w value: " + Variant(w).toString());
mongoc_write_concern_destroy(new_wc);
return false;
}
}
/* This may be redundant in light of the last check (unacknowledged w with
* journal), but we'll check anyway in case additional validation is
* implemented. */
if (!mongoc_write_concern_is_valid(new_wc)) {
throw MongoDriver::Utils::throwInvalidArgumentException("Write concern is not valid");
mongoc_write_concern_destroy(new_wc);
return false;
}
mongoc_uri_set_write_concern(uri, new_wc);
mongoc_write_concern_destroy(new_wc);
return true;
}
static void
_mongoc_uri_build_write_concern (mongoc_uri_t *uri) /* IN */
{
mongoc_write_concern_t *write_concern;
const char *str;
bson_iter_t iter;
int32_t wtimeoutms = 0;
int value;
BSON_ASSERT (uri);
write_concern = mongoc_write_concern_new ();
if (bson_iter_init_find_case (&iter, &uri->options, "safe") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
!bson_iter_bool (&iter)) {
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
}
if (bson_iter_init_find_case (&iter, &uri->options, "wtimeoutms") &&
BSON_ITER_HOLDS_INT32 (&iter)) {
wtimeoutms = bson_iter_int32 (&iter);
}
if (bson_iter_init_find_case (&iter, &uri->options, "w")) {
if (BSON_ITER_HOLDS_INT32 (&iter)) {
value = bson_iter_int32 (&iter);
switch (value) {
case -1:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED);
break;
case 0:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED);
break;
case 1:
mongoc_write_concern_set_w (write_concern,
MONGOC_WRITE_CONCERN_W_DEFAULT);
break;
default:
if (value > 1) {
mongoc_write_concern_set_w (write_concern, value);
break;
}
MONGOC_WARNING ("Unsupported w value [w=%d].", value);
break;
}
} else if (BSON_ITER_HOLDS_UTF8 (&iter)) {
str = bson_iter_utf8 (&iter, NULL);
if (0 == strcasecmp ("majority", str)) {
mongoc_write_concern_set_wmajority (write_concern, wtimeoutms);
} else {
mongoc_write_concern_set_wtag (write_concern, str);
}
} else {
BSON_ASSERT (false);
}
}
uri->write_concern = write_concern;
}
