nutcracker 0.2.3

data/ext/nutcracker/src/nc_array.c

@@ -0,0 +1,204 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+
+#include <nc_core.h>
+
+struct array *
+array_create(uint32_t n, size_t size)
+{
+    struct array *a;
+
+    ASSERT(n != 0 && size != 0);
+
+    a = nc_alloc(sizeof(*a));
+    if (a == NULL) {
+        return NULL;
+    }
+
+    a->elem = nc_alloc(n * size);
+    if (a->elem == NULL) {
+        nc_free(a);
+        return NULL;
+    }
+
+    a->nelem = 0;
+    a->size = size;
+    a->nalloc = n;
+
+    return a;
+}
+
+void
+array_destroy(struct array *a)
+{
+    array_deinit(a);
+    nc_free(a);
+}
+
+rstatus_t
+array_init(struct array *a, uint32_t n, size_t size)
+{
+    ASSERT(n != 0 && size != 0);
+
+    a->elem = nc_alloc(n * size);
+    if (a->elem == NULL) {
+        return NC_ENOMEM;
+    }
+
+    a->nelem = 0;
+    a->size = size;
+    a->nalloc = n;
+
+    return NC_OK;
+}
+
+void
+array_deinit(struct array *a)
+{
+    ASSERT(a->nelem == 0);
+
+    if (a->elem != NULL) {
+        nc_free(a->elem);
+    }
+}
+
+uint32_t
+array_idx(struct array *a, void *elem)
+{
+    uint8_t *p, *q;
+    uint32_t off, idx;
+
+    ASSERT(elem >= a->elem);
+
+    p = a->elem;
+    q = elem;
+    off = (uint32_t)(q - p);
+
+    ASSERT(off % (uint32_t)a->size == 0);
+
+    idx = off / (uint32_t)a->size;
+
+    return idx;
+}
+
+void *
+array_push(struct array *a)
+{
+    void *elem, *new;
+    size_t size;
+
+    if (a->nelem == a->nalloc) {
+
+        /* the array is full; allocate new array */
+        size = a->size * a->nalloc;
+        new = nc_realloc(a->elem, 2 * size);
+        if (new == NULL) {
+            return NULL;
+        }
+
+        a->elem = new;
+        a->nalloc *= 2;
+    }
+
+    elem = (uint8_t *)a->elem + a->size * a->nelem;
+    a->nelem++;
+
+    return elem;
+}
+
+void *
+array_pop(struct array *a)
+{
+    void *elem;
+
+    ASSERT(a->nelem != 0);
+
+    a->nelem--;
+    elem = (uint8_t *)a->elem + a->size * a->nelem;
+
+    return elem;
+}
+
+void *
+array_get(struct array *a, uint32_t idx)
+{
+    void *elem;
+
+    ASSERT(a->nelem != 0);
+    ASSERT(idx < a->nelem);
+
+    elem = (uint8_t *)a->elem + (a->size * idx);
+
+    return elem;
+}
+
+void *
+array_top(struct array *a)
+{
+    ASSERT(a->nelem != 0);
+
+    return array_get(a, a->nelem - 1);
+}
+
+void
+array_swap(struct array *a, struct array *b)
+{
+    struct array tmp;
+
+    tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+/*
+ * Sort nelem elements of the array in ascending order based on the
+ * compare comparator.
+ */
+void
+array_sort(struct array *a, array_compare_t compare)
+{
+    ASSERT(a->nelem != 0);
+
+    qsort(a->elem, a->nelem, a->size, compare);
+}
+
+/*
+ * Calls the func once for each element in the array as long as func returns
+ * success. On failure short-circuits and returns the error status.
+ */
+rstatus_t
+array_each(struct array *a, array_each_t func, void *data)
+{
+    uint32_t i, nelem;
+
+    ASSERT(array_n(a) != 0);
+    ASSERT(func != NULL);
+
+    for (i = 0, nelem = array_n(a); i < nelem; i++) {
+        void *elem = array_get(a, i);
+        rstatus_t status;
+
+        status = func(elem, data);
+        if (status != NC_OK) {
+            return status;
+        }
+    }
+
+    return NC_OK;
+}

data/ext/nutcracker/src/nc_array.h

@@ -0,0 +1,73 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _NC_ARRAY_H_
+#define _NC_ARRAY_H_
+
+#include <nc_core.h>
+
+typedef int (*array_compare_t)(const void *, const void *);
+typedef rstatus_t (*array_each_t)(void *, void *);
+
+struct array {
+    uint32_t nelem;  /* # element */
+    void     *elem;  /* element */
+    size_t   size;   /* element size */
+    uint32_t nalloc; /* # allocated element */
+};
+
+#define null_array { 0, NULL, 0, 0 }
+
+static inline void
+array_null(struct array *a)
+{
+    a->nelem = 0;
+    a->elem = NULL;
+    a->size = 0;
+    a->nalloc = 0;
+}
+
+static inline void
+array_set(struct array *a, void *elem, size_t size, uint32_t nalloc)
+{
+    a->nelem = 0;
+    a->elem = elem;
+    a->size = size;
+    a->nalloc = nalloc;
+}
+
+static inline uint32_t
+array_n(const struct array *a)
+{
+    return a->nelem;
+}
+
+struct array *array_create(uint32_t n, size_t size);
+void array_destroy(struct array *a);
+rstatus_t array_init(struct array *a, uint32_t n, size_t size);
+void array_deinit(struct array *a);
+
+uint32_t array_idx(struct array *a, void *elem);
+void *array_push(struct array *a);
+void *array_pop(struct array *a);
+void *array_get(struct array *a, uint32_t idx);
+void *array_top(struct array *a);
+void array_swap(struct array *a, struct array *b);
+void array_sort(struct array *a, array_compare_t compare);
+rstatus_t array_each(struct array *a, array_each_t func, void *data);
+
+#endif

data/ext/nutcracker/src/nc_client.c

@@ -0,0 +1,189 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <nc_core.h>
+#include <nc_server.h>
+#include <nc_client.h>
+
+void
+client_ref(struct conn *conn, void *owner)
+{
+    struct server_pool *pool = owner;
+
+    ASSERT(conn->client && !conn->proxy);
+    ASSERT(conn->owner == NULL);
+
+    /*
+     * We use null pointer as the sockaddr argument in the accept() call as
+     * we are not interested in the address of the peer for the accepted
+     * connection
+     */
+    conn->family = 0;
+    conn->addrlen = 0;
+    conn->addr = NULL;
+
+    pool->nc_conn_q++;
+    TAILQ_INSERT_TAIL(&pool->c_conn_q, conn, conn_tqe);
+
+    /* owner of the client connection is the server pool */
+    conn->owner = owner;
+
+    log_debug(LOG_VVERB, "ref conn %p owner %p into pool '%.*s'", conn, pool,
+              pool->name.len, pool->name.data);
+}
+
+void
+client_unref(struct conn *conn)
+{
+    struct server_pool *pool;
+
+    ASSERT(conn->client && !conn->proxy);
+    ASSERT(conn->owner != NULL);
+
+    pool = conn->owner;
+    conn->owner = NULL;
+
+    ASSERT(pool->nc_conn_q != 0);
+    pool->nc_conn_q--;
+    TAILQ_REMOVE(&pool->c_conn_q, conn, conn_tqe);
+
+    log_debug(LOG_VVERB, "unref conn %p owner %p from pool '%.*s'", conn,
+              pool, pool->name.len, pool->name.data);
+}
+
+bool
+client_active(struct conn *conn)
+{
+    ASSERT(conn->client && !conn->proxy);
+
+    ASSERT(TAILQ_EMPTY(&conn->imsg_q));
+
+    if (!TAILQ_EMPTY(&conn->omsg_q)) {
+        log_debug(LOG_VVERB, "c %d is active", conn->sd);
+        return true;
+    }
+
+    if (conn->rmsg != NULL) {
+        log_debug(LOG_VVERB, "c %d is active", conn->sd);
+        return true;
+    }
+
+    if (conn->smsg != NULL) {
+        log_debug(LOG_VVERB, "c %d is active", conn->sd);
+        return true;
+    }
+
+    log_debug(LOG_VVERB, "c %d is inactive", conn->sd);
+
+    return false;
+}
+
+static void
+client_close_stats(struct context *ctx, struct server_pool *pool, err_t err,
+                   unsigned eof)
+{
+    stats_pool_decr(ctx, pool, client_connections);
+
+    if (eof) {
+        stats_pool_incr(ctx, pool, client_eof);
+        return;
+    }
+
+    switch (err) {
+    case EPIPE:
+    case ETIMEDOUT:
+    case ECONNRESET:
+    case ECONNABORTED:
+    case ENOTCONN:
+    case ENETDOWN:
+    case ENETUNREACH:
+    case EHOSTDOWN:
+    case EHOSTUNREACH:
+    default:
+        stats_pool_incr(ctx, pool, client_err);
+        break;
+    }
+}
+
+void
+client_close(struct context *ctx, struct conn *conn)
+{
+    rstatus_t status;
+    struct msg *msg, *nmsg; /* current and next message */
+
+    ASSERT(conn->client && !conn->proxy);
+
+    client_close_stats(ctx, conn->owner, conn->err, conn->eof);
+
+    if (conn->sd < 0) {
+        conn->unref(conn);
+        conn_put(conn);
+        return;
+    }
+
+    msg = conn->rmsg;
+    if (msg != NULL) {
+        conn->rmsg = NULL;
+
+        ASSERT(msg->peer == NULL);
+        ASSERT(msg->request && !msg->done);
+
+        log_debug(LOG_INFO, "close c %d discarding pending req %"PRIu64" len "
+                  "%"PRIu32" type %d", conn->sd, msg->id, msg->mlen,
+                  msg->type);
+
+        req_put(msg);
+    }
+
+    ASSERT(conn->smsg == NULL);
+    ASSERT(TAILQ_EMPTY(&conn->imsg_q));
+
+    for (msg = TAILQ_FIRST(&conn->omsg_q); msg != NULL; msg = nmsg) {
+        nmsg = TAILQ_NEXT(msg, c_tqe);
+
+        /* dequeue the message (request) from client outq */
+        conn->dequeue_outq(ctx, conn, msg);
+
+        if (msg->done) {
+            log_debug(LOG_INFO, "close c %d discarding %s req %"PRIu64" len "
+                      "%"PRIu32" type %d", conn->sd,
+                      msg->error ? "error": "completed", msg->id, msg->mlen,
+                      msg->type);
+            req_put(msg);
+        } else {
+            msg->swallow = 1;
+
+            ASSERT(msg->request);
+            ASSERT(msg->peer == NULL);
+
+            log_debug(LOG_INFO, "close c %d schedule swallow of req %"PRIu64" "
+                      "len %"PRIu32" type %d", conn->sd, msg->id, msg->mlen,
+                      msg->type);
+        }
+    }
+    ASSERT(TAILQ_EMPTY(&conn->omsg_q));
+
+    conn->unref(conn);
+
+    status = close(conn->sd);
+    if (status < 0) {
+        log_error("close c %d failed, ignored: %s", conn->sd, strerror(errno));
+    }
+    conn->sd = -1;
+
+    conn_put(conn);
+}