spymemcached.jruby 1.0.0-universal-java-1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2041c63625bc2d15329384c3fcfc124d2c4f3e3
+  data.tar.gz: dd2a6e89826d7fea2d48c802cc60eda42b72463f
+SHA512:
+  metadata.gz: 7725d53c5682dcc8b321f7799a33738310425132f60e68e5d9b00af42dacd8d382a5730bd83a5bc921a5b7529733585b4b59471722ccba8c3bec266878cf6898
+  data.tar.gz: fd482a06a00659cfe2f59965695d542c5ee00cb74bb5494dc1027190e00a397ffbf221df3c5f9286d0e64b3eccbdd9e98f7e03c615553cd158e6fe95825aedcd

data/lib/spymemcached/rails23.rb

@@ -0,0 +1,60 @@
+require 'memcache'
+
+class Spymemcached
+  class Rails23
+    module Response # :nodoc:
+      STORED      = "STORED\r\n"
+      NOT_STORED  = "NOT_STORED\r\n"
+      EXISTS      = "EXISTS\r\n"
+      NOT_FOUND   = "NOT_FOUND\r\n"
+      DELETED     = "DELETED\r\n"
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def get_multi(*args)
+      op(:get_multi, *args)
+    end
+
+    def get(key, *args)
+      op(:get, key)
+    end
+
+    def add(key, value, ttl=0, *args)
+      op(:add, key, value, ttl) ? Response::STORED : Response::NOT_STORED
+    end
+
+    def set(key, value, ttl=0, *args)
+      op(:set, key, value, ttl) ? Response::STORED : Response::NOT_STORED
+    end
+
+    def delete(key, *args)
+      op(:delete, key) ? Response::DELETED : Response::NOT_FOUND
+    end
+
+    def incr(key, by=1)
+      op(:incr, key, by)
+    end
+
+    def decr(key, by=1)
+      op(:decr, key, by)
+    end
+
+    def flush_all
+      op(:flush_all)
+    end
+
+    def stats
+      op(:stats)
+    end
+
+    private
+    def op(name, *args, &block)
+      @client.send(name, *args, &block)
+    rescue TimeoutError => e
+      raise MemCache::MemCacheError, e.message
+    end
+  end
+end

data/lib/spymemcached.rb

@@ -0,0 +1,135 @@
+require 'spymemcached-2.11.4.jar'
+require 'spymemcached_adapter.jar'
+require 'spymemcached_adapter'
+
+#
+# Memcached client Spymemcached JRuby extension
+#
+class Spymemcached
+  class TimeoutError < StandardError; end
+
+  # default options for client
+  DEFAULT_OPTIONS = {
+    :timeout => 0.5, # second
+    :binary => true
+  }
+
+  # Accepts a list of +servers+ and a list of +options+.
+  # The +servers+ can be either strings of the form "hostname:port" or
+  # one string format as "<hostname>:<port>,<hostname>:<port>".
+  # Use KetamaConnectionFactory as Spymemcached MemcachedClient connection factory.
+  # See Spymemcached document for details.
+  # Different with Ruby memcache clients (e.g. Dalli), there is no raw option for operations.
+  #
+  # Valid +options+ are:
+  #
+  #   [:namespace]   Prepends this value to all keys added or retrieved.
+  #   [:timeout]     Time to use as the socket read timeout, seconds.  Defaults to 0.5 sec.
+  #   [:binary]      Talks binary protocol with Memcached server. Default to true.
+  #
+  # Logger: see Spymemcached for how to turn on detail log
+  #
+  def initialize(servers=['localhost:11211'], options={})
+    @servers, @options = Array(servers).join(','), DEFAULT_OPTIONS.merge(options)
+    @client = SpymemcachedAdapter.new(@servers, @options)
+    at_exit { shutdown }
+  end
+
+  def fetch(key, ttl=0, &block)
+    val = get(key)
+    if val.nil? && block_given?
+      val = yield
+      add(key, val, ttl)
+    end
+    val
+  end
+
+  def get(key)
+    @client.get(ns(key))
+  end
+  alias :[] :get
+
+  def get_multi(*keys)
+    Hash[@client.get_multi(keys.map(&method(:ns))).map {|k, v| [unns(k), v]}]
+  end
+
+  def add(key, value, ttl=0, opts={})
+    @client.add(ns(key), value, ttl)
+  end
+
+  def set(key, value, ttl=0, opts={})
+    @client.set(ns(key), value, ttl)
+  end
+  alias :[]= :set
+
+  def cas(key, ttl=0, &block)
+    @client.cas(ns(key), ttl, &block)
+  end
+
+  def replace(key, value, ttl=0)
+    @client.replace(ns(key), value, ttl)
+  end
+
+  def delete(key)
+    @client.delete(ns(key))
+  end
+
+  def incr(key, by=1)
+    @client.incr(ns(key), by)
+  end
+
+  def decr(key, by=1)
+    @client.decr(ns(key), by)
+  end
+
+  def append(key, value)
+    @client.append(ns(key), value)
+  end
+
+  def prepend(key, value)
+    @client.prepend(ns(key), value)
+  end
+
+  def touch(key, ttl=0)
+    @client.touch(ns(key), ttl)
+  end
+
+  def stats
+    @client.stats
+  end
+
+  def version
+    @client.version
+  end
+
+  def flush_all
+    @client.flush_all
+  end
+  alias :flush :flush_all
+  alias :clear :flush_all
+
+  def shutdown
+    @client.shutdown
+  end
+
+  # compatible api
+  def rails23
+    require 'spymemcached/rails23'
+    Rails23.new(self)
+  end
+
+  private
+  def raw?(opts)
+    opts.is_a?(Hash) ? opts[:raw] : opts
+  end
+
+  def ns(key)
+    @options[:namespace] ? "#{@options[:namespace]}:#{key}" : key
+  end
+
+  def unns(k)
+    return k unless @options[:namespace]
+    @ns_size ||= @options[:namespace].size + 1
+    k[@ns_size..-1]
+  end
+end

data/test/memcache.rb

@@ -0,0 +1,4 @@
+class MemCache
+  class MemCacheError
+  end
+end

data/test/spymemcached_binary_protocol_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class SpymemcachedBinaryProtocolTest < Test::Unit::TestCase
+  def setup
+    @client = binary_client
+    @client.flush_all
+  end
+
+  def test_get_set
+    assert_equal nil, @client.get('key')
+    @client.set('key', 'value')
+    assert_equal 'value', @client.get('key')
+    assert_equal 'value', @client['key']
+
+    @client.set('key', nil)
+    assert_equal nil, @client.get('key')
+    @client['key'] = 'hello'
+    assert_equal 'hello', @client.get('key')
+
+    @client.set('key2', ['hello', 'world'])
+    assert_equal ['hello', 'world'], @client.get('key2')
+
+    @client.set('key2', Msg.new('hi'))
+    assert_equal Msg.new('hi'), @client.get('key2')
+  end
+
+  def test_get_set_large_string
+    str = 'value' * 10_000_000
+    @client.set(name, str)
+    assert_equal str, @client.get(name)
+  end
+
+  def test_add
+    assert @client.add('key', 'value')
+    assert_equal "value", @client.get('key')
+
+    assert !@client.add('key', 'another')
+    assert_equal "value", @client.get('key')
+  end
+
+  def test_incr_and_decr
+    @client.add('key', '0')
+    assert_equal 0, @client.incr('key', 0)
+    @client.incr('key')
+    assert_equal 1, @client.incr('key', 0)
+    @client.incr('key', 5)
+    assert_equal 6, @client.incr('key', 0)
+    assert_equal '6', @client.get('key')
+
+    @client.set('key', '6')
+    @client.decr('key')
+    assert_equal 5, @client.decr('key', 0)
+    @client.decr('key', 3)
+    assert_equal 2, @client.decr('key', 0)
+
+    @client.replace('key', '10')
+    assert_equal 11, @client.incr('key')
+
+    @client.cas('key') { '7' }
+    assert_equal 8, @client.incr('key')
+  end
+
+  def test_fetch
+    ret = @client.fetch('key') { 'value' }
+    assert_equal 'value', ret
+    ret = @client.fetch('key') { 'hello' }
+    assert_equal 'value', ret
+  end
+
+  def test_get_multi
+    @client.add('k1', 'v1')
+    @client.add('k2', Msg.new('v2'))
+    ret = @client.get_multi('k1', 'k2', 'k3')
+    assert_equal(2, ret.size)
+    assert_equal('v1', ret['k1'])
+    assert_equal(Msg.new('v2'), ret['k2'])
+  end
+
+  def test_cas
+    assert_nil(@client.cas('k1') { 'v0' })
+
+    assert @client.add('k1', 'v1')
+    assert(@client.cas('k1') { 'v2' })
+    assert_equal 'v2', @client.get('k1')
+
+    ret = @client.cas('k1') do
+      @client.set('k1', 'v4')
+      'v3'
+    end
+    assert_equal(false, ret)
+    assert_equal('v4', @client.get('k1'))
+  end
+
+  def test_replace
+    assert_equal false, @client.replace('k1', 'v1')
+    assert_nil @client['k1']
+
+    @client['k1'] = 'v0'
+    assert @client.replace('k1', 'v1')
+    assert_equal 'v1', @client['k1']
+  end
+
+  def test_delete
+    @client['k1'] = 'v0'
+    assert @client.delete('k1')
+    assert_nil @client['k1']
+    assert_equal false, @client.delete('k1')
+  end
+
+  def test_append_string
+    @client['k1'] = 'v'
+    assert @client.append('k1', '1')
+    assert_equal 'v1', @client['k1']
+  end
+
+  def test_prepend_string
+    @client['k1'] = 'v'
+    assert @client.prepend('k1', '1')
+    assert_equal '1v', @client['k1']
+  end
+end

data/test/spymemcached_plain_protocol_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class SpymemcachedPlainProtocolTest < Test::Unit::TestCase
+  def setup
+    @client = plain_client
+    @client.flush_all
+  end
+
+  def test_get_set
+    assert_equal nil, @client.get('key')
+    @client.set('key', 'value')
+    assert_equal 'value', @client.get('key')
+    assert_equal 'value', @client['key']
+
+    @client.set('key', nil)
+    assert_equal nil, @client.get('key')
+    @client['key'] = 'hello'
+    assert_equal 'hello', @client.get('key')
+
+    @client.set('key2', ['hello', 'world'])
+    assert_equal ['hello', 'world'], @client.get('key2')
+
+    @client.set('key2', Msg.new('hi'))
+    assert_equal Msg.new('hi'), @client.get('key2')
+  end
+
+  def test_get_set_large_string
+    str = 'value' * 10_000_000
+    @client.set(name, str)
+    assert_equal str, @client.get(name)
+  end
+
+  def test_add
+    assert @client.add('key', 'value')
+    assert_equal "value", @client.get('key')
+
+    assert !@client.add('key', 'another')
+    assert_equal "value", @client.get('key')
+  end
+
+  def test_incr_and_decr
+    @client.add('key', '0')
+    assert_equal 0, @client.incr('key', 0)
+    @client.incr('key')
+    assert_equal 1, @client.incr('key', 0)
+    @client.incr('key', 5)
+    assert_equal 6, @client.incr('key', 0)
+    assert_equal '6', @client.get('key')
+
+    @client.set('key', '6')
+    @client.decr('key')
+    assert_equal 5, @client.decr('key', 0)
+    @client.decr('key', 3)
+    assert_equal 2, @client.decr('key', 0)
+
+    @client.replace('key', '10')
+    assert_equal 11, @client.incr('key')
+
+    @client.cas('key') { '7' }
+    assert_equal 8, @client.incr('key')
+  end
+
+  def test_fetch
+    ret = @client.fetch('key') { 'value' }
+    assert_equal 'value', ret
+    ret = @client.fetch('key') { 'hello' }
+    assert_equal 'value', ret
+  end
+
+  def test_get_multi
+    @client.add('k1', 'v1')
+    @client.add('k2', Msg.new('v2'))
+    ret = @client.get_multi('k1', 'k2', 'k3')
+    assert_equal(2, ret.size)
+    assert_equal('v1', ret['k1'])
+    assert_equal(Msg.new('v2'), ret['k2'])
+  end
+
+  def test_cas
+    assert_nil(@client.cas('k1') { 'v0' })
+
+    assert @client.add('k1', 'v1')
+    assert(@client.cas('k1') { 'v2' })
+    assert_equal 'v2', @client.get('k1')
+
+    ret = @client.cas('k1') do
+      @client.set('k1', 'v4')
+      'v3'
+    end
+    assert_equal(false, ret)
+    assert_equal('v4', @client.get('k1'))
+  end
+
+  def test_replace
+    assert_equal false, @client.replace('k1', 'v1')
+    assert_nil @client['k1']
+
+    @client['k1'] = 'v0'
+    assert @client.replace('k1', 'v1')
+    assert_equal 'v1', @client['k1']
+  end
+
+  def test_delete
+    @client['k1'] = 'v0'
+    assert @client.delete('k1')
+    assert_nil @client['k1']
+    assert_equal false, @client.delete('k1')
+  end
+
+  def test_append_string
+    @client['k1'] = 'v'
+    assert @client.append('k1', '1')
+    assert_equal 'v1', @client['k1']
+  end
+
+  def test_prepend_string
+    @client['k1'] = 'v'
+    assert @client.prepend('k1', '1')
+    assert_equal '1v', @client['k1']
+  end
+end

data/test/spymemcached_rails23_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class SpymemcachedRails23Test < Test::Unit::TestCase
+  def setup
+    @client = binary_client.rails23
+    @client.flush_all
+  end
+
+  def test_api_compatible
+    assert_equal response::STORED, @client.add("key", 'value')
+    assert_equal 'value', @client.get('key')
+    assert_equal response::STORED, @client.set('key', 'value2')
+
+    assert_equal response::DELETED, @client.delete('key')
+    assert_equal response::NOT_FOUND, @client.delete('key2')
+
+    @client.set("key1", '0')
+    @client.set("key2", '1')
+    assert_equal({"key1" => '0', 'key2' => '1'}, @client.get_multi('key1', 'key2'))
+
+    assert_equal 1, @client.incr('key1')
+    assert_equal 0, @client.decr('key2')
+
+    assert @client.stats.values.first
+  end
+
+  def response
+    Spymemcached::Rails23::Response
+  end
+end

data/test/spymemcached_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+
+class SpymemcachedTest < Test::Unit::TestCase
+  def setup
+    @client = binary_client
+    @client.flush_all
+  end
+
+  def test_expiry
+    @client.add('add_key1', 'v1', 0)
+    @client.add('add_key2', 'v2', 1)
+
+    @client.set('set_key1', 'v1', 0)
+    @client.set('set_key2', 'v2', 1)
+
+    @client.fetch('fetch_key1', 0) { 'v1' }
+    @client.fetch('fetch_key2', 1) { 'v2' }
+
+    @client.add('cas_key1', 'v0')
+    @client.add('cas_key2', 'v0')
+    @client.cas('cas_key1', 0) { 'v1' }
+    @client.cas('cas_key2', 1) { 'v2' }
+
+    @client.add('replace_key1', 'v0')
+    @client.add('replace_key2', 'v0')
+    @client.replace('replace_key1', 'v1', 0)
+    @client.replace('replace_key2', 'v2', 1)
+
+    @client.add('touch_key1', 'v1', 1)
+
+    sleep 0.5
+    @client.touch('touch_key1')
+
+    sleep 0.7
+    assert_equal 'v1', @client['touch_key1']
+
+    assert_equal 'v1', @client.get('add_key1')
+    assert_nil @client.get('add_key2')
+
+    assert_equal 'v1', @client.get('set_key1')
+    assert_nil @client.get('set_key2')
+
+    assert_equal 'v1', @client.get('fetch_key1')
+    assert_nil @client.get('fetch_key2')
+
+    assert_equal 'v1', @client.get('cas_key1')
+    assert_nil @client.get('cas_key2')
+
+    assert_equal 'v1', @client.get('replace_key1')
+    assert_nil @client.get('replace_key2')
+  end
+
+  def test_timeout
+    @client = Spymemcached.new('localhost:11111', :timeout => 0.01)
+    assert_timeout = lambda do |action, *args|
+      start_at = Time.now
+      assert_raise Spymemcached::TimeoutError do
+        @client.send(action, *args) { 'v1' }
+      end
+      time = Time.now - start_at
+      assert time < 0.025, "Timeout is 0.01, actual time of action #{action} when timeout: #{time}"
+    end
+
+    assert_timeout[:flush_all]
+
+    assert_timeout[:get, 'key']
+    assert_timeout[:get_multi, 'key']
+    assert_timeout[:incr, 'key']
+    assert_timeout[:decr, 'key']
+    assert_timeout[:fetch, 'key']
+    assert_timeout[:delete, 'key']
+    assert_timeout[:touch, 'key']
+
+    assert_timeout[:add, 'key', 'value']
+    assert_timeout[:set, 'key', 'value']
+    assert_timeout[:replace, 'key', 'value']
+    assert_timeout[:append, 'key', 'value']
+    assert_timeout[:prepend, 'key', 'value']
+
+    assert_equal({}, @client.version)
+
+    stats = @client.stats
+    assert_equal(1, stats.size)
+    assert_equal([{}], stats.values)
+  end
+
+  def test_namespace
+    @ns_client = Spymemcached.new('localhost:11211', :namespace => 'ns')
+    assert_ns = lambda do |k, v|
+      assert_equal 'v1', @ns_client.get('key1')
+      assert_nil @client.get('key1')
+      assert_equal 'v1', @client.get('ns:key1')
+    end
+
+    @ns_client.set('key1', 'v1')
+    assert_ns.call('key1', 'v1')
+
+    @ns_client.add('key2', 'v2')
+    assert_ns.call('key2', 'v2')
+
+    assert_equal({'key1' => 'v1', 'key2' => 'v2'}, @ns_client.get_multi('key1', 'key2'))
+    assert_equal({}, @client.get_multi('key1', 'key2'))
+
+    @ns_client.add('key3', 'v0')
+    @ns_client.cas('key3') { 'v3' }
+    assert_equal 'v3', @ns_client['key3']
+    assert_nil @client['key3']
+    assert_equal 'v3', @client['ns:key3']
+
+    assert @ns_client.replace('key3', 'v4')
+    assert_equal 'v4', @ns_client['key3']
+    assert_nil @client['key3']
+    assert_equal 'v4', @client['ns:key3']
+
+    @client['key3'] = 'v3'
+    assert @ns_client.delete('key3')
+    assert_equal 'v3', @client['key3']
+    assert_nil @ns_client['key3']
+
+    @ns_client.append('key2', '4')
+    assert_equal 'v24', @ns_client.get('key2')
+
+    @ns_client.prepend('key2', '4')
+    assert_equal '4v24', @ns_client.get('key2')
+
+    @ns_client['key2'] = '1'
+    assert_equal 2, @ns_client.incr('key2')
+    assert_equal 1, @ns_client.decr('key2')
+
+    @ns_client.touch('key2', 1)
+    sleep 1.1
+    assert_nil @ns_client['key2']
+  end
+
+  def test_stats
+    stats = @client.stats
+    assert_equal(Hash, stats.class)
+    assert_equal(1, stats.size)
+    assert_match /localhost/, stats.keys.first
+    assert_match /\:11211/, stats.keys.first
+    assert_equal Hash, stats.values.first.class
+    assert stats.values.first.size > 5
+    assert_match @client.version.values.first, stats.values.first['version']
+  end
+
+  def test_version
+    v = @client.version
+    assert_equal(Hash, v.class)
+    assert_equal(1, v.size)
+    assert_match /localhost/, v.keys.first
+    assert_match /\:11211/, v.keys.first
+    assert_match /\d\.\d+\.\d+/, v.values.first
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require "spymemcached"
+
+class Msg < Struct.new(:name)
+end
+
+class Test::Unit::TestCase
+  def plain_client
+    @@plain_client ||= spymemcached(:binary => false)
+  end
+
+  def binary_client
+    @@binary_client ||= spymemcached
+  end
+
+  def spymemcached(opts={})
+    Spymemcached.new('localhost:11211', opts)
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: spymemcached.jruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: universal-java-1.7
+authors:
+- Xiao Li
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  prerelease: false
+  type: :development
+description: |
+  A JRuby extension wrapping the latest spymemcached client (v2.11.4).
+email:
+- swing1979@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/spymemcached-2.11.4.jar
+- lib/spymemcached.rb
+- lib/spymemcached_adapter.jar
+- lib/spymemcached/rails23.rb
+- test/memcache.rb
+- test/spymemcached_binary_protocol_test.rb
+- test/spymemcached_plain_protocol_test.rb
+- test/spymemcached_rails23_test.rb
+- test/spymemcached_test.rb
+- test/test_helper.rb
+homepage: https://github.com/xli/spymemcached.jruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: A JRuby extension wrapping the latest spymemcached client (v2.11.4).
+test_files: []