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);
}
