capistrano-mb 0.22.0

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

@@ -0,0 +1,71 @@
+# Use at least one worker per core if you're on a dedicated server,
+# more will usually help for _short_ waits on databases/caches.
+worker_processes <%= fetch(:mb_unicorn_workers) %>
+
+# Help ensure your application will always spawn in the symlinked
+# "current" directory that Capistrano sets up.
+working_directory "<%= current_path %>"
+
+# listen on both a Unix domain socket
+# we use a shorter backlog for quicker failover when busy
+listen "/tmp/unicorn.<%= application_basename %>.sock", :backlog => 64
+
+# nuke workers after <%= fetch(:mb_unicorn_timeout) %> seconds (default is 60)
+timeout <%= fetch(:mb_unicorn_timeout) %>
+
+pid "<%= fetch(:mb_unicorn_pid) %>"
+
+# By default, the Unicorn logger will write to stderr.
+# Additionally, some applications/frameworks log to stderr or stdout,
+# so prevent them from going to /dev/null when daemonized here:
+stderr_path "<%= fetch(:mb_unicorn_log) %>"
+stdout_path "<%= fetch(:mb_unicorn_log) %>"
+
+preload_app true
+
+# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings
+# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+if GC.respond_to?(:copy_on_write_friendly=)
+  GC.copy_on_write_friendly = true
+end
+
+before_exec do |server|
+  # Ensure unicorn picks up our newest Gemfile
+  ENV['BUNDLE_GEMFILE'] = "<%= current_path %>/Gemfile"
+end
+
+before_fork do |server, worker|
+
+  # the following is highly recomended for Rails + "preload_app true"
+  # as there's no need for the master process to hold a connection
+  if defined? ActiveRecord::Base
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  # This allows a new master process to incrementally
+  # phase out the old master process with SIGTTOU to avoid a
+  # thundering herd (especially in the "preload_app false" case)
+  # when doing a transparent upgrade.  The last worker spawned
+  # will then kill off the old master process with a SIGQUIT.
+  old_pid = "#{server.config[:pid]}.oldbin"
+  if File.exists?(old_pid) && server.pid != old_pid
+    begin
+      sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+      Process.kill(sig, File.read(old_pid).to_i)
+    rescue Errno::ENOENT, Errno::ESRCH
+    end
+  end
+
+  # Throttle the master from forking too quickly by sleeping.  Due
+  # to the implementation of standard Unix signal handlers, this
+  # helps (but does not completely) prevent identical, repeated signals
+  # from being lost when the receiving process is busy.
+  sleep 1
+end
+
+after_fork do |server, worker|
+  # the following is *required* for Rails + "preload_app true"
+  if defined?(ActiveRecord::Base)
+    ActiveRecord::Base.establish_connection
+  end
+end

data/lib/capistrano/mb/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=<%= fetch(:mb_unicorn_pid) %>
+CMD="cd <%= current_path %>; bundle exec unicorn -D -c <%= fetch(:mb_unicorn_config) %> -E <%= fetch(:rails_env) %>"
+AS_USER=<%= unicorn_user %>
+set -u
+
+OLD_PIN="$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)
+  sig QUIT && exit 0
+  echo >&2 "Not running"
+  ;;
+force-stop)
+  sig TERM && exit 0
+  echo >&2 "Not running"
+  ;;
+restart|reload)
+  sig USR2 && 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_PIN 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/mb/templates/version.rb.erb

@@ -0,0 +1,3 @@
+Rails.application.config.version = "<%= git_version[:tag] %>"
+Rails.application.config.version_date = Date.parse("<%= git_version[:date] %>")
+Rails.application.config.version_time = Time.zone.parse("<%= git_version[:time] %>")

data/lib/capistrano/mb/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module MB
+    VERSION = "0.22.0"
+  end
+end

data/lib/capistrano/tasks/aptitude.rake

@@ -0,0 +1,101 @@
+mb_recipe :aptitude do
+  during :provision, %w(upgrade install)
+  before "provision:14_04", "mb:aptitude:install_postgres_repo"
+  before "provision:14_04", "mb:aptitude:change_postgres_packages"
+end
+
+namespace :mb do
+  namespace :aptitude do
+
+    desc "Run `aptitude update` and then run `aptitude safe-upgrade`"
+    task :upgrade do
+      privileged_on roles(:all) do |host|
+        _update
+        _safe_upgrade
+      end
+    end
+
+
+    desc "Run `aptitude install` for packages required by the roles of "\
+         "each server."
+    task :install do
+      privileged_on roles(:all) do |host|
+        packages_to_install = []
+        repos_to_add = []
+
+        _each_package(host) do |pkg, repo|
+          unless _already_installed?(pkg)
+            repos_to_add << repo unless repo.nil?
+            packages_to_install << pkg
+          end
+        end
+
+        repos_to_add.uniq.each { |repo| _add_repository(repo) }
+        _update
+        packages_to_install.uniq.each { |pkg| _install(pkg) }
+      end
+    end
+
+    desc "Add the official apt repository for PostgreSQL"
+    task :install_postgres_repo do
+      privileged_on roles(:all) do |host|
+        _add_repository(
+          "deb http://apt.postgresql.org/pub/repos/apt/ trusty-pgdg main",
+          :key => "https://www.postgresql.org/media/keys/ACCC4CF8.asc")
+      end
+    end
+
+    desc "Change 12.04 PostgreSQL package requirements to 14.04 versions"
+    task :change_postgres_packages do
+      packages = fetch(:mb_aptitude_packages, {})
+      packages = Hash[packages.map do |key, value|
+        [key.sub(/@ppa:pitti\/postgresql$/, ""), value]
+      end]
+      set(:mb_aptitude_packages, packages)
+    end
+
+    def _already_installed?(pkg)
+      test(:sudo, "dpkg", "-s", pkg, "2>/dev/null", "|", :grep, "-q 'ok installed'")
+    end
+
+    def _add_repository(repo, options={})
+      unless _already_installed?("python-software-properties")
+        _install("python-software-properties")
+      end
+      execute :sudo, "apt-add-repository", "-y '#{repo}'"
+
+      if (key = options.fetch(:key, nil))
+        execute "wget --quiet -O - #{key} | sudo apt-key add -"
+      end
+    end
+
+    def _install(pkg)
+      with :debian_frontend => "noninteractive" do
+        execute :sudo, "aptitude", "-y -q install", pkg
+      end
+    end
+
+    def _update
+      with :debian_frontend => "noninteractive" do
+        execute :sudo, "aptitude", "-q -q -y update"
+      end
+    end
+
+    def _safe_upgrade
+      with :debian_frontend => "noninteractive" do
+        execute :sudo, "aptitude", "-q -q -y safe-upgrade"
+      end
+    end
+
+    def _each_package(host)
+      return to_enum(:_each_package, host) unless block_given?
+      hostname = host.hostname
+      fetch(:mb_aptitude_packages).each do |package_spec, *role_list|
+        next unless roles(*role_list.flatten).map(&:hostname).include?(hostname)
+
+        pkg, repo = package_spec.split("@")
+        yield(pkg, repo)
+      end
+    end
+  end
+end

data/lib/capistrano/tasks/crontab.rake

@@ -0,0 +1,14 @@
+mb_recipe :crontab do
+  during :provision, "mb:crontab"
+end
+
+namespace :mb do
+  desc "Install crontab using crontab.erb template"
+  task :crontab do
+    on roles(:cron) do
+      tmp_file = "/tmp/crontab"
+      template "crontab.erb", tmp_file
+      execute "crontab #{tmp_file} && rm #{tmp_file}"
+    end
+  end
+end

data/lib/capistrano/tasks/defaults.rake

@@ -0,0 +1,122 @@
+namespace :load do
+  task :defaults do
+
+    set :mb_recipes, %w(
+      aptitude
+      crontab
+      dotenv
+      logrotate
+      migrate
+      nginx
+      postgresql
+      rbenv
+      seed
+      ssl
+      ufw
+      unicorn
+      user
+      version
+    )
+
+    set :mb_privileged_user, "root"
+
+    set :mb_aptitude_packages,
+        "curl"                                   => :all,
+        "debian-goodies"                         => :all,
+        "git-core"                               => :all,
+        "libpq-dev@ppa:pitti/postgresql"         => :all,
+        "nginx@ppa:nginx/stable"                 => :web,
+        "nodejs@ppa:chris-lea/node.js"           => :all,
+        "postgresql-client@ppa:pitti/postgresql" => :all,
+        "postgresql@ppa:pitti/postgresql"        => :db,
+        "ufw"                                    => :all
+
+    set :mb_delayed_job_args, "-n 2"
+    set :mb_delayed_job_script, "bin/delayed_job"
+
+    set :mb_dotenv_keys, %w(rails_secret_key_base postmark_api_key)
+    set :mb_dotenv_filename, -> { ".env.#{fetch(:rails_env)}" }
+
+    set :mb_log_file, "log/capistrano.log"
+
+    set :mb_nginx_force_https, false
+    set :mb_nginx_redirect_hosts, {}
+
+    ask :mb_postgresql_password, nil, :echo => false
+    set :mb_postgresql_max_connections, 25
+    set :mb_postgresql_pool_size, 5
+    set :mb_postgresql_host, "localhost"
+    set :mb_postgresql_database,
+        -> { "#{application_basename}_#{fetch(:rails_env)}" }
+    set :mb_postgresql_user, -> { application_basename }
+    set :mb_postgresql_pgpass_path,
+        proc{ "#{shared_path}/config/pgpass" }
+    set :mb_postgresql_backup_path, -> {
+      "#{shared_path}/backups/postgresql-dump.dmp"
+    }
+    set :mb_postgresql_backup_exclude_tables, []
+    set :mb_postgresql_dump_options, -> {
+      options = fetch(:mb_postgresql_backup_exclude_tables).map do |t|
+        "-T #{t.shellescape}"
+      end
+      options.join(" ")
+    }
+
+    set :mb_rbenv_ruby_version, -> { IO.read(".ruby-version").strip }
+    set :mb_rbenv_vars, -> {
+      {
+        "RAILS_ENV" => fetch(:rails_env),
+        "PGPASSFILE" => fetch(:mb_postgresql_pgpass_path)
+      }
+    }
+
+    set :mb_sidekiq_concurrency, 25
+    set :mb_sidekiq_role, :sidekiq
+
+    ask :mb_ssl_csr_country, "US"
+    ask :mb_ssl_csr_state, "California"
+    ask :mb_ssl_csr_city, "San Francisco"
+    ask :mb_ssl_csr_org, "Example Company"
+    ask :mb_ssl_csr_name, "www.example.com"
+
+    # WARNING: misconfiguring firewall rules could lock you out of the server!
+    set :mb_ufw_rules,
+        "allow ssh" => :all,
+        "allow http" => :web,
+        "allow https" => :web
+
+    set :mb_unicorn_workers, 2
+    set :mb_unicorn_timeout, 30
+    set :mb_unicorn_config, proc{ "#{current_path}/config/unicorn.rb" }
+    set :mb_unicorn_log, proc{ "#{current_path}/log/unicorn.log" }
+    set :mb_unicorn_pid, proc{ "#{current_path}/tmp/pids/unicorn.pid" }
+
+    set :bundle_binstubs, false
+    set :bundle_flags, "--deployment --retry=3"
+    set :deploy_to, -> { "/home/deployer/apps/#{fetch(:application)}" }
+    set :keep_releases, 10
+    set :linked_dirs, -> {
+        ["public/#{fetch(:assets_prefix, 'assets')}"] +
+        %w(
+          log
+          tmp/pids
+          tmp/cache
+          tmp/sockets
+          public/system
+        )
+    }
+    set :linked_files, -> {
+        [fetch(:mb_dotenv_filename)] +
+        %w(
+          config/database.yml
+          config/unicorn.rb
+        )
+    }
+    set :log_level, :debug
+    set :migration_role, :app
+    set :rails_env, -> { fetch(:stage) }
+    set :ssh_options, :compression => false, :keepalive => true
+
+    SSHKit.config.command_map[:rake] = "bundle exec rake"
+  end
+end

data/lib/capistrano/tasks/delayed_job.rake

@@ -0,0 +1,33 @@
+mb_recipe :delayed_job do
+  during :provision, "init_d"
+  during "deploy:start", "start"
+  during "deploy:stop", "stop"
+  during "deploy:restart", "restart"
+  during "deploy:publishing", "restart"
+end
+
+namespace :mb do
+  namespace :delayed_job do
+    desc "Install delayed_job service script"
+    task :init_d do
+      privileged_on roles(:delayed_job) do |host, user|
+        template "delayed_job_init.erb",
+                 "/etc/init.d/delayed_job_#{application_basename}",
+                 :mode => "a+rx",
+                 :binding => binding,
+                 :sudo => true
+
+        execute "sudo update-rc.d -f delayed_job_#{application_basename} defaults"
+      end
+    end
+
+    %w[start stop restart].each do |command|
+      desc "#{command} delayed_job"
+      task command do
+        on roles(:delayed_job) do
+          execute "service delayed_job_#{application_basename} #{command}"
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/tasks/dotenv.rake

@@ -0,0 +1,57 @@
+mb_recipe :dotenv do
+  during "provision", "update"
+  prior_to "deploy:publishing", "update"
+end
+
+namespace :mb do
+  namespace :dotenv do
+    desc "Replace/create .env file with values provided at console"
+    task :replace do
+      set_up_prompts
+
+      on release_roles(:all) do
+        update_dotenv_file
+      end
+    end
+
+    desc "Update .env file with any missing values"
+    task :update do
+      set_up_prompts
+
+      on release_roles(:all), :in => :sequence do
+        existing_env = if test("[ -f #{shared_dotenv_path} ]")
+          download!(shared_dotenv_path)
+        end
+        update_dotenv_file(existing_env.is_a?(String) ? existing_env : "")
+      end
+    end
+
+    def shared_dotenv_path
+      "#{shared_path}/#{fetch(:mb_dotenv_filename)}"
+    end
+
+    def set_up_prompts
+      fetch(:mb_dotenv_keys).each do |key|
+        if key.to_s =~ /key|token|secret|password/i
+          ask(key, nil, :echo => false)
+        else
+          ask(key, nil)
+        end
+      end
+    end
+
+    def update_dotenv_file(existing="")
+      updated = existing.dup
+
+      fetch(:mb_dotenv_keys).each do |key|
+        next if existing =~ /^#{Regexp.escape(key.upcase)}=/
+        updated << "\n" unless updated.end_with?("\n")
+        updated << "#{key.upcase}=#{fetch(key)}\n"
+      end
+
+      unless existing == updated
+        put(updated, shared_dotenv_path, :mode => "600")
+      end
+    end
+  end
+end