capistrano_recipes 1.0.0

data/lib/capistrano/recipes/templates/nginx.vhost.erb

@@ -0,0 +1,139 @@
+<% if using_recipe?(:unicorn) %>
+upstream unicorn_<%= application %> {
+  server unix:<%= unicorn_socket %> fail_timeout=0;
+}
+
+<% end %>
+<% if exists?(:domain_alias) %>
+server {
+  server_name  <%= domain_alias %>;
+  rewrite ^(.*) http://<%= domain %>$1 permanent;
+}
+
+<% end %>
+server {
+  listen <%= nginx_port %>;
+  server_name <%= domain %>;
+
+  root <%= current_path %>/public;
+  access_log <%= shared_path %>/log/access.log main;
+  error_log <%= shared_path %>/log/error.log info;
+
+  # Rewrite all the requests to the maintenance.html
+  # page if it exists in the doc root. This is for
+  # capistrano's disable web task
+  if (-f $document_root/system/maintenance.html) {
+    rewrite ^(.*)$ /system/maintenance.html last;
+    break;
+  }
+
+  location / {
+    # If the file exists as a static file, serve it directly
+    # without running all the other rewrite tests on it
+    if (-f $request_filename) {
+      break;
+    }
+
+    # Check for index.html
+    if (-f $request_filename/index.html) {
+      rewrite (.*) $1/index.html break;
+    }
+
+    # Check if .html file exists for page caching
+    if (-f $request_filename.html) {
+      rewrite (.*) $1.html break;
+    }
+  }
+
+<% if using_recipe?(:rails_assets) %>
+  # Asset pipeline
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+<% end %>
+<% if using_recipe?(:unicorn) %>
+  try_files $uri/index.html $uri @unicorn;
+  location @unicorn {
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header Host $http_host;
+    proxy_redirect off;
+    proxy_pass http://unicorn_<%= application %>;
+  }
+
+<% end %>
+  error_page 500 502 503 504 /500.html;
+  location = /500.html {
+    root <%= current_path %>/public;
+  }
+}
+<% if using_ssl? %>
+
+server {
+  listen <%= nginx_ssl_port %>;
+  server_name <%= domain %>;
+
+  root <%= current_path %>/public;
+  access_log <%= shared_path %>/log/ssl-access.log main;
+  error_log <%= shared_path %>/log/ssl-error.log info;
+
+  ssl                   on;
+  ssl_certificate       <%= File.join nginx_ssl_certs_path, nginx_ssl_cert %>;
+  ssl_certificate_key   <%= File.join nginx_ssl_private_path, nginx_ssl_key %>;
+  ssl_session_timeout   5m;
+
+
+  # Rewrite all the requests to the maintenance.html
+  # page if it exists in the doc root. This is for
+  # capistrano's disable web task
+  if (-f $document_root/system/maintenance.html) {
+    rewrite ^(.*)$ /system/maintenance.html last;
+    break;
+  }
+
+  location / {
+    # If the file exists as a static file, serve it directly
+    # without running all the other rewrite tests on it
+    if (-f $request_filename) {
+      break;
+    }
+
+    # Check for index.html
+    if (-f $request_filename/index.html) {
+      rewrite (.*) $1/index.html break;
+    }
+
+    # Check if .html file exists for page caching
+    if (-f $request_filename.html) {
+      rewrite (.*) $1.html break;
+    }
+  }
+
+<% if using_recipe?(:rails_assets) %>
+  # Asset pipeline
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+<% end %>
+<% if using_recipe?(:unicorn) %>
+  try_files $uri/index.html $uri @unicorn;
+  location @unicorn {
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto https;
+    proxy_set_header Host $http_host;
+    proxy_redirect off;
+    proxy_pass http://unicorn_<%= application %>;
+  }
+
+<% end %>
+  error_page 500 502 503 504 /500.html;
+  location = /500.html {
+    root <%= current_path %>/public;
+  }
+}
+<% end %>

data/lib/capistrano/recipes/templates/unicorn.rb.erb

@@ -0,0 +1,47 @@
+working_directory "<%= current_path %>"
+pid "<%= unicorn_pid_file %>"
+stderr_path "<%= unicorn_log_file %>"
+stdout_path "<%= unicorn_log_file %>"
+
+# Listen on a Unix domain socket
+# Use shorter backlog for quicker failover when busy
+listen "<%= unicorn_socket_file %>", backlog: 64
+
+# Preload our app for more speed
+preload_app true
+
+# See unicorn docs for more configuration details
+worker_processes <%= unicorn_workers %>
+
+# Kill workers after <%= unicorn_workers_timeout %> seconds, instead of the default 60
+timeout <%= unicorn_workers_timeout %>
+
+before_fork do |server, worker|
+  # the following is recommended for Rails + "preload_app true"
+  # as there is no need for the master process to hold a connection
+  if defined?(ActiveRecord::Base)
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  # Before forking, kill the master process that belongs to the .oldbin PID.
+  # This enables 0 downtime deploys.
+  old_pid = "<%= unicorn_pid_file %>.oldbin"
+  
+  if File.exists?(old_pid) && server.pid != old_pid
+    begin
+      Process.kill("QUIT", File.read(old_pid).to_i)
+    rescue Errno::ENOENT, Errno::ESRCH
+      # someone else killed it
+    end
+  end
+end
+
+after_fork do |server, worker|
+  # the following is required for Rails + "preload_app true"
+  if defined?(ActiveRecord::Base)
+    ActiveRecord::Base.establish_connection
+  end
+  
+  # if preload_app is true, you may also want to check and
+  # restart any other shared sockets such as Memcached
+end

data/lib/capistrano/recipes/templates/unicorn_init.erb

@@ -0,0 +1,84 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          unicorn
+# Required-Start:    $remote_fs $syslog
+# Required-Stop:     $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Manage unicorn server
+# Description:       Start, stop, restart unicorn server for a specific application.
+### END INIT INFO
+set -e
+
+# Feel free to change any of the following variables for your app:
+TIMEOUT=${TIMEOUT-60}
+APP_ROOT=<%= current_path %>
+PID=<%= unicorn_pid_file %>
+CMD="cd <%= current_path %>; <%= unicorn_command %> -D -c <%= unicorn_config_file %> -E <%= rails_env %>"
+AS_USER=<%= unicorn_user %>
+set -u
+
+OLD_PID="$PID.oldbin"
+
+sig () {
+  test -s "$PID" && kill -$1 `cat $PID`
+}
+
+oldsig () {
+  test -s $OLD_PIN && kill -$1 `cat $OLD_PIN`
+}
+
+run () {
+  if [ "$(id -un)" = "$AS_USER" ]; then
+    eval $1
+  else
+    su -c "$1" - $AS_USER
+  fi
+}
+
+case "$1" in
+start)
+  sig 0 && echo >&2 "Already running" && exit 0
+  run "$CMD"
+  ;;
+stop)
+  kill -s QUIT `cat $PID` && exit 0
+  echo >&2 "Not running"
+  ;;
+force-stop)
+  sig TERM && exit 0
+  echo >&2 "Not running"
+  ;;
+restart|reload)
+  kill -s USR2 `cat $PID` && echo reloaded OK && exit 0
+  echo >&2 "Couldn't reload, starting '$CMD' instead"
+  run "$CMD"
+  ;;
+upgrade)
+  if sig USR2 && sleep 2 && sig 0 && oldsig QUIT
+  then
+    n=$TIMEOUT
+    while test -s $OLD_PIN && test $n -ge 0
+    do
+      printf '.' && sleep 1 && n=$(( $n - 1 ))
+    done
+    echo
+
+    if test $n -lt 0 && test -s $OLD_PIN
+    then
+      echo >&2 "$OLD_PID still exists after $TIMEOUT seconds"
+      exit 1
+    fi
+    exit 0
+  fi
+  echo >&2 "Couldn't upgrade, starting '$CMD' instead"
+  run "$CMD"
+  ;;
+reopen-logs)
+  sig USR1
+  ;;
+*)
+  echo >&2 "Usage: $0 <start|stop|restart|upgrade|force-stop|reopen-logs>"
+  exit 1
+  ;;
+esac

data/lib/capistrano/recipes/unicorn.rb

@@ -0,0 +1,71 @@
+module CapistranoRecipes
+  module Unicorn
+    def self.load_into(configuration)
+      configuration.load do
+        # Start workers with this user
+        _cset :unicorn_user, lambda { user }
+
+        # Number of unicorn workers
+        _cset :unicorn_workers, lambda { 2 }
+
+        # Unicorn workers timeout in seconds
+        _cset :unicorn_workers_timeout, lambda { 15 }
+
+        # Unicorn config template
+        _cset :unicorn_config_template, lambda { File.join templates_path, 'unicorn.rb.erb' }
+
+        # Unicorn config file
+        _cset :unicorn_config_file, lambda { File.join config_path, 'unicorn.rb' }
+
+        # Whether or not to use unicorn init to start on reboot
+        _cset :use_unicorn_init, lambda { true }
+
+        # Unicorn init template
+        _cset :unicorn_init_template, lambda { File.join templates_path, 'unicorn_init.erb' }
+
+        # Unicorn init file
+        _cset :unicorn_init_file, lambda { "/etc/init.d/unicorn-#{application}" }
+
+        # Unicorn pid file
+        _cset :unicorn_pid_file, lambda { File.join pids_path, 'unicorn.pid' }
+
+        # Unicorn log file
+        _cset :unicorn_log_file, lambda { File.join log_path, 'unicorn.log' }
+
+        # Unicorn socket file
+        _cset :unicorn_socket_file, lambda { File.join sockets_path, 'unicorn.sock' }
+
+        # Unicofn command
+        _cset :unicorn_command, lambda { using_recipe?(:bundle) ? 'bundle exec unicorn' : 'unicorn' }
+
+        def using_unicorn_init?
+          fetch(:use_unicorn_init)
+        end
+
+        namespace :unicorn do
+          desc 'Setup unicorn'
+          task :setup, :roles => :app, :except => { :no_release => true } do
+            run "rm -f #{unicorn_socket_file}"
+            upload_template unicorn_config_template, unicorn_config_file
+
+            if using_unicorn_init?
+              upload_template unicorn_init_template, unicorn_init_file, '+x'
+              run "#{sudo} chkconfig --levels 235 unicorn-#{application} on"
+            end
+          end
+          after 'deploy:setup' do
+            unicorn.setup if agree? "Create and upload unicorn config for #{application}?"
+          end
+
+          %w[start stop restart].each do |command|
+            desc "#{command.capitalize} unicorn"
+            task command, :roles => :app, :except => { :no_release => true } do
+              run "#{unicorn_init_file} #{command}"
+            end
+            after "deploy:#{command}", "unicorn:#{command}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/recipes.rb

@@ -0,0 +1 @@
+require 'capistrano_recipes'

data/lib/capistrano_recipes.rb

@@ -0,0 +1,129 @@
+require 'capistrano'
+
+module CapistranoRecipes
+  def self.load_into(configuration)
+      configuration.load('deploy')
+
+      configuration.load do
+        _cset :shared_children, %w(public/system log tmp/pids tmp/sockets)
+        _cset(:domain) { abort "Please specify domain, set :domain, 'domain.com'"}
+        _cset :config_dir, 'config'
+        _cset :config_path, lambda { File.join shared_path, config_dir }
+        _cset :backup_dir, 'backup'
+        _cset :backup_path, lambda { File.join shared_path, backup_dir }
+        _cset :log_path, lambda { File.join shared_path, 'log' }
+        _cset :pids_path, lambda { File.join shared_path, 'pids' }
+        _cset :sockets_path, lambda { File.join shared_path, 'sockets' }
+
+        set :user, 'deployer'
+
+        @used_recipes = []
+
+        class << self
+          attr_reader :used_recipes
+        end
+
+        def use_recipe(recipe_name)
+          return if @used_recipes.include?(recipe_name.to_sym)
+
+          begin
+            require "capistrano/recipes/#{recipe_name}"
+
+            recipe = CapistranoRecipes.const_get(recipe_name.to_s.capitalize.gsub(/_(\w)/) { $1.upcase })
+            recipe.load_into(self)
+            @used_recipes << recipe.to_s.split('::').last.downcase.to_sym
+          rescue LoadError
+            abort "Did you misspell `#{recipe_name}` recipe name?"
+          end
+        end
+
+        def use_recipes(*recipes)
+          recipes.each do |recipe|
+            use_recipe(recipe)
+          end
+        end
+
+        def using_recipe?(recipe)
+          used_recipes.include?(recipe.to_sym)
+        end
+
+        def upload_template(local_file, remote_file, permissions = nil)
+          temp_file = "/tmp/#{File.basename(remote_file)}"
+          template  = parse_template(local_file)
+          put template, temp_file
+          run "chmod #{permissions} #{temp_file}" unless permissions.nil?
+          run "#{sudo} mv #{temp_file} #{remote_file}"
+        end
+
+        def templates_path
+          expanded_path_for('capistrano/recipes/templates')
+        end
+
+        def expanded_path_for(path)
+          e = File.join(File.dirname(__FILE__), path)
+          File.expand_path(e)
+        end
+
+        def parse_template(file)
+          require 'erb'
+          template = File.read(file)
+          return ERB.new(template, nil, '<>').result(binding)
+        end
+
+        def ask(question)
+          q = "\n#{question} : "
+          Capistrano::CLI.ui.ask(q)
+        end
+
+        def agree?(question)
+          q = "\n#{question} : "
+          Capistrano::CLI.ui.agree(q)
+        end
+
+        def password_prompt(prompt)
+          p = "\n#{prompt} : "
+          Capistrano::CLI.password_prompt(p)
+        end
+
+        def say(message)
+          m = "\n#{message}"
+          Capistrano::CLI.ui.say(m)
+        end
+
+        namespace :deploy do
+          desc 'Deploy application'
+          task :default do
+            update
+            restart
+          end
+
+          desc 'Setup servers for deployment'
+          task :setup, :except => { :no_release => true } do
+            dirs = [deploy_to, releases_path, shared_path, config_path, backup_path]
+            dirs += shared_children.map { |d| File.join(shared_path, d.split('/').last) }
+            run "#{try_sudo} mkdir -p #{dirs.join(' ')}"
+            run "#{try_sudo} chmod g+w #{dirs.join(' ')}" if fetch(:group_writable, true)
+          end
+
+          task :restart do
+            # nothing
+            # if task is not being used, it will not appear in `cap -T`
+          end
+
+          task :start do
+            # nothing
+            # if task is not being used, it will not appear in `cap -T`
+          end
+
+          task :stop do
+            # nothing
+            # if task is not being used, it will not appear in `cap -T`
+          end
+        end
+      end
+    end
+  end
+
+  if Capistrano::Configuration.instance
+    CapistranoRecipes.load_into(Capistrano::Configuration.instance)
+  end

data/spec/bundle_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'bundle' do
+
+  before do
+    mock_config do
+      use_recipes :bundle
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'returns used recipe' do
+    config.used_recipes.should == [:bundle]
+  end
+end

data/spec/bundler_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'bundler' do
+  before do
+    mock_config do
+      use_recipes :bundler
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'uses bundler alias for bundle recipe' do
+    config.used_recipes.should == [:bundle]
+  end
+end

data/spec/git_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'git' do
+  before do
+    mock_config do
+      use_recipe :git
+      set :deploy_to, '/foo/bar'
+      def finalize_update; return; end;
+    end
+  end
+
+  it 'has branch' do
+    config.branch.should == 'master'
+  end
+
+  context 'with repository' do
+    before do
+      mock_config { set :repository, 'git@example.com/test-app.git' }
+    end
+
+    describe 'deploy:setup' do
+      before do
+        mock_config do
+          set :shared_path, "#{deploy_to}/shared"
+          set :shared_children, %w(public/system log tmp/pids)
+        end
+      end
+
+      it 'clones repository' do
+        cli_execute 'deploy:setup'
+        config.should have_run('git clone --no-checkout git@example.com/test-app.git /foo/bar/current')
+      end
+    end
+
+    describe 'deploy:update' do
+      it 'updates' do
+        cli_execute 'deploy:update'
+        config.should have_run('cd /foo/bar && git fetch origin && git reset --hard origin/master')
+      end
+    end
+  end
+
+  it 'has current revision' do
+    config.should_receive(:capture).with('cd /foo/bar && git rev-parse --short HEAD') { "baz\n" }
+    config.current_revision.should == 'baz'
+  end
+
+  it 'shows pending' do
+    config.should_receive(:current_revision) { 'baz' }
+    config.namespaces[:deploy].namespaces[:pending].should_receive(:system).with('git log --pretty=medium --stat baz..origin/master')
+    cli_execute 'deploy:pending'
+  end
+
+  it 'sets forward agent' do
+    config.ssh_options[:forward_agent].should == true
+  end
+end

data/spec/multistage_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'multistage' do
+  before do
+    mock_config do
+      use_recipes :multistage
+
+      set :default_stage, :development
+      stage(:development, :branch => 'develop') { set :foo, 'bar' }
+      stage(:production,  :branch => 'master')  { set :foo, 'baz' }
+      stage :another_stage, :foo => 'bar'
+
+      task(:example) {}
+    end
+  end
+
+  it 'uses default stage' do
+    cli_execute 'example'
+    config.current_stage.should == 'development'
+    config.foo.should == 'bar'
+  end
+
+  it 'aborts when no stage selected' do
+    with_stderr do |output|
+      config.unset :default_stage
+      expect { cli_execute 'example' }.to raise_error(SystemExit)
+      output.should include('No stage specified. Please specify one of: development, production')
+    end
+  end
+
+  it 'uses specified stage' do
+    cli_execute %w[production example]
+    config.current_stage.should == 'production'
+    config.foo.should == 'baz'
+  end
+
+  it 'sets variables from options' do
+    cli_execute 'another_stage'
+    config.foo.should == 'bar'
+  end
+
+  it 'accepts default option' do
+    mock_config { stage :to_be_default, :default => true }
+    config.default_stage.should == :to_be_default
+  end
+
+  context 'with git' do
+    before do
+      mock_config { use_recipe :git }
+    end
+
+    it 'infers stage using local branch' do
+      config.stub(:local_branch) { 'master' }
+      cli_execute 'example'
+      config.current_stage.should == 'production'
+      config.branch.should == 'master'
+    end
+
+    it 'uses default state when local branch not matches' do
+      config.stub(:local_branch) { 'foo' }
+      cli_execute 'example'
+      config.current_stage.should == 'development'
+      config.branch.should == 'develop'
+    end
+  end
+end

data/spec/mysql_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'mysql' do
+
+  before do
+    mock_config do
+      use_recipe :mysql
+    end
+  end
+
+  it 'returns used recipe' do
+    config.used_recipes.should == [:mysql]
+  end
+end

data/spec/nginx_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'nginx' do
+
+  before do
+    mock_config do
+      use_recipe :nginx
+      set :application, 'foo'
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'returns used recipe' do
+    config.used_recipes.should == [:nginx]
+  end
+end

data/spec/rails_assets.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'rails assets' do
+  before do
+    mock_config do
+      use_recipe :rails_assets
+      set :application, 'foo'
+      set :deploy_to, '/foo/bar'
+      set :latest_release, deploy_to
+      set :use_sudo, false
+    end
+  end
+
+  describe 'deploy:assets:precompile' do
+    it 'runs precompile' do
+      cli_execute 'deploy:assets:precompile'
+      config.should have_run('[ -e /foo/bar/shared/assets/manifest* ] && cat /foo/bar/shared/assets/manifest* || echo')
+      config.should have_run(' cd -- /foo/bar && rake RAILS_ENV=production RAILS_GROUPS=assets assets:precompile ')
+      config.should have_run('ls -1 /foo/bar/shared/assets/manifest* | wc -l')
+      config.should have_run('ls /foo/bar/shared/assets/manifest*')
+      config.should have_run(" cp -- '' ''/assets_manifest ")
+    end
+  
+    it 'uses bundle command' do
+      mock_config { use_recipe :bundle }
+      cli_execute 'deploy:assets:precompile'
+      config.should have_run(' cd -- /foo/bar && bundle exec rake RAILS_ENV=production RAILS_GROUPS=assets assets:precompile ')
+    end
+  end
+
+  describe 'deploy:assets:clean' do
+    it 'runs clean' do
+      cli_execute 'deploy:assets:clean'
+      config.should have_run('cd /foo/bar && rake RAILS_ENV=production RAILS_GROUPS=assets assets:clean')
+    end
+  end
+end