static void
leader_shutdown() {
LOG(0, ("Proposer %d dropping leadership\n", this_proposer_id));
evtimer_del(&p1_check_event);
evtimer_del(&p2_check_event);
#ifdef LEADER_EVENTS_UPDATE_INTERVAL
evtimer_del(&print_events_event);
#endif
//Iterate over currently open instances
p_inst_info * ii;
unsigned int i;
for(i = current_iid; i <= p1_info.highest_open; i++) {
ii = GET_PRO_INSTANCE(i);
if(ii->status != p2_completed && ii->p2_value != NULL) {
// A value was assigned to this instance, but it did
// not complete. Send back to the pending list for now
vh_push_back_value(ii->p2_value);
ii->p2_value = NULL;
}
//Clear all instances
pro_clear_instance_info(ii);
}
//This will clear all values in the pending list
// and notify the respective clients
vh_shutdown();
}
void delete_all_timers(hoststate_t* state) {
if (state->savedReqTimer != NULL) {
evtimer_del(state->savedReqTimer);
event_free(state->savedReqTimer);
state->savedReqTimer = NULL;
}
if (state->retrWaitTimer != NULL) {
evtimer_del(state->retrWaitTimer);
event_free(state->retrWaitTimer);
state->retrWaitTimer = NULL;
}
if (state->multiRespTimer != NULL) {
evtimer_del(state->multiRespTimer);
event_free(state->multiRespTimer);
state->multiRespTimer = NULL;
}
if (state->resetWaitTimer != NULL) {
evtimer_del(state->resetWaitTimer);
event_free(state->resetWaitTimer);
state->resetWaitTimer = NULL;
}
}
void
complete(int how, struct request *req)
{
struct timeval now, diff;
int i, total;
long milliseconds;
struct event *timeoutev;
evtimer_del(&req->timeoutev);
switch(how){
case Success:
gettimeofday(&now, nil);
timersub(&now, &req->starttv, &diff);
milliseconds = diff.tv_sec * 1000 + diff.tv_usec / 1000;
for(i=0; params.buckets[i]<milliseconds &&
params.buckets[i]!=0; i++);
counts.counters[i]++;
counts.successes++;
break;
case Error:
counts.errors++;
break;
case Timeout:
counts.timeouts++;
break;
}
total =
counts.successes + counts.errors +
counts.timeouts /*+ counts.closes*/;
/* enqueue the next one */
if(params.count<0 || total<params.count){
if(params.rpc<0 || params.rpc>req->evcon_reqno){
dispatch(req->evcon, req->evcon_reqno+1);
}else{
/* There seems to be a bug in libevent where the connection isn't really
* freed until the event loop is unwound. We'll add ourselves back with a
* 0-second timeout. */
evhttp_connection_free(req->evcon);
timeoutev = mal(sizeof(*timeoutev));
evtimer_set(timeoutev, dispatchcb, (void *)timeoutev);
evtimer_add(timeoutev, &zerotv);
}
}else{
/* We'll count this as a close. I guess that's ok. */
evhttp_connection_free(req->evcon);
if(--params.concurrency == 0){
evtimer_del(&reportev);
reportcb(0, 0, nil); /* issue a last report */
}
}
free(req);
}
void
complete(int how, struct request *req)
{
struct timeval now, diff;
int i, total;
long milliseconds;
evtimer_del(&req->timeoutev);
switch(how){
case Success:
gettimeofday(&now, nil);
timersub(&now, &req->starttv, &diff);
milliseconds = diff.tv_sec * 1000 + diff.tv_usec / 1000;
for(i=0; params.buckets[i]<milliseconds &&
params.buckets[i]!=0; i++);
counts.counters[i]++;
counts.successes++;
break;
case Error:
counts.errors++;
break;
case Timeout:
counts.timeouts++;
break;
}
total =
counts.successes + counts.errors +
counts.timeouts /*+ counts.closes*/;
/* enqueue the next one */
if(params.count<0 || total<params.count){
if(params.rpc<0 || params.rpc>req->evcon_reqno){
dispatch(req->evcon, req->evcon_reqno + 1);
}else{
evhttp_connection_free(req->evcon);
dispatch(mkhttp(), 1);
}
}else{
/* We'll count this as a close. I guess that's ok. */
evhttp_connection_free(req->evcon);
if(--params.concurrency == 0){
evtimer_del(&reportev);
reportcb(0, 0, nil); /* issue a last report */
}
}
free(req);
}
/* Free allocated memory and resources used */
void rmreq (req_t * r)
{
/* Delete all pending timers */
evtimer_del (& r -> ack_timer);
evtimer_del (& r -> resend_timer);
argsfree (r -> data);
argsfree (r -> data_org);
if (r -> id)
free (r -> id);
if (r)
free (r);
}
void delete_handler(int fd, short which, void *arg) {
struct timeval t;
evtimer_del(&deleteevent);
evtimer_set(&deleteevent, delete_handler, 0);
t.tv_sec = 5; t.tv_usec=0;
evtimer_add(&deleteevent, &t);
{
int i, j=0;
time_t now = time(0);
for (i=0; i<delcurr; i++) {
if (todelete[i]->exptime < now) {
/* no longer mark it deleted. it's now expired, same as dead */
todelete[i]->it_flags &= ~ITEM_DELETED;
todelete[i]->usecount--;
} else {
todelete[j++] = todelete[i];
}
}
delcurr = j;
}
return;
}
/** \brief Delete the external timer
*/
void timeout_t::external_stop() throw()
{
// sanity check - the external timer MUST be started
DBG_ASSERT( external_is_started() );
// use evtimer_del
evtimer_del(external_ctx);
}
static void
restart_timer( tr_web * g )
{
dbgmsg( "adding a timeout for %.1f seconds from now", g->timer_msec/1000.0 );
evtimer_del( &g->timer_event );
tr_timerAddMsec( &g->timer_event, g->timer_msec );
}
NwRcT nwTimerStop (
NwGtpv2cTimerMgrHandleT tmrMgrHandle,
NwGtpv2cTimerHandleT hTmr) {
evtimer_del (&(((NwGtpv2cNodeTmrT *) hTmr)->ev));
free ((void *)hTmr);
return NW_OK;
}
void f(const int fd, const short which, void *arg)
{
struct timeval t = {.tv_sec = 1, .tv_usec = 0};
static bool init = false;
if (init) {
evtimer_del(&e);
} else {
init = true;
}
evtimer_set(&e, f, NULL);
event_base_set(me, &e);
evtimer_add(&e, &t);
printf("xxx\n");
}
int main()
{
me = event_init();
f(0, 0, NULL);
event_base_loop(me, 0);
return 0;
}
static void
slowdata_timer_cb(evutil_socket_t fd, short event, void * arg) {
evhtp_request_t * req = (evhtp_request_t *)arg;
/* Write an additional 1 byte */
evbuf_t* buf = evbuffer_new();
evbuffer_add(buf, "0", 1);
evhtp_send_reply_chunk(req, buf);
evbuffer_drain(buf, -1);
++slow_data_bytes;
if (slow_data_bytes == 10) {
/* Reached our limit, close the reply */
evhtp_send_reply_chunk_end(req);
evtimer_del(timer_event);
} else {
/* Keep going */
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 500000;
evtimer_add(timer_event, &tv);
}
evbuffer_free(buf);
}
void event_callback(int _socket, short _kind, void* _connection_ptr)
{
const auto connection = static_cast<curl_handler::connection_context*>(_connection_ptr);
const auto handler = connection->curl_handler_;
const auto tv = curl_handler::make_timeval(connection->timeout_);
event_del(connection->timeout_event_);
event_add(connection->timeout_event_, &tv);
int action = 0;
if (_kind & EV_READ)
action |= CURL_CSELECT_IN;
if (_kind & EV_WRITE)
action |= CURL_CSELECT_OUT;
const auto error = curl_multi_socket_action(handler->multi_handle_, _socket, action, &handler->running_);
assert(!error);
(void*) error; // supress warning
check_multi_info(handler);
if (handler->running_ <= 0)
{
if (evtimer_pending(handler->timer_event_, NULL))
evtimer_del(handler->timer_event_);
}
}
//static
void on_commit(tr_id* id, int commit_result) {
tcp_client* c;
int rv = commit_result;
c = hashtable_search(clients, &id->client_id);
if (c == NULL) return;
c->write_count = 0;
// TODO checking the sequence number here is not sufficient.
// Suppose a timeout occurs, the sequence number remains unchanged until
// the next call to transaction commit...
if (id->seqnumber != c->t->id.seqnumber)
return;
if (commit_result == T_COMMITTED)
rv = transaction_remote_count(c->t);
#ifdef TRACE_MODE
write_to_trace_file(commit_result,id,NULL,NULL,0);
#endif
send_result(c->buffer_ev, rv);
evtimer_del(&c->timeout_ev);
transaction_clear(c->t);
}
/* reset timeout */
static void
l2tp_ctrl_reset_timeout(l2tp_ctrl *_this)
{
int intvl;
struct timeval tv0;
L2TP_CTRL_ASSERT(_this != NULL);
if (evtimer_initialized(&_this->ev_timeout))
evtimer_del(&_this->ev_timeout);
switch (_this->state) {
case L2TP_CTRL_STATE_CLEANUP_WAIT:
intvl = 1;
break;
default:
intvl = 2;
break;
}
tv0.tv_usec = 0;
tv0.tv_sec = intvl;
if (!evtimer_initialized(&_this->ev_timeout))
evtimer_set(&_this->ev_timeout, l2tp_ctrl_timeout, _this);
evtimer_add(&_this->ev_timeout, &tv0);
}
void
tty_close(struct tty *tty)
{
if (tty->log_fd != -1) {
close(tty->log_fd);
tty->log_fd = -1;
}
evtimer_del(&tty->key_timer);
tty_stop_tty(tty);
if (tty->flags & TTY_OPENED) {
bufferevent_free(tty->event);
tty_term_free(tty->term);
tty_keys_free(tty);
tty->flags &= ~TTY_OPENED;
}
if (tty->fd != -1) {
close(tty->fd);
tty->fd = -1;
}
}
static void
jitter_timeout_event (struct rspamd_map *map,
gboolean locked, gboolean initial, gboolean errored)
{
const gdouble error_mult = 20.0, lock_mult = 0.5;
gdouble jittered_sec;
gdouble timeout;
if (initial) {
timeout = 0.0;
}
else if (errored) {
timeout = map->cfg->map_timeout * error_mult;
}
else if (locked) {
timeout = map->cfg->map_timeout * lock_mult;
}
else {
timeout = map->cfg->map_timeout;
}
/* Plan event again with jitter */
evtimer_del (&map->ev);
jittered_sec = rspamd_time_jitter (timeout, 0);
double_to_tv (jittered_sec, &map->tv);
evtimer_add (&map->ev, &map->tv);
}
void
control_close(int fd, struct control_sock *cs)
{
struct ctl_conn *c;
if ((c = control_connbyfd(fd)) == NULL) {
log_warn("control_close: fd %d: not found", fd);
return;
}
msgbuf_clear(&c->iev.ibuf.w);
TAILQ_REMOVE(&ctl_conns, c, entry);
event_del(&c->iev.ev);
close(c->iev.ibuf.fd);
/* Some file descriptors are available again. */
if (evtimer_pending(&cs->cs_evt, NULL)) {
evtimer_del(&cs->cs_evt);
event_add(&cs->cs_ev, NULL);
}
npppd_ctl_destroy(c->ctx);
free(c);
}
void hub_set_idle_timeout(hub_t *hub)
{
if(event_initialized(&hub->idle_timeout_event))
{
evtimer_del(&hub->idle_timeout_event);
}
else
{
evtimer_set(&hub->idle_timeout_event, hub_send_keep_alive, hub);
}
struct timeval tv = {.tv_sec = 300, .tv_usec = 0};
evtimer_add(&hub->idle_timeout_event, &tv);
}
static char *hub_make_tag(hub_t *hub)
{
char *tag = 0;
int num_returned_bytes = asprintf(&tag, "<%s V:%s,M:%c,H:%d/%d/%d,S:%d>",
global_id_tag,
global_id_version,
hub->me->passive ? 'P' : 'A',
hub_count_normal(), hub_count_registered(), hub_count_operator(),
hub_slots_total());
if (num_returned_bytes == -1)
DEBUG("asprintf did not return anything");
return tag;
}
void
control_close(struct ctl_conn *c, const char *msg, struct imsg *imsg)
{
struct control_sock *cs = c->cs;
if (imsg) {
log_debug("%s: fd %d: %s, imsg %d datalen %zu", __func__,
c->iev.ibuf.fd, msg, imsg->hdr.type, IMSG_DATA_SIZE(imsg));
imsg_free(imsg);
} else
log_debug("%s: fd %d: %s", __func__, c->iev.ibuf.fd, msg);
msgbuf_clear(&c->iev.ibuf.w);
TAILQ_REMOVE(&ctl_conns, c, entry);
event_del(&c->iev.ev);
close(c->iev.ibuf.fd);
/* Some file descriptors are available again. */
if (evtimer_pending(&cs->cs_evt, NULL)) {
evtimer_del(&cs->cs_evt);
event_add(&cs->cs_ev, NULL);
}
free(c);
}
void
cert_updater_stop(ProxyContext * const proxy_context)
{
CertUpdater * const cert_updater = &proxy_context->cert_updater;
assert(cert_updater->cert_timer != NULL);
evtimer_del(cert_updater->cert_timer);
}
void terminate(void) {
evtimer_del(&sspPollEvent);
if(db) {
redisAsyncCommand(db, NULL, NULL, "SET component:ssp 0");
redisAsyncDisconnect(db);
db = NULL;
}
}
void
timer::unset_timer(callback *func)
{
if (m_events.find(func) != m_events.end()) {
evtimer_del(m_events[func].get());
m_events.erase(func);
}
}
static void set_reconnect_timer()
{
struct timeval tv = { 5, 0 };
evtimer_del(&reconnect_ev);
evtimer_set(&reconnect_ev, connect, NULL);
evtimer_add(&reconnect_ev, &tv);
}
NwRcT nwTimerStop( NwGtpv2cTimerMgrHandleT tmrMgrHandle,
NwGtpv2cTimerHandleT hTmr)
{
NW_LOG(NW_LOG_LEVEL_DEBG, "Received stop timer request from stack for timer handle %u", hTmr);
evtimer_del(&(((NwGtpv2cNodeTmrT*)hTmr)->ev));
free((void*)hTmr);
return NW_OK;
}
static void
stop_timer( tr_web* g )
{
if( evtimer_pending( &g->timer_event, NULL ) )
{
dbgmsg( "deleting the pending global timer" );
evtimer_del( &g->timer_event );
}
}
timer::~timer()
{
boost::unordered_map<callback*,
boost::shared_ptr<event> >::iterator it;
for (it = m_events.begin(); it != m_events.end(); ++it) {
evtimer_del(it->second.get());
}
}
void
stop_db_tx_timer(struct nbr *nbr)
{
if (nbr == nbr->iface->self)
return;
if (evtimer_del(&nbr->db_tx_timer) == -1)
fatal("stop_db_tx_timer");
}
static void maxconns_handler(const int fd, const short which, void *arg) {
struct timeval t = {.tv_sec = 0, .tv_usec = 10000};
if (fd == -42 || allow_new_conns == false) {
/* reschedule in 10ms if we need to keep polling */
evtimer_set(&maxconnsevent, maxconns_handler, 0);
event_base_set(main_base, &maxconnsevent);
evtimer_add(&maxconnsevent, &t);
} else {
evtimer_del(&maxconnsevent);
accept_new_conns(true);
}
}
static bool update_event(conn *c, const int new_flags) {
assert(c != NULL);
if (c->ev_flags == new_flags)
return true;
pthread_t tid = pthread_self();
if (tid == dispatcher_thread.thread_id)
{
struct event_base *base = c->event.ev_base;
if (event_del(&c->event) == -1) return false;
event_set(&c->event, c->sfd, new_flags, master_event_handler, (void *)c);
event_base_set(base, &c->event);
c->ev_flags = new_flags;
if (event_add(&c->event, 0) == -1) return false;
return true;
}else{
struct event_base *base = bufferevent_get_base(c->buf_ev);
bufferevent_free(c->buf_ev);
c->buf_ev = bufferevent_new(c->sfd, event_handler, buf_write_callback, buf_error_callback, (void * )c);
bufferevent_base_set(base, c->buf_ev);
c->ev_flags = new_flags;
if (bufferevent_enable(c->buf_ev, new_flags) == -1) return false;
return true;
}
//这个也得改成bufferevent的形式
/*
event_set(&c->event, c->sfd, new_flags, event_handler, (void *)c);
event_base_set(base, &c->event);
event_add(&c->event, 0);
c->buf_ev = bufferevent_new(c->sfd, event_handler, event_handler, NULL, (void * )c);
bufferevent_base_set(base, c->buf_ev);
bufferevent_enable(c->buf_ev, new_flags);
c->ev_flags = new_flags;
if (event_add(&c->event, 0) == -1) return false;
return true;
*/
}
void wait_server_backoff(unsigned int timeout /* seconds */,
jsonrpc_server_t* server, bool delay)
{
if(!server) {
ERR("Trying to close/reconnect a NULL server\n");
return;
}
if(delay == false) {
if (requests_using_server(server) <= 0) {
if(server->status == JSONRPC_SERVER_RECONNECTING) {
bev_connect(server);
} else if(server->status == JSONRPC_SERVER_CLOSING) {
close_server(server);
}
return;
}
}
const struct timeval tv = {timeout, 0};
server_backoff_args_t* args = pkg_malloc(sizeof(server_backoff_args_t));
CHECK_MALLOC_VOID(args);
memset(args, 0, sizeof(server_backoff_args_t));
args->ev = evtimer_new(global_ev_base, server_backoff_cb, (void*)args);
CHECK_MALLOC_GOTO(args->ev, error);
args->server = server;
args->timeout = timeout;
if(evtimer_add(args->ev, &tv)<0) {
ERR("event_add failed while setting request timer (%s).", strerror(errno));
goto error;
}
return;
error:
ERR("schedule_server failed.\n");
if(args) {
if(args->ev) {
evtimer_del(args->ev);
}
pkg_free(args);
}
if (server->status == JSONRPC_SERVER_CLOSING) {
ERR("Closing server now...\n");
close_server(server);
} else if (server->status == JSONRPC_SERVER_RECONNECTING) {
ERR("Reconnecting server now...\n");
force_reconnect(server);
}
}
static void
stop_timer( tr_shared * s )
{
if( s->timer != NULL )
{
evtimer_del( s->timer );
tr_free( s->timer );
s->timer = NULL;
}
}
