int
main (void)
{
mongo_sync_connection *conn;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
fprintf (stderr, "Connection failed: %s\n", strerror (errno));
return 1;
}
mongo_sync_cmd_create (conn, "lmc", "cmd_create", MONGO_COLLECTION_DEFAULTS);
print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create"));
mongo_sync_cmd_create (conn, "lmc", "cmd_create_capped",
MONGO_COLLECTION_CAPPED, 655360);
print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create_capped"));
mongo_sync_cmd_create (conn, "lmc", "cmd_create_capped_max",
MONGO_COLLECTION_CAPPED | MONGO_COLLECTION_CAPPED_MAX,
655360, 100);
print_coll_info (mongo_sync_cmd_exists (conn, "lmc",
"cmd_create_capped_max"));
mongo_sync_cmd_create (conn, "lmc", "cmd_create_sized",
MONGO_COLLECTION_SIZED, 655360);
print_coll_info (mongo_sync_cmd_exists (conn, "lmc", "cmd_create_sized"));
mongo_sync_disconnect (conn);
return 0;
}
void
test_mongo_sync_cmd_kill_cursors_net (void)
{
mongo_packet *p;
mongo_sync_connection *conn;
bson *b;
gint i;
mongo_reply_packet_header rh;
gint64 cid;
begin_network_tests (3);
conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
mongo_sync_conn_set_auto_reconnect (conn, TRUE);
b = bson_new ();
for (i = 0; i < 40; i++)
{
bson_reset (b);
bson_append_string (b, "test-name", __FILE__, -1);
bson_append_int32 (b, "seq", i);
bson_finish (b);
mongo_sync_cmd_insert (conn, config.ns, b, NULL);
}
bson_free (b);
b = bson_new ();
bson_append_string (b, "test-name", __FILE__, -1);
bson_finish (b);
p = mongo_sync_cmd_query (conn, config.ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 2, b, NULL);
mongo_wire_reply_packet_get_header (p, &rh);
cid = rh.cursor_id;
mongo_wire_packet_free (p);
ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE,
"mongo_sync_kill_cursors() works");
p = mongo_sync_cmd_query (conn, config.ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 2, b, NULL);
bson_free (b);
mongo_wire_reply_packet_get_header (p, &rh);
cid = rh.cursor_id;
mongo_wire_packet_free (p);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE,
"mongo_sync_cmd_kill_cursors() automatically reconnects");
mongo_sync_disconnect (conn);
test_mongo_sync_cmd_kill_cursors_net_secondary ();
end_network_tests ();
}
void
test_func_mongo_sync_max_insert_size (void)
{
mongo_sync_connection *conn;
const bson *docs[10];
bson *b1, *b2, *b3;
b1 = bson_new ();
bson_append_string (b1, "func_mongo_sync_max_insert_size", "works", -1);
bson_finish (b1);
b2 = bson_new ();
bson_append_int32 (b2, "int32", 1984);
bson_finish (b2);
b3 = bson_new ();
bson_finish (b3);
conn = mongo_sync_connect (config.primary_host, config.primary_port,
FALSE);
/*
* cmd_insert_n()
*/
mongo_sync_conn_set_max_insert_size (conn, bson_size (b1) +
bson_size (b3) + 1);
docs[0] = b1;
docs[1] = b2;
docs[2] = b3;
ok (mongo_sync_cmd_insert_n (conn, config.ns, 3, docs) == TRUE,
"mongo_sync_cmd_insert_n() works with a small max_insert_size");
mongo_sync_conn_set_max_insert_size (conn, 1);
errno = 0;
ok (mongo_sync_cmd_insert_n (conn, config.ns, 3, docs) == FALSE,
"mongo_sync_cmd_insert_n() should fail if any one document is too big");
cmp_ok (errno, "==", EMSGSIZE,
"errno is set to EMSGSIZE");
/*
* cmd_insert()
*/
mongo_sync_conn_set_max_insert_size (conn, bson_size (b1) +
bson_size (b3) + 1);
ok (mongo_sync_cmd_insert (conn, config.ns, b1, b2, b3, NULL) == TRUE,
"mongo_sync_cmd_insert() works with a small max_insert_size");
mongo_sync_conn_set_max_insert_size (conn, 1);
errno = 0;
ok (mongo_sync_cmd_insert (conn, config.ns, b1, b2, b3, NULL) == FALSE,
"mongo_sync_cmd_insert() should fail if any one document is too big");
cmp_ok (errno, "==", EMSGSIZE,
"errno is set to EMSGSIZE");
mongo_sync_disconnect (conn);
bson_free (b1);
bson_free (b2);
bson_free (b3);
}
void
test_mongo_sync_cmd_user_add_net (void)
{
mongo_sync_connection *c;
begin_network_tests (3);
c = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ok (mongo_sync_cmd_user_add (c, config.db, "test", "s3kr1+") == TRUE,
"mongo_sync_cmd_user_add() works");
shutdown (c->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_user_add (c, config.db, "test", "s3kr1+") == TRUE,
"mongo_sync_cmd_user_add() automatically reconnects");
mongo_sync_disconnect (c);
test_mongo_sync_cmd_user_add_net_secondary ();
end_network_tests ();
}
void
test_mongo_sync_gridfs_chunked_find (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
bson *query;
query = bson_build (BSON_TYPE_STRING, "filename", "bogus-fn", -1,
BSON_TYPE_NONE);
bson_finish (query);
ok (mongo_sync_gridfs_chunked_find (NULL, query) == NULL,
"mongo_sync_gridfs_chunked_find() fails with a NULL GridFS");
begin_network_tests (2);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
ok (mongo_sync_gridfs_chunked_find (gfs, NULL) == NULL,
"mongo_sync_gridfs_chunked_find() fails with a NULL query");
ok (mongo_sync_gridfs_chunked_find (gfs, query) == NULL,
"mongo_sync_gridfs_chunked_find() fails when the file is not found");
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
bson_free (query);
}
void
test_mongo_sync_gridfs_get_set_chunk_size (void)
{
mongo_sync_gridfs *gfs;
ok (mongo_sync_gridfs_get_chunk_size (NULL) == -1,
"mongo_sync_gridfs_get_chunk_size() fails with a NULL gfs");
ok (mongo_sync_gridfs_set_chunk_size (NULL, 16 * 1024) == FALSE,
"mongo_sync_gridfs_set_chunk_size() fails with a NULL gfs");
begin_network_tests (3);
gfs = mongo_sync_gridfs_new (mongo_sync_connect (config.primary_host,
config.primary_port,
FALSE),
config.gfs_prefix);
ok (mongo_sync_gridfs_set_chunk_size (gfs, -1) == FALSE,
"mongo_sync_gridfs_set_chunk_size() fails if the size is invalid");
ok (mongo_sync_gridfs_set_chunk_size (gfs, 12345),
"mongo_sync_gridfs_set_chunk_size() works");
cmp_ok (mongo_sync_gridfs_get_chunk_size (gfs), "==", 12345,
"mongo_sync_gridfs_get_chunk_size() works");
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
}
mongo_sync_gridfs *
mongo_gridfs_connect (config_t *config)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
VLOG ("Connecting to %s:%d/%s.%s...\n", config->host, config->port,
config->db, config->coll);
conn = mongo_sync_connect (config->host, config->port, config->slaveok);
if (!conn)
mongo_gridfs_error (errno);
if (config->master_sync)
{
VLOG ("Syncing to master...\n");
conn = mongo_sync_reconnect (conn, TRUE);
if (!conn)
mongo_gridfs_error (errno);
}
gfs = mongo_sync_gridfs_new (conn, config->ns);
if (!gfs)
mongo_gridfs_error (errno);
return gfs;
}
void
test_mongo_sync_cmd_custom_net_secondary (void)
{
mongo_sync_connection *conn;
bson *cmd;
mongo_packet *p;
skip (!config.secondary_host, 1,
"Secondary server not configured");
conn = mongo_sync_connect (config.secondary_host, config.secondary_port,
TRUE);
cmd = bson_build (BSON_TYPE_INT32, "getnonce", 1,
BSON_TYPE_NONE);
bson_finish (cmd);
p = mongo_sync_cmd_custom (conn, config.db, cmd);
ok (p != NULL,
"mongo_sync_cmd_custom() works on the secondary too");
mongo_wire_packet_free (p);
bson_free (cmd);
mongo_sync_disconnect (conn);
endskip;
}
void
test_mongo_sync_cmd_kill_cursors_net_secondary (void)
{
mongo_packet *p;
mongo_sync_connection *conn;
bson *b;
mongo_reply_packet_header rh;
gint64 cid;
skip (!config.secondary_host, 1,
"Secondary server not configured");
conn = mongo_sync_connect (config.secondary_host, config.secondary_port,
TRUE);
b = bson_new ();
bson_append_string (b, "test-name", __FILE__, -1);
bson_finish (b);
p = mongo_sync_cmd_query (conn, config.ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 2, b, NULL);
bson_free (b);
mongo_wire_reply_packet_get_header (p, &rh);
cid = rh.cursor_id;
mongo_wire_packet_free (p);
ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE,
"mongo_sync_cmd_kill_cursors() works on secondary too");
mongo_sync_disconnect (conn);
endskip;
}
void
tut_sync_connect_replica (void)
{
mongo_sync_connection *conn;
conn = mongo_sync_connect ("mongo-master", 27017, TRUE);
if (!conn)
{
perror ("mongo_sync_connect()");
return;
}
if (!mongo_sync_conn_set_auto_reconnect (conn, TRUE))
{
perror ("mongo_sync_conn_set_auto_reconnect()");
return;
}
if (!mongo_sync_conn_seed_add (conn, "mongo-replica", 27017))
{
perror ("mongo_sync_conn_seed_add()");
return;
}
if (!mongo_sync_conn_seed_add (conn, "mongo-replica-2", 27017))
{
perror ("mongo_sync_conn_seed_add()");
return;
}
mongo_sync_disconnect (conn);
}
void
tut_sync_query_simple (void)
{
mongo_sync_connection *conn;
mongo_packet *p;
mongo_sync_cursor *cursor;
bson *query;
gint i = 0;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
query = bson_new ();
bson_finish (query);
p = mongo_sync_cmd_query (conn, "tutorial.docs", 0,
0, 10, query, NULL);
if (!p)
{
perror ("mongo_sync_cmd_query()");
exit (1);
}
bson_free (query);
cursor = mongo_sync_cursor_new (conn, "tutorial.docs", p);
if (!cursor)
{
perror ("mongo_sync_cursor_new()");
exit (1);
}
while (mongo_sync_cursor_next (cursor))
{
bson *result = mongo_sync_cursor_get_data (cursor);
bson_cursor *c;
if (!result)
{
perror ("mongo_sync_cursor_get_data()");
exit (1);
}
printf ("Keys in document #%d:\n", i);
c = bson_cursor_new (result);
while (bson_cursor_next (c))
printf ("\t%s\n", bson_cursor_key (c));
i++;
bson_cursor_free (c);
bson_free (result);
}
mongo_sync_cursor_free (cursor);
mongo_sync_disconnect (conn);
}
void
test_mongo_sync_connect (void)
{
mongo_sync_connection *c;
ok (mongo_sync_connect (NULL, 27017, FALSE) == NULL,
"mongo_sync_connect() fails with a NULL host");
begin_network_tests (1);
ok ((c = mongo_sync_connect (config.primary_host,
config.primary_port, FALSE)) != NULL,
"mongo_sync_connect() works");
mongo_sync_disconnect (c);
end_network_tests ();
}
static gboolean
afmongodb_dd_connect(MongoDBDestDriver *self, gboolean reconnect)
{
GList *l;
if (reconnect && self->conn)
return TRUE;
self->conn = mongo_sync_connect(self->host, self->port, FALSE);
if (!self->conn)
{
msg_error ("Error connecting to MongoDB", NULL);
return FALSE;
}
mongo_sync_conn_set_safe_mode(self->conn, self->safe_mode);
l = self->servers;
while ((l = g_list_next(l)) != NULL)
{
gchar *host = NULL;
gint port = 27017;
if (!mongo_util_parse_addr(l->data, &host, &port))
{
msg_warning("Cannot parse MongoDB server address, ignoring",
evt_tag_str("address", l->data),
NULL);
continue;
}
mongo_sync_conn_seed_add (self->conn, host, port);
msg_verbose("Added MongoDB server seed",
evt_tag_str("host", host),
evt_tag_int("port", port),
NULL);
g_free(host);
}
/*
if (self->user || self->password)
{
if (!self->user || !self->password)
{
msg_error("Neither the username, nor the password can be empty", NULL);
return FALSE;
}
if (mongo_cmd_authenticate(&self->mongo_conn, self->db, self->user, self->password) != 1)
{
msg_error("MongoDB authentication failed", NULL);
return FALSE;
}
}
*/
return TRUE;
}
void
test_mongo_sync_gridfs_stream_seek (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
mongo_sync_gridfs_stream *stream;
mongo_util_oid_init (0);
ok (mongo_sync_gridfs_stream_seek (NULL, 0, SEEK_SET) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with a NULL stream");
begin_network_tests (8);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
stream = mongo_sync_gridfs_stream_new (gfs, NULL);
ok (mongo_sync_gridfs_stream_seek (stream, 0, SEEK_SET) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with a write stream");
stream->file.type = LMC_GRIDFS_FILE_STREAM_READER;
ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_SET) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_SET and a negative "
"position");
ok (mongo_sync_gridfs_stream_seek (stream, 10, SEEK_SET) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_SET and a position "
"past EOF");
ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_CUR) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_CUR and a position "
"before the start");
ok (mongo_sync_gridfs_stream_seek (stream, 10, SEEK_CUR) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_CUR and a position "
"past EOF");
ok (mongo_sync_gridfs_stream_seek (stream, 1, SEEK_END) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_END and a position "
"past EOF");
ok (mongo_sync_gridfs_stream_seek (stream, -1, SEEK_END) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with SEEK_END and a position "
"before the start");
ok (mongo_sync_gridfs_stream_seek (stream, 0, 42) == FALSE,
"mongo_sync_gridfs_stream_seek() fails with an invalid whence");
mongo_sync_gridfs_stream_close (stream);
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
}
void
test_func_mongo_sync_conn_seed_add (void)
{
mongo_sync_connection *conn;
GList *l;
conn = mongo_sync_connect (config.primary_host, config.primary_port,
FALSE);
close (conn->super.fd);
l = conn->rs.hosts;
while (l)
{
g_free (l->data);
l = g_list_delete_link (l, l);
}
conn->rs.hosts = NULL;
conn = mongo_sync_reconnect (conn, TRUE);
ok (conn == NULL,
"mongo_sync_reconnect() fails without seeds or discovery");
conn = mongo_sync_connect (config.primary_host, config.primary_port,
FALSE);
close (conn->super.fd);
l = conn->rs.hosts;
while (l)
{
g_free (l->data);
l = g_list_delete_link (l, l);
}
conn->rs.hosts = NULL;
ok (mongo_sync_conn_seed_add (conn, config.primary_host,
config.primary_port),
"mongo_sync_conn_seed_add() works");
conn = mongo_sync_reconnect (conn, TRUE);
ok (conn != NULL,
"mongo_sync_reconnect() works when properly seeded");
mongo_sync_disconnect (conn);
}
struct db_connect* create_conn()
{
struct db_connect *db_conn;
db_conn = malloc(sizeof(struct db_connect));
db_conn->conn = mongo_sync_connect ("localhost", 27017, TRUE);
if (!db_conn->conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
return db_conn;
}
void
tut_sync_connect (void)
{
mongo_sync_connection *conn;
conn = mongo_sync_connect ("localhost", 27017, TRUE);
if (!conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
mongo_sync_disconnect (conn);
}
void
test_func_mongo_sync_auto_reconnect (void)
{
mongo_sync_connection *conn;
bson *b;
mongo_packet *p;
b = bson_new ();
bson_append_int32 (b, "f_sync_auto_reconnect", 1);
bson_finish (b);
conn = mongo_sync_connect (config.primary_host, config.primary_port,
TRUE);
ok (mongo_sync_cmd_insert (conn, config.ns, b, NULL) == TRUE);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (1);
ok (mongo_sync_cmd_insert (conn, config.ns, b, NULL) == FALSE,
"Inserting fails with auto-reconnect turned off, and a broken "
"connection");
mongo_sync_conn_set_auto_reconnect (conn, TRUE);
ok (mongo_sync_cmd_insert (conn, config.ns, b, NULL) == TRUE,
"Inserting works with auto-reconnect turned on, and a broken "
"connection");
mongo_sync_conn_set_auto_reconnect (conn, FALSE);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (1);
ok (mongo_sync_cmd_insert (conn, config.ns, b, NULL) == FALSE,
"Turning off auto-reconnect works");
shutdown (conn->super.fd, SHUT_RDWR);
sleep (1);
p = mongo_sync_cmd_query (conn, config.ns, 0, 0, 1, b, NULL);
ok (p == NULL,
"Query fails with auto-reconnect turned off");
mongo_sync_conn_set_auto_reconnect (conn, TRUE);
p = mongo_sync_cmd_query (conn, config.ns, 0, 0, 1, b, NULL);
ok (p != NULL,
"Query does reconnect with auto-reconnect turned on");
mongo_wire_packet_free (p);
mongo_sync_disconnect (conn);
}
void
tut_sync_insert (void)
{
mongo_sync_connection *conn;
bson *doc1, *doc2, *doc3;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
perror ("mongo_sync_connect()");
exit (1);
}
doc1 = bson_build (BSON_TYPE_STRING, "hello", "world", -1,
BSON_TYPE_INT32, "the_final_answer", 42,
BSON_TYPE_BOOLEAN, "yes?", FALSE,
BSON_TYPE_INT32, "n", 1,
BSON_TYPE_NONE);
bson_finish (doc1);
if (!mongo_sync_cmd_insert (conn, "tutorial.docs", doc1, NULL))
{
perror ("mongo_sync_cmd_insert()");
exit (1);
}
doc2 = bson_build (BSON_TYPE_INT32, "n", 2,
BSON_TYPE_BOOLEAN, "yes?", FALSE,
BSON_TYPE_STRING, "hello", "dolly", -1,
BSON_TYPE_NONE);
bson_finish (doc2);
doc3 = bson_build (BSON_TYPE_INT32, "n", 3,
BSON_TYPE_STRING, "hello", "nurse", -1,
BSON_TYPE_BOOLEAN, "yes?", TRUE,
BSON_TYPE_NONE);
bson_finish (doc3);
if (!mongo_sync_cmd_insert (conn, "tutorial.docs", doc2, doc3, NULL))
{
perror ("mongo_sync_cmd_insert()");
exit (1);
}
bson_free (doc3);
bson_free (doc2);
bson_free (doc1);
mongo_sync_disconnect (conn);
}
static mongo_sync_pool_connection *
_mongo_sync_pool_connect (const gchar *host, gint port, gboolean slaveok)
{
mongo_sync_connection *c;
mongo_sync_pool_connection *conn;
c = mongo_sync_connect (host, port, slaveok);
if (!c)
return NULL;
conn = g_realloc (c, sizeof (mongo_sync_pool_connection));
conn->pool_id = 0;
conn->in_use = FALSE;
return conn;
}
void
test_mongo_sync_cmd_is_master_net (void)
{
mongo_sync_connection *conn;
begin_network_tests (2);
conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
ok (mongo_sync_cmd_is_master (conn) == TRUE,
"mongo_sync_cmd_is_master() works");
mongo_sync_disconnect (conn);
test_mongo_sync_cmd_is_master_net_secondary ();
end_network_tests ();
}
void
test_mongo_sync_gridfs_new (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
gchar *f, *c;
conn = test_make_fake_sync_conn (4, TRUE);
ok (mongo_sync_gridfs_new (NULL, "test.fs") == NULL,
"mongo_sync_gridfs_new() should fail with a NULL connection");
ok (mongo_sync_gridfs_new (conn, "test.fs") == NULL,
"mongo_sync_gridfs_new() should fail with a bogus connection");
ok (mongo_sync_gridfs_new (conn, NULL) == NULL,
"mongo_sync_gridfs_new() should fail with a NULL ns prefix");
ok (mongo_sync_gridfs_new (conn, "bogus") == NULL,
"mongo_sync_gridfs_new() should fail with a bogus ns prefix");
mongo_sync_disconnect (conn);
begin_network_tests (4);
f = g_strconcat (config.gfs_prefix, ".files", NULL);
c = g_strconcat (config.gfs_prefix, ".chunks", NULL);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
ok (gfs != NULL,
"mongo_sync_gridfs_new() works");
is (gfs->ns.prefix, config.gfs_prefix,
"The namespace prefix is as specified");
is (gfs->ns.files, f,
"The files namespace is correct");
is (gfs->ns.chunks, c,
"The chunks namespace is correct");
mongo_sync_gridfs_free (gfs, FALSE);
mongo_sync_disconnect (conn);
g_free (f);
g_free (c);
end_network_tests ();
}
void
test_mongo_sync_cmd_create_net (void)
{
mongo_sync_connection *conn;
gchar *cc;
begin_network_tests (5);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
cc = g_strconcat (config.coll, ".capped", NULL);
mongo_sync_cmd_drop (conn, config.db, config.coll);
mongo_sync_cmd_drop (conn, config.db, cc);
ok (mongo_sync_cmd_create (conn, config.db, config.coll,
MONGO_COLLECTION_DEFAULTS) == TRUE,
"mongo_sync_cmd_create() can create normal collections");
mongo_sync_cmd_drop (conn, config.db, config.coll);
ok (mongo_sync_cmd_create (conn, config.db, config.coll,
MONGO_COLLECTION_SIZED,
(gint64) 64 * 1024 * 10) == TRUE,
"mongo_sync_cmd_create() can create pre-allocated collections");
ok (mongo_sync_cmd_create (conn, config.db, cc,
MONGO_COLLECTION_CAPPED, (gint64) -1) == FALSE,
"mongo_sync_cmd_create() fails when trying to create a capped "
"collection with an invalid size");
ok (mongo_sync_cmd_create (conn, config.db, cc,
MONGO_COLLECTION_CAPPED_MAX,
(gint64) (64 * 1024 * 10), (gint64) -1) == FALSE,
"mongo_sync_cmd_create() fails when trying to create a capped "
"collection with invalid max.");
ok (mongo_sync_cmd_create (conn, config.db, cc,
MONGO_COLLECTION_CAPPED_MAX |
MONGO_COLLECTION_AUTO_INDEX_ID,
(gint64)(64 * 1024 * 10), (gint64) 10) == TRUE,
"mongo_sync_cmd_create() can create capped collections");
mongo_sync_cmd_drop (conn, config.db, cc);
g_free (cc);
mongo_sync_disconnect (conn);
end_network_tests ();
}
void
test_mongo_sync_cmd_is_master_net_secondary (void)
{
mongo_sync_connection *conn;
skip (!config.secondary_host, 1,
"Secondary server not configured");
errno = 0;
conn = mongo_sync_connect (config.secondary_host, config.secondary_port,
TRUE);
ok (mongo_sync_cmd_is_master (conn) == FALSE && errno == 0,
"mongo_sync_cmd_is_master() works correctly on a secondary");
mongo_sync_disconnect (conn);
endskip;
}
int
main (void)
{
mongo_sync_connection *conn;
conn = mongo_sync_connect ("localhost", 27017, FALSE);
if (!conn)
{
fprintf (stderr, "Connection failed: %s\n", strerror (errno));
return 1;
}
do_inserts (conn);
do_query (conn);
mongo_sync_disconnect (conn);
return 0;
}
void
test_mongo_sync_gridfs_stream_write (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
mongo_sync_gridfs_stream *stream;
bson *meta;
guint8 buffer[4096];
mongo_util_oid_init (0);
meta = bson_build (BSON_TYPE_STRING, "my-id", "sync_gridfs_stream_write", -1,
BSON_TYPE_NONE);
bson_finish (meta);
ok (mongo_sync_gridfs_stream_write (NULL, buffer, sizeof (buffer)) == FALSE,
"mongo_sync_gridfs_stream_write() should fail with a NULL connection");
begin_network_tests (4);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
stream = mongo_sync_gridfs_stream_new (gfs, meta);
ok (mongo_sync_gridfs_stream_write (stream, NULL, sizeof (buffer)) == FALSE,
"mongo_sync_gridfs_stream_write() should fail with a NULL buffer");
ok (mongo_sync_gridfs_stream_write (stream, buffer, 0) == FALSE,
"mongo_sync_gridfs_stream_write() should fail with 0 size");
ok (mongo_sync_gridfs_stream_write (stream, buffer, sizeof (buffer)) == TRUE,
"mongo_sync_gridfs_stream_write() works");
stream->file.type = LMC_GRIDFS_FILE_STREAM_READER;
ok (mongo_sync_gridfs_stream_write (stream, buffer, sizeof (buffer)) == FALSE,
"mongo_sync_gridfs_stream_write() should fail with a read stream");
mongo_sync_gridfs_stream_close (stream);
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
bson_free (meta);
}
void
test_mongo_sync_cmd_user_add_net_secondary (void)
{
mongo_sync_connection *c;
gboolean ret;
skip (!config.secondary_host, 1,
"Secondary server not configured");
c = mongo_sync_connect (config.secondary_host, config.secondary_port, TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ret = mongo_sync_cmd_user_add (c, config.db, "test", "s3kr1+");
ok (ret && mongo_sync_cmd_is_master (c),
"mongo_sync_cmd_user_add() automatically reconnects to master");
mongo_sync_disconnect (c);
endskip;
}
NEOERR* mmg_init(char *host, int port, int ms, mmg_conn **db)
{
if (!host) return nerr_raise(NERR_ASSERT, "paramter null");
mmg_conn *ldb;
mtc_noise("connect to %s %d %d ...", host, port, ms);
*db = NULL;
ldb = calloc(1, sizeof(mmg_conn));
if (!ldb) return nerr_raise(NERR_NOMEM, "calloc for connection");
ldb->con = mongo_sync_connect(host, port, true);
if (!ldb->con) return nerr_raise(NERR_DB, "sync connect: %s", strerror(errno));
mongo_sync_conn_set_auto_reconnect(ldb->con, true);
if (ms > 0) mongo_connection_set_timeout((mongo_connection*)ldb->con, ms);
*db = ldb;
return STATUS_OK;
}
void
test_mongo_sync_gridfs_stream_new (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
mongo_sync_gridfs_stream *stream;
bson *meta;
mongo_util_oid_init (0);
meta = bson_build (BSON_TYPE_STRING, "my-id", "sync_gridfs_stream_new", -1,
BSON_TYPE_NONE);
bson_finish (meta);
ok (mongo_sync_gridfs_stream_new (NULL, meta) == FALSE,
"mongo_sync_gridfs_stream_new() should fail with a NULL connection");
begin_network_tests (2);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
stream = mongo_sync_gridfs_stream_new (gfs, NULL);
ok (stream != NULL,
"mongo_sync_gridfs_stream_new() works with NULL metadata");
mongo_sync_gridfs_stream_close (stream);
stream = mongo_sync_gridfs_stream_new (gfs, meta);
ok (stream != NULL,
"mongo_sync_gridfs_stream_new() works with metadata");
mongo_sync_gridfs_stream_close (stream);
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
bson_free (meta);
}
void
test_mongo_sync_gridfs_stream_read (void)
{
mongo_sync_connection *conn;
mongo_sync_gridfs *gfs;
mongo_sync_gridfs_stream *stream;
guint8 buffer[4096];
mongo_util_oid_init (0);
ok (mongo_sync_gridfs_stream_read (NULL, buffer, sizeof (buffer)) == -1,
"mongo_sync_gridfs_stream_read() should fail with a NULL connection");
begin_network_tests (3);
conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE);
gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix);
stream = mongo_sync_gridfs_stream_new (gfs, NULL);
ok (mongo_sync_gridfs_stream_read (stream, buffer, sizeof (buffer)) == -1,
"mongo-sync_gridfs_stream_read() should fail when the stream is "
"write-only");
stream->file.type = LMC_GRIDFS_FILE_STREAM_READER;
ok (mongo_sync_gridfs_stream_read (stream, NULL, sizeof (buffer)) == -1,
"mongo_sync_gridfs_stream_read() should fail with a NULL buffer");
ok (mongo_sync_gridfs_stream_read (stream, buffer, 0) == -1,
"mongo_sync_gridfs_stream_read() should fail with a 0 size");
mongo_sync_gridfs_stream_close (stream);
mongo_sync_gridfs_free (gfs, TRUE);
end_network_tests ();
}
