static LogMessage *
_get_next_message(LogQueueDiskNonReliable *self, LogPathOptions *path_options)
{
LogMessage *result = NULL;
path_options->ack_needed = TRUE;
if (qdisk_get_length (self->super.qdisk) > 0)
{
result = self->super.read_message(&self->super, path_options);
path_options->ack_needed = FALSE;
}
else if (self->qoverflow->length > 0)
{
result = g_queue_pop_head (self->qoverflow);
POINTER_TO_LOG_PATH_OPTIONS (g_queue_pop_head (self->qoverflow), path_options);
}
return result;
}
static void
_ack_backlog (LogQueueDisk *s, guint num_msg_to_ack)
{
LogQueueDiskNonReliable *self = (LogQueueDiskNonReliable *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
guint i;
for (i = 0; i < num_msg_to_ack; i++)
{
if (self->qbacklog->length < ITEM_NUMBER_PER_MESSAGE)
return;
msg = g_queue_pop_head (self->qbacklog);
POINTER_TO_LOG_PATH_OPTIONS (g_queue_pop_head (self->qbacklog), &path_options);
log_msg_unref (msg);
log_msg_ack (msg, &path_options, AT_PROCESSED);
}
}
static gboolean
_save_queue(QDisk *self, GQueue *q, gint64 *q_ofs, gint32 *q_len)
{
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
SerializeArchive *sa;
GString *serialized;
if (q->length == 0)
{
*q_ofs = 0;
*q_len = 0;
return TRUE;
}
serialized = g_string_sized_new(4096);
sa = serialize_string_archive_new(serialized);
while ((msg = g_queue_pop_head(q)))
{
/* NOTE: we might have some flow-controlled events on qout, when
* saving them to disk, we ack them, they are restored as
* non-flow-controlled entries later, but then we've saved them to
* disk anyway. */
POINTER_TO_LOG_PATH_OPTIONS(g_queue_pop_head(q), &path_options);
log_msg_serialize(msg, sa);
log_msg_ack(msg, &path_options, AT_PROCESSED);
log_msg_unref(msg);
}
serialize_archive_free(sa);
*q_ofs = lseek(self->fd, 0, SEEK_END);
if (!pwrite_strict(self->fd, serialized->str, serialized->len, *q_ofs))
{
msg_error("Error writing in-memory buffer of disk-queue to disk",
evt_tag_str("filename", self->filename),
evt_tag_errno("error", errno));
g_string_free(serialized, TRUE);
return FALSE;
}
*q_len = serialized->len;
g_string_free(serialized, TRUE);
return TRUE;
}
static void
_move_messages_from_overflow(LogQueueDiskNonReliable *self)
{
LogMessage *msg;
LogPathOptions path_options;
/* move away as much entries from the overflow area as possible */
while (_has_movable_message(self))
{
msg = g_queue_pop_head (self->qoverflow);
POINTER_TO_LOG_PATH_OPTIONS (g_queue_pop_head (self->qoverflow), &path_options);
if (qdisk_get_length (self->super.qdisk) == 0 && HAS_SPACE_IN_QUEUE(self->qout))
{
/* we can skip qdisk, go straight to qout */
g_queue_push_tail (self->qout, msg);
g_queue_push_tail (self->qout, LOG_PATH_OPTIONS_FOR_BACKLOG);
log_msg_ref (msg);
}
else
{
if (!self->super.write_message(&self->super, msg))
{
/* oops, altough there seemed to be some free space available,
* we failed saving this message, (it might have needed more
* than 4096 bytes than we ensured), push back and break
*/
g_queue_push_head (self->qoverflow, LOG_PATH_OPTIONS_TO_POINTER (&path_options));
g_queue_push_head (self->qoverflow, msg);
log_msg_ref (msg);
break;
}
}
log_msg_ack (msg, &path_options, AT_PROCESSED);
log_msg_unref (msg);
}
}
