static void
log_reader_stop_watches(LogReader *self)
{
if (iv_fd_registered(&self->fd_watch))
iv_fd_unregister(&self->fd_watch);
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
if (iv_task_registered(&self->restart_task))
iv_task_unregister(&self->restart_task);
}
static void
_stop_watches(JournalReader *self)
{
if (self->watches_running)
{
poll_events_stop_watches(self->poll_events);
if (iv_task_registered(&self->restart_task))
iv_task_unregister(&self->restart_task);
self->watches_running = FALSE;
}
}
static void
afinter_source_stop_watches(AFInterSource *self)
{
if (self->watches_running)
{
if (iv_task_registered(&self->restart_task))
iv_task_unregister(&self->restart_task);
if (iv_timer_registered(&self->mark_timer))
iv_timer_unregister(&self->mark_timer);
self->watches_running = FALSE;
}
}
static void
log_writer_update_fd_callbacks(LogWriter *self, GIOCondition cond)
{
main_loop_assert_main_thread();
if (self->pollable_state > 0)
{
if (self->flags & LW_DETECT_EOF && (cond & G_IO_IN) == 0 && (cond & G_IO_OUT))
{
/* if output is enabled, and we're in DETECT_EOF mode, and input is
* not needed by the log protocol, install the eof check callback to
* destroy the connection if an EOF is received. */
iv_fd_set_handler_in(&self->fd_watch, log_writer_io_check_eof);
}
else if (cond & G_IO_IN)
{
/* in case the protocol requested G_IO_IN, it means that it needs to
* invoke read in the flush code, so just install the flush_output
* handler for input */
iv_fd_set_handler_in(&self->fd_watch, log_writer_io_flush_output);
}
else
{
/* otherwise we're not interested in input */
iv_fd_set_handler_in(&self->fd_watch, NULL);
}
if (cond & G_IO_OUT)
iv_fd_set_handler_out(&self->fd_watch, log_writer_io_flush_output);
else
iv_fd_set_handler_out(&self->fd_watch, NULL);
iv_fd_set_handler_err(&self->fd_watch, log_writer_io_error);
}
else
{
/* fd is not pollable, assume it is always writable */
if (cond & G_IO_OUT)
{
if (!iv_task_registered(&self->immed_io_task))
iv_task_register(&self->immed_io_task);
}
else if (iv_task_registered(&self->immed_io_task))
{
iv_task_unregister(&self->immed_io_task);
}
}
}
static void
log_threaded_dest_driver_stop_watches(LogThrDestDriver* self)
{
if (iv_task_registered(&self->do_work))
{
iv_task_unregister(&self->do_work);
}
if (iv_timer_registered(&self->timer_reopen))
{
iv_timer_unregister(&self->timer_reopen);
}
if (iv_timer_registered(&self->timer_throttle))
{
iv_timer_unregister(&self->timer_throttle);
}
}
static void
log_writer_stop_watches(LogWriter *self)
{
if (self->watches_running)
{
if (iv_timer_registered(&self->suspend_timer))
iv_timer_unregister(&self->suspend_timer);
if (iv_fd_registered(&self->fd_watch))
iv_fd_unregister(&self->fd_watch);
if (iv_task_registered(&self->immed_io_task))
iv_task_unregister(&self->immed_io_task);
log_queue_reset_parallel_push(self->queue);
self->watches_running = FALSE;
}
}
static void abort_me(struct http_client_request *req, int close_fd,
int callback)
{
// @@@ cancel hostname lookup
if (req->hostname_lookup_callback_scheduled)
iv_task_unregister(&req->hostname_lookup);
free(req->redirect);
free(req->redirect_last);
if (req->fd.fd != -1) {
iv_fd_unregister(&req->fd);
if (close_fd) {
close(req->fd.fd);
req->fd.fd = -1;
}
}
if (callback)
req->handler(req->cookie);
}
