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