So I setup a project, called capitate which provides 3 things (and you can take or leave any of them at will): Plugins, Recipes and Templates.

Plugins

Capistrano has a plugin architecture. For example, the capitate prompt plugin gives you a beefier password prompt:

This will prompt for a password, ask you to re-type to verify, up to 3 times and will not be lazy initialized.

set :db_pass, prompt.password("DB password: ", :verify => true, 
  :max_attempts => 3, :lazy => false)

This one prompts for a password and verifies it against an md5 hash and prompt happens when variable is first accessed.

set :db_pass, prompt.password("DB password: ", :verify => false, 
  :check_hash => "3e5e1c82fbed35282cf53608b80503a7")

More plugins are at: lib/capitate/plugins

Adding plugins into capistrano is done by Capistrano.plugin [namespace] [module]. For example,

module Capitate::Plugins::Prompt
  def password(label, options = {})
    ...
  end
end
Capistrano.plugin :prompt, Capitate::Plugins::Prompt

Templates

Most of the configuration files in capitate are erb templates, which allows you to dry up and share your configuration across templates. Here are some examples of templates we use:

• Nginx vhost config
• Merb init script
• An example sphinx config with main/delta indexing
• Mysql cnf for dedicated machine (1024 mb)

Your templates maybe vary, but you get the idea.

Recipes

Recipes combine your templates, configuration and plugins into something more useful.

set :application, "capitate"
 
# Merb config
set :merb_nodes, 5
set :merb_port, 9000
set :merb_pid_dir, "#{shared_path}/pids"
set :merb_pid_path, "#{fetch(:merb_pid_dir)}/merb.pid"
 
# Nginx config
set :nginx_upstream_size, fetch(:merb_nodes)
set :nginx_upstream_port, fetch(:merb_port)
set :nginx_pid_path, "/var/run/nginx.pid"
 
task :setup do
  merb.centos.setup
  merb.monit.setup
  nginx.host.setup  
end

The setup task would generate /etc/init.d/merb_capitate init script, /etc/monit/merb_capitate.monitrc, and /etc/nginx/vhosts/capitate.conf files all with matching ports and pid files.

To use it

Throw this in your Capfile

require 'capitate'  
require 'capitate/recipes'
set :project_root, File.dirname(__FILE__)

Documenting recipes

Part of creating recipes is documenting them, you can view capitate’s recipe documentation at:
http://capitate.rubyforge.org/recipes/index.html

Contribute

Capitate is located at github.

Deployment and configuration varies a lot, so your mileage will vary, but capitate can be a resource for storing all different types of recipes and templates, so feel free to fork and pull request. Forking is the new friending.

config.action_controller.page_cache_directory = RAILS_ROOT + "/public/cache/"

This makes it easier to sweep. To setup nginx to pick up from a rails alternate cache directory like public/cache, I used:

if ($http_user_agent ~* "(iPhone|iPod)") {
  rewrite ^/$ /iphone break;
  proxy_pass http://mongrel-pt;
  break;
}
 
if (-f $request_filename) {
  break;
}
 
if (-f $document_root/cache/$uri/index.html) {
  rewrite (.*) /cache/$1/index.html break;
}
 
if (-f $document_root/cache/$uri.html) {
  rewrite (.*) /cache/$1.html break;
}
 
if (-f $document_root/cache/$uri) {
  rewrite (.*) /cache/$1 break;
}
 
if (!-f $request_filename) {
  proxy_pass http://mongrel-pt;
  break;
}

It was a little tricky to figure out to use the $uri variable. The first rewrite is used for iphone requests so it doesn’t get the non-iphone cached page.

My nginx.conf and init script.

Nginx is hyper optimized…

1
2
3
4

./ngx_http_upstream.c:        if (h->value.len == 2) {
./ngx_http_upstream.c:            if (c0 == 'n' && c1 == 'o') {
./ngx_http_upstream.c:        } else if (h->value.len == 3) {
./ngx_http_upstream.c:            if (c0 == 'y' && c1 == 'e' && c2 == 's') {