mcmire-cache 0.3.4

data/lib/cache.rb

@@ -0,0 +1,233 @@
+require 'cache/config'
+
+class Cache
+  class Error < StandardError; end
+  class DriverNotFound < Error
+    def initialize(client_class)
+      @client_class = client_class
+    end
+
+    def message
+      "The cache gem doesn't support #{@client_class} yet"
+    end
+  end
+
+  attr_reader :config
+  attr_reader :metal
+
+  # For compatibility with Rails 2.x
+  attr_accessor :logger
+
+  # Create a new Cache instance by wrapping a client of your choice.
+  #
+  # Supported memcached clients:
+  #
+  # * memcached[https://github.com/evan/memcached] (either a Memcached or a Memcached::Rails)
+  # * dalli[https://github.com/mperham/dalli] (either a Dalli::Client or an ActiveSupport::Cache::DalliStore)
+  # * memcache-client[https://github.com/mperham/memcache-client] (MemCache, the one commonly used by Rails)
+  #
+  # Supported Redis clients:
+  #
+  # * redis[https://github.com/ezmobius/redis-rb] (Redis)
+  # * redis-namespace[https://github.com/defunkt/redis-namespace] (Redis::Namespace)
+  #
+  # metal - Either an instance of one of the above classes, or :nothing if you
+  #         want to use the Cache API but not actually cache anything.
+  #
+  # Examples:
+  #
+  #   # Use Memcached
+  #   raw_client = Memcached.new('127.0.0.1:11211')
+  #   cache = Cache.new(raw_client)
+  #   cache.get(...)
+  #   cache.set(...)
+  #
+  #   # Don't cache anything
+  #   cache = Cache.new(:nothing)
+  #   cache.get(...)
+  #   cache.set(...)
+  #
+  def initialize(metal)
+    @pid = ::Process.pid
+    @config = Config.new
+    if metal == :nothing
+      @metal = nil
+      client_class = 'Nothing'
+      driver_class = 'Nothing'
+    else
+      @metal = Cache === metal ? metal.metal : metal
+      client_class = @metal.class.to_s
+      driver_class = client_class.gsub('::', '')
+    end
+    filename = client_class.
+      gsub(/([a-z])([A-Z]+)/) { [$1.downcase, $2.downcase].join('_') }.
+      gsub('::', '_').downcase
+    begin
+      require "cache/#{filename}"
+      extend Cache.const_get(driver_class)
+    rescue LoadError, NameError => e
+      puts "#{e.class}: #{e.message}"
+      puts e.backtrace[0..5].join("\n")
+      raise DriverNotFound, client_class
+    end
+  end
+
+  # Get a value.
+  #
+  # Example:
+  #     cache.get 'hello'
+  def get(k, ignored_options = nil)
+    handle_fork
+    _get k
+  end
+
+  alias :read :get
+
+  # Get multiple cache entries.
+  #
+  # Example:
+  #     cache.get_multi 'hello', 'privyet'
+  def get_multi(*ks)
+    handle_fork
+    _get_multi ks
+  end
+
+  # Store a value. Note that this will Marshal it.
+  #
+  # Example:
+  #     cache.set 'hello', 'world'
+  #     cache.set 'hello', 'world', 80 # seconds til it expires
+  def set(k, v, ttl = nil, ignored_options = nil)
+    handle_fork
+    _set k, v, _get_ttl(ttl)
+  end
+
+  alias :write :set
+
+  # Delete a value.
+  #
+  # Example:
+  #     cache.delete 'hello'
+  def delete(k, ignored_options = nil)
+    handle_fork
+    _delete k
+  end
+
+  # Flush the cache.
+  #
+  # Example:
+  #     cache.flush
+  def flush
+    handle_fork
+    _flush
+  end
+
+  alias :clear :flush
+
+  # Check if something exists.
+  #
+  # Example:
+  #     cache.exist? 'hello'
+  def exist?(k, ignored_options = nil)
+    handle_fork
+    _exist? k
+  end
+  alias_method :exists?, :exist?
+
+  # Increment a value.
+  #
+  # Example:
+  #     cache.increment 'high-fives'
+  def increment(k, amount = 1, ignored_options = nil)
+    handle_fork
+    new_v = _get(k).to_i + amount
+    _set k, new_v, 0
+    new_v
+  end
+
+  # Decrement a value.
+  #
+  # Example:
+  #     cache.decrement 'high-fives'
+  def decrement(k, amount = 1, ignored_options = nil)
+    increment k, -amount
+  end
+
+  # Try to get a value and if it doesn't exist, set it to the result of the block.
+  #
+  # Accepts :expires_in for compatibility with Rails.
+  #
+  # Example:
+  #     cache.fetch 'hello' { 'world' }
+  def fetch(k, ttl = nil, &blk)
+    handle_fork
+    _fetch(k, _get_ttl(ttl), &blk)
+  end
+
+  # Default implementation of #fetch for drivers that do not define a method
+  # natively for it
+  def _fetch(k, ttl, &blk)
+    if _exist? k
+      _get k
+    elsif blk
+      v = blk.call
+      _set k, v, ttl
+      v
+    end
+  end
+
+  # Get the current value (if any), pass it into a block, and set the result.
+  #
+  # Example:
+  #     cache.cas 'hello' { |current| 'world' }
+  def cas(k, ttl = nil, &blk)
+    handle_fork
+    _cas(k, ttl, &blk)
+  end
+
+  alias :compare_and_swap :cas
+
+  # Default implementation of #cas which is overridden in some drivers
+  def _cas(k, ttl, &blk)
+    if blk and _exist?(k)
+      old_v = _get k
+      new_v = blk.call old_v
+      _set k, new_v, _get_ttl(ttl)
+      new_v
+    end
+  end
+
+  # Get stats.
+  #
+  # Example:
+  #     cache.stats
+  def stats
+    handle_fork
+    _stats
+  end
+
+  private
+
+  def handle_fork
+    if ::Process.pid != @pid
+      @pid = ::Process.pid
+      after_fork
+    end
+  end
+
+  def after_fork
+    # nothing
+  end
+
+  def _get_ttl(ttl)
+    if Hash === ttl
+      ttl = ttl[:expires_in] || ttl['expires_in'] || ttl[:ttl] || ttl['ttl']
+    end
+    ttl || config.default_ttl
+  end
+
+  def _valid_ttl?(ttl)
+    ttl and ttl > 0
+  end
+end
+

data/lib/cache/active_support_cache_dalli_store.rb

@@ -0,0 +1,15 @@
+require 'cache/active_support_cache_store'
+
+module Cache::ActiveSupportCacheDalliStore
+  def self.extended(base)
+    base.extend Cache::ActiveSupportCacheStore
+  end
+
+  def after_fork
+    @metal.reset
+  end
+
+  def _stats
+    @metal.stats
+  end
+end

data/lib/cache/active_support_cache_file_store.rb

@@ -0,0 +1,11 @@
+require 'cache/active_support_cache_store'
+
+module Cache::ActiveSupportCacheFileStore
+  def self.extended(base)
+    base.extend Cache::ActiveSupportCacheStore
+  end
+
+  def _stats
+    {}
+  end
+end

data/lib/cache/active_support_cache_memory_store.rb

@@ -0,0 +1,11 @@
+require 'cache/active_support_cache_store'
+
+module Cache::ActiveSupportCacheMemoryStore
+  def self.extended(base)
+    base.extend Cache::ActiveSupportCacheStore
+  end
+
+  def _stats
+    {}
+  end
+end

data/lib/cache/active_support_cache_store.rb

@@ -0,0 +1,37 @@
+module Cache::ActiveSupportCacheStore
+  def _get(k)
+    @metal.read k
+  end
+
+  def _get_multi(ks)
+    @metal.read_multi *ks
+  end
+
+  def _set(k, v, ttl)
+    if _valid_ttl?(ttl)
+      @metal.write k, v, :expires_in => ttl
+    else
+      @metal.write k, v
+    end
+  end
+
+  def _fetch(k, ttl, &blk)
+    if _valid_ttl?(ttl)
+      @metal.fetch k, { :expires_in => ttl }, &blk
+    else
+      @metal.fetch k, &blk
+    end
+  end
+
+  def _delete(k)
+    @metal.delete k
+  end
+
+  def _flush
+    @metal.clear
+  end
+
+  def _exist?(k)
+    @metal.exist? k
+  end
+end

data/lib/cache/config.rb

@@ -0,0 +1,27 @@
+
+class Cache
+  class Config
+
+    # Set the default TTL that keys will live when not specifying a TTL.
+    #
+    # ttl - Integer in seconds.
+    #
+    # Example:
+    #
+    #   cache.config.default_ttl = 120
+    #   cache.set('foo', 'val')  # equivalent to set('foo', 'val', 120)
+    #
+    def default_ttl=(seconds)
+      @default_ttl = seconds
+    end
+
+    # Get the currently set TTL.
+    #
+    # Returns an Integer in seconds.
+    #
+    def default_ttl
+      @default_ttl
+    end
+
+  end
+end

data/lib/cache/dalli_client.rb

@@ -0,0 +1,54 @@
+module Cache::DalliClient
+  def after_fork
+    @metal.close
+  end
+
+  def _get(k)
+    @metal.get k
+  end
+
+  def _get_multi(ks)
+    @metal.get_multi ks
+  end
+
+  def _set(k, v, ttl)
+    if _valid_ttl?(ttl)
+      @metal.set k, v, ttl
+    else
+      @metal.set k, v
+    end
+  end
+
+  def _fetch(k, ttl, &blk)
+    if _valid_ttl?(ttl)
+      @metal.fetch k, ttl, &blk
+    else
+      @metal.fetch k, &blk
+    end
+  end
+
+  def _cas(k, ttl, &blk)
+    if _valid_ttl?(ttl)
+      @metal.cas k, ttl, &blk
+    else
+      @metal.cas k, &blk
+    end
+  end
+
+  def _delete(k)
+    @metal.delete k
+  end
+
+  def _flush
+    @metal.flush
+  end
+
+  # sux
+  def _exist?(k)
+    !@metal.get(k).nil?
+  end
+
+  def _stats
+    @metal.stats
+  end
+end

data/lib/cache/mem_cache.rb

@@ -0,0 +1,46 @@
+module Cache::MemCache
+  def after_fork
+    @metal.reset
+  end
+
+  def _get(k)
+    @metal.get k
+  end
+
+  def _get_multi(ks)
+    @metal.get_multi ks
+  end
+
+  def _set(k, v, ttl)
+    if _valid_ttl?(ttl)
+      @metal.set k, v, ttl
+    else
+      @metal.set k, v
+    end
+  end
+
+  def _fetch(k, ttl, &blk)
+    if _valid_ttl?(ttl)
+      @metal.fetch k, ttl, &blk
+    else
+      @metal.fetch k, &blk
+    end
+  end
+
+  def _delete(k)
+    @metal.delete k
+  end
+
+  def _flush
+    @metal.flush_all
+  end
+
+  # sux
+  def _exist?(k)
+    !@metal.get(k).nil?
+  end
+
+  def _stats
+    @metal.stats
+  end
+end

data/lib/cache/memcached.rb

@@ -0,0 +1,54 @@
+module Cache::Memcached
+  def thread_metal
+    ::Thread.current["#{@pid}/#{self.class.name}/#{object_id}/thread_metal"] ||= @metal.clone
+  end
+
+  def _get(k)
+    thread_metal.get k
+  rescue ::Memcached::NotFound
+    return nil
+  end
+
+  def _get_multi(ks)
+    thread_metal.get ks
+  end
+
+  def _set(k, v, ttl)
+    if _valid_ttl?(ttl)
+      thread_metal.set k, v, ttl
+    else
+      thread_metal.set k, v
+    end
+  end
+
+  def _cas(k, ttl, &blk)
+    if _valid_ttl?(ttl)
+      thread_metal.cas k, ttl, &blk
+    else
+      thread_metal.cas k, &blk
+    end
+  rescue ::Memcached::NotFound
+    return nil
+  end
+
+  def _delete(k)
+    thread_metal.delete k
+  rescue ::Memcached::NotFound
+    return nil
+  end
+
+  def _flush
+    thread_metal.flush
+  end
+
+  def _exist?(k)
+    thread_metal.get k
+    true
+  rescue ::Memcached::NotFound
+    false
+  end
+
+  def _stats
+    thread_metal.stats
+  end
+end