couchbase 1.2.0.z.beta2-x86-mingw32 → 1.2.0.z.beta3-x86-mingw32

data/HISTORY.markdown

@@ -1,3 +1,18 @@
+## 1.2.0.z.beta3 / 2012-10-12
+
+* Update view API
+* Mention couchbase-model and em-couchbase in README
+* Use global scope to find Error classes (thanks to @wr0ngway)
+* RCBC-87 Fix build error on macos
+* Use lcb_breakout()
+* Propogate status code for HTTP responses
+* Extract params encoding for easier reusage
+* Destory IO operations struct (fix memleak)
+* Don't try to convert error to number, it is exception object
+* Update error codes
+* Implement bucket create/delete operations
+* Fixup FLUSH tests
+
 ## 1.2.0.z.beta2 / 2012-09-19
 
 * RCBC-82 Fix extconf.rb for RVM/MacOS. (Not all rubies are fat on MacOS)

data/README.markdown

@@ -1,6 +1,13 @@
-# Couchbase Ruby Client [![Build Status](https://secure.travis-ci.org/couchbase/couchbase-ruby-client.png?branch=master)](http://travis-ci.org/couchbase/couchbase-ruby-client)
+# Couchbase Ruby Client
 
-This is the official client library for use with Couchbase Server.
+This is the official client library for use with Couchbase Server. There
+are related libraries available:
+
+* [couchbase-model][6] the ActiveModel implementation, git repository:
+  [https://github.com/couchbase/couchbase-ruby-model][7]
+
+* [em-couchbase][8] EventMachine friendly implementation of couchbase
+  client, git repository: [https://github.com/couchbase/couchbase-ruby-client-em][9]
 
 ## SUPPORT
 
@@ -519,3 +526,8 @@ the error is detected.
 [3]: http://www.couchbase.com/develop/c/current
 [4]: https://github.com/mxcl/homebrew/pulls/avsej
 [5]: http://code.google.com/p/memcached/wiki/BinaryProtocolRevamped
+[6]: https://rubygems.org/gems/couchbase-model
+[7]: https://github.com/couchbase/couchbase-ruby-model
+[8]: https://rubygems.org/gems/em-couchbase
+[9]: https://github.com/couchbase/couchbase-ruby-client-em
+

data/ext/couchbase_ext/bucket.c

@@ -22,7 +22,7 @@ error_callback(lcb_t handle, lcb_error_t error, const char *errinfo)
 {
     struct bucket_st *bucket = (struct bucket_st *)lcb_get_cookie(handle);
 
-    bucket->io->stop_event_loop(bucket->io);
+    lcb_breakout(handle);
     bucket->exception = cb_check_error(error, errinfo, Qnil);
 }
 
@@ -34,6 +34,7 @@ cb_bucket_free(void *ptr)
     if (bucket) {
         if (bucket->handle) {
             lcb_destroy(bucket->handle);
+            lcb_destroy_io_ops(bucket->io);
         }
         xfree(bucket->authority);
         xfree(bucket->hostname);
@@ -124,6 +125,14 @@ do_scan_connection_options(struct bucket_st *bucket, int argc, VALUE *argv)
             bucket->bucket = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
         }
         if (TYPE(opts) == T_HASH) {
+            arg = rb_hash_aref(opts, sym_type);
+            if (arg != Qnil) {
+                if (arg == sym_cluster) {
+                    bucket->type = LCB_TYPE_CLUSTER;
+                } else {
+                    bucket->type = LCB_TYPE_BUCKET;
+                }
+            }
             arg = rb_hash_aref(opts, sym_node_list);
             if (arg != Qnil) {
                 VALUE tt;
@@ -239,6 +248,7 @@ do_connect(struct bucket_st *bucket)
 
     if (bucket->handle) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
     }
@@ -248,11 +258,13 @@ do_connect(struct bucket_st *bucket)
     }
 
     memset(&create_opts, 0, sizeof(struct lcb_create_st));
-    create_opts.v.v0.host = bucket->node_list ? bucket-> node_list : bucket->authority;
-    create_opts.v.v0.user = bucket->username;
-    create_opts.v.v0.passwd = bucket->password;
-    create_opts.v.v0.bucket = bucket->bucket;
-    create_opts.v.v0.io = bucket->io;
+    create_opts.version = 1;
+    create_opts.v.v1.type = bucket->type;
+    create_opts.v.v1.host = bucket->node_list ? bucket-> node_list : bucket->authority;
+    create_opts.v.v1.user = bucket->username;
+    create_opts.v.v1.passwd = bucket->password;
+    create_opts.v.v1.bucket = bucket->bucket;
+    create_opts.v.v1.io = bucket->io;
     err = lcb_create(&bucket->handle, &create_opts);
     if (err != LCB_SUCCESS) {
         rb_exc_raise(cb_check_error(err, "failed to create libcouchbase instance", Qnil));
@@ -266,10 +278,8 @@ do_connect(struct bucket_st *bucket)
     (void)lcb_set_stat_callback(bucket->handle, stat_callback);
     (void)lcb_set_arithmetic_callback(bucket->handle, arithmetic_callback);
     (void)lcb_set_version_callback(bucket->handle, version_callback);
-    (void)lcb_set_view_complete_callback(bucket->handle, http_complete_callback);
-    (void)lcb_set_view_data_callback(bucket->handle, http_data_callback);
-    (void)lcb_set_management_complete_callback(bucket->handle, http_complete_callback);
-    (void)lcb_set_management_data_callback(bucket->handle, http_data_callback);
+    (void)lcb_set_http_complete_callback(bucket->handle, http_complete_callback);
+    (void)lcb_set_http_data_callback(bucket->handle, http_data_callback);
     (void)lcb_set_observe_callback(bucket->handle, observe_callback);
     (void)lcb_set_unlock_callback(bucket->handle, unlock_callback);
 
@@ -281,6 +291,7 @@ do_connect(struct bucket_st *bucket)
     err = lcb_connect(bucket->handle);
     if (err != LCB_SUCCESS) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         rb_exc_raise(cb_check_error(err, "failed to connect libcouchbase instance to server", Qnil));
@@ -289,6 +300,7 @@ do_connect(struct bucket_st *bucket)
     lcb_wait(bucket->handle);
     if (bucket->exception != Qnil) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         rb_exc_raise(bucket->exception);
@@ -391,6 +403,7 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
 
     bucket->self = self;
     bucket->exception = Qnil;
+    bucket->type = LCB_TYPE_BUCKET;
     bucket->hostname = strdup("localhost");
     bucket->port = 8091;
     bucket->pool = strdup("default");
@@ -1060,7 +1073,7 @@ cb_bucket_run(int argc, VALUE *argv, VALUE self)
 cb_bucket_stop(VALUE self)
 {
     struct bucket_st *bucket = DATA_PTR(self);
-    bucket->io->stop_event_loop(bucket->io);
+    lcb_breakout(bucket->handle);
     return Qnil;
 }
 
@@ -1080,6 +1093,7 @@ cb_bucket_disconnect(VALUE self)
 
     if (bucket->handle) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         return Qtrue;

data/ext/couchbase_ext/couchbase_ext.c

@@ -41,6 +41,7 @@ ID sym_cas;
 ID sym_chunked;
 ID sym_content_type;
 ID sym_create;
+ID sym_cluster;
 ID sym_decrement;
 ID sym_default_flags;
 ID sym_default_format;
@@ -156,6 +157,7 @@ VALUE eConnectError;            /* LCB_CONNECT_ERROR = 0x17   */
 VALUE eBucketNotFoundError;     /* LCB_BUCKET_ENOENT = 0x18   */
 VALUE eClientNoMemoryError;     /* LCB_CLIENT_ENOMEM = 0x19   */
 VALUE eClientTmpFailError;      /* LCB_CLIENT_ETMPFAIL = 0x20 */
+VALUE eBadHandleError;          /* LCB_EBADHANDLE = 0x21      */
 
 
 /* Ruby Extension initializer */
@@ -330,6 +332,14 @@ Init_couchbase_ext(void)
      * @since 1.1.0
      */
     eConnectError = rb_define_class_under(mError, "Connect", eBaseError);
+    /* Document-class: Couchbase::Error::BadHandle
+     * Invalid handle type.
+     *
+     * The requested operation isn't allowed for given type.
+     *
+     * @since 1.2.0
+     */
+    eBadHandleError = rb_define_class_under(mError, "BadHandle", eBaseError);
 
     /* Document-method: error
      *
@@ -362,7 +372,9 @@ Init_couchbase_ext(void)
      * 0x16 :: LCB_ETIMEDOUT (Operation timed out)
      * 0x17 :: LCB_CONNECT_ERROR (Connection failure)
      * 0x18 :: LCB_BUCKET_ENOENT (No such bucket)
-     * 0x18 :: LCB_CLIENT_ENOMEM (Out of memory on the client)
+     * 0x19 :: LCB_CLIENT_ENOMEM (Out of memory on the client)
+     * 0x20 :: LCB_CLIENT_ETMPFAIL (Temporary failure on the client)
+     * 0x21 :: LCB_EBADHANDLE (Invalid handle type)
      *
      * @since 1.0.0
      *
@@ -911,6 +923,7 @@ Init_couchbase_ext(void)
     sym_chunked = ID2SYM(rb_intern("chunked"));
     sym_content_type = ID2SYM(rb_intern("content_type"));
     sym_create = ID2SYM(rb_intern("create"));
+    sym_cluster = ID2SYM(rb_intern("cluster"));
     sym_decrement = ID2SYM(rb_intern("decrement"));
     sym_default_flags = ID2SYM(rb_intern("default_flags"));
     sym_default_format = ID2SYM(rb_intern("default_format"));

data/ext/couchbase_ext/couchbase_ext.h

@@ -23,6 +23,9 @@
 #endif
 
 #include "couchbase_config.h"
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#endif
 #ifndef HAVE_GETHRTIME
 typedef uint64_t hrtime_t;
 extern hrtime_t gethrtime(void);
@@ -65,6 +68,7 @@ extern hrtime_t gethrtime(void);
 struct bucket_st
 {
     lcb_t handle;
+    lcb_type_t type;
     struct lcb_io_opt_st *io;
     uint16_t port;
     char *authority;
@@ -155,6 +159,7 @@ extern ID sym_body;
 extern ID sym_bucket;
 extern ID sym_cas;
 extern ID sym_chunked;
+extern ID sym_cluster;
 extern ID sym_content_type;
 extern ID sym_create;
 extern ID sym_decrement;
@@ -272,6 +277,7 @@ extern VALUE eConnectError;            /* LCB_CONNECT_ERROR = 0x17   */
 extern VALUE eBucketNotFoundError;     /* LCB_BUCKET_ENOENT = 0x18   */
 extern VALUE eClientNoMemoryError;     /* LCB_CLIENT_ENOMEM = 0x19   */
 extern VALUE eClientTmpFailError;      /* LCB_CLIENT_ETMPFAIL = 0x20 */
+extern VALUE eBadHandleError;          /* LCB_EBADHANDLE = 0x21      */
 
 void strip_key_prefix(struct bucket_st *bucket, VALUE key);
 VALUE cb_check_error(lcb_error_t rc, const char *msg, VALUE key);

data/ext/couchbase_ext/extconf.rb

@@ -119,8 +119,7 @@ if try_compile(<<-SRC)
   define("HAVE_STDARG_PROTOTYPES")
 end
 
-
-have_library("couchbase", "lcb_get", "libcouchbase/couchbase.h") or abort "You should install libcouchbase >= 2.0.0. See http://www.couchbase.com/develop/ for more details"
+have_library("couchbase", "lcb_set_http_data_callback", "libcouchbase/couchbase.h") or abort "You should install libcouchbase >= 2.0.0beta2. See http://www.couchbase.com/develop/ for more details"
 have_header("mach/mach_time.h")
 have_header("stdint.h") or abort "Failed to locate stdint.h"
 have_header("sys/time.h")

data/ext/couchbase_ext/http.c

@@ -23,6 +23,7 @@ http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *coo
     struct context_st *ctx = (struct context_st *)cookie;
     struct bucket_st *bucket = ctx->bucket;
     VALUE *rv = ctx->rv, key, val, res;
+    lcb_http_status_t status;
 
     ctx->request->completed = 1;
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
@@ -32,6 +33,7 @@ http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *coo
         cb_gc_protect(bucket, ctx->exception);
     }
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
+    status = resp->v.v0.status;
     if (resp->v.v0.headers) {
         cb_build_headers(ctx, resp->v.v0.headers);
         cb_gc_unprotect(bucket, ctx->headers_val);
@@ -39,6 +41,7 @@ http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *coo
     if (ctx->extended) {
         res = rb_class_new_instance(0, NULL, cResult);
         rb_ivar_set(res, id_iv_error, ctx->exception);
+        rb_ivar_set(res, id_iv_status, status ? INT2FIX(status) : Qnil);
         rb_ivar_set(res, id_iv_operation, sym_http_request);
         rb_ivar_set(res, id_iv_key, key);
         rb_ivar_set(res, id_iv_value, val);
@@ -63,11 +66,13 @@ http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie,
     struct context_st *ctx = (struct context_st *)cookie;
     struct bucket_st *bucket = ctx->bucket;
     VALUE key, val, res;
+    lcb_http_status_t status;
 
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
     ctx->exception = cb_check_error_with_status(error,
             "failed to execute HTTP request", key, resp->v.v0.status);
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
+    status = resp->v.v0.status;
     if (ctx->exception != Qnil) {
         cb_gc_protect(bucket, ctx->exception);
         lcb_cancel_http_request(bucket->handle, request);
@@ -79,6 +84,7 @@ http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie,
         if (ctx->extended) {
             res = rb_class_new_instance(0, NULL, cResult);
             rb_ivar_set(res, id_iv_error, ctx->exception);
+            rb_ivar_set(res, id_iv_status, status ? INT2FIX(status) : Qnil);
             rb_ivar_set(res, id_iv_operation, sym_http_request);
             rb_ivar_set(res, id_iv_key, key);
             rb_ivar_set(res, id_iv_value, val);
@@ -305,7 +311,7 @@ cb_http_request_perform(VALUE self)
 cb_http_request_pause(VALUE self)
 {
     struct http_request_st *req = DATA_PTR(self);
-    req->bucket->io->stop_event_loop(req->bucket->io);
+    lcb_breakout(req->bucket->handle);
     return Qnil;
 }
 

data/ext/couchbase_ext/result.c

@@ -41,7 +41,7 @@ cb_result_success_p(VALUE self)
     VALUE
 cb_result_inspect(VALUE self)
 {
-    VALUE str, attr, error;
+    VALUE str, attr;
     char buf[100];
 
     str = rb_str_buf_new2("#<");
@@ -49,18 +49,15 @@ cb_result_inspect(VALUE self)
     snprintf(buf, 100, ":%p", (void *)self);
     rb_str_buf_cat2(str, buf);
 
-    attr = rb_ivar_get(self, id_iv_error);
+    attr = rb_ivar_get(self, id_iv_operation);
     if (RTEST(attr)) {
-        error = rb_ivar_get(attr, id_iv_error);
-    } else {
-        error = INT2FIX(0);
+        rb_str_buf_cat2(str, " operation=");
+        rb_str_append(str, rb_inspect(attr));
     }
-    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);
+    attr = rb_ivar_get(self, id_iv_error);
     if (RTEST(attr)) {
-        rb_str_buf_cat2(str, " operation=");
+        rb_str_buf_cat2(str, " error=");
         rb_str_append(str, rb_inspect(attr));
     }
 

data/ext/couchbase_ext/utils.c

@@ -150,6 +150,12 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
         case LCB_CLIENT_ENOMEM:
             klass = eClientNoMemoryError;
             break;
+        case LCB_CLIENT_ETMPFAIL:
+            klass = eClientTmpFailError;
+            break;
+        case LCB_EBADHANDLE:
+            klass = eBadHandleError;
+            break;
         case LCB_ERROR:
             /* fall through */
         default:

data/lib/active_support/cache/couchbase_store.rb

@@ -184,7 +184,7 @@ module ActiveSupport
         instrument(:read_multi, names, options) do
           @data.get(names, options)
         end
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         false
@@ -245,7 +245,7 @@ module ActiveSupport
           payload[:amount] = amount if payload
           @data.incr(name, amount, options)
         end
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         false
@@ -277,7 +277,7 @@ module ActiveSupport
           payload[:amount] = amount if payload
           @data.decr(name, amount, options)
         end
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         false
@@ -297,7 +297,7 @@ module ActiveSupport
       # Read an entry from the cache.
       def read_entry(key, options) # :nodoc:
         @data.get(key, options)
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         nil
@@ -314,7 +314,7 @@ module ActiveSupport
           options[:ttl] ||= ttl
         end
         @data.send(method, key, value, options)
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         false
@@ -323,7 +323,7 @@ module ActiveSupport
       # Delete an entry from the cache.
       def delete_entry(key, options) # :nodoc:
         @data.delete(key, options)
-      rescue Couchbase::Error::Base => e
+      rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
         false

data/lib/couchbase/bucket.rb

@@ -238,6 +238,9 @@ module Couchbase
     #     end
     #   end
     def flush
+      if !async? && block_given?
+        raise ArgumentError, "synchronous mode doesn't support callbacks"
+      end
       req = make_http_request("/pools/default/buckets/#{bucket}/controller/doFlush",
                               :type => :management, :method => :post, :extended => true)
       res = nil

data/lib/couchbase/cluster.rb

@@ -0,0 +1,105 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+#
+
+module Couchbase
+
+  class Cluster
+
+    # Establish connection to the cluster for administration
+    #
+    # @param [Hash] options The connection parameter
+    # @option options [String] :username The username
+    # @option options [String] :password The password
+    # @option options [String] :pool ("default") The pool name
+    # @option options [String] :hostname ("localhost") The hostname
+    # @option options [String] :port (8091) The port
+    def initialize(options = {})
+      if options[:username].nil? || options[:password].nil?
+        raise ArgumentError, "username and password mandatory to connect to the cluster"
+      end
+      @connection = Bucket.new(options.merge(:type => :cluster))
+    end
+
+    # Create data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options The bucket parameters
+    # @option options [String] :bucket_type ("couchbase") The type of the
+    #   bucket. Possible values are "memcached" and "couchbase".
+    # @option options [Fixnum] :ram_quota (100) The RAM quota in megabytes.
+    # @option options [Fixnum] :replica_number (1) The number of replicas of
+    #   each document
+    # @option options [String] :auth_type ("sasl") The authentication type.
+    #   Possible values are "sasl" and "none". Note you should specify free
+    #   port for "none"
+    # @option options [Fixnum] :proxy_port The port for moxi
+    def create_bucket(name, options = {})
+      defaults = {
+        :type => "couchbase",
+        :ram_quota => 100,
+        :replica_number => 1,
+        :auth_type => "sasl",
+        :sasl_password => "",
+        :proxy_port => nil
+      }
+      options = defaults.merge(options)
+      params = {"name" => name}
+      params["bucketType"] = options[:type]
+      params["ramQuotaMB"] = options[:ram_quota]
+      params["replicaNumber"] = options[:replica_number]
+      params["authType"] = options[:auth_type]
+      params["saslPassword"] = options[:sasl_password]
+      params["proxyPort"] = options[:proxy_port]
+      payload = Utils.encode_params(params.reject!{|k, v| v.nil?})
+      request = @connection.make_http_request("/pools/default/buckets",
+                                              :content_type => "application/x-www-form-urlencoded",
+                                              :type => :management,
+                                              :method => :post,
+                                              :extended => true,
+                                              :body => payload)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :create_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+    # Delete the data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options
+    def delete_bucket(name, options = {})
+      request = @connection.make_http_request("/pools/default/buckets/#{name}",
+                                              :type => :management,
+                                              :method => :delete,
+                                              :extended => true)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :delete_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+  end
+
+end

data/lib/couchbase/utils.rb

@@ -19,11 +19,8 @@ module Couchbase
 
   class Utils
 
-    def self.build_query(uri, params = nil)
-      uri = uri.dup
-      return uri if params.nil? || params.empty?
-      uri << "?"
-      uri << params.map do |k, v|
+    def self.encode_params(params)
+      params.map do |k, v|
         next if !v && k.to_s == "group"
         if %w{key keys startkey endkey start_key end_key}.include?(k.to_s)
           v = MultiJson.dump(v)
@@ -36,6 +33,12 @@ module Couchbase
       end.compact.join("&")
     end
 
+    def self.build_query(uri, params = nil)
+      uri = uri.dup
+      return uri if params.nil? || params.empty?
+      uri << "?" << encode_params(params)
+    end
+
     def self.escape(s)
       s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/nu) {
         '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase

data/lib/couchbase/version.rb

@@ -17,5 +17,5 @@
 
 # Couchbase ruby client
 module Couchbase
-  VERSION = "1.2.0.z.beta2"
+  VERSION = "1.2.0.z.beta3"
 end

data/lib/couchbase.rb

@@ -26,6 +26,7 @@ require 'couchbase/bucket'
 require 'couchbase/view_row'
 require 'couchbase/view'
 require 'couchbase/result'
+require 'couchbase/cluster'
 
 # Couchbase ruby client
 module Couchbase

data/lib/rack/session/couchbase.rb

@@ -90,7 +90,7 @@ module Rack
       def with_lock(env, default = nil)
         @mutex.lock if env['rack.multithread']
         yield
-      rescue Couchbase::Error::Connect, Couchbase::Error::Timeout
+      rescue ::Couchbase::Error::Connect, ::Couchbase::Error::Timeout
         if $VERBOSE
           warn "#{self} is unable to find Couchbase server."
           warn $!.inspect

data/tasks/compile.rake

@@ -84,7 +84,7 @@ namespace :ports do
   directory "ports"
 
   task :libcouchbase => ["ports"] do
-    recipe = MiniPortile.new "libcouchbase", "2.0.0beta_5_g970a292"
+    recipe = MiniPortile.new "libcouchbase", "2.0.0beta2_1_gf60b9fe"
     recipe.files << "http://packages.couchbase.com/clients/c/libcouchbase-#{recipe.version}.tar.gz"
     recipe.configure_options.push("--disable-debug",
                                   "--disable-dependency-tracking",

data/test/test_async.rb

@@ -154,27 +154,31 @@ class TestAsync < MiniTest::Unit::TestCase
   end
 
   def test_nested_async_flush_set
-    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
-    cas = connection.set(uniq_id, "foo")
-    res = {}
+    if @mock.real?
+      connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+      cas = connection.set(uniq_id, "foo")
+      res = {}
 
-    connection.run do |conn|
-      conn.flush do |res1|
-        assert res1.success?
-        id = uniq_id(res1.node)
-        res[id] = false
-        conn.set(id, true) do |res2|
-          res[id] = res2.cas
+      connection.run do |conn|
+        conn.flush do |res1|
+          assert res1.success?
+          id = uniq_id(res1.node)
+          res[id] = false
+          conn.set(id, true) do |res2|
+            res[id] = res2.cas
+          end
         end
       end
-    end
 
-    assert_raises(Couchbase::Error::NotFound) do
-      connection.get(uniq_id)
-    end
-    res.keys.each do |key|
-      assert res[key].is_a?(Numeric)
-      assert connection.get(key)
+      assert_raises(Couchbase::Error::NotFound) do
+        connection.get(uniq_id)
+      end
+      res.keys.each do |key|
+        assert res[key].is_a?(Numeric)
+        assert connection.get(key)
+      end
+    else
+      skip("REST FLUSH isn't implemented in CouchbaseMock.jar yet")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: couchbase
 version: !ruby/object:Gem::Version
-  version: 1.2.0.z.beta2
+  version: 1.2.0.z.beta3
   prerelease: 6
 platform: x86-mingw32
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-21 00:00:00.000000000 Z
+date: 2012-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yaji
@@ -242,6 +242,7 @@ files:
 - lib/active_support/cache/couchbase_store.rb
 - lib/couchbase.rb
 - lib/couchbase/bucket.rb
+- lib/couchbase/cluster.rb
 - lib/couchbase/result.rb
 - lib/couchbase/utils.rb
 - lib/couchbase/version.rb
@@ -293,7 +294,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1839636572192674116
+      hash: -2344661928388476453
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: