ninjudd-memcache 0.9.0

data/lib/memcache_extended.rb

@@ -0,0 +1,120 @@
+# Need to override entire class with Justin's changes
+require File.dirname(__FILE__) + '/memcache'
+
+module MemCacheExtensions
+  LOCK_TIMEOUT    = 5     if not defined? LOCK_TIMEOUT
+  WRITE_LOCK_WAIT = 0.001 if not defined? WRITE_LOCK_WAIT
+
+  def get_some(keys, opts = {})
+    opts[:expiry] ||= default_expiry
+    keys = keys.collect {|key| key.to_s}
+
+    records = {}
+    records = self.get_multi(keys) unless opts[:disable]
+    if opts[:validation]
+      records.delete_if do |key, value|
+        not opts[:validation].call(key, value)
+      end
+    end
+    keys_to_fetch = keys - records.keys
+
+    if keys_to_fetch.any?
+      yield(keys_to_fetch).each do |key, data_item|
+        self.set(key, data_item, opts[:expiry]) unless opts[:disable] or opts[:disable_write]
+        records[key] = data_item
+      end
+    end
+    records
+  end
+
+  def in_namespace(namespace)
+    begin
+      # Temporarily change the namespace for convenience.
+      old_namespace = self.namespace
+      self.namespace = "#{old_namespace}#{namespace}"
+      yield
+    ensure
+      self.namespace = old_namespace
+    end
+  end
+
+  def get_or_set(key)
+    get(key) || begin
+      value = yield
+      set(key, value)
+      value
+    end
+  end
+
+  def get_reset_expiry(key, expiry)
+    result = get(key)
+    set(key, result, expiry) if result
+    result
+  end
+
+  def lock(key)
+    # Returns true if the lock already exists.
+    response = add(lock_key(key), true, LOCK_TIMEOUT)
+    response.index('STORED') != 0
+  end
+
+  def unlock(key)
+    response = delete(lock_key(key))
+    response.index('DELETED') == 0
+  end
+
+  def with_lock(key, flag = nil)
+    while lock(key) do
+      return if flag == :ignore
+      sleep(WRITE_LOCK_WAIT) # just wait
+    end
+    yield
+    unlock(key) unless flag == :keep
+  end
+
+  def lock_key(key)
+    "lock:#{key}"
+  end
+
+  def locked?(key)
+    not get(lock_key(key)).nil?
+  end
+
+  def set_with_lock(*args)
+    with_lock(args.first, :ignore) do
+      set(*args)
+    end
+  end
+
+  def add_with_lock(*args)
+    with_lock(args.first, :ignore) do
+      add(*args)
+    end
+  end
+
+  def delete_with_lock(*args)
+    # leave a :delete lock around to prevent someone from
+    # adding stale data for a little while
+    with_lock(args.first, :keep) do
+      delete(*args)
+    end
+  end
+
+  def clear
+    flush_all
+  end
+
+  ### To support using memcache in testing.
+  def empty?; false; end
+  ###
+end
+
+class MemCache
+  include MemCacheExtensions
+end
+
+if defined?(MemCacheMock)
+  class MemCacheMock
+    include MemCacheExtensions
+  end
+end

data/lib/memcache_mock.rb

@@ -0,0 +1,137 @@
+class MemCacheMock
+  attr_writer :namespace
+  
+  def initialize
+    @data = {}
+    @expiry = {}
+    @auto_clear = false
+  end
+  
+  def namespace
+    @namespace.to_s
+  end
+  
+  def cache_key(key)
+    "#{namespace}:#{key}"
+  end
+
+  def default_expiry
+    0
+  end
+
+  # Note:  This doesn't work exactly like memcache's incr
+  # because MemCacheMock doesn't support raw storage.
+  # This version will work on marshalled data.
+  # This is also not atomic.
+  def incr(key, amount=1)
+    oldval = get(key).to_i or return nil
+    newval = oldval + amount
+    set(key, newval) # Note: Loses the expiry.
+    return newval
+  end
+
+  def decr(key, amount=1)
+    incr(key, amount * -1)
+  end
+  
+  def set(*args)
+    do_set(*args)
+  end
+
+  # Note:  Raw not implemented.
+  def do_set(key, value, expiry = default_expiry, raw=false)
+    return '' if @auto_clear
+    key = cache_key(key)
+
+    @data[key] = Marshal.dump(value)
+    @expiry[key] = Time.now + expiry if expiry and expiry != 0
+    'STORED'
+  end
+
+  def add(key, value, expiry = 0)
+    return '' if get(key)
+    do_set(key, value, expiry)
+  end
+
+  def kind_of?(type)
+    (type == MemCache) || super
+  end
+  
+  def delete(key)
+    key = cache_key(key)
+    @data.delete(key)
+  end
+  
+  def clear
+    @data.clear
+    @expiry.clear 
+  end
+  
+  def reset
+    # do nothing
+  end
+
+  def get_multi(*keys)
+    opts = keys.last.kind_of?(Hash) ? keys.pop : {}
+    keys.flatten!
+
+    hash = {}
+    keys.each do |key|
+      val = get(key)
+      hash[key.to_s] = val if val
+    end
+    hash
+  end
+
+  # Note:  Raw not implemented.
+  def get(key, raw=false)
+    key = cache_key(key)
+    clear if @auto_clear
+    if @expiry[key] and Time.now > @expiry[key]
+      @data[key]   = nil
+      @expiry[key] = nil
+    end
+    return if not @data[key]
+    Marshal.load(@data[key])
+  end
+  
+  def [](key)
+    get(key)
+  end
+
+  def []=(key, value)
+    set(key, value)
+  end
+
+  def empty?
+    @data.empty?
+  end
+  
+  def keys
+    @data.keys
+  end
+  
+  def auto_clear_on(&block)
+    if block_given?
+      auto_clear_block(true, &block)
+    else
+      @auto_clear = true
+    end
+  end
+  
+  def auto_clear_off(&block)
+    if block_given?
+      auto_clear_block(false, &block)
+    else
+      @auto_clear = false
+    end
+  end
+
+  def auto_clear_block(value, &block)
+    old_auto_clear = @auto_clear
+    @auto_clear = value
+    block.call
+    @auto_clear = old_auto_clear
+  end
+
+end

data/lib/memcache_util.rb

@@ -0,0 +1,90 @@
+##
+# A utility wrapper around the MemCache client to simplify cache access.  All
+# methods silently ignore MemCache errors.
+
+module Cache
+
+  ##
+  # Returns the object at +key+ from the cache if successful, or nil if either
+  # the object is not in the cache or if there was an error attermpting to
+  # access the cache.
+  #
+  # If there is a cache miss and a block is given the result of the block will
+  # be stored in the cache with optional +expiry+, using the +add+ method rather
+  # than +set+.
+
+  def self.get(key, expiry = 0)
+    start_time = Time.now
+    value = CACHE.get key
+    elapsed = Time.now - start_time
+    ActiveRecord::Base.logger.debug('MemCache Get (%0.6f)  %s' % [elapsed, key])
+    if value.nil? and block_given? then
+      value = yield
+      add key, value, expiry
+    end
+    value
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    if block_given? then
+      value = yield
+      put key, value, expiry
+    end
+    value
+  end
+
+  ##
+  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
+  # seconds.
+
+  def self.put(key, value, expiry = 0)
+    start_time = Time.now
+    CACHE.set key, value, expiry
+    elapsed = Time.now - start_time
+    ActiveRecord::Base.logger.debug('MemCache Set (%0.6f)  %s' % [elapsed, key])
+    value
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
+  # seconds.  If +key+ already exists in cache, returns nil.
+
+  def self.add(key, value, expiry = 0)
+    start_time = Time.now
+    response = CACHE.add key, value, expiry
+    elapsed = Time.now - start_time
+    ActiveRecord::Base.logger.debug('MemCache Add (%0.6f)  %s' % [elapsed, key])
+    (response == "STORED\r\n") ? value : nil
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Deletes +key+ from the cache in +delay+ seconds.
+
+  def self.delete(key, delay = nil)
+    start_time = Time.now
+    CACHE.delete key, delay
+    elapsed = Time.now - start_time
+    ActiveRecord::Base.logger.debug('MemCache Delete (%0.6f)  %s' %
+                                    [elapsed, key])
+    nil
+  rescue MemCache::MemCacheError => err
+    ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
+  end
+
+  ##
+  # Resets all connections to MemCache servers.
+
+  def self.reset
+    CACHE.reset
+    ActiveRecord::Base.logger.debug 'MemCache Connections Reset'
+    nil
+  end
+
+end
+

data/test/memcache_local_server_test.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/memcache/local_server'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+
+class MemcacheLocalServerTest < Test::Unit::TestCase
+  include MemcacheServerTestHelper
+
+  def setup
+    @memcache = Memcache::LocalServer.new
+  end
+end

data/test/memcache_null_server_test.rb

@@ -0,0 +1,65 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/memcache/null_server'
+
+class MemcacheNullServerTest < Test::Unit::TestCase
+  def setup
+    @memcache = Memcache::NullServer.new
+  end
+
+  def m
+    @memcache
+  end
+
+  def test_set_and_get
+    m.set(2, 'foo', 0)
+    
+    assert_equal nil, m.get('2')
+    assert_equal nil, m.get('2')
+  end
+
+  def test_incr
+    m.incr('foo')
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', -1)
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', 52)
+    assert_equal nil, m.get('foo')
+
+    m.incr('foo', -43)
+    assert_equal nil, m.get('foo')
+  end
+
+  def test_multi_get
+    m.set(2, '1,2,3')
+    m.set(3, '4,5')
+    
+    assert_equal Hash.new, m.get([2,3])
+  end
+  
+  def test_delete
+    m.set(2, '1,2,3')
+    
+    assert_equal nil, m.get(2)
+
+    m.delete(2)
+    
+    assert_equal nil, m.get(2)
+  end
+
+  def test_flush_all
+    m.set(2, 'bar')
+    
+    assert_equal nil, m.get(2)
+
+    m.flush_all
+    
+    assert_equal nil, m.get(2)
+  end
+    
+  def test_expiry
+    m.add('test', '1', 1)
+    assert_equal nil, m.get('test')
+  end
+end

data/test/memcache_pg_server_test.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'rubygems'
+require File.dirname(__FILE__) + '/memcache_server_test_helper'
+require File.dirname(__FILE__) + '/../lib/memcache/pg_server'
+
+class MemcacheDBServerTest < Test::Unit::TestCase
+  ActiveRecord::Base.establish_connection(
+    :adapter  => "postgresql",
+    :host     => "localhost",
+    :username => "postgres",
+    :password => "",
+    :database => "memcache_test"
+  )
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Base.connection.client_min_messages = 'panic'
+
+  include MemcacheServerTestHelper
+
+  def setup
+    Memcache::Migration.table = 'memcache_test'
+    Memcache::Migration.up
+    @memcache = Memcache::PGServer.new(:table => 'memcache_test')
+  end
+
+  def teardown
+    Memcache::Migration.down
+  end
+end