couchbase 1.2.1-x86-mingw32 → 1.2.2-x86-mingw32

data/ext/couchbase_ext/context.c

@@ -0,0 +1,64 @@
+/* vim: ft=c et ts=8 sts=4 sw=4 cino=
+ *
+ *   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.
+ */
+
+#include "couchbase_ext.h"
+
+    static void
+cb_context_mark(void *p, struct cb_bucket_st* bucket)
+{
+    struct cb_context_st *ctx = p;
+    rb_gc_mark(ctx->proc);
+    rb_gc_mark(ctx->rv);
+    rb_gc_mark(ctx->exception);
+    rb_gc_mark(ctx->observe_options);
+    rb_gc_mark(ctx->force_format);
+    rb_gc_mark(ctx->operation);
+    rb_gc_mark(ctx->headers_val);
+    (void)bucket;
+}
+
+    struct cb_context_st *
+cb_context_alloc(struct cb_bucket_st* bucket)
+{
+    struct cb_context_st *ctx = calloc(1, sizeof(*ctx));
+    if (ctx == NULL) {
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
+    }
+    cb_gc_protect_ptr(bucket, ctx, cb_context_mark);
+    ctx->bucket = bucket;
+    ctx->exception = Qnil;
+    return ctx;
+}
+
+    struct cb_context_st *
+cb_context_alloc_common(struct cb_bucket_st *bucket, VALUE proc, size_t nqueries)
+{
+    struct cb_context_st *ctx = cb_context_alloc(bucket);
+    ctx->proc = proc;
+    ctx->nqueries = nqueries;
+    if (!bucket->async) {
+        ctx->rv = rb_hash_new();
+    }
+    return ctx;
+}
+
+    void
+cb_context_free(struct cb_context_st *ctx)
+{
+    cb_gc_unprotect_ptr(ctx->bucket, ctx);
+    free(ctx);
+}

data/ext/couchbase_ext/couchbase_ext.c

@@ -30,19 +30,23 @@ VALUE cb_mError;
 VALUE cb_mMarshal;
 VALUE cb_mMultiJson;
 VALUE cb_mURI;
+VALUE em_m;
 
 /* Symbols */
 ID cb_sym_add;
 ID cb_sym_append;
 ID cb_sym_assemble_hash;
+ID cb_sym_async;
 ID cb_sym_body;
 ID cb_sym_bucket;
 ID cb_sym_cas;
 ID cb_sym_chunked;
+ID cb_sym_cluster;
+ID cb_sym_connect;
 ID cb_sym_content_type;
 ID cb_sym_create;
-ID cb_sym_cluster;
 ID cb_sym_decrement;
+ID cb_sym_default;
 ID cb_sym_default_arithmetic_init;
 ID cb_sym_default_flags;
 ID cb_sym_default_format;
@@ -52,7 +56,9 @@ ID cb_sym_delete;
 ID cb_sym_delta;
 ID cb_sym_development;
 ID cb_sym_document;
+ID cb_sym_engine;
 ID cb_sym_environment;
+ID cb_sym_eventmachine;
 ID cb_sym_extended;
 ID cb_sym_flags;
 ID cb_sym_format;
@@ -63,6 +69,8 @@ ID cb_sym_http_request;
 ID cb_sym_increment;
 ID cb_sym_initial;
 ID cb_sym_key_prefix;
+ID cb_sym_libev;
+ID cb_sym_libevent;
 ID cb_sym_lock;
 ID cb_sym_management;
 ID cb_sym_marshal;
@@ -95,8 +103,10 @@ ID cb_sym_unlock;
 ID cb_sym_username;
 ID cb_sym_version;
 ID cb_sym_view;
+ID cb_id_add_shutdown_hook;
 ID cb_id_arity;
 ID cb_id_call;
+ID cb_id_create_timer;
 ID cb_id_delete;
 ID cb_id_dump;
 ID cb_id_dup;
@@ -120,6 +130,7 @@ ID cb_id_iv_time_to_replicate;
 ID cb_id_iv_value;
 ID cb_id_load;
 ID cb_id_match;
+ID cb_id_next_tick;
 ID cb_id_observe_and_wait;
 ID cb_id_parse;
 ID cb_id_parse_body_bang;
@@ -170,11 +181,26 @@ VALUE cb_eBadHandleError;          /* LCB_EBADHANDLE = 0x1c      */
 /* Default Strings */
 VALUE cb_vStrDefault;
 VALUE cb_vStrEmpty;
+VALUE cb_vStrLocalhost;
+
+    static VALUE
+cb_intern_string(VALUE ar, const char *str)
+{
+    VALUE tmp = STR_NEW_CSTR(str);
+    rb_str_freeze(tmp);
+    rb_ary_push(ar, tmp);
+    return tmp;
+}
 
 /* Ruby Extension initializer */
     void
 Init_couchbase_ext(void)
 {
+    VALUE interned;
+
+    /* just a holder for EventMachine module */
+    em_m = 0;
+
     cb_mMultiJson = rb_const_get(rb_cObject, rb_intern("MultiJson"));
     cb_mURI = rb_const_get(rb_cObject, rb_intern("URI"));
     cb_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
@@ -505,6 +531,7 @@ Init_couchbase_ext(void)
      */
     cb_cResult = rb_define_class_under(cb_mCouchbase, "Result", rb_cObject);
     rb_define_method(cb_cResult, "inspect", cb_result_inspect, 0);
+    rb_define_method(cb_cResult, "to_s", cb_result_inspect, 0);
     rb_define_method(cb_cResult, "success?", cb_result_success_p, 0);
     /* Document-method: operation
      *
@@ -535,6 +562,7 @@ Init_couchbase_ext(void)
      * @return [String]
      */
     rb_define_attr(cb_cResult, "value", 1, 0);
+    rb_define_alias(cb_cResult, "bucket", "value");
     cb_id_iv_value = rb_intern("@value");
     /* Document-method: cas
      *
@@ -816,27 +844,82 @@ Init_couchbase_ext(void)
      *
      * This callback is using to deliver exceptions in asynchronous mode.
      *
-     * @yieldparam [Symbol] op The operation caused the error
-     * @yieldparam [String] key The key which cause the error or +nil+
      * @yieldparam [Exception] exc The exception instance
      *
      * @example Using lambda syntax
-     *   connection = Couchbase.new(:async => true)
-     *   connection.on_error = lambda {|op, key, exc| ... }
+     *   connection = Couchbase.connect
+     *   connection.on_error = lambda {|exc| ... }
      *   connection.run do |conn|
      *     conn.set("foo", "bar")
      *   end
      *
      * @example Using block syntax
-     *   connection = Couchbase.new(:async => true)
-     *   connection.on_error {|op, key, exc| ... }
-     *   ...
+     *   connection = Couchbase.connect
+     *   connection.on_error {|exc| ... }
+     *   connection.run do |conn|
+     *     conn.set("foo", "bar")
+     *   end
      *
      * @return [Proc] the effective callback */
     /* rb_define_attr(cb_cBucket, "on_error", 1, 1); */
     rb_define_method(cb_cBucket, "on_error", cb_bucket_on_error_get, 0);
     rb_define_method(cb_cBucket, "on_error=", cb_bucket_on_error_set, 1);
 
+    /* Document-method: on_connect
+     * Connection callback for asynchronous mode.
+     *
+     * @since 1.3.0
+     *
+     * This callback used to notify that bucket instance is connected
+     * and ready to handle requests in asynchronous mode.
+     *
+     * @yieldparam [Result] result The result instance, with valid
+     *   properties +#error+, +#success?+, +#operation+ and +#bucket+
+     *
+     * @example Using lambda syntax
+     *   connection = Couchbase.new(:async => true)
+     *   connection.on_connect = lambda do |ret|
+     *     if ret.success?
+     *       conn.set("foo", "bar")
+     *     end
+     *   end
+     *   connection.run
+     *
+     * @example Using block syntax
+     *   connection = Couchbase.new(:async => true)
+     *   connection.run do |conn|
+     *     connection.on_connect do |ret|
+     *       if ret.success?
+     *         conn.set("foo", "bar")
+     *       end
+     *     end
+     *   end
+     *
+     * @example
+     *   EM.run do
+     *     pool = Pool.new
+     *     connection = Couchbase.new(:engine => :eventmachine, :async => true)
+     *     connection.on_connect do |result|
+     *       unless result.success?
+     *         $stderr.puts "Could not connect to CouchBase #{result.error}"
+     *       else
+     *         pool.add result.bucket
+     *       end
+     *     end
+     *   end
+     *
+     * @example
+     *   EM.run do
+     *     pool = Pool.new
+     *     connection = Couchbase.new(:engine => :eventmachine, :async => true)
+     *     connection.on_connect = pool.method(:couchbase_connect_callback)
+     *   end
+     *
+     * @return [Proc] the effective callback */
+    /* rb_define_attr(cb_cBucket, "on_connect", 1, 1); */
+    rb_define_method(cb_cBucket, "on_connect", cb_bucket_on_connect_get, 0);
+    rb_define_method(cb_cBucket, "on_connect=", cb_bucket_on_connect_set, 1);
+
     /* Document-method: url
      *
      * The config url for this connection.
@@ -994,8 +1077,10 @@ Init_couchbase_ext(void)
     rb_define_method(cb_cTimer, "cancel", cb_timer_cancel, 0);
 
     /* Define cb_symbols */
+    cb_id_add_shutdown_hook = rb_intern("add_shutdown_hook");
     cb_id_arity = rb_intern("arity");
     cb_id_call = rb_intern("call");
+    cb_id_create_timer = rb_intern("create_timer");
     cb_id_delete = rb_intern("delete");
     cb_id_dump = rb_intern("dump");
     cb_id_dup = rb_intern("dup");
@@ -1004,6 +1089,7 @@ Init_couchbase_ext(void)
     cb_id_host = rb_intern("host");
     cb_id_load = rb_intern("load");
     cb_id_match = rb_intern("match");
+    cb_id_next_tick = rb_intern("next_tick");
     cb_id_observe_and_wait = rb_intern("observe_and_wait");
     cb_id_parse = rb_intern("parse");
     cb_id_parse_body_bang = rb_intern("parse_body!");
@@ -1019,14 +1105,17 @@ Init_couchbase_ext(void)
     cb_sym_add = ID2SYM(rb_intern("add"));
     cb_sym_append = ID2SYM(rb_intern("append"));
     cb_sym_assemble_hash = ID2SYM(rb_intern("assemble_hash"));
+    cb_sym_async = ID2SYM(rb_intern("async"));
     cb_sym_body = ID2SYM(rb_intern("body"));
     cb_sym_bucket = ID2SYM(rb_intern("bucket"));
     cb_sym_cas = ID2SYM(rb_intern("cas"));
     cb_sym_chunked = ID2SYM(rb_intern("chunked"));
     cb_sym_cluster = ID2SYM(rb_intern("cluster"));
+    cb_sym_connect = ID2SYM(rb_intern("connect"));
     cb_sym_content_type = ID2SYM(rb_intern("content_type"));
     cb_sym_create = ID2SYM(rb_intern("create"));
     cb_sym_decrement = ID2SYM(rb_intern("decrement"));
+    cb_sym_default = ID2SYM(rb_intern("default"));
     cb_sym_default_arithmetic_init = ID2SYM(rb_intern("default_arithmetic_init"));
     cb_sym_default_flags = ID2SYM(rb_intern("default_flags"));
     cb_sym_default_format = ID2SYM(rb_intern("default_format"));
@@ -1035,7 +1124,9 @@ Init_couchbase_ext(void)
     cb_sym_delta = ID2SYM(rb_intern("delta"));
     cb_sym_development = ID2SYM(rb_intern("development"));
     cb_sym_document = ID2SYM(rb_intern("document"));
+    cb_sym_engine = ID2SYM(rb_intern("engine"));
     cb_sym_environment = ID2SYM(rb_intern("environment"));
+    cb_sym_eventmachine = ID2SYM(rb_intern("eventmachine"));
     cb_sym_extended = ID2SYM(rb_intern("extended"));
     cb_sym_flags = ID2SYM(rb_intern("flags"));
     cb_sym_format = ID2SYM(rb_intern("format"));
@@ -1046,6 +1137,8 @@ Init_couchbase_ext(void)
     cb_sym_increment = ID2SYM(rb_intern("increment"));
     cb_sym_initial = ID2SYM(rb_intern("initial"));
     cb_sym_key_prefix = ID2SYM(rb_intern("key_prefix"));
+    cb_sym_libev = ID2SYM(rb_intern("libev"));
+    cb_sym_libevent = ID2SYM(rb_intern("libevent"));
     cb_sym_lock = ID2SYM(rb_intern("lock"));
     cb_sym_management = ID2SYM(rb_intern("management"));
     cb_sym_marshal = ID2SYM(rb_intern("marshal"));
@@ -1079,10 +1172,9 @@ Init_couchbase_ext(void)
     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);
+    interned = rb_ary_new();
+    rb_const_set(cb_mCouchbase, rb_intern("_INTERNED"), interned);
+    cb_vStrDefault = cb_intern_string(interned, "default");
+    cb_vStrEmpty = cb_intern_string(interned, "");
+    cb_vStrLocalhost = cb_intern_string(interned, "localhost");
 }

data/ext/couchbase_ext/couchbase_ext.h

@@ -23,6 +23,9 @@
 #endif
 
 #include "couchbase_config.h"
+#ifdef HAVE_RB_FIBER_YIELD
+#define BUILD_EVENTMACHINE_PLUGIN
+#endif
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
@@ -54,13 +57,20 @@ extern hrtime_t gethrtime(void);
 #ifndef HAVE_RB_HASH_LOOKUP2
 VALUE rb_hash_lookup2(VALUE, VALUE, VALUE);
 #endif
+#ifndef HAVE_TYPE_ST_INDEX_T
+typedef st_data_t st_index_t;
+#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(" ")); \
-    rb_funcall(rb_stderr, rb_intern("print"), 1, rb_funcall(OBJ, rb_intern("class"), 0)); \
-    rb_funcall(rb_stderr, rb_intern("print"), 1, STR_NEW_CSTR(" ")); \
-    rb_funcall(rb_stderr, rb_intern("puts"), 1, rb_funcall(OBJ, rb_intern("inspect"), 0));
+#define cb_debug_object(OBJ) do { \
+    VALUE debug_args[6] = { \
+        rb_funcall(OBJ, rb_intern("object_id"), 0), \
+        STR_NEW_CSTR(" "), \
+        rb_funcall(OBJ, rb_intern("class"), 0), \
+        STR_NEW_CSTR(" "), \
+        rb_funcall(OBJ, rb_intern("inspect"), 0), \
+        STR_NEW_CSTR("\n") }; \
+    rb_funcall2(rb_stderr, rb_intern("print"), 6, debug_args); \
+} while(0)
 
 #define CB_FMT_MASK        0x3
 #define CB_FMT_DOCUMENT    0x0
@@ -81,8 +91,12 @@ struct cb_bucket_st
     VALUE bucket;
     VALUE username;
     VALUE password;
+    VALUE engine;
     int async;
     int quiet;
+    uint8_t connected;       /* non-zero if instance has been connected. it is possible to defer connection with :async option */
+    uint8_t running;         /* non-zero if event loop is running */
+    uint8_t trigger_connect_cb_on_set; /* if non-zero, the on_connect callback will be triggered immediately after set */
     VALUE default_format;    /* should update +default_flags+ on change */
     uint32_t default_flags;
     time_t default_ttl;
@@ -94,10 +108,13 @@ struct cb_bucket_st
     size_t nbytes;          /* the number of bytes scheduled to be sent */
     VALUE exception;        /* error delivered by error_callback */
     VALUE on_error_proc;    /* is using to deliver errors in async mode */
+    VALUE on_connect_proc;  /* used to notify that instance ready to handle requests in async mode */
     VALUE environment;      /* sym_development or sym_production */
     VALUE key_prefix_val;
     VALUE node_list;
-    VALUE object_space;
+    st_table *object_space;
+    char destroying;
+    char async_disconnect_hook_set;
     VALUE self;             /* the pointer to bucket representation in ruby land */
 };
 
@@ -107,7 +124,7 @@ struct cb_context_st
     struct cb_bucket_st* bucket;
     int extended;
     VALUE proc;
-    void *rv;
+    VALUE rv;
     VALUE exception;
     VALUE observe_options;
     VALUE force_format;
@@ -117,7 +134,6 @@ struct cb_context_st
     struct cb_http_request_st *request;
     int quiet;
     int arith;           /* incr: +1, decr: -1, other: 0 */
-    int http_cancel_on_error;
     size_t nqueries;
 };
 
@@ -156,19 +172,23 @@ extern VALUE cb_mError;
 extern VALUE cb_mMarshal;
 extern VALUE cb_mMultiJson;
 extern VALUE cb_mURI;
+extern VALUE em_m;
 
 /* Symbols */
 extern ID cb_sym_add;
 extern ID cb_sym_append;
 extern ID cb_sym_assemble_hash;
+extern ID cb_sym_async;
 extern ID cb_sym_body;
 extern ID cb_sym_bucket;
 extern ID cb_sym_cas;
 extern ID cb_sym_chunked;
 extern ID cb_sym_cluster;
+extern ID cb_sym_connect;
 extern ID cb_sym_content_type;
 extern ID cb_sym_create;
 extern ID cb_sym_decrement;
+extern ID cb_sym_default;
 extern ID cb_sym_default_arithmetic_init;
 extern ID cb_sym_default_flags;
 extern ID cb_sym_default_format;
@@ -178,7 +198,9 @@ extern ID cb_sym_delete;
 extern ID cb_sym_delta;
 extern ID cb_sym_development;
 extern ID cb_sym_document;
+extern ID cb_sym_engine;
 extern ID cb_sym_environment;
+extern ID cb_sym_eventmachine;
 extern ID cb_sym_extended;
 extern ID cb_sym_flags;
 extern ID cb_sym_format;
@@ -189,6 +211,8 @@ extern ID cb_sym_http_request;
 extern ID cb_sym_increment;
 extern ID cb_sym_initial;
 extern ID cb_sym_key_prefix;
+extern ID cb_sym_libev;
+extern ID cb_sym_libevent;
 extern ID cb_sym_lock;
 extern ID cb_sym_management;
 extern ID cb_sym_marshal;
@@ -221,8 +245,10 @@ extern ID cb_sym_unlock;
 extern ID cb_sym_username;
 extern ID cb_sym_version;
 extern ID cb_sym_view;
+extern ID cb_id_add_shutdown_hook;
 extern ID cb_id_arity;
 extern ID cb_id_call;
+extern ID cb_id_create_timer;
 extern ID cb_id_delete;
 extern ID cb_id_dump;
 extern ID cb_id_dup;
@@ -246,6 +272,7 @@ extern ID cb_id_iv_time_to_replicate;
 extern ID cb_id_iv_value;
 extern ID cb_id_load;
 extern ID cb_id_match;
+extern ID cb_id_next_tick;
 extern ID cb_id_observe_and_wait;
 extern ID cb_id_parse;
 extern ID cb_id_parse_body_bang;
@@ -295,12 +322,15 @@ extern VALUE cb_eBadHandleError;          /* LCB_EBADHANDLE = 0x1c      */
 /* Default Strings */
 extern VALUE cb_vStrDefault;
 extern VALUE cb_vStrEmpty;
+extern VALUE cb_vStrLocalhost;
 
+typedef void (*mark_f)(void *, struct cb_bucket_st*);
 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);
+int cb_bucket_connected_bang(struct cb_bucket_st *bucket, VALUE operation);
+void cb_gc_protect_ptr(struct cb_bucket_st *bucket, void *ptr, mark_f mark_func);
+void cb_gc_unprotect_ptr(struct cb_bucket_st *bucket, void *ptr);
 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);
@@ -325,6 +355,10 @@ void cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void
 void cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp);
 void cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp);
 
+struct cb_context_st *cb_context_alloc(struct cb_bucket_st *bucket);
+struct cb_context_st *cb_context_alloc_common(struct cb_bucket_st *bucket, VALUE proc, size_t nqueries);
+void cb_context_free(struct cb_context_st *ctx);
+
 VALUE cb_bucket_alloc(VALUE klass);
 void cb_bucket_free(void *ptr);
 VALUE cb_bucket_init_copy(VALUE copy, VALUE orig);
@@ -360,6 +394,8 @@ VALUE cb_bucket_default_format_get(VALUE self);
 VALUE cb_bucket_default_format_set(VALUE self, VALUE val);
 VALUE cb_bucket_on_error_set(VALUE self, VALUE val);
 VALUE cb_bucket_on_error_get(VALUE self);
+VALUE cb_bucket_on_connect_set(VALUE self, VALUE val);
+VALUE cb_bucket_on_connect_get(VALUE self);
 VALUE cb_bucket_timeout_get(VALUE self);
 VALUE cb_bucket_timeout_set(VALUE self, VALUE val);
 VALUE cb_bucket_key_prefix_get(VALUE self);
@@ -535,12 +571,45 @@ struct cb_params_st
     size_t idx;
     /* the approximate size of the data to be sent */
     size_t npayload;
+    VALUE ensurance;
+    VALUE args;
 };
 
 void cb_params_destroy(struct cb_params_st *params);
-void cb_params_build(struct cb_params_st *params, int argc, VALUE argv);
+void cb_params_build(struct cb_params_st *params);
 
+/* common plugin functions */
+lcb_ssize_t cb_io_recv(struct lcb_io_opt_st *iops, lcb_socket_t sock, void *buffer, lcb_size_t len, int flags);
+lcb_ssize_t cb_io_recvv(struct lcb_io_opt_st *iops, lcb_socket_t sock, struct lcb_iovec_st *iov, lcb_size_t niov);
+lcb_ssize_t cb_io_send(struct lcb_io_opt_st *iops, lcb_socket_t sock, const void *msg, lcb_size_t len, int flags);
+lcb_ssize_t cb_io_sendv(struct lcb_io_opt_st *iops, lcb_socket_t sock, struct lcb_iovec_st *iov, lcb_size_t niov);
+lcb_socket_t cb_io_socket(struct lcb_io_opt_st *iops, int domain, int type, int protocol);
+void cb_io_close(struct lcb_io_opt_st *iops, lcb_socket_t sock);
+int cb_io_connect(struct lcb_io_opt_st *iops, lcb_socket_t sock, const struct sockaddr *name, unsigned int namelen);
+
+/* plugin init functions */
 LIBCOUCHBASE_API
 lcb_error_t cb_create_ruby_mt_io_opts(int version, lcb_io_opt_t *io, void *arg);
+
+/* shortcut functions */
+    static inline VALUE
+rb_funcall_0(VALUE self, ID method)
+{
+    return rb_funcall2(self, method, 0, NULL);
+}
+
+    static inline VALUE
+rb_funcall_1(VALUE self, ID method, VALUE arg)
+{
+    return rb_funcall2(self, method, 1, &arg);
+}
+
+    static inline VALUE
+rb_funcall_2(VALUE self, ID method, VALUE arg1, VALUE arg2)
+{
+    VALUE args[2] = {arg1, arg2};
+    return rb_funcall2(self, method, 2, args);
+}
+
 #endif