simple-capistrano-unicorn 0.0.7 → 0.0.8

data/README.md

@@ -30,9 +30,35 @@ after :deploy, "unicorn:restart"
 
 ### 4. Add unicorn.rb (only for single-stage setup)
 
-Grab the sample Unicorn configuration here: http://unicorn.bogomips.org/examples/unicorn.conf.rb
+Grab the sample Unicorn configuration here: https://github.com/kaspergrubbe/simple-capistrano-unicorn/blob/master/configs/unicorn.conf.rb
 
-And place it here: `RAILS_ROOT/config/unicorn.rb`
+And place it here: `RAILS_ROOT/config/unicorn.rb` change the `app_root` variable if you deploy user isn't named `deployer`.
+
+#### 4.1 Should my Unicorn suicide or not?
+
+My prefered way of killing off Unicorns is to let Unicorn kill it old master after forking, this means that workers is up when you kill off the old master. If you use the sample unicorn config described here, Unicorn is doing exactly this. You can see it by this:
+
+```ruby
+after_fork do |server, worker|
+  # (...)
+
+  # Kill off the new master after forking
+  old_pid = "#{app_dir}/shared/pids/unicorn.pid.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 did our job for us
+    end
+  end
+end
+```
+
+If you want Unicorn to suicide, set this variable in your `deploy.rb`-file:
+
+```ruby
+set(:unicorn_suicide) { true }
+```
 
 ### 5. Add unicorn stage files (only for multi-stage setup)
 
@@ -71,6 +97,7 @@ The gem gives you access to the following methods within the `unicorn.<method>`
 You can customize the gems behavior by setting any (or all) of the following options within capistrano's configuration:
 
 * `unicorn_pid` indicates the path for the pid file. Defaults to `"#{shared_path}/pids/unicorn.pid"`.
+* `unicorn_suicide` indicates whether Unicorn kills it own master after forking or not. Defaults to `false`.
 * `unicorn_old_pid` indicates the path for the old pid file, which Unicorn creates when forking a new master. Defaults to `#{shared_path}/pids/unicorn.pid.oldbin`.
 * `unicorn_config` the path to the unicorn config file. Defaults to `"#{current_path}/config/unicorn.rb"`.
 * `unicorn_log` the path where unicorn places its STDERR-log. Defaults to `"#{shared_path}/log/unicorn.stderr.log"`.

data/configs/deploy.rb

@@ -0,0 +1,60 @@
+set :application, "testapp"
+set :repository,  "git@github.com:kaspergrubbe/testapp.git"
+set :branch,      "master"
+set :scm,         :git
+
+# Server settings
+set :user,                  "deployer"
+#set :ssh_options,           { :forward_agent => true }
+set :use_sudo,              false
+set :use_bundler,           true
+set :deploy_to,             "/home/#{user}/apps/#{application}"
+
+# Unicorn options
+set :unicorn_suicide,       true
+
+role :web, "176.58.122.173"                          # Your HTTP server, Apache/etc
+role :app, "176.58.122.173"                          # This may be the same as your `Web` server
+role :db,  "176.58.122.173", :primary => true # This is where Rails migrations will run
+role :db,  "176.58.122.173"
+
+# if you want to clean up old releases on each deploy uncomment this:
+after "deploy:restart", "deploy:cleanup"
+
+# Restart unicorn after deploy
+after :deploy, "unicorn:restart"
+
+# The deploy strategies are:
+# checkout (default) - This makes the servers do a git clone to update code
+# export             - This makes a git export instead of checkout (But what really happens is a checkout
+#                      followed by a deletion of the .git-dirs, use checkout instead)
+# remote_cache       - This keeps a remote git repo on the servers, when deploying it does a git pull
+#                      and copies the files to the release path.
+# copy               - This strategy checks out the branch to your local machine, compresses it, and copies
+#                      the code to each server and uncompress it. This is smart when Github is failing.
+#                      But if you live in Belgium and need to upload it to the danish servers, you might
+#                      not want to use it. 
+# 
+# source: https://github.com/capistrano/capistrano/tree/master/lib/capistrano/recipes/deploy/strategy
+#         https://help.github.com/articles/deploying-with-capistrano
+set :deploy_via, :copy
+
+# rbenv
+set :default_environment, {
+  "PATH" => "/home/#{user}/.rbenv/shims:/home/#{user}/.rbenv/bin:$PATH",
+}
+
+# if you're still using the script/reaper helper you will need
+# these http://github.com/rails/irs_process_scripts
+
+# If you are using Passenger mod_rails uncomment this:
+# namespace :deploy do
+#   task :start do ; end
+#   task :stop do ; end
+#   task :restart, :roles => :app, :except => { :no_release => true } do
+#     run "#{try_sudo} touch #{File.join(current_path,'tmp','restart.txt')}"
+#   end
+# end
+
+require "bundler/capistrano"
+require 'simple-capistrano-unicorn'

data/configs/unicorn.conf.rb

@@ -0,0 +1,118 @@
+# config/unicorn.rb
+
+# Sample verbose configuration file for Unicorn (not Rack)
+#
+# This configuration file documents many features of Unicorn
+# that may not be needed for some applications. See
+# http://unicorn.bogomips.org/examples/unicorn.conf.minimal.rb
+# for a much simpler configuration file.
+#
+# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
+# documentation.
+
+# 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 4
+
+app_name = "testapp"
+app_dir  = "/home/deployer/apps/#{app_name}"
+
+# Since Unicorn is never exposed to outside clients, it does not need to
+# run on the standard HTTP port (80), there is no reason to start Unicorn
+# as root unless it's from system init scripts.
+# If running the master process as root and the workers as an unprivileged
+# user, do this to switch euid/egid in the workers (also chowns logs):
+# user "unprivileged_user", "unprivileged_group"
+
+# Help ensure your application will always spawn in the symlinked
+# "current" directory that Capistrano sets up.
+working_directory "#{app_dir}/current" # available in 0.94.0+
+
+# listen on both a Unix domain socket and a TCP port,
+# we use a shorter backlog for quicker failover when busy
+listen "#{app_dir}/shared/system/unicorn.sock", :backlog => 64
+listen 8080, :tcp_nopush => true
+
+# nuke workers after 30 seconds instead of 60 seconds (the default)
+timeout 30
+
+# feel free to point this anywhere accessible on the filesystem
+pid "#{app_dir}/shared/pids/unicorn.pid"
+
+# By default, the Unicorn logger will write to stderr.
+# Additionally, ome applications/frameworks log to stderr or stdout,
+# so prevent them from going to /dev/null when daemonized here:
+stderr_path "#{app_dir}/shared/log/unicorn.stderr.log"
+stdout_path "#{app_dir}/shared/log/unicorn.stdout.log"
+
+# combine Ruby 2.0.0dev or REE with "preload_app true" for memory savings
+# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+preload_app true
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+# Enable this flag to have unicorn test client connections by writing the
+# beginning of the HTTP headers before calling the application.  This
+# prevents calling the application for connections that have disconnected
+# while queued.  This is only guaranteed to detect clients on the same
+# host unicorn runs on, and unlikely to detect disconnects even on a
+# fast LAN.
+check_client_connection false
+
+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!
+
+  # The following is only recommended for memory/DB-constrained
+  # installations.  It is not needed if your system can house
+  # twice as many worker_processes as you have configured.
+  #
+  # # 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 old_pid != server.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|
+  # per-process listener ports for debugging/admin/migrations
+  # addr = "127.0.0.1:#{9293 + worker.nr}"
+  # server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
+
+  # the following is *required* for Rails + "preload_app true",
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+
+  # if preload_app is true, then you may also want to check and
+  # restart any other shared sockets/descriptors such as Memcached,
+  # and Redis.  TokyoCabinet file handles are safe to reuse
+  # between any number of forked children (assuming your kernel
+  # correctly implements pread()/pwrite() system calls)
+
+
+  # Kill off the new master after forking
+  old_pid = "#{app_dir}/shared/pids/unicorn.pid.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 did our job for us
+    end
+  end
+end

data/lib/simple-capistrano-unicorn/namespace.rb

@@ -10,6 +10,7 @@ module SimpleCapistranoUnicorn
         _cset(:unicorn_old_pid) { "#{shared_path}/pids/unicorn.pid.oldbin" }
         _cset(:unicorn_config)  { "#{current_path}/config/unicorn.rb" }
         _cset(:unicorn_log)     { "#{shared_path}/log/unicorn.stderr.log" }
+        _cset(:unicorn_suicide) { false }
         _cset(:use_bundler)     { true }
         _cset(:rails_env)       { "production" }
         _cset(:unicorn_command) { "unicorn" }
@@ -97,7 +98,8 @@ module SimpleCapistranoUnicorn
                 logger.info nice_output("Started Unicorn!", server)
               end
             end
-            unicorn.cleanup
+            # Only clean-up if unicorn don't kill its old master
+            unicorn.cleanup unless unicorn_suicide
           end
 
           desc "Restart of Unicorn with downtime"
@@ -132,6 +134,7 @@ module SimpleCapistranoUnicorn
             logger.info "unicorn_pid:\t#{fetch(:unicorn_pid)}"
             logger.info "unicorn_old_pid:\t#{fetch(:unicorn_old_pid)}"
             logger.info "unicorn_config:\t#{fetch(:unicorn_config)}"
+            logger.info "unicorn_suicide:\t#{fetch(:unicorn_suicide)}"
             logger.info "unicorn_log:\t#{fetch(:unicorn_log)}"
             logger.info "use_bundler:\t#{fetch(:use_bundler)}"
             logger.info "rails_env:   \t#{fetch(:rails_env)}"

data/lib/simple-capistrano-unicorn/version.rb

@@ -1,7 +1,7 @@
 module Capistrano
   module Unicorn
     module Methods
-      VERSION = "0.0.7"
+      VERSION = "0.0.8"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-capistrano-unicorn
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -72,6 +72,8 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- configs/deploy.rb
+- configs/unicorn.conf.rb
 - lib/simple-capistrano-unicorn.rb
 - lib/simple-capistrano-unicorn/namespace.rb
 - lib/simple-capistrano-unicorn/version.rb