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

data/ext/couchbase_ext/observe.c

@@ -22,13 +22,13 @@ cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, res, *rv = ctx->rv, exc;
+    VALUE key, res, exc;
 
     if (resp->v.v0.key) {
         key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
         exc = cb_check_error(error, "failed to execute observe request", key);
         if (exc != Qnil) {
-            ctx->exception = cb_gc_protect(bucket, exc);
+            ctx->exception = exc;
         }
         res = rb_class_new_instance(0, NULL, cb_cResult);
         rb_ivar_set(res, cb_id_iv_completed, Qfalse);
@@ -58,10 +58,10 @@ cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
             }
         } else {             /* synchronous */
             if (NIL_P(ctx->exception)) {
-                VALUE stats = rb_hash_aref(*rv, key);
+                VALUE stats = rb_hash_aref(ctx->rv, key);
                 if (NIL_P(stats)) {
                     stats = rb_ary_new();
-                    rb_hash_aset(*rv, key, stats);
+                    rb_hash_aset(ctx->rv, key, stats);
                 }
                 rb_ary_push(stats, res);
             }
@@ -73,9 +73,9 @@ cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
             cb_proc_call(bucket, ctx->proc, 1, res);
         }
         ctx->nqueries--;
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
     (void)handle;
@@ -115,37 +115,29 @@ cb_bucket_observe(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE args, rv, proc, exc;
+    VALUE rv, proc, exc;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_observe)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    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");
     }
-    memset(&params, 0, sizeof(struct cb_params_st));
     params.type = cb_cmd_observe;
     params.bucket = bucket;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_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;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, 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) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -158,9 +150,9 @@ cb_bucket_observe(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         exc = bucket->exception;

data/ext/couchbase_ext/plugin_common.c

@@ -0,0 +1,171 @@
+/* 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
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#ifndef RUBY_WIN32_H
+#  include <unistd.h>
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+#define INVALID_SOCKET (-1)
+#else /* RUBY_WIN32_h */
+static st_table *socket_2_fd = NULL;
+#endif
+
+/* Copied from libev plugin */
+    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 ret = recv(sock, buffer, len, flags);
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+    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)
+{
+    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;
+}
+
+    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 ret = send(sock, msg, len, flags);
+    if (ret < 0) {
+        iops->v.v0.error = errno;
+    }
+    return ret;
+}
+
+    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)
+{
+    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 = 0;
+#ifdef F_GETFL
+    if ((flags = fcntl(sock, F_GETFL, NULL)) < 0) {
+        return -1;
+    }
+#endif
+    if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+
+    static int
+close_socket(lcb_socket_t sock)
+{
+    return close(sock);
+}
+
+    lcb_socket_t
+cb_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;
+}
+
+    void
+cb_io_close(struct lcb_io_opt_st *iops, lcb_socket_t sock)
+{
+    close_socket(sock);
+    (void)iops;
+}
+
+    int
+cb_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;
+}
+
+#endif

data/ext/couchbase_ext/result.c

@@ -28,7 +28,7 @@
     VALUE
 cb_result_success_p(VALUE self)
 {
-    return RTEST(rb_ivar_get(self, cb_id_iv_error)) ? Qfalse : Qtrue;
+    return RTEST(rb_attr_get(self, cb_id_iv_error)) ? Qfalse : Qtrue;
 }
 
 /*
@@ -49,67 +49,73 @@ cb_result_inspect(VALUE self)
     snprintf(buf, 100, ":%p", (void *)self);
     rb_str_buf_cat2(str, buf);
 
-    attr = rb_ivar_get(self, cb_id_iv_operation);
+    attr = rb_attr_get(self, cb_id_iv_operation);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " operation=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_error);
+    attr = rb_attr_get(self, cb_id_iv_error);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " error=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_key);
+    attr = rb_attr_get(self, cb_id_iv_value);
+    if (RTEST(attr) && rb_obj_is_kind_of(attr, cb_cBucket)) {
+        rb_str_buf_cat2(str, " bucket="); /* value also accessible using alias #bucket */
+        rb_str_append(str, rb_inspect(attr));
+    }
+
+    attr = rb_attr_get(self, cb_id_iv_key);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " key=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_status);
+    attr = rb_attr_get(self, cb_id_iv_status);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " status=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_cas);
+    attr = rb_attr_get(self, cb_id_iv_cas);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " cas=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_flags);
+    attr = rb_attr_get(self, cb_id_iv_flags);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " flags=0x");
         rb_str_append(str, rb_funcall(attr, cb_id_to_s, 1, INT2FIX(16)));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_node);
+    attr = rb_attr_get(self, cb_id_iv_node);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " node=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, cb_id_iv_from_master);
+    attr = rb_attr_get(self, cb_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, cb_id_iv_time_to_persist);
+    attr = rb_attr_get(self, cb_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, cb_id_iv_time_to_replicate);
+    attr = rb_attr_get(self, cb_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, cb_id_iv_headers);
+    attr = rb_attr_get(self, cb_id_iv_headers);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " headers=");
         rb_str_append(str, rb_inspect(attr));

data/ext/couchbase_ext/stats.c

@@ -22,13 +22,13 @@ cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE stats, node, key, val, *rv = ctx->rv, exc = Qnil, res;
+    VALUE stats, node, key, val, 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, cb_id_iv_operation, cb_sym_stats);
-        ctx->exception = cb_gc_protect(bucket, exc);
+        ctx->exception = exc;
     }
     if (node != Qnil) {
         key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -45,18 +45,18 @@ cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
-                stats = rb_hash_aref(*rv, key);
+                stats = rb_hash_aref(ctx->rv, key);
                 if (NIL_P(stats)) {
                     stats = rb_hash_new();
-                    rb_hash_aset(*rv, key, stats);
+                    rb_hash_aset(ctx->rv, key, stats);
                 }
                 rb_hash_aset(stats, node, val);
             }
         }
     } else {
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
     (void)handle;
@@ -109,37 +109,29 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE rv, exc, args, proc;
+    VALUE rv, exc, proc;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_stats)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    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");
     }
-    memset(&params, 0, sizeof(struct cb_params_st));
     params.type = cb_cmd_stats;
     params.bucket = bucket;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_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;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, 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) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -152,9 +144,9 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         exc = bucket->exception;