CcnetTimer*
ccnet_timer_new (TimerCB func,
void *user_data,
uint64_t interval_milliseconds)
{
CcnetTimer *timer = g_new0 (CcnetTimer, 1);
timer->tv = timeval_from_msec (interval_milliseconds);
timer->func = func;
timer->user_data = user_data;
evtimer_set (&timer->event, timer_callback, timer);
evtimer_add (&timer->event, &timer->tv);
return timer;
}
void
send_byte(int sock, short event, void * arg) {
char fbyte;
struct timeval tv;
if (fread(&fbyte, 1, 1, input_file) == 1) {
printf("sending: '%c' (%x)\n", isprint(fbyte) ? fbyte : ' ', fbyte);
evbuffer_add(bufferevent_get_output(bev), &fbyte, 1);
tv.tv_sec = sec;
tv.tv_usec = usec;
evtimer_add(sev, &tv);
}
}
void
timer::set_timer(callback *func, timeval *t)
{
typedef boost::shared_ptr<event> ev_ptr;
ev_ptr ev = ev_ptr(new event);
// delete old event
unset_timer(func);
func->m_timer = this;
// add new event
m_events[func] = ev;
evtimer_set(ev.get(), timer_callback, func);
evtimer_add(ev.get(), t);
}
void stats_start(stats_t *stats)
{
struct timeval t = {.tv_sec = 1, .tv_usec = 0};
system_data_t *sysdata;
assert(stats);
assert(stats->stats_event == NULL);
assert(stats->sysdata);
sysdata = stats->sysdata;
assert(sysdata->evbase);
stats->stats_event = evtimer_new(sysdata->evbase, stats_handler, (void *) stats);
evtimer_add(stats->stats_event, &t);
assert(stats->stats_event);
}
void gp_get_dev_logs(int fd, short event, void *arg) {
evutil_timerclear(&gp_cfg.scan_log_interval);
gp_cfg.scan_log_interval.tv_sec=5;
if ( evtimer_add(&gp_cfg.ev_scan_log, &gp_cfg.scan_log_interval) < 0) syslog(LOG_ERR, "event_add.evkeep setup: %m");
// fprintf(stderr, "Get logs from all devs.\n");
int i=0, gp_dst;
for(gp_dst=1;gp_dst<=gp_cfg.max_dev_n;i++,gp_dst++) {
if( devices[gp_dst].activ == 1 ) {
// ad_get_token_bound(AD_Q_SECOND, gp_dst, NULL);
ad_get_buff_addr(AD_Q_SECOND, gp_dst, &cb_log_read );
// cmd_log_read(gp_dst, , &cb_log_read);
}
}
return;
}
static int update_conn_event_sleep(struct connection *c)
{
struct timeval t = {.tv_sec = 0, .tv_usec = 0};
struct timeval now;
if (event_del(&c->ev) == -1) return 0;
c->ev_flags = 0; // clear event flags in case we ping-pong to other modes
evtimer_set(&c->ev, sleep_handler, (void *)c);
event_base_set(c->t->base, &c->ev);
gettimeofday(&now, NULL);
// every time we come into this loop, we've run once. which means we
// always have to advance the next_sleep timer.
if (c->next_sleep.tv_sec == 0) {
// initialize next_sleep as late as possible to avoid spamming.
gettimeofday(&c->next_sleep, NULL);
}
memcpy(&t, &c->next_sleep, sizeof(struct timeval));
timeradd(&t, &c->tosleep, &c->next_sleep);
timersub(&c->next_sleep, &now, &t);
// so far as I can tell, it treats times in the past as "Wake up
// immediately".
evtimer_add(&c->ev, &t);
return 1;
}
/* TODO: Be more wary of IOV_MAX */
static void drain_iovecs(struct iovec *vecs, const int iov_count, const int written) {
int i;
int todrain = written;
for (i = 0; i < iov_count; i++) {
if (vecs[i].iov_len > 0) {
if (todrain >= vecs[i].iov_len) {
todrain -= vecs[i].iov_len;
vecs[i].iov_base = NULL;
vecs[i].iov_len = 0;
} else {
vecs[i].iov_len -= todrain;
vecs[i].iov_base += todrain;
break;
}
}
}
}
/* ARGSUSED */
void
control_accept(int listenfd, short event, void *arg)
{
int connfd;
socklen_t len;
struct sockaddr_un sun;
struct ctl_conn *c;
struct control_sock *cs = arg;
event_add(&cs->cs_ev, NULL);
if ((event & EV_TIMEOUT))
return;
len = sizeof(sun);
if ((connfd = accept4(listenfd,
(struct sockaddr *)&sun, &len, SOCK_NONBLOCK)) == -1) {
/*
* Pause accept if we are out of file descriptors, or
* libevent will haunt us here too.
*/
if (errno == ENFILE || errno == EMFILE) {
struct timeval evtpause = { 1, 0 };
event_del(&cs->cs_ev);
evtimer_add(&cs->cs_evt, &evtpause);
} else if (errno != EWOULDBLOCK && errno != EINTR &&
errno != ECONNABORTED)
log_warn("%s: accept", __func__);
return;
}
if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
close(connfd);
log_warn("%s: calloc", __func__);
return;
}
imsg_init(&c->iev.ibuf, connfd);
c->iev.handler = control_dispatch_imsg;
c->iev.events = EV_READ;
c->iev.data = cs; /* proc.c cheats (reuses the handler) */
event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
c->iev.handler, cs);
event_add(&c->iev.ev, NULL);
TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
}
/* ARGSUSED */
void
control_accept(int listenfd, short event, void *bula)
{
int connfd;
socklen_t len;
struct sockaddr_un sun;
struct ctl_conn *c;
event_add(&control_state.ev, NULL);
if ((event & EV_TIMEOUT))
return;
len = sizeof(sun);
if ((connfd = accept(listenfd,
(struct sockaddr *)&sun, &len)) == -1) {
/*
* Pause accept if we are out of file descriptors, or
* libevent will haunt us here too.
*/
if (errno == ENFILE || errno == EMFILE) {
struct timeval evtpause = { 1, 0 };
event_del(&control_state.ev);
evtimer_add(&control_state.evt, &evtpause);
} else if (errno != EWOULDBLOCK && errno != EINTR &&
errno != ECONNABORTED)
log_warn("control_accept: accept");
return;
}
session_socket_blockmode(connfd, BM_NONBLOCK);
if ((c = calloc(1, sizeof(struct ctl_conn))) == NULL) {
log_warn("control_accept");
close(connfd);
return;
}
imsg_init(&c->iev.ibuf, connfd);
c->iev.handler = control_dispatch_imsg;
c->iev.events = EV_READ;
event_set(&c->iev.ev, c->iev.ibuf.fd, c->iev.events,
c->iev.handler, &c->iev);
event_add(&c->iev.ev, NULL);
TAILQ_INSERT_TAIL(&ctl_conns, c, entry);
}
static void dns_cb(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
struct tmate_ssh_client *client;
struct evutil_addrinfo *ai;
struct timeval tv;
if (errcode) {
tmate_status_message("%s lookup failure. Retrying in %d seconds (%s)",
TMATE_HOST, TMATE_DNS_RETRY_TIMEOUT,
evutil_gai_strerror(errcode));
tv.tv_sec = TMATE_DNS_RETRY_TIMEOUT;
tv.tv_usec = 0;
evtimer_assign(&ev_dns_retry, ev_base, on_dns_retry, NULL);
evtimer_add(&ev_dns_retry, &tv);
return;
}
tmate_status_message("Connecting to %s...", TMATE_HOST);
for (ai = addr; ai; ai = ai->ai_next) {
char buf[128];
const char *ip = NULL;
if (ai->ai_family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, 128);
} else if (ai->ai_family == AF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, 128);
}
tmate_debug("Trying server %s", ip);
/*
* Note: We don't deal with the client list. Clients manage it
* and free client structs when necessary.
*/
(void)tmate_ssh_client_alloc(&tmate_session, ip);
}
evutil_freeaddrinfo(addr);
evdns_base_free(ev_dnsbase, 0);
ev_dnsbase = NULL;
}
static void
c_service_validity_timer(evutil_socket_t fd UNUSED, short event UNUSED,
void *arg)
{
mul_service_t *service = arg;
struct timeval tv = { 5, 0 };
if (service->conn.dead) return;
if (!mul_service_alive(service)) {
c_log_err("%s: service died", service->service_name);
return c_service_reconnect(service);
}
if (service->valid_timer_event)
evtimer_add(service->valid_timer_event, &tv);
}
void
HeartbeatEventSource::afterObservers( const int arg1, short int which )
{
struct timeval CLOCK_TV;
struct timeval NEW_TV;
struct timeval TIMER_TV = {1, 0};
//std::cout << "TimerEventSource::afterObservers" << std::endl;
// Get the current time.
if( gettimeofday( &CLOCK_TV, NULL ) )
{
perror("gettimeofday()");
event_loopbreak();
}
//printf( "timer cb: %d, %d\n", CLOCK_TV.tv_sec, CLOCK_TV.tv_usec );
// Calculate the time to the next 100ms boundary
NEW_TV.tv_usec = ( ( CLOCK_TV.tv_usec / 1000 ) * 1000 ) + 1000;
NEW_TV.tv_sec = CLOCK_TV.tv_sec;
while( NEW_TV.tv_usec >= 1000000 )
{
NEW_TV.tv_usec -= 1000000;
NEW_TV.tv_sec += 1;
}
//printf( "new time: %d, %d\n", NEW_TV.tv_sec, NEW_TV.tv_usec );
if( NEW_TV.tv_usec == 0 )
{
TIMER_TV.tv_sec = NEW_TV.tv_sec - CLOCK_TV.tv_sec - 1;
TIMER_TV.tv_usec = 1000000 - CLOCK_TV.tv_usec;
}
else
{
TIMER_TV.tv_sec = NEW_TV.tv_sec - CLOCK_TV.tv_sec;
TIMER_TV.tv_usec = NEW_TV.tv_usec - CLOCK_TV.tv_usec;
}
//printf( "new inc: %d, %d\n", TIMER_TV.tv_sec, TIMER_TV.tv_usec );
// Wake up again in a little bit.
evtimer_add( getEventPtr(), &TIMER_TV );
}
static enum command_state
update_trigger(void *arg, int *retval)
{
short *events = arg;
++deferred_update_notifications;
deferred_update_events |= *events;
// Only add the timer event if the update occurred outside a (init-/re-/fullre-) scan.
// The scanning functions take care of notifying clients of database changes directly
// after the scan finished.
if (!scanning)
evtimer_add(updateev, &library_update_wait);
*retval = 0;
return COMMAND_END;
}
/**
* @name c_app_reconn_timer
* @brief Timer which is invoked once main controller connection goes down
* and it retries till connection is restored
*/
static void
c_app_reconn_timer(evutil_socket_t fd UNUSED, short event UNUSED,
void *arg)
{
c_app_hdl_t *hdl = arg;
struct timeval tv = { 2, 0 };
if(!c_app_sock_init(hdl, server)) {
c_log_debug("Connection to controller restored");
event_del((struct event *)(hdl->reconn_timer_event));
event_free((struct event *)(hdl->reconn_timer_event));
c_app_notify_reconnect(hdl);
return;
}
evtimer_add(hdl->reconn_timer_event, &tv);
}
static void
slowdata_cb(evhtp_request_t * req, void * arg) {
/* Init our slow data vars */
slow_data_bytes = 0;
/* Start the reply */
evhtp_send_reply_chunk_start(req, EVHTP_RES_OK);
/* Create a timer for this request */
timer_event = evtimer_new(evbase, slowdata_timer_cb, req);
/* Set the timer and exit. */
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 500000;
evtimer_add(timer_event, &tv);
}
static void
timerCallback( int fd UNUSED,
short event UNUSED,
void * vtimer )
{
int more;
struct tr_timer * timer = vtimer;
timer->inCallback = 1;
more = ( *timer->func )( timer->user_data );
timer->inCallback = 0;
if( more )
evtimer_add( &timer->event, &timer->tv );
else
tr_timerFree( &timer );
}
static void
rrdtool_restart(int fd, short what, void *arg)
{
struct rrdtool_drv *drv = arg;
struct timeval tv;
/* Terminate the bugger */
if (drv->fd != -1) {
close(drv->fd);
drv->fd = -1;
}
if (drv->pid != 0) {
kill(drv->pid, SIGTERM);
drv->pid = 0;
}
/* If we respawn too quickly, we need to wait a little whilte */
gettimeofday(&tv, NULL);
timersub(&tv, &drv->tv_started, &tv);
if (tv.tv_sec < 5) {
syslog(LOG_NOTICE, "Respawing rrdtool too quickly");
tv.tv_sec = 5;
tv.tv_usec = 0;
evtimer_add(&drv->ev_timeout, &tv);
return;
}
/* Bad hack - we need to disable all events */
bufferevent_disable(drv->evb, EV_READ|EV_WRITE);
if (rrdtool_fork(drv) == -1) {
syslog(LOG_WARNING, "Terminating rrdtool driver.");
rrdtool_free(drv);
} else {
struct rrdtool_command *cmd = TAILQ_FIRST(&drv->commands);
/* This is yet another bad hack */
drv->evb->ev_read.ev_fd = drv->fd;
drv->evb->ev_write.ev_fd = drv->fd;
bufferevent_enable(drv->evb, EV_WRITE);
/* Restart the last command */
if (cmd != NULL)
rrdtool_write_command(drv, cmd->command);
}
}
static void create_base()
{
signal(SIGINT,sig_int);
// strTag->pid = getpid();
struct event_base *base = event_base_new();
struct timeval tv = {5,0};
struct event sig;
struct event timeout;
evtimer_assign(&timeout,base,timerout1,&timeout);
evtimer_add(&timeout,&tv);
evsignal_assign(&sig,base,SIGUSR2,sig_act1,&sig);
evsignal_add(&sig,NULL);
event_base_dispatch(base);
printf("child break loopbase!!\n");
event_base_free(base);
sleep(5);
}
void add_safe_evtimer(PgThread* pgThread, struct event *ev, struct timeval *tv)
{
int res;
struct timer_slot *ts;
Assert(pgMulThread != NULL);
res = evtimer_add(ev, tv);
if (res >= 0)
return;
if (pgThread->current_timer_backup_index >= MAX_TIMER_BACKUP_SLOT)
fatal_perror("TIMER_BACKUP_SLOTS full");
ts = &pgThread->timer_backup_list[pgThread->current_timer_backup_index++];
ts->ev = ev;
ts->tv = *tv;
}
// Process Spotify events in main event loop.
void sess_event_cb(evutil_socket_t sock, short event, void *arg)
{
(void)sock;
(void)event;
session_t *sess = arg;
int timeout = 0;
while (!timeout)
sp_session_process_events(sess->spotify, &timeout);
// Schedule next event.
struct timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
evtimer_add(sess->spot_ev, &tv);
}
static void
rspamd_map_schedule_periodic (struct rspamd_map *map,
gboolean locked, gboolean initial, gboolean errored)
{
const gdouble error_mult = 20.0, lock_mult = 0.1;
gdouble jittered_sec;
gdouble timeout;
struct map_periodic_cbdata *cbd;
timeout = map->poll_timeout;
if (initial) {
timeout = 0.0;
}
if (errored) {
timeout = map->poll_timeout * error_mult;
}
else if (locked) {
timeout = lock_mult;
}
cbd = g_slice_alloc0 (sizeof (*cbd));
cbd->cbdata.state = 0;
cbd->cbdata.prev_data = *map->user_data;
cbd->cbdata.cur_data = NULL;
cbd->cbdata.map = map;
cbd->map = map;
REF_INIT_RETAIN (cbd, rspamd_map_periodic_dtor);
if (initial) {
evtimer_set (&map->ev, rspamd_map_periodic_callback, cbd);
event_base_set (map->ev_base, &map->ev);
}
else {
evtimer_del (&map->ev);
evtimer_set (&map->ev, rspamd_map_periodic_callback, cbd);
event_base_set (map->ev_base, &map->ev);
}
jittered_sec = rspamd_time_jitter (timeout, 0);
msg_debug_map ("schedule new periodic event %p in %.2f seconds", cbd, jittered_sec);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
}
//------------------------------------------------
// Trigger event callback starts all transactions.
//
void
trigger_cb(int fd, short event, void* pv_udata)
{
int b = (int)(uint64_t)pv_udata;
// Continue the current transaction phase.
if (! (g_bases[b].trigger_phase == INSERT ?
put(b, g_bases[b].trigger_k) : get(b, g_bases[b].trigger_k))) {
// Will exit event loop if put/get call failed.
return;
}
// Advance the key index.
g_bases[b].trigger_k += g_config.num_bases;
// Check whether the current phase is done.
if (g_bases[b].trigger_k >= g_config.num_keys) {
if (g_bases[b].trigger_phase == INSERT) {
LOG("base %2d - done puts [%d timeouts]", b,
g_bases[b].num_put_timeouts);
// Done with the write phase on this base, start the read phase.
g_bases[b].trigger_phase = READ;
g_bases[b].trigger_k = b;
}
else {
LOG("base %2d - done gets [%d timeouts, %d not found]", b,
g_bases[b].num_get_timeouts, g_bases[b].num_not_found);
// Done with the read phase on this base - will exit event loop.
return;
}
}
// Re-add the trigger timer event. Its callback (this function) will start
// the next transaction, independent of when the current one is completed.
struct timeval trigger_timeval = { 0, g_config.trigger_usec };
if (evtimer_add(g_bases[b].p_trigger_event, &trigger_timeval) != 0) {
LOG("ERROR: adding timer on event base %d, to trigger key %d", b,
g_bases[b].trigger_k);
// Will exit event loop if timer add failed.
}
}
olibc_retval_t
olibc_msg_q_destroy (olibc_msg_q_hdl *msg_q_hdl)
{
olibc_retval_t retval;
olibc_msg_q_hdl msg_q;
struct event_base *evt_base = NULL;
if (!msg_q_hdl) {
return OLIBC_RETVAL_INVALID_INPUT;
}
msg_q = *msg_q_hdl;
if (msg_q->deleting) {
*msg_q_hdl = NULL;
return OLIBC_RETVAL_SUCCESS;
}
msg_q->deleting = TRUE;
if (msg_q->number_q_elements) {
struct timeval timeout;
if ((retval = olibc_pthread_get_event_base(msg_q->pthread_hdl,
&evt_base)) !=
OLIBC_RETVAL_SUCCESS) {
return retval;
}
olibc_memset(&timeout, 0, sizeof(struct timeval));
msg_q->timer_event_handle = event_new(evt_base, -1, EV_PERSIST,
olibc_msg_q_destroy_timer_cbk,
msg_q);
timeout.tv_sec = MSG_Q_DESTROY_TIME;
evtimer_add(msg_q->timer_event_handle, &timeout);
return OLIBC_RETVAL_SUCCESS;
}
olibc_msg_q_destroy_internal(msg_q);
*msg_q_hdl = NULL;
return OLIBC_RETVAL_SUCCESS;
}
static void
sync_timer_callback (gint fd, short what, void *ud)
{
struct rspamd_sync_ctx *ctx = ud;
guint32 jittered_interval;
/* Plan new event */
evtimer_del (&ctx->tm_ev);
/* Add some jittering for synchronization */
jittered_interval = g_random_int_range (ctx->sync_interval,
ctx->sync_interval * 2);
msec_to_tv (jittered_interval, &ctx->interval);
evtimer_add (&ctx->tm_ev, &ctx->interval);
log_next_sync (ctx->st->symbol, ctx->interval.tv_sec);
if (ctx->is_busy) {
/* Sync is in progress */
msg_info ("syncronization process is in progress, do not start new one");
return;
}
if ((ctx->sock =
make_universal_socket (ctx->st->binlog->master_addr,
ctx->st->binlog->master_port,
SOCK_STREAM, TRUE, FALSE, TRUE)) == -1) {
msg_info ("cannot connect to %s", ctx->st->binlog->master_addr);
return;
}
/* Now create and activate dispatcher */
msec_to_tv (ctx->timeout, &ctx->io_tv);
ctx->dispatcher = rspamd_create_dispatcher (ctx->ev_base,
ctx->sock,
BUFFER_LINE,
sync_read,
NULL,
sync_err,
&ctx->io_tv,
ctx);
ctx->state = SYNC_STATE_GREETING;
ctx->is_busy = TRUE;
msg_info ("starting synchronization of %s", ctx->st->symbol);
}
void
analyze_init(void)
{
struct timeval tv;
timerclear(&tv);
tv.tv_sec = ANALYZE_REPORT_INTERVAL;
struct event *ev_analyze = event_new(stats_libevent_base, -1, EV_PERSIST, analyze_report_cb, NULL);
evtimer_add(ev_analyze, &tv);
SPLAY_INIT(&oses);
SPLAY_INIT(&ports);
SPLAY_INIT(&spammers);
SPLAY_INIT(&countries);
SPLAY_INIT(&country_cache);
evdns_init();
}
static int
execute(struct worker_command *cmd)
{
struct timeval tv = { cmd->arg.delay, 0 };
if (cmd->arg.delay)
{
cmd->arg.timer = evtimer_new(evbase_worker, execute_cb, cmd);
evtimer_add(cmd->arg.timer, &tv);
return 1; // Not done yet, ask caller not to free cmd
}
cmd->arg.cb(cmd->arg.cb_arg);
free(cmd->arg.cb_arg);
return 0;
}
static void
process_stat_event(int fd, short ev, void *arg)
{
struct event *e = arg;
struct timeval tv;
process_stat(p_control);
process_stat(p_lka);
process_stat(p_parent);
process_stat(p_queue);
process_stat(p_scheduler);
process_stat(p_pony);
process_stat(p_ca);
tv.tv_sec = 1;
tv.tv_usec = 0;
evtimer_add(e, &tv);
}
static guint event_timeout_add (guint interval, GSourceFunc function, gpointer data) {
struct timeval timeout;
PurpleIOClosure *closure = g_new0(PurpleIOClosure, 1);
closure->function2 = function;
closure->data = data;
timeout.tv_sec = interval/1000;
timeout.tv_usec = (interval%1000)*1000;
evtimer_set(&closure->evfifo, event_io_invoke, closure);
evtimer_add(&closure->evfifo, &timeout);
closure->timeout = timeout;
guint *f = (guint *) g_malloc(sizeof(guint));
*f = id;
id++;
g_hash_table_replace(events, f, closure);
return *f;
}
static void
setup_notify_active(struct notify_zone_t* zone)
{
zone->notify_retry = 0;
zone->notify_current = zone->options->pattern->notify;
zone->notify_timeout.tv_sec = 0;
zone->notify_timeout.tv_usec = 0;
if(zone->notify_send_enable)
notify_send_disable(zone);
event_set(&zone->notify_send_handler, -1, EV_TIMEOUT,
xfrd_handle_notify_send, zone);
if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0)
log_msg(LOG_ERR, "notifysend: event_base_set failed");
if(evtimer_add(&zone->notify_send_handler, &zone->notify_timeout) != 0)
log_msg(LOG_ERR, "notifysend: evtimer_add failed");
zone->notify_send_enable = 1;
}
void hub_start_myinfo_updater(void)
{
static struct event ev;
evtimer_set(&ev, myinfo_updater, &ev);
struct timeval tv = {.tv_sec = 4, .tv_usec = 0};
evtimer_add(&ev, &tv);
}
static void hub_set_passive_GFunc(hub_t *hub, void *user_data)
{
return_if_fail(hub);
return_if_fail(hub->me);
bool *on = user_data;
return_if_fail(on);
hub->me->passive = *on;
}
int main(void)
{
event_init();
CClient *client = new CClient;
if( client->open( CONNECT_ADDR, CONNECT_PORT ) < 0 ){
return 0;
}
struct timeval t;
timerclear( &t );
struct event ev;
evtimer_set( &ev, oneshot_send, client );
evtimer_add( &ev, &t );
event_dispatch();
return 0;
}
