cachetastic 1.0.5

data/init.rb

@@ -0,0 +1 @@
+#require 'cachetastic'

data/lib/caches/cachetastic_caches_base.rb

@@ -0,0 +1,108 @@
+class Cachetastic::Caches::Base
+
+  # 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
+    
+    def get(key)
+      res = nil
+      do_with_logging(:get, key) do
+        res = store.get(key.to_s)
+        if res.nil?
+          res = yield if block_given?
+        else
+          res = unmarshall(res)
+        end
+      end
+      res
+    end
+    
+    def set(key, value, expiry = (store.all_options["default_expiry"] || 0))
+      do_with_logging(:set, key) do
+        exp_swing = store.all_options["expiry_swing"]
+        if exp_swing
+          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
+        store.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
+    
+    def delete(key, delay = 0)
+      do_with_logging(:delete, key) do
+        store.delete(key.to_s, delay)
+      end
+    end
+    
+    def expire_all
+      store.expire_all
+      logger.info('', '', :expired, cache_name)
+    end
+    
+    def cache_name
+      self.name.methodize
+    end
+
+    def store
+      cache_conn_instance.get(cache_name)
+    end
+    
+    def logger
+      store.logger
+    end
+    
+    private
+    def marshall(value)
+      return case store.all_options["marshall_method"]
+      when "yaml"
+        YAML.dump(value)
+      else
+        value
+      end
+    end
+    
+    def unmarshall(value)
+      return case store.all_options["marshall_method"]
+      when "yaml"
+        YAML.load(value)
+      else
+        value
+      end
+    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 store.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 MethodNotImplemented.new("You can not instaniate this class!")
+    end
+    
+  end
+
+end

data/lib/caches/cachetastic_caches_page_cache.rb

@@ -0,0 +1,3 @@
+class Cachetastic::Caches::PageCache < Cachetastic::Caches::Base
+  
+end

data/lib/caches/cachetastic_caches_rails_session_cache.rb

@@ -0,0 +1,3 @@
+class Cachetastic::Caches::RailsSessionCache < Cachetastic::Caches::Base
+  
+end

data/lib/cachetastic.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'memcache'
+require 'singleton'
+require 'logger'
+require 'yaml'
+require 'zlib'
+require 'pp'
+
+module Cachetastic
+  module Caches
+    module ActiveRecord
+    end
+  end
+  module Stores
+  end
+  module Helpers
+    module ActiveRecord
+    end
+  end
+end
+
+require 'cachetastic_connection'
+require 'cachetastic_logger'
+require 'caches/cachetastic_caches_base'
+require 'caches/cachetastic_caches_page_cache'
+require 'caches/cachetastic_caches_rails_session_cache'
+require 'stores/cachetastic_stores_base'
+require 'stores/cachetastic_stores_memcache'
+require 'stores/cachetastic_stores_local_memory'
+require 'helpers/cachetastic_helpers_active_record'
+require 'rails_extensions/cachetastic_active_record_base'
+require 'rails_extensions/cgi_session_cachetastic_store'

data/lib/cachetastic_connection.rb

@@ -0,0 +1,20 @@
+class Cachetastic::Connection
+  include Singleton
+  
+  attr_accessor :connections
+  
+  def initialize
+    self.connections = {}
+  end
+  
+  def get(name)
+    name = name.to_sym
+    conn = self.connections[name]
+    return conn if conn && conn.valid?
+    store = Cachetastic::Stores::Base.get_options(name)["store"].camelcase
+    conn = "Cachetastic::Stores::#{store}".constantize.new(name)
+    self.connections[name] = conn
+    return conn
+  end
+  
+end

data/lib/cachetastic_logger.rb

@@ -0,0 +1,51 @@
+class Cachetastic::Logger
+  
+  attr_accessor :options
+  attr_accessor :cache_name
+  
+  def initialize(options, cache_name)
+    self.options = options
+    # puts "self.options = #{self.options.inspect}"
+    self.cache_name = cache_name
+    self.options.each_pair do |n, opts|
+      # puts "opts: #{opts.inspect}"
+      # puts "asdfasfsadfaf opts[\"level\"] = #{opts["level"]}"
+      opts["level"] = (opts["level"] ||= "info").to_sym
+    end
+  end
+  
+  LOG_LEVELS = [:fatal, :error, :warn, :info, :debug]
+  
+  LOG_LEVELS.each do |level|
+    define_method(level) do |*args|
+      # puts "logging for: #{level}"
+      lm = "[CACHE] [#{level.to_s.upcase}]\t#{Time.now.strftime("%m/%d/%y %H:%m:%S")}"
+      exs = []
+      args.each do |arg|
+        if arg.is_a?(Exception)
+          exs << arg
+          continue
+        end
+        lm << "\t" << arg.to_s 
+      end
+      exs.each do |ex|
+        lm << "\n#{ex.message}\n" << ex.backtrace.join("\n")
+      end
+      self.options.each_pair do |n, opts|
+        # puts "opts[\"level\"]: #{opts["level"]}"
+        # # if level == opts["level"]
+        # puts "LOG_LEVELS.index(opts[\"level\"]): #{LOG_LEVELS.index(opts["level"])} (#{opts["level"]})"
+        # puts "LOG_LEVELS.index(level): #{LOG_LEVELS.index(level)} (#{level})"
+        if LOG_LEVELS.index(opts["level"]) >= LOG_LEVELS.index(level)
+          case opts["type"]
+          when "file"
+            File.open(opts["file"], "a") {|f| f.puts(lm)} 
+          when "console"
+            puts lm
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/helpers/cachetastic_helpers_active_record.rb

@@ -0,0 +1,35 @@
+module Cachetastic
+  module Helpers
+    module ActiveRecord
+      
+      def cache_class
+        n = self.class.name
+        n = self.name if n == "Class"
+        # puts "n: #{n}"
+        c_name = "Cachetastic::Caches::ActiveRecord::#{n}Cache"
+        unless Cachetastic::Caches::ActiveRecord.const_defined?("#{n}Cache")
+          # puts "we need to create a cache for: #{c_name}"
+          eval %{
+            class #{c_name} < Cachetastic::Caches::Base
+            end
+          }
+        end
+        c_name.constantize
+      end
+      
+      def cache(key, expiry = 0)
+        cache_class.get(key) do
+          if block_given?
+            res = yield
+            cache_class.set(key, res, expiry)
+          end
+        end
+      end
+      
+      def expire_all
+        cache_class.expire_all
+      end
+      
+    end
+  end
+end

data/lib/rails_extensions/cachetastic_active_record_base.rb

@@ -0,0 +1,37 @@
+class ActiveRecord::Base
+  
+  include Cachetastic::Helpers::ActiveRecord # include helpers at instance level
+  
+  class << self
+    include Cachetastic::Helpers::ActiveRecord # include helpers at class level
+    
+    def get_from_cache(key, self_populate = false)
+      res = cache_class.get(key)
+      if res.nil? && self_populate
+        res = self.name.constantize.find(key)
+        unless res.nil?
+          res.cache_self
+        end
+      end
+      res
+    end
+    
+    def delete_from_cache(key)
+      cache_class.delete(key)
+    end
+    
+    def set_into_cache(key, value, expiry = 0)
+      cache_class.set(key, value, expiry)
+    end
+    
+  end
+  
+  def cache_self
+    cache_class.set(self.id, self) unless self.new_record?
+  end
+  
+  def uncache_self
+    cache_class.delete(self.id) unless self.new_record?
+  end
+  
+end

data/lib/rails_extensions/cgi_session_cachetastic_store.rb

@@ -0,0 +1,54 @@
+require 'cgi'
+require 'cgi/session'
+ 
+class CGI #:nodoc:all
+  class Session
+    class CachetasticStore
+ 
+      def check_id(id) #:nodoc:#
+        /[^0-9a-zA-Z]+/ =~ id.to_s ? false : true
+      end
+      
+      def initialize(session, options = {})
+        id = session.session_id
+        unless check_id(id)
+          raise ArgumentError, "session_id '%s' is invalid" % id
+        end
+        
+        @session_key = id
+        
+        @session_data = {}
+      end
+ 
+      # Restore session state from the session's memcache entry.
+      #
+      # Returns the session state as a hash.
+      def restore
+        @session_data = Cachetastic::Caches::RailsSessionCache.get(@session_key) do
+          {}
+        end
+      end
+
+      # Save session state to the session's memcache entry.
+      def update
+        Cachetastic::Caches::RailsSessionCache.set(@session_key, @session_data)
+      end
+    
+      # Update and close the session's memcache entry.
+      def close
+        update
+      end
+
+      # Delete the session's memcache entry.
+      def delete
+        Cachetastic::Caches::RailsSessionCache.delete(@session_key)
+        @session_data = {}
+      end
+      
+      def data
+        @session_data
+      end
+
+    end
+  end
+end

data/lib/stores/cachetastic_stores_base.rb

@@ -0,0 +1,70 @@
+class Cachetastic::Stores::Base
+  
+  attr_reader :all_options
+  attr_reader :store_options
+  attr_reader :servers
+  attr_reader :name
+  attr_reader :logging
+  attr_reader :logger
+  
+  def initialize(name)
+    @name = name
+    configure
+    setup
+    if self.debug?
+      self.logger.debug(self.name, :self, self.inspect)
+      self.logger.debug(self.name, :options, self.all_options.inspect)
+    end
+  end
+  
+  def valid?
+    false
+  end
+
+  [:setup, :set, :get, :delete, :expire_all].each do |meth|
+    define_method(meth) do |*args|
+      raise MethodNotImplemented.new(meth)
+    end
+  end
+  
+  def debug?
+    ivar_cache(:debug) do
+      (self.all_options["debug"] == true || false)
+    end
+  end
+  
+  def configure
+    @all_options = Cachetastic::Stores::Base.get_options(self.name)
+    @store_options = (self.all_options["store_options"] || {})
+    @servers = self.all_options["servers"]
+    @logging = (self.all_options["logging"] || {})
+    @logger = Cachetastic::Logger.new(self.logging, self.name)
+  end
+  
+  # def log(mess, ex = nil)
+  #   self.logging.each_pair do |n, opts|
+  #     
+  #     lm = "[CACHE]\t#{Time.now}:\t#{mess}"
+  #     lm << "\n#{ex.message}\n" << ex.backtrace.join("\n") if ex
+  #     
+  #     case opts["type"]
+  #     when "file"
+  #       File.open(opts["file"], "a") {|f| f.puts(lm)}
+  #     when "console"
+  #       puts lm
+  #     end
+  #   end
+  # end
+  
+  
+  
+  class << self
+    def get_options(name)
+      options = app_config.cachetastic_default_options
+      options.merge!(app_config.send(name.methodize + "_options") || {})
+      options = {"store" => "local_memory"}.merge(options)
+      options
+    end
+  end
+  
+end

data/lib/stores/cachetastic_stores_local_memory.rb

@@ -0,0 +1,71 @@
+class Cachetastic::Stores::LocalMemory < Cachetastic::Stores::Base
+  
+  attr_accessor :local_store
+  
+  def valid?
+    true
+  end
+
+  def setup
+    self.local_store = {}
+  end
+  
+  def expire_all
+    self.local_store = {}
+  end
+  
+  def get(key)
+    so = self.local_store[key.to_s]
+    if so
+      if Time.now >= so.expires_at
+        self.delete(key)
+        return nil
+      end
+      return so.value
+    end
+    return nil
+  end
+  
+  def set(key, value, expiry = 0)
+    self.local_store[key.to_s] = StoreObject.new(key.to_s, value, expiry)
+  end
+  
+  def delete(key, delay = 0)
+    if delay <= 0
+      self.local_store.delete(key.to_s)
+    else
+      so = self.get(key)
+      if so
+        self.set(so.key, so.value, delay)
+      end
+    end
+  end
+
+  private
+  class StoreObject
+    attr_accessor :key
+    attr_accessor :value
+    attr_accessor :expires_at
+    
+    def initialize(key, value, expiry)
+      # puts "expiry: #{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
+    
+  end
+  
+end

data/lib/stores/cachetastic_stores_memcache.rb

@@ -0,0 +1,67 @@
+class Cachetastic::Stores::Memcache < Cachetastic::Stores::Base
+  
+  def setup
+    self.conn = MemCache.new(self.servers, self.store_options.merge({:namespace => self.namespace}))
+    self.version = self.get_version(self.name)
+  end
+  
+  def set(key, value, expiry = 0)
+    self.conn.set(key, value, expiry)
+  end
+  
+  def delete(key, delay = 0)
+    self.conn.delete(key, delay)
+  end
+  
+  def get(key)
+    self.conn.get(key)
+  end
+  
+  def expire_all
+    self.increment_version(self.name)
+  end
+  
+  def inspect
+    self.conn.inspect + " <version: #{self.version}> #{self.conn.stats.inspect}"
+  end
+  
+  def namespace
+    v = self.get_version(self.name)
+    return "#{name}.#{v}"
+  end
+  
+  def valid?
+    begin
+      return (self.active? && self.version == self.get_version(self.name))
+    rescue Exception => e
+      return false
+    end
+  end
+  
+  protected
+  attr_accessor :conn
+  attr_accessor :version
+  
+  def ns_versions
+    ivar_cache do
+      ns_conn = MemCache.new(self.servers, self.store_options.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/tasks/rubyforge_config.yml

@@ -0,0 +1,5 @@
+--- !ruby/object:RubyForgeConfig 
+gem_name: cachetastic
+package: cachetastic
+project: magrathea
+version: 1.0.5

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: cachetastic
+version: !ruby/object:Gem::Version 
+  version: 1.0.5
+date: 2007-12-28 00:00:00 -05:00
+summary: cachetastic
+require_paths: 
+- lib
+- lib
+email: 
+homepage: 
+rubyforge_project: magrathea
+description: "cachetastic was developed by: markbates"
+autorequire: 
+- cachetastic
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- markbates
+files: 
+- init.rb
+- lib/caches/cachetastic_caches_base.rb
+- lib/caches/cachetastic_caches_page_cache.rb
+- lib/caches/cachetastic_caches_rails_session_cache.rb
+- lib/cachetastic.rb
+- lib/cachetastic_connection.rb
+- lib/cachetastic_logger.rb
+- lib/helpers/cachetastic_helpers_active_record.rb
+- lib/rails_extensions/cachetastic_active_record_base.rb
+- lib/rails_extensions/cgi_session_cachetastic_store.rb
+- lib/stores/cachetastic_stores_base.rb
+- lib/stores/cachetastic_stores_local_memory.rb
+- lib/stores/cachetastic_stores_memcache.rb
+- lib/tasks/rubyforge_config.yml
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+