nutcracker 0.3.0.12 → 0.4.0.13

data/ext/nutcracker/src/nc_server.c

@@ -368,6 +368,10 @@ server_close(struct context *ctx, struct conn *conn)
             msg->error = 1;
             msg->err = conn->err;
 
+            if (msg->frag_owner != NULL) {
+                msg->frag_owner->nfrag_done++;
+            }
+
             if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
                 event_add_out(ctx->evb, msg->owner);
             }
@@ -397,6 +401,9 @@ server_close(struct context *ctx, struct conn *conn)
             msg->done = 1;
             msg->error = 1;
             msg->err = conn->err;
+            if (msg->frag_owner != NULL) {
+                msg->frag_owner->nfrag_done++;
+            }
 
             if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
                 event_add_out(ctx->evb, msg->owner);
@@ -464,7 +471,7 @@ server_connect(struct context *ctx, struct server *server, struct conn *conn)
     status = nc_set_nonblocking(conn->sd);
     if (status != NC_OK) {
         log_error("set nonblock on s %d for server '%.*s' failed: %s",
-                  conn->sd,  server->pname.len, server->pname.data,
+                  conn->sd, server->pname.len, server->pname.data,
                   strerror(errno));
         goto error;
     }
@@ -608,15 +615,33 @@ server_pool_hash(struct server_pool *pool, uint8_t *key, uint32_t keylen)
     return pool->key_hash((char *)key, keylen);
 }
 
-static struct server *
-server_pool_server(struct server_pool *pool, uint8_t *key, uint32_t keylen)
+uint32_t
+server_pool_idx(struct server_pool *pool, uint8_t *key, uint32_t keylen)
 {
-    struct server *server;
     uint32_t hash, idx;
 
     ASSERT(array_n(&pool->server) != 0);
     ASSERT(key != NULL && keylen != 0);
 
+    /*
+     * If hash_tag: is configured for this server pool, we use the part of
+     * the key within the hash tag as an input to the distributor. Otherwise
+     * we use the full key
+     */
+    if (!string_empty(&pool->hash_tag)) {
+        struct string *tag = &pool->hash_tag;
+        uint8_t *tag_start, *tag_end;
+
+        tag_start = nc_strchr(key, key + keylen, tag->data[0]);
+        if (tag_start != NULL) {
+            tag_end = nc_strchr(tag_start + 1, key + keylen, tag->data[1]);
+            if ((tag_end != NULL) && (tag_end - tag_start > 1)) {
+                key = tag_start + 1;
+                keylen = (uint32_t)(tag_end - key);
+            }
+        }
+    }
+
     switch (pool->dist_type) {
     case DIST_KETAMA:
         hash = server_pool_hash(pool, key, keylen);
@@ -634,10 +659,19 @@ server_pool_server(struct server_pool *pool, uint8_t *key, uint32_t keylen)
 
     default:
         NOT_REACHED();
-        return NULL;
+        return 0;
     }
     ASSERT(idx < array_n(&pool->server));
+    return idx;
+}
 
+static struct server *
+server_pool_server(struct server_pool *pool, uint8_t *key, uint32_t keylen)
+{
+    struct server *server;
+    uint32_t idx;
+
+    idx = server_pool_idx(pool, key, keylen);
     server = array_get(&pool->server, idx);
 
     log_debug(LOG_VERB, "key '%.*s' on dist %d maps to server '%.*s'", keylen,
@@ -742,6 +776,18 @@ server_pool_each_set_owner(void *elem, void *data)
     return NC_OK;
 }
 
+static rstatus_t
+server_pool_each_calc_connections(void *elem, void *data)
+{
+    struct server_pool *sp = elem;
+    struct context *ctx = data;
+
+    ctx->max_nsconn += sp->server_connections * array_n(&sp->server);
+    ctx->max_nsconn += 1; /* pool listening socket */
+
+    return NC_OK;
+}
+
 rstatus_t
 server_pool_run(struct server_pool *pool)
 {
@@ -802,6 +848,14 @@ server_pool_init(struct array *server_pool, struct array *conf_pool,
         return status;
     }
 
+    /* compute max server connections */
+    ctx->max_nsconn = 0;
+    status = array_each(server_pool, server_pool_each_calc_connections, ctx);
+    if (status != NC_OK) {
+        server_pool_deinit(server_pool);
+        return status;
+    }
+
     /* update server pool continuum */
     status = array_each(server_pool, server_pool_each_run, NULL);
     if (status != NC_OK) {

data/ext/nutcracker/src/nc_server.h

@@ -133,6 +133,7 @@ void server_close(struct context *ctx, struct conn *conn);
 void server_connected(struct context *ctx, struct conn *conn);
 void server_ok(struct context *ctx, struct conn *conn);
 
+uint32_t server_pool_idx(struct server_pool *pool, uint8_t *key, uint32_t keylen);
 struct conn *server_pool_conn(struct context *ctx, struct server_pool *pool, uint8_t *key, uint32_t keylen);
 rstatus_t server_pool_run(struct server_pool *pool);
 rstatus_t server_pool_preconnect(struct context *ctx);

data/ext/nutcracker/src/nc_signal.c

@@ -110,7 +110,7 @@ signal_handler(int signo)
         break;
 
     case SIGSEGV:
-        nc_stacktrace(1);
+        log_stacktrace();
         actionstr = ", core dumping";
         raise(SIGSEGV);
         break;
@@ -119,7 +119,7 @@ signal_handler(int signo)
         NOT_REACHED();
     }
 
-    loga("signal %d (%s) received%s", signo, sig->signame, actionstr);
+    log_safe("signal %d (%s) received%s", signo, sig->signame, actionstr);
 
     if (action != NULL) {
         action();

data/ext/nutcracker/src/nc_stats.c

@@ -361,6 +361,14 @@ stats_create_buf(struct stats *st)
     size += int64_max_digits;
     size += key_value_extra;
 
+    size += st->ntotal_conn_str.len;
+    size += int64_max_digits;
+    size += key_value_extra;
+
+    size += st->ncurr_conn_str.len;
+    size += int64_max_digits;
+    size += key_value_extra;
+
     /* server pools */
     for (i = 0; i < array_n(&st->sum); i++) {
         struct stats_pool *stp = array_get(&st->sum, i);
@@ -508,6 +516,16 @@ stats_add_header(struct stats *st)
         return status;
     }
 
+    status = stats_add_num(st, &st->ntotal_conn_str, conn_ntotal_conn());
+    if (status != NC_OK) {
+        return status;
+    }
+
+    status = stats_add_num(st, &st->ncurr_conn_str, conn_ncurr_conn());
+    if (status != NC_OK) {
+        return status;
+    }
+
     return NC_OK;
 }
 
@@ -909,6 +927,9 @@ stats_create(uint16_t stats_port, char *stats_ip, int stats_interval,
     string_set_text(&st->uptime_str, "uptime");
     string_set_text(&st->timestamp_str, "timestamp");
 
+    string_set_text(&st->ntotal_conn_str, "total_connections");
+    string_set_text(&st->ncurr_conn_str, "curr_connections");
+
     st->updated = 0;
     st->aggregate = 0;
 

data/ext/nutcracker/src/nc_stats.h

@@ -41,7 +41,7 @@
     /* data behavior */                                                                                             \
     ACTION( requests,               STATS_COUNTER,      "# requests")                                               \
     ACTION( request_bytes,          STATS_COUNTER,      "total request bytes")                                      \
-    ACTION( responses,              STATS_COUNTER,      "# respones")                                               \
+    ACTION( responses,              STATS_COUNTER,      "# responses")                                              \
     ACTION( response_bytes,         STATS_COUNTER,      "total response bytes")                                     \
     ACTION( in_queue,               STATS_GAUGE,        "# requests in incoming queue")                             \
     ACTION( in_queue_bytes,         STATS_GAUGE,        "current request bytes in incoming queue")                  \
@@ -87,31 +87,33 @@ struct stats_buffer {
 };
 
 struct stats {
-    uint16_t            port;           /* stats monitoring port */
-    int                 interval;       /* stats aggregation interval */
-    struct string       addr;           /* stats monitoring address */
-
-    int64_t             start_ts;       /* start timestamp of nutcracker */
-    struct stats_buffer buf;            /* output buffer */
-
-    struct array        current;        /* stats_pool[] (a) */
-    struct array        shadow;         /* stats_pool[] (b) */
-    struct array        sum;            /* stats_pool[] (c = a + b) */
-
-    pthread_t           tid;            /* stats aggregator thread */
-    int                 sd;             /* stats descriptor */
-
-    struct string       service_str;    /* service string */
-    struct string       service;        /* service */
-    struct string       source_str;     /* source string */
-    struct string       source;         /* source */
-    struct string       version_str;    /* version string */
-    struct string       version;        /* version */
-    struct string       uptime_str;     /* uptime string */
-    struct string       timestamp_str;  /* timestamp string */
-
-    volatile int        aggregate;      /* shadow (b) aggregate? */
-    volatile int        updated;        /* current (a) updated? */
+    uint16_t            port;            /* stats monitoring port */
+    int                 interval;        /* stats aggregation interval */
+    struct string       addr;            /* stats monitoring address */
+
+    int64_t             start_ts;        /* start timestamp of nutcracker */
+    struct stats_buffer buf;             /* output buffer */
+
+    struct array        current;         /* stats_pool[] (a) */
+    struct array        shadow;          /* stats_pool[] (b) */
+    struct array        sum;             /* stats_pool[] (c = a + b) */
+
+    pthread_t           tid;             /* stats aggregator thread */
+    int                 sd;              /* stats descriptor */
+
+    struct string       service_str;     /* service string */
+    struct string       service;         /* service */
+    struct string       source_str;      /* source string */
+    struct string       source;          /* source */
+    struct string       version_str;     /* version string */
+    struct string       version;         /* version */
+    struct string       uptime_str;      /* uptime string */
+    struct string       timestamp_str;   /* timestamp string */
+    struct string       ntotal_conn_str; /* total connections string */
+    struct string       ncurr_conn_str;  /* curr connections string */
+
+    volatile int        aggregate;       /* shadow (b) aggregate? */
+    volatile int        updated;         /* current (a) updated? */
 };
 
 #define DEFINE_ACTION(_name, _type, _desc) STATS_POOL_##_name,

data/ext/nutcracker/src/nc_string.c

@@ -102,8 +102,183 @@ int
 string_compare(const struct string *s1, const struct string *s2)
 {
     if (s1->len != s2->len) {
-        return s1->len - s2->len > 0 ? 1 : -1;
+        return s1->len > s2->len ? 1 : -1;
     }
 
     return nc_strncmp(s1->data, s2->data, s1->len);
 }
+
+static char *
+_safe_utoa(int _base, uint64_t val, char *buf)
+{
+    char hex[] = "0123456789abcdef";
+    uint32_t base = (uint32_t) _base;
+    *buf-- = 0;
+    do {
+        *buf-- = hex[val % base];
+    } while ((val /= base) != 0);
+    return buf + 1;
+}
+
+static char *
+_safe_itoa(int base, int64_t val, char *buf)
+{
+    char hex[] = "0123456789abcdef";
+    char *orig_buf = buf;
+    const int32_t is_neg = (val < 0);
+    *buf-- = 0;
+
+    if (is_neg) {
+        val = -val;
+    }
+    if (is_neg && base == 16) {
+        int ix;
+        val -= 1;
+        for (ix = 0; ix < 16; ++ix)
+            buf[-ix] = '0';
+    }
+
+    do {
+        *buf-- = hex[val % base];
+    } while ((val /= base) != 0);
+
+    if (is_neg && base == 10) {
+        *buf-- = '-';
+    }
+
+    if (is_neg && base == 16) {
+        int ix;
+        buf = orig_buf - 1;
+        for (ix = 0; ix < 16; ++ix, --buf) {
+            /* *INDENT-OFF* */
+            switch (*buf) {
+            case '0': *buf = 'f'; break;
+            case '1': *buf = 'e'; break;
+            case '2': *buf = 'd'; break;
+            case '3': *buf = 'c'; break;
+            case '4': *buf = 'b'; break;
+            case '5': *buf = 'a'; break;
+            case '6': *buf = '9'; break;
+            case '7': *buf = '8'; break;
+            case '8': *buf = '7'; break;
+            case '9': *buf = '6'; break;
+            case 'a': *buf = '5'; break;
+            case 'b': *buf = '4'; break;
+            case 'c': *buf = '3'; break;
+            case 'd': *buf = '2'; break;
+            case 'e': *buf = '1'; break;
+            case 'f': *buf = '0'; break;
+            }
+            /* *INDENT-ON* */
+        }
+    }
+    return buf + 1;
+}
+
+static const char *
+_safe_check_longlong(const char *fmt, int32_t * have_longlong)
+{
+    *have_longlong = false;
+    if (*fmt == 'l') {
+        fmt++;
+        if (*fmt != 'l') {
+            *have_longlong = (sizeof(long) == sizeof(int64_t));
+        } else {
+            fmt++;
+            *have_longlong = true;
+        }
+    }
+    return fmt;
+}
+
+int
+_safe_vsnprintf(char *to, size_t size, const char *format, va_list ap)
+{
+    char *start = to;
+    char *end = start + size - 1;
+    for (; *format; ++format) {
+        int32_t have_longlong = false;
+        if (*format != '%') {
+            if (to == end) {    /* end of buffer */
+                break;
+            }
+            *to++ = *format;    /* copy ordinary char */
+            continue;
+        }
+        ++format;               /* skip '%' */
+
+        format = _safe_check_longlong(format, &have_longlong);
+
+        switch (*format) {
+        case 'd':
+        case 'i':
+        case 'u':
+        case 'x':
+        case 'p':
+            {
+                int64_t ival = 0;
+                uint64_t uval = 0;
+                if (*format == 'p')
+                    have_longlong = (sizeof(void *) == sizeof(uint64_t));
+                if (have_longlong) {
+                    if (*format == 'u') {
+                        uval = va_arg(ap, uint64_t);
+                    } else {
+                        ival = va_arg(ap, int64_t);
+                    }
+                } else {
+                    if (*format == 'u') {
+                        uval = va_arg(ap, uint32_t);
+                    } else {
+                        ival = va_arg(ap, int32_t);
+                    }
+                }
+
+                {
+                    char buff[22];
+                    const int base = (*format == 'x' || *format == 'p') ? 16 : 10;
+
+		            /* *INDENT-OFF* */
+                    char *val_as_str = (*format == 'u') ?
+                        _safe_utoa(base, uval, &buff[sizeof(buff) - 1]) :
+                        _safe_itoa(base, ival, &buff[sizeof(buff) - 1]);
+		            /* *INDENT-ON* */
+
+                    /* Strip off "ffffffff" if we have 'x' format without 'll' */
+                    if (*format == 'x' && !have_longlong && ival < 0) {
+                        val_as_str += 8;
+                    }
+
+                    while (*val_as_str && to < end) {
+                        *to++ = *val_as_str++;
+                    }
+                    continue;
+                }
+            }
+        case 's':
+            {
+                const char *val = va_arg(ap, char *);
+                if (!val) {
+                    val = "(null)";
+                }
+                while (*val && to < end) {
+                    *to++ = *val++;
+                }
+                continue;
+            }
+        }
+    }
+    *to = 0;
+    return (int)(to - start);
+}
+
+int
+_safe_snprintf(char *to, size_t n, const char *fmt, ...)
+{
+    int result;
+    va_list args;
+    va_start(args, fmt);
+    result = _safe_vsnprintf(to, n, fmt, args);
+    va_end(args);
+    return result;
+}

data/ext/nutcracker/src/nc_string.h

@@ -19,6 +19,9 @@
 #define _NC_STRING_H_
 
 #include <string.h>
+#include <sys/types.h>
+#include <stdarg.h>
+
 #include <nc_core.h>
 
 struct string {
@@ -83,6 +86,29 @@ int string_compare(const struct string *s1, const struct string *s2);
 #define nc_vscnprintf(_s, _n, _f, _a)   \
     _vscnprintf((char *)(_s), (size_t)(_n), _f, _a)
 
+#define nc_strftime(_s, _n, fmt, tm)        \
+    (int)strftime((char *)(_s), (size_t)(_n), fmt, tm)
+
+/*
+ * A (very) limited version of snprintf
+ * @param   to   Destination buffer
+ * @param   n    Size of destination buffer
+ * @param   fmt  printf() style format string
+ * @returns Number of bytes written, including terminating '\0'
+ * Supports 'd' 'i' 'u' 'x' 'p' 's' conversion
+ * Supports 'l' and 'll' modifiers for integral types
+ * Does not support any width/precision
+ * Implemented with simplicity, and async-signal-safety in mind
+ */
+int _safe_vsnprintf(char *to, size_t size, const char *format, va_list ap);
+int _safe_snprintf(char *to, size_t n, const char *fmt, ...);
+
+#define nc_safe_snprintf(_s, _n, ...)       \
+    _safe_snprintf((char *)(_s), (size_t)(_n), __VA_ARGS__)
+
+#define nc_safe_vsnprintf(_s, _n, _f, _a)   \
+    _safe_vsnprintf((char *)(_s), (size_t)(_n), _f, _a)
+
 static inline uint8_t *
 _nc_strchr(uint8_t *p, uint8_t *last, uint8_t c)
 {