couchbase 1.2.0.z.beta5 → 1.2.0

data/ext/couchbase_ext/couchbase_ext.c

@@ -167,6 +167,9 @@ VALUE cb_eClientNoMemoryError;     /* LCB_CLIENT_ENOMEM = 0x1a   */
 VALUE cb_eClientTmpFailError;      /* LCB_CLIENT_ETMPFAIL = 0x1b */
 VALUE cb_eBadHandleError;          /* LCB_EBADHANDLE = 0x1c      */
 
+/* Default Strings */
+VALUE cb_vStrDefault;
+VALUE cb_vStrEmpty;
 
 /* Ruby Extension initializer */
     void
@@ -1075,4 +1078,11 @@ Init_couchbase_ext(void)
     cb_sym_username = ID2SYM(rb_intern("username"));
     cb_sym_version = ID2SYM(rb_intern("version"));
     cb_sym_view = ID2SYM(rb_intern("view"));
+
+    cb_vStrDefault = STR_NEW_CSTR("default");
+    rb_str_freeze(cb_vStrDefault);
+    rb_const_set(cb_mCouchbase, rb_intern("_STR_DEFAULT"), cb_vStrDefault);
+    cb_vStrEmpty = STR_NEW_CSTR("");
+    rb_str_freeze(cb_vStrEmpty);
+    rb_const_set(cb_mCouchbase, rb_intern("_STR_EMPTY"), cb_vStrEmpty);
 }

data/ext/couchbase_ext/couchbase_ext.h

@@ -51,6 +51,10 @@ extern hrtime_t gethrtime(void);
 #define va_init_list(a,b) va_start(a)
 #endif
 
+#ifndef HAVE_RB_HASH_LOOKUP2
+VALUE rb_hash_lookup2(VALUE, VALUE, VALUE);
+#endif
+
 #define cb_debug_object(OBJ) \
     rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("object_id"), 0)); \
     rb_funcall(rb_stderr, rb_intern("print"), 1, STR_NEW_CSTR(" ")); \
@@ -71,12 +75,12 @@ struct cb_bucket_st
     lcb_type_t type;
     struct lcb_io_opt_st *io;
     uint16_t port;
-    char *authority;
-    char *hostname;
-    char *pool;
-    char *bucket;
-    char *username;
-    char *password;
+    VALUE authority;
+    VALUE hostname;
+    VALUE pool;
+    VALUE bucket;
+    VALUE username;
+    VALUE password;
     int async;
     int quiet;
     VALUE default_format;    /* should update +default_flags+ on change */
@@ -91,9 +95,8 @@ struct cb_bucket_st
     VALUE exception;        /* error delivered by error_callback */
     VALUE on_error_proc;    /* is using to deliver errors in async mode */
     VALUE environment;      /* sym_development or sym_production */
-    char *key_prefix;
     VALUE key_prefix_val;
-    char *node_list;
+    VALUE node_list;
     VALUE object_space;
     VALUE self;             /* the pointer to bucket representation in ruby land */
 };
@@ -289,12 +292,16 @@ extern VALUE cb_eClientNoMemoryError;     /* LCB_CLIENT_ENOMEM = 0x1a   */
 extern VALUE cb_eClientTmpFailError;      /* LCB_CLIENT_ETMPFAIL = 0x1b */
 extern VALUE cb_eBadHandleError;          /* LCB_EBADHANDLE = 0x1c      */
 
+/* Default Strings */
+extern VALUE cb_vStrDefault;
+extern VALUE cb_vStrEmpty;
+
 void cb_strip_key_prefix(struct cb_bucket_st *bucket, VALUE key);
 VALUE cb_check_error(lcb_error_t rc, const char *msg, VALUE key);
 VALUE cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key, lcb_http_status_t status);
 VALUE cb_gc_protect(struct cb_bucket_st *bucket, VALUE val);
 VALUE cb_gc_unprotect(struct cb_bucket_st *bucket, VALUE val);
-VALUE cb_proc_call(VALUE recv, int argc, ...);
+VALUE cb_proc_call(struct cb_bucket_st *bucket, VALUE recv, int argc, ...);
 int cb_first_value_i(VALUE key, VALUE value, VALUE arg);
 void cb_build_headers(struct cb_context_st *ctx, const char * const *headers);
 void cb_maybe_do_loop(struct cb_bucket_st *bucket);
@@ -303,6 +310,8 @@ VALUE cb_encode_value(VALUE val, uint32_t flags);
 VALUE cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format);
 uint32_t cb_flags_set_format(uint32_t flags, ID format);
 ID cb_flags_get_format(uint32_t flags);
+void cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc);
+
 
 void cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation, lcb_error_t error, const lcb_store_resp_t *resp);
 void cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_resp_t *resp);
@@ -531,5 +540,7 @@ struct cb_params_st
 void cb_params_destroy(struct cb_params_st *params);
 void cb_params_build(struct cb_params_st *params, int argc, VALUE argv);
 
+LIBCOUCHBASE_API
+lcb_error_t cb_create_ruby_mt_io_opts(int version, lcb_io_opt_t *io, void *arg);
 #endif
 

data/ext/couchbase_ext/delete.c

@@ -32,9 +32,7 @@ cb_delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
         exc = cb_check_error(error, "failed to remove value", key);
         if (exc != Qnil) {
             rb_ivar_set(exc, cb_id_iv_operation, cb_sym_delete);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
     if (bucket->async) {    /* asynchronous */
@@ -43,7 +41,7 @@ cb_delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
             rb_ivar_set(res, cb_id_iv_error, exc);
             rb_ivar_set(res, cb_id_iv_operation, cb_sym_delete);
             rb_ivar_set(res, cb_id_iv_key, key);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
@@ -51,7 +49,7 @@ cb_delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -122,7 +120,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
 
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -138,7 +136,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule delete request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -151,7 +149,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             rb_exc_raise(cb_gc_unprotect(bucket, exc));
         }

data/ext/couchbase_ext/extconf.rb

@@ -130,9 +130,15 @@ have_library("couchbase", "lcb_verify_compiler_setup", "libcouchbase/couchbase.h
 have_header("mach/mach_time.h")
 have_header("stdint.h") or die("Failed to locate stdint.h")
 have_header("sys/time.h")
+have_header("fcntl.h")
 have_func("clock_gettime")
 have_func("gettimeofday")
 have_func("QueryPerformanceCounter")
+have_func("rb_hash_lookup2")
+have_func("rb_thread_fd_select")
+have_func("rb_thread_blocking_region")
+have_func("poll", "poll.h")
+have_func("ppoll", "poll.h")
 define("_GNU_SOURCE")
 create_header("couchbase_config.h")
 create_makefile("couchbase_ext")

data/ext/couchbase_ext/get.c

@@ -32,9 +32,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
         exc = cb_check_error(error, "failed to get value", key);
         if (exc != Qnil) {
             rb_ivar_set(exc, cb_id_iv_operation, cb_sym_get);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
@@ -59,7 +57,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
             val = raw;
         }
     } else if (cb_flags_get_format(resp->v.v0.flags) == cb_sym_plain) {
-        val = STR_NEW_CSTR("");
+        val = cb_vStrEmpty;
     }
     if (bucket->async) { /* asynchronous */
         if (ctx->proc != Qnil) {
@@ -70,7 +68,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
             rb_ivar_set(res, cb_id_iv_value, val);
             rb_ivar_set(res, cb_id_iv_flags, flags);
             rb_ivar_set(res, cb_id_iv_cas, cas);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         if (NIL_P(exc) && error != LCB_KEY_ENOENT) {
@@ -85,7 +83,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -241,7 +239,7 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     params.bucket = bucket;
     params.cmd.get.keys_ary = cb_gc_protect(bucket, rb_ary_new());
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -265,7 +263,7 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     cb_gc_unprotect(bucket, params.cmd.get.keys_ary);
     exc = cb_check_error(err, "failed to schedule get request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -278,7 +276,7 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);

data/ext/couchbase_ext/http.c

@@ -22,20 +22,19 @@ cb_http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE *rv = ctx->rv, key, val, res;
+    VALUE *rv = ctx->rv, key, val, res, exc;
     lcb_http_status_t status;
 
     ctx->request->completed = 1;
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
-    ctx->exception = cb_check_error_with_status(error,
-            "failed to execute HTTP request", key, resp->v.v0.status);
-    if (ctx->exception != Qnil) {
+    exc = cb_check_error_with_status(error, "failed to execute HTTP request", key, resp->v.v0.status);
+    if (exc != Qnil) {
         if (val != Qnil) {
-            rb_ivar_set(ctx->exception, cb_id_iv_body, val);
+            rb_ivar_set(exc, cb_id_iv_body, val);
         }
-        rb_funcall(ctx->exception, cb_id_parse_body_bang, 0);
-        cb_gc_protect(bucket, ctx->exception);
+        rb_funcall(exc, cb_id_parse_body_bang, 0);
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
     status = resp->v.v0.status;
     if (resp->v.v0.headers) {
@@ -55,7 +54,8 @@ cb_http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *
         res = val;
     }
     if (ctx->proc != Qnil) {
-        cb_proc_call(ctx->proc, 1, res);
+        cb_proc_call(bucket, ctx->proc, 1, res);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     if (!bucket->async && ctx->exception == Qnil) {
         *rv = res;
@@ -107,7 +107,7 @@ cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cook
         } else {
             res = val;
         }
-        cb_proc_call(ctx->proc, 1, res);
+        cb_proc_call(bucket, ctx->proc, 1, res);
     }
     (void)handle;
 }
@@ -123,11 +123,11 @@ cb_http_request_free(void *ptr)
                 && !request->completed) {
             lcb_cancel_http_request(request->bucket->handle, request->request);
         }
-        xfree((char *)request->cmd.v.v0.content_type);
-        xfree((char *)request->cmd.v.v0.path);
-        xfree((char *)request->cmd.v.v0.body);
-        xfree(request);
+        free((char *)request->cmd.v.v0.content_type);
+        free((char *)request->cmd.v.v0.path);
+        free((char *)request->cmd.v.v0.body);
     }
+    xfree(request);
 }
 
     void
@@ -242,7 +242,7 @@ cb_http_request_init(int argc, VALUE *argv, VALUE self)
         }
         if ((arg = rb_hash_aref(opts, cb_sym_content_type)) != Qnil) {
             Check_Type(arg, T_STRING);
-            xfree((char *)request->cmd.v.v0.content_type);
+            free((char *)request->cmd.v.v0.content_type);
             request->cmd.v.v0.content_type = strdup(RSTRING_PTR(arg));
         }
     }
@@ -280,24 +280,25 @@ cb_http_request_perform(VALUE self)
     lcb_error_t err;
     struct cb_bucket_st *bucket;
 
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory");
     }
     rv = Qnil;
     ctx->rv = &rv;
     ctx->bucket = bucket = req->bucket;
-    ctx->proc = rb_block_given_p() ? rb_block_proc() : req->on_body_callback;
+    ctx->proc = rb_block_given_p() ? cb_gc_protect(bucket, rb_block_proc()) : req->on_body_callback;
     ctx->extended = req->extended;
     ctx->request = req;
     ctx->headers_val = cb_gc_protect(bucket, rb_hash_new());
+    ctx->exception = Qnil;
 
     err = lcb_make_http_request(bucket->handle, (const void *)ctx,
             req->type, &req->cmd, &req->request);
     exc = cb_check_error(err, "failed to schedule document request",
             STR_NEW(req->cmd.v.v0.path, req->cmd.v.v0.npath));
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     req->running = 1;
@@ -308,7 +309,7 @@ cb_http_request_perform(VALUE self)
         lcb_wait(bucket->handle);
         if (req->completed) {
             exc = ctx->exception;
-            xfree(ctx);
+            free(ctx);
             if (exc != Qnil) {
                 cb_gc_unprotect(bucket, exc);
                 rb_exc_raise(exc);
@@ -340,7 +341,7 @@ cb_http_request_continue(VALUE self)
         if (req->completed) {
             exc = req->ctx->exception;
             rv = req->ctx->rv;
-            xfree(req->ctx);
+            free(req->ctx);
             if (exc != Qnil) {
                 cb_gc_unprotect(req->bucket, exc);
                 rb_exc_raise(exc);

data/ext/couchbase_ext/multithread_plugin.c

@@ -0,0 +1,1201 @@
+/* vim: ft=c et ts=8 sts=4 sw=4 cino=
+ *
+ *   Copyright 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.
+ */
+
+#include "couchbase_ext.h"
+
+
+#ifndef _WIN32
+
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+#include <rubysig.h>
+#endif
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#ifdef HAVE_POLL
+#include <poll.h>
+#endif
+#define INVALID_SOCKET (-1)
+
+/* Copied from libev plugin */
+    static lcb_ssize_t
+lcb_io_recv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
+        void *buffer, lcb_size_t len, int flags)
+{
+    lcb_ssize_t ret = recv(sock, buffer, len, flags);
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+    static lcb_ssize_t
+lcb_io_recvv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
+        struct lcb_iovec_st *iov, lcb_size_t niov)
+{
+    struct msghdr msg;
+    struct iovec vec[2];
+    lcb_ssize_t ret;
+
+    if (niov != 2) {
+        return -1;
+    }
+    memset(&msg, 0, sizeof(msg));
+    msg.msg_iov = vec;
+    msg.msg_iovlen = iov[1].iov_len ? (lcb_size_t)2 : (lcb_size_t)1;
+    msg.msg_iov[0].iov_base = iov[0].iov_base;
+    msg.msg_iov[0].iov_len = iov[0].iov_len;
+    msg.msg_iov[1].iov_base = iov[1].iov_base;
+    msg.msg_iov[1].iov_len = iov[1].iov_len;
+    ret = recvmsg(sock, &msg, 0);
+
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+
+    return ret;
+}
+
+    static lcb_ssize_t
+lcb_io_send(struct lcb_io_opt_st *iops, lcb_socket_t sock,
+        const void *msg, lcb_size_t len, int flags)
+{
+    lcb_ssize_t ret = send(sock, msg, len, flags);
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+    static lcb_ssize_t
+lcb_io_sendv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
+        struct lcb_iovec_st *iov, lcb_size_t niov)
+{
+    struct msghdr msg;
+    struct iovec vec[2];
+    lcb_ssize_t ret;
+
+    if (niov != 2) {
+        return -1;
+    }
+    memset(&msg, 0, sizeof(msg));
+    msg.msg_iov = vec;
+    msg.msg_iovlen = iov[1].iov_len ? (lcb_size_t)2 : (lcb_size_t)1;
+    msg.msg_iov[0].iov_base = iov[0].iov_base;
+    msg.msg_iov[0].iov_len = iov[0].iov_len;
+    msg.msg_iov[1].iov_base = iov[1].iov_base;
+    msg.msg_iov[1].iov_len = iov[1].iov_len;
+    ret = sendmsg(sock, &msg, 0);
+
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+    static int
+make_socket_nonblocking(lcb_socket_t sock)
+{
+    int flags;
+    if ((flags = fcntl(sock, F_GETFL, NULL)) < 0) {
+        return -1;
+    }
+    if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+
+    static int
+close_socket(lcb_socket_t sock)
+{
+    return close(sock);
+}
+
+    static lcb_socket_t
+lcb_io_socket(struct lcb_io_opt_st *iops, int domain, int type,
+        int protocol)
+{
+    lcb_socket_t sock = socket(domain, type, protocol);
+    if (sock == INVALID_SOCKET) {
+        iops->v.v0.error = errno;
+    } else {
+        if (make_socket_nonblocking(sock) != 0) {
+            int error = errno;
+            iops->v.v0.close(iops, sock);
+            iops->v.v0.error = error;
+            sock = INVALID_SOCKET;
+        }
+    }
+
+    return sock;
+}
+
+    static void
+lcb_io_close(struct lcb_io_opt_st *iops, lcb_socket_t sock)
+{
+    close_socket(sock);
+    (void)iops;
+}
+
+    static int
+lcb_io_connect(struct lcb_io_opt_st *iops, lcb_socket_t sock,
+        const struct sockaddr *name, unsigned int namelen)
+{
+    int ret = connect(sock, name, (socklen_t)namelen);
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+/* events sorted array */
+typedef struct rb_mt_event rb_mt_event;
+struct rb_mt_event {
+    void *cb_data;
+    void (*handler)(lcb_socket_t sock, short which, void *cb_data);
+    lcb_socket_t socket;
+    int loop_index;
+    short flags;
+    short actual_flags;
+    short inserted;
+    rb_mt_event *next;
+};
+
+typedef struct rb_mt_socket_list rb_mt_socket_list;
+struct rb_mt_socket_list {
+    lcb_socket_t socket;
+    short flags;
+    rb_mt_event *first;
+};
+
+typedef struct rb_mt_events rb_mt_events;
+struct rb_mt_events {
+    uint32_t capa;
+    uint32_t count;
+    rb_mt_socket_list *sockets;
+};
+
+    static int
+events_init(rb_mt_events *events)
+{
+    rb_mt_socket_list *new_socks = malloc(4 * sizeof(*new_socks));
+    if (new_socks == NULL) {
+        return 0;
+    }
+    events->capa = 4;
+    events->count = 0;
+    events->sockets = new_socks;
+    return 1;
+}
+
+    static void
+events_finalize(rb_mt_events *events)
+{
+    if (events->sockets) {
+        uint32_t i;
+        for(i = 0; i < events->count; i++) {
+            rb_mt_socket_list *list = &events->sockets[i];
+            while(list->first) {
+                rb_mt_event *next = list->first->next;
+                free(list->first);
+                list->first = next;
+            }
+        }
+        free(events->sockets);
+        events->sockets = NULL;
+    }
+    events->capa = 0;
+    events->count = 0;
+}
+
+    static uint32_t
+events_index(rb_mt_events *events, lcb_socket_t socket)
+{
+    uint32_t m, l = 0, r = events->count;
+    while(l < r) {
+        m = l + (r - l) / 2;
+        if (events->sockets[m].socket >= socket) {
+            r = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return l;
+}
+
+    static void
+events_insert(rb_mt_events *events, rb_mt_event *event)
+{
+    uint32_t i = events_index(events, event->socket);
+    rb_mt_socket_list *list = &events->sockets[i];
+    if (i == events->count || list->socket != event->socket) {
+        if (events->capa == events->count) {
+            uint32_t new_capa = events->capa << 1;
+            rb_mt_socket_list *new_socks = realloc(events->sockets, new_capa * sizeof(*new_socks));
+            if (new_socks == NULL) {
+                rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for events array");
+            }
+            events->sockets = new_socks;
+            events->capa = new_capa;
+            list = &events->sockets[i];
+        }
+        if (i < events->count) {
+            MEMMOVE(events->sockets+i+1, events->sockets+i, rb_mt_socket_list, events->count - i);
+        }
+        events->count++;
+        list->socket = event->socket;
+        list->flags = event->flags;
+        list->first = event;
+        event->next = NULL;
+    } else {
+        list->flags |= event->flags;
+        event->next = list->first;
+        list->first = event;
+    }
+    event->inserted = 1;
+}
+
+    static void
+event_list_fix_flags(rb_mt_socket_list *list)
+{
+    short flags = 0;
+    rb_mt_event *event = list->first;
+    while (event) {
+        flags |= event->flags;
+        event = event->next;
+    }
+    list->flags = flags;
+}
+
+    static void
+events_remove(rb_mt_events *events, rb_mt_event *event)
+{
+    uint32_t i = events_index(events, event->socket);
+    rb_mt_socket_list *list = &events->sockets[i];
+    rb_mt_event **next;
+    if (list->socket != event->socket) {
+        rb_raise(rb_eIndexError, "There is no socket in event loop");
+    }
+    next = &list->first;
+    for(;;) {
+        if (*next == NULL) {
+            rb_raise(rb_eIndexError, "There is no event in event loop");
+        }
+        if (*next == event) {
+            *next = event->next;
+            event->next = NULL;
+            event->inserted = 0;
+            break;
+        }
+        next = &event->next;
+    }
+    if (list->first == NULL) {
+        MEMMOVE(events->sockets + i, events->sockets + i + 1, rb_mt_socket_list, events->count - i - 1);
+        events->count--;
+    } else {
+        event_list_fix_flags(list);
+    }
+}
+
+    static void
+events_fix_flags(rb_mt_events *events, lcb_socket_t socket)
+{
+    uint32_t i = events_index(events, socket);
+    rb_mt_socket_list *list = &events->sockets[i];
+    if (list->socket != socket) {
+        rb_raise(rb_eIndexError, "There is no socket in event loop");
+    }
+    event_list_fix_flags(list);
+}
+
+    static inline lcb_socket_t
+events_max_fd(rb_mt_events *events)
+{
+    if (events->count) {
+        return events->sockets[events->count - 1].socket;
+    } else {
+        return -1;
+    }
+}
+
+/* events sorted array end */
+
+/* timers heap */
+typedef struct rb_mt_timer rb_mt_timer;
+struct rb_mt_timer {
+    void *cb_data;
+    void (*handler)(lcb_socket_t sock, short which, void *cb_data);
+    int index;
+    hrtime_t ts;
+    hrtime_t period;
+};
+
+typedef struct rb_mt_timers rb_mt_timers;
+struct rb_mt_timers {
+    uint32_t capa;
+    uint32_t count;
+    rb_mt_timer **timers;
+};
+
+    static int
+timers_init(rb_mt_timers *timers)
+{
+    rb_mt_timer **new_timers = malloc(4 * sizeof(*new_timers));
+    if (new_timers == NULL) {
+        return 0;
+    }
+    timers->capa = 4;
+    timers->count = 0;
+    timers->timers = new_timers;
+    return 1;
+}
+
+    static void
+timers_finalize(rb_mt_timers *timers)
+{
+    if (timers->timers) {
+        uint32_t i;
+        for(i = 0; i < timers->count; i++) {
+            free(timers->timers[i]);
+        }
+        free(timers->timers);
+        timers->timers = NULL;
+    }
+    timers->count = 0;
+    timers->capa = 0;
+}
+
+#define tms_at(_timers, at) (_timers)->timers[(at)]
+#define tms_ts_at(timers, at) tms_at((timers), (at))->ts
+
+    static void
+timers_move_last(rb_mt_timers *timers, uint32_t to)
+{
+    if (to < timers->count - 1) {
+        rb_mt_timer *last = tms_at(timers, timers->count - 1);
+        tms_at(timers, to) = last;
+        last->index = to;
+    }
+    timers->count--;
+}
+
+    static inline void
+timers_swap(rb_mt_timers *timers, uint32_t i, uint32_t j)
+{
+    rb_mt_timer *itmp = tms_at(timers, j);
+    rb_mt_timer *jtmp = tms_at(timers, i);
+    tms_at(timers, i) = itmp;
+    tms_at(timers, j) = jtmp;
+    itmp->index = i;
+    jtmp->index = j;
+}
+
+static void timers_heapify_up(rb_mt_timers *timers, uint32_t pos);
+
+    static void
+timers_insert(rb_mt_timers *timers, rb_mt_timer *timer)
+{
+    if (timers->count == timers->capa) {
+        rb_mt_timer **new_timers;
+        size_t new_capa = timers->capa << 1;
+        new_timers = realloc(timers->timers, new_capa * sizeof(rb_mt_timer*));
+        if (new_timers == NULL) {
+            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for timers heap");
+        }
+        timers->timers = new_timers;
+        timers->capa = new_capa;
+    }
+    tms_at(timers, timers->count) = timer;
+    timer->index = timers->count;
+    timers->count++;
+    timers_heapify_up(timers, timer->index);
+}
+
+    static void
+timers_heapify_up(rb_mt_timers *timers, uint32_t pos)
+{
+    hrtime_t cur_ts = tms_ts_at(timers, pos);
+    uint32_t higher = (pos - 1) / 2;
+    while (pos && tms_ts_at(timers, higher) > cur_ts) {
+        timers_swap(timers, higher, pos);
+        pos = higher;
+        higher = (pos - 1) / 2;
+    }
+}
+
+    static void
+timers_heapify_down(rb_mt_timers *timers, uint32_t pos)
+{
+    uint32_t count = timers->count;
+    uint32_t middle = (timers->count - 2) / 2;
+    hrtime_t cur_ts = tms_ts_at(timers, pos);
+    if (count == 1) return;
+    while (pos <= middle) {
+        uint32_t min_pos = pos;
+        hrtime_t ch_ts, min_ts = cur_ts;
+
+        if ((ch_ts = tms_ts_at(timers, pos * 2 + 1)) < min_ts) {
+            min_pos = pos * 2 + 1;
+            min_ts = ch_ts;
+        }
+
+        if (pos * 2 + 2 < count && tms_ts_at(timers, pos * 2 + 2) < min_ts) {
+            min_pos = pos * 2 + 2;
+        }
+
+        if (min_pos == pos) break;
+        timers_swap(timers, pos, min_pos);
+        pos = min_pos;
+    }
+}
+
+    static void
+timers_heapify_item(rb_mt_timers *timers, uint32_t pos)
+{
+    if (pos && tms_ts_at(timers, pos) < tms_ts_at(timers, (pos - 1) / 2)) {
+        timers_heapify_up(timers, pos);
+    } else {
+        timers_heapify_down(timers, pos);
+    }
+}
+
+    static inline hrtime_t
+timers_minimum(rb_mt_timers *timers)
+{
+    if (timers->count) {
+        return tms_ts_at(timers, 0);
+    } else {
+        return 0;
+    }
+}
+
+    static inline rb_mt_timer *
+timers_first(rb_mt_timers *timers)
+{
+    if (timers->count) {
+        return tms_at(timers, 0);
+    } else {
+        return 0;
+    }
+}
+
+    static void
+timers_remove_timer(rb_mt_timers *timers, rb_mt_timer *timer)
+{
+    uint32_t at = timer->index;
+    timer->index = -1;
+    if (at < timers->count - 1) {
+        timers_move_last(timers, at);
+        timers_heapify_item(timers, at);
+    } else {
+        timers->count--;
+    }
+}
+
+    static void
+timers_run(rb_mt_timers *timers, hrtime_t now)
+{
+    hrtime_t next_time = timers_minimum(timers);
+    while (next_time && next_time < now) {
+        rb_mt_timer *first = timers_first(timers);
+
+        first->ts = now + first->period;
+        timers_heapify_item(timers, 0);
+
+        first->handler(-1, 0, first->cb_data);
+
+        next_time = timers_minimum(timers);
+    }
+}
+/* timers heap end */
+
+/* callbacks array */
+typedef struct rb_mt_callbacks rb_mt_callbacks;
+struct rb_mt_callbacks {
+    uint32_t capa;
+    uint32_t count;
+    rb_mt_event **events;
+};
+
+    static int
+callbacks_init(rb_mt_callbacks *callbacks)
+{
+    rb_mt_event **new_events = calloc(4, sizeof(*new_events));
+    if (new_events == NULL) {
+        return 0;
+    }
+    callbacks->events = new_events;
+    callbacks->capa = 4;
+    callbacks->count = 0;
+    return 1;
+}
+
+    static void
+callbacks_finalize(rb_mt_callbacks *callbacks)
+{
+    if (callbacks->events) {
+        free(callbacks->events);
+        callbacks->events = NULL;
+    }
+    callbacks->capa = 0;
+    callbacks->count = 0;
+}
+
+    static void
+callbacks_push(rb_mt_callbacks *callbacks, rb_mt_event *event)
+{
+    if (callbacks->count == callbacks->capa) {
+        uint32_t new_capa = callbacks->capa << 1;
+        rb_mt_event **new_events = realloc(callbacks->events, new_capa * sizeof(*new_events));
+        if (new_events == NULL) {
+            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for callbacks array");
+        }
+        callbacks->capa = new_capa;
+        callbacks->events = new_events;
+    }
+    callbacks->events[callbacks->count] = event;
+    callbacks->count++;
+}
+
+    static void
+callbacks_remove(rb_mt_callbacks *callbacks, rb_mt_event *event)
+{
+    int i = event->loop_index;
+    if (i >= 0) {
+        if (callbacks->events[i] != event) {
+            rb_raise(rb_eIndexError, "callback index belongs to different callback");
+        }
+        event->loop_index = -1;
+        callbacks->events[i] = NULL;
+    }
+}
+
+    static void
+callbacks_run(rb_mt_callbacks *callbacks)
+{
+    uint32_t i;
+    for(i = 0; i < callbacks->count; i++) {
+        rb_mt_event *cb = callbacks->events[i];
+        if (cb) {
+            cb->handler(cb->socket, cb->actual_flags, cb->cb_data);
+        }
+    }
+    callbacks->count = 0;
+}
+
+    static void
+callbacks_clean(rb_mt_callbacks *callbacks)
+{
+    uint32_t i;
+    for(i = 0; i < callbacks->count; i++) {
+        if (callbacks->events[i]) {
+            callbacks->events[i]->loop_index = -1;
+            callbacks->events[i] = NULL;
+        }
+    }
+    callbacks->count = 0;
+}
+/* callbacks array end */
+
+typedef struct rb_mt_loop rb_mt_loop;
+struct rb_mt_loop {
+    rb_mt_events events;
+    rb_mt_timers timers;
+    rb_mt_callbacks callbacks;
+    short run;
+};
+
+    static rb_mt_loop*
+loop_create()
+{
+    rb_mt_loop *loop = calloc(1, sizeof(*loop));
+    if (loop == NULL) return NULL;
+    if (!events_init(&loop->events)) goto free_loop;
+    if (!timers_init(&loop->timers)) goto free_events;
+    if (!callbacks_init(&loop->callbacks)) goto free_timers;
+    return loop;
+
+free_timers:
+    timers_finalize(&loop->timers);
+free_events:
+    events_finalize(&loop->events);
+free_loop:
+    free(loop);
+    return NULL;
+}
+
+    static void
+loop_destroy(rb_mt_loop *loop)
+{
+    events_finalize(&loop->events);
+    timers_finalize(&loop->timers);
+    callbacks_finalize(&loop->callbacks);
+    free(loop);
+}
+
+    static void
+loop_remove_event(rb_mt_loop *loop, rb_mt_event *event)
+{
+    if (event->inserted) {
+        events_remove(&loop->events, event);
+    }
+    callbacks_remove(&loop->callbacks, event);
+}
+
+    static void
+loop_enque_events(rb_mt_callbacks *callbacks, rb_mt_event *sock, short flags)
+{
+    while (sock) {
+        short actual = sock->flags & flags;
+        if (actual) {
+            sock->actual_flags = actual;
+            callbacks_push(callbacks, (rb_mt_event*)sock);
+        }
+        sock = sock->next;
+    }
+}
+
+/* loop select implementation */
+#ifndef HAVE_RB_THREAD_FD_SELECT
+typedef fd_set rb_fdset_t;
+#define rb_fd_init   FD_ZERO
+#define rb_fd_set    FD_SET
+#define rb_fd_isset  FD_ISSET
+#define rb_fd_term(set)  (void)0
+#define rb_thread_fd_select rb_thread_select
+#endif
+
+typedef struct loop_select_arg {
+    rb_mt_loop *loop;
+    rb_fdset_t in, out;
+} ls_arg;
+
+    static VALUE
+loop_run_select(VALUE argp)
+{
+    ls_arg *args = (ls_arg*) argp;
+    rb_mt_loop *loop = args->loop;
+    rb_fdset_t *in = NULL, *out = NULL;
+    struct timeval timeout;
+    struct timeval *timeoutp = NULL;
+    int result, max = 0;
+    hrtime_t now, next_time;
+
+    next_time = timers_minimum(&loop->timers);
+    if (next_time) {
+        now = gethrtime();
+        if (next_time <= now) {
+            timeout.tv_sec = 0;
+            timeout.tv_usec = 0;
+        } else {
+            hrtime_t hrto = (next_time - now) / 1000;
+            timeout.tv_sec = (long)(hrto / 1000000);
+            timeout.tv_usec = (long)(hrto % 1000000);
+        }
+        timeoutp = &timeout;
+    }
+
+    if (loop->events.count) {
+        uint32_t i;
+        rb_fd_init(&args->in);
+        rb_fd_init(&args->out);
+        for(i = 0; i < loop->events.count; i++) {
+            rb_mt_socket_list *list = &loop->events.sockets[i];
+            if (list->flags & LCB_READ_EVENT) {
+                in = &args->in;
+                rb_fd_set(list->socket, in);
+            }
+            if (list->flags & LCB_WRITE_EVENT) {
+                out = &args->out;
+                rb_fd_set(list->socket, out);
+            }
+        }
+        max = events_max_fd(&loop->events) + 1;
+    }
+
+    result = rb_thread_fd_select(max, in, out, NULL, timeoutp);
+
+    if (result < 0) {
+        rb_sys_fail("rb_thread_fd_select");
+    }
+    /* fix current time so that socket callbacks will not cause timers timeouts */
+    if (next_time) {
+        now = gethrtime();
+    }
+
+    if (result > 0) {
+        uint32_t i;
+        for(i = 0; i < loop->events.count && result; i++) {
+            rb_mt_socket_list *list = loop->events.sockets + i;
+            rb_mt_event *sock = list->first;
+            short flags = 0;
+            if (in && rb_fd_isset(list->socket, in)) {
+                flags |= LCB_READ_EVENT;
+                result--;
+            }
+            if (out && rb_fd_isset(list->socket, out)) {
+                flags |= LCB_WRITE_EVENT;
+                result--;
+            }
+            if (flags) {
+                loop_enque_events(&loop->callbacks, sock, flags);
+            }
+        }
+        callbacks_run(&loop->callbacks);
+    }
+
+    if (next_time) {
+        timers_run(&loop->timers, now);
+    }
+    if (loop->events.count == 0 && loop->timers.count == 0) {
+        loop->run = 0;
+    }
+    return Qnil;
+}
+
+    static VALUE
+loop_select_cleanup(VALUE argp)
+{
+    ls_arg *args = (ls_arg*) argp;
+    rb_fd_term(&args->in);
+    rb_fd_term(&args->out);
+    callbacks_clean(&args->loop->callbacks);
+    return Qnil;
+}
+/* loop select implementaion end */
+
+/* loop poll implementation */
+#ifdef HAVE_POLL
+/* code influenced by ruby's source and cool.io */
+#define POLLIN_SET (POLLIN | POLLHUP | POLLERR)
+#define POLLOUT_SET (POLLOUT | POLLHUP | POLLERR)
+
+#ifndef HAVE_PPOLL
+#if SIZEOF_TIME_T == SIZEOF_LONG
+typedef unsigned long unsigned_time_t;
+#elif SIZEOF_TIME_T == SIZEOF_INT
+typedef unsigned int unsigned_time_t;
+#elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
+typedef unsigned LONG_LONG unsigned_time_t;
+#else
+# error cannot find integer type which size is same as time_t.
+#endif
+#define TIMET_MAX (~(time_t)0 <= 0 ? (time_t)((~(unsigned_time_t)0) >> 1) : (time_t)(~(unsigned_time_t)0))
+    static int
+ppoll(struct pollfd *fds, nfds_t nfds,
+        const struct timespec *ts, const sigset_t *sigmask)
+{
+    int timeout_ms;
+
+    if (ts) {
+        int tmp, tmp2;
+
+        if (ts->tv_sec > TIMET_MAX/1000) {
+            timeout_ms = -1;
+        } else {
+            tmp = ts->tv_sec * 1000;
+            tmp2 = (ts->tv_nsec + 999999) / (1000 * 1000);
+            if (TIMET_MAX - tmp < tmp2) {
+                timeout_ms = -1;
+            } else {
+                timeout_ms = tmp + tmp2;
+            }
+        }
+    } else {
+        timeout_ms = -1;
+    }
+
+    (void)sigmask;
+
+    return poll(fds, nfds, timeout_ms);
+}
+#endif
+
+typedef struct poll_args lp_arg;
+struct poll_args {
+    rb_mt_loop *loop;
+    struct pollfd *fds;
+    nfds_t nfd;
+    struct timespec *ts;
+    int result;
+    int lerrno;
+};
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    static VALUE
+loop_blocking_poll(void *argp)
+{
+    lp_arg *args = argp;
+    args->result = ppoll(args->fds, args->nfd, args->ts, NULL);
+    if (args->result < 0) args->lerrno = errno;
+    return Qnil;
+}
+#endif
+
+    static VALUE
+loop_run_poll(VALUE argp)
+{
+    lp_arg *args = (struct poll_args *)argp;
+    rb_mt_loop *loop = args->loop;
+    struct timespec ts;
+    hrtime_t now, next_time;
+
+    if (loop->events.count) {
+        uint32_t i;
+        args->fds = calloc(loop->events.count, sizeof(struct pollfd));
+        if (args->fds == NULL) {
+            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for pollfd");
+        }
+        for(i = 0; i < loop->events.count; i++) {
+            rb_mt_socket_list *list = &loop->events.sockets[i];
+            args->fds[i].fd = list->socket;
+            args->fds[i].events =
+                (list->flags & LCB_READ_EVENT ? POLLIN : 0) |
+                (list->flags & LCB_WRITE_EVENT ? POLLOUT : 0);
+        }
+        args->nfd = loop->events.count;
+    }
+
+retry:
+    next_time = timers_minimum(&loop->timers);
+    if (next_time) {
+        now = gethrtime();
+        if (next_time <= now) {
+            ts.tv_sec = 0;
+            ts.tv_nsec = 0;
+        } else {
+            hrtime_t hrto = next_time - now;
+            ts.tv_sec = (long)(hrto / 1000000000);
+            ts.tv_nsec = (long)(hrto % 1000000000);
+        }
+        args->ts = &ts;
+    } else {
+        args->ts = NULL;
+    }
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    rb_thread_blocking_region(loop_blocking_poll, args, RUBY_UBF_PROCESS, NULL);
+#else
+    if (rb_thread_alone()) {
+        TRAP_BEG;
+        args->result = ppoll(args->fds, args->nfd, args->ts, NULL);
+        if (args->result < 0) args->lerrno = errno;
+        TRAP_END;
+    } else {
+        struct timespec mini_pause;
+        int exact = 0;
+        mini_pause.tv_sec = 0;
+        /* 5 millisecond pause */
+        mini_pause.tv_nsec = 5000000;
+        if (args->ts && ts.tv_sec == 0 && ts.tv_nsec < 5000000) {
+            mini_pause.tv_nsec = ts.tv_nsec;
+            exact = 1;
+        }
+        TRAP_BEG;
+        args->result = ppoll(args->fds, args->nfd, &mini_pause, NULL);
+        if (args->result < 0) args->lerrno = errno;
+        TRAP_END;
+        if (args->result == 0 && !exact) {
+            args->result = -1;
+            args->lerrno = EINTR;
+        }
+    }
+#endif
+
+    if (args->result < 0) {
+        errno = args->lerrno;
+        switch (errno) {
+            case EINTR:
+#ifdef ERESTART
+            case ERESTART:
+#endif
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+                rb_thread_schedule();
+#endif
+                goto retry;
+        }
+        rb_sys_fail("poll");
+        return Qnil;
+    }
+
+    if (next_time) {
+        now = gethrtime();
+    }
+
+    if (args->result > 0) {
+        uint32_t cnt = args->result;
+        uint32_t fd_n = 0, ev_n = 0;
+        while (cnt && fd_n < args->nfd && ev_n < loop->events.count) {
+            struct pollfd *res = args->fds + fd_n;
+            rb_mt_socket_list *list = loop->events.sockets + ev_n;
+            rb_mt_event *sock = list->first;
+
+            /* if plugin used correctly, this checks are noop */
+            if (res->fd < list->socket) {
+                fd_n++;
+                continue;
+            } else if (res->fd > list->socket) {
+                ev_n++;
+                continue;
+            }
+
+            if (res->revents) {
+                short flags =
+                    ((res->revents & POLLIN_SET) ? LCB_READ_EVENT : 0) |
+                    ((res->revents & POLLOUT_SET) ? LCB_WRITE_EVENT : 0);
+                cnt--;
+                loop_enque_events(&loop->callbacks, sock, flags);
+            }
+            fd_n++;
+            ev_n++;
+        }
+        callbacks_run(&loop->callbacks);
+    }
+
+    if (next_time) {
+        timers_run(&loop->timers, now);
+    }
+    if (loop->events.count == 0 && loop->timers.count == 0) {
+        loop->run = 0;
+    }
+    return Qnil;
+}
+
+    static VALUE
+loop_poll_cleanup(VALUE argp)
+{
+    lp_arg *args = (struct poll_args *)argp;
+    if (args->fds) {
+        free(args->fds);
+    }
+    callbacks_clean(&args->loop->callbacks);
+    return Qnil;
+}
+#endif
+/* loop poll implementation end */
+
+    static void
+loop_run(rb_mt_loop *loop)
+{
+
+    loop->run = 1;
+
+    while(loop->run) {
+#ifdef HAVE_POLL
+        /* prefer use of poll when it gives some benefits, but use rb_thread_fd_select when it is sufficient */
+        lcb_socket_t max = events_max_fd(&loop->events);
+        int use_poll = max >= 128;
+        if (use_poll) {
+            lp_arg args;
+            memset(&args, 0, sizeof(args));
+            args.loop = loop;
+            rb_ensure(loop_run_poll, (VALUE)&args, loop_poll_cleanup, (VALUE)&args);
+        } else
+#endif
+        {
+            ls_arg args;
+            memset(&args, 0, sizeof(args));
+            args.loop = loop;
+            rb_ensure(loop_run_select, (VALUE)&args, loop_select_cleanup, (VALUE)&args);
+        }
+    }
+}
+
+    static void *
+lcb_io_create_event(struct lcb_io_opt_st *iops)
+{
+    rb_mt_event *event = calloc(1, sizeof(*event));
+    (void)iops;
+    event->loop_index = -1;
+    return event;
+}
+
+    static int
+lcb_io_update_event(struct lcb_io_opt_st *iops,
+        lcb_socket_t sock,
+        void *eventp,
+        short flags,
+        void *cb_data,
+        void (*handler)(lcb_socket_t sock,
+            short which,
+            void *cb_data))
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    rb_mt_event *event = eventp;
+    short old_flags = event->flags;
+
+    if (event->inserted && old_flags == flags &&
+            cb_data == event->cb_data && handler == event->handler)
+    {
+        return 0;
+    }
+    loop_remove_event(loop, event);
+    event->flags = flags;
+    event->cb_data = cb_data;
+    event->handler = handler;
+    event->socket = sock;
+    if (!event->inserted) {
+        events_insert(&loop->events, event);
+    }
+    if ((old_flags & flags) != old_flags) {
+        events_fix_flags(&loop->events, sock);
+    }
+    return 0;
+}
+
+    static void
+lcb_io_delete_event(struct lcb_io_opt_st *iops,
+        lcb_socket_t sock,
+        void *event)
+{
+    loop_remove_event((rb_mt_loop*)iops->v.v0.cookie, (rb_mt_event*)event);
+    (void)sock;
+}
+
+    static void
+lcb_io_destroy_event(struct lcb_io_opt_st *iops,
+        void *event)
+{
+    lcb_io_delete_event(iops, -1, event);
+    free(event);
+}
+
+    static void *
+lcb_io_create_timer(struct lcb_io_opt_st *iops)
+{
+    rb_mt_timer *timer = calloc(1, sizeof(*timer));
+    timer->index = -1;
+    (void)iops;
+    return timer;
+}
+
+    static int
+lcb_io_update_timer(struct lcb_io_opt_st *iops, void *event,
+        lcb_uint32_t usec, void *cb_data,
+        void (*handler)(lcb_socket_t sock, short which, void *cb_data))
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    rb_mt_timer *timer = event;
+
+    timer->period = usec * (hrtime_t)1000;
+    timer->ts = gethrtime() + timer->period;
+    timer->cb_data = cb_data;
+    timer->handler = handler;
+    if (timer->index != -1) {
+        timers_heapify_item(&loop->timers, timer->index);
+    } else {
+        timers_insert(&loop->timers, timer);
+    }
+    return 0;
+}
+
+    static void
+lcb_io_delete_timer(struct lcb_io_opt_st *iops, void *event)
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    rb_mt_timer *timer = event;
+    if (timer->index != -1) {
+        timers_remove_timer(&loop->timers, timer);
+    }
+}
+
+    static void
+lcb_io_destroy_timer(struct lcb_io_opt_st *iops, void *timer)
+{
+    lcb_io_delete_timer(iops, timer);
+    free(timer);
+}
+
+    static void
+lcb_io_stop_event_loop(struct lcb_io_opt_st *iops)
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    loop->run = 0;
+}
+
+    static void
+lcb_io_run_event_loop(struct lcb_io_opt_st *iops)
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    loop_run(loop);
+}
+
+    static void
+lcb_destroy_io_opts(struct lcb_io_opt_st *iops)
+{
+    rb_mt_loop *loop = iops->v.v0.cookie;
+    loop_destroy(loop);
+    free(iops);
+}
+
+    LIBCOUCHBASE_API lcb_error_t
+cb_create_ruby_mt_io_opts(int version, lcb_io_opt_t *io, void *arg)
+{
+    struct lcb_io_opt_st *ret;
+    rb_mt_loop *loop;
+    (void)arg;
+    if (version != 0) {
+        return LCB_PLUGIN_VERSION_MISMATCH;
+    }
+    ret = calloc(1, sizeof(*ret));
+    if (ret == NULL) {
+        free(ret);
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    ret->version = 0;
+    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.v0.need_cleanup = 0;
+    ret->v.v0.recv = lcb_io_recv;
+    ret->v.v0.send = lcb_io_send;
+    ret->v.v0.recvv = lcb_io_recvv;
+    ret->v.v0.sendv = lcb_io_sendv;
+    ret->v.v0.socket = lcb_io_socket;
+    ret->v.v0.close = lcb_io_close;
+    ret->v.v0.connect = lcb_io_connect;
+    ret->v.v0.delete_event = lcb_io_delete_event;
+    ret->v.v0.destroy_event = lcb_io_destroy_event;
+    ret->v.v0.create_event = lcb_io_create_event;
+    ret->v.v0.update_event = lcb_io_update_event;
+
+    ret->v.v0.delete_timer = lcb_io_delete_timer;
+    ret->v.v0.destroy_timer = lcb_io_destroy_timer;
+    ret->v.v0.create_timer = lcb_io_create_timer;
+    ret->v.v0.update_timer = lcb_io_update_timer;
+
+    ret->v.v0.run_event_loop = lcb_io_run_event_loop;
+    ret->v.v0.stop_event_loop = lcb_io_stop_event_loop;
+
+    loop = loop_create();
+    if (loop == NULL) {
+        free(ret);
+        return LCB_CLIENT_ENOMEM;
+    }
+    ret->v.v0.cookie = loop;
+    *io = ret;
+    return LCB_SUCCESS;
+}
+#endif /* _WIN32 */