static void
test_command (void)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bool r;
bson_t cmd = BSON_INITIALIZER;
bson_t reply;
client = mongoc_client_new (gTestUri);
assert (client);
database = mongoc_client_get_database (client, "admin");
/*
* Test a known working command, "ping".
*/
bson_append_int32 (&cmd, "ping", 4, 1);
cursor = mongoc_database_command (database, MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, NULL);
assert (cursor);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
assert (!doc);
mongoc_cursor_destroy (cursor);
/*
* Test a non-existing command to ensure we get the failure.
*/
bson_reinit (&cmd);
bson_append_int32 (&cmd, "a_non_existing_command", -1, 1);
r = mongoc_database_command_simple (database, &cmd, NULL, &reply, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_QUERY);
assert (error.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND);
assert (!strcmp ("no such cmd: a_non_existing_command", error.message));
mongoc_database_destroy (database);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
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;
}
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;
}
static void
ping (mongoc_database_t *db,
const bson_t *cmd)
{
mongoc_cursor_t *cursor;
const bson_t *b;
bson_error_t error;
cursor = mongoc_database_command(db, MONGOC_QUERY_NONE, 0, 1, cmd, NULL, NULL);
while (mongoc_cursor_next(cursor, &b)) {
BSON_ASSERT(b);
print_doc(b);
}
if (mongoc_cursor_error(cursor, &error)) {
MONGOC_WARNING("Cursor error: %s", error.message);
}
mongoc_cursor_destroy(cursor);
}
mongoc_cursor_t *
mongoc_database_find_collections (mongoc_database_t *database,
const bson_t *filter,
bson_error_t *error)
{
mongoc_cursor_t *cursor;
mongoc_read_prefs_t *read_prefs;
bson_t cmd = BSON_INITIALIZER;
bson_t child;
bson_error_t lerror;
BSON_ASSERT (database);
BSON_APPEND_INT32 (&cmd, "listCollections", 1);
if (filter) {
BSON_APPEND_DOCUMENT (&cmd, "filter", filter);
BSON_APPEND_DOCUMENT_BEGIN (&cmd, "cursor", &child);
bson_append_document_end (&cmd, &child);
}
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
cursor = mongoc_database_command (database, MONGOC_QUERY_SLAVE_OK, 0, 0, 0,
&cmd, NULL, read_prefs);
_mongoc_cursor_cursorid_init(cursor);
cursor->limit = 0;
if (_mongoc_cursor_cursorid_prime (cursor)) {
/* intentionally empty */
} else {
if (mongoc_cursor_error (cursor, &lerror)) {
if (lerror.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND) {
/* We are talking to a server that doesn' support listCollections. */
/* clear out the error. */
memset (&lerror, 0, sizeof lerror);
/* try again with using system.namespaces */
mongoc_cursor_destroy (cursor);
cursor = _mongoc_database_find_collections_legacy (
database, filter, error);
} else if (error) {
memcpy (error, &lerror, sizeof *error);
}
} else {
/* TODO: remove this branch for general release. Only relevant for RC */
mongoc_cursor_destroy (cursor);
cursor = mongoc_database_command (database, MONGOC_QUERY_SLAVE_OK, 0, 0, 0,
&cmd, NULL, read_prefs);
_mongoc_cursor_array_init(cursor, "collections");
cursor->limit = 0;
}
}
bson_destroy (&cmd);
mongoc_read_prefs_destroy (read_prefs);
return cursor;
}
static void
ha_replica_set_configure (ha_replica_set_t *replica_set,
ha_node_t *primary)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
bson_iter_t iter;
ha_node_t *node;
bson_t ar;
bson_t cmd;
bson_t config;
bson_t member;
char *str;
char *uristr;
char hoststr[32];
char key[8];
int i = 0;
uristr = bson_strdup_printf("mongodb://127.0.0.1:%hu/", primary->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);
bson_init(&cmd);
bson_append_document_begin(&cmd, "replSetInitiate", -1, &config);
bson_append_utf8(&config, "_id", 3, replica_set->name, -1);
bson_append_array_begin(&config, "members", -1, &ar);
for (node = replica_set->nodes; node; node = node->next) {
snprintf(key, sizeof key, "%u", i);
key[sizeof key - 1] = '\0';
snprintf(hoststr, sizeof hoststr, "127.0.0.1:%hu", node->port);
hoststr[sizeof hoststr - 1] = '\0';
bson_append_document_begin(&ar, key, -1, &member);
bson_append_int32(&member, "_id", -1, i);
bson_append_utf8(&member, "host", -1, hoststr, -1);
bson_append_bool(&member, "arbiterOnly", -1, node->is_arbiter);
bson_append_document_end(&ar, &member);
i++;
}
bson_append_array_end(&config, &ar);
bson_append_document_end(&cmd, &config);
str = bson_as_json(&cmd, NULL);
MONGOC_DEBUG("Config: %s", str);
bson_free(str);
database = mongoc_client_get_database(client, "admin");
again:
cursor = mongoc_database_command(database,
MONGOC_QUERY_NONE,
0,
1,
&cmd,
NULL,
NULL);
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
MONGOC_DEBUG("Reply: %s", str);
bson_free(str);
if (bson_iter_init_find(&iter, doc, "ok") &&
bson_iter_as_bool(&iter)) {
goto cleanup;
}
}
if (mongoc_cursor_error(cursor, &error)) {
mongoc_cursor_destroy(cursor);
MONGOC_WARNING("%s: Retrying in 1 second.", error.message);
sleep(1);
goto again;
}
cleanup:
mongoc_cursor_destroy(cursor);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
bson_destroy(&cmd);
}
