void
persist_state_alloc_string(PersistState *self, const gchar *persist_name, const gchar *value, gssize len)
{
PersistEntryHandle handle;
SerializeArchive *sa;
GString *buf;
gboolean success;
gpointer block;
if (len < 0)
len = strlen(value);
buf = g_string_sized_new(len + 5);
sa = serialize_string_archive_new(buf);
success = serialize_write_cstring(sa, value, len);
g_assert(success == TRUE);
serialize_archive_free(sa);
handle = persist_state_alloc_entry(self, persist_name, buf->len);
block = persist_state_map_entry(self, handle);
memcpy(block, buf->str, buf->len);
persist_state_unmap_entry(self, handle);
g_string_free(buf, TRUE);
}
static gboolean
_load_queue(QDisk *self, GQueue *q, gint64 q_ofs, gint32 q_len, gint32 q_count)
{
GString *serialized;
SerializeArchive *sa;
gint i;
if (q_ofs)
{
gssize read_len;
serialized = g_string_sized_new(q_len);
g_string_set_size(serialized, q_len);
read_len = pread(self->fd, serialized->str, q_len, q_ofs);
if (read_len < 0 || read_len != q_len)
{
msg_error("Error reading in-memory buffer from disk-queue file",
evt_tag_str("filename", self->filename),
read_len < 0 ? evt_tag_errno("error", errno) : evt_tag_str("error", "short read"));
g_string_free(serialized, TRUE);
return FALSE;
}
sa = serialize_string_archive_new(serialized);
for (i = 0; i < q_count; i++)
{
LogMessage *msg;
msg = log_msg_new_empty();
if (log_msg_deserialize(msg, sa))
{
g_queue_push_tail(q, msg);
/* we restore the queue without ACKs */
g_queue_push_tail(q, GINT_TO_POINTER(0x80000000));
}
else
{
msg_error("Error reading message from disk-queue file (maybe currupted file) some messages will be lost",
evt_tag_str("filename", self->filename),
evt_tag_int("lost messages", q_count - i));
log_msg_unref(msg);
break;
}
}
g_string_free(serialized, TRUE);
serialize_archive_free(sa);
}
return TRUE;
}
static void
affile_sd_save_pos(LogPipe *s, GlobalConfig *cfg)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
if (cfg->persist && (self->flags & AFFILE_PIPE) == 0)
{
SerializeArchive *archive;
GString *str = g_string_sized_new(0);
archive = serialize_string_archive_new(str);
log_reader_save_state((LogReader *) self->reader, archive);
cfg_persist_config_add_survivor(cfg, affile_sd_format_persist_name(self), str->str, str->len, TRUE);
serialize_archive_free(archive);
g_string_free(str, TRUE);
}
}
static gboolean
_write_message(LogQueueDisk *self, LogMessage *msg)
{
GString *serialized;
SerializeArchive *sa;
gboolean consumed = FALSE;
if (qdisk_initialized(self->qdisk) && qdisk_is_space_avail(self->qdisk, 64))
{
serialized = g_string_sized_new(64);
sa = serialize_string_archive_new(serialized);
log_msg_serialize(msg, sa);
consumed = qdisk_push_tail(self->qdisk, serialized);
serialize_archive_free(sa);
g_string_free(serialized, TRUE);
}
return consumed;
}
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 gint
get_serialized_message_size(LogMessage *msg)
{
GString *serialized;
SerializeArchive *sa;
gint result;
serialized = g_string_sized_new(64);
sa = serialize_string_archive_new(serialized);
assert_true(log_msg_serialize(msg, sa), NULL);
result = serialized->len;
serialize_archive_free(sa);
g_string_free(serialized, TRUE);
return result + sizeof(guint32);
}
static void
affile_sd_load_pos(LogPipe *s, GlobalConfig *cfg)
{
AFFileSourceDriver *self = (AFFileSourceDriver *) s;
gchar *str;
off_t cur_pos;
gsize str_len;
gint version;
if ((self->flags & AFFILE_PIPE) || !cfg->persist)
return;
str = cfg_persist_config_fetch(cfg, affile_sd_format_persist_name(self), &str_len, &version);
if (!str)
return;
if (version == 2)
{
/* NOTE: legacy, should be removed once the release after 3.0 is published */
cur_pos = strtoll(str, NULL, 10);
log_reader_update_pos((LogReader *) self->reader, cur_pos);
g_free(str);
}
else if (version >= 3)
{
GString *g_str = g_string_new("");
SerializeArchive *archive;
g_str = g_string_assign_len(g_str, str, str_len);
archive = serialize_string_archive_new(g_str);
log_reader_restore_state((LogReader *) self->reader, archive);
serialize_archive_free(archive);
g_string_free(g_str, TRUE);
g_free(str);
}
}
static gboolean
_pop_disk(LogQueueDisk *self, LogMessage **msg)
{
GString *serialized;
SerializeArchive *sa;
*msg = NULL;
if (!qdisk_initialized(self->qdisk))
return FALSE;
serialized = g_string_sized_new(64);
if (!qdisk_pop_head(self->qdisk, serialized))
{
g_string_free(serialized, TRUE);
return FALSE;
}
sa = serialize_string_archive_new(serialized);
*msg = log_msg_new_empty();
if (!log_msg_deserialize(*msg, sa))
{
g_string_free(serialized, TRUE);
serialize_archive_free(sa);
log_msg_unref(*msg);
*msg = NULL;
msg_error("Can't read correct message from disk-queue file",evt_tag_str("filename",qdisk_get_filename(self->qdisk)),NULL);
return TRUE;
}
serialize_archive_free(sa);
g_string_free(serialized, TRUE);
return TRUE;
}
