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

data/ext/couchbase_ext/version.c

@@ -18,31 +18,29 @@
 #include "couchbase_ext.h"
 
     void
-version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_version_resp_t *resp)
+cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_version_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE node, val, *rv = ctx->rv, exc, res;
 
     node = resp->v.v0.server_endpoint ? STR_NEW_CSTR(resp->v.v0.server_endpoint) : Qnil;
     exc = cb_check_error(error, "failed to get version", node);
     if (exc != Qnil) {
-        rb_ivar_set(exc, id_iv_operation, sym_version);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        rb_ivar_set(exc, cb_id_iv_operation, cb_sym_version);
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
 
     if (node != Qnil) {
         val = STR_NEW((const char*)resp->v.v0.vstring, resp->v.v0.nvstring);
         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_version);
-                rb_ivar_set(res, id_iv_node, node);
-                rb_ivar_set(res, id_iv_value, val);
-                cb_proc_call(ctx->proc, 1, res);
+                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_version);
+                rb_ivar_set(res, cb_id_iv_node, node);
+                rb_ivar_set(res, cb_id_iv_value, val);
+                cb_proc_call(bucket, ctx->proc, 1, res);
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
@@ -52,6 +50,9 @@ version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
     } else {
         ctx->nqueries--;
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
 
     (void)handle;
@@ -87,26 +88,26 @@ version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
     VALUE
 cb_bucket_version(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE rv, exc, args, proc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_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_version;
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_version;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     rv = rb_hash_new();
     ctx->rv = &rv;
@@ -119,12 +120,12 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
     exc = cb_check_error(err, "failed to schedule version request", Qnil);
     cb_params_destroy(&params);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -132,13 +133,15 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         return rv;
     }

data/lib/action_dispatch/middleware/session/couchbase_store.rb

@@ -16,7 +16,7 @@ module ActionDispatch
     # Or remove this file and add following line to your `config/application.rb`:
     #
     #   require 'action_dispatch/middleware/session/couchbase_store'
-    #   config.session_storage = :couchbase_store
+    #   config.session_store :couchbase_store
     #
     # You can also pass additional options:
     #
@@ -25,7 +25,7 @@ module ActionDispatch
     #     :expire_after => 5.minutes,
     #     :couchbase => {:bucket => "sessions", :default_format => :marshal}
     #   }
-    #   config.session_storage = :couchbase_store, session_options
+    #   config.session_store :couchbase_store, session_options
     #
     # By default sessions will be serialized to JSON, to allow analyse them
     # using Map/Reduce.

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.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/couchbase/bucket.rb

@@ -106,6 +106,9 @@ module Couchbase
       req.on_body do |body|
         res = MultiJson.load(body.value)
         res["rows"].each do |obj|
+          if obj['doc']
+            obj['doc']['value'] = obj['doc'].delete('json')
+          end
           doc = ViewRow.wrap(self, obj)
           key = doc.id.sub(/^_design\//, '')
           next if self.environment == :production && key =~ /dev_/
@@ -117,17 +120,6 @@ module Couchbase
       async? ? nil : docmap
     end
 
-    # Fetch all documents from the bucket.
-    #
-    # @since 1.2.0
-    #
-    # @param [Hash] params Params for Couchbase +/_all_docs+ query
-    #
-    # @return [Couchbase::View] View object
-    def all_docs(params = {})
-      View.new(self, "_all_docs", params)
-    end
-
     # Update or create design doc with supplied views
     #
     # @since 1.2.0
@@ -238,6 +230,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.beta"
+  VERSION = "1.2.0"
 end

data/lib/couchbase/view.rb

@@ -15,6 +15,8 @@
 # limitations under the License.
 #
 
+require 'base64'
+
 module Couchbase
 
   module Error
@@ -27,6 +29,28 @@ module Couchbase
         super("#{prefix}#{from}: #{reason}")
       end
     end
+
+    class HTTP < Base
+      attr_reader :type, :reason
+
+      def parse_body!
+        if @body
+          hash = MultiJson.load(@body)
+          @type = hash["error"]
+          @reason = hash["reason"]
+        end
+      rescue MultiJson::DecodeError
+        @type = @reason = nil
+      end
+
+      def to_s
+        str = super
+        if @type || @reason
+          str.sub(/ \(/, ": #{[@type, @reason].compact.join(": ")} (")
+        end
+        str
+      end
+    end
   end
 
   # This class implements Couchbase View execution
@@ -50,7 +74,7 @@ module Couchbase
     def initialize(bucket, endpoint, params = {})
       @bucket = bucket
       @endpoint = endpoint
-      @params = params
+      @params = {:connection_timeout => 75_000}.merge(params)
       @wrapper_class = params.delete(:wrapper_class) || ViewRow
       unless @wrapper_class.respond_to?(:wrap)
         raise ArgumentError, "wrapper class should reposond to :wrap, check the options"
@@ -142,8 +166,14 @@ module Couchbase
     #   the document and store them in {ViewRow#meta} hash.
     #
     # @param [Hash] params parameters for Couchbase query.
-    # @option params [true, false] :include_docs (false) Include the full
-    #   content of the documents in the return.
+    # @option params [true, false] :include_docs (false) Include the
+    #   full content of the documents in the return. Note that the document
+    #   is fetched from the in memory cache where it may have been changed
+    #   or even deleted. See also +:quiet+ parameter below to control error
+    #   reporting during fetch.
+    # @option params [true, false] :quiet (true) Do not raise error if
+    #   associated document not found in the memory. If the parameter +true+
+    #   will use +nil+ value instead.
     # @option params [true, false] :descending (false) Return the documents
     #   in descending by key order
     # @option params [String, Fixnum, Hash, Array] :key Return only
@@ -175,7 +205,7 @@ module Couchbase
     #               response stream.
     #   :stop::     Stop immediately when an error condition occurs. No
     #               further view information will be returned.
-    # @option params [Fixnum] :connection_timeout (60000) Timeout before the
+    # @option params [Fixnum] :connection_timeout (75000) Timeout before the
     #   view request is dropped (milliseconds)
     # @option params [true, false] :reduce (true) Use the reduction function
     # @option params [true, false] :group (false) Group the results using
@@ -236,6 +266,11 @@ module Couchbase
         body = MultiJson.dump(body) unless body.is_a?(String)
         options.update(:body => body, :method => params.delete(:method) || :post)
       end
+      include_docs = params.delete(:include_docs)
+      quiet = true
+      if params.has_key?(:quiet)
+        quiet = params.delete(:quiet)
+      end
       path = Utils.build_query(@endpoint, params)
       request = @bucket.make_http_request(path, options)
       res = []
@@ -260,6 +295,17 @@ module Couchbase
             raise Error::View.new(from, reason)
           end
         else
+          if include_docs
+            val, flags, cas = @bucket.get(obj['id'], :extended => true, :quiet => quiet)
+            obj['doc'] = {
+              'value' => val,
+              'meta' => {
+                'id' => obj['id'],
+                'flags' => flags,
+                'cas' => cas
+              }
+            }
+          end
           if block_given?
             yield @wrapper_class.wrap(@bucket, obj)
           else
@@ -270,7 +316,7 @@ module Couchbase
       # run event loop until the terminating chunk will be found
       # last_res variable keeps latest known chunk of the result
       last_res = nil
-      loop do
+      while true
         # feed response received chunks to the parser
         while r = res.shift
           if r.error