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; }