nutcracker 0.2.4.12 → 0.3.0.12

data/ext/nutcracker/src/nc_connection.h

@@ -88,6 +88,7 @@ struct conn {
 
 TAILQ_HEAD(conn_tqh, conn);
 
+struct context *conn_to_ctx(struct conn *conn);
 struct conn *conn_get(void *owner, bool client, bool redis);
 struct conn *conn_get_proxy(void *owner);
 void conn_put(struct conn *conn);

data/ext/nutcracker/src/nc_core.c

@@ -17,11 +17,7 @@
 
 #include <stdlib.h>
 #include <unistd.h>
-
-#include <sys/epoll.h>
-
 #include <nc_core.h>
-#include <nc_event.h>
 #include <nc_conf.h>
 #include <nc_server.h>
 #include <nc_proxy.h>
@@ -41,12 +37,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 +68,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 = event_base_create(EVENT_SIZE, &core_core);
+    if (ctx->evb == NULL) {
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -87,7 +81,7 @@ core_ctx_create(struct instance *nci)
     status = server_pool_preconnect(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        event_deinit(ctx);
+        event_base_destroy(ctx->evb);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -99,7 +93,7 @@ core_ctx_create(struct instance *nci)
     status = proxy_init(ctx);
     if (status != NC_OK) {
         server_pool_disconnect(ctx);
-        event_deinit(ctx);
+        event_base_destroy(ctx->evb);
         stats_destroy(ctx->stats);
         server_pool_deinit(&ctx->pool);
         conf_destroy(ctx->cf);
@@ -118,7 +112,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);
+    event_base_destroy(ctx->evb);
     stats_destroy(ctx->stats);
     server_pool_deinit(&ctx->pool);
     conf_destroy(ctx->cf);
@@ -206,9 +200,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));
     }
 
@@ -276,10 +270,12 @@ core_timeout(struct context *ctx)
     }
 }
 
-static void
-core_core(struct context *ctx, struct conn *conn, uint32_t events)
+rstatus_t
+core_core(void *arg, uint32_t events)
 {
     rstatus_t status;
+    struct conn *conn = arg;
+    struct context *ctx = conn_to_ctx(conn);
 
     log_debug(LOG_VVERB, "event %04"PRIX32" on %c %d", events,
               conn->client ? 'c' : (conn->proxy ? 'p' : 's'), conn->sd);
@@ -287,45 +283,41 @@ core_core(struct context *ctx, struct conn *conn, uint32_t events)
     conn->events = events;
 
     /* error takes precedence over read | write */
-    if (events & EPOLLERR) {
+    if (events & EVENT_ERR) {
         core_error(ctx, conn);
-        return;
+        return NC_ERROR;
     }
 
     /* read takes precedence over write */
-    if (events & (EPOLLIN | EPOLLHUP)) {
+    if (events & EVENT_READ) {
         status = core_recv(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
-            return;
+            return NC_ERROR;
         }
     }
 
-    if (events & EPOLLOUT) {
+    if (events & EVENT_WRITE) {
         status = core_send(ctx, conn);
         if (status != NC_OK || conn->done || conn->err) {
             core_close(ctx, conn);
-            return;
+            return NC_ERROR;
         }
     }
+
+    return NC_OK;
 }
 
 rstatus_t
 core_loop(struct context *ctx)
 {
-    int i, nsd;
+    int 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,24 @@
 # define NC_STATS 0
 #endif
 
+#ifdef HAVE_EPOLL
+# define NC_HAVE_EPOLL 1
+#elif HAVE_KQUEUE
+# define NC_HAVE_KQUEUE 1
+#elif HAVE_EVENT_PORTS
+# define NC_HAVE_EVENT_PORTS 1
+#else
+# error missing scalable I/O event notification mechanism
+#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
@@ -65,8 +79,8 @@ struct mbuf;
 struct mhdr;
 struct conf;
 struct stats;
-struct epoll_event;
 struct instance;
+struct event_base;
 
 #include <stddef.h>
 #include <stdint.h>
@@ -82,6 +96,7 @@ struct instance;
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <sys/time.h>
 #include <netinet/in.h>
 
 #include <nc_array.h>
@@ -90,6 +105,7 @@ struct instance;
 #include <nc_rbtree.h>
 #include <nc_log.h>
 #include <nc_util.h>
+#include <event/nc_event.h>
 #include <nc_stats.h>
 #include <nc_mbuf.h>
 #include <nc_message.h>
@@ -101,14 +117,12 @@ struct context {
     struct stats       *stats;      /* stats */
 
     struct array       pool;        /* server_pool[] */
-
-    int                ep;          /* epoll device */
-    int                nevent;      /* # epoll event */
-    int                max_timeout; /* epoll wait max timeout in msec */
-    int                timeout;     /* epoll wait timeout in msec */
-    struct epoll_event *event;      /* epoll event */
+    struct event_base  *evb;        /* event base */
+    int                max_timeout; /* max timeout in msec */
+    int                timeout;     /* timeout in msec */
 };
 
+
 struct instance {
     struct context  *ctx;                        /* active context */
     int             log_level;                   /* log level */
@@ -126,6 +140,7 @@ struct instance {
 
 struct context *core_start(struct instance *nci);
 void core_stop(struct context *ctx);
+rstatus_t core_core(void *arg, uint32_t events);
 rstatus_t core_loop(struct context *ctx);
 
 #endif

data/ext/nutcracker/src/nc_proxy.c

@@ -19,7 +19,6 @@
 
 #include <nc_core.h>
 #include <nc_server.h>
-#include <nc_event.h>
 #include <nc_proxy.h>
 
 void
@@ -163,18 +162,18 @@ proxy_listen(struct context *ctx, struct conn *p)
         return NC_ERROR;
     }
 
-    status = event_add_conn(ctx->ep, p);
+    status = event_add_conn(ctx->evb, p);
     if (status < 0) {
-        log_error("event add conn e %d p %d on addr '%.*s' failed: %s",
-                  ctx->ep, p->sd, pool->addrstr.len, pool->addrstr.data,
+        log_error("event add conn p %d on addr '%.*s' failed: %s",
+                  p->sd, pool->addrstr.len, pool->addrstr.data,
                   strerror(errno));
         return NC_ERROR;
     }
 
-    status = event_del_out(ctx->ep, p);
+    status = event_del_out(ctx->evb, p);
     if (status < 0) {
-        log_error("event del out e %d p %d on addr '%.*s' failed: %s",
-                  ctx->ep, p->sd, pool->addrstr.len, pool->addrstr.data,
+        log_error("event del out p %d on addr '%.*s' failed: %s",
+                  p->sd, pool->addrstr.len, pool->addrstr.data,
                   strerror(errno));
         return NC_ERROR;
     }
@@ -325,9 +324,9 @@ proxy_accept(struct context *ctx, struct conn *p)
         }
     }
 
-    status = event_add_conn(ctx->ep, c);
+    status = event_add_conn(ctx->evb, c);
     if (status < 0) {
-        log_error("event add conn of c %d from p %d failed: %s", c->sd, p->sd,
+        log_error("event add conn from p %d failed: %s", p->sd,
                   strerror(errno));
         c->close(ctx, c);
         return status;

data/ext/nutcracker/src/nc_queue.h

@@ -52,7 +52,9 @@
 
 #include <nc_log.h>
 
+#ifndef __offsetof
 #define __offsetof(type, field) ((size_t)(&((type *)NULL)->field))
+#endif
 
 /*
  * This file defines five types of data structures: singly-linked lists,

data/ext/nutcracker/src/nc_request.c

@@ -17,7 +17,6 @@
 
 #include <nc_core.h>
 #include <nc_server.h>
-#include <nc_event.h>
 
 struct msg *
 req_get(struct conn *conn)
@@ -413,7 +412,7 @@ req_forward_error(struct context *ctx, struct conn *conn, struct msg *msg)
     }
 
     if (req_done(conn, TAILQ_FIRST(&conn->omsg_q))) {
-        status = event_add_out(ctx->ep, conn);
+        status = event_add_out(ctx->evb, conn);
         if (status != NC_OK) {
             conn->err = errno;
         }
@@ -482,7 +481,7 @@ req_forward(struct context *ctx, struct conn *c_conn, struct msg *msg)
 
     /* enqueue the message (request) into server inq */
     if (TAILQ_EMPTY(&s_conn->imsg_q)) {
-        status = event_add_out(ctx->ep, s_conn);
+        status = event_add_out(ctx->evb, s_conn);
         if (status != NC_OK) {
             req_forward_error(ctx, c_conn, msg);
             s_conn->err = errno;
@@ -533,7 +532,7 @@ req_send_next(struct context *ctx, struct conn *conn)
     nmsg = TAILQ_FIRST(&conn->imsg_q);
     if (nmsg == NULL) {
         /* nothing to send as the server inq is empty */
-        status = event_del_out(ctx->ep, conn);
+        status = event_del_out(ctx->evb, conn);
         if (status != NC_OK) {
             conn->err = errno;
         }

data/ext/nutcracker/src/nc_response.c

@@ -17,7 +17,6 @@
 
 #include <nc_core.h>
 #include <nc_server.h>
-#include <nc_event.h>
 
 struct msg *
 rsp_get(struct conn *conn)
@@ -90,7 +89,6 @@ rsp_recv_next(struct context *ctx, struct conn *conn, bool alloc)
     struct msg *msg;
 
     ASSERT(!conn->client && !conn->proxy);
-    ASSERT(!conn->connecting);
 
     if (conn->eof) {
         msg = conn->rmsg;
@@ -157,11 +155,30 @@ rsp_filter(struct context *ctx, struct conn *conn, struct msg *msg)
 
     pmsg = TAILQ_FIRST(&conn->omsg_q);
     if (pmsg == NULL) {
-        log_error("filter stray rsp %"PRIu64" len %"PRIu32" on s %d", msg->id,
-                  msg->mlen, conn->sd);
+        log_debug(LOG_ERR, "filter stray rsp %"PRIu64" len %"PRIu32" on s %d",
+                  msg->id, msg->mlen, conn->sd);
         rsp_put(msg);
-        errno = EINVAL;
-        conn->err = errno;
+
+        /*
+         * Memcached server can respond with an error response before it has
+         * received the entire request. This is most commonly seen for set
+         * requests that exceed item_size_max. IMO, this behavior of memcached
+         * is incorrect. The right behavior for update requests that are over
+         * item_size_max would be to either:
+         * - close the connection Or,
+         * - read the entire item_size_max data and then send CLIENT_ERROR
+         *
+         * We handle this stray packet scenario in nutcracker by closing the
+         * server connection which would end up sending SERVER_ERROR to all
+         * clients that have requests pending on this server connection. The
+         * fix is aggresive, but not doing so would lead to clients getting
+         * out of sync with the server and as a result clients end up getting
+         * responses that don't correspond to the right request.
+         *
+         * See: https://github.com/twitter/twemproxy/issues/149
+         */
+        conn->err = EINVAL;
+        conn->done = 1;
         return true;
     }
     ASSERT(pmsg->peer == NULL);
@@ -222,7 +239,7 @@ rsp_forward(struct context *ctx, struct conn *s_conn, struct msg *msg)
     ASSERT(c_conn->client && !c_conn->proxy);
 
     if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
-        status = event_add_out(ctx->ep, c_conn);
+        status = event_add_out(ctx->evb, c_conn);
         if (status != NC_OK) {
             c_conn->err = errno;
         }
@@ -267,7 +284,7 @@ rsp_send_next(struct context *ctx, struct conn *conn)
             log_debug(LOG_INFO, "c %d is done", conn->sd);
         }
 
-        status = event_del_out(ctx->ep, conn);
+        status = event_del_out(ctx->evb, conn);
         if (status != NC_OK) {
             conn->err = errno;
         }

data/ext/nutcracker/src/nc_server.c

@@ -19,7 +19,6 @@
 #include <unistd.h>
 
 #include <nc_core.h>
-#include <nc_event.h>
 #include <nc_server.h>
 #include <nc_conf.h>
 
@@ -273,6 +272,9 @@ server_failure(struct context *ctx, struct server *server)
     if (now < 0) {
         return;
     }
+
+    stats_server_set_ts(ctx, server, server_ejected_at, now);
+
     next = now + pool->server_retry_timeout;
 
     log_debug(LOG_INFO, "update pool %"PRIu32" '%.*s' to delete server '%.*s' "
@@ -367,7 +369,7 @@ server_close(struct context *ctx, struct conn *conn)
             msg->err = conn->err;
 
             if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
-                event_add_out(ctx->ep, msg->owner);
+                event_add_out(ctx->evb, msg->owner);
             }
 
             log_debug(LOG_INFO, "close s %d schedule error for req %"PRIu64" "
@@ -397,7 +399,7 @@ server_close(struct context *ctx, struct conn *conn)
             msg->err = conn->err;
 
             if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
-                event_add_out(ctx->ep, msg->owner);
+                event_add_out(ctx->evb, msg->owner);
             }
 
             log_debug(LOG_INFO, "close s %d schedule error for req %"PRIu64" "
@@ -476,10 +478,10 @@ server_connect(struct context *ctx, struct server *server, struct conn *conn)
         }
     }
 
-    status = event_add_conn(ctx->ep, conn);
+    status = event_add_conn(ctx->evb, conn);
     if (status != NC_OK) {
-        log_error("event add conn e %d s %d for server '%.*s' failed: %s",
-                  ctx->ep, conn->sd, server->pname.len, server->pname.data,
+        log_error("event add conn s %d for server '%.*s' failed: %s",
+                  conn->sd, server->pname.len, server->pname.data,
                   strerror(errno));
         goto error;
     }

data/ext/nutcracker/src/nc_stats.c

@@ -21,7 +21,6 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
-#include <sys/epoll.h>
 #include <netinet/in.h>
 
 #include <nc_core.h>
@@ -770,34 +769,27 @@ stats_send_rsp(struct stats *st)
     return NC_OK;
 }
 
-static void *
-stats_loop(void *arg)
+static void
+stats_loop_callback(void *arg1, void *arg2)
 {
-    struct stats *st = arg;
-    int n;
+    struct stats *st = arg1;
+    int n = *((int *)arg2);
 
-    for (;;) {
-        n = epoll_wait(st->ep, &st->event, 1, st->interval);
-        if (n < 0) {
-            if (errno == EINTR) {
-                continue;
-            }
-            log_error("epoll wait on e %d with event m %d failed: %s",
-                      st->ep, st->sd, strerror(errno));
-            break;
-        }
-
-        /* aggregate stats from shadow (b) -> sum (c) */
-        stats_aggregate(st);
+    /* aggregate stats from shadow (b) -> sum (c) */
+    stats_aggregate(st);
 
-        if (n == 0) {
-            continue;
-        }
-
-        /* send aggregate stats sum (c) to collector */
-        stats_send_rsp(st);
+    if (n == 0) {
+        return;
     }
 
+    /* send aggregate stats sum (c) to collector */
+    stats_send_rsp(st);
+}
+
+static void *
+stats_loop(void *arg)
+{
+    event_loop_stats(stats_loop_callback, arg);
     return NULL;
 }
 
@@ -847,7 +839,6 @@ static rstatus_t
 stats_start_aggregator(struct stats *st)
 {
     rstatus_t status;
-    struct epoll_event ev;
 
     if (!stats_enabled) {
         return NC_OK;
@@ -858,22 +849,6 @@ stats_start_aggregator(struct stats *st)
         return status;
     }
 
-    st->ep = epoll_create(10);
-    if (st->ep < 0) {
-        log_error("epoll create failed: %s", strerror(errno));
-        return NC_ERROR;
-    }
-
-    ev.data.fd = st->sd;
-    ev.events = EPOLLIN;
-
-    status = epoll_ctl(st->ep, EPOLL_CTL_ADD, st->sd, &ev);
-    if (status < 0) {
-        log_error("epoll ctl on e %d sd %d failed: %s", st->ep, st->sd,
-                  strerror(errno));
-        return NC_ERROR;
-    }
-
     status = pthread_create(&st->tid, NULL, stats_loop, st);
     if (status < 0) {
         log_error("stats aggregator create failed: %s", strerror(status));
@@ -891,7 +866,6 @@ stats_stop_aggregator(struct stats *st)
     }
 
     close(st->sd);
-    close(st->ep);
 }
 
 struct stats *
@@ -921,7 +895,6 @@ stats_create(uint16_t stats_port, char *stats_ip, int stats_interval,
     array_null(&st->sum);
 
     st->tid = (pthread_t) -1;
-    st->ep = -1;
     st->sd = -1;
 
     string_set_text(&st->service_str, "service");
@@ -1101,6 +1074,21 @@ _stats_pool_decr_by(struct context *ctx, struct server_pool *pool,
               stm->name.data, stm->value.counter);
 }
 
+void
+_stats_pool_set_ts(struct context *ctx, struct server_pool *pool,
+                   stats_pool_field_t fidx, int64_t val)
+{
+    struct stats_metric *stm;
+
+    stm = stats_pool_to_metric(ctx, pool, fidx);
+
+    ASSERT(stm->type == STATS_TIMESTAMP);
+    stm->value.timestamp = val;
+
+    log_debug(LOG_VVVERB, "set ts field '%.*s' to %"PRId64"", stm->name.len,
+              stm->name.data, stm->value.timestamp);
+}
+
 static struct stats_metric *
 stats_server_to_metric(struct context *ctx, struct server *server,
                        stats_server_field_t fidx)
@@ -1186,3 +1174,18 @@ _stats_server_decr_by(struct context *ctx, struct server *server,
     log_debug(LOG_VVVERB, "decr by field '%.*s' to %"PRId64"", stm->name.len,
               stm->name.data, stm->value.counter);
 }
+
+void
+_stats_server_set_ts(struct context *ctx, struct server *server,
+                     stats_server_field_t fidx, int64_t val)
+{
+    struct stats_metric *stm;
+
+    stm = stats_server_to_metric(ctx, server, fidx);
+
+    ASSERT(stm->type == STATS_TIMESTAMP);
+    stm->value.timestamp = val;
+
+    log_debug(LOG_VVVERB, "set ts field '%.*s' to %"PRId64"", stm->name.len,
+              stm->name.data, stm->value.timestamp);
+}