libcouchbase 0.0.1

data/ext/libcouchbase/src/list.c

@@ -0,0 +1,144 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 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 "internal.h"
+
+void lcb_list_init(lcb_list_t *list)
+{
+    list->next = list;
+    list->prev = list;
+}
+
+static void list_insert(lcb_list_t *prev, lcb_list_t *next, lcb_list_t *item)
+{
+    item->next = next;
+    item->prev = prev;
+    next->prev = item;
+    prev->next = item;
+}
+
+void lcb_list_prepend(lcb_list_t *list, lcb_list_t *item)
+{
+    list_insert(list, list->next, item);
+}
+
+void lcb_list_append(lcb_list_t *list, lcb_list_t *item)
+{
+    list_insert(list->prev, list, item);
+}
+
+static void list_eject(lcb_list_t *prev, lcb_list_t *next)
+{
+    next->prev = prev;
+    prev->next = next;
+}
+
+void lcb_list_delete(lcb_list_t *item)
+{
+    list_eject(item->prev, item->next);
+    item->next = item->prev = NULL;
+}
+
+
+lcb_list_t *lcb_list_shift(lcb_list_t *list)
+{
+    lcb_list_t *item;
+
+    if (LCB_LIST_IS_EMPTY(list)) {
+        return NULL;
+    }
+    item = list->next;
+    lcb_list_delete(item);
+    return item;
+}
+
+lcb_list_t *lcb_list_pop(lcb_list_t *list)
+{
+    lcb_list_t *item;
+
+    if (LCB_LIST_IS_EMPTY(list)) {
+        return NULL;
+    }
+    item = list->prev;
+    lcb_list_delete(item);
+    return item;
+}
+
+int lcb_list_contains(lcb_list_t *list, lcb_list_t *item)
+{
+    lcb_list_t *ptr = list->next;
+
+    while (ptr != list && ptr != item) {
+        ptr = ptr->next;
+    }
+
+    return (ptr == item) ? 1 : 0;
+}
+
+void lcb_list_add_sorted(lcb_list_t *list, lcb_list_t *item, lcb_list_cmp_fn cmp)
+{
+    lcb_list_t *p;
+
+    if (LCB_LIST_IS_EMPTY(list)) {
+        list_insert(list->prev, list, item);
+    } else {
+        LCB_LIST_FOR(p, list) {
+            if (cmp(item, p) < 0) {
+                break;
+            }
+        }
+        list_insert(p->prev, p, item);
+    }
+}
+
+
+void lcb_clist_init(lcb_clist_t *cl)
+{
+    lcb_list_init((lcb_list_t*)cl);
+    cl->size = 0;
+}
+void lcb_clist_append(lcb_clist_t *cl, lcb_list_t *item)
+{
+    lcb_list_append((lcb_list_t*)cl, item);
+    cl->size++;
+}
+void lcb_clist_prepend(lcb_clist_t *cl, lcb_list_t *item)
+{
+    lcb_list_prepend((lcb_list_t *)cl, item);
+    cl->size++;
+}
+void lcb_clist_delete(lcb_clist_t *cl, lcb_list_t *item)
+{
+    lcb_list_delete(item);
+    cl->size--;
+}
+lcb_list_t *lcb_clist_pop(lcb_clist_t *cl)
+{
+    lcb_list_t *ret = lcb_list_pop((lcb_list_t*)cl);
+    if (ret) {
+        cl->size--;
+    }
+    return ret;
+}
+lcb_list_t *lcb_clist_shift(lcb_clist_t *cl)
+{
+    lcb_list_t *ret = lcb_list_shift((lcb_list_t *)cl);
+    if (ret) {
+        cl->size--;
+    }
+    return ret;
+}

data/ext/libcouchbase/src/list.h

@@ -0,0 +1,127 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 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 LIBCOUCHBASE_LIST_H
+#define LIBCOUCHBASE_LIST_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /* Circular list implementation
+     *
+     * Could be used to implement queues, stacks etc.
+     *
+     * Declare list in your structure:
+     *
+     *      typedef struct {
+     *          lcb_list_t list;
+     *          lcb_uint32_t msec;
+     *          void (*callback)(struct timer *tm);
+     *      } lcb_timer_t;
+     *
+     * Initialize head of list:
+     *
+     *      lcb_timer_t tm;
+     *      lcb_list_init(&tm.list);
+     *
+     * Add new items:
+     *
+     *      lcb_timer_t *t;
+     *      t->msec = 2000;
+     *      t->callback = my_cb;
+     *      lcb_list_append(&tm.list, t);
+     *
+     * Iterate over items:
+     *
+     *      lcb_timer_t *t, *n;
+     *
+     *      for (ii = tm.list.next; ii != &tm.list; ii = ii->next) {
+     *          t = LCB_LIST_ITEM(ii, lcb_timer_t, list);
+     *          printf("timeout: %d\n", t->msec);
+     *      }
+     *
+     *      LCB_LIST_FOR(ii, &tm.list) {
+     *          t = LCB_LIST_ITEM(ii, lcb_timer_t, list);
+     *          printf("timeout: %d\n", t->msec);
+     *      }
+     *
+     *      LCB_LIST_SAFE_FOR(ii, n, &tm.list) {
+     *          t = LCB_LIST_ITEM(ii, lcb_timer_t, list);
+     *          printf("timeout: %d\n", t->msec);
+     *      }
+     */
+    typedef struct lcb_list_s lcb_list_t;
+    struct lcb_list_s {
+        lcb_list_t *next;
+        lcb_list_t *prev;
+    };
+
+    typedef struct lcb_clist_s {
+        lcb_list_t *next;
+        lcb_list_t *prev;
+        lcb_size_t size;
+    } lcb_clist_t;
+
+    typedef int (*lcb_list_cmp_fn)(lcb_list_t *a, lcb_list_t *b);
+
+    void lcb_list_init(lcb_list_t *list);
+    void lcb_list_prepend(lcb_list_t *list, lcb_list_t *item);
+    void lcb_list_append(lcb_list_t *list, lcb_list_t *item);
+    void lcb_list_delete(lcb_list_t *item);
+    lcb_list_t *lcb_list_shift(lcb_list_t *list);
+    lcb_list_t *lcb_list_pop(lcb_list_t *list);
+    int lcb_list_contains(lcb_list_t *list, lcb_list_t *item);
+    void lcb_list_add_sorted(lcb_list_t *list, lcb_list_t *item, lcb_list_cmp_fn cmp);
+
+    /** Definitions for type safety. Rather than macros */
+    void lcb_clist_init(lcb_clist_t*);
+    void lcb_clist_append(lcb_clist_t*, lcb_list_t*);
+    void lcb_clist_prepend(lcb_clist_t*, lcb_list_t*);
+    void lcb_clist_delete(lcb_clist_t*,lcb_list_t*);
+    lcb_list_t* lcb_clist_shift(lcb_clist_t*);
+    lcb_list_t* lcb_clist_pop(lcb_clist_t*);
+
+
+#define LCB_LIST_IS_EMPTY(list) \
+    ((list) == (list)->next && (list) == (list)->prev)
+
+#define LCB_LIST_ITEM(ptr, type, member) \
+    ((type *) (void *) ((char *)(ptr) - offsetof(type, member)))
+
+#define LCB_LIST_FOR(pos, list) \
+    for (pos = (list)->next; pos != (list); pos = pos->next)
+
+
+#define LCB_LIST_SAFE_FOR(pos, n, list) \
+    for (pos = (list)->next, n = pos->next; pos != (list); pos = n, n = pos->next)
+
+#define LCB_LIST_HAS_NEXT(ll, item) \
+    ((item)->next != ll)
+
+#define LCB_CLIST_SIZE(cl) (cl)->size
+
+#define LCB_LIST_TAIL(list) \
+    ((LCB_LIST_IS_EMPTY(list)) ? NULL : (list)->prev)
+
+#define LCB_LIST_HEAD(list) \
+    ((LCB_LIST_IS_EMPTY(list)) ? NULL : (list)->next)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/logging.c

@@ -0,0 +1,244 @@
+/* -*- 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 "settings.h"
+#include "logging.h"
+#include "internal.h" /* for lcb_getenv* */
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef _WIN32
+#define flockfile(x) (void) 0
+#define funlockfile(x) (void) 0
+#endif
+
+
+#if defined(unix) || defined(__unix__) || defined(__unix) || defined(_POSIX_VERSION)
+    #include <unistd.h>
+    #include <pthread.h>
+    #include <sys/types.h>
+
+    /** XXX: If any of these blocks give problems for your platform, just
+     * erase it and have it use the fallback implementation. This isn't core
+     * functionality of the library, but is a rather helpful feature in order
+     * to get the thread/process identifier
+     */
+
+    #if defined(__linux__)
+        #include <sys/syscall.h>
+        #define GET_THREAD_ID() (long)syscall(SYS_gettid)
+        #define THREAD_ID_FMT "ld"
+    #elif defined(__APPLE__)
+        #define GET_THREAD_ID() getpid(), pthread_mach_thread_np(pthread_self())
+        #define THREAD_ID_FMT "d/%x"
+    #elif defined(__sun) && defined(__SVR4)
+        #include <thread.h>
+        /* Thread IDs are not global in solaris, so it's nice to print the PID alongside it */
+        #define GET_THREAD_ID() getpid(), thr_self()
+        #define THREAD_ID_FMT "ld/%u"
+    #elif defined(__FreeBSD__)
+        /* Like solaris, but thr_self is a bit different here */
+        #include <sys/thr.h>
+        static long ret_thr_self(void) { long tmp; thr_self(&tmp); return tmp; }
+        #define GET_THREAD_ID() getpid(), ret_thr_self()
+        #define THREAD_ID_FMT "d/%ld"
+    #else
+        /* other unix? */
+        #define GET_THREAD_ID() 0
+        #define THREAD_ID_FMT "d"
+    #endif
+#elif defined(_WIN32)
+    #define GET_THREAD_ID() GetCurrentThreadId()
+    #define THREAD_ID_FMT "d"
+#else
+    #define GET_THREAD_ID() 0
+    #define THREAD_ID_FMT "d"
+#endif
+
+static hrtime_t start_time = 0;
+
+static void console_log(struct lcb_logprocs_st *procs,
+                        unsigned int iid,
+                        const char *subsys,
+                        int severity,
+                        const char *srcfile,
+                        int srcline,
+                        const char *fmt,
+                        va_list ap);
+
+static struct lcb_CONSOLELOGGER console_logprocs = {
+        {0 /* version */, {{console_log} /* v1 */} /*v*/},
+        NULL,
+        /** Minimum severity */
+        LCB_LOG_INFO
+};
+
+struct lcb_logprocs_st *lcb_console_logprocs = &console_logprocs.base;
+
+
+/**
+ * Return a string representation of the severity level
+ */
+static const char * level_to_string(int severity)
+{
+    switch (severity) {
+    case LCB_LOG_TRACE:
+        return "TRACE";
+    case LCB_LOG_DEBUG:
+        return "DEBUG";
+    case LCB_LOG_INFO:
+        return "INFO";
+    case LCB_LOG_WARN:
+        return "WARN";
+    case LCB_LOG_ERROR:
+        return "ERROR";
+    case LCB_LOG_FATAL:
+        return "FATAL";
+    default:
+        return "";
+    }
+}
+
+/**
+ * Default logging callback for the verbose logger.
+ */
+static void console_log(struct lcb_logprocs_st *procs,
+                        unsigned int iid,
+                        const char *subsys,
+                        int severity,
+                        const char *srcfile,
+                        int srcline,
+                        const char *fmt,
+                        va_list ap)
+{
+    FILE *fp;
+    hrtime_t now;
+    struct lcb_CONSOLELOGGER *vprocs = (struct lcb_CONSOLELOGGER *)procs;
+
+    if (severity < vprocs->minlevel) {
+        return;
+    }
+
+    if (!start_time) {
+        start_time = gethrtime();
+    }
+
+    now = gethrtime();
+    if (now == start_time) {
+        now++;
+    }
+
+    fp = vprocs->fp ? vprocs->fp : stderr;
+
+    flockfile(fp);
+    fprintf(fp, "%lums ", (unsigned long)(now - start_time) / 1000000);
+
+    fprintf(fp, "[I%d] {%"THREAD_ID_FMT"} [%s] (%s - L:%d) ",
+            iid,
+            GET_THREAD_ID(),
+            level_to_string(severity),
+            subsys,
+            srcline);
+    vfprintf(fp, fmt, ap);
+    fprintf(fp, "\n");
+    funlockfile(fp);
+
+    (void)procs;
+    (void)srcfile;
+}
+
+
+LCB_INTERNAL_API
+void lcb_log(const struct lcb_settings_st *settings,
+             const char *subsys,
+             int severity,
+             const char *srcfile,
+             int srcline,
+             const char *fmt,
+             ...)
+{
+    va_list ap;
+    lcb_logging_callback callback;
+
+    if (!settings->logger) {
+        return;
+    }
+
+    if (settings->logger->version != 0) {
+        return;
+    }
+
+    callback = settings->logger->v.v0.callback;
+
+    va_start(ap, fmt);
+    callback(settings->logger, settings->iid, subsys, severity, srcfile, srcline, fmt, ap);
+    va_end(ap);
+}
+
+LCB_INTERNAL_API
+void lcb_log_badconfig(const struct lcb_settings_st *settings,
+    const char *subsys, int severity, const char *srcfile, int srcline,
+    const lcbvb_CONFIG *vbc, const char *origin_txt)
+{
+    const char *errstr = lcbvb_get_error(vbc);
+    if (!errstr) {
+        errstr = "<FIXME: No error string provided for parse failure>";
+    }
+
+    lcb_log(settings, subsys, severity, srcfile, srcline,
+        "vBucket config parsing failed: %s. Raw text in DEBUG level", errstr);
+    if (!origin_txt) {
+        errstr = "<FIXME: No origin text available>";
+    }
+    lcb_log(settings, subsys, LCB_LOG_DEBUG, srcfile, srcline, "%s", origin_txt);
+}
+
+lcb_logprocs * lcb_init_console_logger(void)
+{
+    char vbuf[1024];
+    char namebuf[PATH_MAX] = { 0 };
+    int lvl = 0;
+    int has_file = 0;
+
+    has_file = lcb_getenv_nonempty("LCB_LOGFILE", namebuf, sizeof(namebuf));
+    if (has_file && console_logprocs.fp == NULL) {
+        FILE *fp = fopen(namebuf, "a");
+        if (!fp) {
+            fprintf(stderr, "libcouchbase: could not open file '%s' for logging output. (%s)\n",
+                namebuf, strerror(errno));
+        }
+        console_logprocs.fp = fp;
+    }
+
+    if (!lcb_getenv_nonempty("LCB_LOGLEVEL", vbuf, sizeof(vbuf))) {
+        return NULL;
+    }
+
+    if (sscanf(vbuf, "%d", &lvl) != 1) {
+        return NULL;
+    }
+
+    if (!lvl) {
+        /** "0" */
+        return NULL;
+    }
+
+    /** The "lowest" level we can expose is WARN, e.g. ERROR-1 */
+    lvl = LCB_LOG_ERROR - lvl;
+    console_logprocs.minlevel = lvl;
+    return lcb_console_logprocs;
+}