ngmoco-cache-money 0.2.23 → 0.2.24.2

data/lib/memcached_wrapper.rb

@@ -1,263 +0,0 @@
-# require 'memcache'
-# require 'memcached'
-
-#typically MemCache/Memcached can be used via the following in rails/init.rb:
-#$memcache = MemCache.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
-#$memcache = Memcached::Rails.new(memcache_config[:servers].gsub(' ', '').split(','), memcache_config)
-
-#this wrapper lets both work.
-
-########## they have Memcached installed (do need the wrapper)
-if defined? Memcached
-Rails.logger.info("cache-money: Memcached installed") if defined? Rails
-
-class Memcached
-  alias :get_multi :get #:nodoc:
-end
-
-class MemcachedWrapper < ::Memcached
-  DEFAULTS = { :servers => '127.0.0.1:11211' }
-
-  attr_reader :logger, :default_ttl
-
-  # See Memcached#new for details.
-  def initialize(*args)
-      opts = DEFAULTS.merge(args.last.is_a?(Hash) ? args.pop : {})
-
-      if opts.respond_to?(:symbolize_keys!)
-        opts.symbolize_keys!
-      else
-        opts = symbolize_keys(opts)
-      end
-      
-      servers = Array(
-        args.any? ? args.unshift : opts.delete(:servers)
-      ).flatten.compact
-
-      opts[:prefix_key] ||= "#{opts[:namespace]}:"
-
-      @logger = opts[:logger]
-      @debug  = opts[:debug]
-
-      super(servers, opts)      
-  end
-
-  def symbolize_keys(opts)
-    # Destructively convert all keys to symbols.
-    if opts.kind_of?(Hash) && !opts.kind_of?(HashWithIndifferentAccess)
-      opts.keys.each do |key|
-        unless key.is_a?(Symbol)
-          opts[key.to_sym] = opts[key]
-          opts.delete(key)
-        end
-      end
-    end
-    opts
-  end
-  
-  def namespace
-    options[:prefix_key]
-  end
-
-  # Wraps Memcached::Rails#add to return a text string - for cache money
-  def add(key, value, ttl=@default_ttl, raw=false)
-    logger.debug("Memcached add: #{key.inspect}") if logger && @debug
-    super(key, value, ttl, !raw)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::NotStored
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    not_stored
-  rescue Memcached::Error
-    log_error($!) if logger
-    not_stored
-  end
-
-  def replace(key, value, ttl = @default_ttl, raw = false)
-    logger.debug("Memcached replace: #{key.inspect}") if logger && @debug
-    super(key, value, ttl, !raw)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::NotStored
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    not_stored
-  rescue Memcached::Error
-    log_error($!) if logger
-    not_stored
-  end
-  
-  # Wraps Memcached#get so that it doesn't raise. This has the side-effect of preventing you from 
-  # storing <tt>nil</tt> values.
-  def get(key, raw=false)
-    logger.debug("Memcached get: #{key.inspect}") if logger && @debug
-    value = super(key, !raw)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    value
-  rescue Memcached::NotFound
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    nil
-  rescue TypeError
-    log_error($!) if logger
-    delete(key)
-    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
-    nil
-  rescue Memcached::Error
-    log_error($!) if logger
-    nil
-  end
-
-  def fetch(key, expiry = 0, raw = false)
-    value = get(key, !raw)
-
-    if value.nil? && block_given?
-      value = yield
-      add(key, value, expiry, !raw)
-    end
-
-    value
-  end
-
-  # Wraps Memcached#cas so that it doesn't raise. Doesn't set anything if no value is present.
-  def cas(key, ttl=@default_ttl, raw=false, &block)
-    logger.debug("Memcached cas: #{key.inspect}") if logger && @debug
-    super(key, ttl, !raw, &block)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::NotFound
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-  rescue TypeError
-    log_error($!) if logger
-    delete(key)
-    logger.debug("Memcached deleted: #{key.inspect}") if logger && @debug
-  rescue Memcached::Error
-    if $!.is_a?(Memcached::ClientError)
-      raise $!
-    end
-    log_error($!) if logger
-  end
-  
-  def get_multi(*keys)
-    keys.flatten!
-    logger.debug("Memcached get_multi: #{keys.inspect}") if logger && @debug
-    values = super(keys, true)
-    logger.debug("Memcached hit: #{keys.inspect}") if logger && @debug
-    values
-  rescue Memcached::NotFound
-    logger.debug("Memcached miss: #{keys.inspect}") if logger && @debug
-    {}
-  rescue TypeError
-    log_error($!) if logger
-    keys.each { |key| delete(key) }
-    logger.debug("Memcached deleted: #{keys.inspect}") if logger && @debug
-    {}
-  rescue Memcached::Error
-    log_error($!) if logger
-    {}
-  end
-
-  def set(key, value, ttl=@default_ttl, raw=false)
-    logger.debug("Memcached set: #{key.inspect}") if logger && @debug
-    super(key, value, ttl, !raw)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::Error
-    log_error($!) if logger
-    not_stored
-  end
-
-  def append(key, value)
-    logger.debug("Memcached append: #{key.inspect}") if logger && @debug
-    super(key, value)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::NotStored
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    not_stored
-  rescue Memcached::Error
-    log_error($!) if logger
-  end
-
-  def prepend(key, value)
-    logger.debug("Memcached prepend: #{key.inspect}") if logger && @debug
-    super(key, value)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    stored
-  rescue Memcached::NotStored
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    not_stored
-  rescue Memcached::Error
-    log_error($!) if logger
-  end
-
-  def delete(key)
-    logger.debug("Memcached delete: #{key.inspect}") if logger && @debug
-    super(key)
-    logger.debug("Memcached hit: #{key.inspect}") if logger && @debug
-    deleted
-  rescue Memcached::NotFound
-    logger.debug("Memcached miss: #{key.inspect}") if logger && @debug
-    not_found
-  rescue Memcached::Error
-    log_error($!) if logger
-  end
-  
-  def incr(*args)
-    super
-  rescue Memcached::NotFound
-  rescue Memcached::Error
-    log_error($!) if logger
-  end
-
-  def decr(*args)
-    super
-  rescue Memcached::NotFound
-  rescue Memcached::Error
-    log_error($!) if logger
-  end
-
-  def get_server_for_key(key, options = {})
-    server_by_key(key)
-  end
-
-  alias :reset :quit
-  alias :close :quit #nodoc
-  alias :flush_all :flush
-  alias :compare_and_swap :cas
-  alias :"[]" :get
-  alias :"[]=" :set    
-
-private
-
-  def stored
-    "STORED\r\n"
-  end
-  
-  def deleted
-    "DELETED\r\n"
-  end
-  
-  def not_stored
-    "NOT_STORED\r\n"
-  end
-  
-  def not_found
-    "NOT_FOUND\r\n"
-  end
-
-  def log_error(err)
-    #logger.error("#{err}: \n\t#{err.backtrace.join("\n\t")}") if logger
-    logger.error("Memcached ERROR, #{err.class}: #{err}") if logger
-  end
-  
-end
-####### they have MemCache installed (don't need the wrapper)
-elsif defined? MemCache
-
-Rails.logger.info("cache-money: MemCache installed") if defined? Rails
-#TODO add logging?
-class MemcachedWrapper < ::MemCache
-end
-
-else
-  Rails.logger.warn 'unable to determine memcache implementation' if defined? Rails
-end #include the wraper

data/spec/memcached_wrapper_test.rb

@@ -1,209 +0,0 @@
-require 'test_helper'
-require 'memcache'
-
-class MemcachedWrapperTest < ActiveSupport::TestCase
-
-  context "with single memcached server" do
-
-    setup do
-      @wrapper = MemcachedWrapper.new("127.0.0.1:11211", {:namespace => "wrapper", :show_backtraces => true, :support_cas => true})
-      @memcache = MemCache.new("127.0.0.1:11211", {:namespace => "memcache"})
-      @wrapper.flush_all
-      @memcache.flush_all
-    end
-    
-    teardown do
-      @wrapper.close
-      @memcache.reset
-    end
-
-    should "add" do
-      assert_equal(@wrapper.add("blah/toe", "blah"),  @memcache.add("blah/toe", "blah"))
-      assert_equal(@wrapper.get("blah/toe"),          @memcache.get("blah/toe"))
-      assert_equal(@wrapper.add("blah/toe", "blah2"), @memcache.add("blah/toe", "blah2"))
-      assert_equal(@wrapper.get("blah/toe"),          @memcache.get("blah/toe"))
-    end
-    
-    should "replace" do
-      assert_equal(@wrapper.replace("blah/toe", "blah"),  @memcache.replace("blah/toe", "blah"))
-      assert_equal(@wrapper.add("blah/toe", "blah"),      @memcache.add("blah/toe", "blah"))
-      assert_equal(@wrapper.replace("blah/toe", "blah2"), @memcache.replace("blah/toe", "blah2"))
-      assert_equal(@wrapper.get("blah/toe"),              @memcache.get("blah/toe"))
-    end
-    
-    should "get" do
-      assert_equal(@wrapper.add("blah/toe", "blah"), @memcache.add("blah/toe", "blah"))
-      assert_equal(@wrapper.get("blah/toe"),         @memcache.get("blah/toe"))
-    end
-    
-    should "fetch" do
-      assert_equal(@wrapper.fetch("blah/toe") { "blah" },  @memcache.fetch("blah/toe") { "blah" })
-      assert_equal(@wrapper.fetch("blah/toe") { "blah2" }, @memcache.fetch("blah/toe") { "blah2" })
-    end
-    
-    should "compare and swap" do
-      assert_equal(@wrapper.cas("blah/toe") { "blah" },  @memcache.cas("blah/toe") { "blah" })
-      assert_equal(@wrapper.add("blah/toe", "blah"),     @memcache.add("blah/toe", "blah"))
-      assert_equal(@wrapper.cas("blah/toe") { "blah2" }, @memcache.cas("blah/toe") { "blah2" })
-      assert_equal(@wrapper.get("blah/toe"),             @memcache.get("blah/toe"))
-    end
-    
-    should "get multiple" do
-      assert_equal(@wrapper.add("blah/toe", "blah"),     @memcache.add("blah/toe", "blah"))
-      assert_equal(@wrapper.add("blah/finger", "blah2"), @memcache.add("blah/finger", "blah2"))
-      assert_equal(@wrapper.get_multi(["blah/toe", "blah/finger"]), @memcache.get_multi(["blah/toe", "blah/finger"]))
-    end
-    
-    should "set" do
-      assert_equal(@wrapper.set("blah/toe", "blah"), @memcache.set("blah/toe", "blah"))
-      assert_equal(@wrapper.get("blah/toe"),         @memcache.get("blah/toe"))
-    end
-    
-    should "append" do
-      assert_equal(@wrapper.append("blah/toe", "blah"), @memcache.append("blah/toe", "blah"))
-      assert_equal(@wrapper.get("blah/toe"),            @memcache.get("blah/toe"))
-
-      assert_equal(@wrapper.set("blah/toe", "blah", 0, true), @memcache.set("blah/toe", "blah", 0, true))
-      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
-      assert_equal(@wrapper.append("blah/toe", "blah2"),      @memcache.append("blah/toe", "blah2"))
-      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
-    end
-    
-    should "prepend" do
-      assert_equal(@wrapper.prepend("blah/toe", "blah"), @memcache.prepend("blah/toe", "blah"))
-      assert_equal(@wrapper.get("blah/toe"),             @memcache.get("blah/toe"))
-    
-      assert_equal(@wrapper.set("blah/toe", "blah", 0, true), @memcache.set("blah/toe", "blah", 0, true))
-      assert_equal(@wrapper.prepend("blah/toe", "blah2"),     @memcache.prepend("blah/toe", "blah2"))
-      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
-    end
-    
-    should "delete" do
-      assert_equal(@wrapper.delete("blah/toe"),      @memcache.delete("blah/toe"))
-      assert_equal(@wrapper.set("blah/toe", "blah"), @memcache.set("blah/toe", "blah"))
-      assert_equal(@wrapper.delete("blah/toe"),      @memcache.delete("blah/toe"))
-    end
-    
-    should "increment" do
-      assert_equal(@wrapper.incr("blah/count"),            @memcache.incr("blah/count"))
-      assert_equal(@wrapper.set("blah/count", 0, 0, true), @memcache.set("blah/count", 0, 0, true))
-      assert_equal(@wrapper.incr("blah/count"),            @memcache.incr("blah/count"))
-    end
-    
-    should "decrement" do
-      assert_equal(@wrapper.decr("blah/count"),            @memcache.decr("blah/count")) 
-      assert_equal(@wrapper.set("blah/count", 2, 0, true), @memcache.set("blah/count", 2, 0, true))
-      assert_equal(@wrapper.decr("blah/count"),            @memcache.decr("blah/count"))
-    end
-
-    # should "stats" do
-    #   assert_equal(@wrapper.stats(), @memcache.stats())
-    # end
-
-  end
-
-  # context "with two memcached servers" do
-  # 
-  #   setup do
-  #     @wrapper = MemcachedWrapper.new(["127.0.0.1:11211", "127.0.0.1:1111"], {:show_backtraces => true, :support_cas => true})
-  #     # @wrapper = MemCache.new(["127.0.0.1:11211", "127.0.0.1:1111"], {:show_backtraces => true, :support_cas => true})
-  #     @wrapper.flush_all
-  #   end
-  #   
-  #   teardown do
-  #     # @wrapper.close
-  #   end
-  # 
-  #   should "add value" do
-  #     assert_stored(@wrapper.add("blah/toe", "blah"))
-  #     assert_equal( "blah", @wrapper.get("blah/toe"))
-  #     assert_not_stored(@wrapper.add("blah/toe", "blah2"))
-  #     assert_equal( "blah", @wrapper.get("blah/toe"))
-  #   end
-  #   
-  #   should "get value" do
-  #     assert_stored(@wrapper.add("blah/toe", "blah"))
-  #     assert_equal( "blah", @wrapper.get("blah/toe"))
-  #   end
-  #   
-  #   should "fetch value" do
-  #     assert_equal( "blah", @wrapper.fetch("blah/toe") { "blah" })
-  #     assert_equal( "blah", @wrapper.fetch("blah/toe") { "blah2" })
-  #   end
-  #   
-  #   should "check and set value" do
-  #     assert_nil(   @wrapper.cas("blah/toe") { "blah" })
-  #     assert_stored(@wrapper.add("blah/toe", "blah"))
-  #     assert_stored(@wrapper.cas("blah/toe") { "blah2" })
-  #     assert_equal( "blah2", @wrapper.get("blah/toe"))
-  #   end
-  #   
-  #   should "get multiple values" do
-  #     assert_stored(@wrapper.add("blah/toe", "blah"))
-  #     assert_stored(@wrapper.add("blah/finger", "blah2"))
-  #     assert_equal( {'blah/toe'=>'blah','blah/finger'=>'blah2'}, @wrapper.get_multi(["blah/toe", "blah/finger"]))
-  #   end
-  #   
-  #   should "set value" do
-  #     assert_stored(@wrapper.set("blah/toe", "blah"))
-  #     assert_equal( "blah", @wrapper.get("blah/toe"))
-  #   end
-  #   
-  #   should "append value" do
-  #     assert_not_stored( @wrapper.append("blah/toe", "blah"))
-  #     assert_nil( @wrapper.get("blah/toe"))
-  # 
-  #     assert_stored( @wrapper.set("blah/toe", "blah", 0, true))
-  #     assert_equal(  "blah", @wrapper.get("blah/toe", true))
-  #     assert_stored( @wrapper.append("blah/toe", "blah2"))
-  #     assert_equal(  "blahblah2", @wrapper.get("blah/toe", true))
-  #   end
-  #   
-  #   should "prepend value" do
-  #     assert_not_stored(@wrapper.prepend("blah/toe", "blah"))
-  #     assert_nil( @wrapper.get("blah/toe"))
-  #   
-  #     assert_stored( @wrapper.set("blah/toe", "blah", 0, true))
-  #     assert_stored( @wrapper.prepend("blah/toe", "blah2"))
-  #     assert_equal(  "blah2blah", @wrapper.get("blah/toe", true))
-  #   end
-  #   
-  #   should "delete value" do
-  #     assert_not_found( @wrapper.delete("blah/toe"))
-  #     assert_stored(    @wrapper.set("blah/toe", "blah"))
-  #     assert_deleted(   @wrapper.delete("blah/toe"))
-  #   end
-  #   
-  #   should "increment value" do
-  #     assert_nil(   @wrapper.incr("blah/count"))
-  #     assert_stored(@wrapper.set("blah/count", 0, 0, true))
-  #     assert_equal( 1, @wrapper.incr("blah/count"))
-  #   end
-  #   
-  #   should "decrement value" do
-  #     assert_nil(   @wrapper.decr("blah/count")) 
-  #     assert_stored(@wrapper.set("blah/count", 2, 0, true))
-  #     assert_equal( 1, @wrapper.decr("blah/count"))
-  #   end
-  # 
-  # end
-
-private
-
-  def assert_stored(val)
-    assert_equal("STORED\r\n", val)
-  end
-
-  def assert_deleted(val)
-    assert_equal("DELETED\r\n", val)
-  end
-
-  def assert_not_stored(val)
-    assert_equal("NOT_STORED\r\n", val)
-  end
-
-  def assert_not_found(val)
-    assert_equal("NOT_FOUND\r\n", val)
-  end
-
-end