mongoc_client_t *
mongoc_client_pool_pop (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
mongoc_mutex_lock(&pool->mutex);
again:
if (!(client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
if (pool->size < pool->max_pool_size) {
client = _mongoc_client_new_from_uri(pool->uri, pool->topology);
client->error_api_version = pool->error_api_version;
_mongoc_client_set_apm_callbacks_private (client,
&pool->apm_callbacks,
pool->apm_context);
#ifdef MONGOC_ENABLE_SSL
if (pool->ssl_opts_set) {
mongoc_client_set_ssl_opts (client, &pool->ssl_opts);
}
#endif
pool->size++;
} else {
mongoc_cond_wait(&pool->cond, &pool->mutex);
GOTO(again);
}
}
mongoc_mutex_unlock(&pool->mutex);
RETURN(client);
}
mongoc_client_t *
mongoc_client_pool_try_pop (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
mongoc_mutex_lock(&pool->mutex);
if (!(client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
if (pool->size < pool->max_pool_size) {
client = _mongoc_client_new_from_uri(pool->uri, pool->topology);
#ifdef MONGOC_ENABLE_SSL
if (pool->ssl_opts_set) {
mongoc_client_set_ssl_opts (client, &pool->ssl_opts);
}
#endif
pool->size++;
}
}
mongoc_mutex_unlock(&pool->mutex);
RETURN(client);
}
mongoc_client_t *
mongoc_client_new (const char *uri_string)
{
const mongoc_write_concern_t *write_concern;
mongoc_client_t *client;
mongoc_uri_t *uri;
const bson_t *options;
bson_iter_t iter;
bool has_ssl = false;
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!(uri = mongoc_uri_new(uri_string))) {
return NULL;
}
options = mongoc_uri_get_options (uri);
if (bson_iter_init_find (&iter, options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter)) {
has_ssl = true;
}
client = bson_malloc0(sizeof *client);
client->uri = uri;
client->request_id = rand ();
client->initiator = mongoc_client_default_stream_initiator;
client->initiator_data = client;
write_concern = mongoc_uri_get_write_concern (uri);
client->write_concern = mongoc_write_concern_copy (write_concern);
client->read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
_mongoc_cluster_init (&client->cluster, client->uri, client);
#ifdef MONGOC_ENABLE_SSL
if (has_ssl) {
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
static bson_bool_t
ha_replica_set_get_status (ha_replica_set_t *replica_set,
bson_t *status)
{
mongoc_database_t *db;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_bool_t ret = FALSE;
ha_node_t *node;
bson_t cmd;
char *uristr;
bson_init(&cmd);
bson_append_int32(&cmd, "replSetGetStatus", -1, 1);
for (node = replica_set->nodes; !ret && node; node = node->next) {
uristr = bson_strdup_printf("mongodb://127.0.0.1:%hu/?slaveOk=true",
node->port);
client = mongoc_client_new(uristr);
#ifdef MONGOC_ENABLE_SSL
if (replica_set->ssl_opt) {
mongoc_client_set_ssl_opts(client, replica_set->ssl_opt);
}
#endif
bson_free(uristr);
db = mongoc_client_get_database(client, "admin");
if ((cursor = mongoc_database_command(db,
MONGOC_QUERY_SLAVE_OK,
0,
1,
&cmd,
NULL,
NULL))) {
if (mongoc_cursor_next(cursor, &doc)) {
bson_copy_to(doc, status);
ret = TRUE;
}
mongoc_cursor_destroy(cursor);
}
mongoc_database_destroy(db);
mongoc_client_destroy(client);
}
return ret;
}
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_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_write_concern_t *write_concern;
#ifdef MONGOC_ENABLE_SSL
const bson_t *options;
bson_iter_t iter;
#endif
BSON_ASSERT (uri);
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_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
options = mongoc_uri_get_options (client->uri);
if (bson_iter_init_find (&iter, options, "ssl") &&
BSON_ITER_HOLDS_BOOL (&iter) &&
bson_iter_bool (&iter)) {
mongoc_client_set_ssl_opts (client, mongoc_ssl_opt_get_default ());
}
#endif
mongoc_counter_clients_active_inc ();
return client;
}
SEXP R_mongo_client_new(SEXP uri_string) {
mongoc_client_t *client = mongoc_client_new (translateCharUTF8(asChar(uri_string)));
if(!client)
stop("Invalid uri_string. Try mongodb://localhost");
//set ssl certificates here
if (mongoc_uri_get_ssl (mongoc_client_get_uri(client))) {
mongoc_client_set_ssl_opts(client, mongoc_ssl_opt_get_default());
}
//verify that server is online
//can fail if user has limited priv
/*
bson_error_t err;
if(!mongoc_client_get_server_status(client, NULL, NULL, &err)){
mongoc_client_destroy(client);
stop(err.message);
}
*/
return client2r(client);
}
mongoc_client_t *
ha_replica_set_create_client (ha_replica_set_t *replica_set)
{
mongoc_client_t *client;
bson_string_t *str;
ha_node_t *iter;
char *portstr;
str = bson_string_new("mongodb://");
for (iter = replica_set->nodes; iter; iter = iter->next) {
bson_string_append(str, "127.0.0.1:");
portstr = bson_strdup_printf("%hu", iter->port);
bson_string_append(str, portstr);
bson_free(portstr);
if (iter->next) {
bson_string_append(str, ",");
}
}
bson_string_append(str, "/?replicaSet=");
bson_string_append(str, replica_set->name);
client = mongoc_client_new(str->str);
#ifdef MONGOC_ENABLE_SSL
if (replica_set->ssl_opt) {
mongoc_client_set_ssl_opts(client, replica_set->ssl_opt);
}
#endif
bson_string_free(str, TRUE);
return client;
}
/*
* Connect to MongoDB server using Host/ip and Port number.
*/
MONGO_CONN*
MongoConnect(const char* host, const unsigned short port, char* databaseName, char *user, char *password, char *readPreference, bool ssl, char *pem_file,
char *pem_pwd, char *ca_file, char *ca_dir, char *crl_file, bool weak_cert_validation)
{
MONGO_CONN *client = NULL;
char* uri = NULL;
if (user && password && readPreference)
uri = bson_strdup_printf ("mongodb://%s:%s@%s:%hu/%s?readPreference=%s&ssl=%s", user, password, host, port, databaseName, readPreference, ssl ? "true" : "false");
else if (user && password)
uri = bson_strdup_printf ("mongodb://%s:%s@%s:%hu/%s?ssl=%s", user, password, host, port, databaseName, ssl ? "true" : "false");
else if (readPreference)
uri = bson_strdup_printf ("mongodb://%s:%hu/%s?readPreference=%s&ssl=%s", host, port, databaseName, readPreference, ssl ? "true" : "false");
else
uri = bson_strdup_printf ("mongodb://%s:%hu/%s?ssl=%s", host, port, databaseName, ssl ? "true" : "false");
client = mongoc_client_new(uri);
if (ssl) {
mongoc_ssl_opt_t *ssl_opts = (mongoc_ssl_opt_t*) malloc(sizeof(mongoc_ssl_opt_t));
ssl_opts->pem_file = pem_file;
ssl_opts->pem_pwd = pem_pwd;
ssl_opts->ca_file = ca_file;
ssl_opts->ca_dir = ca_dir;
ssl_opts->crl_file = crl_file;
ssl_opts->weak_cert_validation = weak_cert_validation;
mongoc_client_set_ssl_opts (client, ssl_opts);
free(ssl_opts);
}
bson_free(uri);
if (client == NULL)
ereport(ERROR, (errmsg("could not connect to %s:%d", host, port),
errhint("Mongo driver connection error")));
return client;
}
static void
ha_replica_set_configure (ha_replica_set_t *replica_set,
ha_node_t *primary)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
bson_iter_t iter;
ha_node_t *node;
bson_t ar;
bson_t cmd;
bson_t config;
bson_t member;
char *str;
char *uristr;
char hoststr[32];
char key[8];
int i = 0;
uristr = bson_strdup_printf("mongodb://127.0.0.1:%hu/", primary->port);
client = mongoc_client_new(uristr);
#ifdef MONGOC_ENABLE_SSL
if (replica_set->ssl_opt) {
mongoc_client_set_ssl_opts(client, replica_set->ssl_opt);
}
#endif
bson_free(uristr);
bson_init(&cmd);
bson_append_document_begin(&cmd, "replSetInitiate", -1, &config);
bson_append_utf8(&config, "_id", 3, replica_set->name, -1);
bson_append_array_begin(&config, "members", -1, &ar);
for (node = replica_set->nodes; node; node = node->next) {
snprintf(key, sizeof key, "%u", i);
key[sizeof key - 1] = '\0';
snprintf(hoststr, sizeof hoststr, "127.0.0.1:%hu", node->port);
hoststr[sizeof hoststr - 1] = '\0';
bson_append_document_begin(&ar, key, -1, &member);
bson_append_int32(&member, "_id", -1, i);
bson_append_utf8(&member, "host", -1, hoststr, -1);
bson_append_bool(&member, "arbiterOnly", -1, node->is_arbiter);
bson_append_document_end(&ar, &member);
i++;
}
bson_append_array_end(&config, &ar);
bson_append_document_end(&cmd, &config);
str = bson_as_json(&cmd, NULL);
MONGOC_DEBUG("Config: %s", str);
bson_free(str);
database = mongoc_client_get_database(client, "admin");
again:
cursor = mongoc_database_command(database,
MONGOC_QUERY_NONE,
0,
1,
&cmd,
NULL,
NULL);
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
MONGOC_DEBUG("Reply: %s", str);
bson_free(str);
if (bson_iter_init_find(&iter, doc, "ok") &&
bson_iter_as_bool(&iter)) {
goto cleanup;
}
}
if (mongoc_cursor_error(cursor, &error)) {
mongoc_cursor_destroy(cursor);
MONGOC_WARNING("%s: Retrying in 1 second.", error.message);
sleep(1);
goto again;
}
cleanup:
mongoc_cursor_destroy(cursor);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
bson_destroy(&cmd);
}
static bool hippo_mongo_driver_manager_apply_ssl_opts(mongoc_client_t *client, const Array options)
{
mongoc_ssl_opt_t ssl_opt = { NULL, NULL, NULL, NULL, NULL, true };
Array ssl;
bool apply_ssl = false;
if (!mongoc_uri_get_ssl(mongoc_client_get_uri(client))) {
return 0;
}
if (options.exists(s_MongoDBDriverManager_context)) {
Array context;
if (!options[s_MongoDBDriverManager_context].isResource()) {
return 0;
}
#if HIPPO_HHVM_VERSION >= 30900
req::ptr<StreamContext> sc;
#else
SmartPtr<StreamContext> sc;
#endif
sc = cast<StreamContext>(options[s_MongoDBDriverManager_context]);
context = sc->getOptions();
if (!context.exists(s_MongoDBDriverManager_context_ssl)) {
return 0;
}
if (!context[s_MongoDBDriverManager_context_ssl].isArray()) {
return 0;
}
ssl = context[s_MongoDBDriverManager_context_ssl].toArray();
} else {
ssl = options;
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_allow_self_signed) && ssl[s_MongoDBDriverManager_context_ssl_allow_self_signed].isBoolean()) {
apply_ssl = true;
ssl_opt.weak_cert_validation = (bool)true;//ssl[s_MongoDBDriverManager_context_ssl_allow_self_signed].toBoolean();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_local_cert) && ssl[s_MongoDBDriverManager_context_ssl_local_cert].isString()) {
apply_ssl = true;
ssl_opt.pem_file = ssl[s_MongoDBDriverManager_context_ssl_local_cert].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_passphrase) && ssl[s_MongoDBDriverManager_context_ssl_passphrase].isString()) {
apply_ssl = true;
ssl_opt.pem_pwd = ssl[s_MongoDBDriverManager_context_ssl_passphrase].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_cafile) && ssl[s_MongoDBDriverManager_context_ssl_cafile].isString()) {
apply_ssl = true;
ssl_opt.ca_file = ssl[s_MongoDBDriverManager_context_ssl_cafile].toString().c_str();
}
if (ssl.exists(s_MongoDBDriverManager_context_ssl_capath) && ssl[s_MongoDBDriverManager_context_ssl_capath].isString()) {
apply_ssl = true;
ssl_opt.ca_dir = ssl[s_MongoDBDriverManager_context_ssl_capath].toString().c_str();
}
if (apply_ssl) {
mongoc_client_set_ssl_opts(client, &ssl_opt);
}
return 1;
}