nutcracker 0.3.0.12 → 0.4.0.13

data/ext/nutcracker/src/nc_conf.c

@@ -1557,6 +1557,8 @@ conf_add_server(struct conf *cf, struct command *cmd, void *conf)
     field->weight = nc_atoi(weight, weightlen);
     if (field->weight < 0) {
         return "has an invalid weight in \"hostname:port:weight [name]\" format string";
+    } else if (field->weight == 0) {
+        return "has a zero weight in \"hostname:port:weight [name]\" format string";
     }
 
     if (value->data[0] != '/') {

data/ext/nutcracker/src/nc_connection.c

@@ -83,6 +83,9 @@
 
 static uint32_t nfree_connq;       /* # free conn q */
 static struct conn_tqh free_connq; /* free conn q */
+static uint64_t ntotal_conn;       /* total # connections counter from start */
+static uint32_t ncurr_conn;        /* current # connections */
+static uint32_t ncurr_cconn;       /* current # client connections */
 
 /*
  * Return the context associated with this connection.
@@ -154,6 +157,9 @@ _conn_get(void)
     conn->done = 0;
     conn->redis = 0;
 
+    ntotal_conn++;
+    ncurr_conn++;
+
     return conn;
 }
 
@@ -195,6 +201,8 @@ conn_get(void *owner, bool client, bool redis)
         conn->dequeue_inq = NULL;
         conn->enqueue_outq = req_client_enqueue_omsgq;
         conn->dequeue_outq = req_client_dequeue_omsgq;
+        
+        ncurr_cconn++;
     } else {
         /*
          * server receives a response, possibly parsing it, and sends a
@@ -285,6 +293,11 @@ conn_put(struct conn *conn)
 
     nfree_connq++;
     TAILQ_INSERT_HEAD(&free_connq, conn, conn_tqe);
+
+    if (conn->client) {
+        ncurr_cconn--;
+    }
+    ncurr_conn--;
 }
 
 void
@@ -407,3 +420,21 @@ conn_sendv(struct conn *conn, struct array *sendv, size_t nsend)
 
     return NC_ERROR;
 }
+
+uint32_t
+conn_ncurr_conn(void)
+{
+    return ncurr_conn;
+}
+
+uint64_t
+conn_ntotal_conn(void)
+{
+    return ntotal_conn;
+}
+
+uint32_t
+conn_ncurr_cconn(void)
+{
+    return ncurr_cconn;
+}

data/ext/nutcracker/src/nc_connection.h

@@ -96,5 +96,8 @@ ssize_t conn_recv(struct conn *conn, void *buf, size_t size);
 ssize_t conn_sendv(struct conn *conn, struct array *sendv, size_t nsend);
 void conn_init(void);
 void conn_deinit(void);
+uint32_t conn_ncurr_conn(void);
+uint64_t conn_ntotal_conn(void);
+uint32_t conn_ncurr_cconn(void);
 
 #endif

data/ext/nutcracker/src/nc_core.c

@@ -24,6 +24,27 @@
 
 static uint32_t ctx_id; /* context generation */
 
+static rstatus_t
+core_calc_connections(struct context *ctx)
+{
+    int status;
+    struct rlimit limit;
+
+    status = getrlimit(RLIMIT_NOFILE, &limit);
+    if (status < 0) {
+        log_error("getrlimit failed: %s", strerror(errno));
+        return NC_ERROR;
+    }
+
+    ctx->max_nfd = (uint32_t)limit.rlim_cur;
+    ctx->max_ncconn = ctx->max_nfd - ctx->max_nsconn - RESERVED_FDS;
+    log_debug(LOG_NOTICE, "max fds %"PRIu32" max client conns %"PRIu32" "
+              "max server conns %"PRIu32"", ctx->max_nfd, ctx->max_ncconn,
+              ctx->max_nsconn);
+
+    return NC_OK;
+}
+
 static struct context *
 core_ctx_create(struct instance *nci)
 {
@@ -41,6 +62,9 @@ core_ctx_create(struct instance *nci)
     array_null(&ctx->pool);
     ctx->max_timeout = nci->stats_interval;
     ctx->timeout = ctx->max_timeout;
+    ctx->max_nfd = 0;
+    ctx->max_ncconn = 0;
+    ctx->max_nsconn = 0;
 
     /* parse and create configuration */
     ctx->cf = conf_create(nci->conf_filename);
@@ -57,6 +81,18 @@ core_ctx_create(struct instance *nci)
         return NULL;
     }
 
+    /*
+     * Get rlimit and calculate max client connections after we have
+     * calculated max server connections
+     */
+    status = core_calc_connections(ctx);
+    if (status != NC_OK) {
+        server_pool_deinit(&ctx->pool);
+        conf_destroy(ctx->cf);
+        nc_free(ctx);
+        return NULL;
+    }
+
     /* create stats per server pool */
     ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
                               nci->hostname, &ctx->pool);
@@ -172,9 +208,9 @@ core_send(struct context *ctx, struct conn *conn)
 
     status = conn->send(ctx, conn);
     if (status != NC_OK) {
-        log_debug(LOG_INFO, "send on %c %d failed: %s",
+        log_debug(LOG_INFO, "send on %c %d failed: status: %d errno: %d %s",
                   conn->client ? 'c' : (conn->proxy ? 'p' : 's'), conn->sd,
-                  strerror(errno));
+                  status, errno, strerror(errno));
     }
 
     return status;

data/ext/nutcracker/src/nc_core.h

@@ -63,6 +63,9 @@
 #define NC_EAGAIN   -2
 #define NC_ENOMEM   -3
 
+/* reserved fds for std streams, log, stats fd, epoll etc. */
+#define RESERVED_FDS 32
+
 typedef int rstatus_t; /* return type */
 typedef int err_t;     /* error type */
 
@@ -87,6 +90,8 @@ struct event_base;
 #include <stdbool.h>
 #include <inttypes.h>
 #include <string.h>
+#include <stdio.h>
+#include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <time.h>
@@ -97,6 +102,7 @@ struct event_base;
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/time.h>
+#include <sys/resource.h>
 #include <netinet/in.h>
 
 #include <nc_array.h>
@@ -110,6 +116,7 @@ struct event_base;
 #include <nc_mbuf.h>
 #include <nc_message.h>
 #include <nc_connection.h>
+#include <nc_server.h>
 
 struct context {
     uint32_t           id;          /* unique context id */
@@ -120,6 +127,10 @@ struct context {
     struct event_base  *evb;        /* event base */
     int                max_timeout; /* max timeout in msec */
     int                timeout;     /* timeout in msec */
+
+    uint32_t           max_nfd;     /* max # files */
+    uint32_t           max_ncconn;  /* max # client connections */
+    uint32_t           max_nsconn;  /* max # server connections */
 };
 
 

data/ext/nutcracker/src/nc_log.c

@@ -68,7 +68,7 @@ log_reopen(void)
         close(l->fd);
         l->fd = open(l->name, O_WRONLY | O_APPEND | O_CREAT, 0644);
         if (l->fd < 0) {
-            log_stderr("reopening log file '%s' failed, ignored: %s", l->name,
+            log_stderr_safe("reopening log file '%s' failed, ignored: %s", l->name,
                        strerror(errno));
         }
     }
@@ -81,7 +81,7 @@ log_level_up(void)
 
     if (l->level < LOG_PVERB) {
         l->level++;
-        loga("up log level to %d", l->level);
+        log_safe("up log level to %d", l->level);
     }
 }
 
@@ -92,7 +92,7 @@ log_level_down(void)
 
     if (l->level > LOG_EMERG) {
         l->level--;
-        loga("down log level to %d", l->level);
+        log_safe("down log level to %d", l->level);
     }
 }
 
@@ -105,6 +105,17 @@ log_level_set(int level)
     loga("set log level to %d", l->level);
 }
 
+void
+log_stacktrace(void)
+{
+    struct logger *l = &logger;
+
+    if (l->fd < 0) {
+        return;
+    }
+    nc_stacktrace_fd(l->fd);
+}
+
 int
 log_loggable(int level)
 {
@@ -122,11 +133,10 @@ _log(const char *file, int line, int panic, const char *fmt, ...)
 {
     struct logger *l = &logger;
     int len, size, errno_save;
-    char buf[LOG_MAX_LEN], *timestr;
+    char buf[LOG_MAX_LEN];
     va_list args;
-    struct tm *local;
-    time_t t;
     ssize_t n;
+    struct timeval tv;
 
     if (l->fd < 0) {
         return;
@@ -136,12 +146,11 @@ _log(const char *file, int line, int panic, const char *fmt, ...)
     len = 0;            /* length of output buffer */
     size = LOG_MAX_LEN; /* size of output buffer */
 
-    t = time(NULL);
-    local = localtime(&t);
-    timestr = asctime(local);
-
-    len += nc_scnprintf(buf + len, size - len, "[%.*s] %s:%d ",
-                        strlen(timestr) - 1, timestr, file, line);
+    gettimeofday(&tv, NULL);
+    buf[len++] = '[';
+    len += nc_strftime(buf + len, size - len, "%Y-%m-%d %H:%M:%S.", localtime(&tv.tv_sec));
+    len += nc_scnprintf(buf + len, size - len, "%03ld", tv.tv_usec/1000);
+    len += nc_scnprintf(buf + len, size - len, "] %s:%d ", file, line);
 
     va_start(args, fmt);
     len += nc_vscnprintf(buf + len, size - len, fmt, args);
@@ -250,5 +259,74 @@ _log_hexdump(const char *file, int line, char *data, int datalen,
         l->nerror++;
     }
 
+    if (len >= size - 1) {
+        n = nc_write(l->fd, "\n", 1);
+        if (n < 0) {
+            l->nerror++;
+        }
+    }
+
+    errno = errno_save;
+}
+
+void
+_log_safe(const char *fmt, ...)
+{
+    struct logger *l = &logger;
+    int len, size, errno_save;
+    char buf[LOG_MAX_LEN];
+    va_list args;
+    ssize_t n;
+
+    if (l->fd < 0) {
+        return;
+    }
+
+    errno_save = errno;
+    len = 0;            /* length of output buffer */
+    size = LOG_MAX_LEN; /* size of output buffer */
+
+    len += nc_safe_snprintf(buf + len, size - len, "[.......................] ");
+
+    va_start(args, fmt);
+    len += nc_safe_vsnprintf(buf + len, size - len, fmt, args);
+    va_end(args);
+
+    buf[len++] = '\n';
+
+    n = nc_write(l->fd, buf, len);
+    if (n < 0) {
+        l->nerror++;
+    }
+
+    errno = errno_save;
+}
+
+void
+_log_stderr_safe(const char *fmt, ...)
+{
+    struct logger *l = &logger;
+    int len, size, errno_save;
+    char buf[LOG_MAX_LEN];
+    va_list args;
+    ssize_t n;
+
+    errno_save = errno;
+    len = 0;            /* length of output buffer */
+    size = LOG_MAX_LEN; /* size of output buffer */
+
+    len += nc_safe_snprintf(buf + len, size - len, "[.......................] ");
+
+    va_start(args, fmt);
+    len += nc_safe_vsnprintf(buf + len, size - len, fmt, args);
+    va_end(args);
+
+    buf[len++] = '\n';
+
+    n = nc_write(STDERR_FILENO, buf, len);
+    if (n < 0) {
+        l->nerror++;
+    }
+
     errno = errno_save;
 }

data/ext/nutcracker/src/nc_log.h

@@ -78,6 +78,14 @@ struct logger {
     _log_stderr(__VA_ARGS__);                                               \
 } while (0)
 
+#define log_safe(...) do {                                                  \
+    _log_safe(__VA_ARGS__);                                                 \
+} while (0)
+
+#define log_stderr_safe(...) do {                                           \
+    _log_stderr_safe(__VA_ARGS__);                                          \
+} while (0)
+
 #define loga(...) do {                                                      \
     _log(__FILE__, __LINE__, 0, __VA_ARGS__);                               \
 } while (0)
@@ -111,10 +119,13 @@ void log_deinit(void);
 void log_level_up(void);
 void log_level_down(void);
 void log_level_set(int level);
+void log_stacktrace(void);
 void log_reopen(void);
 int log_loggable(int level);
 void _log(const char *file, int line, int panic, const char *fmt, ...);
 void _log_stderr(const char *fmt, ...);
+void _log_safe(const char *fmt, ...);
+void _log_stderr_safe(const char *fmt, ...);
 void _log_hexdump(const char *file, int line, char *data, int datalen, const char *fmt, ...);
 
 #endif

data/ext/nutcracker/src/nc_mbuf.h

@@ -35,7 +35,7 @@ STAILQ_HEAD(mhdr, mbuf);
 
 #define MBUF_MAGIC      0xdeadbeef
 #define MBUF_MIN_SIZE   512
-#define MBUF_MAX_SIZE   65536
+#define MBUF_MAX_SIZE   16777216
 #define MBUF_SIZE       16384
 #define MBUF_HSIZE      sizeof(struct mbuf)
 

data/ext/nutcracker/src/nc_message.c

@@ -116,6 +116,13 @@ static struct msg_tqh free_msgq; /* free msg q */
 static struct rbtree tmo_rbt;    /* timeout rbtree */
 static struct rbnode tmo_rbs;    /* timeout rbtree sentinel */
 
+#define DEFINE_ACTION(_name) string(#_name),
+static struct string msg_type_strings[] = {
+    MSG_TYPE_CODEC( DEFINE_ACTION )
+    null_string
+};
+#undef DEFINE_ACTION
+
 static struct msg *
 msg_from_rbe(struct rbnode *node)
 {
@@ -212,6 +219,7 @@ done:
 
     STAILQ_INIT(&msg->mhdr);
     msg->mlen = 0;
+    msg->start_ts = 0;
 
     msg->state = 0;
     msg->pos = NULL;
@@ -220,21 +228,26 @@ done:
     msg->parser = NULL;
     msg->result = MSG_PARSE_OK;
 
-    msg->pre_splitcopy = NULL;
-    msg->post_splitcopy = NULL;
+    msg->fragment = NULL;
+    msg->reply = NULL;
     msg->pre_coalesce = NULL;
     msg->post_coalesce = NULL;
 
     msg->type = MSG_UNKNOWN;
 
-    msg->key_start = NULL;
-    msg->key_end = NULL;
+    msg->keys = array_create(1, sizeof(struct keypos));
+    if (msg->keys == NULL) {
+        nc_free(msg);
+        return NULL;
+    }
 
     msg->vlen = 0;
     msg->end = NULL;
 
     msg->frag_owner = NULL;
+    msg->frag_seq = NULL;
     msg->nfrag = 0;
+    msg->nfrag_done = 0;
     msg->frag_id = 0;
 
     msg->narg_start = NULL;
@@ -250,10 +263,9 @@ done:
     msg->request = 0;
     msg->quit = 0;
     msg->noreply = 0;
+    msg->noforward = 0;
     msg->done = 0;
     msg->fdone = 0;
-    msg->first_fragment = 0;
-    msg->last_fragment = 0;
     msg->swallow = 0;
     msg->redis = 0;
 
@@ -280,8 +292,8 @@ msg_get(struct conn *conn, bool request, bool redis)
         } else {
             msg->parser = redis_parse_rsp;
         }
-        msg->pre_splitcopy = redis_pre_splitcopy;
-        msg->post_splitcopy = redis_post_splitcopy;
+        msg->fragment = redis_fragment;
+        msg->reply = redis_reply;
         msg->pre_coalesce = redis_pre_coalesce;
         msg->post_coalesce = redis_post_coalesce;
     } else {
@@ -290,12 +302,15 @@ msg_get(struct conn *conn, bool request, bool redis)
         } else {
             msg->parser = memcache_parse_rsp;
         }
-        msg->pre_splitcopy = memcache_pre_splitcopy;
-        msg->post_splitcopy = memcache_post_splitcopy;
+        msg->fragment = memcache_fragment;
         msg->pre_coalesce = memcache_pre_coalesce;
         msg->post_coalesce = memcache_post_coalesce;
     }
 
+    if (log_loggable(LOG_NOTICE) != 0) {
+        msg->start_ts = nc_usec_now();
+    }
+
     log_debug(LOG_VVERB, "get msg %p id %"PRIu64" request %d owner sd %d",
               msg, msg->id, msg->request, conn->sd);
 
@@ -356,15 +371,30 @@ msg_put(struct msg *msg)
         mbuf_put(mbuf);
     }
 
+    if (msg->frag_seq) {
+        nc_free(msg->frag_seq);
+        msg->frag_seq = NULL;
+    }
+
+    if (msg->keys) {
+        msg->keys->nelem = 0; /* a hack here */
+        array_destroy(msg->keys);
+        msg->keys = NULL;
+    }
+
     nfree_msgq++;
     TAILQ_INSERT_HEAD(&free_msgq, msg, m_tqe);
 }
 
 void
-msg_dump(struct msg *msg)
+msg_dump(struct msg *msg, int level)
 {
     struct mbuf *mbuf;
 
+    if (log_loggable(level) == 0) {
+        return;
+    }
+
     loga("msg dump id %"PRIu64" request %d len %"PRIu32" type %d done %d "
          "error %d (err %d)", msg->id, msg->request, msg->mlen, msg->type,
          msg->done, msg->error, msg->err);
@@ -377,7 +407,7 @@ msg_dump(struct msg *msg)
         q = mbuf->last;
         len = q - p;
 
-        loga_hexdump(p, len, "mbuf with %ld bytes of data", len);
+        loga_hexdump(p, len, "mbuf [%p] with %ld bytes of data", p, len);
     }
 }
 
@@ -406,12 +436,122 @@ msg_deinit(void)
     ASSERT(nfree_msgq == 0);
 }
 
+struct string *
+msg_type_string(msg_type_t type)
+{
+    return &msg_type_strings[type];
+}
+
 bool
 msg_empty(struct msg *msg)
 {
     return msg->mlen == 0 ? true : false;
 }
 
+uint32_t
+msg_backend_idx(struct msg *msg, uint8_t *key, uint32_t keylen)
+{
+    struct conn *conn = msg->owner;
+    struct server_pool *pool = conn->owner;
+
+    return server_pool_idx(pool, key, keylen);
+}
+
+struct mbuf *
+msg_ensure_mbuf(struct msg *msg, size_t len)
+{
+    struct mbuf *mbuf;
+
+    if (STAILQ_EMPTY(&msg->mhdr) ||
+        mbuf_size(STAILQ_LAST(&msg->mhdr, mbuf, next)) < len) {
+        mbuf = mbuf_get();
+        if (mbuf == NULL) {
+            return NULL;
+        }
+        mbuf_insert(&msg->mhdr, mbuf);
+    } else {
+        mbuf = STAILQ_LAST(&msg->mhdr, mbuf, next);
+    }
+    return mbuf;
+}
+
+/*
+ * append small(small than a mbuf) content into msg
+ */
+rstatus_t
+msg_append(struct msg *msg, uint8_t *pos, size_t n)
+{
+    struct mbuf *mbuf;
+
+    ASSERT(n <= mbuf_data_size());
+
+    mbuf = msg_ensure_mbuf(msg, n);
+    if (mbuf == NULL) {
+        return NC_ENOMEM;
+    }
+
+    ASSERT(n <= mbuf_size(mbuf));
+
+    mbuf_copy(mbuf, pos, n);
+    msg->mlen += (uint32_t)n;
+    return NC_OK;
+}
+
+/*
+ * prepend small(small than a mbuf) content into msg
+ */
+rstatus_t
+msg_prepend(struct msg *msg, uint8_t *pos, size_t n)
+{
+    struct mbuf *mbuf;
+
+    mbuf = mbuf_get();
+    if (mbuf == NULL) {
+        return NC_ENOMEM;
+    }
+
+    ASSERT(n <= mbuf_size(mbuf));
+
+    mbuf_copy(mbuf, pos, n);
+    msg->mlen += (uint32_t)n;
+
+    STAILQ_INSERT_HEAD(&msg->mhdr, mbuf, next);
+    return NC_OK;
+}
+
+/*
+ * prepend small(small than a mbuf) content into msg
+ */
+rstatus_t
+msg_prepend_format(struct msg *msg, const char *fmt, ...)
+{
+    struct mbuf *mbuf;
+    int32_t n;
+    va_list args;
+
+    mbuf = mbuf_get();
+    if (mbuf == NULL) {
+        return NC_ENOMEM;
+    }
+
+    va_start(args, fmt);
+    n = nc_vscnprintf(mbuf->last, mbuf_size(mbuf), fmt, args);
+    va_end(args);
+
+    mbuf->last += n;
+    msg->mlen += (uint32_t)n;
+
+    ASSERT(mbuf_size(mbuf) >= 0);
+    STAILQ_INSERT_HEAD(&msg->mhdr, mbuf, next);
+    return NC_OK;
+}
+
+inline uint64_t
+msg_gen_frag_id(void)
+{
+    return ++frag_id;
+}
+
 static rstatus_t
 msg_parsed(struct context *ctx, struct conn *conn, struct msg *msg)
 {
@@ -453,101 +593,6 @@ msg_parsed(struct context *ctx, struct conn *conn, struct msg *msg)
     return NC_OK;
 }
 
-static rstatus_t
-msg_fragment(struct context *ctx, struct conn *conn, struct msg *msg)
-{
-    rstatus_t status;  /* return status */
-    struct msg *nmsg;  /* new message */
-    struct mbuf *nbuf; /* new mbuf */
-
-    ASSERT(conn->client && !conn->proxy);
-    ASSERT(msg->request);
-
-    nbuf = mbuf_split(&msg->mhdr, msg->pos, msg->pre_splitcopy, msg);
-    if (nbuf == NULL) {
-        return NC_ENOMEM;
-    }
-
-    status = msg->post_splitcopy(msg);
-    if (status != NC_OK) {
-        mbuf_put(nbuf);
-        return status;
-    }
-
-    nmsg = msg_get(msg->owner, msg->request, msg->redis);
-    if (nmsg == NULL) {
-        mbuf_put(nbuf);
-        return NC_ENOMEM;
-    }
-    mbuf_insert(&nmsg->mhdr, nbuf);
-    nmsg->pos = nbuf->pos;
-
-    /* update length of current (msg) and new message (nmsg) */
-    nmsg->mlen = mbuf_length(nbuf);
-    msg->mlen -= nmsg->mlen;
-
-    /*
-     * Attach unique fragment id to all fragments of the message vector. All
-     * fragments of the message, including the first fragment point to the
-     * first fragment through the frag_owner pointer. The first_fragment and
-     * last_fragment identify first and last fragment respectively.
-     *
-     * For example, a message vector given below is split into 3 fragments:
-     *  'get key1 key2 key3\r\n'
-     *  Or,
-     *  '*4\r\n$4\r\nmget\r\n$4\r\nkey1\r\n$4\r\nkey2\r\n$4\r\nkey3\r\n'
-     *
-     *   +--------------+
-     *   |  msg vector  |
-     *   |(original msg)|
-     *   +--------------+
-     *
-     *       frag_owner         frag_owner
-     *     /-----------+      /------------+
-     *     |           |      |            |
-     *     |           v      v            |
-     *   +--------------------+     +---------------------+
-     *   |   frag_id = 10     |     |   frag_id = 10      |
-     *   | first_fragment = 1 |     |  first_fragment = 0 |
-     *   | last_fragment = 0  |     |  last_fragment = 0  |
-     *   |     nfrag = 3      |     |      nfrag = 0      |
-     *   +--------------------+     +---------------------+
-     *               ^
-     *               |  frag_owner
-     *               \-------------+
-     *                             |
-     *                             |
-     *                  +---------------------+
-     *                  |   frag_id = 10      |
-     *                  |  first_fragment = 0 |
-     *                  |  last_fragment = 1  |
-     *                  |      nfrag = 0      |
-     *                  +---------------------+
-     *
-     *
-     */
-    if (msg->frag_id == 0) {
-        msg->frag_id = ++frag_id;
-        msg->first_fragment = 1;
-        msg->nfrag = 1;
-        msg->frag_owner = msg;
-    }
-    nmsg->frag_id = msg->frag_id;
-    msg->last_fragment = 0;
-    nmsg->last_fragment = 1;
-    nmsg->frag_owner = msg->frag_owner;
-    msg->frag_owner->nfrag++;
-
-    stats_pool_incr(ctx, conn->owner, fragments);
-
-    log_debug(LOG_VERB, "fragment msg into %"PRIu64" and %"PRIu64" frag id "
-              "%"PRIu64"", msg->id, nmsg->id, msg->frag_id);
-
-    conn->recv_done(ctx, conn, msg, nmsg);
-
-    return NC_OK;
-}
-
 static rstatus_t
 msg_repair(struct context *ctx, struct conn *conn, struct msg *msg)
 {
@@ -581,10 +626,6 @@ msg_parse(struct context *ctx, struct conn *conn, struct msg *msg)
         status = msg_parsed(ctx, conn, msg);
         break;
 
-    case MSG_PARSE_FRAGMENT:
-        status = msg_fragment(ctx, conn, msg);
-        break;
-
     case MSG_PARSE_REPAIR:
         status = msg_repair(ctx, conn, msg);
         break;
@@ -742,11 +783,16 @@ msg_send_chain(struct context *ctx, struct conn *conn, struct msg *msg)
         }
     }
 
-    ASSERT(!TAILQ_EMPTY(&send_msgq) && nsend != 0);
-
+    /*
+     * (nsend == 0) is possible in redis multi-del
+     * see PR: https://github.com/twitter/twemproxy/pull/225
+     */
     conn->smsg = NULL;
-
-    n = conn_sendv(conn, &sendv, nsend);
+    if (!TAILQ_EMPTY(&send_msgq) && nsend != 0) {
+        n = conn_sendv(conn, &sendv, nsend);
+    } else {
+        n = 0;
+    }
 
     nsent = n > 0 ? (size_t)n : 0;
 
@@ -794,7 +840,7 @@ msg_send_chain(struct context *ctx, struct conn *conn, struct msg *msg)
 
     ASSERT(TAILQ_EMPTY(&send_msgq));
 
-    if (n > 0) {
+    if (n >= 0) {
         return NC_OK;
     }