couchbase-jruby-client 0.1.9-java → 0.2.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ff8556640816f6cb67c87afb0aaeb5fc7001f2f
-  data.tar.gz: 08314e3ea7bec37d1010bad128a106fb61c73127
+  metadata.gz: 71bccd5819d83c3e1493076d252d676a36fe311f
+  data.tar.gz: ca2c16285b9d3fc2672d6af3467db5a14d19b8ca
 SHA512:
-  metadata.gz: 1c6218643d51c032b95aad0cb00944c617eb79c753fe095a4ae8f909be2ceb83e838aa629f9da3751a97862c9e1b18b645fd017bd88f9297f529aed6e74141ad
-  data.tar.gz: 46970dc0dcf1342ff99982058d5b768c28f3d57b66b4bd93d8f1732b5bf96146b094d13914bd06222b6d6e3507a34d27483c875f9a5b280c1dccac8a17b109d1
+  metadata.gz: df3f4ddb4342333fe81bc7ed140b934cefcd4f3ce3d5e204c1b3409b88ebe2c7eb7baed3380fe8d11bc8f7efd2682021664f721e6ac4d0fb1d0184a3871af6ae
+  data.tar.gz: e557ddfa428849542ea131d55d98ac3a0280d367dfd46624391e6402f564932040e4afd73f5ee6070418b6588cb461fee3d10f62be32711a11a56e7deb91c717

data/README.md

@@ -5,8 +5,7 @@
 [![Coverage Status](https://coveralls.io/repos/mje113/couchbase-jruby-client/badge.png)](https://coveralls.io/r/mje113/couchbase-jruby-client)
 [![Dependency Status](https://gemnasium.com/mje113/couchbase-jruby-client.png)](https://gemnasium.com/mje113/couchbase-jruby-client)
 
-Attempt to recreate the ruby Couchbase client api in JRuby and the
-Couchbase Java SDK.
+JRuby wrapper of the Couchbase Java SDK that attempts to adhere to Ruby client API.
 
 ## Installation
 
@@ -22,14 +21,17 @@ Or install it yourself as:
 
     $ gem install couchbase-jruby-client
 
-## Caveat
+## Caveats
 
-Please consider this project a very incomplete "alpha" version at best. I'm getting close
-to full coverage, though there are still some missing features.  In fact, as I've gotten
-more familiar with the differences between the native ruby api and the java, there are
-definitely some features that don't make sense to implement.
+Do to the very different approaches that the Ruby and Java SDKs take, 100% compatibility with the Ruby
+API isn't practical.  That said, enough compatibility exists today for the couchbase-ruby-model gem
+to function properly.
 
-Ultimately hoping to get to 100% support of the couchbase-ruby-model gem.
+* Since the original [couchbase-ruby-model](https://github.com/couchbase/couchbase-ruby-model) gem has a dependency
+  on the ruby client, use my fork instead: [couchbase-jruby-model](https://github.com/mje113/couchbase-jruby-model).
+* The ruby client async `run` blocks aren't supported as they were not truly asynchronous (the code executed within
+  the block uses libcouchbase's async calls, but the clock itself blocks until everything is complete).
+* The Java SDK's aysnc methods are exposed to truly async operations and registered callbacks.
 
 ## Usage
 
@@ -38,115 +40,129 @@ they are largely the same. Important bits copied below:
 
 First of all you need to load library:
 
-    require 'couchbase'
+```ruby
+require 'couchbase'
+```
 
 There are several ways to establish new connection to Couchbase Server.
 By default it uses the `http://localhost:8091/pools/default/buckets/default`
 as the endpoint. The client will automatically adjust configuration when
 the cluster will rebalance its nodes when nodes are added or deleted
-therefore this client is "smart".
+therefore this client is 'smart'.
 
-    c = Couchbase.connect
+```ruby
+c = Couchbase.connect
+```
 
 This is equivalent to following forms:
 
-    c = Couchbase.connect("http://localhost:8091/pools/default/buckets/default")
-    c = Couchbase.connect("http://localhost:8091/pools/default")
-    c = Couchbase.connect("http://localhost:8091")
-    c = Couchbase.connect(:hostname => "localhost")
-    c = Couchbase.connect(:hostname => "localhost", :port => 8091)
-    c = Couchbase.connect(:pool => "default", :bucket => "default")
+```ruby
+c = Couchbase.connect('http://localhost:8091/pools/default/buckets/default')
+c = Couchbase.connect('http://localhost:8091/pools/default')
+c = Couchbase.connect('http://localhost:8091')
+c = Couchbase.connect(:hostname => 'localhost')
+c = Couchbase.connect(:hostname => 'localhost', :port => 8091)
+c = Couchbase.connect(:pool => 'default', :bucket => 'default')
+```
 
 The hash parameters take precedence on string URL.
 
 If you worry about state of your nodes or not sure what node is alive,
 you can pass the list of nodes and the library will iterate over it
 until finds the working one. From that moment it won't use **your**
-list, because node list from cluster config is more actual.
+list, because node list from cluster config is more accurate.
 
-    c = Couchbase.connect(:bucket => "mybucket",
-                          :node_list => ['example.com:8091', example.net'])
+```ruby
+c = Couchbase.connect(:bucket => 'mybucket',
+                      :node_list => ['example.com:8091', example.net'])
+```
 
 There is also handy method `Couchbase.bucket` which uses thread local
 storage to keep the reference to default connection. You can set the
 connection options via `Couchbase.connection_options`:
 
-    Couchbase.connection_options = {:bucket => 'blog'}
-    Couchbase.bucket.name                   #=> "blog"
-    Couchbase.bucket.set("foo", "bar")      #=> 3289400178357895424
+```ruby
+Couchbase.connection_options = { bucket: 'blog' }
+Couchbase.bucket.name                   #=> 'blog'
+Couchbase.bucket.set('foo', 'bar')      #=> 3289400178357895424
+```
 
 ### Get
 
-    val = c.get("foo")
-    val, flags, cas = c.get("foo", :extended => true)
+```ruby
+val = c.get('foo')
+val, flags, cas = c.get('foo', extended: true)
+```
 
 Get and touch
 
-    val = c.get("foo", :ttl => 10)
+```ruby
+val = c.get('foo', :ttl => 10)
+```
 
 Get multiple values. In quiet mode will put `nil` values on missing
 positions:
 
-    vals = c.get("foo", "bar", "baz")
-    val_foo, val_bar, val_baz = c.get("foo", "bar", "baz")
-    c.run do
-      c.get("foo") do |ret|
-        ret.success?
-        ret.error
-        ret.key
-        ret.value
-        ret.flags
-        ret.cas
-      end
-    end
+```ruby
+vals = c.get('foo', 'bar', 'baz')
+val_foo, val_bar, val_baz = c.get('foo', 'bar', 'baz')
+```
 
 Get multiple values with extended information. The result will
 represented by hash with tuples `[value, flags, cas]` as a value.
 
-    vals = c.get("foo", "bar", "baz", :extended => true)
-    vals.inspect    #=> {"baz"=>["3", 0, 4784582192793125888],
-                         "foo"=>["1", 0, 8835713818674332672],
-                         "bar"=>["2", 0, 10805929834096100352]}
+```ruby
+vals = c.get('foo', 'bar', 'baz', extended: true)
+vals.inspect    #=> {'baz'=>['3', 0, 4784582192793125888],
+                     'foo'=>['1', 0, 8835713818674332672],
+                     'bar'=>['2', 0, 10805929834096100352]}
+```
 
 Hash-like syntax
 
-    c["foo"]
-    c["foo", "bar", "baz"]
-    c["foo", {:extended => true}]
-    c["foo", :extended => true]         # for ruby 1.9.x only
+```ruby
+c['foo']
+c['foo', 'bar', 'baz']
+c['foo', extended: true]
+```
 
 ### Touch
 
-    c.touch("foo")                      # use :default_ttl
-    c.touch("foo", 10)
-    c.touch("foo", :ttl => 10)
-    c.touch("foo" => 10, "bar" => 20)
-    c.touch("foo" => 10, "bar" => 20){|key, success|  }
+```ruby
+c.touch('foo')                      # use :default_ttl
+c.touch('foo', 10)
+c.touch('foo', ttl: 10)
+c.touch('foo' => 10, 'bar' => 20)
+```
 
 ### Set
 
-    c.set("foo", "bar")
-    c.set("foo", "bar", :flags => 0x1000, :ttl => 30, :format => :plain)
-    c["foo"] = "bar"
-    c["foo", {:flags => 0x1000, :format => :plain}] = "bar"
-    c["foo", :flags => 0x1000] = "bar"          # for ruby 1.9.x only
-    c.set("foo", "bar", :cas => 8835713818674332672)
-    c.set("foo", "bar"){|cas, key, operation|  }
+```ruby
+c.set('foo', 'bar')
+c.set('foo', 'bar', ttl: 30, format: :plain)
+c['foo'] = 'bar'
+c['foo', format: :plain}] = 'bar'
+c.set('foo', 'bar', cas: 8835713818674332672)
+```
 
 ### Add
 
 Add command will fail if the key already exists. It accepts the same
 options as set command above.
 
-    c.add("foo", "bar")
-    c.add("foo", "bar", :flags => 0x1000, :ttl => 30, :format => :plain)
+```ruby
+c.add('foo', 'bar')
+c.add('foo', 'bar', ttl: 30, format: :plain)
+```
 
 ### Replace
 
 The replace command will fail if the key already exists. It accepts the same
 options as set command above.
 
-    c.replace("foo", "bar")
+```ruby
+c.replace('foo', 'bar')
+```
 
 ### Prepend/Append
 
@@ -155,115 +171,110 @@ because the concatenation is performed by server which has no idea how
 to merge to JSON values or values in ruby Marshal format. You may receive
 an `Couchbase::Error::ValueFormat` error.
 
-    c.set("foo", "world")
-    c.append("foo", "!")
-    c.prepend("foo", "Hello, ")
-    c.get("foo")                    #=> "Hello, world!"
+```ruby
+c.set('foo', 'world')
+c.append('foo', '!')
+c.prepend('foo', 'Hello, ')
+c.get('foo')                    #=> 'Hello, world!'
+```
 
 ### Increment/Decrement
 
 These commands increment the value assigned to the key. It will raise
 Couchbase::Error::DeltaBadval if the delta or value is not a number.
 
-    c.set("foo", 1)
-    c.incr("foo")                   #=> 2
-    c.incr("foo", :delta => 2)      #=> 4
-    c.incr("foo", 4)                #=> 8
-    c.incr("foo", -1)               #=> 7
-    c.incr("foo", -100)             #=> 0
-    c.run do
-      c.incr("foo") do |ret|
-        ret.success?
-        ret.value
-        ret.cas
-      end
-    end
-
-    c.set("foo", 10)
-    c.decr("foo", 1)                #=> 9
-    c.decr("foo", 100)              #=> 0
-    c.run do
-      c.decr("foo") do |ret|
-        ret.success?
-        ret.value
-        ret.cas
-      end
-    end
-
-    c.incr("missing1", :initial => 10)      #=> 10
-    c.incr("missing1", :initial => 10)      #=> 11
-    c.incr("missing2", :create => true)     #=> 0
-    c.incr("missing2", :create => true)     #=> 1
+```ruby
+c.set('foo', 1)
+c.incr('foo')                   #=> 2
+c.incr('foo', delta: 2)         #=> 4
+c.incr('foo', 4)                #=> 8
+c.incr('foo', -1)               #=> 7
+c.incr('foo', -100)             #=> 0
+
+c.set('foo', 10)
+c.decr('foo', 1)                #=> 9
+c.decr('foo', 100)              #=> 0
+
+c.incr('missing1', :initial => 10)      #=> 10
+c.incr('missing1', :initial => 10)      #=> 11
+c.incr('missing2', :create => true)     #=> 0
+c.incr('missing2', :create => true)     #=> 1
+```
 
 Note that it isn't the same as increment/decrement in ruby, which is
 performed on client side with following `set` operation:
 
-    c["foo"] = 10
-    c["foo"] -= 20                  #=> -10
+```ruby
+c['foo'] = 10
+c['foo'] -= 20                  #=> -10
+```
 
 ### Delete
 
-    c.delete("foo")
-    c.delete("foo", :cas => 8835713818674332672)
-    c.delete("foo", 8835713818674332672)
-    c.run do
-      c.delete do |ret|
-        ret.success?
-        ret.key
-      end
-    end
+```ruby
+c.delete('foo')
+c.delete('foo', :cas => 8835713818674332672)
+c.delete('foo', 8835713818674332672)
+```
 
 ### Flush
 
 Flush the items in the cluster.
 
-    c.flush
-    c.run do
-      c.flush do |ret|
-        ret.success?
-        ret.node
-      end
-    end
+```ruby
+c.flush
+```
 
 ### Stats
 
 Return statistics from each node in the cluster
 
-    c.stats
-    c.stats(:memory)
-    c.run do
-      c.stats do |ret|
-        ret.success?
-        ret.node
-        ret.key
-        ret.value
-      end
-    end
+```ruby
+c.stats
+c.stats(:memory)
+```
 
 The result is represented as a hash with the server node address as
 the key and stats as key-value pairs.
 
+```ruby
+{
+  'threads'=>
+    {
+      '172.16.16.76:12008'=>'4',
+      '172.16.16.76:12000'=>'4',
+      # ...
+    },
+  'connection_structures'=>
+    {
+      '172.16.16.76:12008'=>'22',
+      '172.16.16.76:12000'=>'447',
+      # ...
+    },
+  'ep_max_txn_size'=>
     {
-      "threads"=>
-        {
-          "172.16.16.76:12008"=>"4",
-          "172.16.16.76:12000"=>"4",
-          # ...
-        },
-      "connection_structures"=>
-        {
-          "172.16.16.76:12008"=>"22",
-          "172.16.16.76:12000"=>"447",
-          # ...
-        },
-      "ep_max_txn_size"=>
-        {
-          "172.16.16.76:12008"=>"1000",
-          "172.16.16.76:12000"=>"1000",
-          # ...
-        },
+      '172.16.16.76:12008'=>'1000',
+      '172.16.16.76:12000'=>'1000',
       # ...
-    }
+    },
+  # ...
+}
+```
+
+### Async Operations
+
+Most synchronous operations detailed above have an asynchronous counterpart.  Async operations
+optionally accept a block that will be used as a callback when the operations completes.  The
+block will be run within the context of a net.spy.memcached.internal.OperationCompletionListener, ie. a
+separate thread, so make sure you adhere to all the
+[typical guidelines for threadsafety](https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#concurrency-basics).
+
+```ruby
+c.set('fu', 'bar')
+c.async_get('fu') do |result| # => yields a Result instance
+  result.value # => 'bar'
+end
+```
 
 ## Contributing
 
@@ -274,5 +285,5 @@ the key and stats as key-value pairs.
 5. Create new Pull Request
 
 
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/mje113/couchbase-jruby-client/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/mje113/couchbase-jruby-client/trend.png)](https://bitdeli.com/free 'Bitdeli Badge')
 

data/Rakefile

@@ -1,5 +1,4 @@
 require 'bundler/gem_tasks'
-require 'rake/testtask'
 
 Dir['tasks/*.rake'].sort.each { |f| load f }
 

data/couchbase-jruby-client.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest',  '>= 5.1.0'
   s.add_development_dependency 'jrjackson', '>= 0.2.3'
   s.add_development_dependency 'pry'
+  s.add_development_dependency 'mocha'
 end

data/lib/couchbase/bucket.rb

@@ -333,16 +333,12 @@ module Couchbase
     # @example Simple flush the bucket
     #   c.flush    #=> true
     #
-    # @example Asynchronous flush
-    #   c.run do
-    #     c.flush do |ret|
-    #       ret.operation   #=> :flush
-    #       ret.success?    #=> true
-    #       ret.status      #=> 200
-    #     end
-    #   end
     def flush
-      @client.flush.get
+      async_flush.get
+    end
+
+    def async_flush
+      @client.flush
     end
 
     private

data/lib/couchbase/operations/fetch.rb

@@ -20,10 +20,11 @@
 module Couchbase::Operations
   module Fetch
 
-    def fetch(key, set_options = {}, &block)
+    def fetch(key, set_options = {}, get_options = {}, &block)
       fail ArgumentError 'Must pass a block to #fetch' unless block_given?
 
-      get(key, quiet: false)
+      get_options[:quiet] = false
+      get(key, get_options)
     rescue Couchbase::Error::NotFound
       yield(block).tap {|value| set(key, value, set_options) }
     end

data/lib/couchbase/operations/store.rb

@@ -25,9 +25,9 @@ module Couchbase::Operations
   module Store
 
     STORE_OP_METHODS = {
-      set:     -> client, key, value, ttl, transcoder { client.set(key, ttl, value, transcoder) },
-      add:     -> client, key, value, ttl, transcoder { client.add(key, ttl, value, transcoder) },
-      replace: -> client, key, value, ttl, transcoder { client.replace(key, ttl, value, transcoder) },
+      set:     -> client, key, value, ttl, transcoder { client.set(key, ttl.to_i, value, transcoder) },
+      add:     -> client, key, value, ttl, transcoder { client.add(key, ttl.to_i, value, transcoder) },
+      replace: -> client, key, value, ttl, transcoder { client.replace(key, ttl.to_i, value, transcoder) },
       append:  -> client, key, value, ttl, transcoder { client.append(key, value, transcoder) },
       prepend: -> client, key, value, ttl, transcoder { client.prepend(key, value, transcoder) }
     }.freeze

data/lib/couchbase/operations/utils.rb

@@ -47,7 +47,7 @@ module Couchbase::Operations
     end
 
     def future_cas(future)
-      future.get && future.getCas
+      future.get && future.cas
     rescue Java::JavaLang::UnsupportedOperationException
       # TODO: don't return fake cas
       1

data/lib/couchbase/version.rb

@@ -16,5 +16,5 @@
 #
 
 module Couchbase
-  VERSION = '0.1.9'
+  VERSION = '0.2.0'
 end

data/lib/couchbase.rb

@@ -16,7 +16,7 @@
 #
 
 unless RUBY_PLATFORM =~ /java/
-  error "This gem is only compatible with a java-based ruby environment like JRuby."
+  fail "This gem is only compatible with a java-based ruby environment like JRuby."
   exit 255
 end
 
@@ -55,7 +55,8 @@ end
 # Couchbase jruby client
 module Couchbase
 
-  @@buckets = ThreadSafe::Cache.new
+  @@buckets     = ThreadSafe::Cache.new
+  @@connections = ThreadSafe::Array.new
 
   class << self
 
@@ -82,7 +83,9 @@ module Couchbase
     #
     # @return [Bucket] connection instance
     def connect(*options)
-      Bucket.new(*(options.flatten))
+      bucket = Bucket.new(*(options.flatten))
+      @@connections << bucket
+      bucket
     end
     alias :new :connect
 
@@ -168,11 +171,14 @@ module Couchbase
     end
 
     def disconnect
-      @@buckets.each_key do |name|
-        bucket = @@buckets.delete(name)
-        bucket.disconnect
+      @@buckets.each_pair do |bucket, connection|
+        connection.disconnect if connection.connected?
       end
-      @@buckets = ThreadSafe::Cache.new
+      @@connections.each do |connection|
+        connection.disconnect if connection.connected?
+      end
+      @@buckets     = ThreadSafe::Cache.new
+      @@connections = ThreadSafe::Array.new
     end
   end
 end

data/tasks/test.rake

@@ -15,20 +15,22 @@
 # limitations under the License.
 #
 
-require 'rake/testtask'
-require 'rake/clean'
-
 rule 'test/CouchbaseMock.jar' do |task|
   jar_path = "0.6-SNAPSHOT/CouchbaseMock-0.6-20130903.160518-3.jar"
   sh %{wget -q -O test/CouchbaseMock.jar http://files.couchbase.com/maven2/org/couchbase/mock/CouchbaseMock/#{jar_path}}
 end
 
-CLOBBER << 'test/CouchbaseMock.jar'
+task :test do
+  $LOAD_PATH.unshift('lib', 'test')
+
+  if ENV['TEST']
+    require ENV['TEST']
+  else
+    Dir.glob('./test/**/test_*.rb') { |f| require f }
+  end
 
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+  require 'test/setup.rb'
 end
 
 Rake::Task['test'].prerequisites.unshift('test/CouchbaseMock.jar')
+

data/test/setup.rb

@@ -19,6 +19,8 @@ gem 'minitest'
 require 'coveralls'
 Coveralls.wear!
 require 'minitest'
+gem 'mocha'
+require 'mocha/setup'
 require 'couchbase'
 require 'open-uri'
 require 'ostruct'
@@ -63,11 +65,10 @@ class Minitest::Test
 
 end
 
-$mock = start_mock
-
-Dir.glob('test/test_*.rb').each { |test| require test }
-exit_code = Minitest.run(ARGV)
-Couchbase.disconnect
-$mock.stop
-java.lang.System.exit(exit_code ? 0 : 1)
-
+at_exit {
+  $mock = start_mock
+  exit_code = Minitest.run(ARGV)
+  Couchbase.disconnect
+  $mock.stop
+  java.lang.System.exit(exit_code ? 0 : 1)
+}

data/test/test_delete.rb

@@ -21,7 +21,8 @@ class TestDelete < Minitest::Test
 
   def test_trivial_delete
     cb.set(uniq_id, "bar")
-    assert cas = cb.delete(uniq_id)
+    cas = cb.delete(uniq_id)
+    assert cas
 
     assert_raises(Couchbase::Error::NotFound) do
       cb.delete(uniq_id)
@@ -49,11 +50,13 @@ class TestDelete < Minitest::Test
     refute cb.quiet?
     cb.quiet = true
     refute cb.delete(uniq_id(:missing))
+  ensure
+    cb.quiet = false
   end
 
   def test_delete_with_cas
     cas = cb.set(uniq_id, "bar")
-    missing_cas = cas - 1
+    missing_cas = cas - 100
     assert_raises(Couchbase::Error::NotFound) do
       cb.delete(uniq_id, :cas => missing_cas)
     end

data/test/test_fetch.rb

@@ -37,6 +37,27 @@ class TestFetch < Minitest::Test
     assert_equal 'abc', cb.get(uniq_id)
   end
 
+  def test_can_include_get_options
+    cb.set(uniq_id, 'abc')
+
+    get_options = { extended: true }
+    value, _, cas = cb.fetch(uniq_id, {}, get_options) do
+      'unused'
+    end
+
+    assert_equal value, 'abc'
+    assert cas.is_a?(Fixnum)
+  end
+
+  def test_can_include_set_options
+    set_options = { ttl: 1 }
+
+    cb.expects(:set).with(uniq_id, 'abc', set_options)
+    cb.fetch(uniq_id, set_options) do
+      'abc'
+    end
+  end
+
   def test_fetch_works_with_quiet_mode
     cb.quiet = true
     cb.fetch(uniq_id) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: couchbase-jruby-client
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: java
 authors:
 - Mike Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-01-06 00:00:00.000000000 Z
+date: 2014-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -108,6 +108,20 @@ dependencies:
         version: '0'
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: mocha
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
 description: Couchbase JRuby driver
 email:
 - mike@urlgonomics.com
@@ -214,7 +228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key:
 specification_version: 4
 summary: The unofficial jruby client library for use with Couchbase Server.