red_unicorn 1.0.0

data/CHANGELOG.rdoc

@@ -0,0 +1,2 @@
+== v1.0.0
+* Initial release

data/README.rdoc

@@ -0,0 +1,43 @@
+== RedUnicorn
+
+RedUnicorn provides easy interaction with unicorn processes. It uses signals
+to communicate with unicorn to check its status, stop the processes or to
+provide zero downtime restarts. 
+
+=== Usage
+
+  $ red_unicorn --help
+  RedUnicorn::Unicorn: Unicorn process interactions
+  Usage: red_unicorn [opts] (prolicide | status | slaughter | start | restart | reload | stop | birth)
+   -h, --help                             Show this help screen
+   -p, --pid /path/to/file.pid            Specify path to PID file (default: /var/run/unicorn/unicorn.pid)
+   -x, --unicorn-exec /path/to/unicorn    Specify path to unicorn executable (default: /var/www/shared/bundle/bin/unicorn_rails)
+   -c, --unicorn-config /path/to/config   Specify path to unicorn configuration file (default: /etc/unicorn/app.rb)
+   -t, --timeout 30                       Specify timeout for running actions
+   -e, --env production                   Specify environment (default: production)
+  Commands:
+    prolicide:        Kill single worker process
+    status:           Returns current unicorn status
+    slaughter:        Kill all worker processes (master remains)
+    start:            Start unicorn
+    restart:          Gracefully restart unicorn (zero downtime)
+    reload:           Reload unicorn configuration
+    stop:             Stop unicorn
+    birth:            Create new worker process
+
+=== Zero downtime restarts
+
+RedUnicorn does its best to provide true zero downtime restarts. After sending
+unicorn the restart signal, it will wait until the new unicorn process has forked
+out workers before killing the original unicorn process. If no worker processes
+are started, the old unicorn process will be left running.
+
+== Bugs and Feature requests
+
+* Fork, make updates and send pull request
+* Report bugs through github's {issues}[http://github.com/chrisroberts/red_unicorn/issues]
+
+== License
+
+Copyright (c) 2011 Chris Roberts <chrisroberts.code@gmail.com>
+Licensed under the MIT license (see LICENSE)

data/bin/red_unicorn

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'getoptlong'
+
+require 'red_unicorn'
+require 'red_unicorn/unicorn'
+
+opts = GetoptLong.new(
+  ['--pid-file', '-p', GetoptLong::REQUIRED_ARGUMENT],
+  ['--unicorn-exec', '-x', GetoptLong::REQUIRED_ARGUMENT],
+  ['--unicorn-config', '-c', GetoptLong::REQUIRED_ARGUMENT],
+  ['--timeout', '-t', GetoptLong::REQUIRED_ARGUMENT],
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--env', '-e', GetoptLong::REQUIRED_ARGUMENT]
+)
+
+ALLOWED_ACTIONS = {
+  :start => 'Start unicorn',
+  :stop => 'Stop unicorn',
+  :restart => 'Gracefully restart unicorn (zero downtime)',
+  :reload => 'Reload unicorn configuration',
+  :birth => 'Create new worker process',
+  :prolicide => 'Kill single worker process',
+  :slaughter => 'Kill all worker processes (master remains)',
+  :status => 'Returns current unicorn status'
+}
+
+RETURN_CODES = {
+  :success => 0,
+  :invalid_action => 1,
+  :action_failed => 2,
+  :not_running => 3
+}
+
+def try_block
+  begin
+    yield
+    [RETURN_CODES[:success], nil]
+  rescue => e
+    [RETURN_CODES[:action_failed], e]
+  end
+end
+
+def print_help
+  puts 'RedUnicorn::Unicorn: Unicorn process interactions'
+  puts "Usage: red_unicorn [opts] (#{ALLOWED_ACTIONS.keys.join(' | ')})"
+  puts ' -h, --help                             Show this help screen'
+  puts ' -p, --pid /path/to/file.pid            Specify path to PID file (default: /var/run/unicorn/unicorn.pid)'
+  puts ' -x, --unicorn-exec /path/to/unicorn    Specify path to unicorn executable (default: /var/www/shared/bundle/bin/unicorn_rails)'
+  puts ' -c, --unicorn-config /path/to/config   Specify path to unicorn configuration file (default: /etc/unicorn/app.rb)'
+  puts ' -t, --timeout 30                       Specify timeout for running actions'
+  puts ' -e, --env production                   Specify environment (default: production)'
+  puts 'Commands:'
+  max_width = ALLOWED_ACTIONS.keys.map(&:to_s).map(&:length).max + 8
+  ALLOWED_ACTIONS.each_pair do |action, message|
+    puts "  #{action}:#{' ' * (max_width - action.to_s.length)}#{message}"
+  end
+end
+
+unicorn_hash = {}
+opts.each do |opt,arg|
+  case opt
+    when '--timeout'
+      unicorn_hash[:action_timeout] = arg.to_i
+    when '--unicorn-config'
+      unicorn_hash[:unicorn_config] = arg.to_s
+    when '--unicorn-exec'
+      unicorn_hash[:exec_path] = arg.to_s
+    when '--pid'
+      unicorn_hash[:pid] = arg.to_s
+    when '--env'
+      unicorn_hash[:env] = arg.to_s
+    when '--help'
+      print_help
+      exit RETURN_CODES[:success]
+  end
+end
+
+unicorn = RedUnicorn::Unicorn.new(unicorn_hash)
+
+action = ARGV.first
+result = nil
+error = nil
+
+case action
+  when 'start'
+    result,error = try_block{ unicorn.start }
+  when 'stop'
+    result,error = try_block{ unicorn.stop }
+  when 'restart'
+    result,error = try_block{ unicorn.restart }
+  when 'reload'
+    result,error = try_block{ unicorn.reload }
+  when 'birth'
+    result,error = try_block{ unicorn.add_child }
+  when 'prolicide'
+    result,error = try_block{ unicorn.remove_child }
+  when 'slaughter'
+    result,error = try_block{ unicorn.remove_all_children }
+  when 'status'
+    result,error = try_block{ unicorn.status }
+    result = RETURN_CODES[:not_running] if error
+  else
+    puts "ERROR: Invalid action received: #{action}"
+    exit RETURN_CODES[:invalid_action]
+end
+
+if(result == RETURN_CODES[:success])
+  puts "Unicorn action #{action} completed successfully."
+else
+  puts "ERROR: Unicorn action #{action} failed. Please check error logs.\n#{error.class.name}: #{error}\n#{error.backtrace.join("\n")}"
+end
+
+exit result

data/lib/red_unicorn/unicorn.rb

@@ -0,0 +1,180 @@
+#TODO: Add method of checking for rouge unicorn process and killing them
+module RedUnicorn
+
+  # Descriptive error classes
+  class UnicornError < StandardError
+  end
+  class ActionFailed < UnicornError
+  end
+  class FileNotFound < UnicornError
+  end
+  class NotRunning < UnicornError
+  end
+  class IsRunning < UnicornError
+  end
+
+  class Unicorn
+    # pid:: Path to unicorn PID file
+    # return_codes:: Hash of return codes (defined in executable bin file)
+    # exec_path:: Path to unicorn executable
+    # Create a new instance of unicorn interactor
+    def initialize(opts={})
+      @opts = {
+        :pid => '/var/run/unicorn/unicorn.pid',
+        :exec_path => '/var/www/shared/bundle/bin/unicorn_rails',
+        :config_path => '/etc/unicorn/app.rb',
+        :action_timeout => 30,
+        :env => 'production'
+      }.merge(opts)
+      check_exec_path
+    end
+
+    # Start a new unicorn process
+    def start
+      process_is :stopped do
+        %x{#{@opts[:exec_path]} --daemonize --env #{@opts[:env]} --config-file #{@opts[:config_path]}}
+      end
+    end
+
+    # Stop current unicorn process
+    def stop
+      process_is :running do
+        Process.kill('QUIT', pid)
+      end
+    end
+
+    # Halts the current unicorn process
+    def halt
+      process_is :running do
+        Process.kill('TERM', pid)
+      end
+    end
+
+    # Graceful restart
+    def restart
+      process_is :running do
+        original_pid = pid
+        Process.kill('USR2', pid)
+        sleep(0.1) # give unicorn some breathing room
+        waited = 0
+        until((File.exists?(@opts[:pid]) && is_running? && !child_pids(pid).empty?) || waited > @opts[:action_timeout])
+          sleep_start = Time.now.to_f
+          sleep(0.2)
+          waited += Time.now.to_f - sleep_start
+        end
+        if(pid == original_pid || waited > @opts[:action_timeout])
+          raise UnicornError.new 'Failed to start new process'
+        end
+        Process.kill('QUIT', original_pid)
+        while(is_running?(original_pid) && waited < @opts[:action_timeout])
+          sleep_start = Time.now.to_f
+          sleep(0.2)
+          waited += Time.now.to_f - sleep_start
+        end
+        raise IsRunning.new 'Failed to stop original unicorn process' if is_running?(original_pid)
+        raise NotRunning.new 'Failed to start new unicorn process'  unless is_running?
+        reopen_logs
+      end
+    end
+
+    # Reload unicorn configuration
+    def reload
+      process_is :running do
+        Process.kill('HUP', pid)
+      end
+    end
+
+    # Add new worker process
+    def add_child
+      process_is :running do
+        Process.kill('TTIN', pid)
+      end
+    end
+
+    # Remove worker process
+    def remove_child
+      process_is :running do
+        Process.kill('TTOU', pid)
+      end
+    end
+
+    # Stops all worker processes but
+    # keeps the master process alive
+    def remove_all_children
+      process_is :running do
+        Process.kill('WINCH', pid)
+      end
+    end
+
+    # Reopen log files
+    def reopen_logs
+      process_is :running do
+        Process.kill('USR1', pid)
+      end
+    end
+
+    # Return status of current process
+    def status
+      process_is :running do
+        puts '* unicorn is running'
+      end
+    end
+
+    private
+
+    # Return process ID from PID file
+    def pid
+      if(File.exists?(@opts[:pid]))
+        File.read(@opts[:pid]).to_s.strip.to_i
+      else
+        raise FileNotFound.new "PID file not found. Provided path: #{@opts[:pid]}"
+      end
+    end
+
+    # Check if unicorn is currently running
+    def is_running?(custom_pid = nil)
+      begin
+        Process.kill(0, custom_pid || pid)
+        true
+      rescue
+        false
+      end
+    end
+
+    # state:: :running or :stopped
+    # Ensure process is in given state and run some code if
+    # the caller felt like passing some along
+    def process_is(state)
+      case state
+        when :running
+          raise NotRunning.new 'Unicorn is not currently running' unless is_running?
+        when :stopped
+          raise IsRunning.new 'Unicorn is currently running' if is_running?
+        else
+          raise UnicornError.new 'Unknown process state received'
+      end
+      yield if block_given?
+    end
+
+    # parent_pid:: Parent process ID
+    # Returns array of child process IDs for the given parent
+    def child_pids(parent_pid)
+      process_list = %x{ps -eo pid,ppid | grep #{parent_pid}}
+      process_list.map(&:strip).find_all{|pr| pr.split.last == parent_pid.to_s }.map{|pr| pr.split.first.strip.to_i }
+    end
+
+    # Check validity of unicorn exec path
+    def check_exec_path
+      unless(File.exists?(@opts[:exec_path]))
+        test_path = '/var/www/shared/bundle/bin/unicorn_rails'
+        if(File.exists?(test_path))
+          @opts[:exec_path] = test_path
+        else
+          raise FileNotFound.new "Failed to find executable unicorn. Set path is: #{@opts[:exec_path]}"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/red_unicorn/version.rb

@@ -0,0 +1,17 @@
+module RedUnicorn
+  class Version
+
+    attr_reader :major, :minor, :tiny
+
+    def initialize(version)
+      version = version.split('.')
+      @major, @minor, @tiny = [version[0].to_i, version[1].to_i, version[2].to_i]
+    end
+
+    def to_s
+      "#{@major}.#{@minor}.#{@tiny}"
+    end
+  end
+
+  VERSION = Version.new('1.0.0')
+end

data/lib/red_unicorn.rb

@@ -0,0 +1 @@
+require 'red_unicorn/version'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: red_unicorn
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: unicorn
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Unicorn Process Handler
+email: chrisroberts.code@gmail.com
+executables: 
+- red_unicorn
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG.rdoc
+files: 
+- README.rdoc
+- CHANGELOG.rdoc
+- bin/red_unicorn
+- lib/red_unicorn.rb
+- lib/red_unicorn/unicorn.rb
+- lib/red_unicorn/version.rb
+has_rdoc: true
+homepage: http://github.com/chrisroberts/red_unicorn
+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: Unicorn Process Handler
+test_files: []
+