mongoc_client_t *
mongoc_client_new_from_uri (const mongoc_uri_t *uri)
{
const char *uristr;
bson_return_val_if_fail(uri, NULL);
uristr = mongoc_uri_get_string(uri);
return mongoc_client_new(uristr);
}
int
main (int argc,
char *argv[])
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_t *query;
bson_t *update;
bson_t reply;
char *str;
mongoc_init ();
client = mongoc_client_new ("mongodb://127.0.0.1:27017/");
collection = mongoc_client_get_collection (client, "test", "test");
/*
* Build our query, {"cmpxchg": 1}
*/
query = BCON_NEW ("cmpxchg", BCON_INT32 (1));
/*
* Build our update. {"$set": {"cmpxchg": 2}}
*/
update = BCON_NEW ("$set", "{", "cmpxchg", BCON_INT32 (2), "}");
/*
* Submit the findAndModify.
*/
if (!mongoc_collection_find_and_modify (collection, query, NULL, update, NULL, false, false, true, &reply, &error)) {
fprintf (stderr, "find_and_modify() failure: %s\n", error.message);
return 1;
}
/*
* Print the result as JSON.
*/
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
/*
* Cleanup.
*/
bson_destroy (query);
bson_destroy (update);
bson_destroy (&reply);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_client_t *client;
mongoc_apm_callbacks_t *callbacks;
stats_t stats = { 0 };
mongoc_collection_t *collection;
const char *uristr = "mongodb://127.0.0.1/?appname=cmd-monitoring-example";
const char *collection_name = "test";
bson_t doc;
mongoc_init ();
if (argc > 1) {
uristr = argv [1];
}
client = mongoc_client_new (uristr);
if (!client) {
fprintf (stderr, "Failed to parse URI.\n");
return EXIT_FAILURE;
}
mongoc_client_set_error_api (client, 2);
callbacks = mongoc_apm_callbacks_new ();
mongoc_apm_set_command_started_cb (callbacks, command_started);
mongoc_apm_set_command_succeeded_cb (callbacks, command_succeeded );
mongoc_apm_set_command_failed_cb (callbacks, command_failed);
mongoc_client_set_apm_callbacks (client,
callbacks,
(void *) &stats /* context pointer */);
bson_init (&doc);
BSON_APPEND_INT32 (&doc, "_id", 1);
collection = mongoc_client_get_collection (client, "test", collection_name);
mongoc_collection_drop (collection, NULL);
mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);
/* duplicate key error on the second insert */
mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);
printf ("started: %d\nsucceeded: %d\nfailed: %d\n",
stats.started, stats.succeeded, stats.failed);
bson_destroy (&doc);
mongoc_collection_destroy (collection);
mongoc_apm_callbacks_destroy (callbacks);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
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_regex (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_write_concern_t *wr;
mongoc_client_t *client;
bson_error_t error = { 0 };
int64_t count;
bson_t q = BSON_INITIALIZER;
bson_t *doc;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
database = get_test_database (client);
ASSERT (database);
collection = get_test_collection (client, "test_regex");
ASSERT (collection);
wr = mongoc_write_concern_new ();
mongoc_write_concern_set_journal (wr, true);
doc = BCON_NEW ("hello", "/world");
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, wr, &error);
ASSERT (r);
BSON_APPEND_REGEX (&q, "hello", "^/wo", "i");
count = mongoc_collection_count (collection,
MONGOC_QUERY_NONE,
&q,
0,
0,
NULL,
&error);
ASSERT (count > 0);
ASSERT (!error.domain);
r = mongoc_collection_drop (collection, &error);
ASSERT (r);
mongoc_write_concern_destroy (wr);
bson_destroy (&q);
bson_destroy (doc);
mongoc_collection_destroy (collection);
mongoc_database_destroy(database);
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;
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_destroy (&options);
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);
}
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);
}
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);
}
int
main (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
bson_error_t error;
bson_t *options;
mongoc_init ();
client = mongoc_client_new (
"mongodb://localhost:27017/admin?appname=find-and-modify-opts-example");
mongoc_client_set_error_api (client, 2);
database = mongoc_client_get_database (client, "databaseName");
options = BCON_NEW ("validator",
"{",
"age",
"{",
"$lte",
BCON_INT32 (34),
"}",
"}",
"validationAction",
BCON_UTF8 ("error"),
"validationLevel",
BCON_UTF8 ("moderate"));
collection = mongoc_database_create_collection (
database, "collectionName", options, &error);
if (!collection) {
fprintf (
stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);
return 1;
}
fam_flags (collection);
fam_bypass (collection);
fam_update (collection);
fam_fields (collection);
fam_opts (collection);
fam_sort (collection);
mongoc_collection_drop (collection, NULL);
bson_destroy (options);
mongoc_database_destroy (database);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
static struct db_connect* create_conn(void)
{
struct db_connect* db_conn;
db_conn = malloc (sizeof (struct db_connect));
db_conn->conn = mongoc_client_new ("mongodb://localhost:27017");
if (!db_conn->conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
return db_conn;
}
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;
}
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
test_insert (void)
{
mongoc_collection_t *collection;
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);
collection = mongoc_client_get_collection(client, "test", "test");
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_insert(collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
}
bson_init (&b);
BSON_APPEND_INT32 (&b, "$hello", 1);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
ASSERT (!r);
ASSERT (error.domain == MONGOC_ERROR_BSON);
ASSERT (error.code == MONGOC_ERROR_BSON_INVALID);
bson_destroy (&b);
mongoc_collection_destroy(collection);
bson_context_destroy(context);
mongoc_client_destroy(client);
}
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;
bson_t empty = BSON_INITIALIZER;
/*
* 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);
/*
* Try various commands while in the failed state to ensure we get the
* same sort of errors.
*/
r = mongoc_collection_insert (collection, 0, &empty, NULL, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_CLIENT);
assert (error.code == MONGOC_ERROR_CLIENT_AUTHENTICATE);
/*
* Try various commands while in the failed state to ensure we get the
* same sort of errors.
*/
r = mongoc_collection_update (collection, 0, &q, &empty, NULL, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_CLIENT);
assert (error.code == MONGOC_ERROR_CLIENT_AUTHENTICATE);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
}
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_delete (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_context_t *context;
bson_error_t error;
bool r;
bson_oid_t oid;
bson_t b;
int i;
client = mongoc_client_new(gTestUri);
ASSERT (client);
collection = mongoc_client_get_collection(client, "test", "test");
ASSERT (collection);
context = bson_context_new(BSON_CONTEXT_NONE);
ASSERT (context);
for (i = 0; i < 100; 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_insert(collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
bson_init(&b);
bson_append_oid(&b, "_id", 3, &oid);
r = mongoc_collection_delete(collection, MONGOC_DELETE_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING("%s\n", error.message);
}
ASSERT (r);
bson_destroy(&b);
}
mongoc_collection_destroy(collection);
bson_context_destroy(context);
mongoc_client_destroy(client);
}
/**
* Module connection constructor.
* @param[in] ctx Talloc context.
* @param[in] instance Module instance.
* @return NULL on error, else a connection handle.
*/
static void *mod_conn_create(TALLOC_CTX *ctx, void *instance) {
rlm_mongodb_t *inst = instance;
mongoc_client_t *client = mongoc_client_new(inst->cfg.server);
if (!client) {
ERROR("rlm_mongodb (%s): failed to connect to server", inst->name);
return NULL;
}
rlm_mongodb_conn_t *conn = talloc_zero(ctx, rlm_mongodb_conn_t);
conn->client = client;
talloc_set_destructor(conn, mod_conn_free);
return conn;
}
/**
* Makes a new connection to a MongoDB server and database.
*
* @param uri A MongoDB URI, as per mongoc_uri(7).
*
* @return A pointer to a mongoc_client_t, or NULL if the connection attempt
* was unsuccessful.
*/
mongoc_client_t* monary_connect(const char* uri) {
mongoc_client_t* client;
if (!uri) {
return NULL;
}
DEBUG("Attempting connection to: %s", uri);
client = mongoc_client_new(uri);
if (client) {
DEBUG("%s", "Connection successful");
}
else {
DEBUG("An error occurred while attempting to connect to %s", uri);
}
return client;
}
static void
test_mongoc_client_preselect (void)
{
mongoc_client_t *client;
bson_error_t error;
uint32_t node;
client = mongoc_client_new (gTestUri);
assert (client);
node = _mongoc_client_preselect (client, MONGOC_OPCODE_INSERT,
NULL, NULL, &error);
assert (node > 0);
mongoc_client_destroy (client);
}
static void
test_validate (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_iter_t iter;
bson_error_t error;
bson_t doc = BSON_INITIALIZER;
bson_t opts = BSON_INITIALIZER;
bson_t reply;
bool r;
client = mongoc_client_new (gTestUri);
ASSERT (client);
collection = get_test_collection (client, "test_validate");
ASSERT (collection);
r = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &doc, NULL, &error);
assert (r);
BSON_APPEND_BOOL (&opts, "full", true);
r = mongoc_collection_validate (collection, &opts, &reply, &error);
assert (r);
assert (bson_iter_init_find (&iter, &reply, "ns"));
assert (bson_iter_init_find (&iter, &reply, "valid"));
bson_destroy (&reply);
bson_reinit (&opts);
BSON_APPEND_UTF8 (&opts, "full", "bad_value");
r = mongoc_collection_validate (collection, &opts, &reply, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_BSON);
assert (error.code == MONGOC_ERROR_BSON_INVALID);
r = mongoc_collection_drop (collection, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (&doc);
bson_destroy (&opts);
}
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
test_remove_by_filename (void)
{
mongoc_gridfs_t *gridfs;
mongoc_gridfs_file_t *file;
mongoc_gridfs_file_opt_t opt = { 0 };
mongoc_client_t *client;
bson_error_t error;
bool ret;
client = mongoc_client_new (gTestUri);
assert (client);
gridfs = get_test_gridfs (client, "fs_remove_by_filename", &error);
assert (gridfs);
mongoc_gridfs_drop (gridfs, &error);
opt.filename = "foo_file_1.txt";
file = mongoc_gridfs_create_file (gridfs, &opt);
assert (file);
assert (mongoc_gridfs_file_save (file));
mongoc_gridfs_file_destroy (file);
opt.filename = "foo_file_2.txt";
file = mongoc_gridfs_create_file (gridfs, &opt);
assert (file);
assert (mongoc_gridfs_file_save (file));
ret = mongoc_gridfs_remove_by_filename (gridfs, "foo_file_1.txt", &error);
if (!ret) fprintf (stderr, "ERROR: %s\n", error.message);
assert (ret);
mongoc_gridfs_file_destroy (file);
file = mongoc_gridfs_find_one_by_filename (gridfs, "foo_file_1.txt", &error);
assert (!file);
file = mongoc_gridfs_find_one_by_filename (gridfs, "foo_file_2.txt", &error);
assert (file);
mongoc_gridfs_file_destroy (file);
drop_collections (gridfs, &error);
mongoc_gridfs_destroy (gridfs);
mongoc_client_destroy (client);
}
int main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
bson_error_t error;
bson_oid_t oid;
bson_t *doc;
/* Init mongo C driver */
mongoc_init ();
/* Create a new connection to the database a get the specified collection */
client = mongoc_client_new ("mongodb://localhost:27017/");
if (!client) {
fprintf(stderr, "Connection to database failed!");
mongoc_cleanup();
return 0;
} else {
printf("Connected to the database successfully\n");
}
collection = mongoc_client_get_collection (client, "testdb", "users");
/* Create a new document (All the documents must have the _id field to be used as primary key) */
doc = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (doc, "_id", &oid);
BSON_APPEND_UTF8 (doc, "username", "John");
BSON_APPEND_UTF8 (doc, "password", "123456");
/* Insert the document into the collection */
if (!mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error)) {
printf ("Error inserting the document. - %s\n", error.message);
} else {
printf ("Document successfully inserted!\n");
}
/* Clean the doc, colletion and client allocations */
bson_destroy (doc);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
/* Cleanup after mongo C driver */
mongoc_cleanup();
return 0;
}
void PruebaMongoDB()
{
mongoc_collection_t *collection;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *item;
bson_error_t error;
bson_oid_t oid;
bson_t *query;
bson_t *doc;
char *str;
bool r;
mongoc_init();
/* get a handle to our collection */
client = mongoc_client_new ("mongodb://localhost:27017");
collection = mongoc_client_get_collection (client, "local", "tito");
/* insert a document */
bson_oid_init (&oid, NULL);
doc = BCON_NEW ("_id", BCON_OID (&oid),
"hello", BCON_UTF8 ("world!"));
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error);
if (!r) {
fprintf (stderr, "%s\n", error.message);
}
/* build a query to execute */
query = BCON_NEW ("_id", BCON_OID (&oid));
/* execute the query and iterate the results */
cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
while (mongoc_cursor_next (cursor, &item)) {
str = bson_as_json (item, NULL);
printf ("%s\n", str);
bson_free (str);
}
/* release everything */
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
bson_destroy (query);
bson_destroy (doc);
}
static void
test_stream (void)
{
mongoc_gridfs_t *gridfs;
mongoc_gridfs_file_t *file;
mongoc_client_t *client;
mongoc_stream_t *stream;
mongoc_stream_t *in_stream;
bson_error_t error;
ssize_t r;
char buf[4096];
mongoc_iovec_t iov;
iov.iov_base = buf;
iov.iov_len = sizeof buf;
client = mongoc_client_new (gTestUri);
assert (client);
gridfs = get_test_gridfs (client, "fs", &error);
assert (gridfs);
mongoc_gridfs_drop (gridfs, &error);
in_stream = mongoc_stream_file_new_for_path (BINARY_DIR"/gridfs.dat", O_RDONLY, 0);
file = mongoc_gridfs_create_file_from_stream (gridfs, in_stream, NULL);
assert (file);
assert (mongoc_gridfs_file_save (file));
stream = mongoc_stream_gridfs_new (file);
r = mongoc_stream_readv (stream, &iov, 1, file->length, 0);
assert (r == file->length);
/* cleanup */
mongoc_stream_destroy (stream);
mongoc_gridfs_file_destroy (file);
drop_collections (gridfs, &error);
mongoc_gridfs_destroy (gridfs);
mongoc_client_destroy (client);
}
static void
test_read (void)
{
mongoc_gridfs_t *gridfs;
mongoc_gridfs_file_t *file;
mongoc_stream_t *stream;
mongoc_client_t *client;
bson_error_t error;
ssize_t r;
char buf[10], buf2[10];
mongoc_iovec_t iov[2];
iov[0].iov_base = buf;
iov[0].iov_len = 10;
iov[1].iov_base = buf2;
iov[1].iov_len = 10;
client = mongoc_client_new (gTestUri);
assert (client);
gridfs = get_test_gridfs (client, "read", &error);
assert (gridfs);
mongoc_gridfs_drop (gridfs, &error);
stream = mongoc_stream_file_new_for_path (BINARY_DIR"/gridfs.dat", O_RDONLY, 0);
file = mongoc_gridfs_create_file_from_stream (gridfs, stream, NULL);
assert (file);
assert (mongoc_gridfs_file_save (file));
r = mongoc_gridfs_file_readv (file, iov, 2, 20, 0);
assert (r == 20);
assert (memcmp (iov[0].iov_base, "Bacon ipsu", 10) == 0);
assert (memcmp (iov[1].iov_base, "m dolor si", 10) == 0);
mongoc_gridfs_file_destroy (file);
drop_collections (gridfs, &error);
mongoc_gridfs_destroy (gridfs);
mongoc_client_destroy (client);
}
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);
}
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_init ();
client = mongoc_client_new ("mongodb://localhost/?appname=bulk-collation");
mongoc_client_set_error_api (client, 2);
collection = mongoc_client_get_collection (client, "db", "collection");
bulk_collation (collection);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
