couchbase-jruby-client 0.1.0-java

data/lib/couchbase/view_row.rb

@@ -0,0 +1,272 @@
+# 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
+  # This class encapsulates structured JSON document
+  #
+  # @since 1.2.0
+  #
+  # It behaves like Hash for document included into row, and has access methods to row data as well.
+  #
+  # @see http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views-datastore.html
+  class ViewRow
+    include Constants
+
+    # Undefine as much methods as we can to free names for views
+    instance_methods.each do |m|
+      undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$|^class$|)/
+    end
+
+    # The hash built from JSON document.
+    #
+    # @since 1.2.0
+    #
+    # This is complete response from the Couchbase
+    #
+    # @return [Hash]
+    attr_accessor :data
+
+    # The key which was emitted by map function
+    #
+    # @since 1.2.0
+    #
+    # @see http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views-writing-map.html
+    #
+    # Usually it is String (the object +_id+) but it could be also any
+    # compount JSON value.
+    #
+    # @return [Object]
+    attr_accessor :key
+
+    # The value which was emitted by map function
+    #
+    # @since 1.2.0
+    #
+    # @see http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views-writing-map.html
+    #
+    # @return [Object]
+    attr_accessor :value
+
+    # The document hash.
+    #
+    # @since 1.2.0
+    #
+    # It usually available when view executed with +:include_doc+ argument.
+    #
+    # @return [Hash]
+    attr_accessor :doc
+
+    # The identificator of the document
+    #
+    # @since 1.2.0
+    #
+    # @return [String]
+    attr_accessor :id
+
+    # The meta data linked to the document
+    #
+    # @since 1.2.0
+    #
+    # @return [Hash]
+    attr_accessor :meta
+
+    # Initialize the document instance
+    #
+    # @since 1.2.0
+    #
+    # It takes reference to the bucket, data hash.
+    #
+    # @param [Couchbase::Bucket] bucket the reference to connection
+    # @param [Hash] data the data hash, which was built from JSON document
+    #   representation
+    def initialize(bucket, data)
+      @bucket = bucket
+      @data = data
+      @key = data[S_KEY]
+      @value = data[S_VALUE]
+      if data[S_DOC]
+        @meta = data[S_DOC][S_META]
+        @doc = data[S_DOC][S_VALUE]
+      end
+      @id = data[S_ID] || @meta && @meta[S_ID]
+      @last = data.delete(S_IS_LAST) || false
+    end
+
+    # Wraps data hash into ViewRow instance
+    #
+    # @since 1.2.0
+    #
+    # @see ViewRow#initialize
+    #
+    # @param [Couchbase::Bucket] bucket the reference to connection
+    # @param [Hash] data the data hash, which was built from JSON document
+    #   representation
+    #
+    # @return [ViewRow]
+    def self.wrap(bucket, data)
+      self.new(bucket, data)
+    end
+
+    # Get attribute of the document
+    #
+    # @since 1.2.0
+    #
+    # Fetches attribute from underlying document hash
+    #
+    # @param [String] key the attribute name
+    #
+    # @return [Object] property value or nil
+    def [](key)
+      @doc[key]
+    end
+
+    # Check attribute existence
+    #
+    # @since 1.2.0
+    #
+    # @param [String] key the attribute name
+    #
+    # @return [true, false] +true+ if the given attribute is present in in
+    #   the document.
+    def has_key?(key)
+      @doc.has_key?(key)
+    end
+
+    # Set document attribute
+    #
+    # @since 1.2.0
+    #
+    # Set or update the attribute in the document hash
+    #
+    # @param [String] key the attribute name
+    # @param [Object] value the attribute value
+    #
+    # @return [Object] the value
+    def []=(key, value)
+      @doc[key] = value
+    end
+
+    # Signals if this row is last in a stream
+    #
+    # @since 1.2.1
+    #
+    # @return [true, false] +true+ if this row is last in a stream
+    def last?
+      @last
+    end
+
+    def inspect
+      desc = "#<#{self.class.name}:#{self.object_id}"
+      [:@id, :@key, :@value, :@doc, :@meta].each do |iv|
+        desc << " #{iv}=#{instance_variable_get(iv).inspect}"
+      end
+      desc << ">"
+      desc
+    end
+  end
+
+  # This class encapsulates information about design docs
+  #
+  # @since 1.2.1
+  #
+  # It is subclass of ViewRow, but also gives access to view creation through method_missing
+  #
+  # @see http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views-datastore.html
+  class DesignDoc < ViewRow
+    # It isn't allowed to change design document ID after
+    # initialization
+    undef id=
+
+    # Initialize the design doc instance
+    #
+    # @since 1.2.1
+    #
+    # It takes reference to the bucket, data hash. It will define view
+    # methods if the data object looks like design document.
+    #
+    # @param [Couchbase::Bucket] bucket the reference to connection
+    # @param [Hash] data the data hash, which was built from JSON document
+    #   representation
+    def initialize(bucket, data)
+      super
+      @all_views = {}
+      @views = @doc.has_key?('views') ? @doc['views'].keys : []
+      @spatial = @doc.has_key?('spatial') ? @doc['spatial'].keys : []
+      @views.each{|name| @all_views[name] = "#{@id}/_view/#{name}"}
+      @spatial.each{|name| @all_views[name] = "#{@id}/_spatial/#{name}"}
+    end
+
+    def method_missing(meth, *args)
+      if path = @all_views[meth.to_s]
+        View.new(@bucket, path, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth, *args)
+      if @all_views[meth.to_s]
+        true
+      else
+        super
+      end
+    end
+
+    def method(meth, *args)
+      if path = @all_views[meth.to_s]
+        lambda{|*p| View.new(@bucket, path, *p)}
+      else
+        super
+      end
+    end
+
+    # The list of views defined or empty array
+    #
+    # @since 1.2.1
+    #
+    # @return [Array<View>]
+    attr_accessor :views
+
+    # The list of spatial views defined or empty array
+    #
+    # @since 1.2.1
+    #
+    # @return [Array<View>]
+    attr_accessor :spatial
+
+    # Check if the document has views defines
+    #
+    # @since 1.2.1
+    #
+    # @see DesignDoc#views
+    #
+    # @return [true, false] +true+ if the document have views
+    def has_views?
+      !@views.empty?
+    end
+
+    def inspect
+      desc = "#<#{self.class.name}:#{self.object_id}"
+      [:@id, :@views, :@spatial].each do |iv|
+        desc << " #{iv}=#{instance_variable_get(iv).inspect}"
+      end
+      desc << ">"
+      desc
+    end
+
+  end
+end

data/lib/couchbase.rb

@@ -0,0 +1,177 @@
+
+unless RUBY_PLATFORM =~ /java/
+  error "This gem is only compatible with a java-based ruby environment like JRuby."
+  exit 255
+end
+
+require 'java'
+require 'jars/commons-codec-1.5.jar'
+require 'jars/couchbase-client-1.2.0.jar'
+require 'jars/jettison-1.1.jar'
+require 'jars/httpcore-4.1.1.jar'
+require 'jars/netty-3.5.5.Final.jar'
+require 'jars/spymemcached-2.10.0.jar'
+require 'jars/httpcore-nio-4.1.1.jar'
+require 'couchbase/version'
+require 'uri'
+require 'atomic'
+require 'couchbase/transcoder'
+require 'couchbase/async'
+require 'couchbase/operations'
+require 'couchbase/error'
+require 'couchbase/constants'
+require 'couchbase/utils'
+require 'couchbase/bucket'
+require 'couchbase/view_row'
+require 'couchbase/view'
+require 'couchbase/result'
+require 'couchbase/cluster'
+
+include Java
+
+import Java::com.couchbase.client.CouchbaseClient;
+
+at_exit do
+  Couchbase.disconnect
+end
+
+# Couchbase jruby client
+module Couchbase
+
+  @@bucket = Atomic.new(nil)
+
+  class << self
+
+    # The method +connect+ initializes new Bucket instance with all arguments passed.
+    #
+    # @since 1.0.0
+    #
+    # @see Bucket#initialize
+    #
+    # @example Use default values for all options
+    #   Couchbase.connect
+    #
+    # @example Establish connection with couchbase default pool and default bucket
+    #   Couchbase.connect("http://localhost:8091/pools/default")
+    #
+    # @example Select custom bucket
+    #   Couchbase.connect("http://localhost:8091/pools/default", :bucket => 'blog')
+    #
+    # @example Specify bucket credentials
+    #   Couchbase.connect("http://localhost:8091/pools/default", :bucket => 'blog', :username => 'bucket', :password => 'secret')
+    #
+    # @example Use URL notation
+    #   Couchbase.connect("http://bucket:secret@localhost:8091/pools/default/buckets/blog")
+    #
+    # @return [Bucket] connection instance
+    def connect(*options)
+      disconnect
+      @@bucket.update { |bucket| bucket ||= Bucket.new(*(options.flatten)) }
+      @@bucket.value
+    end
+    alias :new :connect
+
+    # Default connection options
+    #
+    # @since 1.1.0
+    #
+    # @example Using {Couchbase#connection_options} to change the bucket
+    #   Couchbase.connection_options = {:bucket => 'blog'}
+    #   Couchbase.bucket.name     #=> "blog"
+    #
+    # @return [Hash, String]
+    attr_accessor :connection_options
+
+    # The connection instance for current thread
+    #
+    # @since 1.1.0
+    #
+    # @see Couchbase.connection_options
+    #
+    # @example
+    #   Couchbase.bucket.set("foo", "bar")
+    #
+    # @return [Bucket]
+    def bucket
+      if !connected?
+        connect(connection_options)
+      end
+      @@bucket.value
+    end
+
+    # Set a connection instance for current thread
+    #
+    # @since 1.1.0
+    #
+    # @return [Bucket]
+    def bucket=(connection)
+      @@bucket.update { |bucket| bucket = connection }
+    end
+
+    def connected?
+      !!@@bucket.value
+    end
+
+    def disconnect
+      @@bucket.value.disconnect if connected?
+      @@bucket = Atomic.new(nil)
+    end
+  end
+end
+
+__END__
+
+    def self.connect(*options)
+      disconnect
+      Bucket.new(*(options.flatten))
+    end
+
+    def self.new(*options)
+      connect(options)
+    end
+
+    # Default connection options
+    #
+    # @since 1.1.0
+    #
+    # @example Using {Couchbase#connection_options} to change the bucket
+    #   Couchbase.connection_options = {:bucket => 'blog'}
+    #   Couchbase.bucket.name     #=> "blog"
+    #
+    # @return [Hash, String]
+    attr_accessor :connection_options
+
+    # The connection instance for current thread
+    #
+    # @since 1.1.0
+    #
+    # @see Couchbase.connection_options
+    #
+    # @example
+    #   Couchbase.bucket.set("foo", "bar")
+    #
+    # @return [Bucket]
+    def self.bucket
+      @bucket ||= connect(connection_options)
+    end
+
+    # Set a connection instance for current thread
+    #
+    # @since 1.1.0
+    #
+    # @return [Bucket]
+    def self.bucket=(connection)
+      @bucket = connection
+    end
+
+    def self.connected?
+      !!@bucket
+    end
+
+    def self.disconnect
+      bucket.disconnect if connected?
+      @bucket = nil
+    end
+
+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