LogDriver * afmongodb_dd_new(GlobalConfig *cfg) { MongoDBDestDriver *self = g_new0(MongoDBDestDriver, 1); mongo_util_oid_init (0); log_threaded_dest_driver_init_instance(&self->super); self->super.super.super.super.init = afmongodb_dd_init; self->super.super.super.super.free_fn = afmongodb_dd_free; self->super.queue_method = afmongodb_dd_queue_method; self->super.worker.thread_init = afmongodb_worker_thread_init; self->super.worker.thread_deinit = afmongodb_worker_thread_deinit; self->super.worker.disconnect = afmongodb_dd_disconnect; self->super.worker.insert = afmongodb_worker_insert; self->super.format.stats_instance = afmongodb_dd_format_stats_instance; self->super.format.persist_name = afmongodb_dd_format_persist_name; self->super.stats_source = SCS_MONGODB; afmongodb_dd_set_database((LogDriver *)self, "syslog"); afmongodb_dd_set_collection((LogDriver *)self, "messages"); afmongodb_dd_set_safe_mode((LogDriver *)self, FALSE); init_sequence_number(&self->seq_num); log_template_options_defaults(&self->template_options); afmongodb_dd_set_value_pairs(&self->super.super.super, value_pairs_new_default(cfg)); return (LogDriver *)self; }
LogDriver * afmongodb_dd_new(void) { MongoDBDestDriver *self = g_new0(MongoDBDestDriver, 1); mongo_util_oid_init (0); log_dest_driver_init_instance(&self->super); self->super.super.super.init = afmongodb_dd_init; self->super.super.super.deinit = afmongodb_dd_deinit; self->super.super.super.queue = afmongodb_dd_queue; self->super.super.super.free_fn = afmongodb_dd_free; afmongodb_dd_set_servers((LogDriver *)self, g_list_append (NULL, g_strdup ("127.0.0.1:27017"))); afmongodb_dd_set_database((LogDriver *)self, "syslog"); afmongodb_dd_set_collection((LogDriver *)self, "messages"); afmongodb_dd_set_safe_mode((LogDriver *)self, FALSE); init_sequence_number(&self->seq_num); self->writer_thread_wakeup_cond = g_cond_new(); self->suspend_mutex = g_mutex_new(); self->queue_mutex = g_mutex_new(); return (LogDriver *)self; }
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_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_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 (); }
void test_func_mongo_sync_oidtest (void) { mongo_sync_connection *conn; bson *boid, *reply = NULL; bson_cursor *c; mongo_packet *p; guint8 *oid; const guint8 *noid; mongo_util_oid_init (0); oid = mongo_util_oid_new (1); boid = bson_new (); bson_append_oid (boid, "driverOIDTest", oid); bson_finish (boid); conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); p = mongo_sync_cmd_custom (conn, config.db, boid); ok (p != NULL, "driverOIDTest(OID) custom command works"); mongo_wire_reply_packet_get_nth_document (p, 1, &reply); bson_finish (reply); c = bson_find (reply, "oid"); bson_cursor_get_oid (c, &noid); ok (memcmp (oid, noid, 12) == 0, "driverOIDTest(OID) returns the same OID"); bson_cursor_free (c); mongo_sync_disconnect (conn); mongo_wire_packet_free (p); bson_free (boid); bson_free (reply); }
void mongo_gridfs_put (config_t *config, gint argc, gchar *argv[]) { mongo_sync_gridfs *gfs; mongo_sync_gridfs_chunked_file *gfile; bson *meta; int fd; guint8 *data; struct stat st; gchar *gfn, *ifn, *oid_s; if (argc < 4) { fprintf (stderr, "Usage: %s put INPUT_FILENAME GRIDFS_FILENAME\n", argv[0]); exit (1); } ifn = argv[2]; gfn = argv[3]; mongo_util_oid_init (0); gfs = mongo_gridfs_connect (config); VLOG ("Opening input file: '%s'...\n", ifn); fd = open (ifn, O_RDONLY); if (!fd) { fprintf (stderr, "Error opening input file: %s\n", strerror (errno)); exit (1); } if (fstat (fd, &st) != 0) { fprintf (stderr, "Error stat'ing the input file: %s\n", strerror (errno)); exit (1); } data = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (data == MAP_FAILED) { fprintf (stderr, "Error mmapping the input file: %s\n", strerror (errno)); } meta = bson_build (BSON_TYPE_STRING, "filename", gfn, -1, BSON_TYPE_NONE); bson_finish (meta); VLOG ("Uploading '%s' -> '%s'...\n", ifn, gfn); gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, meta, data, st.st_size); if (!gfile) mongo_gridfs_error (errno); bson_free (meta); munmap (data, st.st_size); oid_s = mongo_util_oid_as_string (mongo_sync_gridfs_file_get_id (gfile)); printf ("Uploaded file: %s (_id: %s; md5 = %s)\n", gfn, oid_s, mongo_sync_gridfs_file_get_md5 (gfile)); g_free (oid_s); mongo_sync_gridfs_chunked_file_free (gfile); mongo_sync_gridfs_free (gfs, TRUE); }
void test_mongo_sync_gridfs_chunked_file_new_from_buffer (void) { mongo_sync_connection *conn; mongo_sync_gridfs *gfs; bson *metadata; guint8 *buffer; mongo_sync_gridfs_chunked_file *gfile; buffer = g_malloc (BUFFER_SIZE); memset (buffer, 'a', BUFFER_SIZE); conn = test_make_fake_sync_conn (4, TRUE); gfs = mongo_sync_gridfs_new (conn, config.gfs_prefix); metadata = bson_build (BSON_TYPE_STRING, "filename", "gridfs_file_new_from_buffer", -1, BSON_TYPE_NONE); bson_finish (metadata); ok (mongo_sync_gridfs_chunked_file_new_from_buffer (NULL, metadata, buffer, BUFFER_SIZE) == FALSE, "mongo_sync_gridfs_chunked_file_new_from_buffer() fails with a NULL GridFS"); mongo_sync_gridfs_free (gfs, TRUE); begin_network_tests (5); 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_file_new_from_buffer (gfs, metadata, NULL, BUFFER_SIZE) == FALSE, "mongo_sync_gridfs_chunked_file_new_from_buffer() fails with NULL data"); ok (mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata, buffer, 0) == FALSE, "mongo_sync_gridfs_chunked_file_new_from_buffer() fails with an invalid data size"); ok (mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata, buffer, BUFFER_SIZE) == FALSE, "mongo_sync_gridfs_chunked_file_new_from_buffer() fails with uninitialized OID"); mongo_util_oid_init (0); gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, metadata, buffer, BUFFER_SIZE); ok (gfile != NULL, "mongo_sync_gridfs_chunked_file_new_from_buffer() works with metadata"); mongo_sync_gridfs_chunked_file_free (gfile); gfile = mongo_sync_gridfs_chunked_file_new_from_buffer (gfs, NULL, buffer, BUFFER_SIZE); ok (gfile != NULL, "mongo_sync_gridfs_chunked_file_new_from_buffer() works without metadata"); mongo_sync_gridfs_chunked_file_free (gfile); mongo_sync_gridfs_free (gfs, TRUE); end_network_tests (); bson_free (metadata); g_free (buffer); }
void test_func_mongo_sync_safe_mode (void) { mongo_sync_connection *conn; const bson *docs[10]; bson *b1, *b2, *b3, *b4, *cmd; mongo_packet *p; gchar *error; mongo_util_oid_init (0); b1 = bson_new (); bson_append_string (b1, "func_mongo_sync_safe_mode", "works", -1); bson_finish (b1); b2 = bson_new (); bson_append_int32 (b2, "int32", 1984); bson_finish (b2); b3 = test_bson_generate_full (); b4 = test_bson_generate_full (); docs[0] = b1; docs[1] = b2; docs[2] = b3; docs[3] = b4; conn = mongo_sync_connect (config.primary_host, config.primary_port, FALSE); /* Test inserts */ mongo_sync_conn_set_safe_mode (conn, FALSE); ok (mongo_sync_cmd_insert_n (conn, config.ns, 4, docs) == TRUE, "mongo_sync_cmd_insert_n() should not fail with safe mode off"); mongo_sync_conn_set_safe_mode (conn, TRUE); ok (mongo_sync_cmd_insert_n (conn, config.ns, 4, docs) == FALSE, "mongo_sync_cmd_insert_n() should fail with safe mode on"); /* Test a custom command */ cmd = bson_new (); bson_append_int32 (cmd, "bogusCommand", 1); bson_finish (cmd); mongo_sync_cmd_reset_error (conn, config.db); mongo_sync_conn_set_safe_mode (conn, FALSE); p = mongo_sync_cmd_custom (conn, config.db, cmd); mongo_sync_cmd_get_last_error (conn, config.db, &error); ok (p == NULL && strcmp (error, "no such cmd: bogusCommand") == 0, "mongo_sync_cmd_custom() with a bogus command fails with safe-mode off"); bson_free (cmd); cmd = bson_new (); bson_append_int32 (cmd, "bogusCommand2", 1); bson_finish (cmd); mongo_sync_cmd_reset_error (conn, config.db); mongo_sync_conn_set_safe_mode (conn, TRUE); p = mongo_sync_cmd_custom (conn, config.db, cmd); mongo_sync_cmd_get_last_error (conn, config.db, &error); ok (p == NULL && strcmp (error, "no such cmd: bogusCommand2") == 0, "mongo_sync_cmd_custom() with a bogus command fails with safe-mode on"); bson_free (cmd); mongo_sync_disconnect (conn); bson_free (b1); bson_free (b2); bson_free (b3); bson_free (b4); }