lacquer 0.4.1 → 0.5.0.beta1

data/Gemfile

@@ -1,8 +1,12 @@
 source 'http://rubygems.org'
 
-gem "activesupport", "3.0.1"
-gem "i18n", "0.4.1"
+gem "activesupport", "~> 3.0"
+gem "i18n", "~> 0.4"
 gem "jeweler"
 gem "rake"
-gem "rspec", "2.0.0"
 gem "yard"
+gem "erubis"
+
+group :test do
+  gem "rspec", "~> 2.5", :require => false
+end

data/README.rdoc

@@ -5,7 +5,8 @@ Rails drop in for Varnish support.
 == Install
 Basic installation
 
-  sudo gem install lacquer
+  sudo gem install lacquer  
+  rails generate lacquer:install
 
 config/initializers/lacquer.rb
 
@@ -36,7 +37,115 @@ 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
+      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 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:
@@ -57,6 +166,14 @@ Clearing the cache:
         post_path(@post))
     end
   end
+  
+Control varnishd with the following rake tasks
+
+  rake varnishd:start
+  rake varnishd:stop
+  rake varnishd:restart
+  rake varnishd:status
+  rake varnishd:global_purge  
 
 == Gotchas
 

data/Rakefile

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require "rubygems"
 require "bundler/setup"
 
@@ -14,8 +15,7 @@ begin
     gem.description = %Q{Rails drop in for Varnish support.}
     gem.email = "russ@bashme.org"
     gem.homepage = "http://github.com/russ/lacquer"
-    gem.authors = ["Russ Smith (russ@bashme.org)", "Ryan Johns", "Garry Tan (garry@posterous.com), Gabe da Silveira (gabe@websaviour.com)"]
-    gem.add_development_dependency "rspec", "~> 1.3.0"
+    gem.authors = ["Russ Smith (russ@bashme.org)", "Ryan Johns", "Garry Tan (garry@posterous.com), Gabe da Silveira (gabe@websaviour.com)", "Håkon Lerring"]
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0.beta1

data/init.rb

@@ -1 +1 @@
-require File.join(File.dirname(__FILE__), 'lib', 'lacquer')
+require File.join(File.dirname(__FILE__), 'lib', 'lacquer')

data/lacquer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lacquer}
-  s.version = "0.4.1"
+  s.version = "0.5.0.beta1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Russ Smith (russ@bashme.org)", "Ryan Johns", "Garry Tan (garry@posterous.com), Gabe da Silveira (gabe@websaviour.com)"]
-  s.date = %q{2010-12-28}
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Russ Smith (russ@bashme.org)", "Ryan Johns", "Garry Tan (garry@posterous.com), Gabe da Silveira (gabe@websaviour.com)", "Håkon Lerring"]
+  s.date = %q{2011-04-25}
   s.description = %q{Rails drop in for Varnish support.}
   s.email = %q{russ@bashme.org}
   s.extra_rdoc_files = [
@@ -20,7 +20,6 @@ Gem::Specification.new do |s|
     ".bundle/config",
     ".document",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE",
     "README.rdoc",
     "Rakefile",
@@ -30,61 +29,73 @@ Gem::Specification.new do |s|
     "lib/generators/lacquer/USAGE",
     "lib/generators/lacquer/install_generator.rb",
     "lib/generators/lacquer/templates/initializer.rb",
-    "lib/generators/lacquer/templates/varnish.sample.vcl",
+    "lib/generators/lacquer/templates/varnish.vcl.erb",
+    "lib/generators/lacquer/templates/varnishd.yml",
     "lib/lacquer.rb",
+    "lib/lacquer/cache_control.rb",
     "lib/lacquer/cache_utils.rb",
+    "lib/lacquer/capistrano.rb",
     "lib/lacquer/configuration.rb",
     "lib/lacquer/delayed_job_job.rb",
+    "lib/lacquer/railtie.rb",
+    "lib/lacquer/recipes.rb",
     "lib/lacquer/resque_job.rb",
+    "lib/lacquer/tasks.rb",
     "lib/lacquer/varnish.rb",
+    "lib/lacquer/varnishd.rb",
     "rails/init.rb",
+    "recipes/lacquer.rb",
+    "spec/config/generate.vcl.erb",
+    "spec/config/varnish.vcl",
+    "spec/config/varnishd.yml",
+    "spec/lacquer/cache_control_spec.rb",
     "spec/lacquer/cache_utils_spec.rb",
     "spec/lacquer/delayed_job_job_spec.rb",
     "spec/lacquer/resque_job_spec.rb",
     "spec/lacquer/varnish_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/lacquer/varnishd_spec.rb",
+    "spec/spec_helper.rb",
+    "tasks/lacquer.rake"
   ]
   s.homepage = %q{http://github.com/russ/lacquer}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.5.0}
   s.summary = %q{Rails drop in for Varnish support.}
   s.test_files = [
+    "spec/lacquer/cache_control_spec.rb",
     "spec/lacquer/cache_utils_spec.rb",
     "spec/lacquer/delayed_job_job_spec.rb",
     "spec/lacquer/resque_job_spec.rb",
     "spec/lacquer/varnish_spec.rb",
+    "spec/lacquer/varnishd_spec.rb",
     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, ["= 3.0.1"])
-      s.add_runtime_dependency(%q<i18n>, ["= 0.4.1"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0"])
+      s.add_runtime_dependency(%q<i18n>, ["~> 0.4"])
       s.add_runtime_dependency(%q<jeweler>, [">= 0"])
       s.add_runtime_dependency(%q<rake>, [">= 0"])
-      s.add_runtime_dependency(%q<rspec>, ["= 2.0.0"])
       s.add_runtime_dependency(%q<yard>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, ["~> 1.3.0"])
+      s.add_runtime_dependency(%q<erubis>, [">= 0"])
     else
-      s.add_dependency(%q<activesupport>, ["= 3.0.1"])
-      s.add_dependency(%q<i18n>, ["= 0.4.1"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0"])
+      s.add_dependency(%q<i18n>, ["~> 0.4"])
       s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<rspec>, ["= 2.0.0"])
       s.add_dependency(%q<yard>, [">= 0"])
-      s.add_dependency(%q<rspec>, ["~> 1.3.0"])
+      s.add_dependency(%q<erubis>, [">= 0"])
     end
   else
-    s.add_dependency(%q<activesupport>, ["= 3.0.1"])
-    s.add_dependency(%q<i18n>, ["= 0.4.1"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0"])
+    s.add_dependency(%q<i18n>, ["~> 0.4"])
     s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<rspec>, ["= 2.0.0"])
     s.add_dependency(%q<yard>, [">= 0"])
-    s.add_dependency(%q<rspec>, ["~> 1.3.0"])
+    s.add_dependency(%q<erubis>, [">= 0"])
   end
 end
 

data/lib/generators/lacquer/install_generator.rb

@@ -8,7 +8,11 @@ module Lacquer
       end
 
       def copy_vcl
-        copy_file("varnish.sample.vcl", "config/varnish.sample.vcl")
+        copy_file("varnish.vcl.erb", "config/varnish.vcl.erb")
+      end
+      
+      def copy_varnishd_config
+        copy_file("varnishd.yml", "config/varnishd.yml")
       end
     end
   end

data/lib/generators/lacquer/templates/{varnish.sample.vcl → varnish.vcl.erb}

@@ -1,6 +1,6 @@
 backend default {
-  .host = "0.0.0.0";
-  .port = "10000";
+  .host = "<%= backend.split(':').first %>";
+  .port = "<%= backend.split(':').last %>";
 }
 
 # Handling of requests that are received from clients.
@@ -14,19 +14,20 @@ sub vcl_recv {
       req.request != "TRACE" &&
       req.request != "OPTIONS" &&
       req.request != "DELETE") {
-    pipe;
+    return(pipe);
   }
-
+  
+  if (req.backend.healthy) {
+     set req.grace = 30s;
+  } else {
+     set req.grace = 1h;
+  }  
+  
   # Pass requests that are not GET or HEAD
   if (req.request != "GET" && req.request != "HEAD") {
-    pass;
-  }
-
-  # Pass requests that we know we aren't caching
-  if (req.url ~ "^/admin") {
-    pass;
+    return(pass);
   }
-
+  
   # Handle compression correctly. Varnish treats headers literally, not
   # semantically. So it is very well possible that there are cache misses
   # because the headers sent by different browsers aren't the same.
@@ -47,8 +48,7 @@ sub vcl_recv {
   # Clear cookie and authorization headers, set grace time, lookup in the cache
   unset req.http.Cookie;
   unset req.http.Authorization;
-  set req.grace = 30s;
-  lookup;
+  return(lookup);
 }
 
 # Called when entering pipe mode
@@ -57,34 +57,34 @@ sub vcl_pipe {
   # requests from the client will also be piped through and
   # left untouched by varnish. We don't want that.
   set req.http.connection = "close";
-  pipe;
+  return(pipe);
 }
 
 # Called when the requested object has been retrieved from the
 # backend, or the request to the backend has failed
 sub vcl_fetch {
-  # Do not cache the object if the backend application does not want us to.
-  if (obj.http.Cache-Control ~ "(no-cache|no-store|private|must-revalidate)") {
-    pass;
-  }
-
+  # Set the grace time
+  set beresp.grace = 1h;
+  
   # Do not cache the object if the status is not in the 200s
-  if (obj.status >= 300) {
+  if (beresp.status >= 300) {
     # Remove the Set-Cookie header
-    remove obj.http.Set-Cookie;
-    pass;
+    remove beresp.http.Set-Cookie;
+    return(pass);
+  }
+  
+  # Do not cache the object if the backend application does not want us to.
+  if (beresp.http.Cache-Control ~ "(no-cache|no-store|private|must-revalidate)") {
+    return(pass);
   }
 
   # Everything below here should be cached
 
   # Remove the Set-Cookie header
-  remove obj.http.Set-Cookie;
-
-  # Set the grace time
-  set obj.grace = 30s;
+  remove beresp.http.Set-Cookie;
 
   # Deliver the object
-  deliver;
+  return(deliver);
 }
 
 # Called before the response is sent back to the client

data/lib/generators/lacquer/templates/varnishd.yml

@@ -0,0 +1,26 @@
+development:
+  listen: 127.0.0.1:3001
+  telnet: 127.0.0.1:6082
+  backend: 127.0.0.1:3000
+  sbin_path: /usr/local/sbin
+  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"
+    
+test:
+  listen: 127.0.0.1:3002
+  telnet: 127.0.0.1:6083
+  backend: 127.0.0.1:3000
+  sbin_path: /usr/local/sbin
+  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"
+
+production:
+  listen: :80
+  telnet: localhost:6082
+  backend: backend_server:8080
+  sbin_path: /usr/local/sbin
+  storage: "file,#{Rails.root}/log/varnishd.#{Rails.env}.cache,100MB"
+  params:
+    overflow_max: 2000
+    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

data/lib/lacquer/cache_control.rb

@@ -0,0 +1,61 @@
+module Lacquer
+  
+  def self.cache_control
+    @cache_control ||= CacheControl.new
+  end
+  
+  class CacheControl
+    include Lacquer::CacheUtils
+    attr_accessor :store
+    
+    def initialize
+      self.store = []
+    end
+  
+    def register(group, options = {})
+      options[:group]  = group
+      options[:args]   = Array(options[:args]).compact
+      store           << options
+    end
+  
+    def configure
+      yield self
+    end
+    
+    def purge(group, *args)
+      clear_cache_for(*urls_for(group, *args))      
+    end
+    
+    def urls_for(group, *args)
+      args.map! { |arg| arg.to_param }
+      urls_by(group).map { |options| options[:url] % args }
+    end
+  
+    def to_vcl_conditions(urls = store)
+      urls.map { |opt| %Q[req.url ~ "#{(opt[:url] % opt[:args])}"] }.join(" || ")
+    end
+    
+    def to_vcl_override_ttl_urls
+      urls_grouped_by_expires.map do |expires_in, list|
+        <<-CODE.strip_heredoc
+        if(#{to_vcl_conditions(list)}) {
+          unset beresp.http.Set-Cookie;
+          set beresp.ttl = #{expires_in};
+          return(deliver);
+        }
+        CODE
+      end.join("\n")
+    end
+    
+    protected
+    
+    def urls_grouped_by_expires
+      store.group_by { |opt| opt[:expires_in] }.select { |expires_in, list| expires_in }
+    end
+    
+    def urls_by(group)
+      store.select   { |opt| opt[:group] == group }
+    end
+  
+  end  
+end

data/lib/lacquer/cache_utils.rb

@@ -26,17 +26,15 @@ module Lacquer
     #
     # clear_cache_for(root_path, blog_posts_path, '/other/content/*')
     def clear_cache_for(*paths)
-      paths.each do |path|
-        case Lacquer.configuration.job_backend
-        when :delayed_job
-          require 'lacquer/delayed_job_job'
-          Delayed::Job.enqueue(Lacquer::DelayedJobJob.new(path))
-        when :resque
-          require 'lacquer/resque_job'
-          Resque.enqueue(Lacquer::ResqueJob, path)
-        when :none
-          Varnish.new.purge(path)
-        end
+      case Lacquer.configuration.job_backend
+      when :delayed_job
+        require 'lacquer/delayed_job_job'
+        Delayed::Job.enqueue(Lacquer::DelayedJobJob.new(paths))
+      when :resque
+        require 'lacquer/resque_job'
+        Resque.enqueue(Lacquer::ResqueJob, paths)
+      when :none
+        Varnish.new.purge(*paths)
       end
     end
     

data/lib/lacquer/capistrano.rb

@@ -0,0 +1,20 @@
+# Capistrano tasks for Lacquer
+
+Capistrano::Configuration.instance(:must_exit).load do
+  _cset(:lacquer_roles) { :web }
+
+  after "deploy:web:disable", "lacquer:global_purge"
+  after "deploy:web:enable", "lacquer:global_purge"
+  after "deploy:rollback", "lacquer:global_purge"
+  after "deploy:rollback", "lacquer:restart"
+  after "deploy:update", "lacquer:restart"
+
+  namespace :lacquer do
+    %w( start stop restart global_purge status ).each do |name|
+      task name.to_sym, :roles => lacquer_roles do
+        next if find_servers_for_task(current_task).empty?
+        run "cd #{current_path} && #{rake} varnishd:#{name}"
+      end
+    end
+  end
+end

data/lib/lacquer/delayed_job_job.rb

@@ -1,7 +1,7 @@
 module Lacquer
-  class DelayedJobJob < Struct.new(:url)
+  class DelayedJobJob < Struct.new(:urls)
     def perform
-      Varnish.new.purge(url)
+      Varnish.new.purge(*urls)
     end
   end
 end

data/lib/lacquer/railtie.rb

@@ -0,0 +1,9 @@
+require 'lacquer'
+require 'rails'
+module Lacquer
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'lacquer/tasks.rb'
+    end
+  end
+end

data/lib/lacquer/recipes.rb

@@ -0,0 +1,62 @@
+# Capistrano Recipes for managing varnishd
+#
+# Add these callbacks to have the varnishd process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "delayed_job:stop"
+#   after "deploy:start",   "delayed_job:start"
+#   after "deploy:restart", "delayed_job:restart"
+#
+# If you've got varnishd running on a servers, you can also specify
+# which servers have varnishd running and should be restarted after deploy.
+#
+#   set :varnishd_role, :varnish
+#
+
+Capistrano::Configuration.instance.load do
+  namespace :varnishd do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+    
+    def rake
+      fetch(:rake, 'rake')
+    end
+    
+    def roles
+      fetch(:varnishd_role, :varnish)
+    end
+    
+    desc "Link varnishd.yml from shared/config to app/config"
+    task :link_varnishd_yml, :roles => lambda { roles } do
+      run "cd #{release_path} && ln -nfs #{shared_path}/config/varnishd.yml  #{release_path}/config/varnishd.yml"
+    end
+    after 'deploy:update_code', 'varnishd:link_varnishd_yml'
+    
+    desc "Link varnish.vcl from shared/config to app/config"
+    task :link_varnish_vcl, :roles => lambda { roles } do
+      run "cd #{release_path} && ln -nfs #{shared_path}/config/varnish.vcl  #{release_path}/config/varnish.vcl"
+    end
+    after 'deploy:update_code', 'varnishd:link_varnishd_vcl'
+    
+    desc "Purge ALL urls from Varnish"
+    task :global_purge, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} #{rake} varnishd:global_purge"
+    end
+    
+    desc "Stop the varnishd process"
+    task :stop, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} #{rake} varnishd:stop"
+    end
+
+    desc "Start the varnishd process"
+    task :start, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} #{rake} varnishd:start"
+    end
+
+    desc "Restart the delayed_job process"
+    task :restart, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} #{rake} varnishd:restart"
+    end
+  end
+end

data/lib/lacquer/resque_job.rb

@@ -2,8 +2,8 @@ module Lacquer
   class ResqueJob
     @queue = :lacquer
 
-    def self.perform(url)
-      Varnish.new.purge(url)
+    def self.perform(urls)
+      Varnish.new.purge(*urls)
     end
   end
 end

data/lib/lacquer/tasks.rb

@@ -0,0 +1,37 @@
+namespace :varnishd do
+  
+  desc "Start varnishd daemon using Lacquer's settings"
+  task :start => :environment do
+    Lacquer::Varnishd.new.start
+  end
+  
+  desc "Stop varnishd daemon using Lacquer's settings"
+  task :stop => :environment do
+    Lacquer::Varnishd.new.stop
+  end
+  
+  desc "Running status of varnishd daemon using Lacquer's settings"
+  task :status => :environment do
+    if Lacquer::Varnishd.new.running?
+      puts "Varnishd is running"
+    else
+      puts "Varnishd is not running"
+    end
+  end
+  
+  desc "Restart varnishd daemon using Lacquer's settings"
+  task :restart => :environment do
+    varnishd = Lacquer::Varnishd.new
+    if varnishd.running?
+      varnishd.stop
+      sleep(1)
+    end
+    varnishd.start
+  end
+  
+  desc "Purge ALL urls from Varnish"
+  task :global_purge => :environment do
+    Lacquer::Varnish.new.purge('.*')
+  end
+    
+end