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

data/ext/couchbase_ext/observe.c

@@ -0,0 +1,174 @@
+/* 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
+observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp)
+{
+    struct context_st *ctx = (struct context_st *)cookie;
+    struct bucket_st *bucket = ctx->bucket;
+    VALUE key, res, *rv = ctx->rv;
+
+    if (resp->v.v0.key) {
+        key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
+        ctx->exception = cb_check_error(error, "failed to execute observe request", key);
+        if (ctx->exception) {
+            cb_gc_protect(bucket, ctx->exception);
+        }
+        res = rb_class_new_instance(0, NULL, cResult);
+        rb_ivar_set(res, id_iv_completed, Qfalse);
+        rb_ivar_set(res, id_iv_error, ctx->exception);
+        rb_ivar_set(res, id_iv_operation, sym_observe);
+        rb_ivar_set(res, id_iv_key, key);
+        rb_ivar_set(res, id_iv_cas, ULL2NUM(resp->v.v0.cas));
+        rb_ivar_set(res, id_iv_from_master, resp->v.v0.from_master ? Qtrue : Qfalse);
+        rb_ivar_set(res, id_iv_time_to_persist, ULONG2NUM(resp->v.v0.ttp));
+        rb_ivar_set(res, id_iv_time_to_replicate, ULONG2NUM(resp->v.v0.ttr));
+        switch (resp->v.v0.status) {
+            case LCB_OBSERVE_FOUND:
+                rb_ivar_set(res, id_iv_status, sym_found);
+                break;
+            case LCB_OBSERVE_PERSISTED:
+                rb_ivar_set(res, id_iv_status, sym_persisted);
+                break;
+            case LCB_OBSERVE_NOT_FOUND:
+                rb_ivar_set(res, id_iv_status, sym_not_found);
+                break;
+            default:
+                rb_ivar_set(res, id_iv_status, Qnil);
+        }
+        if (bucket->async) { /* asynchronous */
+            if (ctx->proc != Qnil) {
+                cb_proc_call(ctx->proc, 1, res);
+            }
+        } else {             /* synchronous */
+            if (NIL_P(ctx->exception)) {
+                VALUE stats = rb_hash_aref(*rv, key);
+                if (NIL_P(stats)) {
+                    stats = rb_ary_new();
+                    rb_hash_aset(*rv, key, stats);
+                }
+                rb_ary_push(stats, res);
+            }
+        }
+    } else {
+        if (bucket->async && ctx->proc != Qnil) {
+            res = rb_class_new_instance(0, NULL, cResult);
+            rb_ivar_set(res, id_iv_completed, Qtrue);
+            cb_proc_call(ctx->proc, 1, res);
+        }
+        ctx->nqueries--;
+        cb_gc_unprotect(bucket, ctx->proc);
+    }
+    (void)handle;
+}
+
+/*
+ * Observe key state
+ *
+ * @since 1.2.0.dp6
+ *
+ * @overload observe(*keys, options = {})
+ *   @param keys [String, Symbol, Array] One or several keys to fetch
+ *   @param options [Hash] Options for operation.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +status+, +operation+, +key+, +cas+,
+ *     +from_master+, +time_to_persist+, +time_to_replicate+).
+ *
+ *   @return [Hash<String, Array<Result>>, Array<Result>] the state of the
+ *     keys on all nodes. If the +keys+ argument was String or Symbol, this
+ *     method will return just array of results (result per each node),
+ *     otherwise it will return hash map.
+ *
+ *   @example Observe single key
+ *     c.observe("foo")
+ *     #=> [#<Couchbase::Result:0x00000001650df0 ...>, ...]
+ *
+ *   @example Observe multiple keys
+ *     keys = ["foo", "bar"]
+ *     stats = c.observe(keys)
+ *     stats.size   #=> 2
+ *     stats["foo"] #=> [#<Couchbase::Result:0x00000001650df0 ...>, ...]
+ */
+
+    VALUE
+cb_bucket_observe(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");
+    }
+    memset(&params, 0, sizeof(struct params_st));
+    params.type = cmd_observe;
+    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->nqueries = params.cmd.observe.num;
+    err = lcb_observe(bucket->handle, (const void *)ctx,
+            params.cmd.observe.num, params.cmd.observe.ptr);
+    cb_params_destroy(&params);
+    exc = cb_check_error(err, "failed to schedule observe 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) {
+            cb_gc_unprotect(bucket, exc);
+            rb_exc_raise(exc);
+        }
+        if (bucket->exception != Qnil) {
+            rb_exc_raise(bucket->exception);
+        }
+        if (params.cmd.observe.num > 1 || params.cmd.observe.array) {
+            return rv;  /* return as a hash {key => {}, ...} */
+        } else {
+            VALUE vv = Qnil;
+            rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
+            return vv;  /* return first value */
+        }
+    }
+}

data/ext/couchbase_ext/result.c

@@ -0,0 +1,126 @@
+/* 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"
+
+/*
+ * Check if result of operation was successful.
+ *
+ * @since 1.0.0
+ *
+ * @return [true, false] +false+ if there is an +error+ object attached,
+ *   +false+ otherwise.
+ */
+    VALUE
+cb_result_success_p(VALUE self)
+{
+    return RTEST(rb_ivar_get(self, id_iv_error)) ? Qfalse : Qtrue;
+}
+
+/*
+ * Returns a string containing a human-readable representation of the Result.
+ *
+ * @since 1.0.0
+ *
+ * @return [String]
+ */
+    VALUE
+cb_result_inspect(VALUE self)
+{
+    VALUE str, attr, error;
+    char buf[100];
+
+    str = rb_str_buf_new2("#<");
+    rb_str_buf_cat2(str, rb_obj_classname(self));
+    snprintf(buf, 100, ":%p", (void *)self);
+    rb_str_buf_cat2(str, buf);
+
+    attr = rb_ivar_get(self, id_iv_error);
+    if (RTEST(attr)) {
+        error = rb_ivar_get(attr, id_iv_error);
+    } else {
+        error = INT2FIX(0);
+    }
+    rb_str_buf_cat2(str, " error=0x");
+    rb_str_append(str, rb_funcall(error, id_to_s, 1, INT2FIX(16)));
+
+    attr = rb_ivar_get(self, id_iv_operation);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " operation=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_key);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " key=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_status);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " status=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_cas);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " cas=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_flags);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " flags=0x");
+        rb_str_append(str, rb_funcall(attr, id_to_s, 1, INT2FIX(16)));
+    }
+
+    attr = rb_ivar_get(self, id_iv_node);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " node=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_from_master);
+    if (attr != Qnil) {
+        rb_str_buf_cat2(str, " from_master=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_time_to_persist);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " time_to_persist=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_time_to_replicate);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " time_to_replicate=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_ivar_get(self, id_iv_headers);
+    if (RTEST(attr)) {
+        rb_str_buf_cat2(str, " headers=");
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    rb_str_buf_cat2(str, ">");
+
+    return str;
+}
+
+

data/ext/couchbase_ext/stats.c

@@ -0,0 +1,169 @@
+/* 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
+stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_stat_resp_t *resp)
+{
+    struct context_st *ctx = (struct context_st *)cookie;
+    struct bucket_st *bucket = ctx->bucket;
+    VALUE stats, node, key, val, *rv = ctx->rv, exc = Qnil, res;
+
+    node = resp->v.v0.server_endpoint ? STR_NEW_CSTR(resp->v.v0.server_endpoint) : Qnil;
+    exc = cb_check_error(error, "failed to fetch stats", node);
+    if (exc != Qnil) {
+        rb_ivar_set(exc, id_iv_operation, sym_stats);
+        if (NIL_P(ctx->exception)) {
+            ctx->exception = cb_gc_protect(bucket, exc);
+        }
+    }
+    if (node != Qnil) {
+        key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
+        val = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
+        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_stats);
+                rb_ivar_set(res, id_iv_node, node);
+                rb_ivar_set(res, id_iv_key, key);
+                rb_ivar_set(res, id_iv_value, val);
+                cb_proc_call(ctx->proc, 1, res);
+            }
+        } else {                /* synchronous */
+            if (NIL_P(exc)) {
+                stats = rb_hash_aref(*rv, key);
+                if (NIL_P(stats)) {
+                    stats = rb_hash_new();
+                    rb_hash_aset(*rv, key, stats);
+                }
+                rb_hash_aset(stats, node, val);
+            }
+        }
+    } else {
+        ctx->nqueries--;
+        cb_gc_unprotect(bucket, ctx->proc);
+    }
+    (void)handle;
+}
+
+/*
+ * Request server statistics.
+ *
+ * @since 1.0.0
+ *
+ * Fetches stats from each node in cluster. Without a key specified the
+ * server will respond with a "default" set of statistical information. In
+ * asynchronous mode each statistic is returned in separate call where the
+ * Result object yielded (+#key+ contains the name of the statistical item
+ * and the +#value+ contains the value, the +#node+ will indicate the server
+ * address). In synchronous mode it returns the hash of stats keys and
+ * node-value pairs as a value.
+ *
+ * @overload stats(arg = nil)
+ *   @param [String] arg argument to STATS query
+ *   @yieldparam [Result] ret the object with +node+, +key+ and +value+
+ *     attributes.
+ *
+ *   @example Found how many items in the bucket
+ *     total = 0
+ *     c.stats["total_items"].each do |key, value|
+ *       total += value.to_i
+ *     end
+ *
+ *   @example Found total items number asynchronously
+ *     total = 0
+ *     c.run do
+ *       c.stats do |ret|
+ *         if ret.key == "total_items"
+ *           total += ret.value.to_i
+ *         end
+ *       end
+ *     end
+ *
+ *   @example Get memory stats (works on couchbase buckets)
+ *     c.stats(:memory)   #=> {"mem_used"=>{...}, ...}
+ *
+ *   @return [Hash] where keys are stat keys, values are host-value pairs
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ */
+    VALUE
+cb_bucket_stats(int argc, VALUE *argv, VALUE self)
+{
+    struct bucket_st *bucket = DATA_PTR(self);
+    struct context_st *ctx;
+    VALUE rv, exc, args, proc;
+    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");
+    }
+    memset(&params, 0, sizeof(struct params_st));
+    params.type = cmd_stats;
+    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");
+    }
+    rv = rb_hash_new();
+    ctx->rv = &rv;
+    ctx->bucket = bucket;
+    ctx->proc = cb_gc_protect(bucket, proc);
+    ctx->exception = Qnil;
+    ctx->nqueries = params.cmd.stats.num;
+    err = lcb_server_stats(bucket->handle, (const void *)ctx,
+            params.cmd.stats.num, params.cmd.stats.ptr);
+    exc = cb_check_error(err, "failed to schedule stat request", Qnil);
+    cb_params_destroy(&params);
+    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) {
+            cb_gc_unprotect(bucket, exc);
+            rb_exc_raise(exc);
+        }
+        if (bucket->exception != Qnil) {
+            rb_exc_raise(bucket->exception);
+        }
+        return rv;
+    }
+
+    return Qnil;
+}
+
+