static void
test_read_concern_always_mutable (void)
{
mongoc_read_concern_t *read_concern;
read_concern = mongoc_read_concern_new ();
ASSERT (read_concern);
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'local'}");
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_MAJORITY);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'majority'}");
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LINEARIZABLE);
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'linearizable'}");
mongoc_read_concern_destroy (read_concern);
}
void
mongoc_database_destroy (mongoc_database_t *database)
{
ENTRY;
BSON_ASSERT (database);
if (database->read_prefs) {
mongoc_read_prefs_destroy(database->read_prefs);
database->read_prefs = NULL;
}
if (database->read_concern) {
mongoc_read_concern_destroy(database->read_concern);
database->read_concern = NULL;
}
if (database->write_concern) {
mongoc_write_concern_destroy(database->write_concern);
database->write_concern = NULL;
}
bson_free(database);
EXIT;
}
static void
test_read_concern_basic (void)
{
mongoc_read_concern_t *read_concern;
read_concern = mongoc_read_concern_new ();
BEGIN_IGNORE_DEPRECATIONS;
/*
* Test defaults.
*/
ASSERT (read_concern);
ASSERT (mongoc_read_concern_is_default (read_concern));
ASSERT (!mongoc_read_concern_get_level (read_concern));
/*
* Test changes to level.
*/
mongoc_read_concern_set_level (read_concern,
MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT (!mongoc_read_concern_is_default (read_concern));
ASSERT_CMPSTR (mongoc_read_concern_get_level (read_concern),
MONGOC_READ_CONCERN_LEVEL_LOCAL);
/*
* Check generated bson.
*/
ASSERT_MATCH (_mongoc_read_concern_get_bson (read_concern),
"{'level': 'local'}");
mongoc_read_concern_destroy (read_concern);
}
void
mongoc_transaction_opts_set_read_concern (
mongoc_transaction_opt_t *opts, const mongoc_read_concern_t *read_concern)
{
BSON_ASSERT (opts);
mongoc_read_concern_destroy (opts->read_concern);
opts->read_concern = mongoc_read_concern_copy (read_concern);
}
void
mongoc_uri_set_read_concern (mongoc_uri_t *uri,
const mongoc_read_concern_t *rc)
{
BSON_ASSERT (uri);
BSON_ASSERT (rc);
mongoc_read_concern_destroy (uri->read_concern);
uri->read_concern = mongoc_read_concern_copy (rc);
}
static void
txn_opts_cleanup (mongoc_transaction_opt_t *opts)
{
/* null inputs are ok */
mongoc_read_concern_destroy (opts->read_concern);
mongoc_write_concern_destroy (opts->write_concern);
mongoc_read_prefs_destroy (opts->read_prefs);
/* prepare opts for reuse */
opts->read_concern = NULL;
opts->write_concern = NULL;
opts->read_prefs = NULL;
}
void
mongoc_client_set_read_concern (mongoc_client_t *client,
const mongoc_read_concern_t *read_concern)
{
BSON_ASSERT (client);
if (read_concern != client->read_concern) {
if (client->read_concern) {
mongoc_read_concern_destroy (client->read_concern);
}
client->read_concern = read_concern ?
mongoc_read_concern_copy (read_concern) :
mongoc_read_concern_new ();
}
}
void
mongoc_database_set_read_concern (mongoc_database_t *database,
const mongoc_read_concern_t *read_concern)
{
BSON_ASSERT (database);
if (database->read_concern) {
mongoc_read_concern_destroy (database->read_concern);
database->read_concern = NULL;
}
if (read_concern) {
database->read_concern = mongoc_read_concern_copy (read_concern);
}
}
void
mongoc_change_stream_destroy (mongoc_change_stream_t *stream)
{
if (!stream) {
return;
}
bson_destroy (&stream->pipeline_to_append);
bson_destroy (&stream->resume_token);
bson_destroy (stream->full_document);
bson_destroy (&stream->err_doc);
_mongoc_change_stream_opts_cleanup (&stream->opts);
mongoc_cursor_destroy (stream->cursor);
mongoc_client_session_destroy (stream->implicit_session);
mongoc_read_prefs_destroy (stream->read_prefs);
mongoc_read_concern_destroy (stream->read_concern);
bson_free (stream);
}
static void
test_read_concern_bson_omits_defaults (void)
{
mongoc_read_concern_t *read_concern;
const bson_t *bson;
bson_iter_t iter;
read_concern = mongoc_read_concern_new ();
/*
* Check generated bson.
*/
ASSERT (read_concern);
bson = _mongoc_read_concern_get_bson (read_concern);
ASSERT (bson);
ASSERT (!bson_iter_init_find (&iter, bson, "level"));
mongoc_read_concern_destroy (read_concern);
}
static bool hippo_mongo_driver_manager_apply_rc(mongoc_uri_t *uri, const Array options)
{
mongoc_read_concern_t *new_rc;
const mongoc_read_concern_t *old_rc;
const char *rc_str = NULL;
if (!(old_rc = mongoc_uri_get_read_concern(uri))) {
throw MongoDriver::Utils::throwRunTimeException("mongoc_uri_t does not have a read concern");
return false;
}
if (options.size() == 0) {
return true;
}
if (
!options.exists(s_MongoDBDriverManager_readConcernLevel) &&
!options.exists(s_MongoDBDriverManager_readconcernlevel)
) {
return true;
}
new_rc = mongoc_read_concern_copy(old_rc);
if (options.exists(s_MongoDBDriverManager_readconcernlevel) && options[s_MongoDBDriverManager_readconcernlevel].isString()) {
rc_str = options[s_MongoDBDriverManager_readconcernlevel].toString().c_str();
}
if (options.exists(s_MongoDBDriverManager_readConcernLevel) && options[s_MongoDBDriverManager_readConcernLevel].isString()) {
rc_str = options[s_MongoDBDriverManager_readConcernLevel].toString().c_str();
}
if (rc_str) {
mongoc_read_concern_set_level(new_rc, rc_str);
}
mongoc_uri_set_read_concern(uri, new_rc);
mongoc_read_concern_destroy(new_rc);
return true;
}
void
mongoc_uri_destroy (mongoc_uri_t *uri)
{
if (uri) {
_mongoc_host_list_destroy_all (uri->hosts);
bson_free(uri->str);
bson_free(uri->database);
bson_free(uri->username);
bson_destroy(&uri->options);
bson_destroy(&uri->credentials);
mongoc_read_prefs_destroy(uri->read_prefs);
mongoc_read_concern_destroy(uri->read_concern);
mongoc_write_concern_destroy(uri->write_concern);
if (uri->password) {
bson_zero_free(uri->password, strlen(uri->password));
}
bson_free(uri);
}
}
static void
test_read_concern_append (void)
{
mongoc_read_concern_t *rc;
bson_t *cmd;
cmd = tmp_bson ("{'foo': 1}");
/* append default readConcern */
rc = mongoc_read_concern_new ();
ASSERT (mongoc_read_concern_is_default (rc));
ASSERT_MATCH (cmd, "{'foo': 1, 'readConcern': {'$exists': false}}");
/* append readConcern with level */
mongoc_read_concern_set_level (rc, MONGOC_READ_CONCERN_LEVEL_LOCAL);
ASSERT (mongoc_read_concern_append (rc, cmd));
ASSERT_MATCH (cmd, "{'foo': 1, 'readConcern': {'level': 'local'}}");
mongoc_read_concern_destroy (rc);
}
void
mongoc_client_destroy (mongoc_client_t *client)
{
if (client) {
#ifdef MONGOC_ENABLE_SSL
bson_free (client->pem_subject);
#endif
if (client->topology->single_threaded) {
mongoc_topology_destroy(client->topology);
}
mongoc_write_concern_destroy (client->write_concern);
mongoc_read_concern_destroy (client->read_concern);
mongoc_read_prefs_destroy (client->read_prefs);
mongoc_cluster_destroy (&client->cluster);
mongoc_uri_destroy (client->uri);
bson_free (client);
mongoc_counter_clients_active_dec ();
mongoc_counter_clients_disposed_inc ();
}
}
