ninjudd-ninjudd-memcache-client 1.5.0.3

data/lib/memcache_extended.rb

@@ -0,0 +1,112 @@
+if not defined?(MemCache)
+  require File.dirname(__FILE__) + '/memcache'
+end
+
+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, disable = false)
+    keys = keys.collect {|key| key.to_s}
+
+    records = {}
+    records = self.get_multi(keys) unless disable
+    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) unless disable
+        records[key] = data_item
+      end
+    end
+    records
+  end
+
+  def in_namespace(namespace)
+    begin
+      # Temporarily change the namespace for convenience.
+      ns = self.namespace
+      self.instance_variable_set(:@namespace, "#{ns}#{namespace}")      
+      yield
+    ensure
+      self.instance_variable_set(:@namespace, ns)
+    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
+
+  ### To support using memcache in testing.
+  def clear; end
+  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,126 @@
+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
+
+  # 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 = 0, raw=false)
+    return '' if @auto_clear
+    key = cache_key(key)
+
+    @data[key] = Marshal.dump(value)
+    @expiry[key] = Time.now + expiry if expiry != 0
+    'STORED'
+  end
+
+  def add(key, value, expiry = 0)
+    do_set(key, value, expiry) unless get(key)
+  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 get_multi(*keys)
+    hash = {}
+    keys.each do |key|
+      val = get(key)
+      key = cache_key(key).sub("#{namespace}:",'')
+      hash[key] = 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
+