couchbase 1.3.4-x64-mingw32

data/tasks/test.rake

@@ -0,0 +1,100 @@
+# 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 'rake/testtask'
+require 'rake/clean'
+
+rule 'test/CouchbaseMock.jar' do |task|
+  jar_path = "0.5-SNAPSHOT/CouchbaseMock-0.5-20120726.220757-19.jar"
+  sh %{wget -q -O test/CouchbaseMock.jar http://files.couchbase.com/maven2/org/couchbase/mock/CouchbaseMock/#{jar_path}}
+end
+
+CLOBBER << 'test/CouchbaseMock.jar'
+
+module FileUtils
+  alias :orig_ruby :ruby
+
+  def ruby(*args, &block)
+    executable = [ENV['RUBY_PREFIX'], RUBY].flatten.compact.join(' ')
+    options = (Hash === args.last) ? args.pop : {}
+    if args.length > 1 then
+      sh(*([executable] + args + [options]), &block)
+    else
+      sh("#{executable} #{args.first}", options, &block)
+    end
+  end
+end
+
+Rake::TestTask.new do |test|
+  test.libs << "test" << "."
+  test.pattern = 'test/test_*.rb'
+  test.options = '--verbose'
+end
+
+Rake::Task['test'].prerequisites.unshift('test/CouchbaseMock.jar')
+
+common_flags = %w[
+  --tool=memcheck
+  --error-limit=no
+  --undef-value-errors=no
+  --leak-check=full
+  --show-reachable=yes
+  --num-callers=50
+  --track-fds=yes
+  --workaround-gcc296-bugs=yes
+  --leak-resolution=med
+  --max-stackframe=7304328
+  --partial-loads-ok=yes
+]
+
+desc "Run the test suite under Valgrind memcheck."
+task "test:valgrind" do
+  ENV['RUBY_PREFIX'] = "valgrind #{common_flags.join(' ')}"
+  Rake::Task['test'].invoke
+end
+
+desc "Run the test suite under Valgrind memcheck with memory-fill."
+task "test:valgrind:mem_fill" do
+  local_flags = %w[
+    --malloc-fill=6D
+    --freelist-vol=100000000
+    --free-fill=66
+  ]
+  ENV['RUBY_PREFIX'] = "valgrind #{common_flags.join(' ')} #{local_flags.join(' ')}"
+  Rake::Task['test'].invoke
+end
+
+desc "Run the test suite under Valgrind memcheck with memory-zero."
+task "test:valgrind:mem_zero" do
+  local_flags = %w[
+    --freelist-vol=100000000
+    --malloc-fill=00
+    --free-fill=00
+  ]
+  ENV['RUBY_PREFIX'] = "valgrind #{common_flags.join(' ')} #{local_flags.join(' ')}"
+  Rake::Task['test'].invoke
+end
+
+desc "Run the test suite under Valgrind massif."
+task "test:valgrind:massif" do
+  local_flags = %w[
+    --tool=massif
+    --time-unit=B
+  ]
+  ENV['RUBY_PREFIX'] = "valgrind #{local_flags.join(' ')}"
+  Rake::Task['test'].invoke
+end

data/tasks/util.rake

@@ -0,0 +1,21 @@
+# 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.
+#
+
+desc 'Start an irb session and load the library.'
+task :console do
+  exec "irb -I lib -rcouchbase"
+end

data/test/profile/.gitignore

@@ -0,0 +1 @@
+benchmark*.log

data/test/profile/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gem "memcached", "~> 1.3.6"
+gem "kgio", "~> 2.7.2"
+gem "dalli", "~> 1.1.4"
+gem "yajl-ruby", "~> 1.1.0"

data/test/profile/benchmark.rb

@@ -0,0 +1,195 @@
+# Useful environment variables:
+#
+# LOOPS (50000)
+#   how many time run exercises
+#
+# HOST (127.0.0.1)
+#   the host where cluster is running. benchmark will use default ports to
+#   connect to it (11211 and 8091)
+#
+# STACK_DEPTH (0)
+#   the depth of stack where exercises are run. the benchmark will
+#   recursively go to given depth before run
+#
+# TEST ('')
+#   use to run specific test (possible values are: set, get, get-multi,
+#   append, prepend, delete, get-missing, append-missing, prepend-missing,
+#   set-large, get-large)
+#
+# CLIENT ('')
+#   use to run with specific client (possible values are: couchbase, dalli,
+#   memcached, memcached:buffer)
+#
+# DEBUG ('')
+#   show exceptions
+#
+
+require "rubygems"
+require "bundler/setup"
+
+require 'benchmark'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "..", "lib")
+require 'couchbase'
+require 'memcached'
+require 'dalli'
+
+puts `uname -a`
+puts File.readlines('/proc/cpuinfo').sort.uniq.grep(/model name|cpu cores/) rescue nil
+puts RUBY_DESCRIPTION
+
+class Bench
+
+  def initialize(loops = nil, stack_depth = nil)
+    @loops = (loops || 50000).to_i
+    @stack_depth = (stack_depth || 0).to_i
+
+    puts "PID is #{Process.pid}"
+    puts "Loops is #{@loops}"
+    puts "Stack depth is #{@stack_depth}"
+
+    @m_value = Marshal.dump(
+      @small_value = ["testing"])
+    @m_large_value = Marshal.dump(
+      @large_value = [{"test" => "1", "test2" => "2", Object.new => "3", 4 => 4, "test5" => 2**65}] * 2048)
+
+    puts "Small value size is: #{@m_value.size} bytes"
+    puts "Large value size is: #{@m_large_value.size} bytes"
+
+    @keys = [
+      @k1 = "Short",
+      @k2 = "Sym1-2-3::45" * 8,
+      @k3 = "Long" * 40,
+      @k4 = "Medium" * 8,
+      @k5 = "Medium2" * 8,
+      @k6 = "Long3" * 40]
+
+    reset_clients
+
+    Benchmark.bm(36) do |x|
+      @benchmark = x
+    end
+  end
+
+  def run(level = @stack_depth)
+    level > 0 ? run(level - 1) : run_without_recursion
+  end
+
+  private
+
+  def reset_clients
+    host = ENV['HOST'] || '127.0.0.1'
+    @clients = {
+      "dalli" => lambda { Dalli::Client.new("#{host}:11211", :marshal => true, :threadsafe => false) },
+      "memcached" => lambda { Memcached::Rails.new("#{host}:11211", :no_block => false, :buffer_requests => false, :binary_protocol => true) },
+      "memcached:buffer" => lambda { Memcached::Rails.new("#{host}:11211", :no_block => true, :buffer_requests => true, :binary_protocol => true) },
+      "couchbase" => lambda { Couchbase.new("http://#{host}:8091/pools/default/buckets/default", :default_format => :marshal) }
+    }
+  end
+
+  def benchmark_clients(test_name, populate_keys = true)
+    return if ENV["TEST"] and !test_name.include?(ENV["TEST"])
+
+    @clients.keys.each do |client_name|
+      next if ENV["CLIENT"] and !client_name.include?(ENV["CLIENT"])
+
+      kid = fork do
+        client = @clients[client_name].call
+        begin
+          if populate_keys
+            client.set @k1, @m_value
+            client.set @k2, @m_value
+            client.set @k3, @m_value
+          else
+            client.delete @k1
+            client.delete @k2
+            client.delete @k3
+          end
+
+          GC.disable
+          @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
+          STDOUT.flush
+        rescue Exception => e
+          puts "#{test_name}: #{client_name} => #{e.inspect}" if ENV["DEBUG"]
+        end
+        exit
+      end
+      Signal.trap("INT") { Process.kill("KILL", kid); exit }
+      Process.wait(kid)
+    end
+    puts
+  end
+
+  def run_without_recursion
+    benchmark_clients("set") do |c|
+      c.set @k1, @m_value
+      c.set @k2, @m_value
+      c.set @k3, @m_value
+    end
+
+    benchmark_clients("get") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+    benchmark_clients("get_multi") do |c|
+      if c.respond_to?(:get_multi)
+        c.get_multi @keys
+      else
+        c.get @keys
+      end
+    end
+
+    benchmark_clients("append") do |c|
+      c.append @k1, @m_value
+      c.append @k2, @m_value
+      c.append @k3, @m_value
+    end
+
+    benchmark_clients("prepend") do |c|
+      c.prepend @k1, @m_value
+      c.prepend @k2, @m_value
+      c.prepend @k3, @m_value
+    end
+
+    benchmark_clients("delete") do |c|
+      c.delete @k1
+      c.delete @k2
+      c.delete @k3
+    end
+
+    benchmark_clients("get_missing", false) do |c|
+      c.get @k1 rescue nil
+      c.get @k2 rescue nil
+      c.get @k3 rescue nil
+    end
+
+    benchmark_clients("append_missing", false) do |c|
+      c.append @k1, @m_value rescue nil
+      c.append @k2, @m_value rescue nil
+      c.append @k3, @m_value rescue nil
+    end
+
+    benchmark_clients("prepend_missing", false) do |c|
+      c.prepend @k1, @m_value rescue nil
+      c.prepend @k2, @m_value rescue nil
+      c.prepend @k3, @m_value rescue nil
+    end
+
+    benchmark_clients("set_large") do |c|
+      c.set @k1, @m_large_value
+      c.set @k2, @m_large_value
+      c.set @k3, @m_large_value
+    end
+
+    benchmark_clients("get_large") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+  end
+end
+
+Bench.new(ENV["LOOPS"], ENV["STACK_DEPTH"]).run

data/test/setup.rb

@@ -0,0 +1,178 @@
+# 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 'minitest/autorun'
+require 'couchbase'
+
+require 'socket'
+require 'open-uri'
+
+class CouchbaseServer
+  attr_accessor :host, :port, :num_nodes, :buckets_spec
+
+  def real?
+    true
+  end
+
+  def initialize(params = {})
+    @host, @port = ENV['COUCHBASE_SERVER'].split(':')
+    @port = @port.to_i
+
+    if @host.nil? || @host.empty? || @port == 0
+      raise ArgumentError, "Check COUCHBASE_SERVER variable. It should be hostname:port"
+    end
+
+    @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
+
+  def start
+    # flush all buckets
+    @buckets_spec.split(',') do |bucket|
+      name, password, _ = bucket.split(':')
+      connection = Couchbase.new(:hostname => @host,
+                                 :port => @port,
+                                 :username => name,
+                                 :bucket => name,
+                                 :password => password)
+      begin
+        connection.flush
+      rescue Couchbase::Error::NotSupported
+        # on recent server flush is disabled
+      end
+    end if ENV['COUCHBASE_FLUSH_BUCKETS']
+  end
+  def stop; end
+end
+
+class CouchbaseMock
+  Monitor = Struct.new(:pid, :client, :socket, :port)
+
+  attr_accessor :host, :port, :buckets_spec, :num_nodes, :num_vbuckets
+
+  def real?
+    false
+  end
+
+  def initialize(params = {})
+    @host = "127.0.0.1"
+    @port = 0
+    @num_nodes = 10
+    @num_vbuckets = 4096
+    @buckets_spec = "default:"  # "default:,protected:secret,cache::memcache"
+    params.each do |key, value|
+      send("#{key}=", value)
+    end
+    yield self if block_given?
+    if @num_vbuckets < 1 || (@num_vbuckets & (@num_vbuckets - 1) != 0)
+      raise ArgumentError, "Number of vbuckets should be a power of two and greater than zero"
+    end
+  end
+
+  def start
+    @monitor = Monitor.new
+    @monitor.socket = TCPServer.new(nil, 0)
+    @monitor.socket.listen(10)
+    _, @monitor.port, _, _ = @monitor.socket.addr
+    trap("CLD") do
+      puts "CouchbaseMock.jar died unexpectedly during startup"
+      exit(1)
+    end
+    @monitor.pid = fork
+    if @monitor.pid.nil?
+      rc = exec(command_line("--harakiri-monitor=:#{@monitor.port}"))
+    else
+      trap("CLD", "SIG_DFL")
+      @monitor.client, _ = @monitor.socket.accept
+      @port = @monitor.client.recv(100).to_i
+    end
+  end
+
+  def stop
+    @monitor.client.close
+    @monitor.socket.close
+    Process.kill("TERM", @monitor.pid)
+    Process.wait(@monitor.pid)
+  end
+
+  def failover_node(index, bucket = "default")
+    @monitor.client.send("failover,#{index},#{bucket}", 0)
+  end
+
+  def respawn_node(index, bucket = "default")
+    @monitor.client.send("respawn,#{index},#{bucket}", 0)
+  end
+
+  protected
+
+  def command_line(extra = nil)
+    cmd = "java -jar #{File.dirname(__FILE__)}/CouchbaseMock.jar"
+    cmd << " --host #{@host}" if @host
+    cmd << " --port #{@port}" if @port
+    cmd << " --nodes #{@num_nodes}" if @num_nodes
+    cmd << " --vbuckets #{@num_vbuckets}" if @num_vbuckets
+    cmd << " --buckets #{@buckets_spec}" if @buckets_spec
+    cmd << " #{extra}"
+    cmd
+  end
+end
+
+class MiniTest::Test
+
+  def start_mock(params = {})
+    mock = nil
+    if ENV['COUCHBASE_SERVER']
+      mock = CouchbaseServer.new(params)
+      if (params[:port] && mock.port != params[:port]) ||
+        (params[:host] && mock.host != params[:host]) ||
+        mock.buckets_spec != "default:"
+        skip("Unable to configure real cluster. Requested config is: #{params.inspect}")
+      end
+    else
+      mock = CouchbaseMock.new(params)
+    end
+    mock.start
+    mock
+  end
+
+  def stop_mock(mock)
+    assert(mock)
+    mock.stop
+  end
+
+  def with_mock(params = {})
+    mock = nil
+    if block_given?
+      mock = start_mock(params)
+      yield mock
+    end
+  ensure
+    stop_mock(mock) if mock
+  end
+
+  def uniq_id(*suffixes)
+    test_id = [caller.first[/.*[` ](.*)'/, 1], suffixes].compact.join("_")
+    @ids ||= {}
+    @ids[test_id] ||= Time.now.to_f
+    [test_id, @ids[test_id]].join("_")
+  end
+
+  def after_teardown
+    GC.start
+  end
+end