unicorn_horn 0.0.1 → 0.1.1

data/Rakefile

@@ -9,6 +9,7 @@ begin
     gem.email = "joe@citizenlogistics.com"
     gem.homepage = "http://github.com/jxe/unicorn_horn"
     gem.authors = ["Joe Edelman"]
+    gem.add_dependency 'configurer'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.1

data/bin/hornrunner

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'unicorn_horn'
+require ARGV.shift
+UnicornHorn::Runner.new( eval "[#{ARGV.join(',')}]" ).start

data/lib/unicorn_horn/runner.rb

@@ -0,0 +1,53 @@
+module UnicornHorn
+  class Runner < SelfPipeDaemon
+
+    def initialize handlers
+      super()
+      @workers = handlers.map{ |handler| Worker.new handler }
+    end
+
+    def start
+      register :QUIT, :INT, :TERM, :CHLD
+      AFTER_FORK << proc{ @workers.clear; forget }
+      @workers.each(&:launch!)
+
+      ploop do |signal|
+        reap
+        case signal
+        when nil
+          @workers.each(&:kill_if_idle)
+          @workers.each{ |w| w.wpid or w.launch! }
+          psleep 1
+        when :CHLD;       next
+        when :QUIT;       raze(:QUIT, 60); break
+        when :TERM, :INT; raze(:TERM,  5); break
+        end
+      end
+    end
+
+
+    private
+
+    def reap
+      begin
+        wpid, status = Process.waitpid2(-1, Process::WNOHANG)
+        wpid or return
+        next unless worker = @workers.detect{ |w| w.wpid == wpid }
+        worker.reap(status)
+      rescue Errno::ECHILD
+        break
+      end while true
+    end
+
+    def raze(sig, timeframe)
+      limit = Time.now + timeframe
+      until @workers.empty? || Time.now > limit
+        @workers.each{ |w| w.kill(sig) }
+        sleep(0.1)
+        reap
+      end
+      @workers.each{ |w| w.kill(:KILL) }
+    end
+
+  end
+end

data/lib/unicorn_horn/self_pipe_daemon.rb

@@ -0,0 +1,52 @@
+module UnicornHorn
+
+  class SelfPipeDaemon
+    extend Configurer
+    config :logger do Logger.new(STDERR) end
+
+    SELF_PIPE = []
+    SIG_QUEUE = []
+
+    def psleep(sec)
+      IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
+      SELF_PIPE[0].read_nonblock(16*1024, "")
+      rescue Errno::EAGAIN, Errno::EINTR
+    end
+
+    def pwake
+      SELF_PIPE[1].write_nonblock('.') # wakeup master process from select
+      rescue Errno::EAGAIN, Errno::EINTR
+    end
+
+    def register *signals
+      @signals = signals
+      signals.each { |sig| trap(sig){ |sig_nr| SIG_QUEUE << sig; pwake } }
+    end
+
+    def initialize
+      SELF_PIPE.replace(IO.pipe)
+      SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+    end
+
+    def ploop
+      Utils.proc_name 'master'
+      logger.info "master process ready"
+
+      begin
+        yield SIG_QUEUE.shift
+      rescue => e
+        logger.error "Unhandled master loop exception #{e.inspect}."
+        logger.error e.backtrace.join("\n")
+      end while true
+
+      logger.info "master complete"
+    end
+
+    def forget
+      @signals.each { |sig| trap(sig, nil) }
+      SIG_QUEUE.clear
+      SELF_PIPE.each { |io| io.close rescue nil }
+    end
+  end
+
+end

data/lib/unicorn_horn/utils.rb

@@ -0,0 +1,24 @@
+require 'tmpdir'
+
+module UnicornHorn
+  module Utils
+    module_function
+
+    def tmpio
+      fp = File.open("#{Dir::tmpdir}/#{rand}",
+                 File::RDWR|File::CREAT|File::EXCL, 0600)
+      File.unlink(fp.path)
+      fp.binmode
+      fp.sync = true
+      fp
+    rescue Errno::EEXIST
+      retry
+    end
+
+    def proc_name foo
+      @orig_zero ||= $0
+      @orig_argv ||= ARGV.join(' ')
+      $0 = "#{@orig_zero} #{foo} #{@orig_argv}"
+    end
+  end
+end

data/lib/unicorn_horn/worker.rb

@@ -0,0 +1,64 @@
+module UnicornHorn
+
+  class Worker
+    extend Configurer
+    config :idle_timeout do 60; end
+    config :logger       do Logger.new(STDERR); end
+
+    attr_reader :name, :wpid
+
+    def initialize handler
+      @name    = handler.respond_to?(:name) ? handler.name : handler.inspect
+      @handler = handler.respond_to?(:new)  ? handler.new  : handler
+    end
+
+    def launch!
+      @tmp = Utils.tmpio
+      @wpid = fork do
+
+        # the prep work
+        Utils.proc_name "worker[#{name}]"
+        AFTER_FORK.each(&:call)
+        @tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } }
+        alive = @tmp
+        m = 0
+        logger.info "worker=#{name} ready"
+
+        # the actual loop
+        while Process.ppid && alive
+          alive.chmod(m = 0 == m ? 1 : 0)
+          @handler.call
+        end
+
+      end
+    end
+
+    def kill_if_idle
+      return unless @tmp and @wpid
+      stat = @tmp.stat
+      stat.mode == 0100600 and return
+      idle_timeout ||= 60
+      (diff = (Time.now - stat.ctime)) <= idle_timeout and return
+      logger.error "worker=#{name} PID:#{@wpid} timeout " \
+                   "(#{diff}s > #{idle_timeout}s), killing"
+      kill(:KILL)
+    end
+
+    def kill(signal)
+      return unless @wpid
+      Process.kill(signal, @wpid)
+      rescue Errno::ESRCH
+        @wpid = nil
+        @tmp.close rescue nil
+    end
+
+    def reap(status)
+      @wpid = nil
+      @tmp.close rescue nil
+      m = "reaped #{status.inspect} worker=#{name}"
+      status.success? ? logger.info(m) : logger.error(m)
+    end
+  end
+
+end

data/lib/unicorn_horn.rb

@@ -1,180 +1,10 @@
 require 'fcntl'
-require 'tmpdir'
+require 'configurer'
+require 'unicorn_horn/utils'
+require 'unicorn_horn/self_pipe_daemon'
+require 'unicorn_horn/worker'
+require 'unicorn_horn/runner'
 
 module UnicornHorn
-  ORIG_ZERO = $0
-  ARGVS = ARGV.join(' ')
-
-  class Worker
-    attr_accessor :name, :logger, :idle_timeout
-    attr_reader :wpid
-    attr_writer :master
-
-    def initialize name, idle_timeout = 60, &blk
-      @name         = name
-      @idle_timeout = idle_timeout
-      @blk          = blk
-    end
-
-    def launch!
-      @tmp = tmpio
-      @wpid = fork do
-        $0 = "#{ORIG_ZERO} worker[#{name}] #{ARGVS}"
-        @master.forget; @master = nil
-        @tmp.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-        [:TERM, :INT].each { |sig| trap(sig) { exit!(0) } }
-        alive = @tmp
-        m = 0
-        logger.info "worker=#{name} ready"
-        @blk.call(proc{
-          if Process.ppid && alive
-            alive.chmod(m = 0 == m ? 1 : 0) or true
-          end
-        })
-      end
-    end
-
-    def tmpio
-      fp = File.open("#{Dir::tmpdir}/#{rand}",
-                 File::RDWR|File::CREAT|File::EXCL, 0600)
-      File.unlink(fp.path)
-      fp.binmode
-      fp.sync = true
-      fp
-    rescue Errno::EEXIST
-      retry
-    end
-
-    def kill_if_idle
-      return unless @tmp and @wpid
-      stat = @tmp.stat
-      stat.mode == 0100600 and return
-      @idle_timeout ||= 60
-      (diff = (Time.now - stat.ctime)) <= @idle_timeout and return
-      @logger.error "worker=#{name} PID:#{@wpid} timeout " \
-                   "(#{diff}s > #{@idle_timeout}s), killing"
-      kill(:KILL)
-    end
-
-    def kill(signal)
-      return unless @wpid
-      Process.kill(signal, @wpid)
-      rescue Errno::ESRCH
-        @wpid = nil
-        @tmp.close rescue nil
-    end
-
-    def reap(status)
-      @wpid = nil
-      @tmp.close rescue nil
-      m = "reaped #{status.inspect} worker=#{name}"
-      status.success? ? @logger.info(m) : @logger.error(m)
-    end
-  end
-
-
-  class SelfPipeDaemon
-    attr_accessor :logger
-
-    SELF_PIPE = []
-    SIG_QUEUE = []
-
-    def psleep(sec)
-      IO.select([ SELF_PIPE[0] ], nil, nil, sec) or return
-      SELF_PIPE[0].read_nonblock(16*1024, "")
-      rescue Errno::EAGAIN, Errno::EINTR
-    end
-
-    def pwake
-      SELF_PIPE[1].write_nonblock('.') # wakeup master process from select
-      rescue Errno::EAGAIN, Errno::EINTR
-    end
-
-    def register *signals
-      @signals = signals
-      signals.each { |sig| trap(sig){ |sig_nr| SIG_QUEUE << sig; pwake } }
-    end
-
-    def initialize options = {}
-      SELF_PIPE.replace(IO.pipe)
-      SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
-      options.each_pair{ |k,v| send("#{k}=", v) }
-      yield self if block_given?
-      self
-    end
-
-    def ploop
-      $0 = "#{ORIG_ZERO} master #{ARGVS}"
-      logger.info "master process ready"
-
-      begin
-        yield SIG_QUEUE.shift
-      rescue => e
-        logger.error "Unhandled master loop exception #{e.inspect}."
-        logger.error e.backtrace.join("\n")
-      end while true
-
-      logger.info "master complete"
-    end
-
-    def forget
-      @signals.each { |sig| trap(sig, nil) }
-      SIG_QUEUE.clear
-      SELF_PIPE.each { |io| io.close rescue nil }
-    end
-  end
-
-
-
-  class Monitor < SelfPipeDaemon
-    attr_accessor :workers, :kill_timeout
-
-    def start
-      workers.each{ |w| w.master = self; w.logger = logger }
-      register :QUIT, :INT, :TERM, :CHLD
-      workers.each(&:launch!)
-
-      ploop do |signal|
-        reap
-        case signal
-        when nil
-          workers.each(&:kill_if_idle)
-          workers.each{ |w| w.wpid or w.launch! }
-          psleep 1
-        when :CHLD;       next
-        when :QUIT;       raze(:QUIT); break
-        when :TERM, :INT; raze(:TERM); break
-        end
-      end
-    end
-
-    def forget
-      super
-      workers.clear
-    end
-
-
-    private
-
-    def reap
-      begin
-        wpid, status = Process.waitpid2(-1, Process::WNOHANG)
-        wpid or return
-        next unless worker = workers.detect{ |w| w.wpid == wpid }
-        worker.reap(status)
-      rescue Errno::ECHILD
-        break
-      end while true
-    end
-
-    def raze(sig)
-      limit = Time.now + (@kill_timeout ||= 60)
-      until workers.empty? || Time.now > limit
-        workers.each{ |w| w.kill(sig) }
-        sleep(0.1)
-        reap
-      end
-      workers.each{ |w| w.kill(:KILL) }
-    end
-  end
+  AFTER_FORK = []
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Joe Edelman
@@ -14,14 +14,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 -04:00
-default_executable: 
-dependencies: []
-
+date: 2010-09-09 00:00:00 -04:00
+default_executable: hornrunner
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: configurer
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: joe@citizenlogistics.com
-executables: []
-
+executables: 
+- hornrunner
 extensions: []
 
 extra_rdoc_files: 
@@ -34,7 +45,12 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- bin/hornrunner
 - lib/unicorn_horn.rb
+- lib/unicorn_horn/runner.rb
+- lib/unicorn_horn/self_pipe_daemon.rb
+- lib/unicorn_horn/utils.rb
+- lib/unicorn_horn/worker.rb
 - test/helper.rb
 - test/test_unicorn_horn.rb
 has_rdoc: true