couchbase 1.1.5-x86-mingw32 → 1.2.0.beta-x86-mingw32

data/ext/couchbase_ext/timer.c

@@ -0,0 +1,192 @@
+/* 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_timer_free(void *ptr)
+{
+    xfree(ptr);
+}
+
+    void
+cb_timer_mark(void *ptr)
+{
+    struct timer_st *timer = ptr;
+    if (timer) {
+        rb_gc_mark(timer->callback);
+    }
+}
+
+    VALUE
+cb_timer_alloc(VALUE klass)
+{
+    VALUE obj;
+    struct timer_st *timer;
+
+    /* allocate new bucket struct and set it to zero */
+    obj = Data_Make_Struct(klass, struct timer_st, cb_timer_mark,
+            cb_timer_free, timer);
+    return obj;
+}
+
+/*
+ * Returns a string containing a human-readable representation of the
+ * Timer.
+ *
+ * @since 1.2.0.dp6
+ *
+ * @return [String]
+ */
+    VALUE
+cb_timer_inspect(VALUE self)
+{
+    VALUE str;
+    struct timer_st *tm = DATA_PTR(self);
+    char buf[200];
+
+    str = rb_str_buf_new2("#<");
+    rb_str_buf_cat2(str, rb_obj_classname(self));
+    snprintf(buf, 20, ":%p", (void *)self);
+    rb_str_buf_cat2(str, buf);
+    snprintf(buf, 100, " timeout:%u periodic:%s>",
+            tm->usec, tm->periodic ? "true" : "false");
+    rb_str_buf_cat2(str, buf);
+
+    return str;
+}
+
+/*
+ * Cancel the timer.
+ *
+ * @since 1.2.0.dp6
+ *
+ * This operation makes sense for periodic timers or if one need to cancel
+ * regular timer before it will be triggered.
+ *
+ * @example Cancel periodic timer
+ *   n = 1
+ *   c.run do
+ *     tm = c.create_periodic_timer(500000) do
+ *       c.incr("foo") do
+ *         if n == 5
+ *           tm.cancel
+ *         else
+ *           n += 1
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ * @return [String]
+ */
+    VALUE
+cb_timer_cancel(VALUE self)
+{
+    struct timer_st *tm = DATA_PTR(self);
+    lcb_timer_destroy(tm->bucket->handle, tm->timer);
+    return self;
+}
+
+    static VALUE
+trigger_timer(VALUE timer)
+{
+    struct timer_st *tm = DATA_PTR(timer);
+    return cb_proc_call(tm->callback, 1, timer);
+}
+
+    static void
+timer_callback(lcb_timer_t timer, lcb_t instance,
+        const void *cookie)
+{
+    struct timer_st *tm = (struct timer_st *)cookie;
+    int error = 0;
+
+    rb_protect(trigger_timer, tm->self, &error);
+    if (error) {
+        lcb_timer_destroy(instance, timer);
+    }
+    (void)cookie;
+}
+
+/*
+ * Initialize new Timer
+ *
+ * @since 1.2.0
+ *
+ * The timers could used to trigger reccuring events or implement timeouts.
+ * The library will call given block after time interval pass.
+ *
+ * @param bucket [Bucket] the connection object
+ * @param interval [Fixnum] the interval in microseconds
+ * @param options [Hash]
+ * @option options [Boolean] :periodic (false) set it to +true+ if the timer
+ *   should be triggered until it will be canceled.
+ *
+ * @yieldparam [Timer] timer the current timer
+ *
+ * @example Create regular timer for 0.5 second
+ *   c.run do
+ *     Couchbase::Timer.new(c, 500000) do
+ *       puts "ding-dong"
+ *     end
+ *   end
+ *
+ * @example Create periodic timer
+ *   n = 10
+ *   c.run do
+ *     Couchbase::Timer.new(c, 500000, :periodic => true) do |tm|
+ *       puts "#{n}"
+ *       n -= 1
+ *       tm.cancel if n.zero?
+ *     end
+ *   end
+ *
+ *
+ * @return [Couchbase::Timer]
+ */
+    VALUE
+cb_timer_init(int argc, VALUE *argv, VALUE self)
+{
+    struct timer_st *tm = DATA_PTR(self);
+    VALUE bucket, opts, timeout, exc, cb;
+    lcb_error_t err;
+
+    rb_need_block();
+    rb_scan_args(argc, argv, "21&", &bucket, &timeout, &opts, &cb);
+
+    if (CLASS_OF(bucket) != cBucket) {
+        rb_raise(rb_eTypeError, "wrong argument type (expected Couchbase::Bucket)");
+    }
+    tm->self = self;
+    tm->callback = cb;
+    tm->usec = NUM2ULONG(timeout);
+    tm->bucket = DATA_PTR(bucket);
+    if (opts != Qnil) {
+        Check_Type(opts, T_HASH);
+        tm->periodic = RTEST(rb_hash_aref(opts, sym_periodic));
+    }
+    tm->timer = lcb_timer_create(tm->bucket->handle, tm, tm->usec,
+            tm->periodic, timer_callback, &err);
+    exc = cb_check_error(err, "failed to attach the timer", Qnil);
+    if (exc != Qnil) {
+        rb_exc_raise(exc);
+    }
+
+    return self;
+}
+

data/ext/couchbase_ext/touch.c

@@ -0,0 +1,190 @@
+/* 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
+touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_touch_resp_t *resp)
+{
+    struct context_st *ctx = (struct context_st *)cookie;
+    struct bucket_st *bucket = ctx->bucket;
+    VALUE key, *rv = ctx->rv, exc = Qnil, res;
+
+    ctx->nqueries--;
+    key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
+    strip_key_prefix(bucket, key);
+
+    if (error != LCB_KEY_ENOENT || !ctx->quiet) {
+        exc = cb_check_error(error, "failed to touch value", key);
+        if (exc != Qnil) {
+            rb_ivar_set(exc, id_iv_operation, sym_touch);
+            if (NIL_P(ctx->exception)) {
+                ctx->exception = cb_gc_protect(bucket, exc);
+            }
+        }
+    }
+
+    if (bucket->async) {    /* asynchronous */
+        if (ctx->proc != Qnil) {
+            res = rb_class_new_instance(0, NULL, cResult);
+            rb_ivar_set(res, id_iv_error, exc);
+            rb_ivar_set(res, id_iv_operation, sym_touch);
+            rb_ivar_set(res, id_iv_key, key);
+            cb_proc_call(ctx->proc, 1, res);
+        }
+    } else {                /* synchronous */
+        rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
+    }
+    if (ctx->nqueries == 0) {
+        cb_gc_unprotect(bucket, ctx->proc);
+    }
+    (void)handle;
+}
+
+/*
+ * Update the expiry time of an item
+ *
+ * @since 1.0.0
+ *
+ * The +touch+ method allow you to update the expiration time on a given
+ * key. This can be useful for situations where you want to prevent an item
+ * from expiring without resetting the associated value. For example, for a
+ * session database you might want to keep the session alive in the database
+ * each time the user accesses a web page without explicitly updating the
+ * session value, keeping the user's session active and available.
+ *
+ * @overload touch(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [true, false] +true+ if the operation was successful and +false+
+ *     otherwise.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Touch value using +default_ttl+
+ *     c.touch("foo")
+ *
+ *   @example Touch value using custom TTL (10 seconds)
+ *     c.touch("foo", :ttl => 10)
+ *
+ * @overload touch(keys)
+ *   @param keys [Hash] The Hash where keys represent the keys in the
+ *     database, values -- the expiry times for corresponding key. See
+ *     description of +:ttl+ argument above for more information about TTL
+ *     values.
+ *
+ *   @yieldparam ret [Result] the result of operation for each key in
+ *     asynchronous mode (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Hash] Mapping keys to result of touch operation (+true+ if the
+ *     operation was successful and +false+ otherwise)
+ *
+ *   @example Touch several values
+ *     c.touch("foo" => 10, :bar => 20) #=> {"foo" => true, "bar" => true}
+ *
+ *   @example Touch several values in async mode
+ *     c.run do
+ *       c.touch("foo" => 10, :bar => 20) do |ret|
+ *          ret.operation   #=> :touch
+ *          ret.success?    #=> true
+ *          ret.key         #=> "foo" and "bar" in separate calls
+ *       end
+ *     end
+ *
+ *   @example Touch single value
+ *     c.touch("foo" => 10)             #=> true
+ *
+ */
+   VALUE
+cb_bucket_touch(int argc, VALUE *argv, VALUE self)
+{
+    struct bucket_st *bucket = DATA_PTR(self);
+    struct context_st *ctx;
+    VALUE args, rv, proc, exc;
+    lcb_error_t err;
+    struct params_st params;
+
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
+    rb_scan_args(argc, argv, "0*&", &args, &proc);
+    if (!bucket->async && proc != Qnil) {
+        rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
+    }
+    rb_funcall(args, id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct params_st));
+    params.type = cmd_touch;
+    params.bucket = bucket;
+    cb_params_build(&params, RARRAY_LEN(args), args);
+    ctx = xcalloc(1, sizeof(struct context_st));
+    if (ctx == NULL) {
+        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+    }
+    ctx->proc = cb_gc_protect(bucket, proc);
+    ctx->bucket = bucket;
+    rv = rb_hash_new();
+    ctx->rv = &rv;
+    ctx->exception = Qnil;
+    ctx->quiet = params.cmd.touch.quiet;
+    ctx->nqueries = params.cmd.touch.num;
+    err = lcb_touch(bucket->handle, (const void *)ctx,
+            params.cmd.touch.num, params.cmd.touch.ptr);
+    cb_params_destroy(&params);
+    exc = cb_check_error(err, "failed to schedule touch request", Qnil);
+    if (exc != Qnil) {
+        xfree(ctx);
+        rb_exc_raise(exc);
+    }
+    bucket->nbytes += params.npayload;
+    if (bucket->async) {
+        maybe_do_loop(bucket);
+        return Qnil;
+    } else {
+        if (ctx->nqueries > 0) {
+            /* we have some operations pending */
+            lcb_wait(bucket->handle);
+        }
+        exc = ctx->exception;
+        xfree(ctx);
+        if (exc != Qnil) {
+            rb_exc_raise(cb_gc_unprotect(bucket, exc));
+        }
+        if (bucket->exception != Qnil) {
+            rb_exc_raise(bucket->exception);
+        }
+        if (params.cmd.touch.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;
+        }
+    }
+}
+
+

data/ext/couchbase_ext/unlock.c

@@ -0,0 +1,180 @@
+/* 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
+unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp)
+{
+    struct context_st *ctx = (struct context_st *)cookie;
+    struct bucket_st *bucket = ctx->bucket;
+    VALUE key, *rv = ctx->rv, exc = Qnil, res;
+
+    ctx->nqueries--;
+    key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
+    strip_key_prefix(bucket, key);
+
+    if (error != LCB_KEY_ENOENT || !ctx->quiet) {
+        exc = cb_check_error(error, "failed to unlock value", key);
+        if (exc != Qnil) {
+            rb_ivar_set(exc, id_iv_operation, sym_unlock);
+            if (NIL_P(ctx->exception)) {
+                ctx->exception = cb_gc_protect(bucket, exc);
+            }
+        }
+    }
+
+    if (bucket->async) {    /* asynchronous */
+        if (ctx->proc != Qnil) {
+            res = rb_class_new_instance(0, NULL, cResult);
+            rb_ivar_set(res, id_iv_error, exc);
+            rb_ivar_set(res, id_iv_operation, sym_unlock);
+            rb_ivar_set(res, id_iv_key, key);
+            cb_proc_call(ctx->proc, 1, res);
+        }
+    } else {                /* synchronous */
+        rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
+    }
+    if (ctx->nqueries == 0) {
+        cb_gc_unprotect(bucket, ctx->proc);
+    }
+    (void)handle;
+}
+
+/*
+ * Unlock key
+ *
+ * @since 1.2.0
+ *
+ * The +unlock+ method allow you to unlock key once locked by {Bucket#get}
+ * with +:lock+ option.
+ *
+ * @overload unlock(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :cas The CAS value must match the current one
+ *     from the storage.
+ *   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *
+ *   @return [true, false] +true+ if the operation was successful and +false+
+ *     otherwise.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @raise [Couchbase::Error::NotFound] if key(s) not found in the storage
+ *
+ *   @raise [Couchbase::Error::TemporaryFail] if either the key wasn't
+ *      locked or given CAS value doesn't match to actual in the storage
+ *
+ *   @example Unlock the single key
+ *     val, _, cas = c.get("foo", :lock => true, :extended => true)
+ *     c.unlock("foo", :cas => cas)
+ *
+ * @overload unlock(keys)
+ *   @param keys [Hash] The Hash where keys represent the keys in the
+ *     database, values -- the CAS for corresponding key.
+ *
+ *   @yieldparam ret [Result] the result of operation for each key in
+ *     asynchronous mode (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Hash] Mapping keys to result of unlock operation (+true+ if the
+ *     operation was successful and +false+ otherwise)
+ *
+ *   @example Unlock several keys
+ *     c.unlock("foo" => cas1, :bar => cas2) #=> {"foo" => true, "bar" => true}
+ *
+ *   @example Unlock several values in async mode
+ *     c.run do
+ *       c.unlock("foo" => 10, :bar => 20) do |ret|
+ *          ret.operation   #=> :unlock
+ *          ret.success?    #=> true
+ *          ret.key         #=> "foo" and "bar" in separate calls
+ *       end
+ *     end
+ *
+ */
+   VALUE
+cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
+{
+    struct bucket_st *bucket = DATA_PTR(self);
+    struct context_st *ctx;
+    VALUE args, rv, proc, exc;
+    lcb_error_t err;
+    struct params_st params;
+
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
+    rb_scan_args(argc, argv, "0*&", &args, &proc);
+    if (!bucket->async && proc != Qnil) {
+        rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
+    }
+    rb_funcall(args, id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct params_st));
+    params.type = cmd_unlock;
+    params.bucket = bucket;
+    cb_params_build(&params, RARRAY_LEN(args), args);
+    ctx = xcalloc(1, sizeof(struct context_st));
+    if (ctx == NULL) {
+        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+    }
+    ctx->proc = cb_gc_protect(bucket, proc);
+    ctx->bucket = bucket;
+    rv = rb_hash_new();
+    ctx->rv = &rv;
+    ctx->exception = Qnil;
+    ctx->quiet = params.cmd.unlock.quiet;
+    ctx->nqueries = params.cmd.unlock.num;
+    err = lcb_unlock(bucket->handle, (const void *)ctx,
+            params.cmd.unlock.num, params.cmd.unlock.ptr);
+    cb_params_destroy(&params);
+    exc = cb_check_error(err, "failed to schedule unlock request", Qnil);
+    if (exc != Qnil) {
+        xfree(ctx);
+        rb_exc_raise(exc);
+    }
+    bucket->nbytes += params.npayload;
+    if (bucket->async) {
+        maybe_do_loop(bucket);
+        return Qnil;
+    } else {
+        if (ctx->nqueries > 0) {
+            /* we have some operations pending */
+            lcb_wait(bucket->handle);
+        }
+        exc = ctx->exception;
+        xfree(ctx);
+        if (exc != Qnil) {
+            rb_exc_raise(cb_gc_unprotect(bucket, exc));
+        }
+        if (bucket->exception != Qnil) {
+            rb_exc_raise(bucket->exception);
+        }
+        if (params.cmd.unlock.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;
+        }
+    }
+}
+
+