示例#1
0
/** closes out-fd */
void li_error_pipe_activate(liErrorPipe *epipe) {
    if (-1 != epipe->fds[1]) {
        close(epipe->fds[1]);
        epipe->fds[1] = -1;
    }
    li_event_start(&epipe->fd_watcher);
}
示例#2
0
void li_event_check_init(liEventLoop *loop, liEventCheck *check, liEventCallback callback) {
	memset(check, 0, sizeof(*check));
	check->base.type = LI_EVT_CHECK;
	check->base.keep_loop_alive = 0;
	check->base.callback = callback;
	ev_init(&check->libevmess.w, NULL);
	ev_set_cb(&check->libevmess.check, event_check_cb);

	if (NULL != loop) li_event_attach(loop, check);
	li_event_start(check);
}
示例#3
0
void li_event_prepare_init(liEventLoop *loop, liEventPrepare *prepare, liEventCallback callback) {
	memset(prepare, 0, sizeof(*prepare));
	prepare->base.type = LI_EVT_PREPARE;
	prepare->base.keep_loop_alive = 0;
	prepare->base.callback = callback;
	ev_init(&prepare->libevmess.w, NULL);
	ev_set_cb(&prepare->libevmess.prepare, event_prepare_cb);

	if (NULL != loop) li_event_attach(loop, prepare);
	li_event_start(prepare);
}
示例#4
0
void li_event_async_init(liEventLoop *loop, liEventAsync *async, liEventCallback callback) {
	memset(async, 0, sizeof(*async));
	async->base.type = LI_EVT_ASYNC;
	async->base.keep_loop_alive = 0;
	async->base.callback = callback;
	ev_init(&async->libevmess.w, NULL);
	ev_set_cb(&async->libevmess.async, event_async_cb);

	if (NULL != loop) li_event_attach(loop, async);
	li_event_start(async);
}
示例#5
0
void li_event_signal_init(liEventLoop *loop, liEventSignal *sig, liEventCallback callback, int signum) {
	memset(sig, 0, sizeof(*sig));
	sig->base.type = LI_EVT_SIGNAL;
	sig->base.keep_loop_alive = 0;
	sig->base.callback = callback;
	ev_init(&sig->libevmess.w, NULL);
	ev_signal_set(&sig->libevmess.sig, signum);
	ev_set_cb(&sig->libevmess.sig, event_signal_cb);

	if (NULL != loop) li_event_attach(loop, sig);
	li_event_start(sig);
}
示例#6
0
void li_event_child_init(liEventLoop *loop, liEventChild *child, liEventCallback callback, int pid) {
	memset(child, 0, sizeof(*child));
	child->base.type = LI_EVT_CHILD;
	child->base.keep_loop_alive = 1;
	child->base.callback = callback;
	ev_init(&child->libevmess.w, NULL);
	ev_child_set(&child->libevmess.child, pid, 0);
	ev_set_cb(&child->libevmess.child, event_child_cb);

	if (NULL != loop) li_event_attach(loop, child);
	li_event_start(child);
}
示例#7
0
static void memcached_start_io(liMemcachedCon *con) {
	if (!li_event_active(&con->con_watcher)) {
		li_memcached_con_acquire(con);
		li_event_start(&con->con_watcher);
	}
}