thorero-cache 0.9.4

data/lib/merb-cache/cache-store/database.rb

@@ -0,0 +1,144 @@
+class Merb::Cache::DatabaseStore
+  # Provides the database cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  class OrmNotFound < Exception #
+    def initialize
+      super("No valid ORM found (did you specify use_orm in init.rb?)")
+    end
+  end
+
+  # Requires the ORM at startup, raising an OrmNotFound exception if
+  # the backend is not found
+  Merb::Controller._cache.config[:table_name] ||= "merb_cache"
+  if defined?(Merb::Orms::ActiveRecord)
+    require "merb-cache/cache-store/database-activerecord.rb"
+    include Merb::Cache::DatabaseStore::ActiveRecord
+  elsif defined?(Merb::Orms::DataMapper)
+    require "merb-cache/cache-store/database-datamapper.rb"
+    include Merb::Cache::DatabaseStore::DataMapper
+  elsif defined?(Merb::Orms::Sequel)
+    require "merb-cache/cache-store/database-sequel.rb"
+    include Merb::Cache::DatabaseStore::Sequel
+  else
+    raise OrmNotFound
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (file permissions, table exists, connected to server, ...)
+  def prepare
+    CacheModel.check_table
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    not CacheModel.cache_get(key).nil?
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    _data = CacheModel.cache_get(key)
+    if _data.nil?
+      _expire = from_now ? from_now.minutes.from_now : nil
+      _data = _controller.send(:capture, &block)
+      CacheModel.cache_set(key, Marshal.dump(_data), _expire, false)
+    else
+      _data = Marshal.load(_data)
+    end
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to the database using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    _expire = from_now ? from_now.minutes.from_now : nil
+    CacheModel.cache_set(key, Marshal.dump(data), _expire)
+    Merb.logger.info("cache: set (#{key})")
+    true
+  end
+
+  # Fetch data from the database using the specified key
+  # The entry is deleted if it has expired
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # data<String, NilClass>::
+  #   nil is returned whether the entry expired or was not found
+  def cache_get(key)
+    data = CacheModel.cache_get(key)
+    Merb.logger.info("cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+    data.nil? ? nil : Marshal.load(data)
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    CacheModel.expire(key)
+    Merb.logger.info("cache: expired (#{key})")
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  def expire_match(key)
+    CacheModel.expire_match(key)
+    Merb.logger.info("cache: expired matching (#{key})")
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    CacheModel.expire_all
+    Merb.logger.info("cache: expired all")
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "database"
+  end
+end

data/lib/merb-cache/cache-store/dummy.rb

@@ -0,0 +1,106 @@
+class Merb::Cache::DummyStore
+  # Provides dummy cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (directories are accessible, table exists, connected to server, ...)
+  def prepare
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    false
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    _data = _controller.send(:capture, &block)
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to memcache using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    true
+  end
+
+  # Fetch data from memcache using the specified key
+  # The entry is deleted if it has expired
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # data<String, NilClass>::
+  #   nil is returned whether the entry expired or was not found
+  def cache_get(key)
+    nil
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  #
+  # ==== Warning !
+  #   This does not work in memcache.
+  def expire_match(key)
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "dummy"
+  end
+end

data/lib/merb-cache/cache-store/file.rb

@@ -0,0 +1,194 @@
+require 'fileutils'
+class Merb::Cache::FileStore
+  # Provides the file cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    @config[:cache_directory] ||= Merb.root_path("tmp/cache")
+#    @config[:cache_action_directory] ||= Merb.dir_for(:public) / "cache"
+    prepare
+  end
+
+  class NotAccessible < Exception #
+    def initialize(message)
+      super("Cache directories are not readable/writeable (#{message})")
+    end
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (directories are accessible, table exists, connected to server, ...)
+  def prepare
+    FileUtils.mkdir_p @config[:cache_directory]
+    unless File.readable?(@config[:cache_directory]) &&
+      File.writable?(@config[:cache_directory])
+      raise NotAccessible, @config[:cache_directory]
+    end
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    _data = _expire = nil
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      return true if _expire.nil? || Time.now < _expire
+      FileUtils.rm_f(cache_file)
+    end
+    false
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    _cache_hit = _data = _expire = nil
+   
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      _cache_hit = true if _expire.nil? || Time.now < _expire
+    end
+    unless _cache_hit
+      cache_directory = File.dirname(cache_file)
+      FileUtils.mkdir_p(cache_directory)
+      _expire = from_now ? from_now.minutes.from_now : nil
+      _data = _controller.send(:capture, &block)
+      cache_write(cache_file, Marshal.dump([_data, _expire]))
+    end
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to the file using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    cache_directory = File.dirname(cache_file)
+    FileUtils.mkdir_p(cache_directory)
+    _expire = from_now ? from_now.minutes.from_now : nil
+    cache_write(cache_file, Marshal.dump([data, _expire]))
+    Merb.logger.info("cache: set (#{key})")
+    true
+  end
+
+  # Fetch data from the file using the specified key
+  # The entry is deleted if it has expired
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # data<String, NilClass>::
+  #   nil is returned whether the entry expired or was not found
+  def cache_get(key)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      if _expire.nil? || Time.now < _expire
+        Merb.logger.info("cache: hit (#{key})")
+        return _data
+      end
+      FileUtils.rm_f(cache_file)
+    end
+    Merb.logger.info("cache: miss (#{key})")
+    nil
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    FileUtils.rm_f(@config[:cache_directory] / "#{key}.cache")
+    Merb.logger.info("cache: expired (#{key})")
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  def expire_match(key)
+    #files = Dir.glob(@config[:cache_directory] / "#{key}*.cache")
+    files = Dir.glob(@config[:cache_directory] / "#{key}*")
+    FileUtils.rm_rf(files)
+    Merb.logger.info("cache: expired matching (#{key})")
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    FileUtils.rm_rf(Dir.glob("#{@config[:cache_directory]}/*"))
+    Merb.logger.info("cache: expired all")
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "file"
+  end
+
+  private
+
+  # Read data from the file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: The full path to the file
+  #
+  # ==== Returns
+  # _data<String>:: The data read from the file
+  def cache_read(cache_file)
+    _data = nil
+    File.open(cache_file, "r") do |cache_data|
+      cache_data.flock(File::LOCK_EX)
+      _data = cache_data.read
+      cache_data.flock(File::LOCK_UN)
+    end
+    _data
+  end
+
+  # Write data to the file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: The full path to the file
+  # data<String>:: The data to be put in cache
+  def cache_write(cache_file, data)
+    File.open(cache_file, "w+") do |cache_data|
+      cache_data.flock(File::LOCK_EX)
+      cache_data.write(data)
+      cache_data.flock(File::LOCK_UN)
+    end
+    true
+  end
+end

data/lib/merb-cache/cache-store/memcache.rb

@@ -0,0 +1,199 @@
+class Merb::Cache::MemcacheStore
+  # Provides the memcache cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  class NotReady < Exception
+    def initialize
+      super("Memcache server is not ready")
+    end
+  end
+
+  class NotDefined < Exception
+    def initialize
+      super("Memcache is not defined (require it in init.rb)")
+    end
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (directories are accessible, table exists, connected to server, ...)
+  def prepare
+    namespace = @config[:namespace] || 'merb-cache'
+    host = @config[:host] || '127.0.0.1:11211'
+    @memcache = MemCache.new(host, {:namespace => namespace})
+    @tracking_key = "_#{namespace}_keys" unless @config[:no_tracking] == true
+    raise NotReady unless @memcache.active?
+    true
+  rescue NameError
+    raise NotDefined
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    not cache_get(key).nil?
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    _data = cache_get(key)
+    if _data.nil?
+      _data = _controller.send(:capture, &block)
+      cache_set(key, _data, from_now)
+    end
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to memcache using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    _expire = from_now ? from_now.minutes.from_now.to_i : 0
+    @memcache.set(key, data, _expire)
+    cache_start_tracking(key)
+    Merb.logger.info!("cache: set (#{key})")
+    true
+  end
+
+  # Fetch data from memcache using the specified key
+  # The entry is deleted if it has expired
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # data<String, NilClass>::
+  #   nil is returned whether the entry expired or was not found
+  def cache_get(key)
+    data = @memcache.get(key)
+    if data.nil?
+      Merb.logger.info!("cache: miss (#{key})")
+    else
+      Merb.logger.debug!("cache: hit (#{key})")
+    end
+    data
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    @memcache.delete(key)
+    cache_stop_tracking(key)
+    Merb.logger.info!("cache: expired (#{key})")
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  #
+  # ==== Additional info
+  #   In memcache this requires to keep track of all keys (on by default).
+  #   If you don't need this, set :no_tracking => true in the config.
+  def expire_match(key)
+    Merb.logger.debug!("cache: attempting to expire #{key}")
+    if @tracking_key
+      for _key in get_tracked_keys
+        expire(_key) if /#{key}/ =~ _key
+      end
+    else
+      Merb.logger.info("cache: expire_match is not supported with memcache (set :no_tracking => false in your config")
+    end
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    @memcache.flush_all
+    stop_tracking_keys
+    Merb.logger.info("cache: expired all")
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "memcache"
+  end
+
+  private
+
+  # Store the tracked keys in memcache (used by expire_match)
+  #
+  # ==== Parameter
+  # keys<Array[String]>:: The keys to keep track of
+  def set_tracked_keys(keys)
+    @memcache.set(@tracking_key, keys)
+  end
+
+  # Retrieve tracked keys from memcache
+  #
+  # ==== Returns
+  # keys<Array[String]>:: The tracked keys
+  def get_tracked_keys
+    @memcache.get(@tracking_key) || []
+  end
+
+  # Remove all tracked keys
+  def stop_tracking_keys
+    @memcache.delete(@tracking_key) if @tracking_key
+  end
+
+  # Add a key in the array of tracked keys (used by expire_match)
+  #
+  # ==== Parameter
+  # key<String>:: the key to add
+  def cache_start_tracking(key)
+    return unless @tracking_key
+    keys = get_tracked_keys
+    keys.push(key)
+    set_tracked_keys(keys)
+  end
+
+  # Remove a key from the array of tracked keys (used by expire_match)
+  #
+  # ==== Parameter
+  # key<String>:: the key to remove
+  def cache_stop_tracking(key)
+    return unless @tracking_key
+    keys = get_tracked_keys
+    keys.delete(key)
+    set_tracked_keys(keys)
+  end
+end