static void
test_mongoc_client_command_secondary (void)
{
mongoc_client_t *client;
mongoc_cursor_t *cursor;
mongoc_read_prefs_t *read_prefs;
bson_t cmd = BSON_INITIALIZER;
client = mongoc_client_new (gTestUri);
assert (client);
BSON_APPEND_INT32 (&cmd, "invalid_command_here", 1);
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY_PREFERRED);
suppress_one_message ();
cursor = mongoc_client_command (client, "admin", MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, read_prefs);
mongoc_read_prefs_destroy (read_prefs);
/* ensure we detected this must go to primary */
assert (cursor->redir_primary);
mongoc_cursor_destroy (cursor);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
int
main (int argc,
char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *query;
char *str;
mongoc_init ();
client = mongoc_client_new ("mongodb://localhost:3001/");
collection = mongoc_client_get_collection (client, "meteor", "sensors");
query = bson_new ();
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
bson_destroy (query);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
return 0;
}
static void
test_mongoc_client_authenticate (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
char *username;
char *uri;
bool r;
bson_t q;
username = gen_test_user ();
uri = gen_good_uri (username);
/*
* Add a user to the test database.
*/
client = mongoc_client_new(gTestUri);
database = mongoc_client_get_database(client, "test");
mongoc_database_remove_user (database, username, &error);
r = mongoc_database_add_user(database, username, "testpass", NULL, NULL, &error);
ASSERT_CMPINT(r, ==, 1);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
/*
* Try authenticating with that user.
*/
bson_init(&q);
client = mongoc_client_new(uri);
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);
if (!r) {
r = mongoc_cursor_error(cursor, &error);
if (r) {
MONGOC_ERROR("Authentication failure: \"%s\"", error.message);
}
assert(!r);
}
mongoc_cursor_destroy(cursor);
/*
* Remove all test users.
*/
database = mongoc_client_get_database (client, "test");
r = mongoc_database_remove_all_users (database, &error);
assert (r);
mongoc_database_destroy (database);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
bson_free (username);
bson_free (uri);
}
int mongo_get_documents(mongoc_client_t *client, char *database, char *collection_name, bson_t *query,
query_result **result) {
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
char *str;
int index = 0;
collection = mongoc_client_get_collection(client, database, collection_name);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
query_result *current = *result;
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
if (index == 0) {
(*result)->document = malloc(strlen(str) + 1);
strcpy((*result)->document, str);
(*result)->next = NULL;
}
else {
current->next = malloc(sizeof(query_result));
current->next->document = malloc(strlen(str) + 1);
strcpy(current->next->document, str);
current->next->next = NULL;
current = current->next;
}
index++;
bson_free(str);
}
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
return 0;
}
int main (int argc,char* argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *query;
char *str;
mongoc_init ();
client = mongoc_client_new ("mongodb://*****:*****@192.168.0.112:27017/");
collection = mongoc_client_get_collection (client, "clown", "testCollection");
query = bson_new ();
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
bson_destroy (query);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
return 0;
}
static void
print_pipeline (mongoc_collection_t *collection)
{
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bson_t *pipeline;
char *str;
pipeline = BCON_NEW ("pipeline", "[",
"{", "$group", "{", "_id", "$state", "total_pop", "{", "$sum", "$pop", "}", "}", "}",
"{", "$match", "{", "total_pop", "{", "$gte", BCON_INT32 (10000000), "}", "}", "}",
"]");
cursor = mongoc_collection_aggregate (collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
}
mongoc_cursor_destroy (cursor);
bson_destroy (pipeline);
}
/*
* Retrieve result set
*/
static int db_mongodb_store_result(const db1_con_t* _h, db1_res_t** _r)
{
km_mongodb_con_t *mgcon;
db_mongodb_result_t *mgres;
const bson_t *itdoc;
mgcon = MONGODB_CON(_h);
if(!_r) {
LM_ERR("invalid result parameter\n");
return -1;
}
*_r = db_mongodb_new_result();
if (!*_r) {
LM_ERR("no memory left for result \n");
goto error;
}
mgres = (db_mongodb_result_t*)RES_PTR(*_r);
mgres->collection = mgcon->collection;
mgcon->collection = NULL;
mgres->cursor = mgcon->cursor;
mgcon->cursor = NULL;
mgres->colsdoc = mgcon->colsdoc;
mgcon->colsdoc = NULL;
mgres->nrcols = mgcon->nrcols;
mgcon->nrcols = 0;
if(!mongoc_cursor_more (mgres->cursor)
|| !mongoc_cursor_next (mgres->cursor, &itdoc)
|| !itdoc) {
LM_DBG("no result from mongodb\n");
return 0;
}
/* first document linked internally in result to get columns */
mgres->rdoc = (bson_t*)itdoc;
if(db_mongodb_get_columns(_h, *_r)<0) {
LM_ERR("failed to set the columns\n");
goto error;
}
if(db_mongodb_convert_result(_h, *_r)<0) {
LM_ERR("failed to set the rows in result\n");
goto error;
}
return 0;
error:
if(mgcon->colsdoc) {
bson_destroy (mgcon->colsdoc);
mgcon->colsdoc = NULL;
}
mgcon->nrcols = 0;
if(mgcon->cursor) {
mongoc_cursor_destroy (mgcon->cursor);
mgcon->cursor = NULL;
}
if(mgcon->collection) {
mongoc_collection_destroy (mgcon->collection);
mgcon->collection = NULL;
}
return -1;
}
/*
* Release a result set from memory
*/
int db_mongodb_free_result(db1_con_t* _h, db1_res_t* _r)
{
if(!_r)
return -1;
if(RES_PTR(_r)) {
if(((db_mongodb_result_t*)RES_PTR(_r))->rdoc) {
bson_destroy(((db_mongodb_result_t*)RES_PTR(_r))->rdoc);
((db_mongodb_result_t*)RES_PTR(_r))->rdoc = NULL;
}
if(((db_mongodb_result_t*)RES_PTR(_r))->colsdoc) {
bson_destroy (((db_mongodb_result_t*)RES_PTR(_r))->colsdoc);
((db_mongodb_result_t*)RES_PTR(_r))->colsdoc = NULL;
}
((db_mongodb_result_t*)RES_PTR(_r))->nrcols = 0;
if(((db_mongodb_result_t*)RES_PTR(_r))->cursor) {
mongoc_cursor_destroy (((db_mongodb_result_t*)RES_PTR(_r))->cursor);
((db_mongodb_result_t*)RES_PTR(_r))->cursor = NULL;
}
if(((db_mongodb_result_t*)RES_PTR(_r))->collection) {
mongoc_collection_destroy (((db_mongodb_result_t*)RES_PTR(_r))->collection);
((db_mongodb_result_t*)RES_PTR(_r))->collection = NULL;
}
pkg_free(RES_PTR(_r));
}
db_free_result(_r);
return 0;
}
static void
test_mongoc_client_command (void)
{
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bool r;
bson_t cmd = BSON_INITIALIZER;
client = mongoc_client_new (gTestUri);
assert (client);
bson_append_int32 (&cmd, "ping", 4, 1);
cursor = mongoc_client_command (client, "admin", MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, NULL);
assert (!cursor->redir_primary);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
assert (!doc);
mongoc_cursor_destroy (cursor);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
static void
test_mongoc_client_authenticate_failure (void)
{
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
mongoc_client_t *client;
const bson_t *doc;
bson_error_t error;
bool r;
bson_t q;
/*
* Try authenticating with that user.
*/
bson_init(&q);
client = mongoc_client_new(gTestUriWithBadPassword);
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_CLIENT);
assert(error.code == MONGOC_ERROR_CLIENT_AUTHENTICATE);
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
}
/**
* Destroys the underlying MongoDB cursor associated with the given cursor.
*
* Note that the column data is not freed in this function as that data is
* exposed as NumPy arrays in Python.
*
* @param cursor A pointer to the Monary cursor to close. If cursor is NULL,
* no operation is performed.
*/
void monary_close_query(monary_cursor* cursor)
{
if (cursor) {
DEBUG("%s", "Closing query");
mongoc_cursor_destroy(cursor->mcursor);
free(cursor);
}
}
static void
func_ctx_cleanup (func_ctx_t *ctx)
{
mongoc_cursor_destroy (ctx->cursor);
if (ctx->destructor) {
ctx->destructor (ctx->data);
}
}
void
mongoc_gridfs_file_list_destroy (mongoc_gridfs_file_list_t *list)
{
BSON_ASSERT (list);
mongoc_cursor_destroy (list->cursor);
bson_free (list);
}
static void
_test_find_command (const mongoc_uri_t *uri,
mock_server_t *server,
const char *query_in,
mongoc_read_prefs_t *read_prefs,
mongoc_query_flags_t expected_find_cmd_query_flags,
const char *expected_find_cmd)
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t b = BSON_INITIALIZER;
future_t *future;
request_t *request;
client = mongoc_client_new_from_uri (uri);
collection = mongoc_client_get_collection (client, "test", "test");
mongoc_collection_set_read_prefs (collection, read_prefs);
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
1,
0,
tmp_bson (query_in),
NULL,
read_prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_command (
server,
"test",
expected_find_cmd_query_flags,
expected_find_cmd);
mock_server_replies (request,
MONGOC_REPLY_NONE, /* flags */
0, /* cursorId */
0, /* startingFrom */
1, /* numberReturned */
"{'ok': 1,"
" 'cursor': {"
" 'id': 0,"
" 'ns': 'db.collection',"
" 'firstBatch': [{'a': 1}]}}");
/* mongoc_cursor_next returned true */
assert (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&b);
}
static void
test_large_return (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc = NULL;
bson_oid_t oid;
bson_t insert_doc = BSON_INITIALIZER;
bson_t query = BSON_INITIALIZER;
size_t len;
char *str;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
collection = get_test_collection (client, "test_large_return");
ASSERT (collection);
len = 1024 * 1024 * 4;
str = bson_malloc (len);
memset (str, (int)' ', len);
str [len - 1] = '\0';
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (&insert_doc, "_id", &oid);
BSON_APPEND_UTF8 (&insert_doc, "big", str);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &insert_doc, NULL, &error);
assert (r);
bson_destroy (&insert_doc);
BSON_APPEND_OID (&query, "_id", &oid);
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, NULL, NULL);
assert (cursor);
bson_destroy (&query);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
mongoc_cursor_destroy (cursor);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_free (str);
}
/* direct connection to a secondary requires read pref primaryPreferred to
* avoid "not master" error from server */
static void
_test_op_msg_direct_connection (bool is_mongos,
test_op_msg_direct_fn_t fn,
const char *expected_cmd)
{
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_read_prefs_t *prefs = NULL;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *cmd;
future_t *future;
request_t *request;
const char *reply;
int i;
if (is_mongos) {
server = mock_mongos_new (WIRE_VERSION_OP_MSG);
} else {
server = mock_server_with_autoismaster (WIRE_VERSION_OP_MSG);
}
mock_server_auto_endsessions (server);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "db", "collection");
for (i = 0; i < 2; i++) {
if (i == 1) {
/* user-supplied read preference primary makes no difference */
prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
}
cursor = fn (collection, prefs);
future = future_cursor_next (cursor, &doc);
cmd = tmp_bson (expected_cmd);
request = mock_server_receives_msg (server, 0, cmd);
reply = "{'ok': 1,"
" 'cursor': {"
" 'id': 0,"
" 'ns': 'db.collection',"
" 'firstBatch': [{'a': 1}]}}";
mock_server_replies_simple (request, reply);
BSON_ASSERT (future_get_bool (future));
future_destroy (future);
request_destroy (request);
mongoc_cursor_destroy (cursor);
mongoc_read_prefs_destroy (prefs); /* null ok */
}
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mock_server_destroy (server);
}
int main(int argc, char *argv[]) {
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_t *query;
char *str;
mongoc_init();
client = mongoc_client_new("mongodb://localhost:27017/");
collection = mongoc_client_get_collection(client, "stockopedia",
"instruments");
query = bson_new();
bson_t *fields = bson_new();
BSON_APPEND_INT32(fields, "RIC", 1);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0,
query, fields, NULL);
bson_iter_t iter;
const bson_value_t *value;
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
printf("%s\n", str);
if (bson_iter_init(&iter, doc)) {
while (bson_iter_next(&iter)) {
printf("Found a field named: %s\n", bson_iter_key(&iter));
value = bson_iter_value(&iter);
if (value->value_type == BSON_TYPE_UTF8) {
printf("It's a UTF8 : '%s'\n", value->value.v_utf8.str);
}
}
}
//printf("Found element key : '%s'\n", bson_iter_key(&iter));
// if (bson_iter_init(&iter, doc)) {
//
// }
bson_free(str);
}
//Now fetch quotes for each RIC
bson_destroy(query);
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
return 0;
}
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);
}
static int mongo_get_oauth_key(const u08bits *kid, oauth_key_data_raw *key) {
mongoc_collection_t * collection = mongo_get_collection("oauth_key");
if (!collection)
return -1;
bson_t query;
bson_init(&query);
BSON_APPEND_UTF8(&query, "kid", (const char *)kid);
bson_t fields;
bson_init(&fields);
BSON_APPEND_INT32(&fields, "lifetime", 1);
BSON_APPEND_INT32(&fields, "timestamp", 1);
BSON_APPEND_INT32(&fields, "as_rs_alg", 1);
BSON_APPEND_INT32(&fields, "ikm_key", 1);
mongoc_cursor_t * cursor;
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0,
&query, &fields, NULL);
int ret = -1;
ns_bzero(key,sizeof(oauth_key_data_raw));
STRCPY(key->kid,kid);
if (!cursor) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,
"Error querying MongoDB collection 'oauth_key'\n");
} else {
const bson_t * item;
uint32_t length;
bson_iter_t iter;
if (mongoc_cursor_next(cursor, &item)) {
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "as_rs_alg") && BSON_ITER_HOLDS_UTF8(&iter)) {
STRCPY(key->as_rs_alg,bson_iter_utf8(&iter, &length));
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "ikm_key") && BSON_ITER_HOLDS_UTF8(&iter)) {
STRCPY(key->ikm_key,bson_iter_utf8(&iter, &length));
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "timestamp") && BSON_ITER_HOLDS_INT64(&iter)) {
key->timestamp = (u64bits)bson_iter_int64(&iter);
}
if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "lifetime") && BSON_ITER_HOLDS_INT32(&iter)) {
key->lifetime = (u32bits)bson_iter_int32(&iter);
}
ret = 0;
}
mongoc_cursor_destroy(cursor);
}
mongoc_collection_destroy(collection);
bson_destroy(&query);
bson_destroy(&fields);
return ret;
}
void
mongoc_gridfs_file_list_destroy (mongoc_gridfs_file_list_t *list)
{
if (!list) {
return;
}
mongoc_cursor_destroy (list->cursor);
bson_free (list);
}
void
mongoc_gridfs_file_destroy (mongoc_gridfs_file_t *file)
{
ENTRY;
BSON_ASSERT (file);
if (file->page) {
_mongoc_gridfs_file_page_destroy (file->page);
}
if (file->bson.len) {
bson_destroy (&file->bson);
}
if (file->cursor) {
mongoc_cursor_destroy (file->cursor);
}
if (file->files_id.value_type) {
bson_value_destroy (&file->files_id);
}
if (file->md5) {
bson_free (file->md5);
}
if (file->filename) {
bson_free (file->filename);
}
if (file->content_type) {
bson_free (file->content_type);
}
if (file->aliases.len) {
bson_destroy (&file->aliases);
}
if (file->bson_aliases.len) {
bson_destroy (&file->bson_aliases);
}
if (file->metadata.len) {
bson_destroy (&file->metadata);
}
if (file->bson_metadata.len) {
bson_destroy (&file->bson_metadata);
}
bson_free (file);
EXIT;
}
char *be_mongo_getuser(void *handle, const char *username)
{
struct mongo_backend *conf = (struct mongo_backend *)handle;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
const char *collection_name = "passport";
bson_t query;
char *str = NULL;
char *result = malloc(33);
memset(result, 0, 33);
bson_init (&query);
bson_append_utf8 (&query, "username", -1, username, -1);
collection = mongoc_client_get_collection (conf->client, "cas", collection_name);
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
0,
0,
&query,
NULL, /* Fields, NULL for all. */
NULL); /* Read Prefs, NULL for default */
bson_iter_t iter;
while (!mongoc_cursor_error (cursor, &error) &&
mongoc_cursor_more (cursor)) {
if (mongoc_cursor_next (cursor, &doc)) {
bson_iter_init(&iter, doc);
bson_iter_find(&iter, "pwd");
//fprintf (stdout, "%s\n", bson_iter_utf8(&iter, NULL));
str = bson_as_json (doc, NULL);
//fprintf (stdout, "%s\n", str);
bson_free (str);
char *src = (char *)bson_iter_utf8(&iter, NULL);
memcpy(result, src, strlen(src));
}
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
return result;
}
bson_destroy (&query);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
return result;
}
/**
* mongoc_database_has_collection:
* @database: (in): A #mongoc_database_t.
* @name: (in): The name of the collection to check for.
* @error: (out) (allow-none): A location for a #bson_error_t, or %NULL.
*
* Checks to see if a collection exists within the database on the MongoDB
* server.
*
* This will return %false if their was an error communicating with the
* server, or if the collection does not exist.
*
* If @error is provided, it will first be zeroed. Upon error, error.domain
* will be set.
*
* Returns: %true if @name exists, otherwise %false. @error may be set.
*/
bool
mongoc_database_has_collection (mongoc_database_t *database,
const char *name,
bson_error_t *error)
{
mongoc_collection_t *collection;
mongoc_read_prefs_t *read_prefs;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_iter_t iter;
bool ret = false;
const char *cur_name;
bson_t q = BSON_INITIALIZER;
char ns[140];
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (name);
if (error) {
memset (error, 0, sizeof *error);
}
bson_snprintf (ns, sizeof ns, "%s.%s", database->name, name);
ns[sizeof ns - 1] = '\0';
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
collection = mongoc_client_get_collection (database->client,
database->name,
"system.namespaces");
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &q,
NULL, read_prefs);
while (!mongoc_cursor_error (cursor, error) &&
mongoc_cursor_more (cursor)) {
while (mongoc_cursor_next (cursor, &doc) &&
bson_iter_init_find (&iter, doc, "name") &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
cur_name = bson_iter_utf8(&iter, NULL);
if (!strcmp(cur_name, ns)) {
ret = true;
GOTO(cleanup);
}
}
}
cleanup:
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_read_prefs_destroy (read_prefs);
RETURN(ret);
}
/**
* mongoc_database_has_collection:
* @database: (in): A #mongoc_database_t.
* @name: (in): The name of the collection to check for.
* @error: (out) (allow-none): A location for a #bson_error_t, or %NULL.
*
* Checks to see if a collection exists within the database on the MongoDB
* server.
*
* This will return %false if their was an error communicating with the
* server, or if the collection does not exist.
*
* If @error is provided, it will first be zeroed. Upon error, error.domain
* will be set.
*
* Returns: %true if @name exists, otherwise %false. @error may be set.
*/
bool
mongoc_database_has_collection (mongoc_database_t *database,
const char *name,
bson_error_t *error)
{
bson_iter_t col_iter;
bool ret = false;
const char *cur_name;
bson_t filter = BSON_INITIALIZER;
mongoc_cursor_t *cursor;
const bson_t *doc;
ENTRY;
BSON_ASSERT (database);
BSON_ASSERT (name);
if (error) {
memset (error, 0, sizeof *error);
}
BSON_APPEND_UTF8 (&filter, "name", name);
cursor = mongoc_database_find_collections (database, &filter, error);
if (!cursor) {
return ret;
}
if (error &&
((error->domain != 0) ||
(error->code != 0))) {
GOTO (cleanup);
}
while (mongoc_cursor_next (cursor, &doc)) {
if (bson_iter_init (&col_iter, doc) &&
bson_iter_find (&col_iter, "name") &&
BSON_ITER_HOLDS_UTF8 (&col_iter) &&
(cur_name = bson_iter_utf8 (&col_iter, NULL))) {
if (!strcmp (cur_name, name)) {
ret = true;
GOTO (cleanup);
}
}
}
cleanup:
mongoc_cursor_destroy (cursor);
RETURN (ret);
}
/* test that we add readConcern only inside $query, not outside it too */
static void
test_mongos_read_concern (void)
{
mock_server_t *server;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_read_prefs_t *prefs;
mongoc_cursor_t *cursor;
const bson_t *doc;
future_t *future;
request_t *request;
server = mock_mongos_new (WIRE_VERSION_READ_CONCERN);
mock_server_run (server);
client = mongoc_client_new_from_uri (mock_server_get_uri (server));
collection = mongoc_client_get_collection (client, "test", "test");
prefs = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);
cursor = mongoc_collection_find_with_opts (
collection,
tmp_bson ("{'a': 1}"),
tmp_bson ("{'readConcern': {'level': 'foo'}}"),
prefs);
future = future_cursor_next (cursor, &doc);
request = mock_server_receives_command (
server,
"test",
MONGOC_QUERY_SLAVE_OK,
"{"
" '$query': {"
" 'find': 'test', 'filter': {}, 'readConcern': {'level': 'foo'}"
" },"
" '$readPreference': {"
" 'mode': 'secondary'"
" },"
" 'readConcern': {'$exists': false}"
"}");
mock_server_replies_to_find (
request, MONGOC_QUERY_SLAVE_OK, 0, 1, "db.collection", "{}", true);
/* mongoc_cursor_next returned true */
BSON_ASSERT (future_get_bool (future));
request_destroy (request);
future_destroy (future);
mongoc_cursor_destroy (cursor);
mongoc_read_prefs_destroy (prefs);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mock_server_destroy (server);
}
int database_find_blockchain_transaction(struct database* db, unsigned char* hash, size_t max_height, struct transaction** tx, size_t* height)
{
mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");
// Build a query doc
bson_t* query = bson_new();
// Set the hash
BSON_APPEND_BINARY(query, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)hash, 32);
// Force the height to be valid (on the main chain)
bson_t* height_doc = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(query, "height", height_doc);
BSON_APPEND_INT32(height_doc, "$lte", (int)max_height);
BSON_APPEND_INT32(height_doc, "$gte", 0);
bson_append_document_end(query, height_doc);
// Perform find
mongoc_cursor_t* cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
bson_error_t error;
if(cursor == NULL || mongoc_cursor_error(cursor, &error)) {
printf("MongoDB error: %s\n", (cursor == NULL) ? "NULL cursor" : error.message);
return -1;
}
bson_t const* doc;
int found = 0;
while(mongoc_cursor_next(cursor, &doc) != 0) {
if(height != NULL) {
bson_iter_t iter;
if(!bson_iter_init_find(&iter, doc, "height") || !BSON_ITER_HOLDS_INT32(&iter)) {
printf("MongoDB error: tx doesn't have height!\n");
return -1;
}
*height = (size_t)bson_iter_int32(&iter);
}
if(tx != NULL) {
*tx = transaction_from_bson(doc);
}
found = 1;
break;
}
mongoc_cursor_destroy(cursor);
bson_destroy(height_doc);
bson_destroy(query);
mongoc_collection_destroy(collection);
return found;
}
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_cursor_new (database->client, database->name,
MONGOC_QUERY_SLAVE_OK, 0, 0, 0, true,
NULL, NULL, NULL, NULL);
_mongoc_cursor_cursorid_init (cursor, &cmd);
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);
}
}
}
bson_destroy (&cmd);
mongoc_read_prefs_destroy (read_prefs);
return cursor;
}
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 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);
}
int be_mongo_superuser(void *conf, const char *username)
{
struct mongo_backend *handle = (struct mongo_backend *) conf;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
int result;
bson_t query;
bson_iter_t iter;
bson_init (&query);
bson_append_utf8(&query, "username", -1, username, -1);
collection = mongoc_client_get_collection(handle->client, dbName, colName);
cursor = mongoc_collection_find(collection,
MONGOC_QUERY_NONE,
0,
0,
0,
&query,
NULL,
NULL);
while (!mongoc_cursor_error (cursor, &error) &&
mongoc_cursor_more (cursor)) {
if (mongoc_cursor_next (cursor, &doc)) {
bson_iter_init(&iter, doc);
bson_iter_find(&iter, superUser);
result = (int64_t) bson_iter_as_int64(&iter);
//_log(LOG_NOTICE, "SUPERUSER: %d", result);
}
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
return result;
}
bson_destroy (&query);
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
return result;
}
