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 (strstr (error.message, "a_non_existing_command")); mongoc_database_destroy (database); mongoc_client_destroy (client); bson_destroy (&cmd); }
static void test_load (mongoc_client_t *client, unsigned iterations) { mongoc_collection_t *col; mongoc_database_t *db; bson_error_t error; unsigned i; bson_t b; bson_t q; bson_init(&b); bson_append_int32(&b, "ping", 4, 1); bson_init(&q); db = mongoc_client_get_database(client, "admin"); col = mongoc_client_get_collection(client, "test", "test"); for (i = 0; i < iterations; i++) { ping(db, &b); fetch(col, &q); } if (!mongoc_collection_drop(col, &error)) { MONGOC_WARNING("Failed to drop collection: %s", error.message); } mongoc_database_destroy(db); db = mongoc_client_get_database(client, "test"); if (!mongoc_database_drop(db, &error)) { MONGOC_WARNING("Failed to drop database: %s", error.message); } mongoc_database_destroy(db); mongoc_collection_destroy(col); bson_destroy(&b); }
static void test_create_collection (void) { mongoc_database_t *database; mongoc_collection_t *collection; mongoc_client_t *client; bson_error_t error = { 0 }; bson_t options; bson_t storage_opts; bson_t wt_opts; char *dbname; char *name; bool r; client = mongoc_client_new (gTestUri); assert (client); dbname = gen_collection_name ("dbtest"); database = mongoc_client_get_database (client, dbname); assert (database); bson_free (dbname); bson_init (&options); BSON_APPEND_INT32 (&options, "size", 1234); BSON_APPEND_INT32 (&options, "max", 4567); BSON_APPEND_BOOL (&options, "capped", true); BSON_APPEND_BOOL (&options, "autoIndexId", true); BSON_APPEND_DOCUMENT_BEGIN(&options, "storage", &storage_opts); BSON_APPEND_DOCUMENT_BEGIN(&storage_opts, "wiredtiger", &wt_opts); BSON_APPEND_UTF8(&wt_opts, "configString", "block_compressor=zlib"); bson_append_document_end(&storage_opts, &wt_opts); bson_append_document_end(&options, &storage_opts); name = gen_collection_name ("create_collection"); collection = mongoc_database_create_collection (database, name, &options, &error); assert (collection); bson_free (name); r = mongoc_collection_drop (collection, &error); assert (r); r = mongoc_database_drop (database, &error); assert (r); mongoc_collection_destroy (collection); mongoc_database_destroy (database); mongoc_client_destroy (client); }
void free_db_connect() { if (client == NULL) { printf("mongdb do not connect\n"); return; } if (database == NULL) { printf("database is null\n"); } else { mongoc_database_destroy(database); } mongoc_client_destroy(client); return; };
static void test_save (void) { mongoc_collection_t *collection; mongoc_database_t *database; mongoc_client_t *client; bson_context_t *context; bson_error_t error; bool r; bson_oid_t oid; unsigned i; bson_t b; client = mongoc_client_new(gTestUri); ASSERT (client); database = get_test_database (client); ASSERT (database); collection = get_test_collection (client, "test_save"); ASSERT (collection); mongoc_collection_drop (collection, &error); context = bson_context_new(BSON_CONTEXT_NONE); ASSERT (context); for (i = 0; i < 10; i++) { bson_init(&b); bson_oid_init(&oid, context); bson_append_oid(&b, "_id", 3, &oid); bson_append_utf8(&b, "hello", 5, "/world", 5); r = mongoc_collection_save(collection, &b, NULL, &error); if (!r) { MONGOC_WARNING("%s\n", error.message); } ASSERT (r); bson_destroy(&b); } bson_destroy (&b); r = mongoc_collection_drop (collection, &error); ASSERT (r); mongoc_collection_destroy(collection); mongoc_database_destroy(database); bson_context_destroy(context); mongoc_client_destroy(client); }
static void multi_upload_before (perf_test_t *test) { multi_upload_test_t *upload_test; mongoc_client_t *client; mongoc_gridfs_t *gridfs; bson_error_t error; mongoc_database_t *db; multi_upload_thread_context_t *ctx; int i; perf_test_before (test); upload_test = (multi_upload_test_t *) test; client = mongoc_client_pool_pop (upload_test->pool); db = mongoc_client_get_database (client, "perftest"); if (!mongoc_database_drop (db, &error)) { MONGOC_ERROR ("database_drop: %s\n", error.message); abort (); } gridfs = mongoc_client_get_gridfs (client, "perftest", NULL, &error); if (!gridfs) { MONGOC_ERROR ("get_gridfs: %s\n", error.message); abort (); } write_one_byte_file (gridfs); mongoc_gridfs_destroy (gridfs); mongoc_client_pool_push (upload_test->pool, client); for (i = 0; i < upload_test->cnt; i++) { ctx = &upload_test->contexts[i]; ctx->client = mongoc_client_pool_pop (upload_test->pool); ctx->gridfs = mongoc_client_get_gridfs (ctx->client, "perftest", NULL, &error); if (!ctx->gridfs) { MONGOC_ERROR ("get_gridfs: %s\n", error.message); abort (); } ctx->stream = mongoc_stream_file_new_for_path (ctx->path, O_RDONLY, 0); if (!ctx->stream) { perror ("stream_new_for_path"); abort (); } } mongoc_database_destroy (db); }
static void _drop_database (gridfs_test_t *gridfs_test) { mongoc_database_t *db; bson_error_t error; db = mongoc_client_get_database (gridfs_test->client, "perftest"); if (!mongoc_database_drop (db, &error)) { MONGOC_ERROR ("database_drop: %s\n", error.message); abort (); } mongoc_database_destroy (db); }
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; }
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_CMPINT(r, ==, false); }
static void test_has_collection (void) { mongoc_collection_t *collection; mongoc_database_t *database; mongoc_client_t *client; bson_error_t error; char *name; bool r; bson_oid_t oid; bson_t b; client = mongoc_client_new (gTestUri); assert (client); name = gen_collection_name ("has_collection"); collection = mongoc_client_get_collection (client, "test", name); assert (collection); database = mongoc_client_get_database (client, "test"); assert (database); bson_init (&b); bson_oid_init (&oid, NULL); bson_append_oid (&b, "_id", 3, &oid); bson_append_utf8 (&b, "hello", 5, "world", 5); r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &b, NULL, &error); if (!r) { MONGOC_WARNING ("%s\n", error.message); } assert (r); bson_destroy (&b); r = mongoc_database_has_collection (database, name, &error); assert (!error.domain); assert (r); bson_free (name); mongoc_database_destroy (database); mongoc_collection_destroy (collection); mongoc_client_destroy (client); }
static void test_index (void) { mongoc_collection_t *collection; mongoc_database_t *database; mongoc_client_t *client; mongoc_index_opt_t opt; bson_error_t error; bool r; bson_t keys; mongoc_index_opt_init(&opt); client = mongoc_client_new(gTestUri); ASSERT (client); database = get_test_database (client); ASSERT (database); collection = get_test_collection (client, "test_index"); ASSERT (collection); bson_init(&keys); bson_append_int32(&keys, "hello", -1, 1); r = mongoc_collection_create_index(collection, &keys, &opt, &error); ASSERT (r); r = mongoc_collection_create_index(collection, &keys, &opt, &error); ASSERT (r); r = mongoc_collection_drop_index(collection, "hello_1", &error); ASSERT (r); bson_destroy(&keys); r = mongoc_collection_drop (collection, &error); ASSERT (r); mongoc_collection_destroy(collection); mongoc_database_destroy(database); mongoc_client_destroy(client); }
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; bool r; bson_t q; /* * Add a user to the test database. */ client = mongoc_client_new(gTestUri); database = mongoc_client_get_database(client, "test"); mongoc_database_remove_user (database, "testuser", &error); r = mongoc_database_add_user(database, "testuser", "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(gTestUriWithPassword); 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("%s", error.message); assert(!r); } mongoc_cursor_destroy(cursor); mongoc_collection_destroy(collection); mongoc_client_destroy(client); }
static void test_create_collection (void) { mongoc_database_t *database; mongoc_collection_t *collection; mongoc_client_t *client; bson_error_t error = { 0 }; bson_t options; char *dbname; char *name; bool r; client = mongoc_client_new (gTestUri); assert (client); dbname = gen_collection_name ("dbtest"); database = mongoc_client_get_database (client, dbname); assert (database); bson_free (dbname); bson_init (&options); BSON_APPEND_INT32 (&options, "size", 1234); BSON_APPEND_INT32 (&options, "max", 4567); BSON_APPEND_BOOL (&options, "capped", true); BSON_APPEND_BOOL (&options, "autoIndexId", true); name = gen_collection_name ("create_collection"); collection = mongoc_database_create_collection (database, name, &options, &error); assert (collection); bson_free (name); r = mongoc_collection_drop (collection, &error); assert (r); r = mongoc_database_drop (database, &error); assert (r); mongoc_collection_destroy (collection); mongoc_database_destroy (database); mongoc_client_destroy (client); }
bool copydb (mongoc_client_t *client, const char *other_host_and_port) { mongoc_database_t *admindb; bson_t *command; bson_t reply; bson_error_t error; bool res; BSON_ASSERT (other_host_and_port); /* Must do this from the admin db */ admindb = mongoc_client_get_database (client, "admin"); command = BCON_NEW ("copydb", BCON_INT32 (1), "fromdb", BCON_UTF8 ("test"), "todb", BCON_UTF8 ("test2"), /* If you want from a different host */ "fromhost", BCON_UTF8 (other_host_and_port)); res = mongoc_database_command_simple (admindb, command, NULL, &reply, &error); if (!res) { fprintf (stderr, "Error with copydb: %s\n", error.message); goto cleanup; } /* Do something with the reply */ print_res (&reply); cleanup: bson_destroy (&reply); bson_destroy (command); mongoc_database_destroy (admindb); return res; }
static void test_drop (void) { mongoc_database_t *database; mongoc_client_t *client; bson_error_t error = { 0 }; char *dbname; bool r; client = mongoc_client_new (gTestUri); assert (client); dbname = gen_collection_name ("db_drop_test"); database = mongoc_client_get_database (client, dbname); bson_free (dbname); r = mongoc_database_drop (database, &error); assert (r); assert (!error.domain); assert (!error.code); mongoc_database_destroy (database); mongoc_client_destroy (client); }
int main (int argc, char *argv[]) { mongoc_database_t *database = NULL; mongoc_client_t *client = NULL; mongoc_collection_t *collection = NULL; char *host_and_port; int res = 0; char* other_host_and_port = NULL; if (argc < 2 || argc > 3) { fprintf (stderr, "usage: %s MONGOD-1-CONNECTION-STRING " "[MONGOD-2-HOST-NAME:MONGOD-2-PORT]\n", argv[0]); fprintf (stderr, "MONGOD-1-CONNECTION-STRING can be " "of the following forms:\n"); fprintf (stderr, "localhost\t\t\t\tlocal machine\n"); fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n"); fprintf (stderr, "mongodb://*****:*****@localhost:27017\t" "local machine on port 27017, and authenticate with username " "user and password pass\n"); return 1; } mongoc_init (); if (strncmp (argv[1], "mongodb://", 10) == 0) { host_and_port = bson_strdup (argv [1]); } else { host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]); } other_host_and_port = argc > 2 ? argv[2] : NULL; client = mongoc_client_new (host_and_port); if (!client) { fprintf(stderr, "Invalid hostname or port: %s\n", host_and_port); res = 2; goto cleanup; } database = mongoc_client_get_database (client, "test"); collection = mongoc_database_get_collection (database, COLLECTION_NAME); printf ("Inserting data\n"); if (!insert_data (collection)) { res = 3; goto cleanup; } printf ("explain\n"); if (!explain (collection)) { res = 4; goto cleanup; } if (other_host_and_port) { printf ("copydb\n"); if (!copydb (client, other_host_and_port)) { res = 5; goto cleanup; } printf ("clone collection\n"); if (!clone_collection (database, other_host_and_port)) { res = 6; goto cleanup; } } cleanup: if (collection) { mongoc_collection_destroy (collection); } if (database) { mongoc_database_destroy (database); } if (client) { mongoc_client_destroy (client); } bson_free (host_and_port); mongoc_cleanup (); return res; }
int main (int argc, char *argv[]) { mongoc_database_t *database; mongoc_client_t *client; bson_t reply; uint16_t port; bson_error_t error; bson_t ping; char *host_and_port; char *str; bool r; if (argc < 2 || argc > 3) { fprintf (stderr, "usage: %s HOSTNAME [PORT]\n", argv[0]); return 1; } mongoc_init (); port = (argc == 3) ? atoi (argv[2]) : 27017; if (!strncmp (argv[1], "mongodb://", 10) || !strncmp (argv[1], "mongodb+srv://", 14)) { host_and_port = bson_strdup (argv[1]); } else { 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); bson_free (host_and_port); return 2; } bson_free (host_and_port); mongoc_client_set_error_api (client, 2); bson_init (&ping); bson_append_int32 (&ping, "ping", 4, 1); database = mongoc_client_get_database (client, "test"); r = mongoc_database_command_with_opts ( database, &ping, NULL, NULL, &reply, &error); if (r) { str = bson_as_canonical_extended_json (&reply, NULL); fprintf (stdout, "%s\n", str); bson_free (str); } else { fprintf (stderr, "Ping failure: %s\n", error.message); } bson_destroy (&ping); bson_destroy (&reply); mongoc_database_destroy (database); mongoc_client_destroy (client); return r ? 0 : 3; }
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); }
int main (int argc, char *argv[]) { const char *uri_str = "mongodb://localhost:27017"; mongoc_client_t *client; mongoc_database_t *database; mongoc_collection_t *collection; bson_t *command, reply, *insert; bson_error_t error; char *str; bool retval; /* * Required to initialize libmongoc's internals */ mongoc_init (); /* * Optionally get MongoDB URI from command line */ if (argc > 1) { uri_str = argv[1]; } /* * Create a new client instance */ client = mongoc_client_new (uri_str); /* * Register the application name so we can track it in the profile logs * on the server. This can also be done from the URI (see other examples). */ mongoc_client_set_appname (client, "connect-example"); /* * Get a handle on the database "db_name" and collection "coll_name" */ database = mongoc_client_get_database (client, "db_name"); collection = mongoc_client_get_collection (client, "db_name", "coll_name"); /* * Do work. This example pings the database, prints the result as JSON and * performs an insert */ command = BCON_NEW ("ping", BCON_INT32 (1)); retval = mongoc_client_command_simple ( client, "admin", command, NULL, &reply, &error); if (!retval) { fprintf (stderr, "%s\n", error.message); return EXIT_FAILURE; } str = bson_as_json (&reply, NULL); printf ("%s\n", str); insert = BCON_NEW ("hello", BCON_UTF8 ("world")); if (!mongoc_collection_insert ( collection, MONGOC_INSERT_NONE, insert, NULL, &error)) { fprintf (stderr, "%s\n", error.message); } bson_destroy (insert); bson_destroy (&reply); bson_destroy (command); bson_free (str); /* * Release our handles and clean up libmongoc */ mongoc_collection_destroy (collection); mongoc_database_destroy (database); mongoc_client_destroy (client); mongoc_cleanup (); return 0; }
static void test_insert_bulk (void) { mongoc_collection_t *collection; mongoc_database_t *database; mongoc_client_t *client; bson_context_t *context; bson_error_t error; bool r; bson_oid_t oid; unsigned i; bson_t q; bson_t b[10]; bson_t *bptr[10]; int64_t count; client = mongoc_client_new(gTestUri); ASSERT (client); database = get_test_database (client); ASSERT (database); collection = get_test_collection (client, "test_insert_bulk"); ASSERT (collection); mongoc_collection_drop(collection, &error); context = bson_context_new(BSON_CONTEXT_NONE); ASSERT (context); bson_init(&q); bson_append_int32(&q, "n", -1, 0); for (i = 0; i < 10; i++) { bson_init(&b[i]); bson_oid_init(&oid, context); bson_append_oid(&b[i], "_id", -1, &oid); bson_append_int32(&b[i], "n", -1, i % 2); bptr[i] = &b[i]; } BEGIN_IGNORE_DEPRECATIONS; r = mongoc_collection_insert_bulk (collection, MONGOC_INSERT_NONE, (const bson_t **)bptr, 10, NULL, &error); END_IGNORE_DEPRECATIONS; if (!r) { MONGOC_WARNING("%s\n", error.message); } ASSERT (r); count = mongoc_collection_count (collection, MONGOC_QUERY_NONE, &q, 0, 0, NULL, &error); ASSERT (count == 5); for (i = 8; i < 10; i++) { bson_destroy(&b[i]); bson_init(&b[i]); bson_oid_init(&oid, context); bson_append_oid(&b[i], "_id", -1, &oid); bson_append_int32(&b[i], "n", -1, i % 2); bptr[i] = &b[i]; } BEGIN_IGNORE_DEPRECATIONS; r = mongoc_collection_insert_bulk (collection, MONGOC_INSERT_NONE, (const bson_t **)bptr, 10, NULL, &error); END_IGNORE_DEPRECATIONS; ASSERT (!r); ASSERT (error.code == 11000); count = mongoc_collection_count (collection, MONGOC_QUERY_NONE, &q, 0, 0, NULL, &error); ASSERT (count == 5); BEGIN_IGNORE_DEPRECATIONS; r = mongoc_collection_insert_bulk (collection, MONGOC_INSERT_CONTINUE_ON_ERROR, (const bson_t **)bptr, 10, NULL, &error); END_IGNORE_DEPRECATIONS; ASSERT (!r); ASSERT (error.code == 11000); count = mongoc_collection_count (collection, MONGOC_QUERY_NONE, &q, 0, 0, NULL, &error); ASSERT (count == 6); bson_destroy(&q); for (i = 0; i < 10; i++) { bson_destroy(&b[i]); } r = mongoc_collection_drop (collection, &error); ASSERT (r); mongoc_collection_destroy(collection); mongoc_database_destroy(database); bson_context_destroy(context); mongoc_client_destroy(client); }
static void test_func_inherits_opts (void *ctx) { opt_inheritance_test_t *test = (opt_inheritance_test_t *) ctx; /* for example, test mongoc_collection_find_with_opts with no read pref, * with a read pref set on the collection (OPT_SOURCE_COLL), with an explicit * read pref (OPT_SOURCE_FUNC), or with one read pref on the collection and * a different one passed explicitly */ opt_source_t source_matrix[] = {OPT_SOURCE_NONE, test->opt_source, OPT_SOURCE_FUNC, test->opt_source | OPT_SOURCE_FUNC}; size_t i; func_ctx_t func_ctx; mock_rs_t *rs; mongoc_client_t *client; mongoc_database_t *db; mongoc_collection_t *collection; bson_t opts = BSON_INITIALIZER; mongoc_read_prefs_t *func_prefs = NULL; future_t *future; request_t *request; bson_t cmd = BSON_INITIALIZER; bool expect_secondary; bson_error_t error; /* one primary, one secondary */ rs = mock_rs_with_autoismaster (WIRE_VERSION_OP_MSG, true, 1, 0); /* we use read pref tags like "collection": "yes" to verify where the * pref was inherited from; ensure all secondaries match all tags */ mock_rs_tag_secondary (rs, 0, tmp_bson ("{'client': 'yes'," " 'database': 'yes'," " 'collection': 'yes'," " 'function': 'yes'}")); mock_rs_run (rs); /* iterate over all combinations of options sources: e.g., an option set on * collection and not function, on function not collection, both, neither */ for (i = 0; i < sizeof (source_matrix) / (sizeof (opt_source_t)); i++) { expect_secondary = false; func_prefs = NULL; bson_reinit (&cmd); bson_reinit (&opts); client = mongoc_client_new_from_uri (mock_rs_get_uri (rs)); if (source_matrix[i] & OPT_SOURCE_CLIENT) { set_client_opt (client, test->opt_type); } db = mongoc_client_get_database (client, "database"); if (source_matrix[i] & OPT_SOURCE_DB) { set_database_opt (db, test->opt_type); } collection = mongoc_database_get_collection (db, "collection"); if (source_matrix[i] & OPT_SOURCE_COLL) { set_collection_opt (collection, test->opt_type); } if (source_matrix[i] & OPT_SOURCE_FUNC) { set_func_opt (&opts, &func_prefs, test->opt_type); } func_ctx_init ( &func_ctx, test, client, db, collection, func_prefs, &opts); /* func_with_opts creates expected "cmd", like {insert: 'collection'} */ future = test->func_with_opts (&func_ctx, &cmd); if (source_matrix[i] != OPT_SOURCE_NONE) { add_expected_opt (source_matrix[i], test->opt_type, &cmd); if (test->opt_type == OPT_READ_PREFS) { expect_secondary = true; } } /* write commands send two OP_MSG sections */ if (test->n_sections == 2) { request = mock_rs_receives_msg (rs, 0, &cmd, tmp_bson ("{}")); } else { request = mock_rs_receives_msg (rs, 0, &cmd); } if (expect_secondary) { BSON_ASSERT (mock_rs_request_is_to_secondary (rs, request)); } else { BSON_ASSERT (mock_rs_request_is_to_primary (rs, request)); } if (func_ctx.cursor) { mock_server_replies_simple (request, "{'ok': 1," " 'cursor': {" " 'id': 0," " 'ns': 'db.collection'," " 'firstBatch': []}}"); BSON_ASSERT (!future_get_bool (future)); future_destroy (future); ASSERT_OR_PRINT (!mongoc_cursor_error (func_ctx.cursor, &error), error); } else { mock_server_replies_simple (request, "{'ok': 1}"); cleanup_future (future); } request_destroy (request); mongoc_read_prefs_destroy (func_prefs); func_ctx_cleanup (&func_ctx); mongoc_collection_destroy (collection); mongoc_database_destroy (db); mongoc_client_destroy (client); } bson_destroy (&cmd); bson_destroy (&opts); mock_rs_destroy (rs); }
~impl() { mongoc_database_destroy(database_t); }
static void test_update (void) { mongoc_collection_t *collection; mongoc_database_t *database; mongoc_client_t *client; bson_context_t *context; bson_error_t error; bool r; bson_oid_t oid; unsigned i; bson_t b; bson_t q; bson_t u; bson_t set; client = mongoc_client_new(gTestUri); ASSERT (client); database = get_test_database (client); ASSERT (database); collection = get_test_collection (client, "test_update"); ASSERT (collection); context = bson_context_new(BSON_CONTEXT_NONE); ASSERT (context); for (i = 0; i < 10; i++) { bson_init(&b); bson_oid_init(&oid, context); bson_append_oid(&b, "_id", 3, &oid); bson_append_utf8(&b, "utf8", 4, "utf8 string", 11); bson_append_int32(&b, "int32", 5, 1234); bson_append_int64(&b, "int64", 5, 12345678); bson_append_bool(&b, "bool", 4, 1); r = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &b, NULL, &error); if (!r) { MONGOC_WARNING("%s\n", error.message); } ASSERT (r); bson_init(&q); bson_append_oid(&q, "_id", 3, &oid); bson_init(&u); bson_append_document_begin(&u, "$set", 4, &set); bson_append_utf8(&set, "utf8", 4, "updated", 7); bson_append_document_end(&u, &set); r = mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &q, &u, NULL, &error); if (!r) { MONGOC_WARNING("%s\n", error.message); } ASSERT (r); bson_destroy(&b); bson_destroy(&q); bson_destroy(&u); } bson_init(&q); bson_init(&u); BSON_APPEND_INT32 (&u, "abcd", 1); BSON_APPEND_INT32 (&u, "$hi", 1); r = mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &q, &u, NULL, &error); ASSERT (!r); ASSERT (error.domain == MONGOC_ERROR_BSON); ASSERT (error.code == MONGOC_ERROR_BSON_INVALID); bson_destroy(&q); bson_destroy(&u); bson_init(&q); bson_init(&u); BSON_APPEND_INT32 (&u, "a.b.c.d", 1); r = mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &q, &u, NULL, &error); ASSERT (!r); ASSERT (error.domain == MONGOC_ERROR_BSON); ASSERT (error.code == MONGOC_ERROR_BSON_INVALID); bson_destroy(&q); bson_destroy(&u); r = mongoc_collection_drop (collection, &error); ASSERT (r); mongoc_collection_destroy(collection); mongoc_database_destroy(database); bson_context_destroy(context); mongoc_client_destroy(client); }
static void test_get_collection_names (void) { mongoc_database_t *database; mongoc_collection_t *collection; mongoc_client_t *client; bson_error_t error = { 0 }; bson_t options; int r; int namecount = 0; char **names; char **name; char *curname; char *dbname; char *name1; char *name2; char *name3; char *name4; char *name5; const char *system_prefix = "system."; client = mongoc_client_new (gTestUri); assert (client); dbname = gen_collection_name ("dbtest"); database = mongoc_client_get_database (client, dbname); assert (database); bson_free (dbname); bson_init (&options); name1 = gen_collection_name ("name1"); name2 = gen_collection_name ("name2"); name3 = gen_collection_name ("name3"); name4 = gen_collection_name ("name4"); name5 = gen_collection_name ("name5"); collection = mongoc_database_create_collection (database, name1, &options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, name2, &options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, name3, &options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, name4, &options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, name5, &options, &error); assert (collection); mongoc_collection_destroy (collection); names = mongoc_database_get_collection_names (database, &error); assert (!error.domain); assert (!error.code); for (name = names; *name; ++name) { /* inefficient, but OK for a unit test. */ curname = *name; if (0 == strcmp (curname, name1) || 0 == strcmp (curname, name2) || 0 == strcmp (curname, name3) || 0 == strcmp (curname, name4) || 0 == strcmp (curname, name5)) { ++namecount; } else if (0 == strncmp (curname, system_prefix, strlen (system_prefix))) { /* Collections prefixed with 'system.' are system collections */ } else { assert (false); } bson_free (curname); } assert (namecount == 5); bson_free (name1); bson_free (name2); bson_free (name3); bson_free (name4); bson_free (name5); bson_free (names); r = mongoc_database_drop (database, &error); assert (r); assert (!error.domain); assert (!error.code); mongoc_database_destroy (database); mongoc_client_destroy (client); }
int main (int argc, char *argv[]) { const char *uri_string = "mongodb://localhost:27017/?appname=new-gridfs-example"; mongoc_client_t *client; mongoc_database_t *db; mongoc_stream_t *file_stream; mongoc_gridfs_bucket_t *bucket; mongoc_cursor_t *cursor; bson_t filter; bool res; bson_value_t file_id; bson_error_t error; const bson_t *doc; char *str; mongoc_init (); if (argc != 3) { fprintf (stderr, "usage: %s SOURCE_FILE_PATH FILE_COPY_PATH\n", argv[0]); return EXIT_FAILURE; } /* 1. Make a bucket. */ client = mongoc_client_new (uri_string); db = mongoc_client_get_database (client, "test"); bucket = mongoc_gridfs_bucket_new (db, NULL, NULL); /* 2. Insert a file. */ file_stream = mongoc_stream_file_new_for_path (argv[1], O_RDONLY, 0); res = mongoc_gridfs_bucket_upload_from_stream ( bucket, "my-file", file_stream, NULL, &file_id, &error); if (!res) { printf ("Error uploading file: %s\n", error.message); return EXIT_FAILURE; } mongoc_stream_close (file_stream); mongoc_stream_destroy (file_stream); /* 3. Download the file in GridFS to a local file. */ file_stream = mongoc_stream_file_new_for_path (argv[2], O_CREAT | O_RDWR, 0); if (!file_stream) { perror ("Error opening file stream"); return EXIT_FAILURE; } res = mongoc_gridfs_bucket_download_to_stream ( bucket, &file_id, file_stream, &error); if (!res) { printf ("Error downloading file to stream: %s\n", error.message); return EXIT_FAILURE; } mongoc_stream_close (file_stream); mongoc_stream_destroy (file_stream); /* 4. List what files are available in GridFS. */ bson_init (&filter); cursor = mongoc_gridfs_bucket_find (bucket, &filter, NULL); while (mongoc_cursor_next (cursor, &doc)) { str = bson_as_canonical_extended_json (doc, NULL); printf ("%s\n", str); bson_free (str); } /* 5. Delete the file that we added. */ res = mongoc_gridfs_bucket_delete_by_id (bucket, &file_id, &error); if (!res) { printf ("Error deleting the file: %s\n", error.message); return EXIT_FAILURE; } /* 6. Cleanup. */ mongoc_stream_close (file_stream); mongoc_stream_destroy (file_stream); mongoc_cursor_destroy (cursor); bson_destroy (&filter); mongoc_gridfs_bucket_destroy (bucket); mongoc_database_destroy (db); mongoc_client_destroy (client); mongoc_cleanup (); return EXIT_SUCCESS; }
static void test_get_collection_info (void) { mongoc_database_t *database; mongoc_collection_t *collection; mongoc_client_t *client; bson_error_t error = { 0 }; bson_iter_t iter; bson_iter_t col_array; bson_iter_t col_iter; bson_t capped_options = BSON_INITIALIZER; bson_t autoindexid_options = BSON_INITIALIZER; bson_t noopts_options = BSON_INITIALIZER; bson_t name_filter = BSON_INITIALIZER; int r; int num_infos = 0; bson_t *infos = NULL; const char *name; char *dbname; char *capped_name; char *autoindexid_name; char *noopts_name; client = mongoc_client_new (gTestUri); assert (client); dbname = gen_collection_name ("dbtest"); database = mongoc_client_get_database (client, dbname); assert (database); bson_free (dbname); capped_name = gen_collection_name ("capped"); BSON_APPEND_BOOL (&capped_options, "capped", true); BSON_APPEND_INT32 (&capped_options, "size", 10000000); BSON_APPEND_INT32 (&capped_options, "max", 1024); autoindexid_name = gen_collection_name ("autoindexid"); BSON_APPEND_BOOL (&autoindexid_options, "autoIndexId", false); noopts_name = gen_collection_name ("noopts"); collection = mongoc_database_create_collection (database, capped_name, &capped_options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, autoindexid_name, &autoindexid_options, &error); assert (collection); mongoc_collection_destroy (collection); collection = mongoc_database_create_collection (database, noopts_name, &noopts_options, &error); assert (collection); mongoc_collection_destroy (collection); /* first we filter on collection name. */ BSON_APPEND_UTF8 (&name_filter, "name", noopts_name); /* We only test with filters since get_collection_names will * test w/o filters for us. */ /* Filter on an exact match of name */ infos = mongoc_database_get_collection_info (database, &name_filter, &error); assert (infos); assert (!error.domain); assert (!error.code); if (bson_iter_init_find (&iter, infos, "collections") && BSON_ITER_HOLDS_ARRAY (&iter) && bson_iter_recurse (&iter, &col_array)) { while (bson_iter_next (&col_array)) { if (BSON_ITER_HOLDS_DOCUMENT (&col_array) && bson_iter_recurse (&col_array, &col_iter) && bson_iter_find (&col_iter, "name") && BSON_ITER_HOLDS_UTF8 (&col_iter) && (name = bson_iter_utf8 (&col_iter, NULL))) { ++num_infos; assert (0 == strcmp (name, noopts_name)); } else { assert (false); } } } assert (1 == num_infos); num_infos = 0; bson_destroy (infos); infos = NULL; r = mongoc_database_drop (database, &error); assert (r); assert (!error.domain); assert (!error.code); bson_free (capped_name); bson_free (noopts_name); bson_free (autoindexid_name); mongoc_database_destroy (database); mongoc_client_destroy (client); }
static void test_aggregate (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; bool r; bson_t b; bson_t opts; bson_t match; bson_t pipeline; bson_iter_t iter; int i; bson_init(&b); bson_append_utf8(&b, "hello", -1, "world", -1); bson_init(&match); bson_append_document(&match, "$match", -1, &b); bson_init(&pipeline); bson_append_document(&pipeline, "0", -1, &match); client = mongoc_client_new(gTestUri); ASSERT (client); database = get_test_database (client); ASSERT (database); collection = get_test_collection (client, "test_aggregate"); ASSERT (collection); mongoc_collection_drop(collection, &error); r = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &b, NULL, &error); ASSERT (r); for (i = 0; i < 2; i++) { if (i % 2 == 0) { cursor = mongoc_collection_aggregate(collection, MONGOC_QUERY_NONE, &pipeline, NULL, NULL); ASSERT (cursor); } else { bson_init (&opts); BSON_APPEND_INT32 (&opts, "batchSize", 10); BSON_APPEND_BOOL (&opts, "allowDiskUse", true); cursor = mongoc_collection_aggregate(collection, MONGOC_QUERY_NONE, &pipeline, &opts, NULL); ASSERT (cursor); bson_destroy (&opts); } /* * This can fail if we are connecting to a 2.0 MongoDB instance. */ r = mongoc_cursor_next(cursor, &doc); if (mongoc_cursor_error(cursor, &error)) { if ((error.domain == MONGOC_ERROR_QUERY) && (error.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND)) { mongoc_cursor_destroy (cursor); break; } MONGOC_WARNING("[%d.%d] %s", error.domain, error.code, error.message); } ASSERT (r); ASSERT (doc); ASSERT (bson_iter_init_find (&iter, doc, "hello") && BSON_ITER_HOLDS_UTF8 (&iter)); r = mongoc_cursor_next(cursor, &doc); if (mongoc_cursor_error(cursor, &error)) { MONGOC_WARNING("%s", error.message); } ASSERT (!r); ASSERT (!doc); mongoc_cursor_destroy(cursor); } r = mongoc_collection_drop(collection, &error); ASSERT (r); mongoc_collection_destroy(collection); mongoc_database_destroy(database); mongoc_client_destroy(client); bson_destroy(&b); bson_destroy(&pipeline); bson_destroy(&match); }
static void test_bypass_validation (void *context) { mongoc_collection_t *collection2; mongoc_collection_t *collection; bson_t reply; mongoc_bulk_operation_t *bulk; mongoc_database_t *database; mongoc_write_concern_t *wr; mongoc_client_t *client; bson_error_t error; bson_t *options; char *collname; char *dbname; int r; int i; client = test_framework_client_new (); assert (client); dbname = gen_collection_name ("dbtest"); collname = gen_collection_name ("bypass"); database = mongoc_client_get_database (client, dbname); collection = mongoc_database_get_collection (database, collname); assert (collection); options = tmp_bson ("{'validator': {'number': {'$gte': 5}}, 'validationAction': 'error'}"); collection2 = mongoc_database_create_collection (database, collname, options, &error); ASSERT_OR_PRINT(collection2, error); mongoc_collection_destroy (collection2); /* {{{ Default fails validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson ("{'number': 3, 'high': %d }", i); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); bson_destroy (&reply); ASSERT(!r); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation"); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ bypass_document_validation=false Fails validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); mongoc_bulk_operation_set_bypass_document_validation (bulk, false); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson ("{'number': 3, 'high': %d }", i); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); bson_destroy (&reply); ASSERT(!r); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation"); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ bypass_document_validation=true ignores validation */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); mongoc_bulk_operation_set_bypass_document_validation (bulk, true); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson ("{'number': 3, 'high': %d }", i); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); bson_destroy (&reply); ASSERT_OR_PRINT(r, error); mongoc_bulk_operation_destroy (bulk); /* }}} */ /* {{{ w=0 and bypass_document_validation=set fails */ bulk = mongoc_collection_create_bulk_operation(collection, true, NULL); wr = mongoc_write_concern_new (); mongoc_write_concern_set_w (wr, 0); mongoc_bulk_operation_set_write_concern (bulk, wr); mongoc_bulk_operation_set_bypass_document_validation (bulk, true); for (i = 0; i < 3; i++) { bson_t *doc = tmp_bson ("{'number': 3, 'high': %d }", i); mongoc_bulk_operation_insert (bulk, doc); } r = mongoc_bulk_operation_execute (bulk, &reply, &error); bson_destroy (&reply); ASSERT_OR_PRINT(!r, error); ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG, "Cannot set bypassDocumentValidation for unacknowledged writes"); mongoc_bulk_operation_destroy (bulk); mongoc_write_concern_destroy (wr); /* }}} */ ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error); bson_free (dbname); bson_free (collname); mongoc_database_destroy (database); mongoc_collection_destroy (collection); mongoc_client_destroy (client); }
int main (int argc, char *argv[]) { mongoc_client_t *client = NULL; mongoc_database_t *database = NULL; mongoc_collection_t *collection = NULL; mongoc_cursor_t *cursor = NULL; bson_error_t error; const char *uristr = "mongodb://127.0.0.1/"; const char *authuristr; bson_t roles; bson_t query; const bson_t *doc; if (argc != 2) { printf ("%s - [implicit|scram]\n", argv[0]); return 1; } if (strcmp (argv[1], "implicit") == 0) { authuristr = "mongodb://user,=:[email protected]/test?appname=scram-example"; } else if (strcmp (argv[1], "scram") == 0) { authuristr = "mongodb://user,=:[email protected]/" "test?appname=scram-example&authMechanism=SCRAM-SHA-1"; } else { printf ("%s - [implicit|scram]\n", argv[0]); return 1; } mongoc_init (); client = mongoc_client_new (uristr); if (!client) { fprintf (stderr, "Failed to parse URI.\n"); return EXIT_FAILURE; } mongoc_client_set_error_api (client, 2); database = mongoc_client_get_database (client, "test"); bson_init (&roles); bson_init (&query); BCON_APPEND (&roles, "0", "{", "role", "root", "db", "admin", "}"); mongoc_database_add_user (database, "user,=", "pass", &roles, NULL, &error); mongoc_database_destroy (database); mongoc_client_destroy (client); client = mongoc_client_new (authuristr); if (!client) { fprintf (stderr, "failed to parse SCRAM uri\n"); goto CLEANUP; } mongoc_client_set_error_api (client, 2); collection = mongoc_client_get_collection (client, "test", "test"); cursor = mongoc_collection_find_with_opts (collection, &query, NULL, NULL); mongoc_cursor_next (cursor, &doc); if (mongoc_cursor_error (cursor, &error)) { fprintf (stderr, "Auth error: %s\n", error.message); goto CLEANUP; } CLEANUP: bson_destroy (&roles); bson_destroy (&query); if (collection) { mongoc_collection_destroy (collection); } if (client) { mongoc_client_destroy (client); } if (cursor) { mongoc_cursor_destroy (cursor); } mongoc_cleanup (); return EXIT_SUCCESS; }