winton-background_cache 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Winton Welsh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,66 @@
+BackgroundCache
+===============
+
+Use a rake task to expire fragments, with or without a layout. Uses Rails and cache_fu.
+
+Dynamic Configuration
+---------------------
+
+Create *lib/background\_cache\_config.rb*:
+
+<pre>
+BackgroundCache::Config.new do |config|
+
+  # Configure a background cache in one call
+  Tag::League.find(:all).each do |tag|
+    config.cache(
+      # Route params
+      :controller => 'sections',
+      :action => 'teams',
+      :tag => tag.permalink,
+      # Background cache options
+      :every => 1.hour,
+      :layout => false,
+      :only => "sections_teams_#{tag.permalink}"
+    )
+  end
+  
+  # Group configure using block methods
+  config.every(1.hour).layout(false).only("sections_teams_#{tag.permalink}") do
+    Tag::League.find(:all).each do |tag|
+      config.cache(
+        :controller => 'sections',
+        :action => 'teams',
+        :tag => tag.permalink
+      )
+    end
+  end
+  
+  # Or use a mix of the two
+end
+</pre>
+
+The :only and :except options can be fragment ids or arrays of fragment ids.
+
+If no fragment is specified, all of the action's caches will regenerate.
+
+This configuration reloads every time the rake task runs. New records get background cached.
+
+Rake task
+---------
+
+Add <code>rake background_cache</code> to cron. Set the job's duration the same as your shortest cache.
+
+What does the rake task do?
+
+* Adds a security key to memcache that is shared by the app and rake task
+* Sends a request to the app to reload its BackgroundCache config
+* If time for a cache to expire, the task sends an expire request to the action
+* BackgroundCache detects the request within the app and modifies the layout or expiry as configured
+
+Memcached is employed to track the expire time of each background cache. As a side benefit, if memcached restarts, the rake task knows to generate all caches.
+
+Todo
+----
+
+* Specs

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+
+task :default => 'background_cache.gemspec'
+
+file 'background_cache.gemspec' => FileList['{lib,spec}/**','Rakefile'] do |f|
+  # read spec file and split out manifest section
+  spec = File.read(f.name)
+  parts = spec.split("  # = MANIFEST =\n")
+  fail 'bad spec' if parts.length != 3
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject{ |file| file =~ /^\./ }.
+    reject { |file| file =~ /^doc/ }.
+    map{ |file| "    #{file}" }.
+    join("\n")
+  # piece file back together and write...
+  parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = parts.join("  # = MANIFEST =\n")
+  File.open(f.name, 'w') { |io| io.write(spec) }
+  puts "Updated #{f.name}"
+end
+
+# sudo rake install
+task :install do
+  `sudo gem uninstall background_cache -x`
+  `gem build background_cache.gemspec`
+  `sudo gem install background_cache*.gem`
+  `rm background_cache*.gem`
+end

data/background_cache.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name    = 'background_cache'
+  s.version = '0.1.1'
+  s.date    = '2008-03-11'
+  
+  s.summary     = "Generate caches before your users do (with Rails and cache_fu)"
+  s.description = "Generate caches before your users do (with Rails and cache_fu)"
+  
+  s.author   = 'Winton Welsh'
+  s.email    = 'mail@wintoni.us'
+  s.homepage = 'http://github.com/winton/background_cache'
+  
+  s.has_rdoc = false
+  
+  # = MANIFEST =
+  s.files = %w[
+    MIT-LICENSE
+    README.markdown
+    Rakefile
+    background_cache.gemspec
+    changelog.markdown
+    init.rb
+    lib/background_cache.rb
+    lib/background_cache/config.rb
+    lib/background_cache/controller.rb
+    lib/background_cache/helper.rb
+    spec/spec.opts
+    spec/spec_helper.rb
+    tasks/background_cache.rake
+  ]
+  # = MANIFEST =
+end

data/changelog.markdown

@@ -0,0 +1,4 @@
+Version 0.1.0
+=============
+
+* Initial Creation

data/init.rb

@@ -0,0 +1,5 @@
+$:.unshift File.dirname(__FILE__) + "/lib"
+require 'background_cache'
+
+ActionController::Base.send(:include, BackgroundCache::Controller)
+ActionController::Base.helper(BackgroundCache::Helper)

data/lib/background_cache.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/background_cache/config.rb"
+require File.dirname(__FILE__) + "/background_cache/controller.rb"

data/lib/background_cache/config.rb

@@ -0,0 +1,118 @@
+require 'digest/sha2'
+
+module BackgroundCache
+  class Config
+    def initialize(&block)
+      @@caches = []
+      yield self
+    end
+    def cache(options)
+      # Convert keys to strings for param matching
+      options.dup.each do |key, value|
+        options[key.to_s] = value
+        options.delete(key)
+      end
+      # Method-style config
+      options = @options.merge(options)
+      # Store the cache options
+      @@caches.push({
+        :except => options.delete('except'),
+        :every => options.delete('every') || 1.hour,
+        :layout => options.delete('layout'),
+        :only => options.delete('only'),
+        :params => options
+      })
+    end
+    def except(value, &block)
+      set_option(:except, value, &block)
+    end
+    def every(value, &block)
+      set_option(:every, value, &block)
+    end
+    def layout(value, &block)
+      set_option(:layout, value, &block)
+    end
+    def only(value, &block)
+      set_option(:only, value, &block)
+    end
+    def set_option(key, value, &block)
+      @options ||= {}
+      @options[key.to_s] = value
+      if block
+        yield
+        @options = {}
+      end
+      self
+    end
+    # Find cache config from params
+    def self.from_params(params)
+      from_params_and_fragment(params)
+    end
+    def self.from_params_and_fragment(params, fragment=nil)
+      unless @@caches.empty?
+        @@caches.select { |item|
+          # Basic params match (action, controller, etc)
+          item[:params] == params &&
+          (
+            # No fragment specified
+            fragment.nil? ||
+            (
+              (
+                # :only not defined
+                !item[:only] ||
+                # :only matches fragment
+                item[:only] == fragment ||
+                (
+                  # :only is an array
+                  items[:only].respond_to?(:index) &&
+                  # :only includes matching fragment
+                  items[:only].include?(fragment)
+                )
+              ) &&
+              (
+                # :except not defined
+                !item[:except] ||
+                # :except not explicitly named
+                item[:except] != fragment ||
+                (
+                  # :except is an array
+                  items[:except].respond_to?(:index) &&
+                  # :except does not include matching fragment
+                  !items[:except].include?(fragment)
+                )
+              )
+            )
+          )
+        }[0]
+      end
+    end
+    def self.caches
+      @@caches
+    end
+    def self.key
+      Digest::SHA256.hexdigest("--#{Time.now}--#{rand}--")
+    end
+    def self.load!
+      load RAILS_ROOT + "/lib/background_cache_config.rb"
+    end
+    def self.unload!
+      @@caches = []
+    end
+    # Unique cache id for storing last expired time
+    def self.unique_cache_id(cache)
+      id = []
+      join = lambda do |k, v|
+        id << (k.nil? || v.nil? ?
+          nil : [ k, v ].collect { |kv| kv.to_s.gsub(/\W/, '_') }.join('-')
+        )
+      end
+      cache[:params].each do |key, value|
+        join.call(key, value)
+      end
+      cache.each do |key, value|
+        join.call(key, value) unless key == :params
+      end
+      'background_cache/' + id.compact.join('/')
+    end
+  end
+end

data/lib/background_cache/controller.rb

@@ -0,0 +1,42 @@
+module BackgroundCache
+  module Controller
+    def self.included(base)
+      base.around_filter BackgroundCacheFilter.new
+    end
+      
+    private
+    class BackgroundCacheFilter
+      def before(controller)
+        # Secure filters
+        key = CACHE['background_cache/key']
+        # Load the background cache config (stay dynamic)
+        if controller.params[:background_cache_load] == key
+          BackgroundCache::Config.load!
+        # Unload the background cache config
+        elsif controller.params[:background_cache_unload] == key
+          BackgroundCache::Config.unload!
+        # Reload the cache for an entire page, action, or fragment
+        elsif controller.params[:background_cache] == key
+          @cache = BackgroundCache::Config.from_params(params)
+          # Store current layout, then disable it
+          if @cache && @cache[:layout] == false
+            @layout = controller.active_layout
+            controller.class.layout(false)
+          end
+        end
+        controller.params.delete("background_cache")
+        controller.params.delete("background_cache_load")
+        controller.params.delete("background_cache_unload")
+        true
+      end
+      def after(controller)
+        if @cache
+          # Restore layout
+          if @cache[:layout] == false
+            controller.class.layout(@layout)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/background_cache/helper.rb

@@ -0,0 +1,18 @@
+module BackgroundCache
+  module Helper
+    def cache_with_background_cache(name = {}, options = nil, &block)
+      cache = BackgroundCache::Config.from_params_and_fragment(params, name)
+      if cache
+        # http://api.rubyonrails.org/classes/ActionView/Helpers/CacheHelper.html
+        # http://api.rubyonrails.org/classes/ActionController/Caching/Fragments.html
+        # ActionController::Caching::Fragments#fragment_for (undocumented)
+        pos = output_buffer.length
+        block.call
+        @controller.write_fragment(name, buffer[pos..-1], options)
+      else
+        cache_without_background_cache(name, options, &block)
+      end
+    end
+    alias_method_chain :cache, :background_cache
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+Spec::Runner.configure do |config|
+
+end

data/tasks/background_cache.rake

@@ -0,0 +1,29 @@
+desc "Background cache cron job"
+task :background_cache => :environment do
+  # Secure filters
+  key = CACHE['background_cache/key'] = BackgroundCache::Config.key
+  # Used to make requests
+  session = ActionController::Integration::Session.new
+  session.host = nil
+  # Load the application background cache config (stay dynamic)
+  session.get("/?background_cache_load=#{key}")
+  # Retrieve caches from config
+  load RAILS_ROOT + "/lib/background_cache_config.rb"
+  caches = BackgroundCache::Config.caches
+  caches.each do |cache|
+    # Unique cache id for storing last expired time
+    id = BackgroundCache::Config.unique_cache_id(cache)
+    # Find out when this cache was last expired
+    expired_at = CACHE[id]
+    # If last expired doesn't exist or is older than :every
+    if !expired_at || Time.now - expired_at > cache[:every]
+      # Request action with ?background_cache
+      session.get(session.url_for(cache[:params]) + "?background_cache=#{key}")
+      # Update last expired time
+      CACHE[id] = Time.now
+    end
+    puts id
+  end
+  # Unload the application background cache config
+  session.get("/?background_cache_unload=#{key}")
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: winton-background_cache
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Winton Welsh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Generate caches before your users do (with Rails and cache_fu)
+email: mail@wintoni.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- background_cache.gemspec
+- changelog.markdown
+- init.rb
+- lib/background_cache.rb
+- lib/background_cache/config.rb
+- lib/background_cache/controller.rb
+- lib/background_cache/helper.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/background_cache.rake
+has_rdoc: false
+homepage: http://github.com/winton/background_cache
+post_install_message: 
+rdoc_options: []
+
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Generate caches before your users do (with Rails and cache_fu)
+test_files: []
+