void
testcase_zero_diskbuf_alternating_send_acks()
{
LogQueue *q;
gint i;
q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
log_queue_set_use_backlog(q, TRUE);
fed_messages = 0;
acked_messages = 0;
for (i = 0; i < 10; i++)
{
feed_some_messages(&q, 10);
send_some_messages(q, 10);
app_ack_some_messages(q, 10);
}
if (fed_messages != acked_messages)
{
fprintf(stderr, "did not receive enough acknowledgements: fed_messages=%d, acked_messages=%d\n", fed_messages, acked_messages);
exit(1);
}
log_queue_unref(q);
}
static void
afamqp_dd_free(LogPipe *d)
{
AMQPDestDriver *self = (AMQPDestDriver *) d;
g_mutex_free(self->suspend_mutex);
g_mutex_free(self->queue_mutex);
g_cond_free(self->writer_thread_wakeup_cond);
if (self->queue)
log_queue_unref(self->queue);
g_free(self->exchange);
g_free(self->exchange_type);
log_template_unref(self->routing_key_template);
log_template_unref(self->body_template);
g_free(self->user);
g_free(self->password);
g_free(self->host);
g_free(self->vhost);
g_free(self->entries);
if (self->vp)
value_pairs_free(self->vp);
log_dest_driver_free(d);
}
Test(logqueue, test_with_threads)
{
LogQueue *q;
GThread *thread_feed[FEEDERS], *thread_consume;
GThread *other_threads[FEEDERS];
gint i, j;
log_queue_set_max_threads(FEEDERS);
for (i = 0; i < TEST_RUNS; i++)
{
fprintf(stderr,"starting testrun: %d\n",i);
q = log_queue_fifo_new(MESSAGES_SUM, NULL);
log_queue_set_use_backlog(q, TRUE);
for (j = 0; j < FEEDERS; j++)
{
fprintf(stderr,"starting feed thread %d\n",j);
other_threads[j] = g_thread_create(_output_thread, NULL, TRUE, NULL);
thread_feed[j] = g_thread_create(_threaded_feed, q, TRUE, NULL);
}
thread_consume = g_thread_create(_threaded_consume, q, TRUE, NULL);
for (j = 0; j < FEEDERS; j++)
{
fprintf(stderr,"waiting for feed thread %d\n",j);
g_thread_join(thread_feed[j]);
g_thread_join(other_threads[j]);
}
g_thread_join(thread_consume);
log_queue_unref(q);
}
fprintf(stderr, "Feed speed: %.2lf\n", (double) TEST_RUNS * MESSAGES_SUM * 1000000 / sum_time);
}
static void
_common_cleanup(LogQueueDiskReliable *dq)
{
log_queue_unref(&dq->super.super);
unlink(FILENAME);
disk_queue_options_destroy(&options);
}
static void
_close_diskq(LogThreadedFetcherDriver *s)
{
ThreadedDiskqSourceDriver *self = (ThreadedDiskqSourceDriver *) s;
log_queue_unref(self->queue);
self->queue = NULL;
}
/* consumes the reference */
void
log_writer_set_queue(LogWriter *s, LogQueue *queue)
{
LogWriter *self = (LogWriter *)s;
log_queue_unref(self->queue);
self->queue = log_queue_ref(queue);
log_queue_set_use_backlog(self->queue, TRUE);
}
/* consumes the reference */
void
log_writer_set_queue(LogWriter *s, LogQueue *queue)
{
LogWriter *self = (LogWriter *)s;
if (self->queue)
log_queue_unref(self->queue);
self->queue = queue;
}
void
log_threaded_dest_driver_free(LogPipe *s)
{
LogThrDestDriver *self = (LogThrDestDriver *)s;
if (self->queue)
log_queue_unref(self->queue);
log_dest_driver_free((LogPipe *)self);
}
/* consumes the reference in @q */
static void
log_dest_driver_release_queue_method(LogDestDriver *self, LogQueue *q, gpointer user_data)
{
GlobalConfig *cfg = log_pipe_get_config(&self->super.super);
/* we only save the LogQueue instance if it contains data */
if (q->persist_name && log_queue_keep_on_reload(q) > 0)
cfg_persist_config_add(cfg, q->persist_name, q, (GDestroyNotify) log_queue_unref, FALSE);
else
log_queue_unref(q);
}
void
log_dest_driver_free(LogPipe *s)
{
LogDestDriver *self = (LogDestDriver *) s;
GList *l;
for (l = self->queues; l; l = l->next)
{
log_queue_unref((LogQueue *) l->data);
}
g_list_free(self->queues);
log_driver_free(s);
}
static void
afmongodb_dd_free(LogPipe *d)
{
MongoDBDestDriver *self = (MongoDBDestDriver *)d;
g_mutex_free(self->suspend_mutex);
g_cond_free(self->writer_thread_wakeup_cond);
if (self->queue)
log_queue_unref(self->queue);
g_free(self->db);
g_free(self->coll);
g_free(self->user);
g_free(self->password);
g_free(self->address);
string_list_free(self->servers);
if (self->vp)
value_pairs_free(self->vp);
log_dest_driver_free(d);
}
Test(logqueue, test_zero_diskbuf_and_normal_acks)
{
LogQueue *q;
gint i;
q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
StatsClusterKey sc_key;
stats_lock();
stats_cluster_logpipe_key_set(&sc_key, SCS_DESTINATION, q->persist_name, NULL );
stats_register_counter(0, &sc_key, SC_TYPE_QUEUED, &q->queued_messages);
stats_register_counter(1, &sc_key, SC_TYPE_MEMORY_USAGE, &q->memory_usage);
stats_unlock();
log_queue_set_use_backlog(q, TRUE);
cr_assert_eq(atomic_gssize_racy_get(&q->queued_messages->value), 0);
fed_messages = 0;
acked_messages = 0;
feed_some_messages(q, 1);
cr_assert_eq(stats_counter_get(q->queued_messages), 1);
cr_assert_neq(stats_counter_get(q->memory_usage), 0);
gint size_when_single_msg = stats_counter_get(q->memory_usage);
for (i = 0; i < 10; i++)
feed_some_messages(q, 10);
cr_assert_eq(stats_counter_get(q->queued_messages), 101);
cr_assert_eq(stats_counter_get(q->memory_usage), 101*size_when_single_msg);
send_some_messages(q, fed_messages);
log_queue_ack_backlog(q, fed_messages);
cr_assert_eq(fed_messages, acked_messages,
"did not receive enough acknowledgements: fed_messages=%d, acked_messages=%d",
fed_messages, acked_messages);
log_queue_unref(q);
}
Test(logqueue, test_zero_diskbuf_alternating_send_acks)
{
LogQueue *q;
gint i;
q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
log_queue_set_use_backlog(q, TRUE);
fed_messages = 0;
acked_messages = 0;
for (i = 0; i < 10; i++)
{
feed_some_messages(q, 10);
send_some_messages(q, 10);
log_queue_ack_backlog(q, 10);
}
cr_assert_eq(fed_messages, acked_messages,
"did not receive enough acknowledgements: fed_messages=%d, acked_messages=%d",
fed_messages, acked_messages);
log_queue_unref(q);
}
Test(logqueue, log_queue_fifo_rewind_all_and_memory_usage)
{
LogQueue *q = log_queue_fifo_new(OVERFLOW_SIZE, NULL);
log_queue_set_use_backlog(q, TRUE);
StatsClusterKey sc_key;
stats_lock();
stats_cluster_logpipe_key_set(&sc_key, SCS_DESTINATION, q->persist_name, NULL );
stats_register_counter(1, &sc_key, SC_TYPE_MEMORY_USAGE, &q->memory_usage);
stats_unlock();
feed_some_messages(q, 1);
gint size_when_single_msg = stats_counter_get(q->memory_usage);
feed_some_messages(q, 9);
cr_assert_eq(stats_counter_get(q->memory_usage), 10*size_when_single_msg);
send_some_messages(q, 10);
cr_assert_eq(stats_counter_get(q->memory_usage), 0);
log_queue_rewind_backlog_all(q);
cr_assert_eq(stats_counter_get(q->memory_usage), 10*size_when_single_msg);
log_queue_unref(q);
}
