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