rack-cache-buster 0.1.0

data/README.markdown

@@ -0,0 +1,34 @@
+# 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.
+
+## Usage:
+
+### 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")
+
+### Before you deploy:
+
+* Find the maximum cache duration for all pages in your app, start this process with at least that amount time before you deploy.
+
+* Create a WIND_DOWN file in the app root of all your app servers.
+
+* 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.

data/lib/rack/cache_buster.rb

@@ -0,0 +1,54 @@
+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
+    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]
+    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"
+    end
+
+    def unpatch_etag!(headers)
+      ETAGGY_HEADERS.each do |k|
+        headers[k] = headers[k].gsub(@key_regexp, "") if headers[k]
+      end
+    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}"}
+    end
+  end
+end

data/lib/rack/cache_buster/auto.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,70 @@
+#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

data/test/cache_busting_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class CacheBustingTest < IntegrationTest
+  DIGEST_OF_FOO=Digest::MD5.hexdigest("foo")
+
+  should "forward the request to the app" do
+    given_env = nil
+    @app = Rack::CacheBuster.new(lambda { |env| given_env = env; [200, {}, []]  })
+    get "/foooo"
+    assert_not_nil given_env
+    assert_equal given_env["PATH_INFO"], "/foooo"
+  end
+
+  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")
+
+    ["If-None-Match", "If-Match", "If-Range"].each do |k|
+      header(k, "foo-#{DIGEST_OF_FOO}")
+    end
+
+    get "/foooo"
+
+    Rack::CacheBuster::ETAGGY_HEADERS.each do |k|
+      assert_equal "foo", given_env[k], "#{k} should be set to foo"
+    end
+  end
+
+  should "set cache-control to no-cache" do
+    @app = Rack::CacheBuster.new(CACHEY_APP)
+    get "/foooo"
+    assert_equal "no-cache", last_response["Cache-Control"]
+  end
+
+  should 'append version to etag of response' do
+    @app = Rack::CacheBuster.new(CACHEY_APP, "foo")
+    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

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+$:<<File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'shoulda'
+require 'rack/cache_buster'
+require 'test/unit'
+require 'rack/test'
+
+class IntegrationTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+  attr_reader :app
+
+  CACHEY_APP = lambda{|env| [200, {"Cache-Control" => "max-age=200, public", "ETag" => '"an-etag"'}, []] }
+
+  def test_nothing
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: rack-cache-buster
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tom Lea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-21 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: commit@tomlea.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- test/auto_test.rb
+- test/cache_busting_test.rb
+- test/test_helper.rb
+- lib/rack/cache_buster/auto.rb
+- lib/rack/cache_buster.rb
+has_rdoc: true
+homepage: http://tomlea.co.uk/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rack-cache-buster
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Place this in your rack stack and all caching will be gone.
+test_files: []
+