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

data/lib/ext/multi_json_fix.rb

@@ -0,0 +1,47 @@
+# 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.
+#
+
+# This patch fixing loading primitives like strings, numbers and booleans
+# using json_gem. It amends behaviour of MultiJson::Engines::JsonGem#load
+# when it receives JSON string which neither Array nor Object.
+
+if MultiJson.respond_to?(:engine)
+  multi_json_engine = MultiJson.send(:engine)
+else
+  multi_json_engine = MultiJson.send(:adapter)
+end
+if multi_json_engine.name =~ /JsonGem$/
+  class << multi_json_engine
+    alias _load_object load
+    def load(string, options = {})
+      if string =~ /\A\s*[{\[]/
+        _load_object(string, options)
+      else
+        _load_object("[#{string}]", options)[0]
+      end
+    end
+  end
+end
+
+# Patch for MultiJson versions < 1.3.3
+if MultiJson.respond_to?(:decode) && MultiJson.respond_to?(:encode) &&
+  !MultiJson.respond_to?(:load) && !MultiJson.respond_to?(:dump)
+  class << MultiJson
+    alias :dump :encode
+    alias :load :decode
+  end
+end

data/lib/rack/session/couchbase.rb

@@ -0,0 +1,104 @@
+# 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.
+#
+
+require 'rack/session/abstract/id'
+require 'couchbase'
+require 'thread'
+
+module Rack
+  module Session
+
+    # This is Couchbase-powered session store for rack applications
+    #
+    # To use it just load it as usual middleware in your `config.ru` file
+    #
+    #   require 'rack/session/couchbase'
+    #   use Rack::Session::Couchbase
+    #
+    # You can also pass additional options:
+    #
+    #   require 'rack/session/couchbase'
+    #   use Rack::Session::Couchbase, :expire_after => 5.minutes,
+    #     :couchbase => {:bucket => "sessions", :default_format => :marshal}
+    #
+    # By default sessions will be serialized to JSON, to allow analyse them
+    # using Map/Reduce.
+    #
+    class Couchbase < Abstract::ID
+      attr_reader :mutex, :pool
+
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge(
+        :couchbase => {:default_format => :document, :key_prefix => 'rack:session:'})
+
+      def initialize(app, options = {})
+        # Support old :expires option
+        options[:expire_after] ||= options[:expires]
+        super
+
+        @default_options[:couchbase][:default_ttl] ||= options[:expire_after]
+        @default_options[:couchbase][:key_prefix] ||= options[:namespace]
+        @namespace = @default_options[:couchbase][:key_prefix]
+        @mutex = Mutex.new
+        @pool = ::Couchbase.connect(@default_options[:couchbase])
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        with_lock(env, [nil, {}]) do
+          unless sid and session = @pool.get(sid)
+            sid, session = generate_sid, {}
+            @pool.set(sid, session)
+          end
+          [sid, session]
+        end
+      end
+
+      def set_session(env, session_id, new_session, options)
+        with_lock(env, false) do
+          @pool.set session_id, new_session, options
+          session_id
+        end
+      end
+
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          @pool.delete(session_id)
+          generate_sid unless options[:drop]
+        end
+      end
+
+      def with_lock(env, default = nil)
+        @mutex.lock if env['rack.multithread']
+        yield
+      rescue Couchbase::Error::Connect, Couchbase::Error::Timeout
+        if $VERBOSE
+          warn "#{self} is unable to find Couchbase server."
+          warn $!.inspect
+        end
+        default
+      ensure
+        @mutex.unlock if @mutex.locked?
+      end
+    end
+  end
+end

data/tasks/compile.rake

@@ -57,7 +57,6 @@ end
 
 require 'rubygems/package_task'
 Gem::PackageTask.new(gemspec) do |pkg|
-  pkg.need_zip = true
   pkg.need_tar = true
 end
 
@@ -84,22 +83,14 @@ end
 namespace :ports do
   directory "ports"
 
-  task :libvbucket => ["ports"] do
-    recipe = MiniPortile.new "libvbucket", "1.8.0.3"
-    recipe.files << "http://packages.couchbase.com/clients/c/#{recipe.name}-#{recipe.version}.tar.gz"
-    recipe.configure_options.push("--disable-debug",
-                                  "--without-docs",
-                                  "--disable-dependency-tracking")
-    recipe.cook
-    recipe.activate
-  end
-
-  task :libcouchbase => [:libvbucket] do
-    recipe = MiniPortile.new "libcouchbase", "1.0.6"
-    recipe.files << "http://packages.couchbase.com/clients/c/#{recipe.name}-#{recipe.version}.tar.gz"
+  task :libcouchbase => ["ports"] do
+    recipe = MiniPortile.new "libcouchbase", "2.0.0beta_5_g970a292"
+    recipe.files << "http://packages.couchbase.com/clients/c/libcouchbase-#{recipe.version}.tar.gz"
     recipe.configure_options.push("--disable-debug",
                                   "--disable-dependency-tracking",
                                   "--disable-couchbasemock",
+                                  "--disable-cxx",
+                                  "--disable-examples",
                                   "--disable-tools")
     recipe.cook
     recipe.activate

data/test/setup.rb

@@ -36,7 +36,7 @@ class CouchbaseServer
       raise ArgumentError, "Check COUCHBASE_SERVER variable. It should be hostname:port"
     end
 
-    @config = Yajl::Parser.parse(open("http://#{@host}:#{@port}/pools/default"))
+    @config = MultiJson.load(open("http://#{@host}:#{@port}/pools/default"))
     @num_nodes = @config["nodes"].size
     @buckets_spec = params[:buckets_spec] || "default:"  # "default:,protected:secret,cache::memcache"
   end
@@ -50,7 +50,11 @@ class CouchbaseServer
                                  :username => name,
                                  :bucket => name,
                                  :password => password)
-      connection.flush
+      begin
+        connection.flush
+      rescue Couchbase::Error::NotSupported
+        # on recent server flush is disabled
+      end
     end
   end
   def stop; end

data/test/test_arithmetic.rb

@@ -84,7 +84,9 @@ class TestArithmetic < MiniTest::Unit::TestCase
     val = connection.incr(uniq_id(:missing), :create => true)
     assert_equal 1, val
     sleep(2)
-    refute connection.get(uniq_id(:missing))
+    assert_raises(Couchbase::Error::NotFound) do
+      connection.get(uniq_id(:missing))
+    end
   end
 
   def test_decrement_with_absolute_ttl
@@ -95,7 +97,9 @@ class TestArithmetic < MiniTest::Unit::TestCase
     assert_equal 0, val
     assert_equal 0, connection.get(uniq_id)
     sleep(2)
-    refute connection.get(uniq_id)
+    assert_raises(Couchbase::Error::NotFound) do
+      refute connection.get(uniq_id)
+    end
   end
 
   def test_it_allows_custom_delta
@@ -106,4 +110,30 @@ class TestArithmetic < MiniTest::Unit::TestCase
     assert_equal 22, val
   end
 
+  def test_it_allows_to_specify_delta_in_options
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+
+    connection.set(uniq_id, 12)
+    options = {:delta => 10}
+    val = connection.incr(uniq_id, options)
+    assert_equal 22, val
+  end
+
+  def test_multi_incr
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    connection.set(uniq_id(:foo) => 1, uniq_id(:bar) => 1)
+
+    assert_equal [2, 2],   connection.incr(uniq_id(:foo), uniq_id(:bar)).values.sort
+    assert_equal [12, 12], connection.incr(uniq_id(:foo), uniq_id(:bar), :delta => 10).values.sort
+    assert_equal [14, 15], connection.incr(uniq_id(:foo) => 2, uniq_id(:bar) => 3).values.sort
+  end
+
+  def test_multi_decr
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+    connection.set(uniq_id(:foo) => 14, uniq_id(:bar) => 15)
+
+    assert_equal [12, 12], connection.decr(uniq_id(:foo) => 2, uniq_id(:bar) => 3).values.sort
+    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
 end

data/test/test_async.rb

@@ -110,7 +110,9 @@ class TestAsync < MiniTest::Unit::TestCase
     assert success
     assert_equal "foo", val
     sleep(2)
-    refute connection.get(uniq_id)
+    assert_raises(Couchbase::Error::NotFound) do
+      connection.get(uniq_id)
+    end
   end
 
   def test_nested_async_delete_get
@@ -167,7 +169,9 @@ class TestAsync < MiniTest::Unit::TestCase
       end
     end
 
-    refute connection.get(uniq_id)
+    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)
@@ -222,13 +226,23 @@ class TestAsync < MiniTest::Unit::TestCase
     connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
     connection.set(uniq_id, "foo")
 
-    connection.timeout = 100  # 100 us
+    connection.timeout = 100_000  # 100_000 us
     connection.run do
       connection.get(uniq_id) do |ret|
         assert ret.success?
         assert_equal "foo", ret.value
       end
-      sleep(1.5)
+      sleep(1.5)  # 1_500_000 us
+    end
+  end
+
+  def test_send_threshold
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port)
+
+    sent = false
+    connection.run(:send_threshold => 100) do # 100 bytes
+      connection.set(uniq_id, "foo" * 100) {|r| sent = true}
+      assert sent
     end
   end
 

data/test/test_bucket.rb

@@ -151,7 +151,7 @@ class TestBucket < MiniTest::Unit::TestCase
     with_mock do |mock|
       connection = Couchbase.new(:hostname => mock.host,
                                  :port => mock.port)
-      assert connection.quiet?
+      refute connection.quiet?
 
       connection = Couchbase.new(:hostname => mock.host,
                                  :port => mock.port,
@@ -224,4 +224,14 @@ class TestBucket < MiniTest::Unit::TestCase
     end
   end
 
+  def test_it_uses_bucket_name_as_username_if_username_is_empty
+    with_mock(:buckets_spec => 'protected:secret') do |mock|
+      connection = Couchbase.new(:hostname => mock.host,
+                                 :port => mock.port,
+                                 :bucket => 'protected',
+                                 :password => 'secret')
+      assert connection.connected?
+    end
+  end
+
 end

data/test/test_cas.rb

@@ -44,13 +44,23 @@ class TestCas < MiniTest::Unit::TestCase
     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|
-        new_val = ret.value
-        new_val["baz"] = 2
-        new_val
+        calls += 1
+        case ret.operation
+        when :get
+          new_val = ret.value
+          new_val["baz"] = 2
+          new_val
+        when :set
+          assert ret.success?
+        else
+          flunk "Unexpected operation: #{ret.operation.inspect}"
+        end
       end
     end
+    assert_equal 2, calls
     val = connection.get(uniq_id)
     expected = {"bar" => 1, "baz" => 2}
     assert_equal expected, val

data/test/test_couchbase_rails_cache_store.rb

@@ -0,0 +1,294 @@
+# 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.
+#
+
+require File.join(File.dirname(__FILE__), 'setup')
+require 'active_support/cache/couchbase_store'
+require 'active_support/notifications'
+require 'ostruct'
+
+class TestCouchbaseRailsCacheStore < MiniTest::Unit::TestCase
+
+  def setup
+    @mock = start_mock
+    @foo = OpenStruct.new :payload => "foo"
+    @foobar = OpenStruct.new :payload => "foobar"
+  end
+
+  def teardown
+    stop_mock(@mock)
+  end
+
+  def store
+    @store ||= ActiveSupport::Cache::CouchbaseStore.new(:hostname => @mock.host,
+                                                        :port => @mock.port)
+  end
+
+  def test_it_supported_methods
+    supported_methods = store.public_methods(false).map(&:to_sym)
+    assert supported_methods.include?(:fetch)
+    assert supported_methods.include?(:write)
+    assert supported_methods.include?(:read)
+    assert supported_methods.include?(:read_multi)
+    assert supported_methods.include?(:increment)
+    assert supported_methods.include?(:decrement)
+    assert supported_methods.include?(:exists?)
+    assert supported_methods.include?(:delete)
+    assert supported_methods.include?(:stats)
+    refute supported_methods.include?(:clear)
+    assert_raises(NotImplementedError) do
+      store.clear
+    end
+    refute supported_methods.include?(:cleanup)
+    assert_raises(NotImplementedError) do
+      store.cleanup
+    end
+  end
+
+  def test_it_writes_and_reads_the_data
+    store.write uniq_id, @foobar
+    assert_equal @foobar, store.read(uniq_id)
+  end
+
+  def test_it_writes_the_data_with_expiration_time
+    store.write(uniq_id, @foobar, :expires_in => 1.second)
+    assert_equal @foobar, store.read(uniq_id)
+    sleep 2
+    refute store.read(uniq_id)
+  end
+
+  def test_it_doest_write_data_if_unless_exist_option_is_true
+    store.write uniq_id, @foo
+    [:unless_exist, :unless_exists].each do |unless_exists|
+      store.write uniq_id, @foobar, unless_exists => true
+      assert_equal @foo, store.read(uniq_id)
+    end
+  end
+
+  if RUBY_VERSION.match /1\.9/
+    def test_it_reads_raw_data
+      store.write uniq_id, @foo
+      assert_equal "\x04\bU:\x0FOpenStruct{\x06:\fpayloadI\"\bfoo\x06:\x06EF",
+        store.read(uniq_id, :raw => true)
+    end
+  else
+    def test_it_reads_raw_data
+      store.write uniq_id, @foo
+      assert_equal "\004\bU:\017OpenStruct{\006:\fpayload\"\bfoo",
+        store.read(uniq_id, :raw => true)
+    end
+  end
+
+  def test_it_writes_raw_data
+    store.write uniq_id, @foobar, :raw => true
+    assert_equal '#<OpenStruct payload="foobar">', store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_deletes_data
+    store.write uniq_id, @foo
+    store.delete uniq_id
+    refute store.read(uniq_id)
+  end
+
+  def test_it_verifies_existence_of_an_object_in_the_store
+    store.write uniq_id, @foo
+    assert store.exist?(uniq_id)
+    refute store.exist?(uniq_id(:missing))
+  end
+
+  def test_it_initializes_key_on_first_increment_with_zero
+    store.increment(uniq_id)
+    assert_equal 0, store.read(uniq_id)
+    assert_equal "0", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_initializes_key_on_first_decrement_with_zero
+    store.decrement(uniq_id)
+    assert_equal 0, store.read(uniq_id)
+    assert_equal "0", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_initializes_key_with_given_value_on_increment
+    store.increment(uniq_id, 1, :initial => 5)
+    assert_equal 5, store.read(uniq_id)
+    assert_equal "5", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_initializes_key_with_given_value_on_decrement
+    store.decrement(uniq_id, 1, :initial => 5)
+    assert_equal 5, store.read(uniq_id)
+    assert_equal "5", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_increments_a_key
+    3.times { store.increment uniq_id }
+    assert_equal 2, store.read(uniq_id)
+    assert_equal "2", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_decrements_a_key
+    4.times { store.increment uniq_id }
+    2.times { store.decrement uniq_id }
+    assert_equal 1, store.read(uniq_id)
+    assert_equal "1", store.read(uniq_id, :raw => true)
+  end
+
+  def test_it_increments_a_raw_key
+    assert store.write(uniq_id, 1, :raw => true)
+    store.increment(uniq_id, 2)
+    assert_equal 3, store.read(uniq_id, :raw => true).to_i
+  end
+
+  def test_it_decrements_a_raw_key
+    assert store.write(uniq_id, 3, :raw => true)
+    store.decrement(uniq_id, 2)
+    assert_equal 1, store.read(uniq_id, :raw => true).to_i
+  end
+
+  def test_it_increments_a_key_by_given_value
+    store.write(uniq_id, 0, :raw => true)
+    store.increment uniq_id, 3
+    assert_equal 3, store.read(uniq_id, :raw => true).to_i
+  end
+
+  def test_it_decrements_a_key_by_given_value
+    store.write(uniq_id, 0, :raw => true)
+    3.times { store.increment uniq_id }
+    store.decrement uniq_id, 2
+    assert_equal 1, store.read(uniq_id, :raw => true).to_i
+  end
+
+  def test_it_provides_store_stats
+    refute store.stats.empty?
+  end
+
+  def test_it_fetches_data
+    assert store.write(uniq_id, @foo)
+    assert_equal @foo, store.fetch(uniq_id)
+    refute store.fetch("rub-a-dub")
+    store.fetch("rub-a-dub") { "Flora de Cana" }
+    assert_equal "Flora de Cana", store.fetch("rub-a-dub")
+    store.fetch(uniq_id, :force => true) # force cache miss
+    store.fetch(uniq_id, :force => true, :expires_in => 1.second) { @foobar }
+    assert_equal @foobar, store.fetch(uniq_id)
+    sleep 2
+    refute store.fetch(uniq_id)
+  end
+
+  def test_it_reads_multiple_keys
+    assert store.write(uniq_id(1), @foo)
+    assert store.write(uniq_id(2), "foo")
+    result = store.read_multi uniq_id(1), uniq_id(2)
+    assert_equal @foo, result[uniq_id(1)]
+    assert_equal "foo", result[uniq_id(2)]
+  end
+
+  def test_it_reads_multiple_keys_and_returns_only_the_matched_ones
+    assert store.write(uniq_id, @foo)
+    result = store.read_multi uniq_id, uniq_id(:missing)
+    assert result[uniq_id]
+    refute result[uniq_id(:missing)]
+  end
+
+  def test_it_notifies_on_fetch
+    collect_notifications do
+      store.fetch(uniq_id) { "foo" }
+    end
+
+    read, generate, write = @events
+
+    assert_equal 'cache_read.active_support', read.name
+    assert_equal({:key => uniq_id, :super_operation => :fetch}, read.payload)
+
+    assert_equal 'cache_generate.active_support', generate.name
+    assert_equal({:key => uniq_id}, generate.payload)
+
+    assert_equal 'cache_write.active_support', write.name
+    assert_equal({:key => uniq_id}, write.payload)
+  end
+
+  def test_it_notifies_on_read
+    collect_notifications do
+      store.read uniq_id
+    end
+
+    read = @events.first
+    assert_equal 'cache_read.active_support', read.name
+    assert_equal({:key => uniq_id, :hit => false}, read.payload)
+  end
+
+  def test_it_notifies_on_write
+    collect_notifications do
+      store.write uniq_id, "foo"
+    end
+
+    write = @events.first
+    assert_equal 'cache_write.active_support', write.name
+    assert_equal({:key => uniq_id}, write.payload)
+  end
+
+  def test_it_notifies_on_delete
+    collect_notifications do
+      store.delete uniq_id
+    end
+
+    delete = @events.first
+    assert_equal 'cache_delete.active_support', delete.name
+    assert_equal({:key => uniq_id}, delete.payload)
+  end
+
+  def test_it_notifies_on_exist?
+    collect_notifications do
+      store.exist? uniq_id
+    end
+
+    exist = @events.first
+    assert_equal 'cache_exists?.active_support', exist.name
+    assert_equal({:key => uniq_id}, exist.payload)
+  end
+
+  def test_it_notifies_on_increment
+    collect_notifications do
+      store.increment uniq_id
+    end
+
+    increment = @events.first
+    assert_equal 'cache_increment.active_support', increment.name
+    assert_equal({:key => uniq_id, :amount => 1, :create => true}, increment.payload)
+  end
+
+  def test_it_notifies_on_decrement
+    collect_notifications do
+      store.decrement uniq_id
+    end
+
+    decrement = @events.first
+    assert_equal 'cache_decrement.active_support', decrement.name
+    assert_equal({:key => uniq_id, :amount => 1, :create => true}, decrement.payload)
+  end
+
+  private
+
+  def collect_notifications
+    @events = [ ]
+    ActiveSupport::Cache::CouchbaseStore.instrument = true
+    ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
+      @events << ActiveSupport::Notifications::Event.new(*args)
+    end
+    yield
+    ActiveSupport::Cache::CouchbaseStore.instrument = false
+  end
+end