result_t net_base::backend(std::string &retVal)
{
switch (ev_backend(s_loop))
{
case EVBACKEND_SELECT:
retVal = "Select";
break;
case EVBACKEND_POLL:
retVal = "Poll";
break;
case EVBACKEND_EPOLL:
retVal = "EPoll";
break;
case EVBACKEND_KQUEUE:
retVal = "KQueue";
break;
case EVBACKEND_DEVPOLL:
retVal = "DevPoll";
break;
case EVBACKEND_PORT:
retVal = "Port";
break;
}
return 0;
}
/** get the event system in use */
static void get_event_sys(const char** n, const char** s, const char** m)
{
#ifdef USE_WINSOCK
*n = "event";
*s = "winsock";
*m = "WSAWaitForMultipleEvents";
#elif defined(USE_MINI_EVENT)
*n = "mini-event";
*s = "internal";
*m = "select";
#else
struct event_base* b;
*s = event_get_version();
# ifdef HAVE_EVENT_BASE_GET_METHOD
*n = "libevent";
b = event_base_new();
*m = event_base_get_method(b);
# elif defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
*n = "libev";
b = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
*m = ev_backend2str(ev_backend((struct ev_loop*)b));
# else
*n = "unknown";
*m = "not obtainable";
b = NULL;
# endif
# ifdef HAVE_EVENT_BASE_FREE
event_base_free(b);
# endif
#endif
}
LWS_VISIBLE int
lws_initloop(
struct lws_context *context,
struct ev_loop *loop)
{
int status = 0;
int backend;
const char * backend_name;
struct ev_io *w_accept = &context->w_accept.watcher;
struct ev_signal *w_sigint = &context->w_sigint.watcher;
if (!loop)
loop = ev_default_loop(0);
context->io_loop = loop;
/*
* Initialize the accept w_accept with the listening socket
* and register a callback for read operations:
*/
ev_io_init(w_accept, lws_accept_cb,
context->lserv_fd, EV_READ);
ev_io_start(context->io_loop,w_accept);
/* Register the signal watcher unless the user has indicated otherwise: */
if( context->use_ev_sigint ) {
ev_signal_init(w_sigint, context->lws_ev_sigint_cb, SIGINT);
ev_signal_start(context->io_loop,w_sigint);
};
backend = ev_backend(loop);
switch (backend) {
case EVBACKEND_SELECT:
backend_name = "select";
break;
case EVBACKEND_POLL:
backend_name = "poll";
break;
case EVBACKEND_EPOLL:
backend_name = "epoll";
break;
case EVBACKEND_KQUEUE:
backend_name = "kqueue";
break;
case EVBACKEND_DEVPOLL:
backend_name = "/dev/poll";
break;
case EVBACKEND_PORT:
backend_name = "Solaris 10 \"port\"";
break;
default:
backend_name = "Unknown libev backend";
break;
};
lwsl_notice(" libev backend: %s\n", backend_name);
return status;
}
const char* li_event_loop_backend_string(liEventLoop *loop) {
switch (ev_backend(loop->loop)) {
case EVBACKEND_SELECT: return "select";
case EVBACKEND_POLL: return "poll";
case EVBACKEND_EPOLL: return "epoll";
case EVBACKEND_KQUEUE: return "kqueue";
case EVBACKEND_DEVPOLL: return "devpoll";
case EVBACKEND_PORT: return "port";
default: return "unknown";
}
}
/**
* Returns one of the EventLoop::BACKEND_* flags indicating the event backend in use.
*
* @return int
* @return false if object is not initialized
*/
PHP_METHOD(EventLoop, getBackend)
{
event_loop_object *obj = (event_loop_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
assert(obj->loop);
if(obj->loop)
{
RETURN_LONG(ev_backend(obj->loop));
}
RETURN_BOOL(0);
}
/*
Procedure exposed in Python will generate and start the event loop
*/
static PyObject *py_run_loop(PyObject *self, PyObject *args)
{
char *backend="";
int i;
ev_io accept_watcher;
ev_signal signal_watcher, signal_watcher2, signal_watcher3;
struct TimerObj *timer;
loop = ev_default_loop (0);
switch (ev_backend(loop))
{
case 1:
backend="select";
break;
case 2:
backend="poll";
break;
case 4:
backend="epoll";
break;
case 8:
backend="kqueue";
break;
}
printf("Using %s as event backend\n", backend);
ev_io_init(&accept_watcher,accept_cb,sockfd,EV_READ);
ev_io_start(loop,&accept_watcher);
ev_signal_init(&signal_watcher, sigint_cb, SIGINT);
ev_signal_start(loop, &signal_watcher);
ev_signal_init(&signal_watcher2, sigpipe_cb, SIGPIPE);
ev_signal_start(loop, &signal_watcher2);
ev_signal_init(&signal_watcher3, sigterm_cb, SIGTERM);
ev_signal_start(loop, &signal_watcher3);
idle_watcher = malloc(sizeof(ev_idle));
ev_idle_init(idle_watcher, idle_cb);
if (list_timers_i>=0)
{
for (i=0; i<list_timers_i; i++)
{
timer=list_timers[i];
ev_timer_init(&timer->timerwatcher, timer_cb, timer->delay, timer->delay);
ev_timer_start(loop, &timer->timerwatcher);
}
}
ev_loop (loop, 0);
return Py_None;
}
void
ub_get_event_sys(struct ub_event_base* base, const char** n, const char** s,
const char** m)
{
#ifdef USE_WINSOCK
(void)base;
*n = "event";
*s = "winsock";
*m = "WSAWaitForMultipleEvents";
#elif defined(USE_MINI_EVENT)
(void)base;
*n = "mini-event";
*s = "internal";
*m = "select";
#else
struct event_base* b = AS_EVENT_BASE(base);
*s = event_get_version();
# if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)
*n = "libev";
if (!b)
b = (struct event_base*)ev_default_loop(EVFLAG_AUTO);
# ifdef EVBACKEND_SELECT
*m = ub_ev_backend2str(ev_backend((struct ev_loop*)b));
# else
*m = "not obtainable";
# endif
# elif defined(HAVE_EVENT_BASE_GET_METHOD)
*n = "libevent";
if (!b)
b = event_base_new();
*m = event_base_get_method(b);
# else
*n = "unknown";
*m = "not obtainable";
(void)b;
# endif
# ifdef HAVE_EVENT_BASE_FREE
if (b && b != AS_EVENT_BASE(base))
event_base_free(b);
# endif
#endif
}
static VALUE NIO_Selector_backend(VALUE self) {
struct NIO_Selector *selector;
Data_Get_Struct(self, struct NIO_Selector, selector);
if(selector->closed) {
rb_raise(rb_eIOError, "selector is closed");
}
switch (ev_backend(selector->ev_loop)) {
case EVBACKEND_EPOLL:
return ID2SYM(rb_intern("epoll"));
case EVBACKEND_POLL:
return ID2SYM(rb_intern("poll"));
case EVBACKEND_KQUEUE:
return ID2SYM(rb_intern("kqueue"));
case EVBACKEND_SELECT:
return ID2SYM(rb_intern("select"));
case EVBACKEND_PORT:
return ID2SYM(rb_intern("port"));
}
return ID2SYM(rb_intern("unknown"));
}
static PyObject *
Loop_backend_get(Loop *self, void *closure)
{
return PyInt_FromUnsignedLong(ev_backend(self->loop));
}
