static void
afinter_source_mark(gpointer s)
{
AFInterSource *self = (AFInterSource *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
struct timespec nmt;
main_loop_assert_main_thread();
g_static_mutex_lock(&internal_mark_target_lock);
nmt = next_mark_target;
g_static_mutex_unlock(&internal_mark_target_lock);
if (log_source_free_to_send(&self->super) && nmt.tv_sec <= self->mark_timer.expires.tv_sec)
{
/* the internal_mark_target has not been overwritten by an incoming message in afinter_postpone_mark
(there was no msg in the meantime) -> the mark msg can be sent */
msg = log_msg_new_mark();
path_options.ack_needed = FALSE;
log_pipe_queue(&self->super.super, msg, &path_options);
/* the next_mark_target will be increased in afinter_postpone_mark */
}
afinter_source_update_watches(self);
}
void
log_source_post(LogSource *self, LogMessage *msg)
{
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint old_window_size;
ack_tracker_track_msg(self->ack_tracker, msg);
/* NOTE: we start by enabling flow-control, thus we need an acknowledgement */
path_options.ack_needed = TRUE;
log_msg_ref(msg);
log_msg_add_ack(msg, &path_options);
msg->ack_func = log_source_msg_ack;
old_window_size = g_atomic_counter_exchange_and_add(&self->window_size, -1);
/*
* NOTE: this assertion validates that the source is not overflowing its
* own flow-control window size, decreased above, by the atomic statement.
*
* If the _old_ value is zero, that means that the decrement operation
* above has decreased the value to -1.
*/
g_assert(old_window_size > 0);
log_pipe_queue(&self->super, msg, &path_options);
}
static gboolean
log_reader_handle_line(LogReader *self, const guchar *line, gint length, GSockAddr *saddr)
{
LogMessage *m;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint i;
msg_debug("Incoming log entry",
evt_tag_printf("line", "%.*s", length, line),
NULL);
/* use the current time to get the time zone offset */
m = log_msg_new((gchar *) line, length,
saddr,
&self->options->parse_options);
if (!m->saddr && self->peer_addr)
{
m->saddr = g_sockaddr_ref(self->peer_addr);
}
if (self->options->tags)
{
for (i = 0; i < self->options->tags->len; i++)
{
log_msg_set_tag_by_id(m, g_array_index(self->options->tags, LogTagId, i));
}
}
log_msg_set_tag_by_id(m, self->super.options->source_group_tag);
log_pipe_queue(&self->super.super, m, &path_options);
return log_source_free_to_send(&self->super);
}
static void
log_dest_group_queue(LogPipe *s, LogMessage *msg, gint path_flags)
{
LogDestGroup *self = (LogDestGroup *) s;
LogDriver *p;
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
{
log_msg_ref(msg);
log_msg_ack_block_start(msg, log_dest_group_ack, NULL);
}
for (p = self->drivers; p; p = p->drv_next)
{
#if 1 /* start dongshu */
if(p->processed_limit !=0 &&
((p->processed_messages > 0) && (p->processed_messages % p->processed_limit == 0))){
p->flush = TRUE;
}
#endif /* end */
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
log_msg_ack_block_inc(msg);
log_pipe_queue(&p->super, log_msg_ref(msg), path_flags); /* call affile_dd_queue()... */
p->processed_messages++;
}
(*self->processed_messages)++;
if ((path_flags & PF_FLOW_CTL_OFF) == 0)
log_msg_ack(msg);
log_msg_unref(msg);
}
static void
log_multiplexer_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
LogMultiplexer *self = (LogMultiplexer *) s;
gint i;
LogPathOptions local_options = *path_options;
gboolean matched;
gboolean delivered = FALSE;
gboolean last_delivery;
gint fallback;
local_options.matched = &matched;
for (fallback = 0; (fallback == 0) || (fallback == 1 && self->fallback_exists && !delivered); fallback++)
{
for (i = 0; i < self->next_hops->len; i++)
{
LogPipe *next_hop = g_ptr_array_index(self->next_hops, i);
if (G_UNLIKELY(fallback == 0 && (next_hop->flags & PIF_BRANCH_FALLBACK) != 0))
{
continue;
}
else if (G_UNLIKELY(fallback && (next_hop->flags & PIF_BRANCH_FALLBACK) == 0))
{
continue;
}
matched = TRUE;
log_msg_add_ack(msg, &local_options);
/* NOTE: this variable indicates that the upcoming message
* delivery is the last one, thus we don't need to retain an an
* unmodified copy to be sent to further paths. The current
* delivery may modify the message at will.
*/
last_delivery = (self->super.pipe_next == NULL) &&
(i == self->next_hops->len - 1) &&
(!self->fallback_exists || delivered || fallback == 1);
if (!last_delivery)
log_msg_write_protect(msg);
log_pipe_queue(next_hop, log_msg_ref(msg), &local_options);
if (!last_delivery)
log_msg_write_unprotect(msg);
if (matched)
{
delivered = TRUE;
if (G_UNLIKELY(next_hop->flags & PIF_BRANCH_FINAL))
break;
}
}
}
log_pipe_forward_msg(s, msg, path_options);
}
void
log_pipe_forward_msg(LogPipe *self, LogMessage *msg, const LogPathOptions *path_options)
{
if (self->pipe_next)
{
log_pipe_queue(self->pipe_next, msg, path_options);
}
else
{
log_msg_drop(msg, path_options);
}
}
static void
log_source_group_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options)
{
LogSourceGroup *self = (LogSourceGroup *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
log_msg_set_value(msg, LM_V_SOURCE, self->name, self->name_len);
if (msg->flags & LF_LOCAL)
afinter_postpone_mark(cfg->mark_freq);
log_pipe_queue(self->super.pipe_next, msg, path_options);
(*self->processed_messages)++;
}
static void
_generate_messages(TestThreadedDestDriver *dd, gint n)
{
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT_NOACK;
gchar buf[32];
for (gint i = 0; i < n; i++)
{
msg = create_sample_message();
g_snprintf(buf, sizeof(buf), "%d", i);
log_msg_set_value(msg, LM_V_PID, buf, -1);
log_pipe_queue(&dd->super.super.super.super, msg, &path_options);
}
}
static void
log_process_pipe_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options)
{
LogProcessPipe *self = (LogProcessPipe *) s;
if (log_process_rule_process(self->rule, msg))
{
/* forward message */
if (s->pipe_next)
log_pipe_queue(s->pipe_next, msg, path_options);
else
log_msg_drop(msg, path_options);
}
else
{
if (path_options->matched)
(*path_options->matched) = FALSE;
log_msg_drop(msg, path_options);
}
}
static void
afinter_source_post(gpointer s)
{
AFInterSource *self = (AFInterSource *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
while (log_source_free_to_send(&self->super))
{
g_static_mutex_lock(&internal_msg_lock);
msg = g_queue_pop_head(internal_msg_queue);
g_static_mutex_unlock(&internal_msg_lock);
if (!msg)
break;
log_pipe_queue(&self->super.super, msg, &path_options);
}
afinter_source_update_watches(self);
}
static void
trigger_source_triggered (gpointer s)
{
TriggerSource *self = (TriggerSource *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
main_loop_assert_main_thread ();
if (!log_source_free_to_send (&self->super))
goto end;
msg = log_msg_new_internal (LOG_INFO, self->options->message);
path_options.ack_needed = FALSE;
log_pipe_queue (&self->super.super, msg, &path_options);
end:
trigger_source_update_watches (self);
}
static void
log_multiplexer_queue(LogPipe *s, LogMessage *msg, const LogPathOptions *path_options, gpointer user_data)
{
LogMultiplexer *self = (LogMultiplexer *) s;
gint i;
LogPathOptions local_options = *path_options;
gboolean matched;
gboolean delivered = FALSE;
gint fallback;
local_options.matched = &matched;
for (fallback = 0; (fallback == 0) || (fallback == 1 && self->fallback_exists && !delivered); fallback++)
{
for (i = 0; i < self->next_hops->len; i++)
{
LogPipe *next_hop = g_ptr_array_index(self->next_hops, i);
if (G_UNLIKELY(fallback == 0 && (next_hop->flags & PIF_BRANCH_FALLBACK) != 0))
{
continue;
}
else if (G_UNLIKELY(fallback && (next_hop->flags & PIF_BRANCH_FALLBACK) == 0))
{
continue;
}
matched = TRUE;
log_msg_add_ack(msg, &local_options);
log_pipe_queue(next_hop, log_msg_ref(msg), &local_options);
if (matched)
{
delivered = TRUE;
if (G_UNLIKELY(next_hop->flags & PIF_BRANCH_FINAL))
break;
}
}
}
log_pipe_forward_msg(s, msg, path_options);
}
static gboolean
log_reader_handle_line(LogReader *self, const guchar *line, gint length, LogTransportAuxData *aux)
{
LogMessage *m;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
msg_debug("Incoming log entry",
evt_tag_printf("line", "%.*s", length, line),
NULL);
/* use the current time to get the time zone offset */
m = log_msg_new((gchar *) line, length,
aux->peer_addr ? : self->peer_addr,
&self->options->parse_options);
log_msg_refcache_start_producer(m);
log_transport_aux_data_foreach(aux, _add_aux_nvpair, m);
log_pipe_queue(&self->super.super, m, &path_options);
log_msg_refcache_stop();
return log_source_free_to_send(&self->super);
}
static gboolean
log_reader_handle_line(LogReader *self, const guchar *line, gint length, GSockAddr *saddr)
{
LogMessage *m;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
msg_debug("Incoming log entry",
evt_tag_printf("line", "%.*s", length, line),
NULL);
/* use the current time to get the time zone offset */
m = log_msg_new((gchar *) line, length,
saddr,
&self->options->parse_options);
log_msg_refcache_start_producer(m);
if (!m->saddr && self->peer_addr)
{
m->saddr = g_sockaddr_ref(self->peer_addr);
}
log_pipe_queue(&self->super.super, m, &path_options);
log_msg_refcache_stop();
return log_source_free_to_send(&self->super);
}
void
invoke_rewrite_rule(LogRewrite *pipe, LogMessage *msg)
{
LogPathOptions po = LOG_PATH_OPTIONS_INIT;
log_pipe_queue((LogPipe *) pipe, log_msg_ref(msg), &po);
};
static void
log_center_queue(LogPipe *s, LogMessage *msg, gint path_flags)
{
LogCenter *self = (LogCenter *) s;
gboolean match, fallbacks, have_fallbacks = 1;
gint ci, fi, di;
(*self->received_messages)++;
afinter_postpone_mark(self->cfg->mark_freq);
log_msg_ref(msg);
log_msg_ack_block_start(msg, log_center_ack, NULL);
for (match = 0, fallbacks = 0; !match && have_fallbacks && (fallbacks <= 1); fallbacks++)
{
have_fallbacks = 0;
for (ci = 0; ci < self->cfg->connections->len; ci++)
{
LogConnection *conn = (LogConnection *) g_ptr_array_index(self->cfg->connections, ci);
if (!fallbacks && (conn->flags & LC_FALLBACK))
{
have_fallbacks = 1;
continue;
}
else if (fallbacks && !(conn->flags & LC_FALLBACK))
{
continue;
}
if (!(conn->flags & LC_CATCHALL))
{
/* check source */
if (!g_hash_table_lookup(conn->source_cache, msg->source_group->name->str))
{
goto next_connection;
}
}
else
{
/* catchall, every source matches */
;
}
for (fi = 0; fi < conn->filters->len; fi++)
{
LogEndpoint *ep = (LogEndpoint *) g_ptr_array_index(conn->filters, fi);
LogFilterRule *f;
f = (LogFilterRule *) ep->ref;
if (!log_filter_rule_eval(f, msg))
{
goto next_connection;
}
}
match = 1;
for (di = 0; di < conn->destinations->len; di++)
{
LogEndpoint *ep = (LogEndpoint *) g_ptr_array_index(conn->destinations, di);
LogDestGroup *dest;
if (conn->flags & LC_FLOW_CONTROL)
log_msg_ack_block_inc(msg);
dest = (LogDestGroup *) ep->ref;
log_pipe_queue(&dest->super, log_msg_ref(msg), path_flags | ((conn->flags & LC_FLOW_CONTROL) ? 0 : PF_FLOW_CTL_OFF));
(*self->queued_messages)++;
}
if (conn->flags & LC_FINAL)
{
break;
}
next_connection:
;
}
}
/* our own ack */
log_msg_ack(msg);
}
