capistrano-recipes 0.5.0 → 0.8.0

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

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

data/lib/helpers.rb

@@ -16,8 +16,68 @@ def environment
   end
 end
 
-# Execute a rake task, example:
-#   run_rake log:clear
+def is_using_nginx
+  is_using('nginx',:web_server)
+end
+
+def is_using_passenger
+  is_using('passenger',:app_server)
+end
+
+def is_using_unicorn
+  is_using('unicorn',:app_server)
+end
+
+def is_app_monitored?
+  is_using('bluepill', :monitorer) || 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
+
+# =========================================================================
+# Prompts the user for a message to agree/decline
+# =========================================================================
+def ask(message, default=true)
+  Capistrano::CLI.ui.agree(message)
+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 
+
+# =========================================================================
+# Executes a basic 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,67 @@
+Capistrano::Configuration.instance.load do
+  # User settings
+  set :user, 'deploy'   unless exists?(:user)
+  set :group,'www-data' unless exists?(:group)
+  
+  # Server settings
+  set :app_server, :unicorn       unless exists?(:app_server)
+  set :web_server, :nginx         unless exists?(:web_server)
+  set :runner, user               unless exists?(:runner)
+  set :application_port, 80       unless exists?(:application_port)
+
+  set :application_uses_ssl, true unless exists?(:application_uses_ssl)
+  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)
+  
+  if using_rvm
+    $:.unshift(File.expand_path('./lib', ENV['rvm_path']))  # Add RVM's lib directory to the load path.
+    require "rvm/capistrano"                                # Load RVM's capistrano plugin.
+    
+    # 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)
+  end
+  
+  # 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, 'bluepill' 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/bluepill.rb

@@ -0,0 +1,53 @@
+Capistrano::Configuration.instance.load do  
+  namespace :bluepill do
+    desc "|DarkRecipes| Install the bluepill monitoring tool"
+    task :install, :roles => [:app] do
+      sudo "gem install bluepill"
+    end
+    
+    desc "|DarkRecipes| Stop processes that bluepill is monitoring and quit bluepill"
+    task :quit, :roles => [:app] do
+      args = options || ""
+      begin
+        sudo "bluepill stop #{args}"
+      rescue
+        puts "Bluepill was unable to finish gracefully all the process"
+      ensure
+        sudo "bluepill quit"
+      end
+    end
+    
+    desc "|DarkRecipes| Load the pill from {your-app}/config/pills/{app-name}.pill"
+    task :init, :roles =>[:app] do
+      sudo "bluepill load #{current_path}/config/pills/#{application}.pill"
+    end
+ 
+    desc "|DarkRecipes| Starts your previous stopped pill"
+    task :start, :roles =>[:app] do
+      args = options || ""
+      sudo "bluepill start #{args}"
+    end
+    
+    desc "|DarkRecipes| Stops some bluepill monitored process"
+    task :stop, :roles =>[:app] do
+      args = options || ""
+      sudo "bluepill stop #{args}"
+    end
+    
+    desc "|DarkRecipes| Restarts the pill from {your-app}/config/pills/{app-name}.pill"
+    task :restart, :roles =>[:app] do
+      args = options || ""
+      sudo "bluepill restart #{args}"
+    end
+ 
+    desc "|DarkRecipes| Prints bluepills monitored processes statuses"
+    task :status, :roles => [:app] do
+      args = options || ""
+      sudo "bluepill status #{args}"
+    end
+  end
+    
+  after 'deploy:setup' do
+    bluepill.install if Capistrano::CLI.ui.agree("Do you want to install the bluepill monitor? [Yn]")
+  end if is_using('bluepill', :monitorer)
+end

data/lib/recipes/bundler.rb

@@ -0,0 +1,14 @@
+Capistrano::Configuration.instance.load do
+  namespace :bundler do
+    desc "|DarkRecipes| Installs bundler gem to your server"
+    task :setup, :roles => :app do
+      run "if ! gem list | grep --silent -e 'bundler'; then #{try_sudo} gem uninstall bundler; #{try_sudo} gem install --no-rdoc --no-ri bundler; fi"
+    end
+    
+    desc "|DarkRecipes| Runs bundle install on the app server (internal task)"
+    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

@@ -1,9 +1,37 @@
 require 'erb'
 
-Capistrano::Configuration.instance(:must_exist).load do
+Capistrano::Configuration.instance.load do
   namespace :db do
     namespace :mysql do
-      desc "Create MySQL database and user for this environment using prompted values"
+      desc <<-EOF
+      |DarkRecipes| 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 "|DarkRecipes| 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 "|DarkRecipes| 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 "|DarkRecipes| Create MySQL database and user for this environment using prompted values"
       task :setup, :roles => :db, :only => { :primary => true } do
         prepare_for_db_command
 
@@ -18,10 +46,31 @@ Capistrano::Configuration.instance(:must_exist).load do
             channel.send_data "#{pass}\n" 
           end
         end
-      end      
+      end
+      
+      # 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
     end
     
-    desc "Create database.yml in shared path with settings for current stage and test env"
+    desc "|DarkRecipes| 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:" }
@@ -29,6 +78,7 @@ Capistrano::Configuration.instance(:must_exist).load do
       db_config = ERB.new <<-EOF
       base: &base
         adapter: mysql
+        encoding: utf8
         username: #{db_user}
         password: #{db_pass}
 
@@ -51,4 +101,14 @@ Capistrano::Configuration.instance(:must_exist).load do
     set(:db_user) { Capistrano::CLI.ui.ask "Enter #{environment} database username:" }
     set(:db_pass) { Capistrano::CLI.password_prompt "Enter #{environment} database password:" }
   end
-end
+  
+  desc "Populates the database with seed data"
+  task :seed do
+    Capistrano::CLI.ui.say "Populating the database..."
+    run "cd #{current_path}; rake RAILS_ENV=#{variables[:rails_env]} db:seed"
+  end
+  
+  after "deploy:setup" do
+    db.create_yaml if Capistrano::CLI.ui.agree("Create database.yml in app's shared path? [Yn]")
+  end
+end

data/lib/recipes/deploy.rb

@@ -1,36 +1,106 @@
-Capistrano::Configuration.instance(:must_exist).load do
+Capistrano::Configuration.instance.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
-  
-  after "deploy:update_code", "symlink:shared_config_files"
-  
   namespace :deploy do
+    desc "|DarkRecipes| Deploy it, github-style."
+    task :default, :roles => :app, :except => { :no_release => true } do
+      update
+      restart
+    end
+    
+    desc "|DarkRecipes| Destroys everything"
+    task :seppuku, :roles => :app, :except => { :no_release => true } do
+      run "rm -rf #{current_path}; rm -rf #{shared_path}"
+    end
+    
+    desc "|DarkRecipes| Create shared dirs"
+    task :setup_dirs, :roles => :app, :except => { :no_release => true } do
+      commands = shared_dirs.map do |path|
+        "mkdir -p #{shared_path}/#{path}"
+      end
+      run commands.join(" && ")
+    end
+    
+    desc "|DarkRecipes| Uploads your local config.yml to the server"
+    task :configure, :roles => :app, :except => { :no_release => true } do
+      generate_config('config/config.yml', "#{shared_path}/config/config.yml")
+    end
+    
+    desc "|DarkRecipes| Setup a GitHub-style deployment."
+    task :setup, :roles => :app, :except => { :no_release => true } do
+      run "rm -rf #{current_path}"
+      setup_dirs
+      run "git clone #{repository} #{current_path}"
+    end
+    
+    desc "|DarkRecipes| Update the deployed code."
+    task :update_code, :roles => :app, :except => { :no_release => true } do
+      run "cd #{current_path}; git fetch origin; git reset --hard #{branch}"
+    end
+
+    desc "|DarkRecipes| Alias for symlinks:make"
+    task :symlink, :roles => :app, :except => { :no_release => true } do
+      symlinks.make
+    end
+    
+    desc "|DarkRecipes| Remote run for rake db:migrate"
+    task :migrate, :roles => :app, :except => { :no_release => true } do
+      run "cd #{current_path}; bundle exec rake RAILS_ENV=#{rails_env} db:migrate"
+    end
+
+    desc "|DarkRecipes| [Obsolete] Nothing to cleanup when using reset --hard on git"
+    task :cleanup, :roles => :app, :except => { :no_release => true } do
+      #nothing to cleanup, we're not working with 'releases'
+      puts "Nothing to cleanup, yay!"
+    end
+
+    namespace :rollback do
+      desc "|DarkRecipes| Rollback , :except => { :no_release => true }a single commit."
+      task :default, :roles => :app, :except => { :no_release => true } do
+        set :branch, "HEAD^"
+        deploy.default
+      end    
+    end
+
     desc <<-DESC
-      Restarts your application. If you are running Phusion Passenger, you can \
-      explicitly set the server type:
+      |DarkRecipes| 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 \
+      By default, this will be |DarkRecipes| d 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
+      set :use_sudo, false
     DESC
     task :restart, :roles => :app, :except => { :no_release => true } do
-      if exists?(:server) && fetch(:server).to_s.downcase == 'passenger'
-        passenger.bounce
+      if exists?(:app_server)
+        case fetch(:app_server).to_s.downcase
+          when 'passenger'
+            passenger.bounce
+          when 'unicorn'
+            is_using('god', :monitorer) ? god.restart.app : unicorn.restart
+        end
       else
-        try_runner "#{current_path}/script/process/reaper"
+        puts "Dunno how to restart your internets! kthx!"
       end
     end
   end
-end
+end