nutcracker 0.2.3

data/ext/nutcracker/src/nc_response.c

@@ -0,0 +1,332 @@
+/*
+ * 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_event.h>
+
+struct msg *
+rsp_get(struct conn *conn)
+{
+    struct msg *msg;
+
+    ASSERT(!conn->client && !conn->proxy);
+
+    msg = msg_get(conn, false, conn->redis);
+    if (msg == NULL) {
+        conn->err = errno;
+    }
+
+    return msg;
+}
+
+void
+rsp_put(struct msg *msg)
+{
+    ASSERT(!msg->request);
+    ASSERT(msg->peer == NULL);
+    msg_put(msg);
+}
+
+static struct msg *
+rsp_make_error(struct context *ctx, struct conn *conn, struct msg *msg)
+{
+    struct msg *pmsg;        /* peer message (response) */
+    struct msg *cmsg, *nmsg; /* current and next message (request) */
+    uint64_t id;
+    err_t err;
+
+    ASSERT(conn->client && !conn->proxy);
+    ASSERT(msg->request && req_error(conn, msg));
+    ASSERT(msg->owner == conn);
+
+    id = msg->frag_id;
+    if (id != 0) {
+        for (err = 0, cmsg = TAILQ_NEXT(msg, c_tqe);
+             cmsg != NULL && cmsg->frag_id == id;
+             cmsg = nmsg) {
+            nmsg = TAILQ_NEXT(cmsg, c_tqe);
+
+            /* dequeue request (error fragment) from client outq */
+            conn->dequeue_outq(ctx, conn, cmsg);
+            if (err == 0 && cmsg->err != 0) {
+                err = cmsg->err;
+            }
+
+            req_put(cmsg);
+        }
+    } else {
+        err = msg->err;
+    }
+
+    pmsg = msg->peer;
+    if (pmsg != NULL) {
+        ASSERT(!pmsg->request && pmsg->peer == msg);
+        msg->peer = NULL;
+        pmsg->peer = NULL;
+        rsp_put(pmsg);
+    }
+
+    return msg_get_error(conn->redis, err);
+}
+
+struct msg *
+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;
+
+        /* server sent eof before sending the entire request */
+        if (msg != NULL) {
+            conn->rmsg = NULL;
+
+            ASSERT(msg->peer == NULL);
+            ASSERT(!msg->request);
+
+            log_error("eof s %d discarding incomplete rsp %"PRIu64" len "
+                      "%"PRIu32"", conn->sd, msg->id, msg->mlen);
+
+            rsp_put(msg);
+        }
+
+        /*
+         * We treat TCP half-close from a server different from how we treat
+         * those from a client. On a FIN from a server, we close the connection
+         * immediately by sending the second FIN even if there were outstanding
+         * or pending requests. This is actually a tricky part in the FA, as
+         * we don't expect this to happen unless the server is misbehaving or
+         * it crashes
+         */
+        conn->done = 1;
+        log_error("s %d active %d is done", conn->sd, conn->active(conn));
+
+        return NULL;
+    }
+
+    msg = conn->rmsg;
+    if (msg != NULL) {
+        ASSERT(!msg->request);
+        return msg;
+    }
+
+    if (!alloc) {
+        return NULL;
+    }
+
+    msg = rsp_get(conn);
+    if (msg != NULL) {
+        conn->rmsg = msg;
+    }
+
+    return msg;
+}
+
+static bool
+rsp_filter(struct context *ctx, struct conn *conn, struct msg *msg)
+{
+    struct msg *pmsg;
+
+    ASSERT(!conn->client && !conn->proxy);
+
+    if (msg_empty(msg)) {
+        ASSERT(conn->rmsg == NULL);
+        log_debug(LOG_VERB, "filter empty rsp %"PRIu64" on s %d", msg->id,
+                  conn->sd);
+        rsp_put(msg);
+        return true;
+    }
+
+    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);
+        rsp_put(msg);
+        errno = EINVAL;
+        conn->err = errno;
+        return true;
+    }
+    ASSERT(pmsg->peer == NULL);
+    ASSERT(pmsg->request && !pmsg->done);
+
+    if (pmsg->swallow) {
+        conn->dequeue_outq(ctx, conn, pmsg);
+        pmsg->done = 1;
+
+        log_debug(LOG_INFO, "swallow rsp %"PRIu64" len %"PRIu32" of req "
+                  "%"PRIu64" on s %d", msg->id, msg->mlen, pmsg->id,
+                  conn->sd);
+
+        rsp_put(msg);
+        req_put(pmsg);
+        return true;
+    }
+
+    return false;
+}
+
+static void
+rsp_forward_stats(struct context *ctx, struct server *server, struct msg *msg)
+{
+    ASSERT(!msg->request);
+
+    stats_server_incr(ctx, server, responses);
+    stats_server_incr_by(ctx, server, response_bytes, msg->mlen);
+}
+
+static void
+rsp_forward(struct context *ctx, struct conn *s_conn, struct msg *msg)
+{
+    rstatus_t status;
+    struct msg *pmsg;
+    struct conn *c_conn;
+
+    ASSERT(!s_conn->client && !s_conn->proxy);
+
+    /* response from server implies that server is ok and heartbeating */
+    server_ok(ctx, s_conn);
+
+    /* dequeue peer message (request) from server */
+    pmsg = TAILQ_FIRST(&s_conn->omsg_q);
+    ASSERT(pmsg != NULL && pmsg->peer == NULL);
+    ASSERT(pmsg->request && !pmsg->done);
+
+    s_conn->dequeue_outq(ctx, s_conn, pmsg);
+    pmsg->done = 1;
+
+    /* establish msg <-> pmsg (response <-> request) link */
+    pmsg->peer = msg;
+    msg->peer = pmsg;
+
+    msg->pre_coalesce(msg);
+
+    c_conn = pmsg->owner;
+    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);
+        if (status != NC_OK) {
+            c_conn->err = errno;
+        }
+    }
+
+    rsp_forward_stats(ctx, s_conn->owner, msg);
+}
+
+void
+rsp_recv_done(struct context *ctx, struct conn *conn, struct msg *msg,
+              struct msg *nmsg)
+{
+    ASSERT(!conn->client && !conn->proxy);
+    ASSERT(msg != NULL && conn->rmsg == msg);
+    ASSERT(!msg->request);
+    ASSERT(msg->owner == conn);
+    ASSERT(nmsg == NULL || !nmsg->request);
+
+    /* enqueue next message (response), if any */
+    conn->rmsg = nmsg;
+
+    if (rsp_filter(ctx, conn, msg)) {
+        return;
+    }
+
+    rsp_forward(ctx, conn, msg);
+}
+
+struct msg *
+rsp_send_next(struct context *ctx, struct conn *conn)
+{
+    rstatus_t status;
+    struct msg *msg, *pmsg; /* response and it's peer request */
+
+    ASSERT(conn->client && !conn->proxy);
+
+    pmsg = TAILQ_FIRST(&conn->omsg_q);
+    if (pmsg == NULL || !req_done(conn, pmsg)) {
+        /* nothing is outstanding, initiate close? */
+        if (pmsg == NULL && conn->eof) {
+            conn->done = 1;
+            log_debug(LOG_INFO, "c %d is done", conn->sd);
+        }
+
+        status = event_del_out(ctx->ep, conn);
+        if (status != NC_OK) {
+            conn->err = errno;
+        }
+
+        return NULL;
+    }
+
+    msg = conn->smsg;
+    if (msg != NULL) {
+        ASSERT(!msg->request && msg->peer != NULL);
+        ASSERT(req_done(conn, msg->peer));
+        pmsg = TAILQ_NEXT(msg->peer, c_tqe);
+    }
+
+    if (pmsg == NULL || !req_done(conn, pmsg)) {
+        conn->smsg = NULL;
+        return NULL;
+    }
+    ASSERT(pmsg->request && !pmsg->swallow);
+
+    if (req_error(conn, pmsg)) {
+        msg = rsp_make_error(ctx, conn, pmsg);
+        if (msg == NULL) {
+            conn->err = errno;
+            return NULL;
+        }
+        msg->peer = pmsg;
+        pmsg->peer = msg;
+        stats_pool_incr(ctx, conn->owner, forward_error);
+    } else {
+        msg = pmsg->peer;
+    }
+    ASSERT(!msg->request);
+
+    conn->smsg = msg;
+
+    log_debug(LOG_VVERB, "send next rsp %"PRIu64" on c %d", msg->id, conn->sd);
+
+    return msg;
+}
+
+void
+rsp_send_done(struct context *ctx, struct conn *conn, struct msg *msg)
+{
+    struct msg *pmsg; /* peer message (request) */
+
+    ASSERT(conn->client && !conn->proxy);
+    ASSERT(conn->smsg == NULL);
+
+    log_debug(LOG_VVERB, "send done rsp %"PRIu64" on c %d", msg->id, conn->sd);
+
+    pmsg = msg->peer;
+
+    ASSERT(!msg->request && pmsg->request);
+    ASSERT(pmsg->peer == msg);
+    ASSERT(pmsg->done && !pmsg->swallow);
+
+    /* dequeue request from client outq */
+    conn->dequeue_outq(ctx, conn, pmsg);
+
+    req_put(pmsg);
+}

data/ext/nutcracker/src/nc_server.c

@@ -0,0 +1,841 @@
+/*
+ * 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 <unistd.h>
+
+#include <nc_core.h>
+#include <nc_event.h>
+#include <nc_server.h>
+#include <nc_conf.h>
+
+void
+server_ref(struct conn *conn, void *owner)
+{
+    struct server *server = owner;
+
+    ASSERT(!conn->client && !conn->proxy);
+    ASSERT(conn->owner == NULL);
+
+    conn->family = server->family;
+    conn->addrlen = server->addrlen;
+    conn->addr = server->addr;
+
+    server->ns_conn_q++;
+    TAILQ_INSERT_TAIL(&server->s_conn_q, conn, conn_tqe);
+
+    conn->owner = owner;
+
+    log_debug(LOG_VVERB, "ref conn %p owner %p into '%.*s", conn, server,
+              server->pname.len, server->pname.data);
+}
+
+void
+server_unref(struct conn *conn)
+{
+    struct server *server;
+
+    ASSERT(!conn->client && !conn->proxy);
+    ASSERT(conn->owner != NULL);
+
+    server = conn->owner;
+    conn->owner = NULL;
+
+    ASSERT(server->ns_conn_q != 0);
+    server->ns_conn_q--;
+    TAILQ_REMOVE(&server->s_conn_q, conn, conn_tqe);
+
+    log_debug(LOG_VVERB, "unref conn %p owner %p from '%.*s'", conn, server,
+              server->pname.len, server->pname.data);
+}
+
+int
+server_timeout(struct conn *conn)
+{
+    struct server *server;
+    struct server_pool *pool;
+
+    ASSERT(!conn->client && !conn->proxy);
+
+    server = conn->owner;
+    pool = server->owner;
+
+    return pool->timeout;
+}
+
+bool
+server_active(struct conn *conn)
+{
+    ASSERT(!conn->client && !conn->proxy);
+
+    if (!TAILQ_EMPTY(&conn->imsg_q)) {
+        log_debug(LOG_VVERB, "s %d is active", conn->sd);
+        return true;
+    }
+
+    if (!TAILQ_EMPTY(&conn->omsg_q)) {
+        log_debug(LOG_VVERB, "s %d is active", conn->sd);
+        return true;
+    }
+
+    if (conn->rmsg != NULL) {
+        log_debug(LOG_VVERB, "s %d is active", conn->sd);
+        return true;
+    }
+
+    if (conn->smsg != NULL) {
+        log_debug(LOG_VVERB, "s %d is active", conn->sd);
+        return true;
+    }
+
+    log_debug(LOG_VVERB, "s %d is inactive", conn->sd);
+
+    return false;
+}
+
+static rstatus_t
+server_each_set_owner(void *elem, void *data)
+{
+    struct server *s = elem;
+    struct server_pool *sp = data;
+
+    s->owner = sp;
+
+    return NC_OK;
+}
+
+rstatus_t
+server_init(struct array *server, struct array *conf_server,
+            struct server_pool *sp)
+{
+    rstatus_t status;
+    uint32_t nserver;
+
+    nserver = array_n(conf_server);
+    ASSERT(nserver != 0);
+    ASSERT(array_n(server) == 0);
+
+    status = array_init(server, nserver, sizeof(struct server));
+    if (status != NC_OK) {
+        return status;
+    }
+
+    /* transform conf server to server */
+    status = array_each(conf_server, conf_server_each_transform, server);
+    if (status != NC_OK) {
+        server_deinit(server);
+        return status;
+    }
+    ASSERT(array_n(server) == nserver);
+
+    /* set server owner */
+    status = array_each(server, server_each_set_owner, sp);
+    if (status != NC_OK) {
+        server_deinit(server);
+        return status;
+    }
+
+    log_debug(LOG_DEBUG, "init %"PRIu32" servers in pool %"PRIu32" '%.*s'",
+              nserver, sp->idx, sp->name.len, sp->name.data);
+
+    return NC_OK;
+}
+
+void
+server_deinit(struct array *server)
+{
+    uint32_t i, nserver;
+
+    for (i = 0, nserver = array_n(server); i < nserver; i++) {
+        struct server *s;
+
+        s = array_pop(server);
+        ASSERT(TAILQ_EMPTY(&s->s_conn_q) && s->ns_conn_q == 0);
+    }
+    array_deinit(server);
+}
+
+struct conn *
+server_conn(struct server *server)
+{
+    struct server_pool *pool;
+    struct conn *conn;
+
+    pool = server->owner;
+
+    /*
+     * FIXME: handle multiple server connections per server and do load
+     * balancing on it. Support multiple algorithms for
+     * 'server_connections:' > 0 key
+     */
+
+    if (server->ns_conn_q < pool->server_connections) {
+        return conn_get(server, false, pool->redis);
+    }
+    ASSERT(server->ns_conn_q == pool->server_connections);
+
+    /*
+     * Pick a server connection from the head of the queue and insert
+     * it back into the tail of queue to maintain the lru order
+     */
+    conn = TAILQ_FIRST(&server->s_conn_q);
+    ASSERT(!conn->client && !conn->proxy);
+
+    TAILQ_REMOVE(&server->s_conn_q, conn, conn_tqe);
+    TAILQ_INSERT_TAIL(&server->s_conn_q, conn, conn_tqe);
+
+    return conn;
+}
+
+static rstatus_t
+server_each_preconnect(void *elem, void *data)
+{
+    rstatus_t status;
+    struct server *server;
+    struct server_pool *pool;
+    struct conn *conn;
+
+    server = elem;
+    pool = server->owner;
+
+    conn = server_conn(server);
+    if (conn == NULL) {
+        return NC_ENOMEM;
+    }
+
+    status = server_connect(pool->ctx, server, conn);
+    if (status != NC_OK) {
+        log_warn("connect to server '%.*s' failed, ignored: %s",
+                 server->pname.len, server->pname.data, strerror(errno));
+        server_close(pool->ctx, conn);
+    }
+
+    return NC_OK;
+}
+
+static rstatus_t
+server_each_disconnect(void *elem, void *data)
+{
+    struct server *server;
+    struct server_pool *pool;
+
+    server = elem;
+    pool = server->owner;
+
+    while (!TAILQ_EMPTY(&server->s_conn_q)) {
+        struct conn *conn;
+
+        ASSERT(server->ns_conn_q > 0);
+
+        conn = TAILQ_FIRST(&server->s_conn_q);
+        conn->close(pool->ctx, conn);
+    }
+
+    return NC_OK;
+}
+
+static void
+server_failure(struct context *ctx, struct server *server)
+{
+    struct server_pool *pool = server->owner;
+    int64_t now, next;
+    rstatus_t status;
+
+    if (!pool->auto_eject_hosts) {
+        return;
+    }
+
+    server->failure_count++;
+
+    log_debug(LOG_VERB, "server '%.*s' failure count %"PRIu32" limit %"PRIu32,
+              server->pname.len, server->pname.data, server->failure_count,
+              pool->server_failure_limit);
+
+    if (server->failure_count < pool->server_failure_limit) {
+        return;
+    }
+
+    now = nc_usec_now();
+    if (now < 0) {
+        return;
+    }
+    next = now + pool->server_retry_timeout;
+
+    log_debug(LOG_INFO, "update pool %"PRIu32" '%.*s' to delete server '%.*s' "
+              "for next %"PRIu32" secs", pool->idx, pool->name.len,
+              pool->name.data, server->pname.len, server->pname.data,
+              pool->server_retry_timeout / 1000 / 1000);
+
+    stats_pool_incr(ctx, pool, server_ejects);
+
+    server->failure_count = 0;
+    server->next_retry = next;
+
+    status = server_pool_run(pool);
+    if (status != NC_OK) {
+        log_error("updating pool %"PRIu32" '%.*s' failed: %s", pool->idx,
+                  pool->name.len, pool->name.data, strerror(errno));
+    }
+}
+
+static void
+server_close_stats(struct context *ctx, struct server *server, err_t err,
+                   unsigned eof, unsigned connected)
+{
+    if (connected) {
+        stats_server_decr(ctx, server, server_connections);
+    }
+
+    if (eof) {
+        stats_server_incr(ctx, server, server_eof);
+        return;
+    }
+
+    switch (err) {
+    case ETIMEDOUT:
+        stats_server_incr(ctx, server, server_timedout);
+        break;
+    case EPIPE:
+    case ECONNRESET:
+    case ECONNABORTED:
+    case ECONNREFUSED:
+    case ENOTCONN:
+    case ENETDOWN:
+    case ENETUNREACH:
+    case EHOSTDOWN:
+    case EHOSTUNREACH:
+    default:
+        stats_server_incr(ctx, server, server_err);
+        break;
+    }
+}
+
+void
+server_close(struct context *ctx, struct conn *conn)
+{
+    rstatus_t status;
+    struct msg *msg, *nmsg; /* current and next message */
+    struct conn *c_conn;    /* peer client connection */
+
+    ASSERT(!conn->client && !conn->proxy);
+
+    server_close_stats(ctx, conn->owner, conn->err, conn->eof,
+                       conn->connected);
+
+    if (conn->sd < 0) {
+        server_failure(ctx, conn->owner);
+        conn->unref(conn);
+        conn_put(conn);
+        return;
+    }
+
+    for (msg = TAILQ_FIRST(&conn->imsg_q); msg != NULL; msg = nmsg) {
+        nmsg = TAILQ_NEXT(msg, s_tqe);
+
+        /* dequeue the message (request) from server inq */
+        conn->dequeue_inq(ctx, conn, msg);
+
+        /*
+         * Don't send any error response, if
+         * 1. request is tagged as noreply or,
+         * 2. client has already closed its connection
+         */
+        if (msg->swallow || msg->noreply) {
+            log_debug(LOG_INFO, "close s %d swallow req %"PRIu64" len %"PRIu32
+                      " type %d", conn->sd, msg->id, msg->mlen, msg->type);
+            req_put(msg);
+        } else {
+            c_conn = msg->owner;
+            ASSERT(c_conn->client && !c_conn->proxy);
+
+            msg->done = 1;
+            msg->error = 1;
+            msg->err = conn->err;
+
+            if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
+                event_add_out(ctx->ep, msg->owner);
+            }
+
+            log_debug(LOG_INFO, "close s %d schedule error for req %"PRIu64" "
+                      "len %"PRIu32" type %d from c %d%c %s", conn->sd, msg->id,
+                      msg->mlen, msg->type, c_conn->sd, conn->err ? ':' : ' ',
+                      conn->err ? strerror(conn->err): " ");
+        }
+    }
+    ASSERT(TAILQ_EMPTY(&conn->imsg_q));
+
+    for (msg = TAILQ_FIRST(&conn->omsg_q); msg != NULL; msg = nmsg) {
+        nmsg = TAILQ_NEXT(msg, s_tqe);
+
+        /* dequeue the message (request) from server outq */
+        conn->dequeue_outq(ctx, conn, msg);
+
+        if (msg->swallow) {
+            log_debug(LOG_INFO, "close s %d swallow req %"PRIu64" len %"PRIu32
+                      " type %d", conn->sd, msg->id, msg->mlen, msg->type);
+            req_put(msg);
+        } else {
+            c_conn = msg->owner;
+            ASSERT(c_conn->client && !c_conn->proxy);
+
+            msg->done = 1;
+            msg->error = 1;
+            msg->err = conn->err;
+
+            if (req_done(c_conn, TAILQ_FIRST(&c_conn->omsg_q))) {
+                event_add_out(ctx->ep, msg->owner);
+            }
+
+            log_debug(LOG_INFO, "close s %d schedule error for req %"PRIu64" "
+                      "len %"PRIu32" type %d from c %d%c %s", conn->sd, msg->id,
+                      msg->mlen, msg->type, c_conn->sd, conn->err ? ':' : ' ',
+                      conn->err ? strerror(conn->err): " ");
+        }
+    }
+    ASSERT(TAILQ_EMPTY(&conn->omsg_q));
+
+    msg = conn->rmsg;
+    if (msg != NULL) {
+        conn->rmsg = NULL;
+
+        ASSERT(!msg->request);
+        ASSERT(msg->peer == NULL);
+
+        rsp_put(msg);
+
+        log_debug(LOG_INFO, "close s %d discarding rsp %"PRIu64" len %"PRIu32" "
+                  "in error", conn->sd, msg->id, msg->mlen);
+    }
+
+    ASSERT(conn->smsg == NULL);
+
+    server_failure(ctx, conn->owner);
+
+    conn->unref(conn);
+
+    status = close(conn->sd);
+    if (status < 0) {
+        log_error("close s %d failed, ignored: %s", conn->sd, strerror(errno));
+    }
+    conn->sd = -1;
+
+    conn_put(conn);
+}
+
+rstatus_t
+server_connect(struct context *ctx, struct server *server, struct conn *conn)
+{
+    rstatus_t status;
+
+    ASSERT(!conn->client && !conn->proxy);
+
+    if (conn->sd > 0) {
+        /* already connected on server connection */
+        return NC_OK;
+    }
+
+    log_debug(LOG_VVERB, "connect to server '%.*s'", server->pname.len,
+              server->pname.data);
+
+	conn->sd = socket(conn->family, SOCK_STREAM, 0);
+    if (conn->sd < 0) {
+        log_error("socket for server '%.*s' failed: %s", server->pname.len,
+                  server->pname.data, strerror(errno));
+        status = NC_ERROR;
+        goto error;
+    }
+
+    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,
+                  strerror(errno));
+        goto error;
+    }
+
+    status = nc_set_tcpnodelay(conn->sd);
+    if (status != NC_OK) {
+        log_warn("set tcpnodelay on s %d for server '%.*s' failed, ignored: %s",
+                 conn->sd, server->pname.len, server->pname.data,
+                 strerror(errno));
+    }
+
+    status = event_add_conn(ctx->ep, 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,
+                  strerror(errno));
+        goto error;
+    }
+
+    ASSERT(!conn->connecting && !conn->connected);
+
+	status = connect(conn->sd, conn->addr, conn->addrlen);
+    if (status != NC_OK) {
+        if (errno == EINPROGRESS) {
+            conn->connecting = 1;
+            log_debug(LOG_DEBUG, "connecting on s %d to server '%.*s'",
+                      conn->sd, server->pname.len, server->pname.data);
+            return NC_OK;
+        }
+
+        log_error("connect on s %d to server '%.*s' failed: %s", conn->sd,
+                  server->pname.len, server->pname.data, strerror(errno));
+
+        goto error;
+    }
+
+    ASSERT(!conn->connecting);
+    conn->connected = 1;
+    log_debug(LOG_INFO, "connected on s %d to server '%.*s'", conn->sd,
+              server->pname.len, server->pname.data);
+
+    return NC_OK;
+
+error:
+    conn->err = errno;
+    return status;
+}
+
+void
+server_connected(struct context *ctx, struct conn *conn)
+{
+    struct server *server = conn->owner;
+
+    ASSERT(!conn->client && !conn->proxy);
+    ASSERT(conn->connecting && !conn->connected);
+
+    stats_server_incr(ctx, server, server_connections);
+
+    conn->connecting = 0;
+    conn->connected = 1;
+
+    log_debug(LOG_INFO, "connected on s %d to server '%.*s'", conn->sd,
+              server->pname.len, server->pname.data);
+}
+
+void
+server_ok(struct context *ctx, struct conn *conn)
+{
+    struct server *server = conn->owner;
+
+    ASSERT(!conn->client && !conn->proxy);
+    ASSERT(conn->connected);
+
+    if (server->failure_count != 0) {
+        log_debug(LOG_VERB, "reset server '%.*s' failure count from %"PRIu32
+                  " to 0", server->pname.len, server->pname.data,
+                  server->failure_count);
+        server->failure_count = 0;
+        server->next_retry = 0LL;
+    }
+}
+
+static rstatus_t
+server_pool_update(struct server_pool *pool)
+{
+    rstatus_t status;
+    int64_t now;
+    uint32_t pnlive_server; /* prev # live server */
+
+    if (!pool->auto_eject_hosts) {
+        return NC_OK;
+    }
+
+    if (pool->next_rebuild == 0LL) {
+        return NC_OK;
+    }
+
+    now = nc_usec_now();
+    if (now < 0) {
+        return NC_ERROR;
+    }
+
+    if (now <= pool->next_rebuild) {
+        if (pool->nlive_server == 0) {
+            errno = ECONNREFUSED;
+            return NC_ERROR;
+        }
+        return NC_OK;
+    }
+
+    pnlive_server = pool->nlive_server;
+
+    status = server_pool_run(pool);
+    if (status != NC_OK) {
+        log_error("updating pool %"PRIu32" with dist %d failed: %s", pool->idx,
+                  pool->dist_type, strerror(errno));
+        return status;
+    }
+
+    log_debug(LOG_INFO, "update pool %"PRIu32" '%.*s' to add %"PRIu32" servers",
+              pool->idx, pool->name.len, pool->name.data,
+              pool->nlive_server - pnlive_server);
+
+
+    return NC_OK;
+}
+
+static uint32_t
+server_pool_hash(struct server_pool *pool, uint8_t *key, uint32_t keylen)
+{
+    ASSERT(array_n(&pool->server) != 0);
+
+    if (array_n(&pool->server) == 1) {
+        return 0;
+    }
+
+    ASSERT(key != NULL && keylen != 0);
+
+    return pool->key_hash((char *)key, keylen);
+}
+
+static struct server *
+server_pool_server(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);
+
+    switch (pool->dist_type) {
+    case DIST_KETAMA:
+        hash = server_pool_hash(pool, key, keylen);
+        idx = ketama_dispatch(pool->continuum, pool->ncontinuum, hash);
+        break;
+
+    case DIST_MODULA:
+        hash = server_pool_hash(pool, key, keylen);
+        idx = modula_dispatch(pool->continuum, pool->ncontinuum, hash);
+        break;
+
+    case DIST_RANDOM:
+        idx = random_dispatch(pool->continuum, pool->ncontinuum, 0);
+        break;
+
+    default:
+        NOT_REACHED();
+        return NULL;
+    }
+    ASSERT(idx < array_n(&pool->server));
+
+    server = array_get(&pool->server, idx);
+
+    log_debug(LOG_VERB, "key '%.*s' on dist %d maps to server '%.*s'", keylen,
+              key, pool->dist_type, server->pname.len, server->pname.data);
+
+    return server;
+}
+
+struct conn *
+server_pool_conn(struct context *ctx, struct server_pool *pool, uint8_t *key,
+                 uint32_t keylen)
+{
+    rstatus_t status;
+    struct server *server;
+    struct conn *conn;
+
+    status = server_pool_update(pool);
+    if (status != NC_OK) {
+        return NULL;
+    }
+
+    /* from a given {key, keylen} pick a server from pool */
+    server = server_pool_server(pool, key, keylen);
+    if (server == NULL) {
+        return NULL;
+    }
+
+    /* pick a connection to a given server */
+    conn = server_conn(server);
+    if (conn == NULL) {
+        return NULL;
+    }
+
+    status = server_connect(ctx, server, conn);
+    if (status != NC_OK) {
+        server_close(ctx, conn);
+        return NULL;
+    }
+
+    return conn;
+}
+
+static rstatus_t
+server_pool_each_preconnect(void *elem, void *data)
+{
+    rstatus_t status;
+    struct server_pool *sp = elem;
+
+    if (!sp->preconnect) {
+        return NC_OK;
+    }
+
+    status = array_each(&sp->server, server_each_preconnect, NULL);
+    if (status != NC_OK) {
+        return status;
+    }
+
+    return NC_OK;
+}
+
+rstatus_t
+server_pool_preconnect(struct context *ctx)
+{
+    rstatus_t status;
+
+    status = array_each(&ctx->pool, server_pool_each_preconnect, NULL);
+    if (status != NC_OK) {
+        return status;
+    }
+
+    return NC_OK;
+}
+
+static rstatus_t
+server_pool_each_disconnect(void *elem, void *data)
+{
+    rstatus_t status;
+    struct server_pool *sp = elem;
+
+    status = array_each(&sp->server, server_each_disconnect, NULL);
+    if (status != NC_OK) {
+        return status;
+    }
+
+    return NC_OK;
+}
+
+void
+server_pool_disconnect(struct context *ctx)
+{
+    array_each(&ctx->pool, server_pool_each_disconnect, NULL);
+}
+
+static rstatus_t
+server_pool_each_set_owner(void *elem, void *data)
+{
+    struct server_pool *sp = elem;
+    struct context *ctx = data;
+
+    sp->ctx = ctx;
+
+    return NC_OK;
+}
+
+rstatus_t
+server_pool_run(struct server_pool *pool)
+{
+    ASSERT(array_n(&pool->server) != 0);
+
+    switch (pool->dist_type) {
+    case DIST_KETAMA:
+        return ketama_update(pool);
+
+    case DIST_MODULA:
+        return modula_update(pool);
+
+    case DIST_RANDOM:
+        return random_update(pool);
+
+    default:
+        NOT_REACHED();
+        return NC_ERROR;
+    }
+
+    return NC_OK;
+}
+
+static rstatus_t
+server_pool_each_run(void *elem, void *data)
+{
+    return server_pool_run(elem);
+}
+
+rstatus_t
+server_pool_init(struct array *server_pool, struct array *conf_pool,
+                 struct context *ctx)
+{
+    rstatus_t status;
+    uint32_t npool;
+
+    npool = array_n(conf_pool);
+    ASSERT(npool != 0);
+    ASSERT(array_n(server_pool) == 0);
+
+    status = array_init(server_pool, npool, sizeof(struct server_pool));
+    if (status != NC_OK) {
+        return status;
+    }
+
+    /* transform conf pool to server pool */
+    status = array_each(conf_pool, conf_pool_each_transform, server_pool);
+    if (status != NC_OK) {
+        server_pool_deinit(server_pool);
+        return status;
+    }
+    ASSERT(array_n(server_pool) == npool);
+
+    /* set ctx as the server pool owner */
+    status = array_each(server_pool, server_pool_each_set_owner, 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) {
+        server_pool_deinit(server_pool);
+        return status;
+    }
+
+    log_debug(LOG_DEBUG, "init %"PRIu32" pools", npool);
+
+    return NC_OK;
+}
+
+void
+server_pool_deinit(struct array *server_pool)
+{
+    uint32_t i, npool;
+
+    for (i = 0, npool = array_n(server_pool); i < npool; i++) {
+        struct server_pool *sp;
+
+        sp = array_pop(server_pool);
+        ASSERT(sp->p_conn == NULL);
+        ASSERT(TAILQ_EMPTY(&sp->c_conn_q) && sp->nc_conn_q == 0);
+
+        if (sp->continuum != NULL) {
+            nc_free(sp->continuum);
+            sp->ncontinuum = 0;
+            sp->nserver_continuum = 0;
+            sp->nlive_server = 0;
+        }
+
+        server_deinit(&sp->server);
+
+        log_debug(LOG_DEBUG, "deinit pool %"PRIu32" '%.*s'", sp->idx,
+                  sp->name.len, sp->name.data);
+    }
+
+    array_deinit(server_pool);
+
+    log_debug(LOG_DEBUG, "deinit %"PRIu32" pools", npool);
+}