abhiyerra-jruby-memcache-client 1.5.0

data/README

@@ -0,0 +1,35 @@
+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.
+
+gem sources -a http://gems.github.com
+gem install abhiyerra-jruby-memcache-client --remote
+
+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,13 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "jruby-memcache-client"
+    gemspec.summary = "A drop in replacement for Ruby's memcache-client."
+    gemspec.email = "abhi@traytwo.com"
+    gemspec.homepage = "http://github.com/abhiyerra/jruby-memcache-client"
+    gemspec.description = "A drop in replacement for Ruby's memcache-client."
+    gemspec.authors = ["Abhi Yerra", "Ikai Lan"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

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

data/lib/memcache.rb

@@ -0,0 +1,225 @@
+require File.dirname(__FILE__) + '/java/java_memcached-release_2.0.1.jar'
+
+class MemCache
+  include_class 'com.danga.MemCached.MemCachedClient'
+  include_class 'com.danga.MemCached.SockIOPool'
+    
+  VERSION = '1.5.0'
+
+  ##
+  # Default options for the cache object.
+
+  DEFAULT_OPTIONS = {
+    :namespace   => nil,
+    :readonly    => false,
+    :multithread => true,
+    :pool_initial_size => 5,
+    :pool_min_size => 5,
+    :pool_max_size => 250,
+    :pool_max_idle => (1000 * 60 * 60 * 6),
+    :pool_maintenance_thread_sleep => 30,
+    :pool_use_nagle => false,
+    :pool_socket_timeout => 3000,
+    :pool_socket_connect_timeout => 3000,
+    :pool_name => 'default'
+  }
+  
+  ## CHARSET for Marshalling
+  MARSHALLING_CHARSET = 'ISO-8859-1'
+
+  ##
+  # 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
+  
+  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
+
+    opts = DEFAULT_OPTIONS.merge opts
+        
+    @namespace = opts[:namespace] || opts["namespace"]
+    @pool_name = opts[:pool_name] || opts["pool_name"]
+
+    @client = MemCachedClient.new(@pool_name)
+    
+    @client.primitiveAsString = true 
+    @client.sanitizeKeys = false
+  	
+    weights = Array.new(@servers.size, DEFAULT_WEIGHT)
+
+    @pool = SockIOPool.getInstance(@pool_name)
+    unless @pool.initialized?
+      # // set the servers and the weights
+      @pool.servers = @servers.to_java(:string)
+      @pool.weights = weights.to_java(:Integer)
+      
+      # // set some basic pool settings
+      # // 5 initial, 5 min, and 250 max conns
+      # // and set the max idle time for a conn
+      # // to 6 hours
+      @pool.initConn = opts[:pool_initial_size]
+      @pool.minConn = opts[:pool_min_size] 
+      @pool.maxConn = opts[:pool_max_size]
+      @pool.maxIdle = opts[:pool_max_idle]
+      
+      # // set the sleep for the maint thread
+      # // it will wake up every x seconds and
+      # // maintain the pool size
+      @pool.maintSleep = opts[:pool_maintenance_thread_sleep]
+      # 
+      # // set some TCP settings
+      # // disable nagle
+      # // set the read timeout to 3 secs
+      # // and don't set a connect timeout
+      @pool.nagle = opts[:pool_use_nagle]
+      @pool.socketTO = opts[:pool_socket_timeout]
+      @pool.socketConnectTO = opts[:pool_socket_connect_timeout]
+      @pool.aliveCheck = true
+      @pool.initialize__method
+    end
+  end
+  
+  def servers
+    @pool.get_servers.to_a rescue []
+  end
+  
+  def alive?
+    @pool.servers.to_a.any?
+  end
+
+  def get(key, raw = false)
+    value = @client.get(make_cache_key(key))
+    return nil if value.nil?
+    unless raw
+      marshal_bytes = java.lang.String.new(value).getBytes(MARSHALLING_CHARSET)
+      value = Marshal.load(String.from_java_bytes(marshal_bytes))
+    end
+    value
+  end
+  
+  def set(key, value, expiry = 0, raw = false)
+    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
+  
+  def add(key, value, expiry = 0, raw = false)
+    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
+  
+  def delete(key, expiry = 0)
+    @client.delete(make_cache_key(key))
+  end
+  
+  def incr(key, amount = 1)
+    value = get(key) || 0
+    value += amount
+    set key, value
+    value
+  end
+  
+  def decr(key, amount = 1)
+    value = get(key) || 0
+    value -= amount
+    set key, value
+    value
+  end
+  
+  def []=(key, value)
+    set key, value
+  end
+
+  def [](key)
+    get key
+  end
+
+    
+  def flush_all
+    @client.flushAll
+  end
+  
+  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
+    
+  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)
+      marshal_bytes = Marshal.dump(value).to_java_bytes
+      java.lang.String.new(marshal_bytes, MARSHALLING_CHARSET)
+    end
+    
+  class MemCacheError < RuntimeError; end
+  
+end
+

data/spec/jruby_memcache_spec.rb

@@ -0,0 +1,179 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/j_mem_cache'
+
+describe JMemCache do
+  before(:all) do
+    @server = "127.0.0.1:11211"
+    @client = JMemCache.new @server
+    @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 = JMemCache.new @server
+      @client.servers.should == [@server]
+    end
+    
+    it "should work if the instance is created with an Array" do
+      @client = JMemCache.new [ @server ]
+      @client.servers.should == [ @server ]
+    end
+    
+    it "should work if the instance is created with a Hash" do
+      @client = JMemCache.new [ @server ], :namespace => 'test'
+      @client.servers.should == [ @server ]
+    end
+
+    it "should work with an explicit pool name" do
+      @client = JMemCache.new([@server], :pool_name => 'new_pool')
+      @client.pool_name.should == 'new_pool'
+    end
+  end
+  
+  describe "namespacing" do
+    before(:each) do
+      @ns = 'namespace'
+      @nsclient = JMemCache.new [ @server ] , :namespace => @ns
+      @nsclient.flush_all
+      @nsclient.set "test", 333, 0    
+    end
+    
+    it "should set and get values transparently" do
+      @nsclient.get("test").to_i.should == 333
+    end
+    
+    it "should set values to the given namespace" do
+      @client.get("#{@ns}: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 "#stats" do
+    it "should return a hash" do    
+      @client.stats.should be_instance_of(Hash)
+    end
+    
+    # it "should return 0 for curr_items" do
+    #   @client.stats[@server]['curr_items'].should == 0
+    # end
+    
+    it "should return a float for rusage_system and rusage_user" do
+      @client.stats[@server]['rusage_system'].should be_instance_of(Float)
+      @client.stats[@server]['rusage_user'].should be_instance_of(Float)
+    end
+    
+    it "should return a String for version" do
+      @client.stats[@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
+  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 be implemented"
+  end
+end
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: abhiyerra-jruby-memcache-client
+version: !ruby/object:Gem::Version 
+  version: 1.5.0
+platform: ruby
+authors: 
+- Abhi Yerra
+- Ikai Lan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A drop in replacement for Ruby's memcache-client.
+email: abhi@traytwo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- VERSION.yml
+- lib/java/java_memcached-release_2.0.1.jar
+- lib/memcache.rb
+- spec/jruby_memcache_spec.rb
+- README
+has_rdoc: true
+homepage: http://github.com/abhiyerra/jruby-memcache-client
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A drop in replacement for Ruby's memcache-client.
+test_files: 
+- spec/jruby_memcache_spec.rb