benschwarz-merb-cache 1.0.0

data/lib/merb-cache/stores/fundamental/file_store.rb

@@ -0,0 +1,113 @@
+module Merb::Cache
+  # Cache store that uses files. Usually this is good for fragment
+  # and page caching but not object caching.
+  #
+  # By default cached files are stored in tmp/cache under Merb.root directory.
+  # To use other location pass :dir option to constructor.
+  #
+  # File caching does not support expiration time.
+  class FileStore < AbstractStore
+    attr_accessor :dir
+
+    # Creates directory for cached files unless it exists.
+    def initialize(config = {})
+      @dir = config[:dir] || Merb.root_path(:tmp / :cache)
+
+      create_path(@dir)
+    end
+
+    # File caching does not support expiration time.
+    def writable?(key, parameters = {}, conditions = {})
+      case key
+      when String, Numeric, Symbol
+        !conditions.has_key?(:expire_in)
+      else 
+        false
+      end
+    end
+
+    # Reads cached template from disk if it exists.
+    def read(key, parameters = {})
+      if exists?(key, parameters)
+        read_file(pathify(key, parameters))
+      end
+    end
+
+    # Writes cached template to disk, creating cache directory
+    # if it does not exist.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        if File.file?(path = pathify(key, parameters))
+          write_file(path, data)
+        else
+          create_path(path) && write_file(path, data)
+        end
+      end
+    end
+
+    # Fetches cached data by key if it exists. If it does not,
+    # uses passed block to get new cached value and writes it
+    # using given key.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) || (writable?(key, parameters, conditions) && write(key, value = blk.call, parameters, conditions) && value)
+    end
+
+    # Checks if cached template with given key exists.
+    def exists?(key, parameters = {})
+      File.file?(pathify(key, parameters))
+    end
+
+    # Deletes cached template by key using FileUtils#rm.
+    def delete(key, parameters = {})
+      if File.file?(path = pathify(key, parameters))
+        FileUtils.rm(path)
+      end
+    end
+
+    def delete_all
+      raise NotSupportedError
+    end
+
+    def pathify(key, parameters = {})
+      if key.to_s =~ /^\//
+        path = "#{@dir}#{key}"
+      else
+        path = "#{@dir}/#{key}"
+      end
+
+      path << "--#{parameters.to_sha2}" unless parameters.empty?
+      path
+    end
+    
+    protected
+
+    def create_path(path)
+      FileUtils.mkdir_p(File.dirname(path))
+    end
+
+    # Reads file content. Access to the file
+    # uses file locking.
+    def read_file(path)
+      data = nil
+      File.open(path, "r") do |file|
+        file.flock(File::LOCK_EX)
+        data = file.read
+        file.flock(File::LOCK_UN)
+      end
+
+      data
+    end
+
+    # Writes file content. Access to the file
+    # uses file locking.    
+    def write_file(path, data)
+      File.open(path, "w+") do |file|
+        file.flock(File::LOCK_EX)
+        file.write(data)
+        file.flock(File::LOCK_UN)
+      end
+
+      true
+    end
+  end
+end

data/lib/merb-cache/stores/fundamental/memcached_store.rb

@@ -0,0 +1,110 @@
+require 'memcached'
+
+module Merb::Cache
+  # Memcached store uses one or several Memcached
+  # servers for caching. It's flexible and can be used
+  # for fragment caching, action caching, page caching
+  # or object caching.
+  class MemcachedStore < AbstractStore
+    attr_accessor :namespace, :servers, :memcached
+
+    def initialize(config = {})
+      @namespace = config[:namespace]
+      @servers = config[:servers] || ["127.0.0.1:11211"]
+
+      connect(config)
+    end
+
+    # Memcached store consideres all keys and parameters
+    # writable.
+    def writable?(key, parameters = {}, conditions = {})
+      true
+    end
+
+    # Reads key from the cache.
+    def read(key, parameters = {})
+      begin
+        @memcached.get(normalize(key, parameters))
+      rescue Memcached::NotFound, Memcached::Stored
+        nil
+      end
+    end
+
+    # Writes data to the cache using key, parameters and conditions.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        begin
+          @memcached.set(normalize(key, parameters), data, expire_time(conditions))
+          true
+        rescue
+          nil
+        end
+      end
+    end
+
+    # Fetches cached data by key if it exists. If it does not,
+    # uses passed block to get new cached value and writes it
+    # using given key.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) || (writable?(key, parameters, conditions) && write(key, value = blk.call, parameters, conditions) && value)
+    end
+
+    # returns true/false based on if data identified by the key & parameters
+    # is persisted in the store.
+    #
+    # With Memcached 1.2 protocol the only way to
+    # find if key exists in the cache is to read it.
+    # It is very fast and shouldn't be a concern.
+    def exists?(key, parameters = {})
+      begin
+        true if @memcached.get(normalize(key, parameters))
+      rescue Memcached::NotFound
+        false
+      end
+    end
+
+    # Deletes entry from cached by key.
+    def delete(key, parameters = {})
+      begin
+        @memcached.delete(normalize(key, parameters))
+      rescue Memcached::NotFound
+        nil
+      end
+    end
+
+    # Flushes the cache.
+    def delete_all
+      @memcached.flush
+    end
+
+    def clone
+      twin = super
+      twin.memcached = @memcached.clone
+      twin
+    end
+
+    # Establishes connection to Memcached.
+    #
+    # Use :buffer_requests option to use bufferring,
+    # :no_block to use non-blocking async I/O.
+    def connect(config = {})
+      @memcached = ::Memcached.new(@servers, config.only(:buffer_requests, :no_block).merge(:namespace => @namespace))
+    end
+
+    # Returns cache key calculated from base key
+    # and SHA2 hex from parameters.
+    def normalize(key, parameters = {})
+      parameters.empty? ? "#{key}" : "#{key}--#{parameters.to_sha2}"
+    end
+
+    # Returns expiration timestamp if :expire_in key is
+    # given.
+    def expire_time(conditions = {})
+      if t = conditions[:expire_in]
+        Time.now + t
+      else
+        0
+      end
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/abstract_strategy_store.rb

@@ -0,0 +1,119 @@
+# -*- coding: undecided -*-
+module Merb::Cache
+  # A strategy store wraps one or
+  # more fundamental stores, acting as a middle man between caching
+  # requests.
+  #
+  # For example, if you need to save memory on your Memcache server,
+  # you could wrap your MemcachedStore with a GzipStore. This would
+  # automatically compress the cached data when put into the cache, and
+  # decompress it on the way out. You can even wrap strategy caches
+  # with other strategy caches. If your key was comprised of sensitive
+  # information, like a SSN, you might want to encrypt the key before
+  # storage. Wrapping your GzipStore in a SHA1Store would take
+  # care of that for you.
+  #
+  # The AbstractStore class defines 9 methods as the API:
+  # 
+  # writable?(key, parameters = {}, conditions = {})
+  # exists?(key, parameters = {})
+  # read(key, parameters = {})
+  # write(key, data = nil, parameters = {}, conditions = {})
+  # write_all(key, data = nil, parameters = {}, conditions = {})
+  # fetch(key, parameters = {}, conditions = {}, &blk)
+  # delete(key, parameters = {})
+  # delete_all
+  # delete_all!
+  # 
+  # AbstractStrategyStore implements all of these with the exception
+  # of delete_all. If a strategy store can guarantee that calling
+  # delete_all on it’s wrapped store(s) will only delete entries
+  # populated by the strategy store, it may define the safe
+  # version of delete_all. However, this is usually not the
+  # case, hence delete_all is not part of the
+  # public API for AbstractStrategyStore.
+  class AbstractStrategyStore < AbstractStore
+    # START: interface for creating strategy stores.  This should/might change.
+    def self.[](*stores)
+        Class.new(self) do
+          cattr_accessor :contextualized_stores
+
+          self.contextualized_stores = stores
+        end
+      end
+
+      attr_accessor :stores
+
+      def initialize(config = {})
+        @stores = contextualized_stores.map do |cs|
+          case cs
+          when Symbol
+            Merb::Cache[cs]
+          when Class
+            cs.new(config)
+          end
+        end
+      end
+
+    # END: interface for creating strategy stores.
+
+    attr_accessor :stores
+
+    # determines if the store is able to persist data identified by the key & parameters
+    # with the given conditions.
+    def writable?(key, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # gets the data from the store identified by the key & parameters.
+    # return nil if the entry does not exist.
+    def read(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # persists the data so that it can be retrieved by the key & parameters.
+    # returns nil if it is unable to persist the data.
+    # returns true if successful.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # persists the data to all context stores.
+    # returns nil if none of the stores were able to persist the data.
+    # returns true if at least one write was successful.
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # tries to read the data from the store.  If that fails, it calls
+    # the block parameter and persists the result.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      raise NotImplementedError
+    end
+
+    # returns true/false/nil based on if data identified by the key & parameters
+    # is persisted in the store.
+    def exists?(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # deletes the entry for the key & parameter from the store.
+    def delete(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # deletes all entries for the key & parameters for the store.
+    # considered dangerous because strategy stores which call delete_all!
+    # on their context stores could delete other store's entrees.
+    def delete_all!
+      raise NotImplementedError
+    end
+
+    def clone
+      twin = super
+      twin.stores = self.stores.map {|s| s.clone}
+      twin
+    end
+    
+  end
+end

data/lib/merb-cache/stores/strategy/action_store.rb

@@ -0,0 +1,61 @@
+module Merb::Cache
+  # Store well suited for action caching.
+  class ActionStore < AbstractStrategyStore
+    # If you're not sending a controller dispatch, then we
+    # can't really write a cache
+    def writable?(dispatch, parameters = {}, conditions = {})      
+      return @stores.any?{|s| s.writable?(normalize(dispatch), parameters, conditions)} if dispatch.is_a? Merb::Controller
+      return false
+    end
+
+    def read(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.capture_first {|s| s.read(normalize(dispatch), parameters)}
+      end
+    end
+
+    def write(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters)
+        return @stores.capture_first {|s| s.write(normalize(dispatch), (data || dispatch.body), parameters, conditions)}
+      else
+        return false
+      end
+    end
+
+    def write_all(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters, conditions)
+        return @stores.map {|s| s.write_all(normalize(dispatch), data || dispatch.body, parameters, conditions)}.all?
+      else 
+        return false
+      end
+    end
+
+    def fetch(dispatch, parameters = {}, conditions = {}, &blk)
+      if writable?(dispatch, parameters, conditions)
+        return read(dispatch, parameters) || @stores.capture_first {|s| s.fetch(normalize(dispatch), data || dispatch.body, parameters, conditions, &blk)}
+      end
+    end
+
+    def exists?(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        return @stores.capture_first {|s| s.exists?(normalize(dispatch), parameters)}
+      end
+      
+      return false
+    end
+
+    def delete(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.map {|s| s.delete(normalize(dispatch), parameters)}.any?
+      end
+    end
+
+    def delete_all!
+      @stores.map {|s| s.delete_all!}.all?
+    end
+
+    def normalize(dispatch)
+      "#{dispatch.class.name}##{dispatch.action_name}" unless dispatch.class.name.blank? || dispatch.action_name.blank?
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/adhoc_store.rb

@@ -0,0 +1,69 @@
+module Merb::Cache
+  # General purpose store, use for your own
+  # contexts. Since it wraps access to multiple
+  # fundamental stores, it's easy to use
+  # this strategy store with distributed cache
+  # stores like Memcached.
+  class AdhocStore < AbstractStrategyStore
+    class << self
+      alias_method :[], :new
+    end
+
+    attr_accessor :stores
+
+    def initialize(*names)
+      @stores = names.map {|n| Merb::Cache[n]}
+    end
+
+    def writable?(key, parameters = {}, conditions = {})
+      @stores.capture_first {|s| s.writable?(key, parameters, conditions)}
+    end
+
+    # gets the data from the store identified by the key & parameters.
+    # return nil if the entry does not exist.
+    def read(key, parameters = {})
+      @stores.capture_first {|s| s.read(key, parameters)}
+    end
+
+    # persists the data so that it can be retrieved by the key & parameters.
+    # returns nil if it is unable to persist the data.
+    # returns true if successful.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      @stores.capture_first {|s| s.write(key, data, parameters, conditions)}
+    end
+
+    # persists the data to all context stores.
+    # returns nil if none of the stores were able to persist the data.
+    # returns true if at least one write was successful.
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      @stores.map {|s| s.write_all(key, data, parameters, conditions)}.all?
+    end
+
+    # tries to read the data from the store.  If that fails, it calls
+    # the block parameter and persists the result.  If it cannot be fetched,
+    # the block call is returned.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) ||
+        @stores.capture_first {|s| s.fetch(key, parameters, conditions, &blk)} ||
+        blk.call
+    end
+
+    # returns true/false/nil based on if data identified by the key & parameters
+    # is persisted in the store.
+    def exists?(key, parameters = {})
+      @stores.any? {|s| s.exists?(key, parameters)}
+    end
+
+    # deletes the entry for the key & parameter from the store.
+    def delete(key, parameters = {})
+      @stores.map {|s| s.delete(key, parameters)}.any?
+    end
+
+    # deletes all entries for the key & parameters for the store.
+    # considered dangerous because strategy stores which call delete_all!
+    # on their context stores could delete other store's entrees.
+    def delete_all!
+      @stores.map {|s| s.delete_all!}.all?
+    end
+  end
+end