cachetastic 2.1.4 → 3.0.0

data/lib/cachetastic/adapters/html_file.rb

@@ -1,68 +0,0 @@
-# This adapter uses the file system as it's backing.
-# Caches are stored in files called index.html.
-# At the beginning of the html the following html comments are pre-pended:
-#   <!-- cachetastic: expires_at: Fri Feb 01 20:51:45 -0500 2008 -->
-#   <!-- cachetastic: key: /channels/1-arts-humanities --> 
-# Obviously the expires_at date will be the ACTUAL expire date,
-# same goes for the key.
-# The configuration for this should look something like this:
-#  my_awesome_cache_options:
-#    debug: false
-#    adapter: html_file
-#    marshall_method: none
-#    default_expiry: <%= 24.hours %>
-#    store_options:  
-#      dir: /usr/local/caches/
-#    logging:
-#      logger_1:
-#        type: file
-#        file: log/file_store_cache.log
-require 'time'
-class Cachetastic::Adapters::HtmlFile < Cachetastic::Adapters::FileBase
-  
-  def get(key)
-    full_path = full_path_from_dir(get_key_directoy(key, false))
-    return nil unless File.exists?(full_path)
-    so = html_to_store_object(File.open(full_path).read)
-    if so
-      if so.invalid?
-        self.delete(key)
-        return nil
-      end
-      return so.value
-    end
-    return nil
-  end
-  
-  def set(key, value, expiry = 0)
-    so = Cachetastic::Adapters::StoreObject.new(key.to_s, value, expiry)
-    File.open(full_path_from_key(key), "w") do |f|
-      f.puts store_object_to_html(so)
-    end
-  end
-  
-  protected
-  def store_file_name
-    return STORE_FILE_NAME
-  end
-  
-  private
-  def html_to_store_object(html)
-    key = html.match(/<!-- cachetastic: key: (.*) -->/).captures.first
-    expires_at = html.match(/<!-- cachetastic: expires_at: (.*) -->/).captures.first
-    html.gsub!(/<!-- cachetastic: key: .* -->/, '')
-    html.gsub!(/<!-- cachetastic: expires_at: .* -->/, '')
-    so = Cachetastic::Adapters::StoreObject.new(key, html, 0)
-    so.expires_at = Time.parse(expires_at)
-    so
-  end
-  
-  def store_object_to_html(so)
-    x = so.value
-    x << "\n<!-- cachetastic: expires_at: #{so.expires_at} -->"
-    x << "\n<!-- cachetastic: key: #{so.key} -->"
-  end
-  
-  STORE_FILE_NAME = "index.html"
-  
-end

data/lib/cachetastic/adapters/memcache.rb

@@ -1,114 +0,0 @@
-# This adapter uses Memcache as it's backing.
-# The configuration for this should look something like this:
-#  my_awesome_cache_options:
-#    debug: false
-#    adapter: memcache
-#    marshall_method: none
-#    default_expiry: <%= 24.hours %>
-#    store_options:  
-#      c_threshold: 10_000
-#      compression: true
-#      debug: false
-#      readonly: false
-#      urlencode: false
-#    logging:
-#      logger_1:
-#        type: file
-#        file: log/memcached.log
-#    servers:
-#      - 127.0.0.1:11211
-class Cachetastic::Adapters::Memcache < Cachetastic::Adapters::Base
-  
-  def setup
-    self.conn = MemCache.new([configuration.servers].flatten, configuration.store_options.to_hash.merge({:namespace => self.namespace}))
-    self.version = self.get_version(self.name)
-  end
-  
-  def set(key, value, expiry = 0, raw = false)
-    self.conn.set(key, value, expiry, raw)
-  end
-  
-  def delete(key, delay = 0)
-    self.conn.delete(key, delay)
-  end
-  
-  def get(key, raw = false)
-    self.conn.get(key, raw)
-  end
-  
-  def expire_all
-    self.increment_version(self.name)
-  end
-  
-  def inspect
-    self.conn.inspect + " <version: #{self.version}> #{self.conn.stats.inspect}"
-  end
-  
-  def valid?
-    begin
-      return (self.conn.active? && self.version == self.get_version(self.name))
-    rescue Exception => e
-      puts e.message
-      puts e.backtrace.join("\n")
-      return false
-    end
-  end
-  
-  def stats
-    super
-    begin
-      puts "Memcache stats for all caches:"
-      memc = self.conn
-      puts Kernel.pp_to_s(memc.stats)
-      paths = `sh -c 'echo $PATH'`
-      paths = paths.split(':')
-      memcached_tool_found = false
-      paths.each do |path|
-        cmd_path = File.expand_path(File.join(path,'memcached_tool'))
-        if File.exists?(cmd_path)
-           memcached_tool_found = true
-          break
-        end
-      end
-      if memcached_tool_found
-        configuration.memcache_servers.each do |server|
-          puts `memcached_tool #{server}`
-        end
-      end
-    rescue
-    end
-    puts ""
-  end
-  
-  protected
-  attr_accessor :conn
-  attr_accessor :version
-  
-  def namespace
-    v = self.get_version(self.name)
-    return "#{name}.#{v}"
-  end
-  
-  def ns_versions
-    ivar_cache do
-      ns_conn = MemCache.new([configuration.servers].flatten, configuration.store_options.to_hash.merge({:namespace => :namespace_versions}))
-    end
-  end
-  
-  def increment_version(name)
-    name = name.to_s
-    v = get_version(name)
-    self.ns_versions.set(name, v + 1)
-  end
-
-  def get_version(name)
-    name = name.to_s
-    v = self.ns_versions.get(name)
-    if v.nil?
-      self.ns_versions.set(name, 1)
-      v = 1
-    end
-    v
-  end
-  
-end

data/lib/cachetastic/adapters/store_object.rb

@@ -1,28 +0,0 @@
-class Cachetastic::Adapters::StoreObject #:nodoc:#
-  attr_accessor :key
-  attr_accessor :value
-  attr_accessor :expires_at
-  
-  def initialize(key, value, expiry)
-    self.key = key
-    self.value = value
-    begin
-      self.expires_at = (Time.now + (expiry == 0 ? (31536000) : expiry)) # 31536000 = one year
-    rescue RangeError => e
-      self.expires_at = Time.at(expiry)
-    end
-    # puts "now: #{Time.now}"
-    # puts "expiry: #{expiry}"
-    # puts "expires_at: #{self.expires_at}"
-  end
-  
-  def size
-    return self.value.size if self.value.respond_to?(:size)
-    -1
-  end
-  
-  def invalid?
-    Time.now >= self.expires_at
-  end
-  
-end

data/lib/cachetastic/caches/base.rb

@@ -1,238 +0,0 @@
-require 'singleton'
-# When creating a new 'Cache' this class should be extended.
-# Once extended you'll only need to override just the methods
-# that are different for your cache.
-#   class MyAwesomeCache < Cachetastic::Caches::Base
-#   end
-#   MyAwesomeCache.set(1, "One")
-#   MyAwesomeCache.get(1) # => "One"
-#   MyAwesomeCache.update(1, "One!!")
-#   MyAwesomeCache.get(1) # => "One!!"
-#   MyAwesomeCache.delete(1)
-#   MyAwesomeCache.get(1) # => nil
-# 
-#   class MyAwesomeCache < Cachetastic::Caches::Base
-#     class << self
-#       def get(key)
-#         super(key) do
-#           set(key, key * 10)
-#         end
-#       end
-#     end
-#   end
-#   MyAwesomeCache.set(1, "One")
-#   MyAwesomeCache.get(1) # => "One"
-#   MyAwesomeCache.delete(1)
-#   MyAwesomeCache.get(1) # => 10
-class Cachetastic::Caches::Base
-
-  # Used to store a list of all the caches registered with the system.
-  # In order for a cache to be registered it must extend Cachetastic::Caches::Base.
-  class RegisteredCaches
-    include Singleton
-    
-    # list of all caches registered with the system.
-    attr_reader :list
-    
-    def initialize
-      @list = []
-    end
-    
-  end
-
-  # everything is done at the class level. there won't be any 'instances of it'
-  # using class << self means we don't have to prefix each method with 'self.'
-  class << self
-    
-    # Returns a list of all registered caches in the system.
-    def all_registered_caches
-      RegisteredCaches.instance.list
-    end
-    
-    # Returns an object from the cache for a given key.
-    # If the object comes back as nil and a block is given
-    # that block will be run and the results of the block
-    # will be run. This can be used to JIT caches, just make
-    # sure in the block to call the set method because the
-    # results of the block are not automatically cached.
-    def get(key, &block)
-      res = nil
-      do_with_logging(:get, key) do
-        retryable(:on => ArgumentError) do
-          begin
-            res = adapter.get(key.to_s)
-            if res.nil?
-              res = yield key if block_given?
-            else
-              res = unmarshall(res)
-            end
-            res
-          rescue ArgumentError => e
-            m = e.message.match(/class\/module .*/)
-            if m
-              m = m.to_s
-              m.gsub!("class/module", '')
-              m.gsub!("(ArgumentError)", '')
-              require m.strip.underscore
-              raise e
-            end
-          rescue Exception => e
-            raise e
-          end
-        end
-      end
-      res
-    end
-    
-    # Set a particular object info the cache for the given key.
-    # An optional third parameter sets the expiry time for the object in the cache.
-    # The default for this expiry is set as either 0, meaning it never expires, or
-    # if there's a default_expiry time set in the config file, that file will be
-    # used.
-    # If there is an expiry_swing set in the config file it will be +/- to the
-    # expiry time. See also: calculate_expiry_time
-    def set(key, value, expiry = adapter.configuration.retrieve(:default_expiry, 0))
-      do_with_logging(:set, key) do
-        expiry = calculate_expiry_time(expiry)
-        adapter.set(key.to_s, marshall(value), expiry.to_i)
-        logger.info('', '', :expiry, cache_name, key, expiry.to_i)
-        value
-      end
-    end
-    
-    alias_method :put, :set
-    
-    # Deletes an object from the cache. The optional delay parameter
-    # sets an offset, in seconds, for when the object should get deleted.
-    # The default of 0 means the object gets deleted right away.
-    def delete(key, delay = 0)
-      do_with_logging(:delete, key) do
-        adapter.delete(key.to_s, delay)
-      end
-    end
-    
-    # Expires all objects for this cache.
-    def expire_all
-      adapter.expire_all
-      logger.info('', '', :expired, cache_name)
-    end
-    
-    # Raises a MethodNotImplemented exception. This method should be overridden
-    # in the child class to enable a populating the cache with all things that
-    # should be in there. 
-    needs_method :populate_all
-    
-    # A convenience method that returns statistics for the underlying Cachetastic::Adapters::Base for the cache.
-    def stats
-      adapter.stats
-    end
-    
-    # Returns a 'methodize' version of the cache's class name. This gets used in logging,
-    # namespacing, and as the key in the Cachetastic::Connection class.
-    #   MyAwesomeCache.cache # => "my_awesome_cache"
-    #   Cachetastic::Caches::Base # => "cachetastic_caches_base"
-    def cache_name
-      self.name.methodize
-    end
-    
-    # Returns the underlying Cachetastic::Adapters::Base for this cache.
-    def adapter
-      a = cache_conn_instance.get(cache_name)
-      if adapter_supported?(a.class)
-        return a
-      else
-        raise Cachetastic::Errors::UnsupportedAdapter.new(cache_name, a.class)
-      end
-    end
-    
-    # Returns the Cachetastic::Logger for the underlying Cachetastic::Adapters::Base.
-    def logger
-      adapter.logger
-    end
-    
-    # Returns an array of unsupported adapters for this cache. Defaults to an empty
-    # array which will let any adapter be used by the cache. Override in your specific
-    # cache to prevent certain adapters.
-    def unsupported_adapters
-      []
-    end
-    
-    # Returns true/false on whether the adapter you want to use is supported for the cache.
-    def adapter_supported?(a = cache_conn_instance.get(cache_name).class)
-      return !unsupported_adapters.include?(a)
-    end
-    
-    def marshall(value)
-      return value if value.nil?
-      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
-      when :yaml
-        YAML.dump(value)
-      when :ruby
-        Marshal.dump(value)
-      else
-        value
-      end
-    end
-    
-    def unmarshall(value)
-      return value if value.nil?
-      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
-      when :yaml
-        YAML.load(value)
-      when :ruby
-        Marshal.load(value)
-      else
-        value
-      end
-    end
-    
-    private
-    # If the expiry time is set to 60 minutes and the expiry_swing time is set to
-    # 15 minutes, this method will return a number between 45 minutes and 75 minutes.
-    def calculate_expiry_time(expiry) # :doc:
-      exp_swing = adapter.configuration.retrieve(:expiry_swing, 0)
-      if exp_swing && exp_swing != 0
-        swing = rand(exp_swing.to_i)
-        case rand(2)
-        when 0
-          expiry = (expiry.to_i + swing)
-        when 1
-          expiry = (expiry.to_i - swing)
-        end
-      end
-      expiry
-    end
-    
-    def inherited(child)
-      # puts "child: #{child.inspect}"
-      all_registered_caches << child.to_s
-      # puts "all_registered_caches: #{all_registered_caches.inspect}"
-    end
-    
-    def cache_conn_instance
-      Cachetastic::Connection.instance
-    end
-    
-    def do_with_logging(action, key)
-      start_time = Time.now
-      logger.info(:starting, action, cache_name, key)
-      res = yield if block_given?
-      end_time = Time.now
-      str = ""
-      unless res.nil?
-        str = "[#{res.class.name}]"
-        str << "\t[Size = #{res.size}]" if res.respond_to? :size
-        str << "\t" << res.inspect if adapter.debug?
-      end
-      logger.info(:finished, action, cache_name, key, (end_time - start_time), str)
-      res
-    end
-    
-    # make sure people can't instaniate this object!
-    def new(*args)
-      raise NoMethodError.new("You can not instaniate this class!")
-    end
-    
-  end
-
-end