unicorn-wrangler 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6c6c6c34675d90e10f42b3edd377a4c7201df27
-  data.tar.gz: 043e1bbcdaf37e1eb17772969a2d8a5c394d20c9
+  metadata.gz: 467ba192f3c2102dbc67f8fa957081576ca2e1a0
+  data.tar.gz: 0e3fc78a240edc9c0c0982d60dc2579ecffff3a6
 SHA512:
-  metadata.gz: 717e78358e2ba9d8d6a75f1848423a6ee7265712f900a1c7a05edc3baf88de9c24835200378f672cfab8ec7ddccbcb4eaeee430f39de852b726805e17fcb60fd
-  data.tar.gz: 8c8358d531f80106ddba1461b044c8f91ffade248f79bfc459989a21803583593cbe6a85f259163ab9668278149f19e9cb0e57707f1d8165def51bbeafc13c15
+  metadata.gz: 5e7eebda41d84eb9a914a93ad9d8914591963877d8cc5d51c9d42b0e838f026e763317b8db0deccc9b316a5c5cbb3176ea9a2c72137ea5a9af02e7ee808d7c24
+  data.tar.gz: 428f1680fea401c017cc88f6371457bcdf24cbd8dc2a14ad6035faa5adfd561cdfe7dc1317af53ea178f47864854325f7213421b97fceeebb1a5eb93a2c2e304

data/README.md

@@ -5,3 +5,13 @@ A simple process to launch and relaunch unicorn.  When launched, it either start
 Usage:
 
 unicorn-wrangler --pidfile /path/to/unicorn.pid --startup-time 60 -- /path/to/unicorn <unicorn-options>
+
+When the wrangler starts, it does the following:
+
+If unicorn is not running (determined by looking for the unicorn pidfile, and if it exists, checking the named process is running), it starts unicorn with the given command.
+
+If unicorn is running, it reloads the running instance, then terminates the old instance after the grace period has passed.
+
+The wrangler will continue to run while the monitored unicorn process runs.  It will stop running shortly after unicorn stops.
+
+If the wrangler is manually stopped (by sending INT or TERM signals to its process), it forks a new 'assassin' process that will terminate unicorn after the grace period has passed.  This is so that quickly stopping and starting the wrangler will have the effect of reloading unicorn, not terminating and restarting it.

data/lib/unicorn/wrangler.rb

@@ -3,86 +3,159 @@ require "unicorn/wrangler/version"
 module Unicorn
   class Wrangler
     attr_reader :command, :pidfile, :grace_period
-    attr_accessor :unicorn_pid
+    attr_accessor :unicorn
 
     def initialize(command, options = {})
       @command = command
       @pidfile = File.expand_path(options[:pidfile] || 'unicorn.pid')
       @grace_period = options[:grace_period] || 60
       @verbose = options[:verbose]
+      @unicorn = UnicornProcess.from_pidfile(@pidfile)
     end
 
-    def start
-      trap_signals(:HUP) { restart_unicorn }
-      trap_signals(:QUIT, :INT, :TERM) do |signal|
-        kill_unicorn_after_delay
-        exit
+    class UnicornProcess
+      attr_reader :pid, :pidfile
+
+      def initialize(pidfile)
+        @pidfile = pidfile
+        @pid = File.read(pidfile).to_i
+        recall_assassin
       end
 
-      if old_unicorn = old_pidfile_contents && process_running?(old_unicorn)
-        signal :QUIT, old_unicorn
+      def running?
+        Process.getpgid(pid)
+      rescue Errno::ESRCH
+        false
       end
 
-      self.unicorn_pid = pidfile_contents
+      def signal(msg)
+        puts "Sending signal #{msg} to #{pid}"
+        Process.kill msg, pid
+      end
 
-      if unicorn_pid && process_running?(unicorn_pid)
-        debug "running unicorn found at #{unicorn_pid}"
-        restart_unicorn
-      else
-        debug "no running unicorn found, starting new instance"
-        self.unicorn_pid = Process.spawn(command, pgroup: true)
-        wait_for { process_running?(unicorn_pid) }
-        debug "new instance started with PID #{unicorn_pid}"
+      def reload(grace_period)
+        signal "USR2"
+        sleep grace_period
+        reloaded_unicorn = UnicornProcess.from_pidfile(pidfile)
+        if reloaded_unicorn && pid != reloaded_unicorn.pid
+          terminate
+          reloaded_unicorn
+        else
+          raise "unicorn didn't reload correctly within grace period (was pid #{pid})"
+        end
       end
 
-      loop do
-        unless process_running?(unicorn_pid)
-          debug "unicorn(#{unicorn_pid}) no longer running, quitting."
-          exit
+      def launch_assassin(grace_period)
+        if running? && !@assassin_launched
+          @assassin_launched = true
+          puts "preparing to kill unicorn #{pid} in #{grace_period} seconds"
+          unless fork
+            File.write(assassin_pidfile, Process.pid.to_s)
+
+            trap 'TERM' do
+              exit
+            end
+
+            Process.setsid
+            sleep grace_period
+            terminate
+            File.delete(assassin_pidfile)
+          end
         end
-        sleep 1
       end
-    end
 
-    private
+      def recall_assassin
+        if File.exist?(assassin_pidfile)
+          assassin_pid = File.read(assassin_pidfile).to_i
+          Process.kill 'TERM', assassin_pid
+        end
+      rescue Errno::ESRCH
+      end
 
-    def trap_signals(*signals, &block)
-      signals.map(&:to_s).each do |signal|
-        trap(signal) do
-          debug "received #{signal} (managing #{unicorn_pid})"
-          block.call signal
+      def assassin_pidfile
+        pidfile + ".assassin"
+      end
+
+      def terminate
+        if running?
+          signal 'TERM'
+        else
+          "Attempt to terminate #{pid} failed as process not running"
+        end
+      end
+
+      def verbose(message)
+        self.class.verbose(message)
+      end
+
+      def self.verbose(message)
+        Unicorn::Wrangler.verbose(message)
+      end
+
+      def self.wait_for(&block)
+        until block.call
+          sleep 0.1
         end
       end
+
+      def self.start(pidfile, command)
+        Process.spawn(command, pgroup: true)
+        wait_for { File.exist?(pidfile) }
+        new(pidfile)
+      end
+
+      def self.from_pidfile(pidfile)
+        File.exist?(pidfile) && new(pidfile)
+      end
     end
 
-    def restart_unicorn
-      debug "restarting unicorn process at #{unicorn_pid}"
-      signal "USR2", unicorn_pid
-      wait_for { pidfile_contents && unicorn_pid != pidfile_contents }
-      debug "new master process started at #{pidfile_contents}"
-      sleep grace_period
-      signal "TERM", unicorn_pid
-      self.unicorn_pid = pidfile_contents
+    def start
+      setup_signal_handlers
+
+      if unicorn && unicorn.running?
+        self.unicorn = reload_unicorn
+      else
+        self.unicorn = UnicornProcess.start(pidfile, command)
+        sleep grace_period
+      end
+
+      if unicorn.running?
+        verbose "Unicorn running on #{unicorn.pid}"
+        loop_while_unicorn_runs
+      else
+        verbose "Unable to start unicorn.  Exiting."
+      end
     end
 
-    def pidfile_contents
-      File.exist?(pidfile) && File.read(pidfile).to_i
+    def setup_signal_handlers
+      trap_signals(:HUP) { reload_unicorn }
+      trap_signals(:QUIT, :INT, :TERM) do |signal|
+        kill_unicorn_after_delay
+        exit
+      end
     end
 
-    def old_pidfile_contents
-      File.exist?(pidfile + ".oldbin") && File.read(pidfile + ".oldbin").to_i
+    def reload_unicorn
+      self.unicorn = unicorn.reload(grace_period) if unicorn
     end
 
-    def signal(name, pid)
-      debug "signalling #{pid} with #{name}"
-      Process.kill name, pid
-    rescue Errno::ESRCH
+    def loop_while_unicorn_runs
+      loop do
+        if unicorn.running?
+          sleep 0.1
+        else
+          exit
+        end
+      end
     end
 
-    def process_running?(pid)
-      pid && Process.getpgid(pid)
-    rescue Errno::ESRCH
-      false
+    def trap_signals(*signals, &block)
+      signals.map(&:to_s).each do |signal|
+        trap(signal) do
+          verbose "received #{signal} (managing #{unicorn.pid})"
+          block.call signal
+        end
+      end
     end
 
     def wait_for(&block)
@@ -92,17 +165,14 @@ module Unicorn
     end
 
     def kill_unicorn_after_delay
-      if process_running?(unicorn_pid)
-        unless fork
-          debug "preparing to kill unicorn #{unicorn_pid} in #{grace_period} seconds"
-          Process.setsid
-          sleep grace_period
-          signal :TERM, unicorn_pid if process_running?(unicorn_pid)
-        end
-      end
+      unicorn.launch_assassin(grace_period) if unicorn
+    end
+
+    def verbose(message)
+      self.class.verbose(message)
     end
 
-    def debug(message)
+    def self.verbose(message)
       puts message if @verbose
     end
   end

data/lib/unicorn/wrangler/version.rb

@@ -1,5 +1,5 @@
 module Unicorn
   class Wrangler
-    VERSION = "0.0.6"
+    VERSION = "0.0.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unicorn-wrangler
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Tom Ward
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler