mongoc_uri_t *
mongoc_uri_new (const char *uri_string)
{
mongoc_uri_t *uri;
uri = bson_malloc0(sizeof *uri);
bson_init(&uri->options);
bson_init(&uri->credentials);
bson_init(&uri->read_prefs);
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!mongoc_uri_parse(uri, uri_string)) {
mongoc_uri_destroy(uri);
return NULL;
}
_mongoc_uri_build_write_concern (uri);
if (!_mongoc_write_concern_is_valid(uri->write_concern)) {
mongoc_uri_destroy(uri);
return NULL;
}
uri->str = bson_strdup(uri_string);
return uri;
}
static void
_test_read_prefs_op_msg (read_pref_test_type_t test_type,
mongoc_read_prefs_t *read_prefs,
const char *query_in,
const char *expected_query,
mongoc_query_flags_t expected_query_flags,
const char *expected_find_cmd,
mongoc_query_flags_t expected_find_cmd_query_flags,
const char *expected_op_msg)
{
mock_server_t *server;
mongoc_uri_t *uri;
server = _run_server (test_type, 3);
uri = _get_uri (server, test_type);
_test_op_query (
uri, server, query_in, read_prefs, expected_query_flags, expected_query);
if (_can_be_command (query_in)) {
_test_command (uri,
server,
query_in,
read_prefs,
expected_query_flags,
expected_query);
_test_command_simple (uri,
server,
query_in,
read_prefs,
expected_query_flags,
expected_query);
}
mock_server_destroy (server);
mongoc_uri_destroy (uri);
server = _run_server (test_type, 4);
uri = _get_uri (server, test_type);
_test_find_command (uri,
server,
query_in,
read_prefs,
expected_find_cmd_query_flags,
expected_find_cmd);
mock_server_destroy (server);
server = _run_server (test_type, WIRE_VERSION_OP_MSG);
mongoc_uri_destroy (uri);
uri = _get_uri (server, test_type);
_test_op_msg (uri, server, query_in, read_prefs, expected_op_msg);
mock_server_destroy (server);
mongoc_uri_destroy (uri);
}
mongoc_uri_t *
mongoc_uri_new (const char *uri_string)
{
mongoc_uri_t *uri;
#ifdef MONGOC_EXPERIMENTAL_FEATURES
int32_t max_staleness_ms;
#endif
uri = (mongoc_uri_t *)bson_malloc0(sizeof *uri);
bson_init(&uri->options);
bson_init(&uri->credentials);
/* Initialize read_prefs since tag parsing may add to it */
uri->read_prefs = mongoc_read_prefs_new(MONGOC_READ_PRIMARY);
/* Initialize empty read_concern */
uri->read_concern = mongoc_read_concern_new ();
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!mongoc_uri_parse(uri, uri_string)) {
mongoc_uri_destroy(uri);
return NULL;
}
uri->str = bson_strdup(uri_string);
_mongoc_uri_assign_read_prefs_mode(uri);
#ifdef MONGOC_EXPERIMENTAL_FEATURES
max_staleness_ms = mongoc_uri_get_option_as_int32 (uri, "maxstalenessms", 0);
mongoc_read_prefs_set_max_staleness_ms (uri->read_prefs, max_staleness_ms);
#endif
if (!mongoc_read_prefs_is_valid(uri->read_prefs)) {
mongoc_uri_destroy(uri);
return NULL;
}
_mongoc_uri_build_write_concern (uri);
if (!mongoc_write_concern_is_valid (uri->write_concern)) {
mongoc_uri_destroy(uri);
return NULL;
}
return uri;
}
int64_t
execute (int argc,
char *argv[])
{
int64_t count = 0;
const char *uristr = MONGODB_DEFAULT_URI;
const char *database_name;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_database_t *db;
bson_t bson_schema;
bson_error_t error;
int argi;
uristr = getenv ("MONGODB_URI");
uri = mongoc_uri_new (uristr);
client = mongoc_client_new (uristr);
database_name = mongoc_uri_get_database (uri);
db = mongoc_client_get_database (client, database_name);
bson_init_from_json_file (&bson_schema, schema_file) || WARN_ERROR;
for (argi = 0; argi < argc; argi++) {
fprintf (stderr, "[%d/%d] %s\n", argi + 1, argc, argv[argi]);
count += load_table (db, argv[argi], &bson_schema);
}
bson_destroy (&bson_schema);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_uri_destroy (uri);
return count;
}
static void MongoFree(MONGO * info) {
if(info) {
if(info->uri) mongoc_uri_destroy(info->uri);
if(info->client) mongoc_client_destroy(info->client);
turn_free(info, sizeof(MONGO));
}
}
void
mongoc_client_pool_destroy (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
while ((client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
mongoc_client_destroy(client);
}
mongoc_topology_destroy (pool->topology);
mongoc_uri_destroy(pool->uri);
mongoc_mutex_destroy(&pool->mutex);
mongoc_cond_destroy(&pool->cond);
#ifdef MONGOC_ENABLE_SSL
_mongoc_ssl_opts_cleanup (&pool->ssl_opts);
#endif
bson_free(pool);
mongoc_counter_client_pools_active_dec();
mongoc_counter_client_pools_disposed_inc();
EXIT;
}
SOFT_BEGIN_NAMESPACE
MONGO_BEGIN_NAMESPACE
static void uriDeleter (mongoc_uri_t * ptr)
{
mongoc_uri_destroy (ptr);
}
void
mongoc_client_pool_destroy (mongoc_client_pool_t *pool)
{
mongoc_client_t *client;
ENTRY;
BSON_ASSERT (pool);
while ((client = (mongoc_client_t *)_mongoc_queue_pop_head(&pool->queue))) {
mongoc_client_destroy(client);
}
mongoc_topology_destroy (pool->topology);
mongoc_uri_destroy(pool->uri);
mongoc_mutex_destroy(&pool->mutex);
mongoc_cond_destroy(&pool->cond);
bson_free(pool);
mongoc_counter_client_pools_active_dec();
mongoc_counter_client_pools_disposed_inc();
EXIT;
}
int
main (int argc,
char *argv[])
{
mongoc_read_prefs_t *read_prefs;
mongoc_client_t *client;
mongoc_uri_t *uri;
if (argc < 2) {
fprintf(stderr, "usage: %s mongodb://...\n", argv[0]);
return EXIT_FAILURE;
}
uri = mongoc_uri_new(argv[1]);
if (!uri) {
fprintf(stderr, "Invalid URI: \"%s\"\n", argv[1]);
return EXIT_FAILURE;
}
signal(SIGUSR1, sighandler);
signal(SIGUSR2, sighandler);
client = mongoc_client_new_from_uri(uri);
read_prefs = mongoc_read_prefs_new(MONGOC_READ_SECONDARY);
mongoc_client_set_read_prefs(client, read_prefs);
mongoc_read_prefs_destroy(read_prefs);
test_secondary(client);
mongoc_client_destroy(client);
mongoc_uri_destroy(uri);
return EXIT_SUCCESS;
}
bool
_mongoc_host_list_from_string (mongoc_host_list_t *host_list,
const char *host_and_port)
{
bool rval = false;
char *uri_str = NULL;
mongoc_uri_t *uri = NULL;
const mongoc_host_list_t *uri_hl;
BSON_ASSERT (host_list);
BSON_ASSERT (host_and_port);
uri_str = bson_strdup_printf("mongodb://%s/", host_and_port);
if (! uri_str) goto CLEANUP;
uri = mongoc_uri_new(uri_str);
if (! uri) goto CLEANUP;
uri_hl = mongoc_uri_get_hosts(uri);
if (uri_hl->next) goto CLEANUP;
memcpy(host_list, uri_hl, sizeof(*uri_hl));
rval = true;
CLEANUP:
bson_free(uri_str);
if (uri) mongoc_uri_destroy(uri);
return rval;
}
static void
test_mongoc_metadata_append_after_cmd (void)
{
mongoc_client_pool_t *pool;
mongoc_client_t *client;
mongoc_uri_t *uri;
_reset_metadata ();
uri = mongoc_uri_new ("mongodb://127.0.0.1?maxpoolsize=1&minpoolsize=1");
pool = mongoc_client_pool_new (uri);
/* Make sure that after we pop a client we can't set global metadata */
pool = mongoc_client_pool_new (uri);
client = mongoc_client_pool_pop (pool);
ASSERT (!mongoc_metadata_append ("a", "a", "a"));
mongoc_client_pool_push (pool, client);
mongoc_uri_destroy (uri);
mongoc_client_pool_destroy (pool);
_reset_metadata ();
}
static void
multi_download_setup (perf_test_t *test)
{
multi_download_test_t *download_test;
multi_download_thread_context_t *ctx;
mongoc_uri_t *uri;
int i;
_setup_load_gridfs_files ();
perf_test_setup (test);
download_test = (multi_download_test_t *) test;
uri = mongoc_uri_new (NULL);
download_test->pool = mongoc_client_pool_new (uri);
download_test->cnt = 50; /* DANGER!: assumes test corpus won't change */
download_test->contexts = (multi_download_thread_context_t *) bson_malloc0 (
download_test->cnt * sizeof (multi_download_thread_context_t));
for (i = 0; i < download_test->cnt; i++) {
ctx = &download_test->contexts[i];
ctx->filename = bson_strdup_printf ("file%d.txt", i);
ctx->path = bson_strdup_printf ("%s/%s", test->data_path, ctx->filename);
}
mongoc_uri_destroy (uri);
}
int
main (int argc,
char *argv[])
{
mongoc_client_pool_t *pool;
mongoc_client_t *client;
mongoc_uri_t *uri;
unsigned count = 10000;
if (argc > 1) {
if (!(uri = mongoc_uri_new(argv[1]))) {
fprintf(stderr, "Failed to parse uri: %s\n", argv[1]);
return 1;
}
} else {
uri = mongoc_uri_new("mongodb://127.0.0.1:27017/?sockettimeoutms=500");
}
if (argc > 2) {
count = MAX(atoi(argv[2]), 1);
}
pool = mongoc_client_pool_new(uri);
client = mongoc_client_pool_pop(pool);
test_load(client, count);
mongoc_client_pool_push(pool, client);
mongoc_uri_destroy(uri);
mongoc_client_pool_destroy(pool);
return 0;
}
int
main (int argc,
char *argv[])
{
const char *default_uristr = "mongodb://localhost/test";
char *uristr;
const char *database_name;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_database_t *db;
mongoc_collection_t *collection;
mongoc_init ();
uristr = getenv ("MONGODB_URI");
uristr = uristr ? uristr : (char*)default_uristr;
uri = mongoc_uri_new (uristr);
client = mongoc_client_new_from_uri (uri);
database_name = mongoc_uri_get_database (uri);
db = mongoc_client_get_database (client, database_name);
collection = mongoc_database_get_collection (db, "test");
test_suite (db, collection);
mongoc_collection_destroy (collection);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_uri_destroy (uri);
mongoc_cleanup ();
return 0;
}
void *be_mongo_init()
{
struct mongo_backend *conf;
conf = (struct mongo_backend *)malloc(sizeof(struct mongo_backend));
conf->database = strdup(be_mongo_get_option("mongo_database", NULL, "mqGate"));
conf->user_coll = strdup(be_mongo_get_option("mongo_user_coll", "mongo_collection_users", "users"));
conf->topiclist_coll = strdup(be_mongo_get_option("mongo_topiclist_coll", "mongo_collection_topics", "topics"));
conf->user_username_prop = strdup(be_mongo_get_option("mongo_user_username_prop", NULL, "username"));
conf->user_password_prop = strdup(be_mongo_get_option("mongo_user_password_prop", "mongo_location_password", "password"));
conf->user_superuser_prop = strdup(be_mongo_get_option("mongo_user_superuser_prop", "mongo_location_superuser", "superuser"));
conf->user_topics_prop = strdup(be_mongo_get_option("mongo_user_topics_prop", NULL, "topics"));
conf->user_topiclist_fk_prop = strdup(be_mongo_get_option("mongo_user_topiclist_fk_prop", "mongo_location_topic", "topics"));
conf->topiclist_key_prop = strdup(be_mongo_get_option("mongo_topiclist_key_prop", "mongo_location_superuser", "_id"));
conf->topiclist_topics_prop = strdup(be_mongo_get_option("mongo_topiclist_topics_prop", "mongo_location_topic", "topics"));
mongoc_init();
mongoc_uri_t *uri = be_mongo_new_uri_from_options();
if (!uri) {
_fatal("MongoDB connection options invalid");
}
conf->client = mongoc_client_new_from_uri(uri);
mongoc_uri_destroy(uri);
return (conf);
}
dbproxy::dbproxy(boost::shared_ptr<config::config> _config) {
mongoc_init();
mongoc_uri_t * _uri = mongoc_uri_new_for_host_port(_config->get_value_string("ip").c_str(), _config->get_value_int("port"));
_client = mongoc_client_new(mongoc_uri_get_string(_uri));
mongoc_uri_destroy(_uri);
_db = mongoc_client_get_database(_client, _config->get_value_string("db").c_str());
}
static void
multi_upload_setup (perf_test_t *test)
{
multi_upload_test_t *upload_test;
multi_upload_thread_context_t *ctx;
mongoc_uri_t *uri;
char *data_dir;
DIR *dirp;
struct dirent *dp;
int i;
perf_test_setup (test);
upload_test = (multi_upload_test_t *) test;
uri = mongoc_uri_new (NULL);
upload_test->pool = mongoc_client_pool_new (uri);
data_dir = bson_strdup_printf ("%s/%s", g_test_dir, test->data_path);
dirp = opendir(data_dir);
if (!dirp) {
perror ("opening data path");
abort ();
}
i = 0;
while ((dp = readdir(dirp)) != NULL) {
if (!strcmp (get_ext (dp->d_name), "txt")) {
++i;
}
}
upload_test->cnt = i;
upload_test->contexts = (multi_upload_thread_context_t *) bson_malloc0 (
i * sizeof (multi_upload_thread_context_t));
rewinddir (dirp);
i = 0;
while ((dp = readdir (dirp)) != NULL) {
if (!strcmp (get_ext (dp->d_name), "txt")) {
ctx = &upload_test->contexts[i];
ctx->filename = bson_strdup (dp->d_name);
ctx->path = bson_strdup_printf (
"%s/%s/%s", g_test_dir, test->data_path, dp->d_name);
++i;
}
}
assert (i == upload_test->cnt);
closedir (dirp);
bson_free (data_dir);
mongoc_uri_destroy (uri);
}
mongoc_uri_t *
mongoc_uri_new (const char *uri_string)
{
mongoc_uri_t *uri;
uri = (mongoc_uri_t *)bson_malloc0(sizeof *uri);
bson_init(&uri->options);
bson_init(&uri->credentials);
/* Initialize read_prefs since tag parsing may add to it */
uri->read_prefs = mongoc_read_prefs_new(MONGOC_READ_PRIMARY);
/* Initialize empty read_concern */
uri->read_concern = mongoc_read_concern_new ();
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!mongoc_uri_parse(uri, uri_string)) {
mongoc_uri_destroy(uri);
return NULL;
}
uri->str = bson_strdup(uri_string);
_mongoc_uri_assign_read_prefs_mode(uri);
if (!mongoc_read_prefs_is_valid(uri->read_prefs)) {
mongoc_uri_destroy(uri);
return NULL;
}
_mongoc_uri_build_write_concern (uri);
if (!mongoc_write_concern_is_valid (uri->write_concern)) {
mongoc_uri_destroy(uri);
return NULL;
}
return uri;
}
static void
test_mongoc_uri_write_concern (void)
{
const mongoc_write_concern_t *wr;
mongoc_uri_t *uri;
const write_concern_test *t;
int i;
static const write_concern_test tests [] = {
{ "mongodb://localhost/?safe=false", true, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?safe=true", true, 1 },
{ "mongodb://localhost/?w=-1", true, MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED },
{ "mongodb://localhost/?w=0", true, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?w=1", true, 1 },
{ "mongodb://localhost/?w=2", true, 2 },
{ "mongodb://localhost/?w=majority", true, MONGOC_WRITE_CONCERN_W_MAJORITY },
{ "mongodb://localhost/?w=10", true, 10 },
{ "mongodb://localhost/?w=", true, MONGOC_WRITE_CONCERN_W_DEFAULT },
{ "mongodb://localhost/?w=mytag", true, MONGOC_WRITE_CONCERN_W_TAG, "mytag" },
{ "mongodb://localhost/?w=mytag&safe=false", true, MONGOC_WRITE_CONCERN_W_TAG, "mytag" },
{ "mongodb://localhost/?w=1&safe=false", true, 1 },
{ "mongodb://localhost/?journal=true", true, MONGOC_WRITE_CONCERN_W_DEFAULT },
{ "mongodb://localhost/?w=0&journal=true", false, MONGOC_WRITE_CONCERN_W_UNACKNOWLEDGED },
{ "mongodb://localhost/?w=-1&journal=true", false, MONGOC_WRITE_CONCERN_W_ERRORS_IGNORED },
{ "mongodb://localhost/?w=1&journal=true", true, 1 },
{ NULL }
};
/* Suppress warnings from two invalid URIs ("journal" and "w" conflict) */
suppress_one_message();
suppress_one_message();
for (i = 0; tests [i].uri; i++) {
t = &tests [i];
uri = mongoc_uri_new (t->uri);
if (t->parses) {
assert (uri);
} else {
assert (!uri);
continue;
}
wr = mongoc_uri_get_write_concern (uri);
assert (wr);
assert (t->w == mongoc_write_concern_get_w (wr));
if (t->wtag) {
assert (0 == strcmp (t->wtag, mongoc_write_concern_get_wtag (wr)));
}
mongoc_uri_destroy (uri);
}
}
static void
test_mongoc_uri_new_for_host_port (void)
{
mongoc_uri_t *uri;
uri = mongoc_uri_new_for_host_port("uber", 555);
ASSERT(uri);
ASSERT(!strcmp("uber", mongoc_uri_get_hosts(uri)->host));
ASSERT(!strcmp("uber:555", mongoc_uri_get_hosts(uri)->host_and_port));
ASSERT(555 == mongoc_uri_get_hosts(uri)->port);
mongoc_uri_destroy(uri);
}
static PyObject *
pymongoc_client_pool_tp_new (PyTypeObject *self,
PyObject *args,
PyObject *kwargs)
{
pymongoc_client_pool_t *pyclient_pool;
mongoc_uri_t *uri;
const char *uri_str;
PyObject *key = NULL;
PyObject *pyuri = NULL;
PyObject *ret = NULL;
if (kwargs) {
key = PyString_FromStringAndSize("uri", 3);
if (PyDict_Contains(kwargs, key)) {
if (!(pyuri = PyDict_GetItem(kwargs, key))) {
goto cleanup;
} else if (!PyString_Check(pyuri)) {
PyErr_SetString(PyExc_TypeError, "uri must be a string.");
goto cleanup;
}
}
}
uri_str = pyuri ? PyString_AsString(pyuri) : NULL;
uri = mongoc_uri_new (uri_str);
pyclient_pool = (pymongoc_client_pool_t *)
PyType_GenericNew (&pymongoc_client_pool_type, NULL, NULL);
if (!pyclient_pool) {
goto cleanup;
}
pyclient_pool->client_pool = mongoc_client_pool_new (uri);
if (!pyclient_pool->client_pool) {
PyErr_SetString (PyExc_TypeError, "Invalid URI string.");
Py_DECREF (pyclient_pool);
pyclient_pool = NULL;
goto cleanup;
}
ret = (PyObject *)pyclient_pool;
cleanup:
if (uri) {
mongoc_uri_destroy (uri);
}
Py_XDECREF (key);
Py_XDECREF (pyuri);
return ret;
}
static void
test_mongoc_client_pool_basic (void)
{
mongoc_client_pool_t *pool;
mongoc_client_t *client;
mongoc_uri_t *uri;
uri = mongoc_uri_new("mongodb://127.0.0.1?maxpoolsize=1&minpoolsize=1");
pool = mongoc_client_pool_new(uri);
client = mongoc_client_pool_pop(pool);
assert(client);
mongoc_client_pool_push(pool, client);
mongoc_uri_destroy(uri);
mongoc_client_pool_destroy(pool);
}
void
mongoc_client_destroy (mongoc_client_t *client)
{
if (client) {
#ifdef MONGOC_ENABLE_SSL
bson_free (client->pem_subject);
#endif
mongoc_write_concern_destroy (client->write_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 ();
}
}
static void
test_clone (void)
{
mongoc_cursor_t *clone;
mongoc_cursor_t *cursor;
mongoc_client_t *client;
const bson_t *doc;
bson_error_t error;
mongoc_uri_t *uri;
bson_bool_t r;
bson_t q = BSON_INITIALIZER;
char *uristr;
uristr = bson_strdup_printf("mongodb://%s/", HOST);
uri = mongoc_uri_new(uristr);
bson_free(uristr);
client = mongoc_client_new_from_uri(uri);
BSON_ASSERT(client);
cursor = _mongoc_cursor_new(client, "test.test", MONGOC_QUERY_NONE, 0, 1, 1,
FALSE, &q, NULL, NULL);
BSON_ASSERT(cursor);
r = mongoc_cursor_next(cursor, &doc);
if (!r && mongoc_cursor_error(cursor, &error)) {
MONGOC_ERROR("%s", error.message);
abort();
}
clone = mongoc_cursor_clone(cursor);
BSON_ASSERT(cursor);
r = mongoc_cursor_next(clone, &doc);
if (!r && mongoc_cursor_error(clone, &error)) {
MONGOC_ERROR("%s", error.message);
abort();
}
mongoc_cursor_destroy(cursor);
mongoc_cursor_destroy(clone);
mongoc_client_destroy(client);
mongoc_uri_destroy(uri);
}
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
const char *uri_string = "mongodb://localhost/?appname=bulk-collation";
mongoc_uri_t *uri;
bson_error_t error;
mongoc_init ();
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;
}
mongoc_client_set_error_api (client, 2);
collection = mongoc_client_get_collection (client, "db", "collection");
bulk_collation (collection);
mongoc_uri_destroy (uri);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
/*
*--------------------------------------------------------------------------
*
* mongoc_client_new --
*
* Create a new mongoc_client_t using the URI provided.
*
* @uri should be a MongoDB URI string such as "mongodb://localhost/"
* More information on the format can be found at
* http://docs.mongodb.org/manual/reference/connection-string/
*
* Returns:
* A newly allocated mongoc_client_t or NULL if @uri_string is
* invalid.
*
* Side effects:
* None.
*
*--------------------------------------------------------------------------
*/
mongoc_client_t *
mongoc_client_new(const char *uri_string)
{
mongoc_topology_t *topology;
mongoc_client_t *client;
mongoc_uri_t *uri;
if (!uri_string) {
uri_string = "mongodb://127.0.0.1/";
}
if (!(uri = mongoc_uri_new (uri_string))) {
return NULL;
}
topology = mongoc_topology_new(uri, true);
client = _mongoc_client_new_from_uri (uri, topology);
mongoc_uri_destroy (uri);
return client;
}
static void
test_get_host (void)
{
const mongoc_host_list_t *hosts;
mongoc_host_list_t host;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
mongoc_uri_t *uri;
const bson_t *doc;
bson_error_t error;
bson_bool_t r;
bson_t q = BSON_INITIALIZER;
char *uristr;
uristr = bson_strdup_printf("mongodb://%s/", HOST);
uri = mongoc_uri_new(uristr);
bson_free(uristr);
hosts = mongoc_uri_get_hosts(uri);
client = mongoc_client_new_from_uri(uri);
cursor = _mongoc_cursor_new(client, "test.test", MONGOC_QUERY_NONE, 0, 1, 1,
FALSE, &q, NULL, NULL);
r = mongoc_cursor_next(cursor, &doc);
if (!r && mongoc_cursor_error(cursor, &error)) {
MONGOC_ERROR("%s", error.message);
abort();
}
mongoc_cursor_get_host(cursor, &host);
assert_cmpstr(host.host, hosts->host);
assert_cmpstr(host.host_and_port, hosts->host_and_port);
assert_cmpint(host.port, ==, hosts->port);
assert_cmpint(host.family, ==, hosts->family);
mongoc_uri_destroy(uri);
}
static void
_test_heartbeat_events (bool pooled,
bool succeeded)
{
context_t context;
mock_server_t *server;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_client_pool_t *pool = NULL;
future_t *future;
request_t *request;
char *expected_json;
bson_error_t error;
context_init (&context);
/* auto-respond to "foo" command */
server = mock_server_new ();
mock_server_run (server);
mock_server_autoresponds (server, responder, NULL, NULL);
uri = mongoc_uri_copy (mock_server_get_uri (server));
mongoc_uri_set_option_as_int32 (uri, "serverSelectionTimeoutMS", 400);
if (pooled) {
pool = mongoc_client_pool_new (uri);
pool_set_heartbeat_event_callbacks (pool, &context);
client = mongoc_client_pool_pop (pool);
} else {
client = mongoc_client_new_from_uri (uri);
client_set_heartbeat_event_callbacks (client, &context);
}
/* trigger "ismaster" handshake */
future = future_client_command_simple (client, "admin",
tmp_bson ("{'foo': 1}"),
NULL, NULL, &error);
/* topology scanner calls ismaster once */
request = mock_server_receives_ismaster (server);
if (succeeded) {
mock_server_replies_ok_and_destroys (request);
} else {
mock_server_hangs_up (request);
request_destroy (request);
}
/* pooled client opens new socket, handshakes it by calling ismaster again */
if (pooled && succeeded) {
request = mock_server_receives_ismaster (server);
mock_server_replies_ok_and_destroys (request);
}
if (succeeded) {
/* "foo" command succeeds */
ASSERT_OR_PRINT (future_get_bool (future), error);
} else {
ASSERT (!future_get_bool (future));
}
if (pooled) {
mongoc_client_pool_push (pool, client);
mongoc_client_pool_destroy (pool);
} else {
mongoc_client_destroy (client);
}
/* even if pooled, only topology scanner sends events, so we get one pair */
if (succeeded) {
expected_json = bson_strdup_printf (
"{'0': {'heartbeat_started_event': {'host': '%s'}},"
" '1': {'heartbeat_succeeded_event': {'host': '%s'}}}",
mock_server_get_host_and_port (server),
mock_server_get_host_and_port (server));
} else {
expected_json = bson_strdup_printf (
"{'0': {'heartbeat_started_event': {'host': '%s'}},"
" '1': {'heartbeat_failed_event': {'host': '%s'}}}",
mock_server_get_host_and_port (server),
mock_server_get_host_and_port (server));
}
check_json_apm_events (&context.events, tmp_bson (expected_json));
future_destroy (future);
bson_free (expected_json);
mongoc_uri_destroy (uri);
mock_server_destroy (server);
context_destroy (&context);
}
void
mock_server_destroy (mock_server_t *server)
{
size_t i;
autoresponder_handle_t *handle;
int64_t deadline = bson_get_monotonic_time () + 10 * 1000 * 1000;
request_t *request;
mongoc_mutex_lock (&server->mutex);
if (server->running) {
server->stopped = true;
}
mongoc_mutex_unlock (&server->mutex);
while (bson_get_monotonic_time () <= deadline) {
/* wait 10 seconds */
mongoc_mutex_lock (&server->mutex);
if (!server->running) {
mongoc_mutex_unlock (&server->mutex);
break;
}
mongoc_mutex_unlock (&server->mutex);
_mongoc_usleep (1000);
}
mongoc_mutex_lock (&server->mutex);
if (server->running) {
fprintf (stderr, "server still running after timeout\n");
fflush (stderr);
abort ();
}
mongoc_mutex_unlock (&server->mutex);
mongoc_thread_join (server->main_thread);
_mongoc_array_destroy (&server->worker_threads);
for (i = 0; i < server->autoresponders.len; i++) {
handle = &_mongoc_array_index (&server->autoresponders,
autoresponder_handle_t,
i);
autoresponder_handle_destroy (handle);
}
_mongoc_array_destroy (&server->autoresponders);
mongoc_cond_destroy (&server->cond);
mongoc_mutex_unlock (&server->mutex);
mongoc_mutex_destroy (&server->mutex);
mongoc_socket_destroy (server->sock);
bson_free (server->uri_str);
mongoc_uri_destroy (server->uri);
while ((request = (request_t *) q_get_nowait (server->q))) {
request_destroy (request);
}
q_destroy (server->q);
bson_free (server);
}
void MongoDBConnectionPool::destroy() {
mongoc_client_pool_t *pool = (mongoc_client_pool_t*)getEnv();
mongoc_client_pool_destroy(pool);
mongoc_uri_destroy(uri);
}
