void
test_client_install (TestSuite *suite)
{
bool local;
gTestUri = bson_strdup_printf("mongodb://%s/", MONGOC_TEST_HOST);
gTestUriWithBadPassword = bson_strdup_printf("mongodb://*****:*****@%s/test", MONGOC_TEST_HOST);
local = !getenv ("MONGOC_DISABLE_MOCK_SERVER");
if (!local) {
TestSuite_Add (suite, "/Client/wire_version", test_wire_version);
TestSuite_Add (suite, "/Client/read_prefs", test_mongoc_client_read_prefs);
}
if (getenv ("MONGOC_CHECK_IPV6")) {
/* try to validate ipv6 too */
TestSuite_Add (suite, "/Client/ipv6", test_mongoc_client_ipv6);
}
TestSuite_Add (suite, "/Client/authenticate", test_mongoc_client_authenticate);
TestSuite_Add (suite, "/Client/authenticate_failure", test_mongoc_client_authenticate_failure);
TestSuite_Add (suite, "/Client/command", test_mongoc_client_command);
TestSuite_Add (suite, "/Client/command_secondary", test_mongoc_client_command_secondary);
TestSuite_Add (suite, "/Client/preselect", test_mongoc_client_preselect);
TestSuite_Add (suite, "/Client/exhaust_cursor", test_exhaust_cursor);
TestSuite_Add (suite, "/Client/server_status", test_server_status);
atexit (cleanup_globals);
}
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, /* IN */
char *argv[]) /* IN */
{
char *cwd;
char buf[1024];
if (argc <= 1 || !!strcmp (argv[1], "-v")) {
mongoc_log_set_handler (log_handler, NULL);
}
mongoc_init ();
cwd = getcwd(buf, sizeof(buf));
assert(cwd);
gTestCAFile = bson_strdup_printf("%s/" CAFILE, cwd);
gTestPEMFileLocalhost = bson_strdup_printf("%s/" PEMFILE_LOCALHOST, cwd);
run_test("/ReplicaSet/ssl/client", &test_replica_set_ssl_client);
bson_free(gTestCAFile);
bson_free(gTestPEMFileLocalhost);
mongoc_cleanup();
return 0;
}
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);
}
static void
test_query_flags (void)
{
int i;
char *opts;
char *find_cmd;
test_collection_find_with_opts_t test_data = { 0 };
typedef struct
{
mongoc_query_flags_t flag;
const char *json_fragment;
} flag_and_name_t;
/* slaveok is not supported as an option, exhaust is tested separately */
flag_and_name_t flags_and_frags[] = {
{
MONGOC_QUERY_TAILABLE_CURSOR,
"'tailable': true"
},
{
MONGOC_QUERY_OPLOG_REPLAY,
"'oplogReplay': true"
},
{
MONGOC_QUERY_NO_CURSOR_TIMEOUT,
"'noCursorTimeout': true"
},
{
MONGOC_QUERY_PARTIAL,
"'allowPartialResults': true"
},
{
MONGOC_QUERY_TAILABLE_CURSOR | MONGOC_QUERY_AWAIT_DATA,
"'tailable': true, 'awaitData': true"
},
};
for (i = 0; i < (sizeof flags_and_frags) / (sizeof (flag_and_name_t)); i++) {
opts = bson_strdup_printf ("{%s}", flags_and_frags[i].json_fragment);
find_cmd = bson_strdup_printf (
"{'find': 'collection', 'filter': {}, %s}",
flags_and_frags[i].json_fragment);
test_data.opts = opts;
test_data.expected_flags = flags_and_frags[i].flag;
test_data.expected_find_command = find_cmd;
_test_collection_find_with_opts (&test_data);
bson_free (find_cmd);
bson_free (opts);
}
}
static char *
gen_test_user (void)
{
return bson_strdup_printf ("testuser_%u_%u",
(unsigned)time(NULL),
(unsigned)gettestpid());
}
/*
* free (*s) and make *s point to *s concated with suffix.
* If *s is NULL it's treated like it's an empty string.
* If suffix is NULL, nothing happens.
*/
static void
_append_and_truncate (char **s,
const char *suffix,
int max_len)
{
char *old_str = *s;
char *prefix;
const int delim_len = strlen (" / ");
int space_for_suffix;
BSON_ASSERT (s);
prefix = old_str ? old_str : "";
if (!suffix) {
return;
}
space_for_suffix = max_len - strlen (prefix) - delim_len;
BSON_ASSERT (space_for_suffix >= 0);
*s = bson_strdup_printf ("%s / %.*s", prefix, space_for_suffix, suffix);
BSON_ASSERT (strlen (*s) <= max_len);
bson_free (old_str);
}
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 char *
gen_good_uri (const char *username)
{
return bson_strdup_printf("mongodb://%s:testpass@%s/test",
username,
MONGOC_TEST_HOST);
}
/*
* free (*s) and make *s point to *s concated with suffix.
* If *s is NULL it's treated like it's an empty string.
* If suffix is NULL, nothing happens.
*/
static void
_append_and_truncate (char **s, const char *suffix, int max_len)
{
char *old_str = *s;
char *prefix;
const int delim_len = (int) strlen (" / ");
int space_for_suffix;
BSON_ASSERT (s);
prefix = old_str ? old_str : "";
if (!suffix) {
return;
}
space_for_suffix = max_len - (int) strlen (prefix) - delim_len;
if (space_for_suffix <= 0) {
/* the old string already takes the whole allotted space */
return;
}
*s = bson_strdup_printf ("%s / %.*s", prefix, space_for_suffix, suffix);
BSON_ASSERT (strlen (*s) <= max_len);
bson_free (old_str);
}
void
test_write_command_install (TestSuite *suite)
{
gTestUri = bson_strdup_printf("mongodb://%s/", MONGOC_TEST_HOST);
TestSuite_Add (suite, "/WriteCommand/split_insert", test_split_insert);
atexit (cleanup_globals);
}
char *
gen_collection_name (const char *str)
{
return bson_strdup_printf ("%s_%u_%u",
str,
(unsigned)time(NULL),
(unsigned)gettestpid());
}
void
test_bulk_install (TestSuite *suite)
{
gTestUri = bson_strdup_printf("mongodb://%s/", MONGOC_TEST_HOST);
TestSuite_Add (suite, "/BulkOperation/basic", test_bulk);
TestSuite_Add (suite, "/BulkOperation/update_upserted", test_update_upserted);
TestSuite_Add (suite, "/BulkOperation/index_offset", test_index_offset);
atexit (cleanup_globals);
}
void
_mongoc_handshake_append_sasl_supported_mechs (const mongoc_uri_t *uri,
bson_t *cmd)
{
const char *username;
char *db_user;
username = mongoc_uri_get_username (uri);
db_user =
bson_strdup_printf ("%s.%s", mongoc_uri_get_auth_source (uri), username);
bson_append_utf8 (cmd, "saslSupportedMechs", 18, db_user, -1);
bson_free (db_user);
}
static void
ha_config_add_shard (ha_node_t *node,
ha_replica_set_t *replica_set)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_string_t *shardstr;
bson_error_t error;
bson_bool_t r;
bson_t reply;
bson_t cmd = BSON_INITIALIZER;
char *uristr;
uristr = bson_strdup_printf ("mongodb://127.0.0.1:%hu/", node->port);
client = mongoc_client_new (uristr);
collection = mongoc_client_get_collection (client, "admin", "fake");
shardstr = bson_string_new (NULL);
bson_string_append_printf (shardstr, "%s/127.0.0.1:%hu",
replica_set->name,
replica_set->nodes->port);
bson_append_utf8 (&cmd, "addShard", -1, shardstr->str, shardstr->len);
bson_string_free (shardstr, TRUE);
again:
sleep (1);
r = mongoc_collection_command_simple (collection, &cmd, NULL, &reply, &error);
if (!r) {
fprintf (stderr, "%s\n", error.message);
goto again;
}
#if 1
{
char *str;
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
}
#endif
bson_destroy (&reply);
bson_destroy (&cmd);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_free (uristr);
}
void
test_client_install (TestSuite *suite)
{
bool local;
gTestUri = bson_strdup_printf("mongodb://%s:27017/", MONGOC_TEST_HOST);
gTestUriWithPassword = bson_strdup_printf("mongodb://*****:*****@%s:27017/test", MONGOC_TEST_HOST);
gTestUriWithBadPassword = bson_strdup_printf("mongodb://*****:*****@%s:27017/test", MONGOC_TEST_HOST);
local = !getenv ("MONGOC_DISABLE_MOCK_SERVER");
if (!local) {
TestSuite_Add (suite, "/Client/wire_version", test_wire_version);
TestSuite_Add (suite, "/Client/read_prefs", test_mongoc_client_read_prefs);
}
TestSuite_Add (suite, "/Client/authenticate", test_mongoc_client_authenticate);
TestSuite_Add (suite, "/Client/authenticate_failure", test_mongoc_client_authenticate_failure);
TestSuite_Add (suite, "/Client/command", test_mongoc_client_command);
TestSuite_Add (suite, "/Client/exhaust_cursor", test_exhaust_cursor);
atexit (cleanup_globals);
}
static void
test_wire_version (void)
{
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
mongoc_client_t *client;
mock_server_t *server;
uint16_t port;
const bson_t *doc;
bson_error_t error;
bool r;
bson_t q = BSON_INITIALIZER;
char *uristr;
port = 20000 + (rand () % 1000);
server = mock_server_new ("127.0.0.1", port, NULL, NULL);
mock_server_set_wire_version (server, 10, 11);
mock_server_run_in_thread (server);
usleep (5000);
uristr = bson_strdup_printf ("mongodb://127.0.0.1:%hu/", port);
client = mongoc_client_new (uristr);
collection = mongoc_client_get_collection (client, "test", "test");
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
1,
0,
&q,
NULL,
NULL);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
r = mongoc_cursor_error (cursor, &error);
assert (r);
assert (error.domain == MONGOC_ERROR_PROTOCOL);
assert (error.code == MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mock_server_quit (server, 0);
mongoc_client_destroy (client);
bson_free (uristr);
}
/** run as a child thread by test_mongoc_tls_handshake_stall
*
* It:
* 1. spins up
* 2. waits on a condvar until the server is up
* 3. connects to the server's port
* 4. attempts handshake
* 5. confirms that it times out
* 6. shuts down
*/
static void *
handshake_stall_client (void *ptr)
{
ssl_test_data_t *data = (ssl_test_data_t *)ptr;
char *uri_str;
mongoc_client_t *client;
bson_t reply;
bson_error_t error;
int64_t connect_timeout_ms = data->handshake_stall_ms - 100;
int64_t duration_ms;
int64_t start_time;
mongoc_mutex_lock (&data->cond_mutex);
while (!data->server_port) {
mongoc_cond_wait (&data->cond, &data->cond_mutex);
}
mongoc_mutex_unlock (&data->cond_mutex);
uri_str = bson_strdup_printf (
"mongodb://localhost:%u/?ssl=true&serverselectiontimeoutms=200&connecttimeoutms=%" PRId64,
data->server_port, connect_timeout_ms);
client = mongoc_client_new (uri_str);
/* we should time out after about 200ms */
start_time = bson_get_monotonic_time ();
mongoc_client_get_server_status (client,
NULL,
&reply,
&error);
/* time is in microseconds */
duration_ms = (bson_get_monotonic_time () - start_time) / 1000;
if (llabs(duration_ms - connect_timeout_ms) > 100) {
fprintf (stderr,
"expected timeout after about 200ms, not %" PRId64 "\n",
duration_ms);
abort ();
}
data->client_result->result = SSL_TEST_SUCCESS;
bson_destroy (&reply);
mongoc_client_destroy (client);
bson_free (uri_str);
return NULL;
}
/*
* 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 int
TestSuite_RunFuncInChild (TestSuite *suite, /* IN */
Test *test) /* IN */
{
STARTUPINFO si;
PROCESS_INFORMATION pi;
char *cmdline;
DWORD exit_code = -1;
ZeroMemory (&si, sizeof (si));
si.cb = sizeof (si);
ZeroMemory (&pi, sizeof (pi));
cmdline = bson_strdup_printf ("%s --silent --no-fork -l %s",
suite->prgname, test->name);
if (!CreateProcess (NULL,
cmdline,
NULL, /* Process handle not inheritable */
NULL, /* Thread handle not inheritable */
FALSE, /* Set handle inheritance to FALSE */
0, /* No creation flags */
NULL, /* Use parent's environment block */
NULL, /* Use parent's starting directory */
&si,
&pi)) {
_Print_StdErr ("CreateProcess failed (%d).\n", GetLastError ());
bson_free (cmdline);
return -1;
}
if (WaitForSingleObject (pi.hProcess, INFINITE) != WAIT_OBJECT_0) {
_print_getlasterror_win ("Couldn't await process");
goto done;
}
if (!GetExitCodeProcess (pi.hProcess, &exit_code)) {
_print_getlasterror_win ("Couldn't get exit code");
goto done;
}
done:
CloseHandle (pi.hProcess);
CloseHandle (pi.hThread);
bson_free (cmdline);
return exit_code;
}
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;
}
/*
* 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)
{
MONGO_CONN *client = NULL;
char* uri = NULL;
if (user && password && readPreference)
uri = bson_strdup_printf ("mongodb://%s:%s@%s:%hu/%s?readPreference=%s", user, password, host, port, databaseName, readPreference);
else if (user && password)
uri = bson_strdup_printf ("mongodb://%s:%s@%s:%hu/%s", user, password, host, port, databaseName);
else if (readPreference)
uri = bson_strdup_printf ("mongodb://%s:%hu/%s?readPreference=%s", host, port, databaseName, readPreference);
else
uri = bson_strdup_printf ("mongodb://%s:%hu/%s", host, port, databaseName);
client = mongoc_client_new(uri);
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
test_index_spec_modifiers (void)
{
const char *modifiers[] = {
"hint",
"min",
"max",
};
const char *mod;
size_t i;
char *opts;
char *query;
char *find_command;
test_collection_find_with_opts_t test_data = { 0 };
for (i = 0; i < sizeof (modifiers) / sizeof (const char *); i++) {
mod = modifiers[i];
opts = bson_strdup_printf ("{'%s': {'_id': 1}}", mod);
/* OP_QUERY modifiers use $-prefix: $hint, $min, $max */
query = bson_strdup_printf ("{'$query': {}, '$%s': {'_id': 1}}", mod);
/* find command options have no $-prefix: hint, min, max */
find_command = bson_strdup_printf (
"{'find': 'collection', 'filter': {}, '%s': {'_id': 1}}", mod);
test_data.opts = opts;
test_data.expected_op_query = query;
test_data.expected_find_command = find_command;
_test_collection_find_with_opts (&test_data);
bson_free (opts);
bson_free (query);
bson_free (find_command);
}
}
static void
test_int_modifiers (void)
{
const char *modifiers[] = {
"maxScan",
"maxTimeMS",
};
const char *mod;
size_t i;
char *opts;
char *query;
char *find_command;
test_collection_find_with_opts_t test_data = { 0 };
for (i = 0; i < sizeof (modifiers) / sizeof (const char *); i++) {
mod = modifiers[i];
opts = bson_strdup_printf ("{'%s': {'$numberLong': '9999'}}", mod);
query = bson_strdup_printf ("{'$query': {},"
" '$%s': {'$numberLong': '9999'}}", mod);
/* find command has same modifier, without the $-prefix */
find_command = bson_strdup_printf (
"{'find': 'collection', 'filter': {},"
" '%s': {'$numberLong': '9999'}}", mod);
test_data.opts = opts;
test_data.expected_op_query = query;
test_data.expected_find_command = find_command;
_test_collection_find_with_opts (&test_data);
bson_free (opts);
bson_free (query);
bson_free (find_command);
}
}
void
mock_server_replies_to_find (request_t *request,
mongoc_query_flags_t flags,
int64_t cursor_id,
int32_t number_returned,
const char *ns,
const char *reply_json,
bool is_command)
{
char *find_reply;
char db[MONGOC_NAMESPACE_MAX];
_mongoc_get_db_name (ns, db);
/* minimal validation, we're not testing query / find cmd here */
if (request->is_command && !is_command) {
MONGOC_ERROR ("expected query, got command");
abort ();
}
if (!request->is_command && is_command) {
MONGOC_ERROR ("expected command, got query");
abort ();
}
if (!request_matches_flags (request, flags)) {
abort ();
}
if (is_command) {
find_reply = bson_strdup_printf (
"{'ok': 1,"
" 'cursor': {"
" 'id': {'$numberLong': '%" PRId64 "'},"
" 'ns': '%s',"
" 'firstBatch': [%s]}}",
cursor_id,
ns,
reply_json);
mock_server_replies_simple (request, find_reply);
bson_free (find_reply);
} else {
mock_server_replies (request, MONGOC_REPLY_NONE, cursor_id, 0,
number_returned, reply_json);
}
}
void
test_database_install (TestSuite *suite)
{
gTestUri = bson_strdup_printf ("mongodb://%s/", MONGOC_TEST_HOST);
TestSuite_Add (suite, "/Database/has_collection", test_has_collection);
TestSuite_Add (suite, "/Database/command", test_command);
TestSuite_Add (suite, "/Database/drop", test_drop);
TestSuite_Add (suite, "/Database/create_collection", test_create_collection);
TestSuite_Add (suite, "/Database/get_collection_info",
test_get_collection_info);
TestSuite_Add (suite, "/Database/get_collection_names",
test_get_collection_names);
atexit (cleanup_globals);
}
mongoc_uri_t *
mongoc_uri_new_for_host_port (const char *hostname,
uint16_t port)
{
mongoc_uri_t *uri;
char *str;
bson_return_val_if_fail(hostname, NULL);
bson_return_val_if_fail(port, NULL);
str = bson_strdup_printf("mongodb://%s:%hu/", hostname, port);
uri = mongoc_uri_new(str);
bson_free(str);
return uri;
}
void
test_gridfs_install (TestSuite *suite)
{
gTestUri = bson_strdup_printf ("mongodb://%s/", MONGOC_TEST_HOST);
TestSuite_Add (suite, "/GridFS/create", test_create);
TestSuite_Add (suite, "/GridFS/create_from_stream", test_create_from_stream);
TestSuite_Add (suite, "/GridFS/list", test_list);
TestSuite_Add (suite, "/GridFS/read", test_read);
TestSuite_Add (suite, "/GridFS/stream", test_stream);
TestSuite_Add (suite, "/GridFS/remove", test_remove);
TestSuite_Add (suite, "/GridFS/write", test_write);
TestSuite_Add (suite, "/GridFS/remove_by_filename", test_remove_by_filename);
atexit (cleanup_globals);
}
mongoc_uri_t *
mongoc_uri_new_for_host_port (const char *hostname,
uint16_t port)
{
mongoc_uri_t *uri;
char *str;
BSON_ASSERT (hostname);
BSON_ASSERT (port);
str = bson_strdup_printf("mongodb://%s:%hu/", hostname, port);
uri = mongoc_uri_new(str);
bson_free(str);
return uri;
}
int
main (int argc,
char *argv[])
{
mongoc_database_t *database;
mongoc_cursor_t *cursor;
mongoc_client_t *client;
const bson_t *reply;
bson_uint16_t port;
bson_error_t error;
bson_t ping;
char *host_and_port;
char *str;
if (argc < 2 || argc > 3) {
fprintf(stderr, "usage: %s HOSTNAME [PORT]\n", argv[0]);
return 1;
}
port = (argc == 3) ? atoi(argv[2]) : 27017;
host_and_port = bson_strdup_printf("mongodb://%s:%hu", argv[1], port);
client = mongoc_client_new(host_and_port);
if (!client) {
fprintf(stderr, "Invalid hostname or port: %s\n", host_and_port);
return 2;
}
bson_init(&ping);
bson_append_int32(&ping, "ping", 4, 1);
database = mongoc_client_get_database(client, "test");
cursor = mongoc_database_command(database, 0, 0, 1, 0, &ping, NULL, NULL);
if (mongoc_cursor_next(cursor, &reply)) {
str = bson_as_json(reply, NULL);
fprintf(stdout, "%s\n", str);
bson_free(str);
} else if (mongoc_cursor_error(cursor, &error)) {
fprintf(stderr, "Ping failure: %s\n", error.message);
return 3;
}
mongoc_cursor_destroy(cursor);
bson_destroy(&ping);
mongoc_client_destroy(client);
bson_free(host_and_port);
return 0;
}
