jruby-memcache-client-thoughtworks 1.8.0

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2008 Abhi Yerra <abhi@traytwo.com>
+Copyright (c) 2009 Ikai Lan <ikai.lan@gmail.com>
+Copyright (c) 2009 Tiago Bastos <comechao@gmail.com>
+Copyright (c) 2009 Frederic Jean <frederic.jean@sun.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,84 @@
+This is forked version of jruby-memcached-client gem. It was forked and published as its own gem because the original owners have not published an updated gem for 3 years. Also the published gem depends on the development version of the jar and throws ugly exceptions when connection is lost.
+- Sudhindra Rao
+_____________________________________________________________________________________________________________________
+
+This projects provides memcached based stores for JRuby. It is a gem based on Ikai Lan's jruby-memcache-client project hosted at http://github.com/ikai/jruby-memcache-client/tree
+
+This project is a JRuby wrapper of the Java MemCache library by Greg Whalin
+
+http://www.whalin.com/memcached/
+
+In production, the standard Ruby MemCache client can cause a thread to hang. In the Glassfish application server, by default there are 5 Grizzly connectors that handle incoming requests. A site that uses MemCache heavily can quickly cause all Grizzly connectors to block and take down a site. I'm hoping that this work I am doing here will help others adopt JRuby as a production platform for their Ruby on Rails applications.
+
+The Ruby MemCache library was never written with threaded applications in mind. All threads use the same socket, and multithreaded mode basically wraps the IO with a Mutex. The Java library provides several features that are not available in the Ruby MemCache library:
+
+- connection pooling
+- socket timeouts. In forks of the Ruby MemCache library this is achieved either with a Mongrel timeout or use of the Ruby Timeout class, which, at least at the writing of this README, will work unpredictably when being used as a failsafe against hanging IO.
+
+As of right now this code only provides a very minimal amount of functionality, but it is enough to use with the Rails cache and cache_fu.
+
+Installation
+------------
+This is a ruby gem that can be installed from gemcutter.org.
+
+You will first need to install the gemcutter gem and configure your system to use it:
+
+jruby -S gem install gemcutter
+jruby -S gem tumble
+
+You will then be able to install the JRuby Memcache Client gem:
+
+jruby -S gem install jruby-memcache-client
+
+Java Requirements
+-----------------
+
+The underlying library used for this project was compiled using Java 6. You will not be able to run this gem under Java 5 out of the box. You can however clone http://github.com/gwhalin/Memcached-Java-Client and attempt to build it under Java 5 if you must. (You really should consider upgrading to Java 6 since Oracle no longer supports Java 5.)
+
+Replacing Rail's MemCache Client
+--------------------------------
+
+Rails ships with a bundled copy of the MemCache client. This client will prevent you from using this gem instead. Adding the following code into your environment.rb file:
+
+if RUBY_PLATFORM =~ /java/i
+  # Based on instructions from http://www.mikeperham.com/2009/03/03/using-memcache-client-16x-in-rails-23/
+  # Brain surgery to use our own version of memcache-client without
+  # having to modify activesupport directly.
+  # Unload any previous instance of the class
+  if Object.const_defined? :MemCache
+    Object.instance_eval { remove_const :MemCache }
+  end
+  # Pull in the exact version we want
+  gem 'jruby-memcache-client', '1.6.1'
+
+  # Ensure that the memcache-client path is at the front of the loadpath
+  $LOAD_PATH.each do |path|
+    if path =~ /jruby-memcache-client/
+      $LOAD_PATH.delete(path)
+      $LOAD_PATH.unshift(path)
+    end
+  end
+  # If Ruby thinks it's already loaded memcache.rb, force
+  # a reload otherwise just require.
+  if $".find { |file| file =~ /\Amemcache.rb\Z/ }
+    load 'memcache.rb'
+  else
+    require 'memcache'
+  end
+end
+
+This will remove the original MemCache client and load our version of the MemCache class instead.
+
+Configuration
+-------------
+The JRuby MemCache client uses the same configuration options as the regular MemCache client. Here is how to build the configuration in your environment.rb file:
+
+memcache_options = {
+  :namespace => 'fortaleza:production_live:',
+}
+memcached_servers = [ ENV['MEMCACHED_LOCATION'] || '0.0.0.0:11211']
+
+# Constant used by libs
+CACHE = MemCache.new memcached_servers, memcache_options if RUBY_PLATFORM =~ /java/
+
+Note that this may vary based on your particular configuration method and environment.

data/Rakefile

@@ -0,0 +1,30 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.version = "1.8.0"
+    gemspec.name = "jruby-memcache-client-thoughtworks"
+    gemspec.summary = "A drop in replacement for Ruby's memcache-client. Now with a stable jruby-memcached-release jar."
+    gemspec.email = "sudhindra.r.rao@gmail.com"
+    gemspec.homepage = "http://github.com/ThoughtWorksStudios/jruby-memcache-client"
+    gemspec.description = "A drop in replacement for Ruby's memcache-client.Now with a stable jruby-memcached-release jar."
+    gemspec.authors = ["Abhi Yerra", "Ikai Lan", "Frederic Jean", "Lennon Day-Reynolds",
+		"slyphon", "Brayn Helmkamp", "Travis Tilley", "Sudhindra Rao(ThoughtWorksStudios)"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+if RUBY_PLATFORM =~ /java/i
+  begin
+    require 'spec/rake/spectask'
+
+    task :default => :spec
+
+    desc "Run the specs for the jruby-memcache-client gem"
+    Spec::Rake::SpecTask.new
+  rescue LoadError
+    puts "You must have rspec installed in order to run the tests."
+  end
+else
+  puts "You must run rake under JRuby."
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 7
+:patch: 0

data/jruby-memcache-client-thoughtworks.gemspec

@@ -0,0 +1,42 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "jruby-memcache-client-thoughtworks"
+  s.version = "1.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Abhi Yerra", "Ikai Lan", "Frederic Jean", "Lennon Day-Reynolds", "slyphon", "Brayn Helmkamp", "Travis Tilley", "Sudhindra Rao(ThoughtWorksStudios)"]
+  s.date = "2013-01-24"
+  s.description = "A drop in replacement for Ruby's memcache-client.Now with a stable jruby-memcached-release jar."
+  s.email = "sudhindra.r.rao@gmail.com"
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+    "README",
+    "Rakefile",
+    "VERSION.yml",
+    "jruby-memcache-client-thoughtworks.gemspec",
+    "lib/java/java_memcached-release_2.5.1.jar",
+    "lib/memcache.rb",
+    "spec/jruby_memcache_spec.rb"
+  ]
+  s.homepage = "http://github.com/ThoughtWorksStudios/jruby-memcache-client"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "A drop in replacement for Ruby's memcache-client. Now with a stable jruby-memcached-release jar."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/memcache.rb

@@ -0,0 +1,345 @@
+require 'java'
+require 'base64'
+
+require File.dirname(__FILE__) + '/java/java_memcached-release_2.5.1.jar'
+
+class MemCache
+  include_class 'com.danga.MemCached.MemCachedClient'
+  include_class 'com.danga.MemCached.SockIOPool'
+  include_class 'com.danga.MemCached.Logger'
+
+  VERSION = '1.7.0'
+
+  ##
+  # Default options for the cache object.
+
+  DEFAULT_OPTIONS = {
+    :namespace   => nil,
+    :readonly    => false,
+    :multithread => true,
+    :pool_initial_size => 10,
+    :pool_min_size => 5,
+    :pool_max_size => 100,
+    :pool_max_idle => (1000 * 60 * 5),
+    :pool_max_busy => (1000 * 30),
+    :pool_maintenance_thread_sleep => (1000 * 30),
+    :pool_socket_timeout => (1000 * 3),
+    :pool_socket_connect_timeout => (1000 * 3),
+    :pool_use_alive => false,
+    :pool_use_failover => true,
+    :pool_use_failback => true,
+    :pool_use_nagle => false,
+    :pool_name => 'default',
+    :log_level => 2
+  }
+
+  ## CHARSET for Marshalling
+  MARSHALLING_CHARSET = 'UTF-8'
+
+  ##
+  # Default memcached port.
+
+  DEFAULT_PORT = 11211
+
+  ##
+  # Default memcached server weight.
+
+  DEFAULT_WEIGHT = 1
+
+  attr_accessor :request_timeout
+
+  ##
+  # The namespace for this instance
+
+  attr_reader :namespace
+
+  ##
+  # The multithread setting for this instance
+
+  attr_reader :multithread
+
+  ##
+  # The configured socket pool name for this client.
+  attr_reader :pool_name
+
+  ##
+  # Configures the client
+  def initialize(*args)
+    @servers = []
+    opts = {}
+
+    case args.length
+    when 0 then # NOP
+    when 1 then
+      arg = args.shift
+      case arg
+      when Hash   then opts = arg
+      when Array  then @servers = arg
+      when String then @servers = [arg]
+      else raise ArgumentError, 'first argument must be Array, Hash or String'
+      end
+    when 2 then
+      @servers, opts = args
+      @servers = [@servers].flatten
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 2)"
+    end
+
+    # Normalizing the server(s) so they all have a port number.
+
+    @servers = @servers.map do |server|
+      server =~ /(.+):(\d+)/ ? server : "#{server}:#{DEFAULT_PORT}"
+    end
+
+    Logger.getLogger('com.meetup.memcached.MemcachedClient').setLevel(opts[:log_level])
+    Logger.getLogger('com.meetup.memcached.SockIOPool').setLevel(opts[:log_level])
+
+    opts = DEFAULT_OPTIONS.merge opts
+
+    @namespace = opts[:namespace] || opts["namespace"]
+    @pool_name = opts[:pool_name] || opts["pool_name"]
+    @readonly = opts[:readonly] || opts["readonly"]
+
+    @client = MemCachedClient.new(@pool_name)
+
+    @client.error_handler = opts[:error_handler] if opts[:error_handler]
+    @client.primitiveAsString = true
+    @client.sanitizeKeys = false
+
+    weights = Array.new(@servers.size, DEFAULT_WEIGHT)
+
+    @pool = SockIOPool.getInstance(@pool_name)
+    unless @pool.initialized?
+      @pool.servers = @servers.to_java(:string)
+      @pool.weights = weights.to_java(:Integer)
+
+      @pool.initConn = opts[:pool_initial_size]
+      @pool.minConn = opts[:pool_min_size]
+      @pool.maxConn = opts[:pool_max_size]
+
+      @pool.maxIdle = opts[:pool_max_idle]
+      @pool.maxBusyTime = opts[:pool_max_busy]
+      @pool.maintSleep = opts[:pool_maintenance_thread_sleep]
+      @pool.socketTO = opts[:pool_socket_timeout]
+      @pool.socketConnectTO = opts[:pool_socket_connect_timeout]
+
+      @pool.failover = opts[:pool_use_failover]
+      @pool.failback = opts[:pool_use_failback]
+      @pool.aliveCheck = opts[:pool_use_alive]
+      @pool.nagle = opts[:pool_use_nagle]
+
+      # public static final int NATIVE_HASH     = 0;        
+      #     // native String.hashCode();
+      # public static final int OLD_COMPAT_HASH = 1;        
+      #     // original compatibility hashing algorithm (works with other clients)
+      # public static final int NEW_COMPAT_HASH = 2;
+      #     // new CRC32 based compatibility hashing algorithm (works with other clients)
+      # public static final int CONSISTENT_HASH = 3;        
+      #     // MD5 Based -- Stops thrashing when a server added or removed
+      @pool.hashingAlg = opts[:pool_hashing_algorithm]
+
+      # __method methods have been removed in jruby 1.5
+      @pool.java_send :initialize rescue @pool.initialize__method
+    end
+
+  end
+
+  def reset
+    @pool.shut_down
+    @pool.java_send :initialize rescue @pool.initialize__method
+  end
+
+  ##
+  # Returns the servers that the client has been configured to
+  # use. Injects an alive? method into the string so it works with the
+  # updated Rails MemCacheStore session store class.
+  def servers
+    @pool.servers.to_a.collect do |s|
+      s.instance_eval(<<-EOIE)
+      def alive?
+        #{!!stats[s]}
+      end
+      EOIE
+      s
+    end rescue []
+  end
+
+  ##
+  # Determines whether any of the connections to the servers is
+  # alive. We are alive if it is the case.
+  def alive?
+    servers.to_a.any? { |s| s.alive? }
+  end
+
+  alias :active? :alive?
+
+  ##
+  # Retrieves a value associated with the key from the
+  # cache. Retrieves the raw value if the raw parameter is set.
+  def get(key, raw = false)
+    value = @client.get(make_cache_key(key))
+    return nil if value.nil?
+    unless raw
+      begin
+        marshal_bytes = java.lang.String.new(value).getBytes(MARSHALLING_CHARSET)
+        decoded = Base64.decode64(String.from_java_bytes(marshal_bytes))
+        value = Marshal.load(decoded)
+      rescue
+        value = case value
+          when /^\d+\.\d+$/ then value.to_f
+          when /^\d+$/ then value.to_i
+          else value
+        end
+      end
+    end
+    value
+  end
+
+  alias :[] :get
+
+  ##
+  # Retrieves the values associated with the keys parameter.
+  def get_multi(keys, raw = false)
+    keys = keys.map {|k| make_cache_key(k)}
+    keys = keys.to_java :String
+    values = {}
+    values_j = @client.getMulti(keys)
+    values_j.to_a.each {|kv|
+      k,v = kv
+      next if v.nil?
+      unless raw
+        begin
+          marshal_bytes = java.lang.String.new(v).getBytes(MARSHALLING_CHARSET)
+          decoded = Base64.decode64(String.from_java_bytes(marshal_bytes))
+          v = Marshal.load(decoded)
+        rescue
+          v = case v
+            when /^\d+\.\d+$/ then v.to_f
+            when /^\d+$/ then v.to_i
+            else v
+          end
+        end
+      end
+      values[k] = v
+    }
+    values
+  end
+
+  ##
+  # Associates a value with a key in the cache. MemCached will expire
+  # the value if an expiration is provided. The raw parameter allows
+  # us to store a value without marshalling it first.
+  def set(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    key = make_cache_key(key)
+    if expiry == 0
+      @client.set key, value
+    else
+      @client.set key, value, expiration(expiry)
+    end
+  end
+
+  alias :[]= :set
+
+  ##
+  # Add a new value to the cache following the same conventions that
+  # are used in the set method.
+  def add(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    if expiry == 0
+      @client.add make_cache_key(key), value
+    else
+      @client.add make_cache_key(key), value, expiration(expiry)
+    end
+  end
+
+  ##
+  # Removes the value associated with the key from the cache. This
+  # will ignore values that are not already present in the cache,
+  # which makes this safe to use without first checking for the
+  # existance of the key in the cache first.
+  def delete(key, expires = 0)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    @client.delete(make_cache_key(key))
+  end
+
+  ##
+  # Replaces the value associated with a key in the cache if it
+  # already is stored. It will not add the value to the cache if it
+  # isn't already present.
+  def replace(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = marshal_value(value) unless raw
+    if expiry == 0
+      @client.replace make_cache_key(key), value
+    else
+      @client.replace make_cache_key(key), value
+    end
+  end
+
+  ##
+  # Increments the value associated with the key by a certain amount.
+  def incr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = @client.incr(make_cache_key(key), amount)
+    return nil if value == "NOT_FOUND\r\n"
+    return value.to_i
+  end
+
+  ##
+  # Decrements the value associated with the key by a certain amount.
+  def decr(key, amount = 1)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    value = @client.decr(make_cache_key(key),amount)
+    return nil if value == "NOT_FOUND\r\n"
+    return value.to_i
+  end
+
+  ##
+  # Clears the cache.
+  def flush_all
+    @client.flush_all
+  end
+
+  ##
+  # Reports statistics on the cache.
+  def stats
+    stats_hash = {}
+    @client.stats.each do |server, stats|
+      stats_hash[server] = Hash.new
+      stats.each do |key, value|
+        unless key == 'version'
+          value = value.to_f
+          value = value.to_i if value == value.ceil
+        end
+        stats_hash[server][key] = value
+      end
+    end
+    stats_hash
+  end
+
+  class MemCacheError < RuntimeError; end
+
+  protected
+  def make_cache_key(key)
+    if namespace.nil? then
+      key
+    else
+      "#{@namespace}:#{key}"
+    end
+  end
+
+  def expiration(expiry)
+    java.util.Date.new((Time.now.to_i + expiry) * 1000)
+  end
+
+  def marshal_value(value)
+    return value if value.kind_of?(Numeric)
+    encoded = Base64.encode64(Marshal.dump(value))
+    marshal_bytes = encoded.to_java_bytes
+    java.lang.String.new(marshal_bytes, MARSHALLING_CHARSET)
+  end
+end
+

data/spec/jruby_memcache_spec.rb

@@ -0,0 +1,272 @@
+require 'java'
+require File.dirname(__FILE__) + '/../lib/memcache'
+
+describe MemCache do
+
+  hostname = `hostname`.strip
+
+  ["127.0.0.1:11211", "127.0.0.1", hostname, "#{hostname}:11211"].each do |server|
+    before :all do
+      @server = server
+      @normalized_server = @server =~ /(.+):(\d+)/ ? @server : "#{@server}:11211" 
+    end
+
+    before :each do
+      @client = MemCache.new @server
+      @client.should_not be_nil
+      @client.flush_all
+    end
+
+    after :each do
+      @client.flush_all
+    end
+
+    it "should return nil for a non-existent key" do
+      @client.get('non-existent-key').should be_nil
+    end
+
+    describe "setting servers" do
+      it "should work if the instance is created with a single String argument" do
+        @client = MemCache.new @server
+        @client.servers.should == [@normalized_server]
+      end
+
+      it "should work if the instance is created with an Array" do
+        @client = MemCache.new [ @server ]
+        @client.servers.should == [@normalized_server]
+      end
+
+      it "should work if the instance is created with a Hash" do
+        @client = MemCache.new [ @server ], :namespace => 'test'
+        @client.servers.should == [@normalized_server]
+      end
+
+      it "should work with an explicit pool name" do
+        @client = MemCache.new([@server], :pool_name => 'new_pool')
+        @client.pool_name.should == 'new_pool'
+      end
+
+      it "should work with an error handler" do
+        include_class 'com.danga.MemCached.MemCachedClient'
+        java_memcache_client = mock.as_null_object
+        MemCachedClient.stub!(:new => java_memcache_client)
+        error_handler = Object.new
+        java_memcache_client.should_receive(:error_handler=).with(error_handler)
+        @client = MemCache.new([@server], :error_handler => error_handler)
+      end
+    end
+
+    describe "namespacing" do
+      before(:each) do
+        @ns = 'namespace'
+        @nsclient = MemCache.new [ @server ] , :namespace => @ns
+        @nsclient.flush_all
+        @nsclient.set "test", 333, 0
+      end
+
+      it "should set and get values transparently" do
+        @nsclient.get("test").should == 333
+      end
+
+      it "should set values to the given namespace" do
+        @nsclient.get("test").to_i.should == 333
+      end
+
+      it "should not set a value without the given namespace" do
+        @client.get("test").to_i.should_not == 333
+      end
+
+      it "should delete values in the given namespace" do
+        @nsclient.delete "test"
+        @nsclient.get("test").should be_nil
+      end
+
+      it "should increment in the given namespace" do
+        @nsclient.incr("test").to_i.should == 334
+      end
+
+      it "should decrement values in the given namespace" do
+        @nsclient.decr("test").should == 332
+      end
+    end
+
+    describe "after setting a value to MemCache" do
+      before(:each) do
+        @client.set 'key', 'value'
+      end
+
+      it "should be able to retrieve the value" do
+        @client.get('key').should == 'value'
+      end
+
+      it "should not be able to retrieve the value after deleting" do
+        @client.delete('key')
+        @client.get('key').should be_nil
+      end
+
+      it "should not be able to retrieve the value after flushing everything" do
+        @client.flush_all
+        @client.get("key").should be_nil
+      end
+
+      it "should work exactly the same if the []= operator were used" do
+        @client['key'] = 'val'
+        @client.get('key').should == 'val'
+      end
+    end
+
+    describe "replacing values from the cache." do
+      before :each do
+        @client['key'] = 'value'
+      end
+
+      it "should be able to replace the stored value." do
+        @client.replace('key', 'new value').should be_true
+        @client['key'].should == 'new value'
+      end
+
+      it "should not replace values that are not in the cache." do
+        @client.replace('notthere', 'value').should be_false
+      end
+    end
+
+    describe "using the Hash notation" do
+      before :each do
+        @client['key'] = 'value'
+      end
+
+      it "should be able to retrieve the value using []" do
+        @client['key'].should == 'value'
+      end
+
+      it "should be able to retrieve the value using get" do
+        @client.get('key').should == 'value'
+      end
+    end
+
+    describe "#stats" do
+      it "should return a hash" do
+        @client.stats.should be_instance_of(Hash)
+      end
+
+      it "should return a float for rusage_system and rusage_user" do
+        @client.stats[@normalized_server]['rusage_system'].should be_instance_of(Float)
+        @client.stats[@normalized_server]['rusage_user'].should be_instance_of(Float)
+      end
+
+      it "should return a String for version" do
+        @client.stats[@normalized_server]['version'].should be_instance_of(String)
+      end
+
+    end
+
+    describe "#incr" do
+
+      it "should increment a value by 1 without a second parameter" do
+        @client.set 'incr', 100, 0
+        @client.incr 'incr'
+        @client.get('incr').to_i.should == 101
+      end
+
+      it "should increment a value by a given second parameter" do
+        @client.set 'incr', 100, 0
+        @client.incr 'incr', 20
+        @client.get('incr').to_i.should == 120
+      end
+    end
+
+    describe "#decr" do
+
+      it "should decrement a value by 1 without a second parameter" do
+        @client.set 'decr', 100, 0
+        @client.decr 'decr'
+        @client.get('decr').to_i.should == 99
+      end
+
+      it "should decrement a value by a given second parameter" do
+        @client.set 'decr', 100, 0
+        @client.decr 'decr', 20
+        @client.get('decr').to_i.should == 80
+      end
+    end
+
+    describe "with Ruby Objects" do
+      it "should be able to transparently set and get equivalent Ruby objects" do
+        obj = { :test => :hi }
+        @client.set('obj', obj)
+        @client.get('obj').should == obj
+      end
+
+      it %[should work with those whose marshalled stream contains invalid UTF8 byte sequences] do
+        # this test fails w/o the Base64 encoding step
+        obj = { :foo => 900 }
+        @client.set('obj', obj)
+        @client.get('obj').should == obj
+      end
+
+      it %[should work with binary blobs] do
+        # this test fails w/o the Base64 encoding step
+        blob = "\377\330\377\340\000\020JFIF\000\001\001\000\000\001\000\001\000\000\377"
+        @client.set('blob', blob)
+        @client.get('blob').should == blob
+      end
+    end
+
+    describe "using set with an expiration" do
+      it "should make a value unretrievable if the expiry is set to a negative value" do
+        @client.set('key', 'val', -1)
+        @client.get('key').should be_nil
+      end
+
+      it "should make a value retrievable for only the amount of time if a value is given" do
+        @client.set('key', 'val', 2)
+        @client.get('key').should == 'val'
+        sleep(3)
+        @client.get('key').should be_nil
+      end
+    end
+
+    describe "#get_multi" do
+      it "should get 2 keys" do
+        @client.set('key', 'val')
+        @client.set('key2', 'val2')
+        @client.get_multi(%w/key key2/).should == {'key' => 'val', 'key2' => 'val2'}
+      end
+
+      it "should ignore nil values" do
+        @client.set('key', 'val')
+        @client.set('key2', 'val2')
+        @client.get_multi(%w/key key2 key3/).should == {'key' => 'val', 'key2' => 'val2'}
+      end
+
+      it "should not marshall if requested" do
+        @client.set('key', 'val', 0, true)
+        @client.set('key2', 'val2', 0, true)
+        @client.get_multi(%w/key key2/, true).should == {'key' => 'val', 'key2' => 'val2'}
+      end
+    end
+
+    describe "aliveness of the MemCache server." do
+      before :each do
+        @servers = ["localhost:11211", "localhost:11212", {:pool_name => "test"}]
+        @client = MemCache.new @servers
+        @client.flush_all
+      end
+
+      it "should report the client as being alive." do
+        @client.should be_alive
+      end
+
+      it "should report localhost:11211 as being alive." do
+        servers = @client.servers
+        servers.first.should be_alive
+      end
+
+      it "should report localhost:11212 as not being alive." do
+        servers = @client.servers
+        servers.find {|s| s.to_s == "localhost:11212"}.should be_nil
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: jruby-memcache-client-thoughtworks
+version: !ruby/object:Gem::Version
+  version: 1.8.0
+  prerelease: 
+platform: ruby
+authors:
+- Abhi Yerra
+- Ikai Lan
+- Frederic Jean
+- Lennon Day-Reynolds
+- slyphon
+- Brayn Helmkamp
+- Travis Tilley
+- Sudhindra Rao(ThoughtWorksStudios)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-24 00:00:00.000000000 Z
+dependencies: []
+description: A drop in replacement for Ruby's memcache-client.Now with a stable jruby-memcached-release
+  jar.
+email: sudhindra.r.rao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION.yml
+- jruby-memcache-client-thoughtworks.gemspec
+- lib/java/java_memcached-release_2.5.1.jar
+- lib/memcache.rb
+- spec/jruby_memcache_spec.rb
+homepage: http://github.com/ThoughtWorksStudios/jruby-memcache-client
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A drop in replacement for Ruby's memcache-client. Now with a stable jruby-memcached-release
+  jar.
+test_files: []