nutcracker 0.2.3 → 0.2.4.beta1

data/ext/nutcracker/src/nc_conf.c

@@ -1109,14 +1109,6 @@ conf_pre_validate(struct conf *cf)
     return NC_OK;
 }
 
-static int
-conf_server_pname_cmp(const void *t1, const void *t2)
-{
-    const struct conf_server *s1 = t1, *s2 = t2;
-
-    return string_compare(&s1->pname, &s2->pname);
-}
-
 static int
 conf_server_name_cmp(const void *t1, const void *t2)
 {
@@ -1156,27 +1148,10 @@ conf_validate_server(struct conf *cf, struct conf_pool *cp)
 
     /*
      * Disallow duplicate servers - servers with identical "host:port:weight"
-     * or "name" combination are considered as duplicates
+     * or "name" combination are considered as duplicates. When server name
+     * is configured, we only check for duplicate "name" and not for duplicate
+     * "host:port:weight"
      */
-    array_sort(&cp->server, conf_server_pname_cmp);
-    for (valid = true, i = 0; i < nserver - 1; i++) {
-        struct conf_server *cs1, *cs2;
-
-        cs1 = array_get(&cp->server, i);
-        cs2 = array_get(&cp->server, i + 1);
-
-        if (string_compare(&cs1->pname, &cs2->pname) == 0) {
-            log_error("conf: pool '%.*s' has servers with same name '%.*s'",
-                    cp->name.len, cp->name.data, cs1->pname.len,
-                    cs1->pname.data);
-            valid = false;
-            break;
-        }
-    }
-    if (!valid) {
-        return NC_ERROR;
-    }
-
     array_sort(&cp->server, conf_server_name_cmp);
     for (valid = true, i = 0; i < nserver - 1; i++) {
         struct conf_server *cs1, *cs2;
@@ -1497,7 +1472,7 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
     struct conf_server *field;
     uint8_t *p, *q, *start;
     uint8_t *pname, *addr, *port, *weight, *name;
-    uint32_t k, pnamelen, addrlen, portlen, weightlen, namelen;
+    uint32_t k, delimlen, pnamelen, addrlen, portlen, weightlen, namelen;
     struct string address;
     char delim[] = " ::";
 
@@ -1514,7 +1489,7 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
 
     value = array_top(&cf->arg);
 
-    /* parse "hostname:port:weight [name]" from the end */
+    /* parse "hostname:port:weight [name]" or "/path/unix_socket:weight [name]" from the end */
     p = value->data + value->len - 1;
     start = value->data;
     addr = NULL;
@@ -1526,6 +1501,8 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
     name = NULL;
     namelen = 0;
 
+    delimlen = value->data[0] == '/' ? 2 : 3;
+
     for (k = 0; k < sizeof(delim); k++) {
         q = nc_strrchr(p, start, delim[k]);
         if (q == NULL) {
@@ -1562,8 +1539,8 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
         p = q - 1;
     }
 
-    if (k != 3) {
-        return "has an invalid \"hostname:port:weight [name]\" format string";
+    if (k != delimlen) {
+        return "has an invalid \"hostname:port:weight [name]\"or \"/path/unix_socket:weight [name]\" format string";
     }
 
     pname = value->data;
@@ -1582,9 +1559,11 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
         return "has an invalid weight in \"hostname:port:weight [name]\" format string";
     }
 
-    field->port = nc_atoi(port, portlen);
-    if (field->port < 0 || !nc_valid_port(field->port)) {
-        return "has an invalid port in \"hostname:port:weight [name]\" format string";
+    if (value->data[0] != '/') {
+        field->port = nc_atoi(port, portlen);
+        if (field->port < 0 || !nc_valid_port(field->port)) {
+            return "has an invalid port in \"hostname:port:weight [name]\" format string";
+        }
     }
 
     if (name == NULL) {

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,9 +17,6 @@
 
 #include <stdlib.h>
 #include <unistd.h>
-
-#include <sys/epoll.h>
-
 #include <nc_core.h>
 #include <nc_event.h>
 #include <nc_conf.h>
@@ -28,6 +25,10 @@
 
 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)
 {
@@ -41,12 +42,10 @@ 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);
@@ -74,8 +73,8 @@ core_ctx_create(struct instance *nci)
     }
 
     /* initialize event handling for client, proxy and server */
-    status = event_init(ctx, EVENT_SIZE_HINT);
-    if (status != NC_OK) {
+    ctx->evb = evbase_create(NC_EVENT_SIZE, &core_core);
+    if (ctx->evb == NULL) {
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -87,7 +86,7 @@ core_ctx_create(struct instance *nci)
     status = server_pool_preconnect(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        event_deinit(ctx);
+        evbase_destroy(ctx->evb);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -99,7 +98,7 @@ core_ctx_create(struct instance *nci)
     status = proxy_init(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        event_deinit(ctx);
+        evbase_destroy(ctx->evb);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -118,7 +117,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);
-    event_deinit(ctx);
+    evbase_destroy(ctx->evb);
     stats_destroy(ctx->stats);
     server_pool_deinit(&ctx->pool);
     conf_destroy(ctx->cf);
@@ -206,9 +205,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->ep, conn);
+    status = event_del_conn(ctx->evb, conn);
     if (status < 0) {
-        log_warn("event del conn e %d %c %d failed, ignored: %s", ctx->ep,
+        log_warn("event del conn %c %d failed, ignored: %s",
                  type, conn->sd, strerror(errno));
     }
 
@@ -277,23 +276,33 @@ core_timeout(struct context *ctx)
 }
 
 static void
-core_core(struct context *ctx, struct conn *conn, uint32_t events)
+core_core(void *arg, uint32_t evflags)
 {
     rstatus_t status;
+    struct conn *conn = (struct conn *) arg;
+    struct context *ctx;
 
-    log_debug(LOG_VVERB, "event %04"PRIX32" on %c %d", events,
+    
+
+    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,
               conn->client ? 'c' : (conn->proxy ? 'p' : 's'), conn->sd);
 
-    conn->events = events;
+    conn->events = evflags;
 
     /* error takes precedence over read | write */
-    if (events & EPOLLERR) {
+    if (evflags & EV_ERR) {
         core_error(ctx, conn);
         return;
     }
 
     /* read takes precedence over write */
-    if (events & (EPOLLIN | EPOLLHUP)) {
+    if (evflags & EV_READ) {
         status = core_recv(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
@@ -301,7 +310,7 @@ core_core(struct context *ctx, struct conn *conn, uint32_t events)
         }
     }
 
-    if (events & EPOLLOUT) {
+    if (evflags & EV_WRITE) {
         status = core_send(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
@@ -315,17 +324,11 @@ core_loop(struct context *ctx)
 {
     int i, nsd;
 
-    nsd = event_wait(ctx->ep, ctx->event, ctx->nevent, ctx->timeout);
+    nsd = event_wait(ctx->evb, 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,10 +40,20 @@
 # 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
@@ -101,14 +111,12 @@ struct context {
     struct stats       *stats;      /* stats */
 
     struct array       pool;        /* server_pool[] */
-
-    int                ep;          /* epoll device */
-    int                nevent;      /* # epoll event */
+    struct evbase      *evb;
     int                max_timeout; /* epoll wait max timeout in msec */
-    int                timeout;     /* epoll wait timeout in msec */
-    struct epoll_event *event;      /* epoll event */
+    int                timeout;
 };
 
+
 struct instance {
     struct context  *ctx;                        /* active context */
     int             log_level;                   /* log level */

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

@@ -16,66 +16,86 @@
  */
 
 #include <unistd.h>
-#include <sys/epoll.h>
-
 #include <nc_core.h>
 #include <nc_event.h>
 
-int
-event_init(struct context *ctx, int size)
+#ifdef NC_HAVE_EPOLL
+#include <sys/epoll.h>
+
+struct evbase * 
+evbase_create(int nevent, void (*callback_fp)(void *, uint32_t))
 {
+
+    struct evbase *evb;
     int status, ep;
     struct epoll_event *event;
 
-    ASSERT(ctx->ep < 0);
-    ASSERT(ctx->nevent != 0);
-    ASSERT(ctx->event == NULL);
+    if (nevent <= 0) {
+        log_error("nevent has to be positive %d", nevent);
+        return NULL;
+    }
 
-    ep = epoll_create(size);
+    ep = epoll_create(nevent);
     if (ep < 0) {
-        log_error("epoll create of size %d failed: %s", size, strerror(errno));
-        return -1;
+        log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
+        return NULL;
     }
 
-    event = nc_calloc(ctx->nevent, sizeof(*ctx->event));
+    event = nc_calloc(nevent, sizeof(*event));
     if (event == NULL) {
         status = close(ep);
         if (status < 0) {
             log_error("close e %d failed, ignored: %s", ep, strerror(errno));
         }
-        return -1;
+        return NULL;
     }
 
-    ctx->ep = ep;
-    ctx->event = event;
+    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;
 
-    log_debug(LOG_INFO, "e %d with nevent %d timeout %d", ctx->ep,
-              ctx->nevent, ctx->timeout);
+    }
 
-    return 0;
+    evb->nevent = nevent;
+    evb->ep = ep;
+    evb->event = event;
+    evb->callback_fp = callback_fp;
+
+    log_debug(LOG_INFO, "e %d with nevent %d", evb->ep,
+              evb->nevent);
+
+    return evb;
 }
 
 void
-event_deinit(struct context *ctx)
+evbase_destroy(struct evbase *evb)
 {
     int status;
 
-    ASSERT(ctx->ep >= 0);
+    if (evb == NULL) return;
 
-    nc_free(ctx->event);
+    ASSERT(evb->ep >= 0);
 
-    status = close(ctx->ep);
+    nc_free(evb->event);
+
+    status = close(evb->ep);
     if (status < 0) {
-        log_error("close e %d failed, ignored: %s", ctx->ep, strerror(errno));
+        log_error("close e %d failed, ignored: %s", evb->ep, strerror(errno));
     }
-    ctx->ep = -1;
+    nc_free(evb);
 }
 
 int
-event_add_out(int ep, struct conn *c)
+event_add_out(struct evbase *evb, struct conn *c)
 {
     int status;
     struct epoll_event event;
+    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -101,10 +121,11 @@ event_add_out(int ep, struct conn *c)
 }
 
 int
-event_del_out(int ep, struct conn *c)
+event_del_out(struct evbase *evb, struct conn *c)
 {
     int status;
     struct epoll_event event;
+    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -130,10 +151,11 @@ event_del_out(int ep, struct conn *c)
 }
 
 int
-event_add_conn(int ep, struct conn *c)
+event_add_conn(struct evbase *evb, struct conn *c)
 {
     int status;
     struct epoll_event event;
+    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -155,9 +177,10 @@ event_add_conn(int ep, struct conn *c)
 }
 
 int
-event_del_conn(int ep, struct conn *c)
+event_del_conn(struct evbase *evb, struct conn *c)
 {
     int status;
+    int ep = evb->ep;
 
     ASSERT(ep > 0);
     ASSERT(c != NULL);
@@ -176,9 +199,14 @@ event_del_conn(int ep, struct conn *c)
 }
 
 int
-event_wait(int ep, struct epoll_event *event, int nevent, int timeout)
+event_wait(struct evbase *evb, int timeout)
 {
-    int nsd;
+    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;
 
     ASSERT(ep > 0);
     ASSERT(event != NULL);
@@ -187,6 +215,22 @@ event_wait(int ep, struct epoll_event *event, int nevent, 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;
         }
 
@@ -209,6 +253,26 @@ event_wait(int ep, struct epoll_event *event, int nevent, 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;
+}
+
+#endif /* NC_HAVE_EPOLL */