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 (); }
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; }
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); }
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); }
ClientPool :: ClientPool (const char *uri, QObject * parent) : QObject (parent) { std::shared_ptr<mongoc_uri_t> auto_uri ( mongoc_uri_new(uri), uriDeleter); auto *pool = mongoc_client_pool_new ( auto_uri.get() ); std::shared_ptr <mongoc_client_pool_t> newPool (pool, clientPoolDeleter); clientPool.swap (newPool); }
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); }
ConnectionPool::ConnectionPoolImpl::ConnectionPoolImpl( const std::string& connstr, const std::string& dbname ) : m_dbname(dbname) { disable_mongoc_logging(); URI uri(connstr); mongoc_client_pool_t* pool = mongoc_client_pool_new(uri.Get()); if(!pool) { std::stringstream strm; strm << "Failed to get connections pool to: " << connstr << "\n"; throw MongoError(strm.str()); } m_pool.reset( pool, tlib_mongoc_client_pool_destroy ); }
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 MongoDBConnectionPool::initEnv() { mongoc_init(); ConnectionProperties props = getProperties(); std::string connectionString = ""; if(isUnixDomainSocket) { if(props.getNodes().at(0).getUsername()!="" && props.getNodes().at(0).getPassword()!="") { connectionString += (props.getNodes().at(0).getUsername() + ":" + props.getNodes().at(0).getPassword() + "@"); } connectionString += "/tmp/mongodb.sock"; if(props.getNodes().at(0).getDatabaseName()!="") { connectionString += "/" + props.getNodes().at(0).getDatabaseName(); } } else { std::string databaseName = ""; std::cout << props.getNodes().size() << std::endl; for (int var = 0; var < (int)props.getNodes().size(); ++var) { if(databaseName=="") { databaseName = props.getNodes().at(var).getDatabaseName(); } int port = props.getNodes().at(var).getPort(); if(props.getNodes().at(var).getHost()=="") { continue; } if(port==-1) { port = 27017; } std::cout << props.getNodes().at(var).getHost() << std::endl; if(props.getNodes().at(var).getUsername()!="" && props.getNodes().at(var).getPassword()!="") { connectionString += (props.getNodes().at(var).getUsername() + ":" + props.getNodes().at(var).getPassword() + "@"); } connectionString += props.getNodes().at(var).getHost() + ":" + CastUtil::lexical_cast<std::string>(port); if(var!=(int)props.getNodes().size()-1) { connectionString += ","; } } if(connectionString.at(connectionString.length()-1)==',') { connectionString = connectionString.substr(0, connectionString.length()-1); } connectionString += "/"; if(databaseName!="") { connectionString += databaseName; } connectionString += "?"; if(isReplicaSet && replicaSetName!="") { connectionString += "replicaSet="+replicaSetName; if(isSSL) { connectionString += "&ssl=true"; } } else if(isSSL) { connectionString += "ssl=true"; } } int poolmin = 2, poolmax = 5; if((props.getPoolWriteSize()+props.getPoolReadSize())>0) { poolmax = props.getPoolWriteSize()+props.getPoolReadSize(); if(poolmax<poolmin) poolmax += poolmin; } if(connectionString.at(connectionString.length()-1)=='?') { connectionString += "minPoolSize=" + CastUtil::lexical_cast<std::string>(poolmin); } else { connectionString += "&minPoolSize=" + CastUtil::lexical_cast<std::string>(poolmin); } connectionString += "&maxPoolSize=" + CastUtil::lexical_cast<std::string>(poolmax); connectionString = "mongodb://" + connectionString; std::cout << connectionString << std::endl; uri = mongoc_uri_new(connectionString.c_str()); mongoc_client_pool_t *pool = mongoc_client_pool_new(uri); setEnv(pool); props.setNewConnectionStrategy(true); }
static int mongodb_load_module(int reload) { int res = -1; struct ast_config *cfg = NULL; mongoc_uri_t *uri = NULL; do { const char *tmp; struct ast_variable *var; struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; cfg = ast_config_load(CONFIG_FILE, config_flags); if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) { ast_log(LOG_WARNING, "unable to load config file=%s\n", CONFIG_FILE); res = AST_MODULE_LOAD_DECLINE; break; } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) break; var = ast_variable_browse(cfg, CATEGORY); if (!var) { ast_log(LOG_WARNING, "no category specified.\n"); break; } if ((tmp = ast_variable_retrieve(cfg, CATEGORY, URI)) == NULL) { ast_log(LOG_WARNING, "no uri specified.\n"); break; } uri = mongoc_uri_new(tmp); if (uri == NULL) { ast_log(LOG_ERROR, "parsing uri error, %s\n", tmp); break; } if ((tmp = ast_variable_retrieve(cfg, CATEGORY, DATABSE)) == NULL) { ast_log(LOG_WARNING, "no database specified.\n"); break; } if (dbname) ast_free(dbname); dbname = ast_strdup(tmp); if (dbname == NULL) { ast_log(LOG_ERROR, "not enough memory for dbname\n"); break; } if ((tmp = ast_variable_retrieve(cfg, CATEGORY, COLLECTION)) == NULL) { ast_log(LOG_WARNING, "no collection specified.\n"); break; } if (dbcollection) ast_free(dbcollection); dbcollection = ast_strdup(tmp); if (dbcollection == NULL) { ast_log(LOG_ERROR, "not enough memory for dbcollection\n"); break; } if (!ast_test_flag(&config, CONFIG_REGISTERED)) { res = ast_cdr_register(NAME, ast_module_info->description, mongodb_log); if (res) { ast_log(LOG_ERROR, "unable to register CDR handling\n"); break; } ast_set_flag(&config, CONFIG_REGISTERED); } if ((tmp = ast_variable_retrieve(cfg, CATEGORY, SERVERID)) != NULL) { if (!bson_oid_is_valid (tmp, strlen(tmp))) { ast_log(LOG_ERROR, "invalid server id specified.\n"); break; } serverid = ast_malloc(sizeof(bson_oid_t)); if (serverid == NULL) { ast_log(LOG_ERROR, "not enough memory\n"); break; } bson_oid_init_from_string(serverid, tmp); } if (dbpool) mongoc_client_pool_destroy(dbpool); dbpool = mongoc_client_pool_new(uri); if (dbpool == NULL) { ast_log(LOG_ERROR, "cannot make a connection pool for MongoDB\n"); break; } res = 0; // suceess } while (0); if (uri) mongoc_uri_destroy(uri); if (ast_test_flag(&config, CONFIG_REGISTERED) && (!cfg || dbname == NULL || dbcollection == NULL)) { ast_cdr_backend_suspend(NAME); ast_clear_flag(&config, CONFIG_REGISTERED); } else ast_cdr_backend_unsuspend(NAME); if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED && cfg != CONFIG_STATUS_FILEINVALID) ast_config_destroy(cfg); return res; }
static void test_mongoc_metadata_append_success (void) { mock_server_t *server; mongoc_uri_t *uri; mongoc_client_t *client; mongoc_client_pool_t *pool; request_t *request; const bson_t *request_doc; bson_iter_t iter; bson_iter_t md_iter; bson_iter_t inner_iter; const char *val; const char *driver_name = "php driver"; const char *driver_version = "version abc"; const char *platform = "./configure -nottoomanyflags"; char big_string [METADATA_MAX_SIZE]; memset (big_string, 'a', METADATA_MAX_SIZE - 1); big_string [METADATA_MAX_SIZE - 1] = '\0'; _reset_metadata (); /* Make sure setting the metadata works */ ASSERT (mongoc_metadata_append (driver_name, driver_version, platform)); server = mock_server_new (); mock_server_run (server); uri = mongoc_uri_copy (mock_server_get_uri (server)); mongoc_uri_set_option_as_int32 (uri, "heartbeatFrequencyMS", 500); pool = mongoc_client_pool_new (uri); /* Force topology scanner to start */ client = mongoc_client_pool_pop (pool); request = mock_server_receives_ismaster (server); ASSERT (request); request_doc = request_get_doc (request, 0); ASSERT (request_doc); ASSERT (bson_has_field (request_doc, "isMaster")); ASSERT (bson_has_field (request_doc, METADATA_FIELD)); ASSERT (bson_iter_init_find (&iter, request_doc, METADATA_FIELD)); ASSERT (bson_iter_recurse (&iter, &md_iter)); /* Make sure driver.name and driver.version and platform are all right */ ASSERT (bson_iter_find (&md_iter, "driver")); ASSERT (BSON_ITER_HOLDS_DOCUMENT (&md_iter)); ASSERT (bson_iter_recurse (&md_iter, &inner_iter)); ASSERT (bson_iter_find (&inner_iter, "name")); ASSERT (BSON_ITER_HOLDS_UTF8 (&inner_iter)); val = bson_iter_utf8 (&inner_iter, NULL); ASSERT (val); ASSERT (strstr (val, driver_name) != NULL); ASSERT (bson_iter_find (&inner_iter, "version")); ASSERT (BSON_ITER_HOLDS_UTF8 (&inner_iter)); val = bson_iter_utf8 (&inner_iter, NULL); ASSERT (val); ASSERT (strstr (val, driver_version)); /* Check os type not empty */ ASSERT (bson_iter_find (&md_iter, "os")); ASSERT (BSON_ITER_HOLDS_DOCUMENT (&md_iter)); ASSERT (bson_iter_recurse (&md_iter, &inner_iter)); ASSERT (bson_iter_find (&inner_iter, "type")); ASSERT (BSON_ITER_HOLDS_UTF8 (&inner_iter)); val = bson_iter_utf8 (&inner_iter, NULL); ASSERT (val); ASSERT (strlen (val) > 0); /* Not checking os_name, as the spec says it can be NULL. */ /* Check platform field ok */ ASSERT (bson_iter_find (&md_iter, "platform")); ASSERT (BSON_ITER_HOLDS_UTF8 (&md_iter)); val = bson_iter_utf8 (&md_iter, NULL); ASSERT (val); ASSERT (strstr (val, platform) != NULL); mock_server_replies_simple (request, "{'ok': 1, 'ismaster': true}"); request_destroy (request); /* Cleanup */ mongoc_client_pool_push (pool, client); mongoc_client_pool_destroy (pool); mongoc_uri_destroy (uri); mock_server_destroy (server); _reset_metadata (); }
/* Test the case where we can't prevent the metadata doc being too big * and so we just don't send it */ static void test_mongoc_metadata_cannot_send (void) { mock_server_t *server; mongoc_uri_t *uri; mongoc_client_t *client; mongoc_client_pool_t *pool; request_t *request; const char *const server_reply = "{'ok': 1, 'ismaster': true}"; const bson_t *request_doc; char big_string[METADATA_MAX_SIZE]; mongoc_metadata_t *md; _reset_metadata (); /* Mess with our global metadata struct so the metadata doc will be * way too big */ memset (big_string, 'a', METADATA_MAX_SIZE - 1); big_string[METADATA_MAX_SIZE - 1] = '\0'; md = _mongoc_metadata_get (); bson_free (md->os_name); md->os_name = bson_strdup (big_string); server = mock_server_new (); mock_server_run (server); uri = mongoc_uri_copy (mock_server_get_uri (server)); mongoc_uri_set_option_as_int32 (uri, "heartbeatFrequencyMS", 500); pool = mongoc_client_pool_new (uri); /* Pop a client to trigger the topology scanner */ client = mongoc_client_pool_pop (pool); request = mock_server_receives_ismaster (server); /* Make sure the isMaster request DOESN'T have a metadata field: */ ASSERT (request); request_doc = request_get_doc (request, 0); ASSERT (request_doc); ASSERT (bson_has_field (request_doc, "isMaster")); ASSERT (!bson_has_field (request_doc, METADATA_FIELD)); mock_server_replies_simple (request, server_reply); request_destroy (request); /* Cause failure on client side */ request = mock_server_receives_ismaster (server); ASSERT (request); mock_server_hangs_up (request); request_destroy (request); /* Make sure the isMaster request still DOESN'T have a metadata field * on subsequent heartbeats. */ request = mock_server_receives_ismaster (server); ASSERT (request); request_doc = request_get_doc (request, 0); ASSERT (request_doc); ASSERT (bson_has_field (request_doc, "isMaster")); ASSERT (!bson_has_field (request_doc, METADATA_FIELD)); mock_server_replies_simple (request, server_reply); request_destroy (request); /* cleanup */ mongoc_client_pool_push (pool, client); mongoc_client_pool_destroy (pool); mongoc_uri_destroy (uri); mock_server_destroy (server); /* Reset again so the next tests don't have a metadata doc which * is too big */ _reset_metadata (); }