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_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); }
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 (); }
static void do_inserts (mongo_sync_connection *conn) { bson *base; gint i; base = bson_build (BSON_TYPE_STRING, "tutorial-program", "tut_hl_client.c", -1, BSON_TYPE_INT32, "the answer to life, the universe and everything", 42, BSON_TYPE_NONE); bson_finish (base); for (i = 0; i < 1000; i++) { bson *n; n = bson_new_from_data (bson_data (base), bson_size (base) - 1); bson_append_int32 (n, "counter", i); bson_finish (n); if (!mongo_sync_cmd_insert (conn, "lmc.tutorial", n, NULL)) { fprintf (stderr, "Error inserting document %d: %s\n", i, strerror (errno)); exit (1); } bson_free (n); } bson_free (base); }
static void do_inserts (mongo_sync_connection *conn) { bson *data1a; data1a = bson_build (BSON_TYPE_TIMESTAMP, "processed", 0, BSON_TYPE_STRING, "encoded_encrypted_data", "SGVsbG8gV29ybGQgCg==", -1, BSON_TYPE_STRING, "user_id", "", -1, BSON_TYPE_INT64, "word_id", 0, BSON_TYPE_INT64, "synset_id", 0, BSON_TYPE_INT32, "word_type", 0, BSON_TYPE_STRING, "data", "", -1, BSON_TYPE_NONE); // Missing values or NULL values are simply not provided. bson_finish (data1a); if (!mongo_sync_cmd_insert (conn, "blahblah.plurals", data1a, NULL)) { fprintf (stderr, "Error inserting document: %s\n", strerror(errno)); exit (1); } bson_free (data1a); bson *data1b; data1b = bson_build (BSON_TYPE_TIMESTAMP, "processed", 1294860709000, BSON_TYPE_STRING, "encoded_encrypted_data", "SGVsbG8gV29ybGQgCg==", -1, BSON_TYPE_STRING, "user_id", "****", -1, BSON_TYPE_INT64, "word_id", 41012531, BSON_TYPE_INT64, "synset_id", 0, BSON_TYPE_INT32, "word_type", 1, BSON_TYPE_STRING, "data", "smörgåsbord", -1, BSON_TYPE_NONE); bson_finish (data1b); if (!mongo_sync_cmd_insert (conn, "blahblah.plurals", data1b, NULL)) { fprintf (stderr, "Error inserting document: %s\n", strerror(errno)); exit (1); } bson_free (data1b); }
gpointer ssl_insert_thread (gpointer _c) { mongo_ssl_ctx *c = (mongo_ssl_ctx*) _c; static int insert_count = 0; insert_count++; mongo_sync_connection *conn = mongo_sync_ssl_connect (config.primary_host, config.primary_port, TRUE, c); bson *test_doc = bson_new (); gchar *test_string = g_strdup_printf ("%s:%d", "ssl_insert_thread", insert_count); bson_append_string (test_doc, test_string, "ok", -1); bson_finish (test_doc); ok (mongo_sync_cmd_insert (conn, config.ns, test_doc, NULL), "mongo_sync_cmd_insert () works in a multi-threaded scenario over SSL"); mongo_sync_disconnect (conn); bson_free (test_doc); g_free (test_string); }
NEOERR* mmg_hdf_insert(mmg_conn *db, char *dsn, HDF *node) { bson *doc; NEOERR *err; MCS_NOT_NULLC(db, dsn, node); mtc_noise("insert hdf %s", dsn); err = mbson_import_from_hdf(node, &doc, true); if (err != STATUS_OK) return nerr_pass(err); if (!mongo_sync_cmd_insert(db->con, dsn, doc, NULL)) return nerr_raise(NERR_DB, "sync_cmd_insert: %s", strerror(errno)); bson_free(doc); return STATUS_OK; }
NEOERR* mmg_string_insert(mmg_conn *db, char *dsn, char *str) { bson *doc; MCS_NOT_NULLC(db, dsn, str); mtc_noise("insert string %s %s", dsn, str); doc = mbson_new_from_string(str, true); if (!doc) return nerr_raise(NERR_ASSERT, "build doc: %s: %s", str, strerror(errno)); if (!mongo_sync_cmd_insert(db->con, dsn, doc, NULL)) return nerr_raise(NERR_DB, "sync_cmd_insert: %s", strerror(errno)); bson_free(doc); 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_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 (); }