rack-cache-buster 0.1.0 → 0.2.0

data/README.markdown

@@ -1,25 +1,17 @@
 # Rack::CacheBuster
 
-Place this in your rack stack and all caching will be gone.
-
-Add an optional key to salt the ETags in and out of your app.
-
-## Usage:
-    use Rack::CacheBuster, APP_VERSION
-
-# Rack::CacheBuster::Auto
-
 Use to wind down a running app when needed.
 
-Busts the cache when enabled file exists, salts the ETags when key_file exists.
+Limits the max-age to the contents of the `WIND_DOWN` file, and salts the ETags to unsure clients see different deployments as having different contents.
 
 ## Usage:
+    require "rack/cache_buster"
+    WIND_DOWN_TIME = Time.parse(File.read(File.join(Rails.root, "WIND_DOWN"))) rescue nil
+    APP_VERSION    = File.read(File.join(Rails.root, "REVISION")) rescue nil
+    
+    …
 
-### Setup:
-
-ensure you have a REVISION file on your production servers, capistrano does this by default.
-
-    use Rack::CacheBuster::Auto, File.join(Rails.root, "REVISION"), File.join(Rails.root, "WIND_DOWN")
+    use Rack::CacheBuster, APP_VERSION, WIND_DOWN_TIME
 
 ### Before you deploy:
 
@@ -29,6 +21,10 @@ ensure you have a REVISION file on your production servers, capistrano does this
 
 * Restart all instances (touch tmp/restart.txt will be fine for passenger apps).
 
-During this period all caching will be disabled. If you respect If-Modified (using `stale?` in rails for example), these will still be respected.
+* Once all the caches should have expired you can deploy as normal.
+
+## Notes
+
+If you are using Rack::Cache, you can safely put the CacheBuster below it in the stack, but only if you clear Rack::Cache's cache upon deploy.
 
-Once all the caches should have expired you can deploy as normal.
+This is actually the recommended approach as it will prevent the increased amount of hits between `WIND_DOWN_TIME` and your actual deployment from making it through to your app.

data/lib/rack/cache_buster.rb

@@ -2,53 +2,58 @@ require 'digest/md5'
 
 module Rack
   class CacheBuster
-    autoload :Auto, "rack/cache_buster/auto"
-
-    def initialize(app, key = nil)
-      @app = app
-      if key
-        @key = "-"+Digest::MD5.hexdigest(key).freeze
-        @key_regexp = /#{@key}/.freeze
-      end
+    def initialize(app, key, target_time = nil)
+      @app, @target_time = app, target_time
+      @key = "-"+Digest::MD5.hexdigest(key || "blank-key").freeze
+      @key_regexp = /#{@key}/.freeze
     end
 
     def call(env)
-      env = env.dup
-      unpatch_etag!(env) if key
-
-      status, headers, body = app.call(env)
-
-      headers = headers.dup
-      patch_etag!(headers) if key
-      bust_cache!(headers)
-
-      [status, headers, body]
+      status, headers, body = app.call(unpatch_etag(env))
+      [status, patch_etag(limit_cache(headers)), body]
     end
 
   protected
     QUOTE_STRIPPER=/^"|"$/.freeze
     ETAGGY_HEADERS = ["HTTP_IF_NONE_MATCH", "HTTP_IF_MATCH", "HTTP_IF_RANGE"].freeze
     ETag = "ETag".freeze
-    CacheControl = "Cache-Control".freeze
 
     attr_reader :app
     attr_reader :key
 
 
-    def bust_cache!(headers)
-      headers[CacheControl] = "no-cache"
+    def limit_cache(headers)
+      return headers if @target_time.nil?
+      cache_control_header = CacheControlHeader.new(headers)
+      if cache_control_header.expired?
+        headers
+      else
+        cache_control_header.expire_time = [@target_time, cache_control_header.expire_time].min
+        headers.merge(CacheControlHeader::CacheControl => cache_control_header.to_s)
+      end
+    end
+
+    def unpatch_etag(headers)
+      p headers
+      ETAGGY_HEADERS.inject(headers){|memo, k|
+        p [k, memo[k], strip_etag(memo[k])] if memo[k]
+        memo.has_key?(k) ? memo.merge(k => strip_etag(memo[k])) : memo
+      }
     end
 
-    def unpatch_etag!(headers)
-      ETAGGY_HEADERS.each do |k|
-        headers[k] = headers[k].gsub(@key_regexp, "") if headers[k]
-      end
+    def strip_etag(s)
+      s.gsub(@key_regexp, "")
     end
 
-    def patch_etag!(headers)
-      stripped_tag = headers[ETag].to_s.gsub(QUOTE_STRIPPER, "")
-      return if stripped_tag.empty?
-      headers[ETag] = %Q{"#{stripped_tag}#{key}"}
+    def modify_etag(s)
+      s = s.to_s.gsub(QUOTE_STRIPPER, "")
+      s.empty? ? s : %Q{"#{s}#{key}"}
     end
+
+    def patch_etag(headers)
+      headers.merge(ETag => modify_etag(headers[ETag]))
+    end
+
+    autoload :CacheControlHeader, "rack/cache_buster/cache_control_header"
   end
 end

data/lib/rack/cache_buster/cache_control_header.rb

@@ -0,0 +1,46 @@
+require "rack/cache_buster"
+
+class Rack::CacheBuster::CacheControlHeader < Rack::CacheBuster
+  CacheControl = "Cache-Control".freeze
+  Age = "Age".freeze
+  MaxAge = "max-age".freeze
+
+  def initialize(env)
+    @age = env[Age].to_i
+    @max_age = 0
+    if env[CacheControl]
+      parts = env[CacheControl].split(/ *, */)
+      settings, options = parts.partition{|part| part =~ /=/ }
+      settings = settings.inject({}){|acc, part|
+        k, v = part.split(/ *= */, 2)
+        acc.merge(k => v)
+      }
+      @max_age = settings.delete(MaxAge).to_i
+      @other_parts = options + settings.map{|k,v| "#{k}=#{v}"}
+    end
+  end
+
+  def expires_in
+    @max_age - @age
+  end
+
+  def expired?
+    expires_in <= 0
+  end
+
+  def expire_time
+    Time.now + expires_in
+  end
+
+  def expire_time=(t)
+    @max_age = [t.to_i - Time.now.to_i + @age, @age].max
+  end
+
+  def update_env(env)
+    env[CacheControl] = to_s
+  end
+
+  def to_s
+    ["max-age=#{@max_age}", *@other_parts].join(", ")
+  end
+end

data/recipes/rack_cache_buster_recipes.rb

@@ -0,0 +1,57 @@
+def get_wind_down_time
+  target_time_string = capture("[ -f #{current_path}/WIND_DOWN ] && cat #{current_path}/WIND_DOWN || echo -n ")
+  if target_time_string.empty?
+    nil
+  else
+    Time.parse(target_time_string)
+  end
+end
+
+Capistrano::Configuration.instance(:must_exist).load do
+  unless exists? :wind_down_time
+    set :wind_down_time, 60*60 # 1.hour
+  end
+
+  namespace :cache do
+    desc "Start winding down the current deployment."
+    task :winddown do
+      run "echo '#{Time.now + wind_down_time}' > #{current_path}/WIND_DOWN"
+      deploy.restart
+    end
+
+    desc "Cancel an in progress wind down."
+    task :cancel_winddown do
+      run "rm -f #{current_path}/WIND_DOWN"
+      deploy.restart
+    end
+
+    desc "Check that wind down has completed (or was never started)."
+    task :check_ready_to_deploy do
+      if target_time = get_wind_down_time
+        if target_time > Time.now
+          puts "Servers are still winding down the cache.\nThey will be done at #{target_time} #{((target_time.to_i - Time.now.to_i)/60.0).ceil} mins from now.\nContinue with deploy?"
+          raise "Servers still winding down." if STDIN.gets !~ /^y/i
+        else
+          puts "Wind Down completed at #{target_time}"
+        end
+      else
+        puts "No wind down in progress."
+      end
+    end
+
+    desc "Get info about the current state of the wind down."
+    task :info do
+      if target_time = get_wind_down_time
+        if target_time > Time.now
+          puts "Servers are winding down the cache.\nThey will be done at #{target_time} #{((target_time.to_i - Time.now.to_i)/60.0).ceil} mins from now."
+        else
+          puts "Wind Down completed at #{target_time}"
+        end
+      else
+        puts "No wind down in progress."
+      end
+    end
+  end
+
+  before "deploy:update_code", "cache:check_ready_to_deploy"
+end

data/test/cache_busting_test.rb

@@ -5,7 +5,7 @@ class CacheBustingTest < IntegrationTest
 
   should "forward the request to the app" do
     given_env = nil
-    @app = Rack::CacheBuster.new(lambda { |env| given_env = env; [200, {}, []]  })
+    @app = Rack::CacheBuster.new(lambda { |env| given_env = env; [200, {}, []]  }, nil, Time.now)
     get "/foooo"
     assert_not_nil given_env
     assert_equal given_env["PATH_INFO"], "/foooo"
@@ -14,7 +14,7 @@ class CacheBustingTest < IntegrationTest
   should "forward the request to the app with digests removed" do
     given_env = nil
 
-    @app = Rack::CacheBuster.new(lambda { |env| given_env = env; [200, {}, []]  }, "foo")
+    @app = Rack::CacheBuster.new(lambda { |env| given_env = env; [200, {}, []]  }, "foo", Time.now)
 
     ["If-None-Match", "If-Match", "If-Range"].each do |k|
       header(k, "foo-#{DIGEST_OF_FOO}")
@@ -27,21 +27,28 @@ class CacheBustingTest < IntegrationTest
     end
   end
 
-  should "set cache-control to no-cache" do
-    @app = Rack::CacheBuster.new(CACHEY_APP)
+  should "set max-age to 0 if we should already have expired" do
+    @app = Rack::CacheBuster.new(CACHEY_APP, nil, Time.now - 100)
     get "/foooo"
-    assert_equal "no-cache", last_response["Cache-Control"]
+    assert_equal "max-age=0, public", last_response["Cache-Control"]
+  end
+
+  should "set max-age to 0 if we are at expirey time" do
+    @app = Rack::CacheBuster.new(CACHEY_APP, nil, Time.now)
+    get "/foooo"
+    assert_equal "max-age=0, public", last_response["Cache-Control"]
+  end
+
+  should "set max-age to 10 if we have 10s left" do
+    @app = Rack::CacheBuster.new(CACHEY_APP, nil, Time.now + 10)
+    get "/foooo"
+    assert_equal "max-age=10, public", last_response["Cache-Control"]
   end
 
   should 'append version to etag of response' do
-    @app = Rack::CacheBuster.new(CACHEY_APP, "foo")
+    @app = Rack::CacheBuster.new(CACHEY_APP, "foo", Time.now)
     get "/"
     assert_equal %Q{"an-etag-#{DIGEST_OF_FOO}"}, last_response["ETag"]
   end
 
-  should "leave the ETag alone if no key is given" do
-    @app = Rack::CacheBuster.new(CACHEY_APP)
-    get "/foooo"
-    assert_equal %Q{"an-etag"}, last_response["ETag"]
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-cache-buster
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Tom Lea
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-21 00:00:00 +01:00
+date: 2009-10-23 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -23,10 +23,10 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - README.markdown
-- test/auto_test.rb
+- recipes/rack_cache_buster_recipes.rb
 - test/cache_busting_test.rb
 - test/test_helper.rb
-- lib/rack/cache_buster/auto.rb
+- lib/rack/cache_buster/cache_control_header.rb
 - lib/rack/cache_buster.rb
 has_rdoc: true
 homepage: http://tomlea.co.uk/
@@ -37,6 +37,7 @@ rdoc_options:
 - --main
 - README.markdown
 require_paths: 
+- recipes
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 

data/lib/rack/cache_buster/auto.rb

@@ -1,13 +0,0 @@
-require "rack/cache_buster"
-
-class Rack::CacheBuster::Auto < Rack::CacheBuster
-  def initialize(app, key_filename, enabled_filename)
-    @enabled = File.exists?(enabled_filename)
-    key = File.exists?(key_filename) && File.open(key_filename).gets.chomp
-    super(app, key)
-  end
-
-  def bust_cache!(headers)
-    @enabled ? super(headers) : headers
-  end
-end

data/test/auto_test.rb

@@ -1,70 +0,0 @@
-#FOO
-require "test_helper"
-
-class CacheBusterAutoTest < IntegrationTest
-  DIGEST_OF_HASH_FOO=Digest::MD5.hexdigest("#FOO")
-
-  context "with no key files" do
-    setup do
-      @app = Rack::CacheBuster::Auto.new(CACHEY_APP, "/no-file-here.txt", "/no-file-here.txt")
-    end
-
-    should "not set cache-control to no-cache" do
-      get "/foooo"
-      assert_not_equal "no-cache", last_response["Cache-Control"]
-    end
-
-    should "leave the ETag alone" do
-      get "/foooo"
-      assert_equal %Q{"an-etag"}, last_response["ETag"]
-    end
-  end
-
-  context "with a key file" do
-    setup do
-      @app = Rack::CacheBuster::Auto.new(CACHEY_APP, __FILE__, "/no-file-here.txt")
-    end
-
-    should "still not set cache-control to no-cache" do
-      get "/foooo"
-      assert_not_equal "no-cache", last_response["Cache-Control"]
-    end
-
-    should "fiddle with the ETag" do
-      get "/foooo"
-      assert_equal %Q{"an-etag-#{DIGEST_OF_HASH_FOO}"}, last_response["ETag"]
-    end
-  end
-
-  context "with an enabled file" do
-    setup do
-      @app = Rack::CacheBuster::Auto.new(CACHEY_APP, "/no-file-here.txt", __FILE__)
-    end
-
-    should "set cache-control to no-cache" do
-      get "/foooo"
-      assert_equal "no-cache", last_response["Cache-Control"]
-    end
-
-    should "leave the ETag alone" do
-      get "/foooo"
-      assert_equal %Q{"an-etag"}, last_response["ETag"]
-    end
-  end
-
-  context "with an enabled file and a key file" do
-    setup do
-      @app = Rack::CacheBuster::Auto.new(CACHEY_APP, __FILE__, __FILE__)
-    end
-
-    should "set cache-control to no-cache" do
-      get "/foooo"
-      assert_equal "no-cache", last_response["Cache-Control"]
-    end
-
-    should "fiddle with the ETag" do
-      get "/foooo"
-      assert_equal %Q{"an-etag-#{DIGEST_OF_HASH_FOO}"}, last_response["ETag"]
-    end
-  end
-end