void
test_mongo_sync_get_set_auto_reconnect (void)
{
mongo_sync_connection *c;
c = test_make_fake_sync_conn (-1, FALSE);
errno = 0;
ok (mongo_sync_conn_get_auto_reconnect (NULL) == FALSE,
"mongo_sync_conn_get_auto_reconnect() returns FALSE with a "
"NULL connection");
cmp_ok (errno, "==", ENOTCONN,
"errno is now set to ENOTCONN");
ok (mongo_sync_conn_get_auto_reconnect (c) == FALSE,
"mongo_sync_get_auto_reconnect() works");
cmp_ok (errno, "==", 0,
"errno is now cleared");
errno = 0;
mongo_sync_conn_set_auto_reconnect (NULL, TRUE);
cmp_ok (errno, "==", ENOTCONN,
"errno is set to ENOTCONN after "
"mongo_sync_conn_set_auto_reconnect(NULL)");
ok (mongo_sync_conn_set_auto_reconnect (c, TRUE),
"mongo_sync_auto_reconnect() works");
ok (mongo_sync_conn_get_auto_reconnect (c) == TRUE,
"mongo_sync_set_auto_reconnect() worked");
mongo_sync_disconnect (c);
}
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
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
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
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_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_func_mongo_sync_ssl_insert_query (void)
{
mongo_sync_connection *conn = NULL;
bson *test_doc = bson_new ();
mongo_packet *p = NULL;
//gchar *test_string = g_strdup_printf ("%s:%s:%d", __FILE__, __func__, __LINE__);
gchar *test_string = g_strdup ("test_func_mongo_sync_ssl_insert_query");
bson_append_string (test_doc, test_string, "ok", -1);
bson_finish (test_doc);
conn = mongo_sync_ssl_connect (config.primary_host, config.primary_port, TRUE, config.ssl_settings);
//conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
mongo_sync_conn_set_auto_reconnect (conn, TRUE);
ok (conn != NULL, "connection works without whitelists");
ok (mongo_sync_cmd_insert (conn, config.ns, test_doc, NULL) == TRUE, "inserting a document works via SSL");
p = mongo_sync_cmd_query (conn, config.ns, 0, 0, 1, test_doc, NULL);
ok (p != NULL,
"querying the recently inserted document works via SSL");
mongo_wire_packet_free (p);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_delete (conn, config.ns, 0, test_doc) == TRUE, "automatic reconnection over SSL should work (at this time: attempting delete command)");
/* ok (mongo_sync_cmd_query (conn, config.ns, 0, 0, 1, test_doc, NULL) == NULL, "test document should not exist after delete");
*/
mongo_sync_disconnect (conn);
bson_free (test_doc);
g_free (test_string);
}
void
test_mongo_sync_cmd_custom_net (void)
{
mongo_sync_connection *conn;
bson *cmd;
mongo_packet *p;
begin_network_tests (3);
conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
mongo_sync_cmd_is_master (conn);
mongo_sync_conn_set_auto_reconnect (conn, 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");
mongo_wire_packet_free (p);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
p = mongo_sync_cmd_custom (conn, config.db, cmd);
ok (p != NULL,
"mongo_sync_cmd_custom() automatically reconnects");
mongo_wire_packet_free (p);
bson_free (cmd);
mongo_sync_disconnect (conn);
test_mongo_sync_cmd_custom_net_secondary ();
end_network_tests ();
}
void
test_func_mongo_sync_auto_reconnect_cache (void)
{
mongo_sync_conn_recovery_cache *cache;
mongo_sync_connection *conn;
bson *b;
mongo_packet *p;
GList *hosts;
gchar *primary_addr;
const gchar *error_msg;
primary_addr = g_strdup_printf ("%s:%d", config.primary_host, config.primary_port);
b = bson_new ();
bson_append_int32 (b, "f_sync_auto_reconnect", 1);
bson_finish (b);
cache = mongo_sync_conn_recovery_cache_new ();
mongo_sync_conn_recovery_cache_seed_add (cache,
config.primary_host,
config.primary_port);
conn = mongo_sync_connect_recovery_cache (cache,
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");
error_msg = mongo_sync_conn_get_last_error (conn);
ok (error_msg != NULL, "We have an error msg when insert fails.");
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");
error_msg = mongo_sync_conn_get_last_error (conn);
ok (error_msg == NULL,
"After a succesful insert we shouldn't have an error msg.");
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");
skip (!config.secondary_host, 7,
"Secondary host not set up");
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");
error_msg = mongo_sync_conn_get_last_error(conn);
ok (error_msg != NULL, "We have an error msg after a failure query.");
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");
ok (mongo_sync_conn_get_last_error(conn) == NULL,
"We shouldn't have any error messages after a successful operation.");
mongo_wire_packet_free (p);
hosts = conn->rs.hosts;
ok (cache->rs.hosts == NULL,
"cache is discarded due to connect replace during auto-reconnect");
ok ((conn->rs.hosts != NULL) &&
(g_list_length (conn->rs.hosts) > 0),
"hosts is filled in mongo_sync_connection");
mongo_sync_disconnect (conn);
ok ((cache->rs.hosts != NULL) &&
(cache->rs.hosts == hosts) &&
(g_list_length (cache->rs.hosts) > 0),
"cache is filled by disconnect()");
mongo_sync_conn_recovery_cache_free (cache);
endskip;
g_free (primary_addr);
}
void
test_mongo_sync_cmd_insert (void)
{
mongo_sync_connection *c;
bson *b1, *b2;
c = test_make_fake_sync_conn (-1, FALSE);
b1 = test_bson_generate_full ();
b2 = test_bson_generate_full ();
ok (mongo_sync_cmd_insert (NULL, "test.ns", b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a NULL connection");
ok (mongo_sync_cmd_insert (c, NULL, b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a NULL namespace");
ok (mongo_sync_cmd_insert (c, "test.ns", NULL) == FALSE,
"mongo_sync_cmd_insert() fails with no documents to insert");
ok (mongo_sync_cmd_insert (c, "test.ns", b1, b2, NULL) == FALSE,
"mongo_sync_cmd_insert() fails with a bogus FD");
mongo_sync_disconnect (c);
bson_free (b1);
bson_free (b2);
begin_network_tests (4);
b1 = bson_new ();
bson_append_string (b1, "sync_cmd_insert", "works", -1);
bson_finish (b1);
b2 = bson_new ();
bson_append_int32 (b2, "int32", 1984);
bson_finish (b2);
c = mongo_sync_connect (config.primary_host, config.primary_port,
TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() works");
shutdown (c->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() automatically reconnects");
mongo_sync_disconnect (c);
/*
* Tests involving a secondary
*/
skip (!config.secondary_host, 2, "Secondary host not set up");
c = mongo_sync_connect (config.secondary_host, config.secondary_port,
TRUE);
mongo_sync_conn_set_auto_reconnect (c, TRUE);
ok (c && mongo_sync_cmd_is_master (c) == FALSE,
"Connected to a secondary");
ok (mongo_sync_cmd_insert (c, config.ns, b1, b2, NULL) == TRUE,
"mongo_sync_cmd_insert() automatically reconnects to master");
mongo_sync_disconnect (c);
endskip;
bson_free (b1);
bson_free (b2);
end_network_tests ();
}
