dark-capistrano-recipes 0.6.4

data/generators/unicorn.rb.erb

@@ -0,0 +1,62 @@
+rails_root = '<%= "#{deploy_to}/current" %>'
+rails_env  = '<%= environment %>'
+pid_file   = '<%= unicorn_pid %>'
+socket_file= '<%= unicorn_socket %>'
+log_file   = "#{rails_root}/log/unicorn.log"
+username   = '<%= unicorn_user %>'
+group      = '<%= unicorn_group %>'
+old_pid    = pid_file + '.oldbin'
+
+
+timeout <%= unicorn_workers_timeout %>
+
+worker_processes <%= unicorn_workers %>
+
+# Listen on a Unix data socket
+listen socket_file, :backlog => 1024
+pid pid_file
+
+stderr_path log_file
+stdout_path log_file
+
+preload_app true
+##
+# REE
+
+GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
+
+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
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+
+  
+  ##
+  # When sent a USR2, Unicorn will suffix its pidfile with .oldbin and
+  # immediately start loading up a new version of itself (loaded with a new
+  # version of our app). When this new Unicorn is completely loaded
+  # it will begin spawning workers. The first worker spawned will check to
+  # see if an .oldbin pidfile exists. If so, this means we've just booted up
+  # a new Unicorn and need to tell the old one that it can now die. To do so
+  # we send it a QUIT.
+  #
+  # Using this method we get 0 downtime deploys.
+
+  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 did our job for us
+    end
+  end
+end
+
+
+after_fork do |server, worker|
+    defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+
+
+  worker.user(username, group) if Process.euid == 0 && rails_env == 'production'
+end

data/lib/capistrano_recipes.rb

@@ -0,0 +1,5 @@
+require 'capistrano'
+require 'capistrano/cli'
+require 'helpers'
+
+Dir.glob(File.join(File.dirname(__FILE__), '/recipes/*.rb')).sort.each { |f| load f }

data/lib/helpers.rb

@@ -0,0 +1,70 @@
+# =========================================================================
+# These are helper methods that will be available to your recipes.
+# =========================================================================
+
+# automatically sets the environment based on presence of 
+# :stage (multistage gem), :rails_env, or RAILS_ENV variable; otherwise defaults to 'production'
+def environment  
+  if exists?(:stage)
+    stage
+  elsif exists?(:rails_env)
+    rails_env  
+  elsif(ENV['RAILS_ENV'])
+    ENV['RAILS_ENV']
+  else
+    "production"  
+  end
+end
+
+def is_using_nginx
+  is_using('nginx',:web_server)
+end
+
+def is_using_unicorn
+  is_using('unicorn',:server)
+end
+
+def is_using_god
+  is_using('god',:monitorer)
+end
+
+def is_using(something, with_some_var)
+ exists?(with_some_var.to_sym) && fetch(with_some_var.to_sym).to_s.downcase == something
+end
+
+# Path to where the generators live
+def templates_path
+  expanded_path_for('../generators')
+end
+
+def docs_path
+  expanded_path_for('../doc')
+end
+
+def expanded_path_for(path)
+  e = File.join(File.dirname(__FILE__),path)
+  File.expand_path(e)
+end
+
+def parse_config(file)
+  require 'erb'  #render not available in Capistrano 2
+  template=File.read(file)          # read it
+  return ERB.new(template).result(binding)   # parse it
+end
+
+# Generates a configuration file parsing through ERB
+# Fetches local file and uploads it to remote_file
+# Make sure your user has the right permissions.
+def generate_config(local_file,remote_file)
+  temp_file = '/tmp/' + File.basename(local_file)
+  buffer    = parse_config(local_file)
+  File.open(temp_file, 'w+') { |f| f << buffer }
+  upload temp_file, remote_file, :via => :scp
+  `rm #{temp_file}`
+end 
+
+# Execute a rake task, example:
+#   run_rake log:clear
+def run_rake(task)
+  run "cd #{current_path} && rake #{task} RAILS_ENV=#{environment}"
+end

data/lib/recipes/application.rb

@@ -0,0 +1,68 @@
+Capistrano::Configuration.instance(:must_exist).load do
+
+  # User settings
+  set :user, 'deploy'   unless exists?(:user)
+  set :group,'www-data' unless exists?(:group)
+  
+  
+  # Server settings
+  set :server, :unicorn   unless exists?(:server)
+  set :web_server, :nginx unless exists?(:web_server)
+  set :runner, user       unless exists?(:runner)
+  
+  # The port to listen to, normally we default to 80
+  set :application_port, 80 unless exists?(:application_port)
+  
+  # Are we using ssl as well? Used by generators to configure a ssl host
+  set :application_uses_ssl, true unless exists?(:application_uses_ssl)
+  
+  # The port to listen to https requests, usually 443
+  set :application_port_ssl, 443 unless exists?(:application_port_ssl)
+  
+  # Database settings
+  set :database, :mysql unless exists?(:database)
+  
+  # SCM settings
+  set :scm, :git
+  set :branch, 'master' unless exists?(:branch)
+  set :deploy_to, "/var/www/apps/#{application}" unless exists?(:deploy_to)
+  set :deploy_via, :remote_cache
+  set :keep_releases, 3
+  set :git_enable_submodules, true
+  set :rails_env, 'production' unless exists?(:rails_env)
+  set :use_sudo, false
+
+  # Git settings for capistrano
+  default_run_options[:pty] = true 
+  ssh_options[:forward_agent] = true
+  
+  # RVM settings
+  set :using_rvm, true unless exists?(:using_rvm)
+  # Sets the rvm to a specific version (or whatever env you want it to run in)
+  set :rvm_ruby_string, 'ree' unless exists?(:rvm_ruby_string)  
+  
+  # Daemons settings
+  # The unix socket that unicorn will be attached to.
+  # Also, nginx will upstream to this guy.
+  # The *nix place for socks is /var/run, so we should probably put it there
+  # Make sure the runner can access this though.
+  set :sockets_path, "/var/run/#{application}" unless exists?(:sockets_path)
+  
+  # Just to be safe, put the pid somewhere that survives deploys. shared/pids is
+  # a good choice as any.
+  set(:pids_path) { File.join(shared_path, "pids") } unless exists?(:pids_path)
+  
+  set :monitorer, 'god' unless exists?(:monitorer)
+  
+  # Application settings  
+  set :shared_dirs, %w( config uploads backup bundle tmp ) unless exists?(:shared_dirs)
+  
+  namespace :app do
+    task :setup, :roles => :app do
+      commands = shared_dirs.map do |path|
+        "if [ ! -d '#{path}' ]; then mkdir -p #{path}; fi;"
+      end
+      run "cd #{shared_path}; #{commands.join(' ')}"
+    end
+  end
+end

data/lib/recipes/bundler.rb

@@ -0,0 +1,19 @@
+ Bundler
+# Manages gems in a sane way.
+# http://gembundler.com/
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :bundler do
+    set :bundler_ver, '1.0.0'
+    desc "Installs bundler gem to your server"
+    task :setup, :roles => :app do
+      run "if ! gem list | grep --silent -e 'bundler.*#{bundler_ver}'; then #{try_sudo} gem uninstall bundler; #{try_sudo} gem install --no-rdoc --no-ri bundler; fi"
+    end
+    
+    # [internal] runs bundle install on the app server
+    task :install, :roles => :app, :except => { :no_release => true } do
+      run "cd #{current_path} && bundle install --deployment --without=development test"
+    end
+  end  
+    
+end
+

data/lib/recipes/db.rb

@@ -0,0 +1,105 @@
+require 'erb'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :db do
+    namespace :mysql do
+    
+      # Sets database variables from remote database.yaml
+      def prepare_from_yaml
+        set(:db_file) { "#{application}-dump.sql.bz2" }
+        set(:db_remote_file) { "#{shared_path}/backup/#{db_file}" }
+        set(:db_local_file)  { "tmp/#{db_file}" }
+        set(:db_user) { db_config[rails_env]["username"] }
+        set(:db_pass) { db_config[rails_env]["password"] }
+        set(:db_host) { db_config[rails_env]["host"] }
+        set(:db_name) { db_config[rails_env]["database"] }
+      end
+        
+      def db_config
+        @db_config ||= fetch_db_config
+      end
+
+      def fetch_db_config
+        require 'yaml'
+        file = capture "cat #{shared_path}/config/database.yml"
+        db_config = YAML.load(file)
+      end
+
+      desc <<-EOF
+      Performs a compressed database dump. \
+      WARNING: This locks your tables for the duration of the mysqldump.
+      Don't run it madly!
+      EOF
+      task :dump, :roles => :db, :only => { :primary => true } do
+        prepare_from_yaml
+        run "mysqldump --user=#{db_user} -p --host=#{db_host} #{db_name} | bzip2 -z9 > #{db_remote_file}" do |ch, stream, out|
+        ch.send_data "#{db_pass}\n" if out =~ /^Enter password:/
+          puts out
+        end
+      end
+
+      desc "Restores the database from the latest compressed dump"
+      task :restore, :roles => :db, :only => { :primary => true } do
+        prepare_from_yaml
+        run "bzcat #{db_remote_file} | mysql --user=#{db_user} -p --host=#{db_host} #{db_name}" do |ch, stream, out|
+        ch.send_data "#{db_pass}\n" if out =~ /^Enter password:/
+          puts out
+        end
+      end
+
+      desc "Downloads the compressed database dump to this machine"
+      task :fetch_dump, :roles => :db, :only => { :primary => true } do
+        prepare_from_yaml
+        download db_remote_file, db_local_file, :via => :scp
+      end
+    
+    
+      desc "Create MySQL database and user for this environment using prompted values"
+      task :setup, :roles => :db, :only => { :primary => true } do
+        prepare_for_db_command
+
+        sql = <<-SQL
+        CREATE DATABASE #{db_name};
+        GRANT ALL PRIVILEGES ON #{db_name}.* TO #{db_user}@localhost IDENTIFIED BY '#{db_pass}';
+        SQL
+
+        run "mysql --user=#{db_admin_user} -p --execute=\"#{sql}\"" do |channel, stream, data|
+          if data =~ /^Enter password:/
+            pass = Capistrano::CLI.password_prompt "Enter database password for '#{db_admin_user}':"
+            channel.send_data "#{pass}\n" 
+          end
+        end
+      end      
+    end
+    
+    desc "Create database.yml in shared path with settings for current stage and test env"
+    task :create_yaml do      
+      set(:db_user) { Capistrano::CLI.ui.ask "Enter #{environment} database username:" }
+      set(:db_pass) { Capistrano::CLI.password_prompt "Enter #{environment} database password:" }
+      
+      db_config = ERB.new <<-EOF
+      base: &base
+        adapter: mysql
+        username: #{db_user}
+        password: #{db_pass}
+
+      #{environment}:
+        database: #{application}_#{environment}
+        <<: *base
+
+      test:
+        database: #{application}_test
+        <<: *base
+      EOF
+
+      put db_config.result, "#{shared_path}/config/database.yml"
+    end
+  end
+    
+  def prepare_for_db_command
+    set :db_name, "#{application}_#{environment}"
+    set(:db_admin_user) { Capistrano::CLI.ui.ask "Username with priviledged database access (to create db):" }
+    set(:db_user) { Capistrano::CLI.ui.ask "Enter #{environment} database username:" }
+    set(:db_pass) { Capistrano::CLI.password_prompt "Enter #{environment} database password:" }
+  end
+end

data/lib/recipes/deploy.rb

@@ -0,0 +1,105 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  set :shared_children, %w(system log pids config)
+
+  after "deploy:setup" do
+    db.create_yaml if Capistrano::CLI.ui.agree("Create database.yml in app's shared path?")  
+  end
+  
+  
+  namespace :deploy do
+    desc "Deploy it, github-style."
+    task :default do
+      update
+      restart
+    end
+    
+    desc "[Seppuku] Destroy everything"
+    task :seppuku do
+      run "rm -rf #{current_path}; rm -rf #{shared_path}"
+      rubycas.seppuku
+    end
+    
+     task :setup_dirs, :except => { :no_release => true } do
+      commands = shared_dirs.map do |path|
+        "mkdir -p #{shared_path}/#{path}"
+      end
+      run commands.join(" && ")
+    end
+    
+    desc "Uploads your local config.yml to the server"
+    task :configure, :except => { :no_release => true } do
+      generate_config('config/config.yml', "#{shared_path}/config/config.yml")
+    end
+    
+    desc "Setup a GitHub-style deployment."
+    task :setup, :except => { :no_release => true } do
+      run "rm -rf #{current_path}"
+      setup_dirs
+      run "git clone #{repository} #{current_path}"
+    end
+    
+    desc "Update the deployed code."
+    task :update_code, :except => { :no_release => true } do
+      run "cd #{current_path}; git fetch origin; git reset --hard #{branch}"
+    end
+
+    task :symlink, :except => { :no_release => true } do
+      symlinks.make
+    end
+
+    desc "[Obsolete] Nothing to cleanup when using reset --hard on git"
+    task :cleanup, :except => { :no_release => true } do
+      #nothing to cleanup, we're not working with 'releases'
+      puts "Nothing to cleanup, yay!"
+    end
+
+    namespace :rollback do
+      desc "Rollback a single commit."
+      task :default, :except => { :no_release => true } do
+        set :branch, "HEAD^"
+        deploy.default
+      end    
+    end
+
+    desc <<-DESC
+      Restarts your application. This depends heavily on what server you're running. 
+      If you are running Phusion Passenger, you can explicitly set the server type:
+      
+        set :server, :passenger
+          
+      ...which will touch tmp/restart.txt, a file monitored by Passenger.
+
+      If you are running Unicorn, you can set:
+      
+        set :server, :unicorn
+      
+      ...which will use unicorn signals for restarting its workers.
+
+      Otherwise, this command will call the script/process/reaper \
+      script under the current path.
+      
+      If you are running with Unicorn, you can set the server type as well:
+      
+      set :server, :unicorn
+
+      By default, this will be invoked via sudo as the `app' user. If \
+      you wish to run it as a different user, set the :runner variable to \
+      that user. If you are in an environment where you can't use sudo, set \
+      the :use_sudo variable to false:
+
+        set :use_sudo, false
+    DESC
+    task :restart, :roles => :app, :except => { :no_release => true } do
+      if exists?(:server)
+        case fetch(:server).to_s.downcase
+          when 'passenger'
+            passenger.bounce
+          when 'unicorn'
+            is_using_god ? god.restart_unicorn : unicorn.restart
+        end
+      else
+        puts "Dunno how to restart your internets! kthx!"
+      end
+    end
+  end
+end

data/lib/recipes/god.rb

@@ -0,0 +1,114 @@
+# God Monitoring Tool
+# God is a Process Monitoring Framework written in Ruby
+# More info at http://god.rubyforge.org/
+#------------------------------------------------------------------------------
+Capistrano::Configuration.instance(:must_exist).load do
+  _cset(:god_local_config)  { "#{templates_path}/app.god.erb" }
+  _cset(:god_remote_config) { "#{shared_path}/config/app.god" }
+
+  namespace :god do
+    
+    desc "Parses and uploads god configuration for this app"
+    task :setup do
+      generate_config(god_local_config, god_remote_config)
+    end
+
+    _cset(:bin_god) { defined?(:rvm_ruby_string) ? 'bootup_god' : 'god' }
+    _cset(:server_name)    { "#{application}-unicorn" }
+    _cset(:god_init_local) { "#{docs_path}/god/god.init" }
+    _cset :god_init_temp,   '/tmp/god.init'
+    _cset :god_init_remote, '/etc/init.d/god'
+    _cset(:god_defo_local) { "#{docs_path}/god/god"}
+    _cset :god_defo_temp,   '/tmp/god'
+    _cset :god_defo_remote, '/etc/default/god'
+    _cset(:god_conf_local) { "#{docs_path}/god/god.conf" }
+    _cset :god_conf_temp,   '/tmp/god.conf'
+    _cset :god_conf_remote, '/etc/god/god.conf'
+    
+    
+    task :setup_temp, :roles => :app do
+      sudo "rm -f #{god_conf_remote} #{god_init_remote} #{god_defo_remote}"
+    end
+    
+    task :setup_conf, :roles => :app do
+      upload god_conf_local, god_conf_temp, :via => :scp
+      sudo "mkdir -p #{File.dirname(god_conf_remote)}"
+      sudo "mv #{god_conf_temp} #{god_conf_remote}"
+    end
+    
+    task :setup_init, :roles => :app do
+      upload god_init_local, god_init_temp, :via => :scp
+      sudo "mv #{god_init_temp} #{god_init_remote}"  
+      # Allow executing the init.d script
+      sudo "chmod +x #{god_init_remote}"
+      # Make it run at bootup     
+      sudo "update-rc.d god defaults"    
+    end
+    
+    task :setup_defo, :roles => :app do
+      upload god_defo_local, god_defo_temp, :via => :scp
+      sudo "mv #{god_defo_temp} #{god_defo_remote}"
+    end
+    
+    desc "Bootstraps god on your server. Be careful with this."
+    task :bootstrap, :roles => :app do
+      setup_temp
+      setup_defo
+      setup_init
+      setup_conf    
+
+      puts "God is bootstrapped. To remove use 'cap god:implode'"
+    end
+    
+    desc "(Seppuku) Completely remove god from the system init"
+    task :implode, :roles => :app do
+      #  Removing any system startup links for /etc/init.d/god ...
+      sudo "update-rc.d -f god remove"
+      
+      # Suicide follows.
+      sudo "rm -f #{god_conf_remote}"
+      sudo "rm -f #{god_defo_remote}"
+      sudo "rm -f #{god_init_remote}"
+      puts "God is no more."
+    end
+    
+    task :restart_unicorn, :roles => :app do
+      sudo "#{bin_god} restart #{server_name}"
+    end
+    
+    task :log, :roles => :app do
+      sudo "#{bin_god} log #{application}"
+    end
+    
+    desc "Reload config"
+    task :reload, :roles => :app do
+      sudo "#{bin_god} load #{god_remote_config}"
+    end
+
+    desc "Start god service"
+    task :start, :roles => :app do
+      sudo "service god start"
+    end
+    
+    desc "Stops god service"
+    task :stop, :roles => :app do
+      sudo "service god stop"
+    end
+        
+    desc "Quit god, but not the processes it's monitoring"
+    task :quit, :roles => :app do
+      sudo "#{bin_god} quit"
+    end
+
+    desc "Terminate god and all monitored processes"
+    task :terminate, :roles => :app do
+      sudo "#{bin_god} terminate"
+    end
+
+    desc "Describe the status of the running tasks"
+    task :status, :roles => :app do
+      sudo "#{bin_god} status"
+    end
+  end
+  after 'deploy:setup', 'god:setup' if is_using_god
+end