libcouchbase 0.0.1

data/ext/libcouchbase/plugins/io/libevent/CMakeLists.txt

@@ -0,0 +1,29 @@
+INSTALL(
+    FILES
+    libevent_io_opts.h
+    DESTINATION
+    include/libcouchbase)
+
+
+IF(NOT (HAVE_LIBEVENT OR HAVE_LIBEVENT2))
+    RETURN()
+ENDIF()
+
+IF(HAVE_LIBEVENT2)
+    ADD_DEFINITIONS(-DHAVE_LIBEVENT2)
+    INCLUDE_DIRECTORIES(AFTER ${LIBEVENT_INCLUDE_DIR})
+ELSE()
+    INCLUDE_DIRECTORIES(AFTER ${LIBEVENT_INCLUDE_DIR})
+    ADD_DEFINITIONS(-DHAVE_LIBEVENT)
+ENDIF()
+
+IF(LCB_EMBED_PLUGIN_LIBEVENT)
+    ADD_LIBRARY(couchbase_libevent OBJECT plugin-libevent.c)
+    SET(LCB_LINK_SPEC "${LCB_LINKS_SPEC} ${LIBEVENT_LIBRARIES}")
+ELSE()
+    ADD_LIBRARY(couchbase_libevent SHARED plugin-libevent.c)
+    INSTALL(TARGETS couchbase_libevent LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+    TARGET_LINK_LIBRARIES(couchbase_libevent ${LIBEVENT_LIBRARIES})
+ENDIF()
+
+LCB_UTIL(couchbase_libevent)

data/ext/libcouchbase/plugins/io/libevent/libevent_io_opts.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2012 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.
+ */
+
+/**
+ * @file
+ * libevent integration with libcouchbase
+ * @author Trond Norbye
+ */
+
+/**
+ * @ingroup lcb-io-plugin-api
+ * @defgroup lcb-libevent libevent
+ * @brief libev integration
+ *
+ * lcb_create_libevent_io_opts() allows you to create an instance
+ * of the ioopts that will utilize libevent. You may either supply an event
+ * base (if you'd like to add your own events into the loop), or it will
+ * create its own.
+ */
+
+/**
+ * @addtogroup lcb-libevent
+ * @{
+ */
+#ifndef LIBCOUCHBASE_LIBEVENT_IO_OPTS_H
+#define LIBCOUCHBASE_LIBEVENT_IO_OPTS_H 1
+
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /**
+     * Create an instance of an event handler that utilize libevent for
+     * event notification.
+     *
+     * @param version the API version to use
+     * @param base the event base (struct event_base *) to hook use (please
+     *             note that you shouldn't reference the event base from
+     *             multiple threads)
+     * @param io a pointer to a newly created and initialized event handler
+     * @return status of the operation
+     */
+    LIBCOUCHBASE_API
+    lcb_error_t lcb_create_libevent_io_opts(int version, lcb_io_opt_t *io, void *base);
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@}*/
+#endif

data/ext/libcouchbase/plugins/io/libevent/plugin-libevent.c

@@ -0,0 +1,292 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2012 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.
+ */
+
+/**
+ * This file contains IO operations that use libevent
+ *
+ * @author Trond Norbye
+ * @todo add more documentation
+ */
+#define LCB_IOPS_V12_NO_DEPRECATE
+#include "config.h"
+#include <event.h>
+#include "libevent_io_opts.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <libcouchbase/plugins/io/bsdio-inl.c>
+
+struct libevent_cookie {
+    struct event_base *base;
+    int allocated;
+};
+
+
+#ifndef HAVE_LIBEVENT2
+/* libevent 1.x compatibility layer */
+#ifndef evutil_socket_t
+#define evutil_socket_t int
+#endif
+
+typedef void (*event_callback_fn)(evutil_socket_t, short, void *);
+
+static int
+event_assign(struct event *ev,
+             struct event_base *base,
+             evutil_socket_t fd,
+             short events,
+             event_callback_fn callback,
+             void *arg)
+{
+    ev->ev_callback = callback;
+    ev->ev_arg = arg;
+    ev->ev_fd = fd;
+    ev->ev_events = events;
+    ev->ev_res = 0;
+    ev->ev_flags = EVLIST_INIT;
+    ev->ev_ncalls = 0;
+    ev->ev_pncalls = NULL;
+    event_base_set(base, ev);
+
+    return 0;
+}
+
+static struct event *
+event_new(struct event_base *base,
+          evutil_socket_t fd,
+          short events,
+          event_callback_fn cb,
+          void *arg) {
+    struct event *ev;
+    ev = malloc(sizeof(struct event));
+    if (ev == NULL) {
+        return NULL;
+    }
+    if (event_assign(ev, base, fd, events, cb, arg) < 0) {
+        free(ev);
+        return NULL;
+    }
+    return ev;
+}
+
+static void
+event_free(struct event *ev)
+{
+    /* make sure that this event won't be coming back to haunt us. */
+    free(ev);
+
+}
+static short
+event_get_events(const struct event *ev)
+{
+    return ev->ev_events;
+}
+
+static event_callback_fn
+event_get_callback(const struct event *ev)
+{
+    return ev->ev_callback;
+}
+#endif
+
+static void *lcb_io_create_event(struct lcb_io_opt_st *iops)
+{
+    return event_new(((struct libevent_cookie *)iops->v.v2.cookie)->base,
+                     INVALID_SOCKET, 0, NULL, NULL);
+}
+
+static int lcb_io_update_event(struct lcb_io_opt_st *iops,
+                               lcb_socket_t sock,
+                               void *event,
+                               short flags,
+                               void *cb_data,
+                               void (*handler)(lcb_socket_t sock,
+                                               short which,
+                                               void *cb_data))
+{
+    flags |= EV_PERSIST;
+    if (flags == event_get_events(event) &&
+            handler == event_get_callback(event)) {
+        /* no change! */
+        return 0;
+    }
+
+    if (event_pending(event, EV_READ | EV_WRITE, 0)) {
+        event_del(event);
+    }
+
+    event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, sock, flags, handler, cb_data);
+    return event_add(event, NULL);
+}
+
+
+static void lcb_io_delete_timer(struct lcb_io_opt_st *iops,
+                                void *event)
+{
+    (void)iops;
+    if (event_pending(event, EV_TIMEOUT, 0) != 0 && event_del(event) == -1) {
+        iops->v.v2.error = EINVAL;
+    }
+    event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, 0, NULL, NULL);
+}
+
+static int lcb_io_update_timer(struct lcb_io_opt_st *iops,
+                               void *timer,
+                               lcb_uint32_t usec,
+                               void *cb_data,
+                               void (*handler)(lcb_socket_t sock,
+                                               short which,
+                                               void *cb_data))
+{
+    short flags = EV_TIMEOUT | EV_PERSIST;
+    struct timeval tmo;
+    if (flags == event_get_events(timer) &&
+            handler == event_get_callback(timer)) {
+        /* no change! */
+        return 0;
+    }
+
+    if (event_pending(timer, EV_TIMEOUT, 0)) {
+        event_del(timer);
+    }
+
+    event_assign(timer, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, flags, handler, cb_data);
+    tmo.tv_sec = usec / 1000000;
+    tmo.tv_usec = usec % 1000000;
+    return event_add(timer, &tmo);
+}
+
+static void lcb_io_destroy_event(struct lcb_io_opt_st *iops,
+                                 void *event)
+{
+    (void)iops;
+    if (event_pending(event, EV_READ | EV_WRITE | EV_TIMEOUT, 0)) {
+        event_del(event);
+    }
+    event_free(event);
+}
+
+static void lcb_io_delete_event(struct lcb_io_opt_st *iops,
+                                lcb_socket_t sock,
+                                void *event)
+{
+    (void)iops;
+    (void)sock;
+    if (event_del(event) == -1) {
+        iops->v.v2.error = EINVAL;
+    }
+    event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, 0, NULL, NULL);
+}
+
+static void lcb_io_stop_event_loop(struct lcb_io_opt_st *iops)
+{
+    event_base_loopbreak(((struct libevent_cookie *)iops->v.v2.cookie)->base);
+}
+
+static void lcb_io_run_event_loop(struct lcb_io_opt_st *iops)
+{
+    event_base_loop(((struct libevent_cookie *)iops->v.v2.cookie)->base, 0);
+}
+
+static void lcb_io_tick_event_loop(struct lcb_io_opt_st *iops)
+{
+    event_base_loop(((struct libevent_cookie *)iops->v.v2.cookie)->base,
+        EVLOOP_NONBLOCK);
+}
+
+static void lcb_destroy_io_opts(struct lcb_io_opt_st *iops)
+{
+    if (((struct libevent_cookie *)iops->v.v2.cookie)->allocated) {
+        event_base_free(((struct libevent_cookie *)iops->v.v2.cookie)->base);
+    }
+    free(iops->v.v2.cookie);
+    free(iops);
+}
+
+static void
+procs2_lnt_callback(int version, lcb_loop_procs *loop_procs,
+    lcb_timer_procs *timer_procs, lcb_bsd_procs *bsd_procs,
+    lcb_ev_procs *ev_procs, lcb_completion_procs *completion_procs,
+    lcb_iomodel_t *iomodel)
+{
+    ev_procs->create = lcb_io_create_event;
+    ev_procs->destroy = lcb_io_destroy_event;
+    ev_procs->watch = lcb_io_update_event;
+    ev_procs->cancel = lcb_io_delete_event;
+
+    timer_procs->create = lcb_io_create_event;
+    timer_procs->destroy  = lcb_io_destroy_event;
+    timer_procs->schedule = lcb_io_update_timer;
+    timer_procs->cancel = lcb_io_delete_timer;
+
+    loop_procs->start = lcb_io_run_event_loop;
+    loop_procs->stop = lcb_io_stop_event_loop;
+    loop_procs->tick = lcb_io_tick_event_loop;
+
+    *iomodel = LCB_IOMODEL_EVENT;
+
+    wire_lcb_bsd_impl2(bsd_procs, version);
+    (void)completion_procs;
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_create_libevent_io_opts(int version, lcb_io_opt_t *io, void *arg)
+{
+    struct event_base *base = arg;
+    struct lcb_io_opt_st *ret;
+    struct libevent_cookie *cookie;
+    if (version != 0) {
+        return LCB_PLUGIN_VERSION_MISMATCH;
+    }
+
+    ret = calloc(1, sizeof(*ret));
+    cookie = calloc(1, sizeof(*cookie));
+    if (ret == NULL || cookie == NULL) {
+        free(ret);
+        free(cookie);
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    /* setup io iops! */
+    ret->version = 3;
+    ret->dlhandle = NULL;
+    ret->destructor = lcb_destroy_io_opts;
+    /* consider that struct isn't allocated by the library,
+     * `need_cleanup' flag might be set in lcb_create() */
+    ret->v.v3.need_cleanup = 0;
+
+    if (base == NULL) {
+        if ((cookie->base = event_base_new()) == NULL) {
+            free(ret);
+            free(cookie);
+            return LCB_CLIENT_ENOMEM;
+        }
+        cookie->allocated = 1;
+    } else {
+        cookie->base = base;
+        cookie->allocated = 0;
+    }
+
+    ret->v.v3.cookie = cookie;
+    ret->v.v3.get_procs = procs2_lnt_callback;
+
+    /* For back-compat */
+    wire_lcb_bsd_impl(ret);
+
+    *io = ret;
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/plugins/io/libuv/CMakeLists.txt

@@ -0,0 +1,42 @@
+INSTALL(
+    FILES
+    plugin-libuv.c
+    plugin-internal.h
+    libuv_compat.h
+    DESTINATION
+    include/libcouchbase/plugins/io/libuv)
+
+INSTALL(
+    FILES
+    libuv_io_opts.h
+    DESTINATION
+    include/libcouchbase)
+
+IF(NOT HAVE_LIBUV OR LCB_NO_PLUGINS OR NOT LCB_BUILD_LIBUV)
+    RETURN()
+ENDIF()
+
+ADD_LIBRARY(couchbase_libuv SHARED plugin-libuv.c)
+
+# The macros abstracting UV versions dynamically inject special signatures. We
+# can't have the compiler whine about that.
+
+# Unfortunately, Older GCC (EL5) barfs at this option.
+#IF(CMAKE_COMPILER_IS_GNUCC)
+#    SET(_lcbuv_cflags "-Wno-unused-parameters")
+#ELSE()
+#    SET(_lcbuv_cflags "")
+#ENDIF()
+SET_TARGET_PROPERTIES(couchbase_libuv
+    PROPERTIES
+    PREFIX "lib"
+    IMPORT_PREFIX "lib"
+    COMPILE_FLAGS "${CMAKE_C_FLAGS} ${LCB_CORE_FLAGS} ${_lcbuv_cflags}")
+
+TARGET_LINK_LIBRARIES(couchbase_libuv ${LIBUV_LIBRARIES} couchbase)
+INCLUDE_DIRECTORIES(AFTER ${LIBUV_INCLUDE_DIR})
+ADD_DEFINITIONS(-DLIBCOUCHBASE_INTERNAL=1)
+INSTALL(TARGETS
+    couchbase_libuv
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

data/ext/libcouchbase/plugins/io/libuv/libuv_compat.h

@@ -0,0 +1,212 @@
+/* -*- 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 LIBUV_COMPAT_H
+#define LIBUV_COMPAT_H
+
+#ifdef UV_VERSION_MAJOR
+#ifndef UV_VERSION_PATCH
+#define UV_VERSION_PATCH 0
+#endif
+#define UV_VERSION  ((UV_VERSION_MAJOR << 16) | \
+                     (UV_VERSION_MINOR <<  8) | \
+                     (UV_VERSION_PATCH))
+#else
+#define UV_VERSION 0x000b00
+#endif
+
+#if defined(_WIN32) && defined(LIBCOUCHBASE_INTERNAL)
+#include <libcouchbase/plugins/io/wsaerr.h>
+#endif
+
+#ifndef UNKNOWN
+#define UNKNOWN -1
+#endif
+
+#ifndef EAIFAMNOSUPPORT
+#define EAIFAMNOSUPPORT EAI_FAMILY
+#endif
+
+#ifndef EAISERVICE
+#define EAISERVICE EAI_SERVICE
+#endif
+
+#ifndef EAI_SYSTEM
+#define EAI_SYSTEM -11
+#endif
+#ifndef EADDRINFO
+#define EADDRINFO EAI_SYSTEM
+#endif
+
+#ifndef EAISOCKTYPE
+#define EAISOCKTYPE EAI_SOCKTYPE
+#endif
+
+#ifndef ECHARSET
+#define ECHARSET 0
+#endif
+
+#ifndef EOF
+#define EOF -1
+#endif
+
+#ifndef ENONET
+#define ENONET ENETDOWN
+#endif
+
+#ifndef ESHUTDOWN
+#define ESHUTDOWN WSAESHUTDOWN
+#endif
+
+#ifndef EHOSTDOWN
+/* missing only on Windows */
+#define EHOSTDOWN WSAEHOSTDOWN
+#endif
+
+/* Not all systems have these error codes */
+#ifndef EAI_FAIL
+#define EAI_FAIL (-1)
+#endif
+#ifndef EAI_CANCELED
+#define EAI_CANCELED -101
+#endif
+#ifndef EAI_ADDRFAMILY
+#define EAI_ADDRFAMILY -9
+#endif
+#ifndef EAI_BADHINTS
+#define EAI_BADHINTS EAI_FAIL
+#endif
+#ifndef EAI_NODATA
+#define EAI_NODATA EAI_FAIL
+#endif
+#ifndef EAI_PROTOCOL
+#define EAI_PROTOCOL EAI_FAIL
+#endif
+#ifndef EAI_AGAIN
+#define EAI_AGAIN EAI_FAIL
+#endif
+#ifndef EAI_BADFLAGS
+#define EAI_BADFLAGS EAI_FAIL
+#endif
+#ifndef EAI_MEMORY
+#define EAI_MEMORY EAI_FAIL
+#endif
+#ifndef EAI_OVERFLOW
+#define EAI_OVERFLOW EAI_FAIL
+#endif
+
+#define OK 0
+
+#if UV_VERSION < 0x000900
+    #define UVC_RUN_ONCE(l) uv_run_once(l)
+    #define UVC_RUN_DEFAULT(l) uv_run(l)
+#else
+    #define UVC_RUN_ONCE(l) uv_run(l, UV_RUN_ONCE)
+    #define UVC_RUN_DEFAULT(l) uv_run(l, UV_RUN_DEFAULT)
+#endif
+
+#if UV_VERSION < 0x000b00
+
+  #define UVC_TCP_CONNECT(req, handle, addr, cb) \
+      uv_tcp_connect(req, handle, *(struct sockaddr_in *)addr, cb);
+
+  #define UVC_TCP_CONNECT6(req, handle, addr, cb) \
+      uv_tcp_connect6(req, handle, *(struct sockaddr_in6 *)addr, cb);
+
+  #define UVC_ALLOC_CB(func) \
+      uv_buf_t func(uv_handle_t *handle, size_t suggested_size)
+
+  #define UVC_ALLOC_CB_VARS() \
+      uv_buf_t _buf; uv_buf_t *buf = &_buf;
+
+  #define UVC_ALLOC_CB_RETURN() \
+      return _buf;
+
+  #define UVC_READ_CB(func) \
+      void func(uv_stream_t *stream, ssize_t nread, const uv_buf_t _buf)
+
+  #define UVC_READ_CB_VARS() \
+      const uv_buf_t *buf = &_buf;
+
+  #define UVC_TIMER_CB(func) \
+      void func(uv_timer_t *timer, int status)
+
+  static int uvc_uv2syserr(int status) {
+      #define X(errnum,errname,errdesc) \
+        if (status == UV_##errname) { return errname; }
+      UV_ERRNO_MAP(X);
+      #undef X
+      return 0;
+  }
+
+  static int uvc_is_eof(uv_loop_t *loop, int error) {
+      error = uv_last_error(loop).code;
+      return error == UV_EOF;
+  }
+
+  static int uvc_last_errno(uv_loop_t *loop, int error) {
+      int uverr = 0;
+
+      if (!error) {
+        return 0;
+      }
+
+      uverr = uv_last_error(loop).code;
+      return uvc_uv2syserr(uverr);
+  }
+
+#else
+
+  #define UVC_TCP_CONNECT(req, handle, addr, cb) \
+      uv_tcp_connect(req, handle, addr, cb);
+
+  #define UVC_TCP_CONNECT6(req, handle, addr, cb) \
+      uv_tcp_connect(req, handle, addr, cb);
+
+  #define UVC_ALLOC_CB(func) \
+      void func(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
+
+  #define UVC_ALLOC_CB_VARS()
+
+  #define UVC_ALLOC_CB_RETURN()
+
+  #define UVC_READ_CB(func) \
+      void func(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
+
+  #define UVC_READ_CB_VARS()
+
+  #define UVC_TIMER_CB(func) \
+      void func(uv_timer_t *timer)
+
+  static int uv_uv2syserr(int status) {
+      #define X(name, desc) if (status == UV_##name) { return name; }
+      UV_ERRNO_MAP(X)
+      #undef X
+      return 0;
+  }
+
+  static int uvc_last_errno(uv_loop_t *loop, int error) {
+      return uv_uv2syserr(error);
+  }
+
+  static int uvc_is_eof(uv_loop_t *loop, int error) {
+      (void) loop;
+      return error == UV_EOF;
+  }
+
+#endif
+#endif