capistrano-runit 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.markdown

@@ -0,0 +1 @@
+TODO: Write README!

data/capistrano-runit.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "capistrano-runit"
+  s.version = "1.0.0"
+  s.summary = "Useful deployment recipes."
+  s.homepage = "http://github.com/antage/capistrano-runit"
+  s.author = "Anton Ageev"
+  s.email = "antage@gmail.com"
+  s.files = `git ls-files`.split
+  s.add_dependency "capistrano", ">= 2.0.0"
+end
+
+# vim:ts=2 sw=2 ft=ruby

data/lib/capistrano-runit/recipes/base.rb

@@ -0,0 +1,13 @@
+Capistrano::Configuration.instance(true).load do
+  _cset :runit_dir, defer { "#{deploy_to}/runit" }
+
+  namespace :runit do
+    desc "Setup runit directories"
+    task :setup, :roles => :app do
+      run "[ -d #{runit_dir}/.env ] || mkdir -p #{runit_dir}/.env"
+      run "echo $HOME > #{runit_dir}/.env/HOME"
+      run "[ -d #{runit_dir}/available ] || mkdir -p #{runit_dir}/available"
+      run "[ -d #{runit_dir}/enabled ] || mkdir -p #{runit_dir}/enabled"
+    end
+  end
+end

data/lib/capistrano-runit/recipes/delayed_job.rb

@@ -0,0 +1,36 @@
+Capistrano::Configuration.instance(true).load do
+  _cset :runit_delayed_job_service_name, "delayed_job"
+  _cset :runit_delayed_job_template, File.expand_path(File.join(File.dirname(__FILE__), "../templates/run-delayed_job.erb"))
+  _cset :runit_delayed_job_command, "./script/delayed_job"
+
+  namespace :runit do
+    namespace :delayed_job do
+      desc "Setup delayed_job runit-service"
+      task :setup, :roles => :app do
+        run "[ -d #{runit_dir}/available/#{runit_delayed_job_service_name} ] || mkdir -p #{runit_dir}/available/#{runit_delayed_job_service_name}"
+        template = File.read(runit_delayed_job_template)
+        erb_template = ERB.new(template)
+        servers = find_servers_for_task(current_task)
+        servers.each do |server|
+          put erb_template.result(binding), "#{runit_dir}/available/#{runit_delayed_job_service_name}/run", :mode => 0755, :hosts => server.host
+        end
+        find_and_execute_task "runit:delayed_job:enable"
+      end
+
+      desc "Enable delayed_job runit-service"
+      task :enable, :roles => :app do
+        run "cd #{runit_dir}/enabled && [ -h ./#{runit_delayed_job_service_name} ] || ln -sf ../available/#{runit_delayed_job_service_name} ."
+      end
+
+      desc "Disable delayed_job runit-service"
+      task :disable, :roles => :app do
+        run "[ ! -h #{runit_dir}/enabled/#{runit_delayed_job_service_name} ] || sv stop #{runit_dir}/enabled/#{runit_delayed_job_service_name}/ && rm -f #{runit_dir}/enabled/#{runit_delayed_job_service_name}"
+      end
+
+      desc "Restart delayed_job runit-service"
+      task :restart, :roles => :app do
+        run "[ ! -h #{runit_dir}/enabled/#{runit_delayed_job_service_name} ] || sv restart #{runit_dir}/enabled/#{runit_delayed_job_service_name}/"
+      end
+    end
+  end
+end

data/lib/capistrano-runit/recipes/unicorn.rb

@@ -0,0 +1,58 @@
+Capistrano::Configuration.instance(true).load do
+  _cset :runit_unicorn_service_name, "unicorn"
+  _cset :runit_unicorn_template, File.expand_path(File.join(File.dirname(__FILE__), "../templates/run-unicorn.erb"))
+  _cset :runit_unicorn_command, "unicorn"
+  _cset :runit_unicorn_workers, 4
+  _cset :runit_unicorn_listen, "127.0.0.1"
+  _cset :runit_unicorn_port, 8080
+  _cset :runit_unicorn_after_fork_code, ""
+
+  namespace :runit do
+    namespace :unicorn do
+      desc "Setup Unicorn runit-service"
+      task :setup, :roles => :app do
+        run "[ -d #{runit_dir}/available/#{runit_unicorn_service_name} ] || mkdir -p #{runit_dir}/available/#{runit_unicorn_service_name}"
+        template = File.read(runit_unicorn_template)
+        erb_template = ERB.new(template)
+        servers = find_servers_for_task(current_task)
+        servers.each do |server|
+          runit_unicorn_listen_current =
+            if runit_unicorn_listen.is_a?(Hash)
+              runit_unicorn_listen[server.host]
+            else
+              runit_unicorn_listen
+            end
+          runit_unicorn_port_current =
+            if runit_unicorn_port.is_a?(Hash)
+              runit_unicorn_port[server.host]
+            else
+              runit_unicorn_port
+            end
+          runit_unicorn_workers_current =
+            if runit_unicorn_workers.is_a?(Hash)
+              runit_unicorn_workers[server.host]
+            else
+              runit_unicorn_workers
+            end
+          put erb_template.result(binding), "#{runit_dir}/available/#{runit_unicorn_service_name}/run", :mode => 0755, :hosts => server.host
+        end
+        find_and_execute_task "runit:unicorn:enable"
+      end
+
+      desc "Enable Unicorn runit-service"
+      task :enable, :roles => :app do
+        run "cd #{runit_dir}/enabled && [ -h ./#{runit_unicorn_service_name} ] || ln -sf ../available/#{runit_unicorn_service_name} ."
+      end
+
+      desc "Enable Unicorn runit-service"
+      task :disable, :roles => :app do
+        run "[ ! -h #{runit_dir}/enabled/#{runit_unicorn_service_name} ] || sv stop #{runit_dir}/enabled/#{runit_unicorn_service_name}/ && rm -f #{runit_dir}/enabled/#{runit_unicorn_service_name}"
+      end
+
+      desc "Restart Unicorn runit-service"
+      task :restart, :roles => :app do
+        run "[ ! -h #{runit_dir}/enabled/#{runit_unicorn_service_name} ] || sv restart #{runit_dir}/enabled/#{runit_unicorn_service_name}/"
+      end
+    end
+  end
+end

data/lib/capistrano-runit/recipes.rb

@@ -0,0 +1,3 @@
+require "capistrano-runit/recipes/base"
+require "capistrano-runit/recipes/unicorn"
+require "capistrano-runit/recipes/delayed_job"

data/lib/capistrano-runit/templates/run-delayed_job.erb

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd <%= current_path %>
+<%= runit_delayed_job_command %> run

data/lib/capistrano-runit/templates/run-unicorn.erb

@@ -0,0 +1,157 @@
+#!/bin/bash -e
+
+#
+# Supervises unicorn; stopping this service prompts a graceful shutdown of the
+# current unicorn instance. Sending HUP to this service causes unicorn to re-exec
+# itself for upgrades etc.
+#
+
+ADDR=<%= runit_unicorn_listen_current %>
+PORT=<%= runit_unicorn_port_current %>
+APP_DIR="<%= current_path %>"
+THIS_DIR=$(pwd)
+CUR_PID_FILE=$APP_DIR/tmp/pids/unicorn.pid
+OLD_PID_FILE=$CUR_PID_FILE.oldbin
+
+
+if [ ! -d "$APP_DIR" ]; then
+  echo "no such app dir: $APP_DIR" 1>&2;
+  exit 2
+fi
+
+cat <<EOF > unicorn.rb
+working_directory "$APP_DIR"
+pid "$CUR_PID_FILE"
+
+worker_processes <%= runit_unicorn_workers_current %>
+
+preload_app true
+
+# Restart any workers that haven't responded in 30 seconds
+timeout 60
+
+# listen on both a Unix domain socket and a TCP port,
+#listen '$THIS_DIR/socket', :backlog => 64
+listen '$ADDR:$PORT', :tcp_nopush => true
+
+stderr_path "log/unicorn.stderr.log"
+stdout_path "log/unicorn.stdout.log"
+
+# http://www.rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+if GC.respond_to?(:copy_on_write_friendly=)
+  GC.copy_on_write_friendly = true
+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
+
+  ##
+  # 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.
+
+  old_pid = "$APP_DIR/tmp/pids/unicorn.pid.oldbin"
+  if File.exists?(old_pid) && server.pid != old_pid
+    begin
+      puts "Shutting down old process"
+      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|
+  ##
+  # Unicorn master loads the app then forks off workers - because of the way
+  # Unix forking works, we need to make sure we aren't using any of the parent's
+  # sockets, e.g. db connection
+
+  if defined?(::ActiveRecord::Base)
+    ::ActiveRecord::Base.establish_connection
+  end
+
+  # Redis and Memcached would go here but their connections are established
+  # on demand, so the master never opens a socket
+  <% unless fetch(:runit_unicorn_after_fork_code, nil).nil? %>
+    <%= runit_unicorn_after_fork_code %>
+  <% end %>
+end
+EOF
+
+function is_pid_running() {
+    set +e
+    if [ -n $1 ] && kill -0 $1 >/dev/null 2>&1; then
+        echo "yes"
+    fi
+    set -e
+}
+
+echo "My pid: $$"
+
+if [ -e $OLD_PID_FILE ]; then
+    OLD_PID=$(cat $OLD_PID_FILE)
+    echo "Unicorn appears to be restarting: waiting for old master ($OLD_PID) to exit"
+    while [ -n "$(is_pid_running $OLD_PID)" ]; do
+        /bin/echo -n '.'
+        sleep 2
+    done
+fi
+
+if [ -e $CUR_PID_FILE ]; then
+    CUR_PID=$(cat $CUR_PID_FILE)
+    if [ -n "$(is_pid_running $CUR_PID)" ]; then
+        echo "Already running as $CUR_PID"
+        RUNNING=true
+    fi
+fi
+
+if [ ! $RUNNING ]; then
+    echo "Starting unicorn"
+    old=$(pwd)
+    cd $APP_DIR
+    <%= runit_unicorn_command %> -E production -c $THIS_DIR/unicorn.rb -D
+    cd $old
+    sleep 2
+    CUR_PID=$(cat $CUR_PID_FILE)
+fi
+
+function restart() {
+    # TODO: regenerate config if this file has changed
+
+    # Tell unicorn to re-exec itself
+    echo "Asking unicorn to re-exec itself with USR2"
+    kill -USR2 $CUR_PID
+    # Wait and then exit -- after runit restarts the script, we'll
+    # wait for the re-exec'd process
+    sleep 2
+    echo "Restarting to supervise new unicorn"
+    exit
+}
+
+function graceful_shutdown() {
+    echo "Requesting graceful shutdown"
+    kill -QUIT $CUR_PID
+}
+
+trap restart HUP QUIT
+trap graceful_shutdown INT TERM
+
+echo "Watching for unicorn ($CUR_PID) exiting"
+while [ -n "$(is_pid_running $CUR_PID)" ]; do
+    /bin/echo -n '.'
+    sleep 2
+done
+echo "Unicorn has exited."

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano-runit
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Anton Ageev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-15 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: antage@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- capistrano-runit.gemspec
+- lib/capistrano-runit/recipes.rb
+- lib/capistrano-runit/recipes/base.rb
+- lib/capistrano-runit/recipes/delayed_job.rb
+- lib/capistrano-runit/recipes/unicorn.rb
+- lib/capistrano-runit/templates/run-delayed_job.erb
+- lib/capistrano-runit/templates/run-unicorn.erb
+has_rdoc: true
+homepage: http://github.com/antage/capistrano-runit
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Useful deployment recipes.
+test_files: []
+