1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/* Copyright (c) 2015-2017, The Tor Project, Inc. */
/* See LICENSE for licensing information */
/**
* \file periodic.c
*
* \brief Generic backend for handling periodic events.
*
* The events in this module are used by main.c to track items that need
* to fire once every N seconds, possibly picking a new interval each time
* that they fire. See periodic_events[] in main.c for examples.
*/
#include "or.h"
#include "compat_libevent.h"
#include "config.h"
#include "periodic.h"
#include <event2/event.h>
/** We disable any interval greater than this number of seconds, on the
* grounds that it is probably an absolute time mistakenly passed in as a
* relative time.
*/
static const int MAX_INTERVAL = 10 * 365 * 86400;
/** Set the event <b>event</b> to run in <b>next_interval</b> seconds from
* now. */
static void
periodic_event_set_interval(periodic_event_item_t *event,
time_t next_interval)
{
tor_assert(next_interval < MAX_INTERVAL);
struct timeval tv;
tv.tv_sec = next_interval;
tv.tv_usec = 0;
event_add(event->ev, &tv);
}
/** Wraps dispatches for periodic events, <b>data</b> will be a pointer to the
* event that needs to be called */
static void
periodic_event_dispatch(evutil_socket_t fd, short what, void *data)
{
(void)fd;
(void)what;
periodic_event_item_t *event = data;
time_t now = time(NULL);
const or_options_t *options = get_options();
// log_debug(LD_GENERAL, "Dispatching %s", event->name);
int r = event->fn(now, options);
int next_interval = 0;
/* update the last run time if action was taken */
if (r==0) {
log_err(LD_BUG, "Invalid return value for periodic event from %s.",
event->name);
tor_assert(r != 0);
} else if (r > 0) {
event->last_action_time = now;
/* If the event is meant to happen after ten years, that's likely
* a bug, and somebody gave an absolute time rather than an interval.
*/
tor_assert(r < MAX_INTERVAL);
next_interval = r;
} else {
/* no action was taken, it is likely a precondition failed,
* we should reschedule for next second incase the precondition
* passes then */
next_interval = 1;
}
// log_debug(LD_GENERAL, "Scheduling %s for %d seconds", event->name,
// next_interval);
struct timeval tv = { next_interval , 0 };
event_add(event->ev, &tv);
}
/** Schedules <b>event</b> to run as soon as possible from now. */
void
periodic_event_reschedule(periodic_event_item_t *event)
{
periodic_event_set_interval(event, 1);
}
/** Initializes the libevent backend for a periodic event. */
void
periodic_event_setup(periodic_event_item_t *event)
{
if (event->ev) { /* Already setup? This is a bug */
log_err(LD_BUG, "Initial dispatch should only be done once.");
tor_assert(0);
}
event->ev = tor_event_new(tor_libevent_get_base(),
-1, 0,
periodic_event_dispatch,
event);
tor_assert(event->ev);
}
/** Handles initial dispatch for periodic events. It should happen 1 second
* after the events are created to mimic behaviour before #3199's refactor */
void
periodic_event_launch(periodic_event_item_t *event)
{
if (! event->ev) { /* Not setup? This is a bug */
log_err(LD_BUG, "periodic_event_launch without periodic_event_setup");
tor_assert(0);
}
// Initial dispatch
periodic_event_dispatch(-1, EV_TIMEOUT, event);
}
/** Release all storage associated with <b>event</b> */
void
periodic_event_destroy(periodic_event_item_t *event)
{
if (!event)
return;
tor_event_free(event->ev);
event->last_action_time = 0;
}
|
