couchbase 1.3.3 → 1.3.4

data/lib/active_support/cache/couchbase_store.rb

@@ -55,6 +55,7 @@ module ActiveSupport
         options[:default_ttl] ||= options.delete(:expires_in)
         options[:default_format] ||= :marshal
         options[:key_prefix] ||= options.delete(:namespace)
+        @key_prefix = options[:key_prefix]
         options[:connection_pool] ||= options.delete(:connection_pool)
         args.push(options)
 
@@ -348,7 +349,7 @@ module ActiveSupport
       # object responds to +cache_key+. Otherwise, to_param method will be
       # called. If the key is a Hash, then keys will be sorted alphabetically.
       def expanded_key(key) # :nodoc:
-        return key.cache_key.to_s if key.respond_to?(:cache_key)
+        return validate_key(key.cache_key.to_s) if key.respond_to?(:cache_key)
 
         case key
         when Array
@@ -361,7 +362,22 @@ module ActiveSupport
           key = key.sort_by { |k,_| k.to_s }.collect{|k,v| "#{k}=#{v}"}
         end
 
-        key.respond_to?(:to_param) ? key.to_param : key
+        validate_key(key.respond_to?(:to_param) ? key.to_param : key)
+      end
+
+      def validate_key(key)
+        if key_with_prefix(key).length > 250
+          key = "#{key[0, max_length_before_prefix]}:md5:#{Digest::MD5.hexdigest(key)}"
+        end
+        return key
+      end
+
+      def key_with_prefix(key)
+        (ns = @key_prefix) ? "#{ns}#{key}" : key
+      end
+
+      def max_length_before_prefix
+        @max_length_before_prefix ||= 212 - (@key_prefix || '').size
       end
 
       module Threadsafe

data/lib/couchbase/bucket.rb

@@ -35,12 +35,23 @@ module Couchbase
     #
     # @see http://couchbase.com/docs/memcached-api/memcached-api-protocol-text_cas.html
     #
+    # Setting the +:retry+ option to a positive number will cause this method
+    # to rescue the {Couchbase::Error::KeyExists} error that happens when
+    # an update collision is detected, and automatically get a fresh copy
+    # of the value and retry the block. This will repeat as long as there
+    # continues to be conflicts, up to the maximum number of retries specified.
+    # For asynchronous mode, this means the block will be yielded once for
+    # the initial {Bucket#get}, once for the final {Bucket#set} (successful
+    # or last failure), and zero or more additional {Bucket#get} retries
+    # in between, up to the maximum allowed by the +:retry+ option.
+    #
     # @param [String, Symbol] key
     #
     # @param [Hash] options the options for "swap" part
     # @option options [Fixnum] :ttl (self.default_ttl) the time to live of this key
     # @option options [Symbol] :format (self.default_format) format of the value
     # @option options [Fixnum] :flags (self.default_flags) flags for this key
+    # @option options [Fixnum] :retry (0) maximum number of times to autmatically retry upon update collision
     #
     # @yieldparam [Object, Result] value old value in synchronous mode and
     #   +Result+ object in asynchronous mode.
@@ -80,16 +91,32 @@ module Couchbase
     #
     # @return [Fixnum] the CAS of new value
     def cas(key, options = {})
+      retries_remaining = options.delete(:retry) || 0
       if async?
         block = Proc.new
         get(key) do |ret|
           val = block.call(ret) # get new value from caller
-          set(ret.key, val, options.merge(:cas => ret.cas, :flags => ret.flags), &block)
+          set(ret.key, val, options.merge(:cas => ret.cas, :flags => ret.flags)) do |set_ret|
+            if set_ret.error.is_a?(Couchbase::Error::KeyExists) && (retries_remaining > 0)
+              cas(key, options.merge(:retry => retries_remaining - 1), &block)
+            else
+              block.call(set_ret)
+            end
+          end
         end
       else
-        val, flags, ver = get(key, :extended => true)
-        val = yield(val) # get new value from caller
-        set(key, val, options.merge(:cas => ver, :flags => flags))
+        begin
+          val, flags, ver = get(key, :extended => true)
+          val = yield(val) # get new value from caller
+          set(key, val, options.merge(:cas => ver, :flags => flags))
+        rescue Couchbase::Error::KeyExists
+          if retries_remaining > 0
+            retries_remaining -= 1
+            retry
+          else
+            raise
+          end
+        end
       end
     end
     alias :compare_and_swap :cas

data/lib/couchbase/cluster.rb

@@ -42,11 +42,19 @@ module Couchbase
     #   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
+    #   each document. Minimum 0, maximum 3.
     # @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
+    # @option options [true, false] :replica_index (true) Disable or
+    #   enable indexes for bucket replicas
+    # @option options [true, false] :flush_enabled (false) Enables the
+    #   'flush all' functionality on the specified bucket.
+    # @option options [true, false] :parallel_db_and_view_compaction (false)
+    #   Indicates whether database and view files on disk can be
+    #   compacted simultaneously
+    #
     def create_bucket(name, options = {})
       defaults = {
         :type => "couchbase",
@@ -54,7 +62,10 @@ module Couchbase
         :replica_number => 1,
         :auth_type => "sasl",
         :sasl_password => "",
-        :proxy_port => nil
+        :proxy_port => nil,
+        :flush_enabled => false,
+        :replica_index => true,
+        :parallel_db_and_view_compaction => false
       }
       options = defaults.merge(options)
       params = {"name" => name}
@@ -64,6 +75,9 @@ module Couchbase
       params["authType"] = options[:auth_type]
       params["saslPassword"] = options[:sasl_password]
       params["proxyPort"] = options[:proxy_port]
+      params["flushEnabled"] = !!options[:flush_enabled]
+      params["replicaIndex"] = !!options[:replica_index]
+      params["parallelDBAndViewCompaction"] = !!options[:parallel_db_and_view_compaction]
       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",

data/lib/couchbase/version.rb

@@ -17,5 +17,5 @@
 
 # Couchbase ruby client
 module Couchbase
-  VERSION = "1.3.3"
+  VERSION = "1.3.4"
 end

data/tasks/compile.rake

@@ -30,6 +30,36 @@ version_router = lambda do |t|
   end
 end
 
+class Platform
+  attr_reader :name, :host, :versions
+
+  def initialize(params)
+    @name = params[:name]
+    @host = params[:host]
+    @versions = params[:versions]
+  end
+
+  def each_version
+    @versions.each do |v|
+      yield(v, v[/\d\.\d\.\d/])
+    end
+  end
+
+  def short_versions
+    res = []
+    each_version do |long, short|
+      res << short
+    end
+    res
+  end
+end
+
+recent = "2.0.0-p353"
+CROSS_PLATFORMS = [
+  Platform.new(:name => 'x64-mingw32', :host => 'x86_64-w64-mingw32', :versions => %w(1.9.3-p484 2.0.0-p353 2.1.0)),
+  Platform.new(:name => 'x86-mingw32', :host => 'i686-w64-mingw32', :versions => %w(1.8.7-p374 1.9.3-p484 2.0.0-p353 2.1.0)),
+]
+
 # Setup compile tasks.  Configuration can be passed via ENV.
 # Example:
 #  rake compile with_libcouchbase_include=/opt/couchbase/include
@@ -41,13 +71,14 @@ end
 #
 Rake::ExtensionTask.new("couchbase_ext", gemspec) do |ext|
   ext.cross_compile = true
-  ext.cross_platform = ENV['HOST'] || "i386-mingw32"
+  ext.cross_platform = ENV['TARGET']
   if ENV['RUBY_CC_VERSION']
     ext.lib_dir = "lib/couchbase"
   end
   ext.cross_compiling do |spec|
     spec.files.delete("lib/couchbase/couchbase_ext.so")
-    spec.files.push("lib/couchbase_ext.rb", Dir["lib/couchbase/1.{8,9}/couchbase_ext.so"])
+    spec.files.push("lib/couchbase_ext.rb", Dir["lib/couchbase/*/couchbase_ext.so"])
+    spec.files.push(Dir["lib/couchbase/*/couchbase_ext.so"])
     file "#{ext.tmp_dir}/#{ext.cross_platform}/stage/lib/couchbase_ext.rb", &version_router
   end
 
@@ -66,19 +97,13 @@ end
 
 require 'rubygems/package_task'
 Gem::PackageTask.new(gemspec) do |pkg|
-  pkg.need_tar = true
+  pkg.need_tar = pkg.need_zip = false
 end
 
 require 'mini_portile'
 require 'rake/extensioncompiler'
 
 class MiniPortile
-  alias :initialize_with_default_host :initialize
-  def initialize(name, version)
-    initialize_with_default_host(name, version)
-    @host = ENV['HOST'] || Rake::ExtensionCompiler.mingw_host
-  end
-
   alias :cook_without_checkpoint :cook
   def cook
     checkpoint = "ports/.#{name}-#{version}-#{host}.installed"
@@ -89,13 +114,30 @@ class MiniPortile
   end
 end
 
-namespace :ports do
-  directory "ports"
+file "lib/couchbase_ext.rb", &version_router
 
-  task :libcouchbase => ["ports"] do
-    recipe = MiniPortile.new "libcouchbase", "2.1.3"
+desc "Package gem for windows"
+task "package:windows" => ["package", "lib/couchbase_ext.rb"] do
+  vars = [
+    'CC',
+    'CFLAGS',
+    'CPATH',
+    'CPP',
+    'CPPFLAGS',
+    'LDFLAGS',
+    'LIBRARY_PATH',
+    'PATH'
+  ].reduce({}) do |h, v|
+    h[v] = ENV[v]
+    h
+  end
+  CROSS_PLATFORMS.each do |platform|
+    ENV['TARGET'] = platform.name
+    rm_rf("tmp/ ports/")
+    mkdir_p("ports")
+    recipe = MiniPortile.new("libcouchbase", "2.2.0_30_gc87bec4")
+    recipe.host = platform.host
     recipe.files << "http://packages.couchbase.com/clients/c/libcouchbase-#{recipe.version}.tar.gz"
-
     recipe.configure_options.push("--disable-debug",
                                   "--disable-dependency-tracking",
                                   "--disable-couchbasemock",
@@ -105,16 +147,12 @@ namespace :ports do
                                   "--disable-tools")
     recipe.cook
     recipe.activate
+    platform.each_version do |long, short|
+      sh("env RUBY_CC_VERSION=#{short} RBENV_VERSION=#{long} rbenv exec rake cross compile")
+    end
+    vars.each do |k, v|
+      ENV[k] = v
+    end
+    sh("env RUBY_CC_VERSION=#{platform.short_versions.join(":")} RBENV_VERSION=#{recent} rbenv exec rake cross native gem")
   end
 end
-
-file "lib/couchbase_ext.rb", &version_router
-task :cross => ["lib/couchbase_ext.rb", "ports:libcouchbase"]
-
-desc "Package gem for windows"
-task "package:windows" => :package do
-  sh("env RUBY_CC_VERSION=1.8.7 RBENV_VERSION=1.8.7-p370 rbenv exec bundle exec rake cross compile")
-  sh("env RUBY_CC_VERSION=1.9.2 RBENV_VERSION=1.9.2-p320 rbenv exec bundle exec rake cross compile")
-  sh("env RUBY_CC_VERSION=2.0.0 RBENV_VERSION=2.0.0-p247 rbenv exec bundle exec rake cross compile")
-  sh("env RUBY_CC_VERSION=1.8.7:1.9.2:2.0.0 RBENV_VERSION=1.9.2-p320 rbenv exec bundle exec rake cross native gem")
-end

data/test/test_arithmetic.rb

@@ -173,4 +173,13 @@ class TestArithmetic < MiniTest::Test
     assert_equal [2, 2],   connection.decr(uniq_id(:foo), uniq_id(:bar), :delta => 10).values.sort
     assert_equal [1, 1],   connection.decr(uniq_id(:foo), uniq_id(:bar)).values.sort
   end
+
+  def test_it_returns_cas_value_in_extended_mode
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    orig_cas = connection.set(uniq_id(:foo), 1)
+    val, cas = connection.incr(uniq_id(:foo), :extended => true)
+    assert_equal 2, val
+    assert cas.is_a?(Numeric), "CAS should be numeric value: #{cas.inspect}"
+    refute_equal orig_cas, cas
+  end
 end

data/test/test_cas.rb

@@ -40,6 +40,69 @@ class TestCas < MiniTest::Test
     assert_equal expected, val
   end
 
+  def test_compare_and_swap_collision
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 1})
+    assert_raises(Couchbase::Error::KeyExists) do
+      connection.cas(uniq_id) do |val|
+        # Simulate collision with a separate writer. This will
+        # change the CAS value to be different than what #cas just loaded.
+        connection.set(uniq_id, {"bar" => 2})
+
+        # Complete the modification we desire, which should fail when set.
+        val["baz"] = 3
+        val
+      end
+    end
+  end
+
+  def test_compare_and_swap_retry
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 1})
+    calls = 0
+    connection.cas(uniq_id, :retry => 1) do |val|
+      calls += 1
+      if calls == 1
+        # Simulate collision with a separate writer. This will
+        # change the CAS value to be different than what #cas just loaded.
+        # Only do this the first time this block is executed.
+        connection.set(uniq_id, {"bar" => 2})
+      end
+
+      # Complete the modification we desire, which should fail when set.
+      val["baz"] = 3
+      val
+    end
+    assert_equal 2, calls
+    val = connection.get(uniq_id)
+    expected = {"bar" => 2, "baz" => 3}
+    assert_equal expected, val
+  end
+
+  def test_compare_and_swap_too_many_retries
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 0})
+    calls = 0
+    assert_raises(Couchbase::Error::KeyExists) do
+      connection.cas(uniq_id, :retry => 10) do |val|
+        calls += 1
+
+        # Simulate collision with a separate writer. This will
+        # change the CAS value to be different than what #cas just loaded.
+        # Do it every time so we just keep retrying and failing.
+        connection.set(uniq_id, {"bar" => calls})
+
+        # Complete the modification we desire, which should fail when set.
+        val["baz"] = 3
+        val
+      end
+    end
+    assert_equal 11, calls
+  end
+
   def test_compare_and_swap_async
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
                                :default_format => :document)
@@ -66,6 +129,101 @@ class TestCas < MiniTest::Test
     assert_equal expected, val
   end
 
+  def test_compare_and_swap_async_collision
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 1})
+    calls = 0
+    connection.run do |conn|
+      conn.cas(uniq_id) do |ret|
+        calls += 1
+        case ret.operation
+        when :get
+          new_val = ret.value
+
+          # Simulate collision with a separate writer. This will
+          # change the CAS value to be different than what #cas just loaded.
+          connection.set(uniq_id, {"bar" => 2})
+
+
+          # Complete the modification we desire, which should fail when set.
+          new_val["baz"] = 3
+          new_val
+        when :set
+          assert ret.error.is_a? Couchbase::Error::KeyExists
+        else
+          flunk "Unexpected operation: #{ret.operation.inspect}"
+        end
+      end
+    end
+    assert_equal 2, calls
+  end
+
+  def test_compare_and_swap_async_retry
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 1})
+    calls = 0
+    connection.run do |conn|
+      conn.cas(uniq_id, :retry => 1) do |ret|
+        calls += 1
+        case ret.operation
+        when :get
+          new_val = ret.value
+
+          if calls == 1
+            # Simulate collision with a separate writer. This will
+            # change the CAS value to be different than what #cas just loaded.
+            # Only do this the first time this block is executed.
+            connection.set(uniq_id, {"bar" => 2})
+          end
+
+          # Complete the modification we desire, which should fail when set.
+          new_val["baz"] = 3
+          new_val
+        when :set
+          assert ret.success?
+        else
+          flunk "Unexpected operation: #{ret.operation.inspect}"
+        end
+      end
+    end
+    assert_equal 3, calls
+    val = connection.get(uniq_id)
+    expected = {"bar" => 2, "baz" => 3}
+    assert_equal expected, val
+  end
+
+  def test_compare_and_swap_async_too_many_retries
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, {"bar" => 0})
+    calls = 0
+    connection.run do |conn|
+      conn.cas(uniq_id, :retry => 10) do |ret|
+        calls += 1
+        case ret.operation
+        when :get
+          new_val = ret.value
+
+          # Simulate collision with a separate writer. This will
+          # change the CAS value to be different than what #cas just loaded.
+          # Do it every time so we just keep retrying and failing.
+          connection.set(uniq_id, {"bar" => calls})
+
+          # Complete the modification we desire, which should fail when set.
+          new_val["baz"] = 3
+          new_val
+        when :set
+          assert ret.error.is_a? Couchbase::Error::KeyExists
+        else
+          flunk "Unexpected operation: #{ret.operation.inspect}"
+        end
+      end
+    end
+    assert_equal 12, calls
+  end
+
   def test_flags_replication
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
                                :default_format => :document)