unicorn 0.5.4 → 0.6.0

data/ext/unicorn/http11/http11_parser.rl

@@ -2,12 +2,37 @@
  * 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>
+#ifndef http11_parser_h
+#define http11_parser_h
+
+#include <sys/types.h>
+
+static void http_field(void *data, const char *field,
+                       size_t flen, const char *value, size_t vlen);
+static void request_method(void *data, const char *at, size_t length);
+static void scheme(void *data, const char *at, size_t length);
+static void host(void *data, const char *at, size_t length);
+static void request_uri(void *data, const char *at, size_t length);
+static void fragment(void *data, const char *at, size_t length);
+static void request_path(void *data, const char *at, size_t length);
+static void query_string(void *data, const char *at, size_t length);
+static void http_version(void *data, const char *at, size_t length);
+static void header_done(void *data, const char *at, size_t length);
+
+typedef struct http_parser {
+  int cs;
+  size_t body_start;
+  size_t nread;
+  size_t mark;
+  size_t field_start;
+  size_t field_len;
+  size_t query_start;
+
+  void *data;
+} http_parser;
+
+static int http_parser_has_error(http_parser *parser);
+static int http_parser_is_finished(http_parser *parser);
 
 /*
  * capitalizes all lower-case ASCII characters,
@@ -15,10 +40,16 @@
  */
 static void snake_upcase_char(char *c)
 {
-    if (*c >= 'a' && *c <= 'z')
-      *c &= ~0x20;
-    else if (*c == '-')
-      *c = '_';
+  if (*c >= 'a' && *c <= 'z')
+    *c &= ~0x20;
+  else if (*c == '-')
+    *c = '_';
+}
+
+static void downcase_char(char *c)
+{
+  if (*c >= 'A' && *c <= 'Z')
+    *c |= 0x20;
 }
 
 #define LEN(AT, FPC) (FPC - buffer - parser->AT)
@@ -28,84 +59,69 @@ static void snake_upcase_char(char *c)
 /** 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 { 
+  action downcase_char { downcase_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 write_value {
+    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_method {
+    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 scheme { scheme(parser->data, PTR_TO(mark), LEN(mark, fpc)); }
+  action host { host(parser->data, PTR_TO(mark), LEN(mark, fpc)); }
+  action request_uri {
+    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 fragment {
+    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 query_string {
+    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 http_version {
+    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));
+    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);
+  action done {
+    parser->body_start = fpc - buffer + 1;
+    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)  {
+static void http_parser_init(http_parser *parser) {
   int cs = 0;
+  memset(parser, 0, sizeof(*parser));
   %% 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)  {
+static void http_parser_execute(
+  http_parser *parser, const char *buffer, size_t len)
+{
   const char *p, *pe;
   int cs = parser->cs;
   size_t off = parser->nread;
@@ -130,25 +146,13 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len)
   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) {
+static int http_parser_has_error(http_parser *parser) {
   return parser->cs == http_parser_error;
 }
 
-int http_parser_is_finished(http_parser *parser) {
+static int http_parser_is_finished(http_parser *parser) {
   return parser->cs == http_parser_first_final;
 }
+#endif /* http11_parser_h */

data/ext/unicorn/http11/http11_parser_common.rl

@@ -24,8 +24,9 @@
   token = (ascii -- (CTL | tspecials));
 
 # URI schemes and absolute paths
-  scheme = ( alpha | digit | "+" | "-" | "." )* ;
-  absolute_uri = (scheme ":" (uchar | reserved )*);
+  scheme = ( "http"i ("s"i)? ) $downcase_char >mark %scheme;
+  hostname = (alnum | "-" | "." | "_")+;
+  host_with_port = (hostname (":" digit*)?) >mark %host;
 
   path = ( pchar+ ( "/" pchar* )* ) ;
   query = ( uchar | reserved )* %query_string ;
@@ -33,8 +34,10 @@
   params = ( param ( ";" param )* ) ;
   rel_path = ( path? %request_path (";" params)? ) ("?" %start_query query)?;
   absolute_path = ( "/"+ rel_path );
+  path_uri = absolute_path > mark %request_uri;
+  Absolute_URI = (scheme "://" host_with_port path_uri);
 
-  Request_URI = ( "*" | absolute_uri | absolute_path ) >mark %request_uri;
+  Request_URI = ((absolute_path | "*") >mark %request_uri) | Absolute_URI;
   Fragment = ( uchar | reserved )* >mark %fragment;
   Method = ( upper | digit | safe ){1,20} >mark %request_method;
 

data/lib/unicorn.rb

@@ -1,7 +1,6 @@
-require 'logger'
 require 'fcntl'
 
-require 'unicorn/socket'
+require 'unicorn/socket_helper'
 require 'unicorn/const'
 require 'unicorn/http_request'
 require 'unicorn/http_response'
@@ -26,14 +25,30 @@ module Unicorn
     attr_reader :logger
     include ::Unicorn::SocketHelper
 
+    # prevents IO objects in here from being GC-ed
+    IO_PURGATORY = []
+
+    # all bound listener sockets
+    LISTENERS = []
+
+    # This hash maps PIDs to Workers
+    WORKERS = {}
+
+    # See: http://cr.yp.to/docs/selfpipe.html
+    SELF_PIPE = []
+
+    # signal queue used for self-piping
     SIG_QUEUE = []
-    DEFAULT_START_CTX = {
+
+    # We populate this at startup so we can figure out how to reexecute
+    # and upgrade the currently running instance of Unicorn
+    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,
-    }.freeze
+    }
 
     Worker = Struct.new(:nr, :tempfile) unless defined?(Worker)
     class Worker
@@ -45,22 +60,16 @@ module Unicorn
 
     # 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
+    # HttpServer.run.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
-      @workers = Hash.new
-      @io_purgatory = [] # prevents IO objects in here from being GC-ed
-      @request = @rd_sig = @wr_sig = nil
       @reexec_pid = 0
       @init_listeners = options[:listeners] ? options[:listeners].dup : []
       @config = Configurator.new(options.merge(:use_defaults => true))
       @listener_opts = {}
       @config.commit!(self, :skip => [:listeners, :pid])
-      @listeners = []
+      @request = HttpRequest.new(@logger)
     end
 
     # Runs the thing.  Returns self so you can run join on it
@@ -72,30 +81,27 @@ module Unicorn
       inherited = ENV['UNICORN_FD'].to_s.split(/,/).map do |fd|
         io = Socket.for_fd(fd.to_i)
         set_server_sockopt(io, @listener_opts[sock_name(io)])
-        @io_purgatory << io
+        IO_PURGATORY << io
         logger.info "inherited addr=#{sock_name(io)} fd=#{fd}"
         server_cast(io)
       end
 
       config_listeners = @config[:listeners].dup
-      @listeners.replace(inherited)
+      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
-      if config_listeners.empty? && @listeners.empty?
+      if config_listeners.empty? && LISTENERS.empty?
         config_listeners << Unicorn::Const::DEFAULT_LISTEN
       end
       config_listeners.each { |addr| listen(addr) }
-      raise ArgumentError, "no listeners" if @listeners.empty?
+      raise ArgumentError, "no listeners" if LISTENERS.empty?
       self.pid = @config[:pid]
       build_app! if @preload_app
-      File.open(@stderr_path, "a") { |fp| $stderr.reopen(fp) } if @stderr_path
-      File.open(@stdout_path, "a") { |fp| $stdout.reopen(fp) } if @stdout_path
-      $stderr.sync = $stdout.sync = true
-      spawn_missing_workers
+      maintain_worker_count
       self
     end
 
@@ -115,9 +121,9 @@ module Unicorn
       dead_names += cur_names - set_names
       dead_names.uniq!
 
-      @listeners.delete_if do |io|
+      LISTENERS.delete_if do |io|
         if dead_names.include?(sock_name(io))
-          @io_purgatory.delete_if do |pio|
+          IO_PURGATORY.delete_if do |pio|
             pio.fileno == io.fileno && (pio.close rescue nil).nil? # true
           end
           (io.close rescue nil).nil? # true
@@ -130,6 +136,9 @@ module Unicorn
       (set_names - cur_names).each { |addr| listen(addr) }
     end
 
+    def stdout_path=(path); redirect_io($stdout, path); end
+    def stderr_path=(path); redirect_io($stderr, path); end
+
     # sets the path for the PID file of the master process
     def pid=(path)
       if path
@@ -152,11 +161,11 @@ module Unicorn
 
       if io = bind_listen(address, opt)
         unless TCPServer === io || UNIXServer === io
-          @io_purgatory << io
+          IO_PURGATORY << io
           io = server_cast(io)
         end
         logger.info "listening on addr=#{sock_name(io)} fd=#{io.fileno}"
-        @listeners << io
+        LISTENERS << io
       else
         logger.error "adding listener failed addr=#{address} (in use)"
         raise Errno::EADDRINUSE, address
@@ -170,8 +179,7 @@ module Unicorn
     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)
-      mode = nil
+      init_self_pipe!
       respawn = true
 
       QUEUE_SIGS.each { |sig| trap_deferred(sig) }
@@ -181,10 +189,10 @@ module Unicorn
       begin
         loop do
           reap_all_workers
-          case (mode = SIG_QUEUE.shift)
+          case SIG_QUEUE.shift
           when nil
             murder_lazy_workers
-            spawn_missing_workers if respawn
+            maintain_worker_count if respawn
             master_sleep
           when :QUIT # graceful shutdown
             break
@@ -206,6 +214,10 @@ module Unicorn
             else
               logger.info "SIGWINCH ignored because we're not daemonized"
             end
+          when :TTIN
+            @worker_processes += 1
+          when :TTOU
+            @worker_processes -= 1 if @worker_processes > 0
           when :HUP
             respawn = true
             if @config.config_file
@@ -216,8 +228,6 @@ module Unicorn
               reexec
               break
             end
-          else
-            logger.error "master process in unknown mode: #{mode}"
           end
         end
       rescue Errno::EINTR
@@ -238,7 +248,7 @@ module Unicorn
       timeleft = @timeout
       step = 0.2
       reap_all_workers
-      until @workers.empty?
+      until WORKERS.empty?
         sleep(step)
         reap_all_workers
         (timeleft -= step) > 0 and next
@@ -251,7 +261,8 @@ module Unicorn
     private
 
     # list of signals we care about and trap in master.
-    QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP ].freeze
+    QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP,
+                   :TTIN, :TTOU ].freeze
 
     # defer a signal for later processing in #join (master process)
     def trap_deferred(signal)
@@ -269,16 +280,16 @@ module Unicorn
     # Wake up every second anyways to run murder_lazy_workers
     def master_sleep
       begin
-        ready = IO.select([@rd_sig], nil, nil, 1)
-        ready && ready[0] && ready[0][0] or return
-        loop { @rd_sig.read_nonblock(Const::CHUNK_SIZE) }
+        ready = IO.select([SELF_PIPE.first], nil, nil, 1) or return
+        ready.first && ready.first.first or return
+        loop { SELF_PIPE.first.read_nonblock(Const::CHUNK_SIZE) }
       rescue Errno::EAGAIN, Errno::EINTR
       end
     end
 
     def awaken_master
       begin
-        @wr_sig.write_nonblock('.') # wakeup master process from IO.select
+        SELF_PIPE.last.write_nonblock('.') # wakeup master process from select
       rescue Errno::EAGAIN, Errno::EINTR
         # pipe is full, master should wake up anyways
         retry
@@ -297,7 +308,7 @@ module Unicorn
             self.pid = @pid.chomp('.oldbin') if @pid
             proc_name 'master'
           else
-            worker = @workers.delete(pid)
+            worker = WORKERS.delete(pid)
             worker.tempfile.close rescue nil
             logger.info "reaped #{status.inspect} " \
                         "worker=#{worker.nr rescue 'unknown'}"
@@ -307,7 +318,7 @@ module Unicorn
       end
     end
 
-    # reexecutes the @start_ctx with a new binary
+    # reexecutes the START_CTX with a new binary
     def reexec
       if @reexec_pid > 0
         begin
@@ -335,20 +346,19 @@ module Unicorn
       end
 
       @reexec_pid = fork do
-        listener_fds = @listeners.map { |sock| sock.fileno }
+        listener_fds = LISTENERS.map { |sock| sock.fileno }
         ENV['UNICORN_FD'] = listener_fds.join(',')
-        Dir.chdir(@start_ctx[:cwd])
-        cmd = [ @start_ctx[:zero] ] + @start_ctx[:argv]
+        Dir.chdir(START_CTX[:cwd])
+        cmd = [ START_CTX[:zero] ] + START_CTX[:argv]
 
         # avoid leaking FDs we don't know about, but let before_exec
         # unset FD_CLOEXEC, if anything else in the app eventually
         # relies on FD inheritence.
-        purgatory = [] # prevent GC of IO objects
         (3..1024).each do |io|
           next if listener_fds.include?(io)
           io = IO.for_fd(io) rescue nil
           io or next
-          purgatory << io
+          IO_PURGATORY << io
           io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
         end
         logger.info "executing #{cmd.inspect} (in #{Dir.pwd})"
@@ -366,7 +376,7 @@ module Unicorn
     # worker.
     def murder_lazy_workers
       now = Time.now
-      @workers.each_pair do |pid, worker|
+      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
@@ -375,25 +385,32 @@ module Unicorn
     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
+        WORKERS.values.include?(worker_nr) and next
         begin
-          Dir.chdir(@start_ctx[:cwd])
+          Dir.chdir(START_CTX[:cwd])
         rescue Errno::ENOENT => err
-          logger.fatal "#{err.inspect} (#{@start_ctx[:cwd]})"
+          logger.fatal "#{err.inspect} (#{START_CTX[:cwd]})"
           SIG_QUEUE << :QUIT # forcibly emulate SIGQUIT
           return
         end
-        tempfile = Tempfile.new('') # as short as possible to save dir space
+        tempfile = Tempfile.new(nil) # as short as possible to save dir space
         tempfile.unlink # don't allow other processes to find or see it
         worker = Worker.new(worker_nr, tempfile)
         @before_fork.call(self, worker)
         pid = fork { worker_loop(worker) }
-        @workers[pid] = worker
+        WORKERS[pid] = worker
       end
     end
 
+    def maintain_worker_count
+      (off = WORKERS.size - @worker_processes) == 0 and return
+      off < 0 and return spawn_missing_workers
+      WORKERS.each_pair { |pid,w|
+        w.nr >= @worker_processes and kill_worker(:QUIT, pid) rescue nil
+      }
+    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)
@@ -431,15 +448,22 @@ module Unicorn
       trap(:CHLD, 'DEFAULT')
       SIG_QUEUE.clear
       proc_name "worker[#{worker.nr}]"
-      @rd_sig.close if @rd_sig
-      @wr_sig.close if @wr_sig
-      @workers.values.each { |other| other.tempfile.close rescue nil }
-      @start_ctx = @workers = @rd_sig = @wr_sig = nil
-      @listeners.each { |sock| sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
+      START_CTX.clear
+      init_self_pipe!
+      WORKERS.values.each { |other| other.tempfile.close! rescue nil }
+      WORKERS.clear
+      LISTENERS.each { |sock| sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
       worker.tempfile.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
       @after_fork.call(self, worker) # can drop perms
-      @request = HttpRequest.new(logger)
-      build_app! unless @preload_app
+      @timeout /= 2.0 # halve it for select()
+      build_app! unless @config[:preload_app]
+    end
+
+    def reopen_worker_logs(worker_nr)
+      @logger.info "worker=#{worker_nr} reopening logs..."
+      Unicorn::Util.reopen_logs
+      @logger.info "worker=#{worker_nr} done reopening logs"
+      init_self_pipe!
     end
 
     # runs inside each forked worker, this sits around and waits
@@ -449,30 +473,19 @@ module Unicorn
       master_pid = Process.ppid # slightly racy, but less memory usage
       init_worker_process(worker)
       nr = 0 # this becomes negative if we need to reopen logs
-      tempfile = worker.tempfile
-      ready = @listeners
+      alive = worker.tempfile # tempfile is our lifeline to the master process
+      ready = LISTENERS
       client = nil
-      rd, wr = IO.pipe
-      rd.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-      wr.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
       # closing anything we IO.select on will raise EBADF
       trap(:USR1) { nr = -65536; rd.close rescue nil }
-      trap(:QUIT) { @listeners.each { |sock| sock.close rescue nil } }
+      trap(:QUIT) { alive = nil; LISTENERS.each { |s| s.close rescue nil } }
       [:TERM, :INT].each { |sig| trap(sig) { exit(0) } } # instant shutdown
       @logger.info "worker=#{worker.nr} ready"
 
-      while master_pid == Process.ppid
-        if nr < 0
-          @logger.info "worker=#{worker.nr} reopening logs..."
-          Unicorn::Util.reopen_logs
-          @logger.info "worker=#{worker.nr} done reopening logs"
-          wr.close rescue nil
-          rd, wr = IO.pipe
-          rd.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-          wr.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-        end
-        # we're a goner in @timeout seconds anyways if tempfile.chmod
+      while alive
+        reopen_worker_logs(worker.nr) if nr < 0
+        # we're a goner in @timeout seconds anyways if alive.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,
@@ -480,7 +493,7 @@ module Unicorn
         # changes with chmod doesn't update ctime on all filesystems; so
         # we change our counter each and every time (after process_client
         # and before IO.select).
-        tempfile.chmod(nr = 0)
+        alive.chmod(nr = 0)
 
         begin
           ready.each do |sock|
@@ -495,7 +508,7 @@ module Unicorn
               # client closed the socket even before accept
               client.close rescue nil
             ensure
-              tempfile.chmod(nr += 1) if client
+              alive.chmod(nr += 1) if client
               break if nr < 0
             end
           end
@@ -506,17 +519,18 @@ module Unicorn
           # and do a speculative accept_nonblock on every listener
           # before we sleep again in select().
           if nr != 0 # (nr < 0) => reopen logs
-            ready = @listeners
+            ready = LISTENERS
           else
+            master_pid == Process.ppid or exit(0)
+            alive.chmod(nr += 1)
             begin
-              tempfile.chmod(nr += 1)
               # timeout used so we can detect parent death:
-              ret = IO.select(@listeners, nil, [rd], @timeout/2.0) or next
-              ready = ret[0]
+              ret = IO.select(LISTENERS, nil, SELF_PIPE, @timeout) or next
+              ready = ret.first
             rescue Errno::EINTR
-              ready = @listeners
+              ready = LISTENERS
             rescue Errno::EBADF => e
-              nr < 0 or exit(@listeners[0].closed? ? 0 : 1)
+              nr < 0 or exit(alive ? 1 : 0)
             end
           end
         rescue SignalException, SystemExit => e
@@ -536,13 +550,13 @@ module Unicorn
       begin
         Process.kill(signal, pid)
       rescue Errno::ESRCH
-        worker = @workers.delete(pid) and worker.tempfile.close rescue nil
+        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) }
+      WORKERS.keys.each { |pid| kill_worker(signal, pid) }
     end
 
     # unlinks a PID file at given +path+ if it contains the current PID
@@ -579,7 +593,7 @@ module Unicorn
     end
 
     # returns an array of string names for the given listener array
-    def listener_names(listeners = @listeners)
+    def listener_names(listeners = LISTENERS)
       listeners.map { |io| sock_name(io) }
     end
 
@@ -588,8 +602,19 @@ module Unicorn
     end
 
     def proc_name(tag)
-      $0 = ([ File.basename(@start_ctx[:zero]), tag ] +
-              @start_ctx[:argv]).join(' ')
+      $0 = ([ File.basename(START_CTX[:zero]), tag ] +
+              START_CTX[:argv]).join(' ')
+    end
+
+    def redirect_io(io, path)
+      File.open(path, 'a') { |fp| io.reopen(fp) } if path
+      io.sync = true
+    end
+
+    def init_self_pipe!
+      SELF_PIPE.each { |io| io.close rescue nil }
+      SELF_PIPE.replace(IO.pipe)
+      SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
     end
 
   end