Question

How can I cache background images (forcefully) in user’s browser.
It will great to set a expiry time of 1 week or 1 month something.

PS:I have a page which shows listing based upon category. Every category has its own background image and I want to cache those background images.Every image is something about 20-30kb and I have some 20 categories.

Answer 1

Varnish is a solution and here is the gem which can help you in implementing it

Install
This gem requires ruby 1.9

Basic installation

sudo gem install lacquer  
rails generate lacquer:install

config/initializers/lacquer.rb

Lacquer.configure do |config|
  # Globally enable/disable cache
  config.enable_cache = true

  # Unless overridden in a controller or action, the default will be used
  config.default_ttl = 1.week

  # Can be :none, :delayed_job, :resque
  config.job_backend = :none

  # Array of Varnish servers to manage
  config.varnish_servers << {
    :host => "0.0.0.0", :port => 6082 # if you have authentication enabled, add :secret => "your secret"
  }

  # Number of retries
  config.retries = 5

  # config handler (optional, if you use Hoptoad or another error tracking service)
  config.command_error_handler = lambda { |s| HoptoadNotifier.notify(s) }

  ### Varnish - 2.x  /  3.x  .. VCL-Changes
  ### https://www.varnish-cache.org/docs/trunk/installation/upgrade.html

  # => Purge Command  ( "url.purge" for Varnish 2.x .. "ban.url" for Varnish 3.x )
  # => purges are now called bans in Varnish 3.x .. purge() and purge_url() are now respectively ban() and ban_url()
  config.purge_command = "ban.url"

  # => VCL_Fetch Pass Command  ( "pass" for Varnish 2.x .. "hit_for_pass" for Varnish 3.x )
  # => pass in vcl_fetch renamed to hit_for_pass in Varnish 3.x   
  config.pass_command = "pass"
end

app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
  include Lacquer::CacheUtils
end

config/varnishd.yml

development:
  listen: localhost:3001
  telnet: localhost:6082
  sbin_path: /usr/local/sbin
  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"

test:
  listen: localhost:3002
  telnet: localhost:6083
  sbin_path: /usr/local/sbin
  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"

production:
  listen: :80
  telnet: localhost:6082
  sbin_path: /usr/local/sbin
  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"
  params:
    overflow_max: 2000          # for Varnish 2.x ... use "queue_max: 2000" for Varnish 3.x
    thread_pool_add_delay: 2
    thread_pools: 4             # <Number of cpu cores>
    thread_pool_min: 200        # <800/number of cpu cores>
    thread_pool_max: 4000

If only some urls of the application should be cached by varnish, Lacquer::CacheControl will be helpful.

config/initializers/caches.rb

require "lacquer/cache_control"

Lacquer.cache_control.configure do |config|
  config.register :static,              :url => "^/images",                                           
                                        :expires_in => "365d"

  config.register :static,              :url => "^/stylesheets",
                                        :expires_in => "365d"

  config.register :static,              :url => "^/javascripts",                                       
                                        :expires_in => "365d"

  config.register :class_section,       :url => "^(/[a-z]{2})?/(info_screens|class_sections)/%s.*$",   
                                        :args => "[0-9]+", 
                                        :expires_in => "1m"

  config.register :open_scoring,        :url => "^(/[a-z]{2})?/class_sections/%s/open_scoring.*$",
                                        :args => "[0-9]+",
                                        :expires_in => "1m"

end

In the sweeper we can do something like this

class_section = ClassSection.find(1)
Lacquer.cache_control.purge(:open_scoring, class_section)

This will purge “^(/[a-z]{2})?/class_sections/1/open_scoring.*$” (/sv/class_sections/1/open_scoring.js, /sv/class_sections/1/open_scoring.html)

The varnish.vcl is preprocssed when starting varnishd with the rake tasks

rake lacquer:varnishd:start

config/varnish.vcl.erb

sub vcl_recv {
  # Lookup requests that we know should be cached
  if (<%= Lacquer.cache_control.to_vcl_conditions %>) {    
    # Clear cookie and authorization headers, set grace time, lookup in the cache
    unset req.http.Cookie;
    unset req.http.Authorization;
    return(lookup);
  }

  # Generates
  #
  # if(req.url ~ "^/images" || 
  #    req.url ~ "^/stylesheets" || 
  #    req.url ~ "^/javascripts" || 
  #    req.url ~ "^(/[a-z]{2})?/(info_screens|class_sections)/[0-9]+.*$" || 
  #    req.url ~ "^(/[a-z]{2})?/class_sections/[0-9]+/open_scoring.*$") {
  #    unset req.http.Cookie;
  #    unset req.http.Authorization;
  #    return(lookup);         
  # }
}

sub vcl_fetch {
  <%= Lacquer.cache_control.to_vcl_override_ttl_urls %>

  # Generates
  #
  # if(req.url ~ "^/images" || req.url ~ "^/stylesheets" || req.url ~ "^/javascripts") {
  #   unset beresp.http.Set-Cookie;
  #   set beresp.ttl = 365d;
  #   return(deliver);
  # }
  #
  # if(req.url ~ "^(/[a-z]{2})?/(info_screens|class_sections)/[0-9]+.*$" || 
  #   req.url ~ "^(/[a-z]{2})?/class_sections/[0-9]+/open_scoring.*$") {
  #   unset beresp.http.Set-Cookie;
  #   set beresp.ttl = 1m;
  #   return(deliver);
  # }
}

This makes it much simpler to perform cacheing, it’s only setuped in one place, purge it or just let it expire.

Usage
To set a custom ttl for a controller:

  before_filter { |controller| controller.set_cache_ttl(15.minutes) }

Clearing the cache:

class Posts < ApplicationController
  after_filter :clear_cache, :only => [ :create, :update, :destroy ]

private

  def clear_cache
    clear_cache_for(
      root_path,
      posts_path,
      post_path(@post))
  end
end

Control varnishd with the following rake tasks

rake lacquer:varnishd:start
rake lacquer:varnishd:stop
rake lacquer:varnishd:restart
rake lacquer:varnishd:status
rake lacquer:varnishd:global_purge

Gotchas
The default TTL for most actions is set to 0, since for most cases you’ll probably want to be fairly explicit about what pages do get cached by varnish. The default cache header is typically:

Cache-Control: max-age=0, no-cache, private
This is good for normal controller actions, since you won’t want to cache them. If TTL for an action is set to 0, it won’t mess with the default header.

The key gotcha here is that cached pages strip cookies, so if your application relies on sessions and uses authenticity tokens, the user will need a session cookie set before form actions will work. Setting default TTL to 0 here will make sure these session cookies won’t break.

As a result, all you have to do to set a cacheable action is the before filter above.