couchbase 1.3.4-x64-mingw32

data/ext/couchbase_ext/delete.c

@@ -0,0 +1,163 @@
+/* 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"
+
+    void
+cb_delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_remove_resp_t *resp)
+{
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
+    VALUE key, exc = Qnil, res;
+
+    ctx->nqueries--;
+    key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
+    cb_strip_key_prefix(bucket, key);
+
+    if (error != LCB_KEY_ENOENT || !ctx->quiet) {
+        exc = cb_check_error(error, "failed to remove value", key);
+        if (exc != Qnil) {
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_delete);
+            ctx->exception = exc;
+        }
+    }
+    if (bucket->async) {    /* asynchronous */
+        if (ctx->proc != Qnil) {
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            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(bucket, ctx->proc, 1, res);
+        }
+    } else {                /* synchronous */
+        rb_hash_aset(ctx->rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
+    }
+    if (ctx->nqueries == 0) {
+        ctx->proc = Qnil;
+        if (bucket->async) {
+            cb_context_free(ctx);
+        }
+    }
+    (void)handle;
+}
+
+/*
+ * Delete the specified key
+ *
+ * @since 1.0.0
+ *
+ * @overload delete(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *     Otherwise it will raise error in synchronous mode. In asynchronous
+ *     mode this option ignored.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to
+ *     update/delete an item simultaneously.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+ *   @raise [Couchbase::Error::NotFound] if key is missing in verbose mode
+ *
+ *   @return [true, false, Hash<String, Boolean>] the result of the
+ *     operation
+ *
+ *   @example Delete the key in quiet mode (default)
+ *     c.set("foo", "bar")
+ *     c.delete("foo")        #=> true
+ *     c.delete("foo")        #=> false
+ *
+ *   @example Delete the key verbosely
+ *     c.set("foo", "bar")
+ *     c.delete("foo", :quiet => false)   #=> true
+ *     c.delete("foo", :quiet => true)    #=> nil (default behaviour)
+ *     c.delete("foo", :quiet => false)   #=> will raise Couchbase::Error::NotFound
+ *
+ *   @example Delete the key with version check
+ *     ver = c.set("foo", "bar")          #=> 5992859822302167040
+ *     c.delete("foo", :cas => 123456)    #=> will raise Couchbase::Error::KeyExists
+ *     c.delete("foo", :cas => ver)       #=> true
+ */
+    VALUE
+cb_bucket_delete(int argc, VALUE *argv, VALUE self)
+{
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
+    VALUE rv, exc;
+    VALUE proc;
+    lcb_error_t err;
+    struct cb_params_st params;
+
+    if (!cb_bucket_connected_bang(bucket, cb_sym_delete)) {
+        return Qnil;
+    }
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
+    if (!bucket->async && proc != Qnil) {
+        rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
+    }
+    rb_funcall(params.args, cb_id_flatten_bang, 0);
+    params.type = cb_cmd_remove;
+    params.bucket = bucket;
+    cb_params_build(&params);
+
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.remove.num);
+    ctx->quiet = params.cmd.remove.quiet;
+    err = lcb_remove(bucket->handle, (const void *)ctx,
+            params.cmd.remove.num, params.cmd.remove.ptr);
+    cb_params_destroy(&params);
+    exc = cb_check_error(err, "failed to schedule delete request", Qnil);
+    if (exc != Qnil) {
+        cb_context_free(ctx);
+        rb_exc_raise(exc);
+    }
+    bucket->nbytes += params.npayload;
+    if (bucket->async) {
+        cb_maybe_do_loop(bucket);
+        return Qnil;
+    } else {
+        if (ctx->nqueries > 0) {
+            /* we have some operations pending */
+            lcb_wait(bucket->handle);
+        }
+        exc = ctx->exception;
+        rv = ctx->rv;
+        cb_context_free(ctx);
+        if (exc != Qnil) {
+            rb_exc_raise(exc);
+        }
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
+        }
+        if (params.cmd.remove.num > 1) {
+            return rv;  /* return as a hash {key => true, ...} */
+        } else {
+            VALUE vv = Qnil;
+            rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
+            return vv;
+        }
+        return rv;
+    }
+}

data/ext/couchbase_ext/eventmachine_plugin.c

@@ -0,0 +1,452 @@
+/* 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
+#ifdef BUILD_EVENTMACHINE_PLUGIN
+
+#include <errno.h>
+
+VALUE cb_mEm;
+VALUE cb_cEmSocket;
+VALUE em_cPeriodicTimer;
+VALUE cb_cEmEvent;
+VALUE rb_mObSpace;
+ID cb_id_add_timer;
+ID cb_id_cancel_timer;
+ID cb_id_detach;
+ID cb_id_define_finalizer;
+ID cb_id_iv_event;
+ID cb_id_notify_readable_p;
+ID cb_id_notify_writable_p;
+ID cb_id_set_notify_readable;
+ID cb_id_set_notify_writable;
+ID cb_id_undefine_finalizer;
+ID cb_id_watch;
+VALUE cb_sym_clear_holder;
+VALUE cb_sym_resume;
+
+typedef struct rb_em_event rb_em_event;
+typedef struct rb_em_loop rb_em_loop;
+struct rb_em_event {
+    lcb_socket_t socket;
+    void *cb_data;
+    void (*handler)(lcb_socket_t sock, short which, void *cb_data);
+    VALUE holder;
+    lcb_uint32_t usec;
+    short canceled;
+    short current_flags;
+    VALUE self;
+    rb_em_loop *loop;
+};
+
+struct rb_em_loop {
+    VALUE fiber;
+    struct cb_bucket_st *bucket;
+};
+
+    static void
+rb_em_event_mark(void *p)
+{
+    if (p) {
+        rb_em_event *ev = p;
+        rb_gc_mark(ev->holder);
+        rb_gc_mark(ev->loop->bucket->self);
+    }
+}
+
+    static void
+rb_em_event_free(void *p)
+{
+    if (p) {
+        rb_em_event *ev = p;
+        ev->self = 0;
+        ev->holder = 0;
+        ev->loop = NULL;
+    }
+}
+
+    static void
+rb_em_event_run_callback(rb_em_event *ev, short flags)
+{
+    if (ev->loop->fiber) {
+        ev->current_flags = flags;
+        rb_fiber_resume(ev->loop->fiber, 1, &ev->self);
+    } else {
+        ev->handler(ev->socket, flags, ev->cb_data);
+    }
+}
+
+    static VALUE
+rb_em_event_call(VALUE self)
+{
+    rb_em_event *ev;
+    Data_Get_Struct(self, rb_em_event, ev);
+
+    ev->holder = 0;
+    rb_em_event_run_callback(ev, 0);
+
+    if (!ev->canceled && !ev->holder) {
+        ev->holder = rb_funcall_2(em_m, cb_id_add_timer, rb_float_new((double)ev->usec / 1.0e6), self);
+    }
+
+    return Qnil;
+}
+
+    static VALUE
+rb_em_event_clear_holder(VALUE self)
+{
+    rb_em_event *ev;
+    Data_Get_Struct(self, rb_em_event, ev);
+
+    ev->holder = 0;
+
+    return Qnil;
+}
+
+    static void
+rb_em_event_setup_finalizer(rb_em_event *ev)
+{
+    rb_funcall_2(rb_mObSpace, cb_id_define_finalizer, ev->holder,
+                 rb_obj_method(ev->self, cb_sym_clear_holder));
+}
+
+    static void
+rb_em_event_clear_finalizer(rb_em_event *ev)
+{
+    rb_funcall_1(rb_mObSpace, cb_id_undefine_finalizer, ev->holder);
+}
+
+    static VALUE
+rb_em_socket_notify_readable(VALUE self)
+{
+    VALUE event = rb_ivar_get(self, cb_id_iv_event);
+    rb_em_event *ev;
+
+    if (RTEST(event)) {
+        Data_Get_Struct(event, rb_em_event, ev);
+        rb_em_event_run_callback(ev, LCB_READ_EVENT);
+    } else {
+        rb_funcall_0(self, cb_id_detach);
+    }
+
+    return Qnil;
+}
+
+    static VALUE
+rb_em_socket_notify_writable(VALUE self)
+{
+    VALUE event = rb_ivar_get(self, cb_id_iv_event);
+    rb_em_event *ev;
+
+    if (RTEST(event)) {
+        Data_Get_Struct(event, rb_em_event, ev);
+        rb_em_event_run_callback(ev, LCB_WRITE_EVENT);
+    } else {
+        rb_funcall_0(self, cb_id_detach);
+    }
+
+    return Qnil;
+}
+
+    static void
+cb_gc_em_loop_mark(void *p, struct cb_bucket_st *bucket)
+{
+    rb_em_loop *loop = p;
+    rb_gc_mark(loop->fiber);
+    (void)bucket;
+}
+
+    static rb_em_loop *
+rb_em_loop_create(struct cb_bucket_st *bucket)
+{
+    rb_em_loop *loop = calloc(1, sizeof(*loop));
+    loop->bucket = bucket;
+    cb_gc_protect_ptr(bucket, loop, cb_gc_em_loop_mark);
+    return loop;
+}
+
+    static void
+rb_em_loop_destroy(rb_em_loop *loop)
+{
+    cb_gc_unprotect_ptr(loop->bucket, loop);
+    free(loop);
+}
+
+    static void
+initialize_event_machine_plugin() {
+    VALUE em_cConnection;
+
+    rb_mObSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+
+    em_m = rb_const_get(rb_cObject, rb_intern("EM"));
+    em_cConnection = rb_const_get(em_m, rb_intern("Connection"));
+    em_cPeriodicTimer = rb_const_get(em_m, rb_intern("PeriodicTimer"));
+
+    cb_mEm = rb_define_module_under(cb_mCouchbase, "EM");
+
+    cb_cEmEvent = rb_define_class_under(cb_mEm, "Event", rb_cObject);
+    rb_define_method(cb_cEmEvent, "call", rb_em_event_call, 0);
+    rb_define_method(cb_cEmEvent, "clear_holder", rb_em_event_clear_holder, 0);
+
+    cb_cEmSocket = rb_define_class_under(cb_mEm, "Socket", em_cConnection);
+    rb_define_method(cb_cEmSocket, "notify_readable", rb_em_socket_notify_readable, 0);
+    rb_define_method(cb_cEmSocket, "notify_writable", rb_em_socket_notify_writable, 0);
+
+    cb_id_add_timer = rb_intern("add_timer");
+    cb_id_cancel_timer = rb_intern("cancel_timer");
+    cb_id_define_finalizer = rb_intern("define_finalizer");
+    cb_id_detach = rb_intern("detach");
+    cb_id_iv_event = rb_intern("@event");
+    cb_id_notify_readable_p = rb_intern("notify_readable?");
+    cb_id_notify_writable_p = rb_intern("notify_writable?");
+    cb_id_set_notify_readable = rb_intern("notify_readable=");
+    cb_id_set_notify_writable = rb_intern("notify_writable=");
+    cb_id_undefine_finalizer = rb_intern("undefine_finalizer");
+    cb_id_watch = rb_intern("watch");
+    cb_sym_clear_holder = ID2SYM(rb_intern("clear_holder"));
+    cb_sym_resume = ID2SYM(rb_intern("resume"));
+}
+
+    static void
+cb_gc_em_event_mark(void *p, struct cb_bucket_st *bucket)
+{
+    rb_em_event *ev = p;
+    rb_gc_mark(ev->self);
+    (void)bucket;
+}
+
+    static void *
+lcb_io_create_event(struct lcb_io_opt_st *iops)
+{
+    rb_em_loop *loop = iops->v.v0.cookie;
+    rb_em_event *ev = calloc(1, sizeof(rb_em_event));
+    VALUE res = Data_Wrap_Struct(cb_cEmEvent, rb_em_event_mark, rb_em_event_free, ev);
+    cb_gc_protect_ptr(loop->bucket, ev, cb_gc_em_event_mark);
+    ev->self = res;
+    ev->loop = loop;
+    ev->socket = -1;
+
+    return ev;
+}
+
+    static inline void
+rb_em_event_dealloc(rb_em_event *ev, rb_em_loop *loop)
+{
+    if (ev->self) {
+        DATA_PTR(ev->self) = 0;
+    }
+    cb_gc_unprotect_ptr(loop->bucket, ev);
+    free(ev);
+}
+
+    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))
+{
+    rb_em_event *ev = event;
+
+    if (ev->holder == 0) {
+        ev->holder = rb_funcall_2(em_m, cb_id_watch, INT2FIX(sock), cb_cEmSocket);
+        rb_ivar_set(ev->holder, cb_id_iv_event, ev->self);
+        rb_em_event_setup_finalizer(ev);
+    }
+
+    ev->socket = sock;
+    ev->cb_data = cb_data;
+    ev->handler = handler;
+
+    rb_funcall_1(ev->holder, cb_id_set_notify_readable, (flags & LCB_READ_EVENT) ? Qtrue : Qfalse);
+    rb_funcall_1(ev->holder, cb_id_set_notify_writable, (flags & LCB_WRITE_EVENT) ? Qtrue : Qfalse);
+
+    (void)iops;
+    return 0;
+}
+
+    static void
+lcb_io_delete_event(struct lcb_io_opt_st *iops,
+        lcb_socket_t sock,
+        void *event)
+{
+    rb_em_event *ev = event;
+    if (ev->holder) {
+        rb_funcall_1(ev->holder, cb_id_set_notify_readable, Qfalse);
+        rb_funcall_1(ev->holder, cb_id_set_notify_writable, Qfalse);
+    }
+    (void)sock;
+    (void)iops;
+}
+
+    static void
+lcb_io_destroy_event(struct lcb_io_opt_st *iops,
+        void *event)
+{
+    rb_em_loop *loop = iops->v.v0.cookie;
+    rb_em_event *ev = event;
+    if (ev->holder) {
+        rb_em_event_clear_finalizer(ev);
+        rb_ivar_set(ev->holder, cb_id_iv_event, Qfalse);
+        rb_funcall_0(ev->holder, cb_id_detach);
+        ev->holder = 0;
+    }
+    rb_em_event_dealloc(ev, loop);
+}
+
+#define lcb_io_create_timer lcb_io_create_event
+
+    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))
+{
+    rb_em_event *ev = timer;
+
+    if (ev->holder) {
+        rb_funcall_1(em_m, cb_id_cancel_timer, ev->holder);
+        ev->holder = 0;
+    }
+
+    ev->socket = (lcb_socket_t)-1;
+    ev->cb_data = cb_data;
+    ev->handler = handler;
+    ev->usec = usec;
+    ev->canceled = 0;
+    ev->holder = rb_funcall_2(em_m, cb_id_add_timer, rb_float_new((double)usec / 1.0e6), ev->self);
+
+    (void)iops;
+    return 0;
+}
+
+    static void
+lcb_io_delete_timer(struct lcb_io_opt_st *iops, void *timer)
+{
+    rb_em_event *ev = timer;
+
+    if (ev->holder) {
+        rb_funcall_1(em_m, cb_id_cancel_timer, ev->holder);
+        ev->holder = 0;
+    }
+    ev->canceled = 1;
+    (void)iops;
+}
+
+    static void
+lcb_io_destroy_timer(struct lcb_io_opt_st *iops, void *timer)
+{
+    rb_em_loop *loop = iops->v.v0.cookie;
+    rb_em_event *ev = timer;
+    if (!ev->canceled) {
+        lcb_io_delete_timer(iops, timer);
+    }
+    rb_em_event_dealloc(ev, loop);
+}
+
+    static void
+lcb_io_run_event_loop(struct lcb_io_opt_st *iops)
+{
+    rb_em_loop *loop = iops->v.v0.cookie;
+    VALUE fiber = rb_fiber_current();
+    VALUE event;
+    rb_em_event *ev;
+    loop->fiber = fiber;
+    for(;;) {
+        event = rb_fiber_yield(0, NULL);
+        if (!RTEST(event)) break;
+        Data_Get_Struct(event, rb_em_event, ev);
+        ev->handler(ev->socket, ev->current_flags, ev->cb_data);
+    }
+}
+
+    static void
+lcb_io_stop_event_loop(struct lcb_io_opt_st *iops)
+{
+    rb_em_loop *loop = iops->v.v0.cookie;
+    VALUE fiber = loop->fiber;
+    loop->fiber = 0;
+    if (fiber) {
+        VALUE method = rb_obj_method(fiber, cb_sym_resume);
+        rb_funcall_1(em_m, cb_id_next_tick, method);
+    }
+}
+
+    static void
+lcb_destroy_io_opts(struct lcb_io_opt_st *iops)
+{
+    rb_em_loop_destroy((rb_em_loop*)iops->v.v0.cookie);
+}
+
+    LIBCOUCHBASE_API lcb_error_t
+cb_create_ruby_em_io_opts(int version, lcb_io_opt_t *io, void *arg)
+{
+    struct lcb_io_opt_st *ret;
+    rb_em_loop *loop;
+    struct cb_bucket_st *bucket = arg;
+
+    if (version != 0) {
+        return LCB_PLUGIN_VERSION_MISMATCH;
+    }
+
+    if (!em_m) initialize_event_machine_plugin();
+
+    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 = cb_io_recv;
+    ret->v.v0.send = cb_io_send;
+    ret->v.v0.recvv = cb_io_recvv;
+    ret->v.v0.sendv = cb_io_sendv;
+    ret->v.v0.socket = cb_io_socket;
+    ret->v.v0.close = cb_io_close;
+    ret->v.v0.connect = cb_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 = rb_em_loop_create(bucket);
+    ret->v.v0.cookie = loop;
+
+    *io = ret;
+    return LCB_SUCCESS;
+}
+
+#endif
+#endif