super_cache 0.0.1 → 0.0.2

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.2  
+  - 1.9.3

data/Gemfile

@@ -1,4 +1,8 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
+#source 'http://ruby.taobao.org'
 
 # Specify your gem's dependencies in super_cache.gemspec
 gemspec
+gem 'rake'
+gem 'rails', '~> 3.1'
+#gem 'mocha', :require => false

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/ShiningRay/super_cache.png?branch=master)](https://travis-ci.org/ShiningRay/super_cache)
+
 # SuperCache
 
 SuperCache for rails is a caching middleware inspired by the "SuperCache" plugin
@@ -25,7 +27,8 @@ Just call `super_caches_page` inside your controller with the action names to be
 class MyController < ApplicationController
   super_caches_page :index
   def index
-    # action to be 
+    # action to be cached
+    @expires_in = 1.hour
   edn
 end
 ```
@@ -33,6 +36,11 @@ end
 Super_cache will store the response body into `Rails.cache`. The next time requesting
 that action will get the same result.
 
+There are several instance variables can be used for controlling the cache:
+
+* `@cache_path` control the cache key, defaults to the request uri.
+* `@expires_in` control the expiration time, now defaults to 600 sec.
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1 +1,24 @@
+# encoding: UTF-8
+
 require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test
+
+desc 'Generate documentation for InheritedResources.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InheritedResources'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/super_cache/dog_pile_filter.rb

@@ -0,0 +1,100 @@
+module SuperCache
+  class DogPileFilter
+    attr_accessor :options
+    def initialize(options={})
+      self.options = options
+    end
+    # 1. check the expiration info of target key
+    # 2. if target key is expired, add a lock against target key
+    # 2.1 if not expired, return the cache
+    # 3.1 if lock successfully, then continue to action 
+    # 3.2 if lock failed, then obtain target key
+    # 3.2.1 if target key is missing, then
+    # 3.2.1.1  wait for N sec to check if the cache is generated
+    # 3.2.1.1.1 if timeout, go to action
+    # 3.2.2 target key is not missing, return the cache
+    # 3.3 go to the action and obtain response body
+    # 3.4 store the response body to the target key and set the expiration with 2x longer
+    # 3.5 store the expireation info of target key
+    def filter(controller, action=nil, &block)
+      action ||= block
+      return action.call unless controller.perform_caching
+      options = self.options.dup
+
+      options[:controller] = controller
+      options[:action] = action || block
+      options[:cache_path] ||= weird_cache_path(options)
+      options[:flag_key] = "expires_at:#{options[:cache_path]}"
+      options[:expires_in] ||= 600
+      options[:content] = nil
+
+      if Rails.cache.read(options[:flag_key], :raw => true) 
+        check_cache(options)
+      else
+        cache_expired(options)
+      end
+    end
+
+    protected
+    def write_cache(options)
+      response = options[:controller].response
+      return if response.status.to_i != 200
+      expires_in = options[:expires_in].to_i
+      Rails.cache.write(options[:flag_key], expires_in, :raw => true, :expires_in => expires_in)
+      Rails.cache.write(options[:cache_path], response.body, :raw => true, :expires_in => expires_in * 2)      
+    end
+
+    def check_cache(options)
+      if options[:content] = Rails.cache.read(options[:cache_path], :raw => true) and options[:content].size > 0
+        cache_hit(options)
+      else
+        cache_miss(options)
+      end             
+    end    
+
+    def cache_hit(options)
+      controller = options[:controller]
+      request = controller.request
+      headers = controller.headers
+      content = options[:content]
+      Rails.logger.info "Hit #{options[:cache_path]}"
+      headers['Content-Length'] ||= content.size.to_s
+      headers['Content-Type'] ||= request.format.to_s.strip unless  request.format == :all
+      controller.send :render, :text => content, :content_type => 'text/html'
+    end
+
+    #when the target cache is not established yet
+    def cache_miss(options)
+      Lock.synchronize(options[:cache_path]) do
+        options[:action].call
+        write_cache(options)
+      end
+    rescue Lock::MaxRetriesError
+      options[:action].call
+      write_cache(options)
+    end
+
+    # the cache is expired
+    def cache_expired(options) 
+      if Lock.acquire_lock(options[:cache_path])
+        options[:action].call
+        write_cache(options)
+      else
+        # haven't acquired lock, return stale cache
+        check_cache(options)
+      end
+    end
+
+    def weird_cache_path(options)
+      controller = options[:controller]
+      request = controller.request
+      path = File.join request.host, request.path
+      q = request.query_string
+      request.format ||= :html
+      format = request.format.to_sym
+      path = "#{path}.#{format}" if format != :html and format != :all and controller.params[:format].blank?
+      path = "#{path}?#{q}" if !q.empty? && q =~ /=/
+      path
+    end    
+  end
+end

data/lib/super_cache/lock.rb

@@ -0,0 +1,44 @@
+module SuperCache
+  class Lock
+    class MaxRetriesError < RuntimeError; end
+
+    DEFAULT_RETRY = 5
+    DEFAULT_EXPIRY = 30
+    
+    class << self
+      def synchronize(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY)
+        if recursive_lock?(key)
+          yield
+        else
+          begin
+            retries.times do |count|
+              return yield if acquire_lock(key, lock_expiry)
+              raise MaxRetriesError if count == retries - 1
+              exponential_sleep(count) unless count == retries - 1
+            end
+            raise MaxRetriesError, "Couldn't acquire memcache lock for: #{key}"      
+          ensure
+            release_lock(key)
+          end
+        end
+      end
+
+      def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY)
+        Rails.cache.write("lock/#{key}", Process.pid, :unless_exist => true, :expires_in => lock_expiry)
+      end
+
+      def release_lock(key)
+        Rails.cache.delete("lock/#{key}")
+      end
+
+      def exponential_sleep(count)
+        Benchmark::measure { sleep((2**count) / 5.0) }
+      end
+
+      private
+      def recursive_lock?(key)
+        Rails.cache.read("lock/#{key}") == Process.pid
+      end
+    end
+  end
+end

data/lib/super_cache/simple_filter.rb

@@ -0,0 +1,48 @@
+module SuperCache
+  class SimpleFilter
+    def initialize(options={})
+      
+    end
+
+    def filter(controller)
+      return yield unless controller.perform_caching
+      @cache_path = controller.instance_variable_get('@caches_path') || weird_cache_path(controller)
+      request = controller.request
+      response = controller.response
+      headers = response.headers
+
+      if content = Rails.cache.read(@cache_path, :raw => true)
+        return yield if content.size <= 0
+        Rails.logger.debug "Hit #{@cache_path}"
+        headers['Content-Length'] ||= content.size.to_s
+        headers['Content-Type'] ||= request.format.to_s.strip unless  request.format == :all
+        controller.send :render, :text => content, :content_type => 'text/html'
+        return false
+      else
+        yield
+        body = response.body.to_s
+        return if controller.instance_variable_get('@no_cache') || body.size == 0 || response.status.to_i != 200        
+        @expires_in = controller.instance_variable_get('@expires_in') || 600 
+        Rails.logger.debug("Write #{@cache_path}")
+        Rails.cache.write(@cache_path, body, :raw => true, :expires_in => @expires_in.to_i)            
+      end
+    rescue ArgumentError => e
+      @no_cache = true
+      Rails.logger.info e.to_s
+      Rails.logger.debug {e.backtrace}
+    end
+
+    private
+      def weird_cache_path(controller)
+        controller.instance_eval do
+          path = File.join request.host, request.path
+          q = request.query_string
+          request.format ||= :html
+          format = request.format.to_sym
+          path = "#{path}.#{format}" if format != :html and format != :all and params[:format].blank?
+          path = "#{path}?#{q}" if !q.empty? && q =~ /=/
+          path          
+        end
+      end    
+  end
+end

data/lib/super_cache/version.rb

@@ -1,3 +1,3 @@
 module SuperCache
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/super_cache.rb

@@ -4,7 +4,12 @@ require 'fileutils'
 # for static-caching the generated html pages
 
 module SuperCache
+  autoload :Lock,          'super_cache/lock'
+  autoload :DogPileFilter, 'super_cache/dog_pile_filter'
+  autoload :SimpleFilter,  'super_cache/simple_filter'
+
   def self.included(base)
+    base.class_attribute :cache_filter
     base.extend(ClassMethods)
   end
 
@@ -13,66 +18,21 @@ module SuperCache
       return unless perform_caching
       options = pages.extract_options!
       options[:only] = (Array(options[:only]) + pages).flatten
-      before_filter :check_weird_cache, options
-      after_filter :weird_cache, options
+      self.cache_filter = if options.delete(:lock)
+         DogPileFilter.new
+      else
+        SimpleFilter.new
+      end
+      around_filter self.cache_filter, options
     end
 
     def skip_super_caches_page(*pages)
+      return unless self.cache_filter
       options = pages.extract_options!
       options[:only] = (Array(options[:only]) + pages).flatten
-      skip_before_filter :check_weird_cache, options
-      skip_after_filter :weird_cache, options
-    end
-  end
-
-  def check_weird_cache
-    return unless perform_caching
-    @cache_path ||= weird_cache_path
-    
-    if content = Rails.cache.read(@cache_path, :raw => true)
-      return if content.size <= 1
-      logger.info "Hit #{@cache_path}"
-
-      headers['Content-Length'] ||= content.size.to_s
-      headers['Content-Type'] ||= request.format.to_s.strip unless  request.format == :all
-      render :text => content, :content_type => 'text/html'
-      return false
+      skip_around_filter self.cache_filter, options
     end
-  rescue ArgumentError => e
-    @no_cache = true
-    logger.info e.to_s
-    logger.debug {e.backtrace}
   end
-
-  def weird_cache
-    return if @no_cache
-    return unless perform_caching
-    return if request.format.to_sym == :mobile
-    @cache_path ||= weird_cache_path
-    @expires_in ||= 600
-    return if response.body.size <= 1
-    return if response.respond_to?(:status) and response.status.to_i != 200
-    #benchmark "Super Cached page: #{@cache_path}" do
-    #  @cache_subject = Array(@cache_subject)
-    #  @cache_subject.compact.flatten.select{|s|s.respond_to?(:append_cached_key)}.each do |subject|
-    #    subject.append_cached_key @cache_path
-    #  end
-    Rails.cache.write(@cache_path, response.body, :raw => true, :expires_in => @expires_in.to_i)
-    #end
-  end
-
-  protected :check_weird_cache
-  protected :weird_cache
-  private
-    def weird_cache_path
-      path = File.join request.host, request.path
-      q = request.query_string
-      request.format ||= :html
-      format = request.format.to_sym
-      path = "#{path}.#{format}" if format != :html and format != :all and params[:format].blank?
-      path = "#{path}?#{q}" #if !q.empty? && q =~ /=/
-      path
-    end
 end
 
 ActionController::Base.__send__ :include, SuperCache

data/super_cache.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |gem|
   gem.authors       = ["ShiningRay"]
   gem.email         = ["tsowly@hotmail.com"]
   gem.description   = %q{A simple caching middleware for rails}
-  gem.summary       = %q{A simple caching middleware for rails}
+  gem.summary       = %q{A simple caching middleware for rails, with solution for dog-pile effect}
   gem.homepage      = "https://github.com/shiningray/super_cache"
 
   gem.files         = `git ls-files`.split($/)

data/test/dog_pile_filter_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+require File.expand_path('my_controller', File.dirname(__FILE__))
+
+class MyController < ApplicationController
+  around_filter do |controller, action |
+    DogPileFilter.new.filter(controller, action)
+  end
+end
+
+class DogPileFilterTest < ActionController::TestCase
+  tests MyController
+  setup do
+    MyController.counter = 0
+  end  
+  test "should get index successfully and store cache and then get the cached version" do
+    get :index
+    assert_response :success
+    assert_equal '0', @response.body.strip
+    assert_equal '0', Rails.cache.read('test.host/my', :raw => true)
+    get :index
+    assert_response :success
+    assert_equal '0', @response.body.strip
+  end 
+  test "should not cache when performing cache is disabled" do
+    ActionController::Base.perform_caching=false
+    get :index
+    assert_response :success
+    assert_equal '0', @response.body.strip
+    assert_nil Rails.cache.read('test.host/my', :raw => true)
+    ActionController::Base.perform_caching=true
+  end
+  test "should not cache when response is redirected" do
+    get :redirect
+    assert_response :redirect
+    assert_nil Rails.cache.read('test.host/redirect', :raw => true)
+  end
+end

data/test/locales/en.yml

@@ -0,0 +1,2 @@
+en:
+  flash:

data/test/my_controller.rb

@@ -0,0 +1,10 @@
+class MyController < ApplicationController
+  cattr_accessor :counter
+  def index
+    render :text => counter
+    self.counter += 1
+  end
+  def redirect
+    redirect_to :action => :index
+  end
+end

data/test/super_cache_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path('test_helper', File.dirname(__FILE__))
+require File.expand_path('my_controller', File.dirname(__FILE__))
+class MyController
+  super_caches_page :index
+end
+class SuperCacheTest < ActionController::TestCase
+  tests MyController
+  setup do
+    MyController.counter = 0
+  end
+  test "should get index successfully and store cache and then get the cached version" do
+    get :index
+    assert_response :success
+    assert_equal '0', @response.body.strip
+    assert_equal '0', Rails.cache.read('test.host/my', :raw => true)
+    get :index
+    assert_response :success    
+    assert_equal '0', @response.body.strip
+    Rails.cache.delete('test.host/my')
+    get :index
+    assert_response :success
+    assert_equal '1', @response.body.strip
+    assert_equal '1', Rails.cache.read('test.host/my', :raw => true)
+  end 
+  test "should not cache when performing cache is disabled" do
+    ActionController::Base.perform_caching=false
+    get :index
+    assert_response :success
+    assert_equal '0', @response.body.strip
+    assert_nil Rails.cache.read('test.host/my', :raw => true)
+    ActionController::Base.perform_caching=true
+  end
+  test "should not cache when response is redirected" do
+    get :redirect
+    assert_response :redirect
+    assert_nil Rails.cache.read('test.host/redirect', :raw => true)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'test/unit'
+#require 'mocha/setup'
+
+ENV["RAILS_ENV"] = "test"
+RAILS_ROOT = "anywhere"
+
+require "active_support"
+require "active_model"
+require "action_controller"
+
+I18n.load_path << File.join(File.dirname(__FILE__), 'locales', 'en.yml')
+I18n.reload!
+
+class ApplicationController < ActionController::Base; end
+class Rails
+  cattr_accessor :cache, :logger
+  @@cache = ActiveSupport::Cache::MemoryStore.new
+  @@logger = Logger.new($stderr)
+end
+# Add IR to load path and load the main file
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'super_cache'
+
+ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+ActionController::Base.perform_caching=true
+SuperCache::Routes = ActionDispatch::Routing::RouteSet.new
+SuperCache::Routes.draw do
+  match ':controller(/:action(/:id))'
+  match ':controller(/:action)'
+  resources 'posts'
+  root :to => 'posts#index'
+end
+
+ActionController::Base.send :include, SuperCache::Routes.url_helpers
+
+class ActionController::TestCase
+  setup do
+    @routes = SuperCache::Routes
+    @request.host = 'test.host'
+    Rails.cache.clear
+  end
+end

metadata

@@ -1,53 +1,86 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: super_cache
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
-authors:
+authors: 
 - ShiningRay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+
+date: 2013-03-08 00:00:00 Z
 dependencies: []
+
 description: A simple caching middleware for rails
-email:
+email: 
 - tsowly@hotmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/super_cache.rb
+- lib/super_cache/dog_pile_filter.rb
+- lib/super_cache/lock.rb
+- lib/super_cache/simple_filter.rb
 - lib/super_cache/version.rb
 - super_cache.gemspec
+- test/dog_pile_filter_test.rb
+- test/locales/en.yml
+- test/my_controller.rb
+- test/super_cache_test.rb
+- test/test_helper.rb
 homepage: https://github.com/shiningray/super_cache
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
-summary: A simple caching middleware for rails
-test_files: []
+summary: A simple caching middleware for rails, with solution for dog-pile effect
+test_files: 
+- test/dog_pile_filter_test.rb
+- test/locales/en.yml
+- test/my_controller.rb
+- test/super_cache_test.rb
+- test/test_helper.rb