nutcracker 0.2.4.mac9 → 0.2.4.1

data/ext/nutcracker/src/nc_conf.h

@@ -120,7 +120,7 @@ char *conf_set_string(struct conf *cf, struct command *cmd, void *conf);
 char *conf_set_listen(struct conf *cf, struct command *cmd, void *conf);
 char *conf_add_server(struct conf *cf, struct command *cmd, void *conf);
 char *conf_set_num(struct conf *cf, struct command *cmd, void *conf);
-char *conf_set_bool(struct conf *cf, struct command *cmd, void *conf);
+char * conf_set_bool(struct conf *cf, struct command *cmd, void *conf);
 char *conf_set_hash(struct conf *cf, struct command *cmd, void *conf);
 char *conf_set_distribution(struct conf *cf, struct command *cmd, void *conf);
 char *conf_set_hashtag(struct conf *cf, struct command *cmd, void *conf);

data/ext/nutcracker/src/nc_core.c

@@ -17,6 +17,9 @@
 
 #include <stdlib.h>
 #include <unistd.h>
+
+#include <sys/epoll.h>
+
 #include <nc_core.h>
 #include <nc_event.h>
 #include <nc_conf.h>
@@ -25,10 +28,6 @@
 
 static uint32_t ctx_id; /* context generation */
 
-/* function prototype for use in core_ctx_create() */
-static void
-core_core(void *arg, uint32_t evflags);
-
 static struct context *
 core_ctx_create(struct instance *nci)
 {
@@ -42,10 +41,12 @@ core_ctx_create(struct instance *nci)
     ctx->id = ++ctx_id;
     ctx->cf = NULL;
     ctx->stats = NULL;
-    ctx->evb = NULL;
     array_null(&ctx->pool);
+    ctx->ep = -1;
+    ctx->nevent = EVENT_SIZE_HINT;
     ctx->max_timeout = nci->stats_interval;
     ctx->timeout = ctx->max_timeout;
+    ctx->event = NULL;
 
     /* parse and create configuration */
     ctx->cf = conf_create(nci->conf_filename);
@@ -73,8 +74,8 @@ core_ctx_create(struct instance *nci)
     }
 
     /* initialize event handling for client, proxy and server */
-    ctx->evb = evbase_create(NC_EVENT_SIZE, &core_core);
-    if (ctx->evb == NULL) {
+    status = event_init(ctx, EVENT_SIZE_HINT);
+    if (status != NC_OK) {
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -86,7 +87,7 @@ core_ctx_create(struct instance *nci)
     status = server_pool_preconnect(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        evbase_destroy(ctx->evb);
+        event_deinit(ctx);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -98,7 +99,7 @@ core_ctx_create(struct instance *nci)
     status = proxy_init(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        evbase_destroy(ctx->evb);
+        event_deinit(ctx);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -117,7 +118,7 @@ core_ctx_destroy(struct context *ctx)
     log_debug(LOG_VVERB, "destroy ctx %p id %"PRIu32"", ctx, ctx->id);
     proxy_deinit(ctx);
     server_pool_disconnect(ctx);
-    evbase_destroy(ctx->evb);
+    event_deinit(ctx);
     stats_destroy(ctx->stats);
     server_pool_deinit(&ctx->pool);
     conf_destroy(ctx->cf);
@@ -205,9 +206,9 @@ core_close(struct context *ctx, struct conn *conn)
               conn->eof, conn->done, conn->recv_bytes, conn->send_bytes,
               conn->err ? ':' : ' ', conn->err ? strerror(conn->err) : "");
 
-    status = event_del_conn(ctx->evb, conn);
+    status = event_del_conn(ctx->ep, conn);
     if (status < 0) {
-        log_warn("event del conn %c %d failed, ignored: %s",
+        log_warn("event del conn e %d %c %d failed, ignored: %s", ctx->ep,
                  type, conn->sd, strerror(errno));
     }
 
@@ -276,33 +277,23 @@ core_timeout(struct context *ctx)
 }
 
 static void
-core_core(void *arg, uint32_t evflags)
+core_core(struct context *ctx, struct conn *conn, uint32_t events)
 {
     rstatus_t status;
-    struct conn *conn = (struct conn *) arg;
-    struct context *ctx;
 
-    
-
-    if ((conn->proxy) || (conn->client)) {
-        ctx = ((struct server_pool *) (conn -> owner)) -> ctx;
-    } else { 
-        ctx = ((struct server_pool *) (((struct server *) (conn -> owner)) -> owner )) -> ctx;
-    }
-
-    log_debug(LOG_VVERB, "event %04"PRIX32" on %c %d", evflags,
+    log_debug(LOG_VVERB, "event %04"PRIX32" on %c %d", events,
               conn->client ? 'c' : (conn->proxy ? 'p' : 's'), conn->sd);
 
-    conn->events = evflags;
+    conn->events = events;
 
     /* error takes precedence over read | write */
-    if (evflags & EV_ERR) {
+    if (events & EPOLLERR) {
         core_error(ctx, conn);
         return;
     }
 
     /* read takes precedence over write */
-    if (evflags & EV_READ) {
+    if (events & (EPOLLIN | EPOLLHUP)) {
         status = core_recv(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
@@ -310,7 +301,7 @@ core_core(void *arg, uint32_t evflags)
         }
     }
 
-    if (evflags & EV_WRITE) {
+    if (events & EPOLLOUT) {
         status = core_send(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
@@ -324,11 +315,17 @@ core_loop(struct context *ctx)
 {
     int i, nsd;
 
-    nsd = event_wait(ctx->evb, ctx->timeout);
+    nsd = event_wait(ctx->ep, ctx->event, ctx->nevent, ctx->timeout);
     if (nsd < 0) {
         return nsd;
     }
 
+    for (i = 0; i < nsd; i++) {
+        struct epoll_event *ev = &ctx->event[i];
+
+        core_core(ctx, ev->data.ptr, ev->events);
+    }
+
     core_timeout(ctx);
 
     stats_swap(ctx->stats);

data/ext/nutcracker/src/nc_core.h

@@ -40,20 +40,10 @@
 # define NC_STATS 0
 #endif
 
-#ifdef HAVE_EPOLL
-#define NC_HAVE_EPOLL 1
-#elif HAVE_KQUEUE
-#define NC_HAVE_KQUEUE 1
-#endif
-
 #ifdef HAVE_LITTLE_ENDIAN
 # define NC_LITTLE_ENDIAN 1
 #endif
 
-#ifdef HAVE_BACKTRACE
-#define NC_HAVE_BACKTRACE 1
-#endif
-
 #define NC_OK        0
 #define NC_ERROR    -1
 #define NC_EAGAIN   -2
@@ -111,12 +101,14 @@ struct context {
     struct stats       *stats;      /* stats */
 
     struct array       pool;        /* server_pool[] */
-    struct evbase      *evb;
+
+    int                ep;          /* epoll device */
+    int                nevent;      /* # epoll event */
     int                max_timeout; /* epoll wait max timeout in msec */
-    int                timeout;
+    int                timeout;     /* epoll wait timeout in msec */
+    struct epoll_event *event;      /* epoll event */
 };
 
-
 struct instance {
     struct context  *ctx;                        /* active context */
     int             log_level;                   /* log level */

data/ext/nutcracker/src/{nc_epoll.c → nc_event.c}

@@ -16,86 +16,66 @@
  */
 
 #include <unistd.h>
+#include <sys/epoll.h>
+
 #include <nc_core.h>
 #include <nc_event.h>
 
-#ifdef NC_HAVE_EPOLL
-#include <sys/epoll.h>
-
-struct evbase * 
-evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
+int
+event_init(struct context *ctx, int size)
 {
-
-    struct evbase *evb;
     int status, ep;
     struct epoll_event *event;
 
-    if (nevent <= 0) {
-        log_error("nevent has to be positive %d", nevent);
-        return NULL;
-    }
+    ASSERT(ctx->ep < 0);
+    ASSERT(ctx->nevent != 0);
+    ASSERT(ctx->event == NULL);
 
-    ep = epoll_create(nevent);
+    ep = epoll_create(size);
     if (ep < 0) {
-        log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
-        return NULL;
+        log_error("epoll create of size %d failed: %s", size, strerror(errno));
+        return -1;
     }
 
-    event = nc_calloc(nevent, sizeof(*event));
+    event = nc_calloc(ctx->nevent, sizeof(*ctx->event));
     if (event == NULL) {
         status = close(ep);
         if (status < 0) {
             log_error("close e %d failed, ignored: %s", ep, strerror(errno));
         }
-        return NULL;
-    }
-
-    evb = nc_alloc(sizeof(*evb));
-    if (evb == NULL) {
-        nc_free(event);
-        status = close(ep);
-        if (status < 0) {
-            log_error("close e %d failed, ignored: %s", ep, strerror(errno));
-        }
-        return NULL;
-
+        return -1;
     }
 
-    evb->nevent = nevent;
-    evb->ep = ep;
-    evb->event = event;
-    evb->callback_fp = callback_fp;
+    ctx->ep = ep;
+    ctx->event = event;
 
-    log_debug(LOG_INFO, "e %d with nevent %d", evb->ep,
-              evb->nevent);
+    log_debug(LOG_INFO, "e %d with nevent %d timeout %d", ctx->ep,
+              ctx->nevent, ctx->timeout);
 
-    return evb;
+    return 0;
 }
 
 void
-evbase_destroy(struct evbase *evb)
+event_deinit(struct context *ctx)
 {
     int status;
 
-    if (evb == NULL) return;
+    ASSERT(ctx->ep >= 0);
 
-    ASSERT(evb->ep >= 0);
+    nc_free(ctx->event);
 
-    nc_free(evb->event);
-
-    status = close(evb->ep);
+    status = close(ctx->ep);
     if (status < 0) {
-        log_error("close e %d failed, ignored: %s", evb->ep, strerror(errno));
+        log_error("close e %d failed, ignored: %s", ctx->ep, strerror(errno));
     }
-    nc_free(evb);
+    ctx->ep = -1;
 }
 
 int
-event_add_out(struct evbase *evb, struct conn *c)
+event_add_out(int ep, struct conn *c)
 {
     int status;
     struct epoll_event event;
-    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -121,11 +101,10 @@ event_add_out(struct evbase *evb, struct conn *c)
 }
 
 int
-event_del_out(struct evbase *evb, struct conn *c)
+event_del_out(int ep, struct conn *c)
 {
     int status;
     struct epoll_event event;
-    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -151,11 +130,10 @@ event_del_out(struct evbase *evb, struct conn *c)
 }
 
 int
-event_add_conn(struct evbase *evb, struct conn *c)
+event_add_conn(int ep, struct conn *c)
 {
     int status;
     struct epoll_event event;
-    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -177,10 +155,9 @@ event_add_conn(struct evbase *evb, struct conn *c)
 }
 
 int
-event_del_conn(struct evbase *evb, struct conn *c)
+event_del_conn(int ep, struct conn *c)
 {
     int status;
-    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -199,14 +176,9 @@ event_del_conn(struct evbase *evb, struct conn *c)
 }
 
 int
-event_wait(struct evbase *evb, int timeout)
+event_wait(int ep, struct epoll_event *event, int nevent, int timeout)
 {
-    int nsd, i;
-    uint32_t evflags = 0;
-    int ep = evb->ep;
-    struct epoll_event *event = evb->event;
-    int nevent = evb->nevent;
-    void (*callback_fp)(void *, uint32_t) = evb->callback_fp;
+    int nsd;
 
     ASSERT(ep > 0);
     ASSERT(event != NULL);
@@ -215,22 +187,6 @@ event_wait(struct evbase *evb, int timeout)
     for (;;) {
         nsd = epoll_wait(ep, event, nevent, timeout);
         if (nsd > 0) {
-            for (i = 0; i < nsd; i++) {
-                struct epoll_event *ev = &evb->event[i];
-
-                evflags = 0;
-                if (ev->events & EPOLLERR)
-                    evflags |= EV_ERR;
-
-                if (ev->events & EPOLLIN)
-                    evflags |= EV_READ;
-
-                if (ev->events & EPOLLOUT)
-                    evflags |= EV_WRITE;
-
-                if (callback_fp != NULL)
-                    (*callback_fp)((void *) ev->data.ptr, evflags);
-            }
             return nsd;
         }
 
@@ -253,26 +209,6 @@ event_wait(struct evbase *evb, int timeout)
 
         return -1;
     }
-    NOT_REACHED();
-}
 
-int
-event_add_st(struct evbase *evb, int fd)
-{
-    int status;
-    struct epoll_event ev;
-
-    ev.data.fd = fd;
-    ev.events = EPOLLIN;
-
-    status = epoll_ctl(evb->ep, EPOLL_CTL_ADD, fd, &ev);
-    if (status < 0) {
-        log_error("epoll ctl on e %d sd %d failed: %s", evb->ep, fd,
-                  strerror(errno));
-        return status;
-    }
-    
-    return status;
+    NOT_REACHED();
 }
-
-#endif /* NC_HAVE_EPOLL */

data/ext/nutcracker/src/nc_event.h

@@ -20,40 +20,20 @@
 
 #include <nc_core.h>
 
-#define NC_EVENT_SIZE 1024
-#define EV_READ 0xff
-#define EV_WRITE 0xff00
-#define EV_ERR 0xff0000
+/*
+ * A hint to the kernel that is used to size the event backing store
+ * of a given epoll instance
+ */
+#define EVENT_SIZE_HINT 1024
 
-#ifdef NC_HAVE_KQUEUE
-struct evbase {
-    int                  kq;
-    struct kevent        *changes;   /* list of changes to be made */
-    struct kevent        *kevents;   /* list of events returned from kevent */
-    int                  n_changes;  /* number of changes in our list */
-    int                  n_returned; /* number of events returned from kevent */
-    int                  n_processed;
-    int                  nevent;
-    void (*callback_fp)(void *, uint32_t);
-};
-#endif
-#ifdef NC_HAVE_EPOLL
-struct evbase {
-    int                   ep;
-    int                   nevent;
-    struct epoll_event    *event;
-    void (*callback_fp)(void *, uint32_t);
-};
-#endif
+int event_init(struct context *ctx, int size);
+void event_deinit(struct context *ctx);
 
-struct evbase *evbase_create(int size, void (*callback_fp)(void *, uint32_t));
-void evbase_destroy(struct evbase *evb);
+int event_add_out(int ep, struct conn *c);
+int event_del_out(int ep, struct conn *c);
+int event_add_conn(int ep, struct conn *c);
+int event_del_conn(int ep, struct conn *c);
 
-int event_add_out(struct evbase *evb, struct conn *c);
-int event_del_out(struct evbase *evb, struct conn *c);
-int event_add_conn(struct evbase *evb, struct conn *c);
-int event_del_conn(struct evbase *evb, struct conn *c);
-int event_wait(struct evbase *evb, int timeout);
-int event_add_st(struct evbase *evb, int fd);
+int event_wait(int ep, struct epoll_event *event, int nevent, int timeout);
 
-#endif /* _NC_EVENT_H */
+#endif