mongoc_uri_t *
mongoc_uri_copy (const mongoc_uri_t *uri)
{
mongoc_uri_t *copy;
mongoc_host_list_t *iter;
BSON_ASSERT (uri);
copy = (mongoc_uri_t *)bson_malloc0(sizeof (*copy));
copy->str = bson_strdup (uri->str);
copy->username = bson_strdup (uri->username);
copy->password = bson_strdup (uri->password);
copy->database = bson_strdup (uri->database);
copy->read_prefs = mongoc_read_prefs_copy (uri->read_prefs);
copy->read_concern = mongoc_read_concern_copy (uri->read_concern);
copy->write_concern = mongoc_write_concern_copy (uri->write_concern);
for (iter = uri->hosts; iter; iter = iter->next) {
mongoc_uri_append_host (copy, iter->host, iter->port);
}
bson_copy_to (&uri->options, ©->options);
bson_copy_to (&uri->credentials, ©->credentials);
return copy;
}
mongoc_database_t *
_mongoc_database_new (mongoc_client_t *client,
const char *name,
const mongoc_read_prefs_t *read_prefs,
const mongoc_read_concern_t *read_concern,
const mongoc_write_concern_t *write_concern)
{
mongoc_database_t *db;
ENTRY;
BSON_ASSERT (client);
BSON_ASSERT (name);
db = (mongoc_database_t *)bson_malloc0(sizeof *db);
db->client = client;
db->write_concern = write_concern ?
mongoc_write_concern_copy(write_concern) :
mongoc_write_concern_new();
db->read_concern = read_concern ?
mongoc_read_concern_copy(read_concern) :
mongoc_read_concern_new();
db->read_prefs = read_prefs ?
mongoc_read_prefs_copy(read_prefs) :
mongoc_read_prefs_new(MONGOC_READ_PRIMARY);
bson_strncpy (db->name, name, sizeof db->name);
RETURN(db);
}
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_copy (const mongoc_transaction_opt_t *src,
mongoc_transaction_opt_t *dst)
{
txn_opts_cleanup (dst);
/* null inputs are ok for these copy functions */
dst->read_concern = mongoc_read_concern_copy (src->read_concern);
dst->write_concern = mongoc_write_concern_copy (src->write_concern);
dst->read_prefs = mongoc_read_prefs_copy (src->read_prefs);
}
Object HHVM_METHOD(MongoDBDriverManager, getReadConcern)
{
MongoDBDriverManagerData *data = Native::data<MongoDBDriverManagerData>(this_);
Class *c_rc = Unit::lookupClass(s_MongoDriverReadConcern_className.get());
assert(c_rc);
Object rc_obj = Object{c_rc};
MongoDBDriverReadConcernData* rc_data = Native::data<HPHP::MongoDBDriverReadConcernData>(rc_obj.get());
rc_data->m_read_concern = mongoc_read_concern_copy(mongoc_client_get_read_concern(data->m_client));
return rc_obj;
}
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);
}
}
mongoc_client_t *
_mongoc_client_new_from_uri (const mongoc_uri_t *uri, mongoc_topology_t *topology)
{
mongoc_client_t *client;
const mongoc_read_prefs_t *read_prefs;
const mongoc_read_concern_t *read_concern;
const mongoc_write_concern_t *write_concern;
BSON_ASSERT (uri);
#ifndef MONGOC_ENABLE_SSL
if (mongoc_uri_get_ssl (uri)) {
MONGOC_ERROR ("Can't create SSL client, SSL not enabled in this build.");
return NULL;
}
#endif
client = (mongoc_client_t *)bson_malloc0(sizeof *client);
client->uri = mongoc_uri_copy (uri);
client->request_id = rand ();
client->initiator = mongoc_client_default_stream_initiator;
client->initiator_data = client;
client->topology = topology;
write_concern = mongoc_uri_get_write_concern (client->uri);
client->write_concern = mongoc_write_concern_copy (write_concern);
read_concern = mongoc_uri_get_read_concern (client->uri);
client->read_concern = mongoc_read_concern_copy (read_concern);
read_prefs = mongoc_uri_get_read_prefs_t (client->uri);
client->read_prefs = mongoc_read_prefs_copy (read_prefs);
mongoc_cluster_init (&client->cluster, client->uri, client);
#ifdef MONGOC_ENABLE_SSL
client->use_ssl = false;
if (mongoc_uri_get_ssl (client->uri)) {
/* sets use_ssl = true */
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
mongoc_change_stream_t *
_mongoc_change_stream_new_from_client (mongoc_client_t *client,
const bson_t *pipeline,
const bson_t *opts)
{
mongoc_change_stream_t *stream;
BSON_ASSERT (client);
stream =
(mongoc_change_stream_t *) bson_malloc0 (sizeof (mongoc_change_stream_t));
bson_strncpy (stream->db, "admin", sizeof (stream->db));
stream->coll[0] = '\0';
stream->read_prefs = mongoc_read_prefs_copy (client->read_prefs);
stream->read_concern = mongoc_read_concern_copy (client->read_concern);
stream->client = client;
stream->change_stream_type = MONGOC_CHANGE_STREAM_CLIENT;
_change_stream_init (stream, pipeline, opts);
return stream;
}
mongoc_change_stream_t *
_mongoc_change_stream_new_from_database (const mongoc_database_t *db,
const bson_t *pipeline,
const bson_t *opts)
{
mongoc_change_stream_t *stream;
BSON_ASSERT (db);
stream =
(mongoc_change_stream_t *) bson_malloc0 (sizeof (mongoc_change_stream_t));
bson_strncpy (stream->db, db->name, sizeof (stream->db));
stream->coll[0] = '\0';
stream->read_prefs = mongoc_read_prefs_copy (db->read_prefs);
stream->read_concern = mongoc_read_concern_copy (db->read_concern);
stream->client = db->client;
stream->change_stream_type = MONGOC_CHANGE_STREAM_DATABASE;
_change_stream_init (stream, pipeline, opts);
return stream;
}
mongoc_change_stream_t *
_mongoc_change_stream_new_from_collection (const mongoc_collection_t *coll,
const bson_t *pipeline,
const bson_t *opts)
{
mongoc_change_stream_t *stream;
BSON_ASSERT (coll);
stream =
(mongoc_change_stream_t *) bson_malloc0 (sizeof (mongoc_change_stream_t));
bson_strncpy (stream->db, coll->db, sizeof (stream->db));
bson_strncpy (stream->coll, coll->collection, sizeof (stream->coll));
stream->read_prefs = mongoc_read_prefs_copy (coll->read_prefs);
stream->read_concern = mongoc_read_concern_copy (coll->read_concern);
stream->client = coll->client;
stream->change_stream_type = MONGOC_CHANGE_STREAM_COLLECTION;
_change_stream_init (stream, pipeline, opts);
return stream;
}
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;
}
