libcouchbase 0.0.1

data/ext/libcouchbase/src/lcbio/lcbio.h

@@ -0,0 +1,51 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, 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 LCBIO_H
+#define LCBIO_H
+#include "connect.h"
+#include "manager.h"
+#include "ioutils.h"
+#include "ctx.h"
+#endif
+
+/**
+ * @defgroup lcbio I/O
+ * @brief IO Core
+ *
+ * @details
+ *
+ * This module represents the I/O core of libcouchbase. Effort has been made
+ * so that this module in theory is usable outside of libcouchbase.
+ *
+ * # Architectural Overview
+ *
+ * The I/O core (_LCBIO_) has been designed to support different I/O models and
+ * operating environments, with the goal of being able to integrate natively
+ * into such environments with minimal performance loss. Integration is acheived
+ * through several layers. The first layer is the _IOPS_ system defined in
+ * <libcouchbase/iops.h> and defines integration APIs for different I/O models.
+ *
+ * Afterwards, this is flattened and normalized into an _IO Table_ (`lcbio_TABLE`)
+ * which serves as a context and abstraction layer for unifying those two APIs
+ * where applicable.
+ *
+ * Finally the "End-user" APIs (in this case end-user means the application which
+ * requests a TCP connection or I/O on a socket) employs the
+ * `lcbio_connect` and `lcbio_CTX` systems to provide a uniform interface, the
+ * end result being that the underlying I/O model is completely abstracted.
+ */

data/ext/libcouchbase/src/lcbio/manager.c

@@ -0,0 +1,584 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, 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 "manager.h"
+#include "hostlist.h"
+#include "iotable.h"
+#include "timer-ng.h"
+#include "internal.h"
+
+#define LOGARGS(mgr, lvl) mgr->settings, "lcbio_mgr", LCB_LOG_##lvl, __FILE__, __LINE__
+
+typedef enum {
+    CS_PENDING,
+    CS_IDLE,
+    CS_LEASED
+} cinfo_state;
+
+typedef enum {
+    RS_PENDING,
+    RS_ASSIGNED
+} request_state;
+
+typedef char mgr_KEY[NI_MAXSERV + NI_MAXHOST + 2];
+
+typedef struct lcbio_MGRHOST {
+    lcb_clist_t ll_idle; /* idle connections */
+    lcb_clist_t ll_pending; /* pending cinfo */
+    lcb_clist_t requests; /* pending requests */
+    mgr_KEY key; /* host:port */
+    struct lcbio_MGR *parent;
+    lcbio_pASYNC async;
+    unsigned n_total; /* number of total connections */
+    unsigned refcount;
+} mgr_HOST;
+
+typedef struct mgr_CINFO_st {
+    lcbio_PROTOCTX base;
+    lcb_list_t llnode;
+    mgr_HOST *parent;
+    lcbio_SOCKET *sock;
+    struct lcbio_CONNSTART *cs;
+    lcbio_pTIMER idle_timer;
+    int state;
+} mgr_CINFO;
+
+typedef struct lcbio_MGRREQ {
+    lcb_list_t llnode;
+    lcbio_CONNDONE_cb callback;
+    void *arg;
+    mgr_HOST *host;
+    lcbio_pTIMER timer;
+    int state;
+    lcbio_SOCKET *sock;
+    lcb_error_t err;
+} mgr_REQ;
+
+#define HE_NPEND(he) LCB_CLIST_SIZE(&(he)->ll_pending)
+#define HE_NIDLE(he) LCB_CLIST_SIZE(&(he)->ll_idle)
+#define HE_NREQS(he) LCB_CLIST_SIZE(&(he)->requests)
+#define HE_NLEASED(he) ((he)->n_total - (HE_NIDLE(he) + HE_NPEND(he)))
+
+static void on_idle_timeout(void *cookie);
+static void he_available_notify(void *cookie);
+static void he_dump(mgr_HOST *he, FILE *out);
+static void he_unref(mgr_HOST *he);
+static void mgr_unref(lcbio_MGR *mgr);
+
+#define he_ref(he) (he)->refcount++
+#define mgr_ref(mgr) (mgr)->refcount++
+
+static const char *get_hehost(mgr_HOST *h) {
+    if (!h) { return "NOHOST:NOPORT"; }
+    return h->key;
+}
+
+/** Format string arguments for %p%s:%s */
+#define HE_LOGID(h) get_hehost(h), (void*)h
+#define HE_LOGFMT "<%s> (HE=%p) "
+
+static mgr_CINFO *
+cinfo_from_sock(lcbio_SOCKET *sock)
+{
+    lcbio_PROTOCTX *ctx = lcbio_protoctx_get(sock, LCBIO_PROTOCTX_POOL);
+    return (mgr_CINFO *)ctx;
+}
+
+static void
+destroy_cinfo(mgr_CINFO *info)
+{
+    info->parent->n_total--;
+    if (info->state == CS_IDLE) {
+        lcb_clist_delete(&info->parent->ll_idle, &info->llnode);
+
+    } else if (info->state == CS_PENDING && info->cs) {
+        lcbio_connect_cancel(info->cs);
+    }
+
+    if (info->sock) {
+        lcbio_SOCKET *s = info->sock;
+        info->sock = NULL;
+        lcbio_protoctx_delptr(s, &info->base, 0);
+        lcbio_unref(s);
+    }
+    lcbio_timer_destroy(info->idle_timer);
+    he_unref(info->parent);
+    free(info);
+}
+
+static void
+cinfo_protoctx_dtor(lcbio_PROTOCTX *ctx)
+{
+    mgr_CINFO *info = (void *)ctx;
+    info->sock = NULL;
+    destroy_cinfo(info);
+}
+
+lcbio_MGR *
+lcbio_mgr_create(lcb_settings *settings, lcbio_TABLE *io)
+{
+    lcbio_MGR *pool = calloc(1, sizeof(*pool));
+    if (!pool) {
+        return NULL;
+    }
+
+    if ((pool->ht = lcb_hashtable_nc_new(32)) == NULL) {
+        free(pool);
+        return NULL;
+    }
+
+    pool->settings = settings;
+    pool->io = io;
+    mgr_ref(pool);
+    return pool;
+}
+
+static void
+iterfunc(const void *k, lcb_size_t nk, const void *v, lcb_size_t nv, void *arg)
+{
+    lcb_clist_t *he_list = (lcb_clist_t *)arg;
+    mgr_HOST *he = (mgr_HOST *)v;
+    lcb_list_t *cur, *next;
+
+    LCB_LIST_SAFE_FOR(cur, next, (lcb_list_t *)&he->ll_idle) {
+        mgr_CINFO *info = LCB_LIST_ITEM(cur, mgr_CINFO, llnode);
+        destroy_cinfo(info);
+    }
+
+    LCB_LIST_SAFE_FOR(cur, next, (lcb_list_t *)&he->ll_pending) {
+        mgr_CINFO *info = LCB_LIST_ITEM(cur, mgr_CINFO, llnode);
+        destroy_cinfo(info);
+    }
+
+    memset(&he->ll_idle, 0, sizeof(he->ll_idle));
+    lcb_clist_append(he_list, (lcb_list_t *)&he->ll_idle);
+
+    (void)k; (void)nk; (void)nv;
+}
+
+static void
+he_unref(mgr_HOST *host)
+{
+    if (--host->refcount) {
+        return;
+    }
+
+    mgr_unref(host->parent);
+    free(host);
+}
+
+static void
+mgr_unref(lcbio_MGR *mgr)
+{
+    if (--mgr->refcount) {
+        return;
+    }
+    genhash_free(mgr->ht);
+    free(mgr);
+}
+
+void
+lcbio_mgr_destroy(lcbio_MGR *mgr)
+{
+    lcb_clist_t hes;
+    lcb_list_t *cur, *next;
+    lcb_clist_init(&hes);
+
+    genhash_iter(mgr->ht, iterfunc, &hes);
+
+    LCB_LIST_SAFE_FOR(cur, next, (lcb_list_t*)&hes) {
+        mgr_HOST *he = LCB_LIST_ITEM(cur, mgr_HOST, ll_idle);
+        genhash_delete(mgr->ht, he->key, strlen(he->key));
+        lcb_clist_delete(&hes, (lcb_list_t *)&he->ll_idle);
+        lcbio_timer_destroy(he->async);
+        he->async = NULL;
+        he_unref(he);
+    }
+    mgr_unref(mgr);
+}
+
+static void
+invoke_request(mgr_REQ *req)
+{
+    if (req->sock) {
+        mgr_CINFO *info = cinfo_from_sock(req->sock);
+        lcb_assert(info->state == CS_IDLE);
+        info->state = CS_LEASED;
+        req->state = RS_ASSIGNED;
+        lcbio_timer_disarm(info->idle_timer);
+        lcb_log(LOGARGS(info->parent->parent, DEBUG), HE_LOGFMT "Assigning R=%p SOCKET=%p",HE_LOGID(info->parent), (void*)req, (void*)req->sock);
+    }
+
+    if (req->timer) {
+        lcbio_timer_destroy(req->timer);
+        req->timer = NULL;
+    }
+
+    req->callback(req->sock, req->arg, req->err, 0);
+    if (req->sock) {
+        lcbio_unref(req->sock);
+    }
+    free(req);
+}
+
+/**
+ * Called to notify that a connection has become available.
+ */
+static void
+connection_available(mgr_HOST *he)
+{
+    while (LCB_CLIST_SIZE(&he->requests) && LCB_CLIST_SIZE(&he->ll_idle)) {
+        mgr_REQ *req;
+        mgr_CINFO *info;
+        lcb_list_t *reqitem, *connitem;
+
+        reqitem = lcb_clist_shift(&he->requests);
+        connitem = lcb_clist_pop(&he->ll_idle);
+
+        req = LCB_LIST_ITEM(reqitem, mgr_REQ, llnode);
+        info = LCB_LIST_ITEM(connitem, mgr_CINFO, llnode);
+        req->sock = info->sock;
+        req->err = LCB_SUCCESS;
+        invoke_request(req);
+    }
+}
+
+/**
+ * Connection callback invoked from lcbio_connect() when a result is received
+ */
+static void
+on_connected(lcbio_SOCKET *sock, void *arg, lcb_error_t err, lcbio_OSERR oserr)
+{
+    mgr_CINFO *info = arg;
+    mgr_HOST *he = info->parent;
+    lcb_assert(info->state == CS_PENDING);
+    info->cs = NULL;
+
+    lcb_log(LOGARGS(he->parent, DEBUG), HE_LOGFMT "Received result for I=%p,C=%p; E=0x%x", HE_LOGID(he), (void*)info, (void*)sock, err);
+    lcb_clist_delete(&he->ll_pending, &info->llnode);
+
+    if (err != LCB_SUCCESS) {
+        /** If the connection failed, fail out all remaining requests */
+        lcb_list_t *cur, *next;
+        LCB_LIST_SAFE_FOR(cur, next, (lcb_list_t *)&he->requests) {
+            mgr_REQ *req = LCB_LIST_ITEM(cur, mgr_REQ, llnode);
+            lcb_clist_delete(&he->requests, &req->llnode);
+            req->sock = NULL;
+            req->err = err;
+            invoke_request(req);
+        }
+
+        destroy_cinfo(info);
+
+    } else {
+        info->state = CS_IDLE;
+        info->sock = sock;
+        lcbio_ref(info->sock);
+        lcbio_protoctx_add(sock, &info->base);
+
+        lcb_clist_append(&he->ll_idle, &info->llnode);
+        lcbio_timer_rearm(info->idle_timer, he->parent->tmoidle);
+        connection_available(info->parent);
+    }
+
+    (void)oserr;
+}
+
+static void
+start_new_connection(mgr_HOST *he, uint32_t tmo)
+{
+    lcb_host_t tmphost;
+    lcb_error_t err;
+
+    mgr_CINFO *info = calloc(1, sizeof(*info));
+    info->state = CS_PENDING;
+    info->parent = he;
+
+    info->base.id = LCBIO_PROTOCTX_POOL;
+    info->base.dtor = cinfo_protoctx_dtor;
+    info->idle_timer = lcbio_timer_new(he->parent->io, info, on_idle_timeout);
+
+    err = lcb_host_parsez(&tmphost, he->key, 80);
+    if (err != LCB_SUCCESS) {
+        lcb_log(LOGARGS(he->parent, ERROR), HE_LOGFMT "Could not parse host! Will supply dummy host", HE_LOGID(he));
+        strcpy(tmphost.host, "BADHOST");
+        strcpy(tmphost.port, "BADPORT");
+    }
+    lcb_log(LOGARGS(he->parent, DEBUG), HE_LOGFMT "Starting connection on I=%p", HE_LOGID(he), (void*)info);
+
+    info->cs = lcbio_connect(he->parent->io, he->parent->settings, &tmphost,
+                             tmo, on_connected, info);
+
+    lcb_clist_append(&he->ll_pending, &info->llnode);
+    he->n_total++;
+    he_ref(he);
+}
+
+static void
+on_request_timeout(void *cookie)
+{
+    mgr_REQ *req = cookie;
+    lcb_clist_delete(&req->host->requests, &req->llnode);
+    req->err = LCB_ETIMEDOUT;
+    invoke_request(req);
+}
+
+static void
+async_invoke_request(void *cookie)
+{
+
+    mgr_REQ *req = cookie;
+    mgr_CINFO *cinfo = cinfo_from_sock(req->sock);
+    cinfo->state = CS_IDLE;
+    invoke_request(req);
+}
+
+mgr_REQ *
+lcbio_mgr_get(lcbio_MGR *pool, lcb_host_t *dest, uint32_t timeout,
+              lcbio_CONNDONE_cb handler, void *arg)
+{
+    mgr_HOST *he;
+    lcb_list_t *cur;
+    mgr_REQ *req = calloc(1, sizeof(*req));
+    mgr_KEY key = { 0 };
+
+    sprintf(key, "%s:%s", dest->host, dest->port);
+
+    req->callback = handler;
+    req->arg = arg;
+
+    he = genhash_find(pool->ht, key, strlen(key));
+    if (!he) {
+        he = calloc(1, sizeof(*he));
+        he->parent = pool;
+        he->async = lcbio_timer_new(pool->io, he, he_available_notify);
+        strcpy(he->key, key);
+
+        lcb_clist_init(&he->ll_idle);
+        lcb_clist_init(&he->ll_pending);
+        lcb_clist_init(&he->requests);
+
+        /** Not copied */
+        genhash_store(pool->ht, he->key, strlen(he->key), he, 0);
+        he_ref(he);
+        mgr_ref(pool);
+    }
+
+    req->host = he;
+
+    GT_POPAGAIN:
+
+    cur = lcb_clist_pop(&he->ll_idle);
+    if (cur) {
+        int clstatus;
+        mgr_CINFO *info = LCB_LIST_ITEM(cur, mgr_CINFO, llnode);
+
+        clstatus = lcbio_is_netclosed(info->sock, LCB_IO_SOCKCHECK_PEND_IS_ERROR);
+
+        if (clstatus == LCB_IO_SOCKCHECK_STATUS_CLOSED) {
+            lcb_log(LOGARGS(pool, WARN), HE_LOGFMT "Pooled socket is dead. Continuing to next one", HE_LOGID(he));
+
+            /* Set to CS_LEASED, since it's not inside any of our lists */
+            info->state = CS_LEASED;
+            destroy_cinfo(info);
+            goto GT_POPAGAIN;
+        }
+
+        lcbio_timer_disarm(info->idle_timer);
+        req->sock = info->sock;
+        req->state = RS_ASSIGNED;
+        req->timer = lcbio_timer_new(pool->io, req, async_invoke_request);
+        info->state = CS_LEASED;
+        lcbio_async_signal(req->timer);
+        lcb_log(LOGARGS(pool, INFO), HE_LOGFMT "Found ready connection in pool. Reusing socket and not creating new connection", HE_LOGID(he));
+
+    } else {
+        req->state = RS_PENDING;
+        req->timer = lcbio_timer_new(pool->io, req, on_request_timeout);
+        lcbio_timer_rearm(req->timer, timeout);
+
+        lcb_clist_append(&he->requests, &req->llnode);
+        if (HE_NPEND(he) < HE_NREQS(he)) {
+            lcb_log(LOGARGS(pool, DEBUG), HE_LOGFMT "Creating new connection because none are available in the pool", HE_LOGID(he));
+            start_new_connection(he, timeout);
+
+        } else {
+            lcb_log(LOGARGS(pool, DEBUG), HE_LOGFMT "Not creating a new connection. There are still pending ones", HE_LOGID(he));
+        }
+    }
+
+    return req;
+}
+
+/**
+ * Invoked when a new socket is available for allocation within the
+ * request queue.
+ */
+static void
+he_available_notify(void *cookie)
+{
+    connection_available((mgr_HOST *)cookie);
+}
+
+void
+lcbio_mgr_cancel(mgr_REQ *req)
+{
+    mgr_HOST *he = req->host;
+    lcbio_MGR *mgr = he->parent;
+    if (req->timer) {
+        lcbio_timer_destroy(req->timer);
+        req->timer = NULL;
+    }
+
+    if (req->sock) {
+        lcb_log(LOGARGS(mgr, DEBUG), HE_LOGFMT "Cancelling request=%p with existing connection", HE_LOGID(he), (void*)req);
+        lcbio_mgr_put(req->sock);
+        lcbio_async_signal(he->async);
+
+    } else {
+        lcb_log(LOGARGS(mgr, DEBUG), HE_LOGFMT "Request=%p has no connection.. yet", HE_LOGID(he), (void*)req);
+        lcb_clist_delete(&he->requests, &req->llnode);
+    }
+    free(req);
+}
+
+static void
+on_idle_timeout(void *cookie)
+{
+    mgr_CINFO *info = cookie;
+
+    lcb_log(LOGARGS(info->parent->parent, DEBUG), HE_LOGFMT "Idle connection expired", HE_LOGID(info->parent));
+
+    lcbio_unref(info->sock);
+}
+
+void
+lcbio_mgr_put(lcbio_SOCKET *sock)
+{
+    mgr_HOST *he;
+    lcbio_MGR *mgr;
+    mgr_CINFO *info = cinfo_from_sock(sock);
+
+    if (!info) {
+        fprintf(stderr, "Requested put() for non-pooled (or detached) socket=%p\n", (void *)sock);
+        lcbio_unref(sock);
+        return;
+    }
+
+    he = info->parent;
+    mgr = he->parent;
+
+    if (HE_NIDLE(he) >= mgr->maxidle) {
+        lcb_log(LOGARGS(mgr, INFO), HE_LOGFMT "Closing idle connection. Too many in quota", HE_LOGID(he));
+        lcbio_unref(info->sock);
+        return;
+    }
+
+    lcb_log(LOGARGS(mgr, INFO), HE_LOGFMT "Placing socket back into the pool. I=%p,C=%p", HE_LOGID(he), (void*)info, (void*)sock);
+    lcbio_timer_rearm(info->idle_timer, mgr->tmoidle);
+    lcb_clist_append(&he->ll_idle, &info->llnode);
+    info->state = CS_IDLE;
+}
+
+void
+lcbio_mgr_discard(lcbio_SOCKET *sock)
+{
+    lcbio_unref(sock);
+}
+
+void
+lcbio_mgr_detach(lcbio_SOCKET *sock)
+{
+    lcbio_protoctx_delid(sock, LCBIO_PROTOCTX_POOL, 1);
+}
+
+
+#define CONN_INDENT "    "
+
+static void
+write_he_list(lcb_clist_t *ll, FILE *out)
+{
+    lcb_list_t *llcur;
+    LCB_LIST_FOR(llcur, (lcb_list_t *)ll) {
+        mgr_CINFO *info = LCB_LIST_ITEM(llcur, mgr_CINFO, llnode);
+        fprintf(out, "%sCONN [I=%p,C=%p ",
+                CONN_INDENT, (void *)info, (void *)&info->sock);
+
+        if (info->sock->io->model == LCB_IOMODEL_EVENT) {
+            fprintf(out, "SOCKFD=%d", (int)info->sock->u.fd);
+        } else {
+            fprintf(out, "SOCKDATA=%p", (void *)info->sock->u.sd);
+        }
+        fprintf(out, " STATE=0x%x", info->state);
+        fprintf(out, "]\n");
+    }
+
+}
+
+static void
+he_dump(mgr_HOST *he, FILE *out)
+{
+    lcb_list_t *llcur;
+    fprintf(out, "HOST=%s", he->key);
+    fprintf(out, "Requests=%d, Idle=%d, Pending=%d, Leased=%d\n",
+            (int)HE_NREQS(he), (int)HE_NIDLE(he), (int)HE_NPEND(he), (int)HE_NLEASED(he));
+
+    fprintf(out, CONN_INDENT "Idle Connections:\n");
+    write_he_list(&he->ll_idle, out);
+    fprintf(out, CONN_INDENT "Pending Connections: \n");
+    write_he_list(&he->ll_pending, out);
+    fprintf(out, CONN_INDENT "Pending Requests:\n");
+
+    LCB_LIST_FOR(llcur, (lcb_list_t *)&he->requests) {
+        mgr_REQ *req = LCB_LIST_ITEM(llcur, mgr_REQ, llnode);
+        union {
+            lcbio_CONNDONE_cb cb;
+            void *ptr;
+        } u_cb;
+
+        u_cb.cb = req->callback;
+
+        fprintf(out, "%sREQ [R=%p, Callback=%p, Data=%p, State=0x%x]\n",
+                CONN_INDENT, (void *)req, u_cb.ptr, (void *)req->arg,
+                req->state);
+    }
+
+    fprintf(out, "\n");
+
+}
+
+static void
+dumpfunc(const void *k, lcb_size_t nk, const void *v, lcb_size_t nv, void *arg)
+{
+    FILE *out = (FILE *)arg;
+    mgr_HOST *he = (void *)v;
+    he_dump(he, out);
+    (void)nk;(void)k;(void)nv;
+}
+
+/**
+ * Dumps the connection manager state to stderr
+ */
+LCB_INTERNAL_API
+void lcbio_mgr_dump(lcbio_MGR *mgr, FILE *out)
+{
+    if (out == NULL) {
+        out = stderr;
+    }
+
+    genhash_iter(mgr->ht, dumpfunc, out);
+}