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