unicorn 0.1.0

data/ext/unicorn/http11/http11_parser.h

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include <sys/types.h>
+
+typedef void (*element_cb)(void *data, const char *at, size_t length);
+typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
+
+typedef struct http_parser { 
+  int cs;
+  size_t body_start;
+  int content_len;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  void *data;
+
+  field_cb http_field;
+  element_cb request_method;
+  element_cb request_uri;
+  element_cb fragment;
+  element_cb request_path;
+  element_cb query_string;
+  element_cb http_version;
+  element_cb header_done;
+  
+} http_parser;
+
+int http_parser_init(http_parser *parser);
+int http_parser_finish(http_parser *parser);
+size_t http_parser_execute(http_parser *parser, const char *data, size_t len, size_t off);
+int http_parser_has_error(http_parser *parser);
+int http_parser_is_finished(http_parser *parser);
+
+#define http_parser_nread(parser) (parser)->nread 
+
+#endif

data/ext/unicorn/http11/http11_parser.rl

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+#include "http11_parser.h"
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+/*
+ * capitalizes all lower-case ASCII characters,
+ * converts dashes to underscores.
+ */
+static void snake_upcase_char(char *c)
+{
+    if (*c >= 'a' && *c <= 'z')
+      *c &= ~0x20;
+    else if (*c == '-')
+      *c = '_';
+}
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+
+/** Machine **/
+
+%%{
+  
+  machine http_parser;
+
+  action mark {MARK(mark, fpc); }
+
+
+  action start_field { MARK(field_start, fpc); }
+  action snake_upcase_field { snake_upcase_char((char *)fpc); }
+  action write_field { 
+    parser->field_len = LEN(field_start, fpc);
+  }
+
+  action start_value { MARK(mark, fpc); }
+  action write_value { 
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+    }
+  }
+  action request_method { 
+    if(parser->request_method != NULL) 
+      parser->request_method(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action request_uri { 
+    if(parser->request_uri != NULL)
+      parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+  action fragment { 
+    if(parser->fragment != NULL)
+      parser->fragment(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action start_query {MARK(query_start, fpc); }
+  action query_string { 
+    if(parser->query_string != NULL)
+      parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, fpc));
+  }
+
+  action http_version {	
+    if(parser->http_version != NULL)
+      parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action request_path {
+    if(parser->request_path != NULL)
+      parser->request_path(parser->data, PTR_TO(mark), LEN(mark,fpc));
+  }
+
+  action done { 
+    parser->body_start = fpc - buffer + 1; 
+    if(parser->header_done != NULL)
+      parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+  include http_parser_common "http11_parser_common.rl";
+
+}%%
+
+/** Data **/
+%% write data;
+
+int http_parser_init(http_parser *parser)  {
+  int cs = 0;
+  %% write init;
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;    
+
+  return(1);
+}
+
+
+/** exec **/
+size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  assert(*pe == '\0' && "pointer does not end on NUL");
+  assert(pe - p == len - off && "pointers aren't same distance");
+
+  %% write exec;
+
+  if (!http_parser_has_error(parser))
+    parser->cs = cs;
+  parser->nread += p - (buffer + off);
+
+  assert(p <= pe && "buffer overflow after parsing execute");
+  assert(parser->nread <= len && "nread longer than length");
+  assert(parser->body_start <= len && "body starts after buffer end");
+  assert(parser->mark < len && "mark is after buffer end");
+  assert(parser->field_len <= len && "field has length longer than whole buffer");
+  assert(parser->field_start < len && "field starts after buffer end");
+
+  return(parser->nread);
+}
+
+int http_parser_finish(http_parser *parser)
+{
+  if (http_parser_has_error(parser) ) {
+    return -1;
+  } else if (http_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int http_parser_has_error(http_parser *parser) {
+  return parser->cs == http_parser_error;
+}
+
+int http_parser_is_finished(http_parser *parser) {
+  return parser->cs == http_parser_first_final;
+}

data/ext/unicorn/http11/http11_parser_common.rl

@@ -0,0 +1,55 @@
+%%{
+  
+  machine http_parser_common;
+
+#### HTTP PROTOCOL GRAMMAR
+# line endings
+  CRLF = "\r\n";
+
+# character types
+  CTL = (cntrl | 127);
+  safe = ("$" | "-" | "_" | ".");
+  extra = ("!" | "*" | "'" | "(" | ")" | ",");
+  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
+  sorta_safe = ("\"" | "<" | ">");
+  unsafe = (CTL | " " | "#" | "%" | sorta_safe);
+  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
+  unreserved = (alpha | digit | safe | extra | national);
+  escape = ("%" xdigit xdigit);
+  uchar = (unreserved | escape | sorta_safe);
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
+  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
+
+# elements
+  token = (ascii -- (CTL | tspecials));
+
+# URI schemes and absolute paths
+  scheme = ( alpha | digit | "+" | "-" | "." )* ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+
+  path = ( pchar+ ( "/" pchar* )* ) ;
+  query = ( uchar | reserved )* %query_string ;
+  param = ( pchar | "/" )* ;
+  params = ( param ( ";" param )* ) ;
+  rel_path = ( path? %request_path (";" params)? ) ("?" %start_query query)?;
+  absolute_path = ( "/"+ rel_path );
+
+  Request_URI = ( "*" | absolute_uri | absolute_path ) >mark %request_uri;
+  Fragment = ( uchar | reserved )* >mark %fragment;
+  Method = ( upper | digit | safe ){1,20} >mark %request_method;
+
+  http_number = ( digit+ "." digit+ ) ;
+  HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
+  Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ;
+
+  field_name = ( token -- ":" )+ >start_field $snake_upcase_field %write_field;
+
+  field_value = any* >start_value %write_value;
+
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Request = Request_Line ( message_header )* ( CRLF @done );
+
+main := Request;
+
+}%%

data/lib/unicorn.rb

@@ -0,0 +1,548 @@
+require 'logger'
+
+require 'unicorn/socket'
+require 'unicorn/const'
+require 'unicorn/http_request'
+require 'unicorn/http_response'
+require 'unicorn/configurator'
+require 'unicorn/util'
+
+# Unicorn module containing all of the classes (include C extensions) for running
+# a Unicorn web server.  It contains a minimalist HTTP server with just enough
+# functionality to service web application requests fast as possible.
+module Unicorn
+  class << self
+    def run(app, options = {})
+      HttpServer.new(app, options).start.join
+    end
+  end
+
+  # This is the process manager of Unicorn. This manages worker
+  # processes which in turn handle the I/O and application process.
+  # Listener sockets are started in the master process and shared with
+  # forked worker children.
+  class HttpServer
+    attr_reader :logger
+    include Process
+    include ::Unicorn::SocketHelper
+
+    DEFAULT_START_CTX = {
+      :argv => ARGV.map { |arg| arg.dup },
+      # don't rely on Dir.pwd here since it's not symlink-aware, and
+      # symlink dirs are the default with Capistrano...
+      :cwd => `/bin/sh -c pwd`.chomp("\n"),
+      :zero => $0.dup,
+      :environ => {}.merge!(ENV),
+      :umask => File.umask,
+    }.freeze
+
+    Worker = Struct.new(:nr, :tempfile) unless defined?(Worker)
+    class Worker
+      # worker objects may be compared to just plain numbers
+      def ==(other_nr)
+        self.nr == other_nr
+      end
+    end
+
+    # Creates a working server on host:port (strange things happen if
+    # port isn't a Number).  Use HttpServer::run to start the server and
+    # HttpServer.workers.join to join the thread that's processing
+    # incoming requests on the socket.
+    def initialize(app, options = {})
+      start_ctx = options.delete(:start_ctx)
+      @start_ctx = DEFAULT_START_CTX.dup
+      @start_ctx.merge!(start_ctx) if start_ctx
+      @app = app
+      @mode = :idle
+      @master_pid = $$
+      @workers = Hash.new
+      @io_purgatory = [] # prevents IO objects in here from being GC-ed
+      @request = @rd_sig = @wr_sig = nil
+      @reexec_pid = 0
+      @config = Configurator.new(options.merge(:use_defaults => true))
+      @config.commit!(self, :skip => [:listeners, :pid])
+      @listeners = []
+    end
+
+    # Runs the thing.  Returns self so you can run join on it
+    def start
+      BasicSocket.do_not_reverse_lookup = true
+
+      # inherit sockets from parents, they need to be plain Socket objects
+      # before they become UNIXServer or TCPServer
+      inherited = ENV['UNICORN_FD'].to_s.split(/,/).map do |fd|
+        io = Socket.for_fd(fd.to_i)
+        set_server_sockopt(io)
+        @io_purgatory << io
+        logger.info "inherited: #{io} fd=#{fd} addr=#{sock_name(io)}"
+        server_cast(io)
+      end
+
+      config_listeners = @config[:listeners].dup
+      @listeners.replace(inherited)
+
+      # we start out with generic Socket objects that get cast to either
+      # TCPServer or UNIXServer objects; but since the Socket objects
+      # share the same OS-level file descriptor as the higher-level *Server
+      # objects; we need to prevent Socket objects from being garbage-collected
+      config_listeners -= listener_names
+      config_listeners.each { |addr| listen(addr) }
+      raise ArgumentError, "no listeners" if @listeners.empty?
+      self.pid = @config[:pid]
+      build_app! if @preload_app
+      $stderr.reopen(File.open(@stderr_path, "a")) if @stderr_path
+      $stdout.reopen(File.open(@stdout_path, "a")) if @stdout_path
+      $stderr.sync = $stdout.sync = true
+      spawn_missing_workers
+      self
+    end
+
+    # replaces current listener set with +listeners+.  This will
+    # close the socket if it will not exist in the new listener set
+    def listeners=(listeners)
+      cur_names = listener_names
+      set_names = listener_names(listeners)
+      dead_names = cur_names - set_names
+
+      @listeners.delete_if do |io|
+        if dead_names.include?(sock_name(io))
+          @io_purgatory.delete_if { |pio| pio.fileno == io.fileno }
+          destroy_safely(io)
+          true
+        else
+          false
+        end
+      end
+
+      (set_names - cur_names).each { |addr| listen(addr) }
+    end
+
+    # sets the path for the PID file of the master process
+    def pid=(path)
+      if path
+        if x = valid_pid?(path)
+          return path if @pid && path == @pid && x == $$
+          raise ArgumentError, "Already running on PID:#{x} " \
+                               "(or pid=#{path} is stale)"
+        end
+        File.open(path, 'wb') { |fp| fp.syswrite("#{$$}\n") }
+      end
+      unlink_pid_safe(@pid) if @pid && @pid != path
+      @pid = path
+    end
+
+    # add a given address to the +listeners+ set, idempotently
+    # Allows workers to add a private, per-process listener via the
+    # @after_fork hook.  Very useful for debugging and testing.
+    def listen(address)
+      return if String === address && listener_names.include?(address)
+
+      if io = bind_listen(address, @backlog)
+        if Socket == io.class
+          @io_purgatory << io
+          io = server_cast(io)
+        end
+        logger.info "#{io} listening on PID:#{$$} " \
+                    "fd=#{io.fileno} addr=#{sock_name(io)}"
+        @listeners << io
+      else
+        logger.error "adding listener failed addr=#{address} (in use)"
+        raise Errno::EADDRINUSE, address
+      end
+    end
+
+    # monitors children and receives signals forever
+    # (or until a termination signal is sent).  This handles signals
+    # one-at-a-time time and we'll happily drop signals in case somebody
+    # is signalling us too often.
+    def join
+      # this pipe is used to wake us up from select(2) in #join when signals
+      # are trapped.  See trap_deferred
+      @rd_sig, @wr_sig = IO.pipe unless (@rd_sig && @wr_sig)
+      @rd_sig.nonblock = @wr_sig.nonblock = true
+
+      reset_master
+      $0 = "unicorn master"
+      logger.info "master process ready" # test relies on this message
+      begin
+        loop do
+          reap_all_workers
+          case @mode
+          when :idle
+            murder_lazy_workers
+            spawn_missing_workers
+          when 'QUIT' # graceful shutdown
+            break
+          when 'TERM', 'INT' # immediate shutdown
+            stop(false)
+            break
+          when 'USR1' # user-defined (probably something like log reopening)
+            kill_each_worker('USR1')
+            Unicorn::Util.reopen_logs
+            reset_master
+          when 'USR2' # exec binary, stay alive in case something went wrong
+            reexec
+            reset_master
+          when 'HUP'
+            if @config.config_file
+              load_config!
+              reset_master
+              redo # immediate reaping since we may have QUIT workers
+            else # exec binary and exit if there's no config file
+              logger.info "config_file not present, reexecuting binary"
+              reexec
+              break
+            end
+          else
+            logger.error "master process in unknown mode: #{@mode}, resetting"
+            reset_master
+          end
+          reap_all_workers
+
+          ready = begin
+            IO.select([@rd_sig], nil, nil, 1) or next
+          rescue Errno::EINTR # next
+          end
+          ready[0] && ready[0][0] or next
+          begin # just consume the pipe when we're awakened, @mode is set
+            loop { @rd_sig.sysread(Const::CHUNK_SIZE) }
+          rescue Errno::EAGAIN, Errno::EINTR # next
+          end
+        end
+      rescue Errno::EINTR
+        retry
+      rescue Object => e
+        logger.error "Unhandled master loop exception #{e.inspect}."
+        logger.error e.backtrace.join("\n")
+        reset_master
+        retry
+      end
+      stop # gracefully shutdown all workers on our way out
+      logger.info "master PID:#{$$} join complete"
+      unlink_pid_safe(@pid) if @pid
+    end
+
+    # Terminates all workers, but does not exit master process
+    def stop(graceful = true)
+      kill_each_worker(graceful ? 'QUIT' : 'TERM')
+      timeleft = @timeout
+      step = 0.2
+      reap_all_workers
+      until @workers.empty?
+        sleep(step)
+        reap_all_workers
+        (timeleft -= step) > 0 and next
+        kill_each_worker('KILL')
+      end
+    ensure
+      self.listeners = []
+    end
+
+    private
+
+    # list of signals we care about and trap in master.
+    TRAP_SIGS = %w(QUIT INT TERM USR1 USR2 HUP).map { |x| x.freeze }.freeze
+
+    # defer a signal for later processing in #join (master process)
+    def trap_deferred(signal)
+      trap(signal) do |sig_nr|
+        # we only handle/defer one signal at a time and ignore all others
+        # until we're ready again.  Queueing signals can lead to more bugs,
+        # and simplicity is the most important thing
+        TRAP_SIGS.each { |sig| trap(sig, 'IGNORE') }
+        if Symbol === @mode
+          @mode = signal
+          begin
+            @wr_sig.syswrite('.') # wakeup master process from IO.select
+          rescue Errno::EAGAIN
+          rescue Errno::EINTR
+            retry
+          end
+        end
+      end
+    end
+
+
+    def reset_master
+      @mode = :idle
+      TRAP_SIGS.each { |sig| trap_deferred(sig) }
+    end
+
+    # reaps all unreaped workers
+    def reap_all_workers
+      begin
+        loop do
+          pid = waitpid(-1, WNOHANG) or break
+          if @reexec_pid == pid
+            logger.error "reaped exec()-ed PID:#{pid} status=#{$?.exitstatus}"
+            @reexec_pid = 0
+            self.pid = @pid.chomp('.oldbin') if @pid
+          else
+            worker = @workers.delete(pid)
+            worker.tempfile.close rescue nil
+            logger.info "reaped PID:#{pid} " \
+                        "worker=#{worker.nr rescue 'unknown'} " \
+                        "status=#{$?.exitstatus}"
+          end
+        end
+      rescue Errno::ECHILD
+      end
+    end
+
+    # reexecutes the @start_ctx with a new binary
+    def reexec
+      if @reexec_pid > 0
+        begin
+          Process.kill(0, @reexec_pid)
+          logger.error "reexec-ed child already running PID:#{@reexec_pid}"
+          return
+        rescue Errno::ESRCH
+          @reexec_pid = 0
+        end
+      end
+
+      if @pid
+        old_pid = "#{@pid}.oldbin"
+        prev_pid = @pid.dup
+        begin
+          self.pid = old_pid  # clear the path for a new pid file
+        rescue ArgumentError
+          logger.error "old PID:#{valid_pid?(old_pid)} running with " \
+                       "existing pid=#{old_pid}, refusing rexec"
+          return
+        rescue Object => e
+          logger.error "error writing pid=#{old_pid} #{e.class} #{e.message}"
+          return
+        end
+      end
+
+      @reexec_pid = fork do
+        @rd_sig.close if @rd_sig
+        @wr_sig.close if @wr_sig
+        @workers.values.each { |other| other.tempfile.close rescue nil }
+
+        ENV.replace(@start_ctx[:environ])
+        ENV['UNICORN_FD'] = @listeners.map { |sock| sock.fileno }.join(',')
+        File.umask(@start_ctx[:umask])
+        Dir.chdir(@start_ctx[:cwd])
+        cmd = [ @start_ctx[:zero] ] + @start_ctx[:argv]
+        logger.info "executing #{cmd.inspect} (in #{Dir.pwd})"
+        @before_exec.call(self) if @before_exec
+        exec(*cmd)
+      end
+    end
+
+    # forcibly terminate all workers that haven't checked in in @timeout
+    # seconds.  The timeout is implemented using an unlinked tempfile
+    # shared between the parent process and each worker.  The worker
+    # runs File#chmod to modify the ctime of the tempfile.  If the ctime
+    # is stale for >@timeout seconds, then we'll kill the corresponding
+    # worker.
+    def murder_lazy_workers
+      now = Time.now
+      @workers.each_pair do |pid, worker|
+        (now - worker.tempfile.ctime) <= @timeout and next
+        logger.error "worker=#{worker.nr} PID:#{pid} is too old, killing"
+        kill_worker('KILL', pid) # take no prisoners for @timeout violations
+        worker.tempfile.close rescue nil
+      end
+    end
+
+    def spawn_missing_workers
+      return if @workers.size == @worker_processes
+      (0...@worker_processes).each do |worker_nr|
+        @workers.values.include?(worker_nr) and next
+        tempfile = Tempfile.new('') # as short as possible to save dir space
+        tempfile.unlink # don't allow other processes to find or see it
+        tempfile.sync = true
+        worker = Worker.new(worker_nr, tempfile)
+        @before_fork.call(self, worker.nr)
+        pid = fork { worker_loop(worker) }
+        @workers[pid] = worker
+      end
+    end
+
+    # once a client is accepted, it is processed in its entirety here
+    # in 3 easy steps: read request, call app, write app response
+    def process_client(client)
+      env = @request.read(client) or return
+      app_response = @app.call(env)
+      HttpResponse.write(client, app_response)
+    rescue EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,Errno::EBADF
+      client.closed? or client.close rescue nil
+    rescue Object => e
+      logger.error "Read error: #{e.inspect}"
+      logger.error e.backtrace.join("\n")
+    ensure
+      begin
+        client.closed? or client.close
+      rescue Object => e
+        logger.error "Client error: #{e.inspect}"
+        logger.error e.backtrace.join("\n")
+      end
+      @request.reset
+    end
+
+    # gets rid of stuff the worker has no business keeping track of
+    # to free some resources and drops all sig handlers.
+    # traps for USR1, USR2, and HUP may be set in the @after_fork Proc
+    # by the user.
+    def init_worker_process(worker)
+      build_app! unless @preload_app
+      TRAP_SIGS.each { |sig| trap(sig, 'IGNORE') }
+      trap('CHLD', 'DEFAULT')
+      trap('USR1') do
+        @logger.info "worker=#{worker.nr} rotating logs..."
+        Unicorn::Util.reopen_logs
+        @logger.info "worker=#{worker.nr} done rotating logs"
+      end
+
+      $0 = "unicorn worker[#{worker.nr}]"
+      @rd_sig.close if @rd_sig
+      @wr_sig.close if @wr_sig
+      @workers.values.each { |other| other.tempfile.close rescue nil }
+      @workers.clear
+      @start_ctx.clear
+      @mode = @start_ctx = @workers = @rd_sig = @wr_sig = nil
+      @listeners.each { |sock| set_cloexec(sock) }
+      ENV.delete('UNICORN_FD')
+      @after_fork.call(self, worker.nr) if @after_fork
+      @request = HttpRequest.new(logger)
+    end
+
+    # runs inside each forked worker, this sits around and waits
+    # for connections and doesn't die until the parent dies (or is
+    # given a INT, QUIT, or TERM signal)
+    def worker_loop(worker)
+      init_worker_process(worker)
+      nr = 0
+      tempfile = worker.tempfile
+      alive = true
+      ready = @listeners
+      client = nil
+      %w(TERM INT).each { |sig| trap(sig) { exit(0) } } # instant shutdown
+      trap('QUIT') do
+        alive = false
+        @listeners.each { |sock| sock.close rescue nil } # break IO.select
+      end
+
+      while alive && @master_pid == ppid
+        # we're a goner in @timeout seconds anyways if tempfile.chmod
+        # breaks, so don't trap the exception.  Using fchmod() since
+        # futimes() is not available in base Ruby and I very strongly
+        # prefer temporary files to be unlinked for security,
+        # performance and reliability reasons, so utime is out.  No-op
+        # changes with chmod doesn't update ctime on all filesystems; so
+        # we increment our counter each and every time.
+        tempfile.chmod(nr += 1)
+
+        begin
+          accepted = false
+          ready.each do |sock|
+            begin
+              client = begin
+                sock.accept_nonblock
+              rescue Errno::EAGAIN
+                next
+              end
+              accepted = client.sync = true
+              client.nonblock = false
+              set_client_sockopt(client) if TCPSocket === client
+              process_client(client)
+            rescue Errno::ECONNABORTED
+              # client closed the socket even before accept
+              if client && !client.closed?
+                client.close rescue nil
+              end
+            end
+            tempfile.chmod(nr += 1)
+          end
+          client = nil
+
+          # make the following bet: if we accepted clients this round,
+          # we're probably reasonably busy, so avoid calling select(2)
+          # and try to do a blind non-blocking accept(2) on everything
+          # before we sleep again in select
+          if accepted
+            ready = @listeners
+          else
+            begin
+              tempfile.chmod(nr += 1)
+              # timeout used so we can detect parent death:
+              ret = IO.select(@listeners, nil, nil, @timeout/2.0) or next
+              ready = ret[0]
+            rescue Errno::EINTR
+              ready = @listeners
+            rescue Errno::EBADF => e
+              exit(alive ? 1 : 0)
+            end
+          end
+        rescue SystemExit => e
+          exit(e.status)
+        rescue Object => e
+          if alive
+            logger.error "Unhandled listen loop exception #{e.inspect}."
+            logger.error e.backtrace.join("\n")
+          end
+        end
+      end
+    end
+
+    # delivers a signal to a worker and fails gracefully if the worker
+    # is no longer running.
+    def kill_worker(signal, pid)
+      begin
+        kill(signal, pid)
+      rescue Errno::ESRCH
+        worker = @workers.delete(pid) and worker.tempfile.close rescue nil
+      end
+    end
+
+    # delivers a signal to each worker
+    def kill_each_worker(signal)
+      @workers.keys.each { |pid| kill_worker(signal, pid) }
+    end
+
+    # unlinks a PID file at given +path+ if it contains the current PID
+    # useful as an at_exit handler.
+    def unlink_pid_safe(path)
+      (File.read(path).to_i == $$ and File.unlink(path)) rescue nil
+    end
+
+    # returns a PID if a given path contains a non-stale PID file,
+    # nil otherwise.
+    def valid_pid?(path)
+      if File.exist?(path) && (pid = File.read(path).to_i) > 1
+        begin
+          kill(0, pid)
+          return pid
+        rescue Errno::ESRCH
+        end
+      end
+      nil
+    end
+
+    def load_config!
+      begin
+        logger.info "reloading config_file=#{@config.config_file}"
+        @config.reload
+        @config.commit!(self)
+        kill_each_worker('QUIT')
+        logger.info "done reloading config_file=#{@config.config_file}"
+      rescue Object => e
+        logger.error "error reloading config_file=#{@config.config_file}: " \
+                     "#{e.class} #{e.message}"
+      end
+    end
+
+    # returns an array of string names for the given listener array
+    def listener_names(listeners = @listeners)
+      listeners.map { |io| sock_name(io) }
+    end
+
+    def build_app!
+      @app = @app.call if @app.respond_to?(:arity) && @app.arity == 0
+    end
+
+  end
+end