unicorn 0.92.0 → 0.93.0

data/bin/unicorn_rails

@@ -12,7 +12,6 @@ options = { :listeners => listeners }
 host, port = Unicorn::Const::DEFAULT_HOST, Unicorn::Const::DEFAULT_PORT
 set_listener = false
 ENV['RAILS_ENV'] ||= "development"
-map_path = ENV['RAILS_RELATIVE_URL_ROOT']
 
 opts = OptionParser.new("", 24, '  ') do |opts|
   opts.banner = "Usage: #{cmd} " \
@@ -58,8 +57,8 @@ opts = OptionParser.new("", 24, '  ') do |opts|
     set_listener = true
   end
 
-  opts.on("-E", "--env ENVIRONMENT",
-          "use ENVIRONMENT for defaults (default: development)") do |e|
+  opts.on("-E", "--env RAILS_ENV",
+          "use RAILS_ENV for defaults (default: development)") do |e|
     ENV['RAILS_ENV'] = e
   end
 
@@ -79,10 +78,15 @@ opts = OptionParser.new("", 24, '  ') do |opts|
     options[:config_file] = File.expand_path(f)
   end
 
-  opts.on("-P", "--path PATH", "DEPRECATED") do |v|
-    warn %q{Use of --path/-P is strongly discouraged}
-    warn %q{Use the 'map' directive in the rackup config instead}
-    ENV['RAILS_RELATIVE_URL_ROOT'] = map_path = v
+  opts.on("-P PATH", "DEPRECATED") do |v|
+    warn %q{Use of -P is ambiguous and discouraged}
+    warn %q{Use --path or RAILS_RELATIVE_URL_ROOT instead}
+    ENV['RAILS_RELATIVE_URL_ROOT'] = v
+  end
+
+  opts.on("--path PATH", "Runs Rails app mounted at a specific path.",
+          "(default: /)") do |v|
+    ENV['RAILS_RELATIVE_URL_ROOT'] = v
   end
 
   # I'm avoiding Unicorn-specific config options on the command-line.
@@ -156,8 +160,8 @@ app = lambda do ||
     Object.const_get(File.basename(config, '.rb').capitalize)
   end
 
-  map_path ||= '/'
   Rack::Builder.new do
+    map_path = ENV['RAILS_RELATIVE_URL_ROOT'] || '/'
     if inner_app.class.to_s == "Unicorn::App::OldRails"
       if map_path != '/'
         # patches + tests welcome, but I really cbf to deal with this

data/ext/unicorn_http/extconf.rb

@@ -1,12 +1,14 @@
 # -*- encoding: binary -*-
 require 'mkmf'
 
-$CFLAGS += " -fPIC " # needed for Rubinius, MRI already uses it regardless
-
 dir_config("unicorn_http")
 
 have_macro("SIZEOF_OFF_T", "ruby.h") or check_sizeof("off_t", "sys/types.h")
 have_macro("SIZEOF_LONG", "ruby.h") or check_sizeof("long", "sys/types.h")
 have_func("rb_str_set_len", "ruby.h")
 have_func("rb_str_modify", "ruby.h")
-create_makefile("unicorn_http")
+
+# -fPIC is needed for Rubinius, MRI already uses it regardless
+with_cflags($CFLAGS + " -fPIC ") do
+  create_makefile("unicorn_http")
+end

data/lib/unicorn.rb

@@ -15,10 +15,6 @@ module Unicorn
   autoload :TeeInput, 'unicorn/tee_input'
   autoload :Util, 'unicorn/util'
 
-  Z = '' # the stock empty string we use everywhere...
-  Z.force_encoding(Encoding::BINARY) if Z.respond_to?(:force_encoding)
-  Z.freeze
-
   class << self
     def run(app, options = {})
       HttpServer.new(app, options).start.join
@@ -65,7 +61,13 @@ module Unicorn
       0 => $0.dup,
     }
 
+    # This class and its members can be considered a stable interface
+    # and will not change in a backwards-incompatible fashion between
+    # releases of Unicorn.  You may need to access it in the
+    # before_fork/after_fork hooks.  See the Unicorn::Configurator RDoc
+    # for examples.
     class Worker < Struct.new(:nr, :tmp)
+
       # worker objects may be compared to just plain numbers
       def ==(other_nr)
         self.nr == other_nr
@@ -82,6 +84,17 @@ module Unicorn
       self.init_listeners = options[:listeners] ? options[:listeners].dup : []
       self.config = Configurator.new(options.merge(:use_defaults => true))
       self.listener_opts = {}
+
+      # we try inheriting listeners first, so we bind them later.
+      # we don't write the pid file until we've bound listeners in case
+      # unicorn was started twice by mistake.  Even though our #pid= method
+      # checks for stale/existing pid files, race conditions are still
+      # possible (and difficult/non-portable to avoid) and can be likely
+      # to clobber the pid if the second start was in quick succession
+      # after the first, so we rely on the listener binding to fail in
+      # that case.  Some tests (in and outside of this source tree) and
+      # monitoring tools may also rely on pid files existing before we
+      # attempt to connect to the listener(s)
       config.commit!(self, :skip => [:listeners, :pid])
       self.orig_app = app
     end
@@ -127,7 +140,7 @@ module Unicorn
     def listeners=(listeners)
       cur_names, dead_names = [], []
       listener_names.each do |name|
-        if "/" == name[0..0]
+        if ?/ == name[0]
           # mark unlinked sockets as dead so we can rebind them
           (File.socket?(name) ? cur_names : dead_names) << name
         else
@@ -168,17 +181,36 @@ module Unicorn
         end
       end
       unlink_pid_safe(pid) if pid
-      File.open(path, 'wb') { |fp| fp.syswrite("#$$\n") } if path
+
+      if path
+        fp = begin
+          tmp = "#{File.dirname(path)}/#{rand}.#$$"
+          File.open(tmp, File::RDWR|File::CREAT|File::EXCL, 0644)
+        rescue Errno::EEXIST
+          retry
+        end
+        fp.syswrite("#$$\n")
+        File.rename(fp.path, path)
+        fp.close
+      end
       self.set_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.
+    # +:tries+ may be specified as an option for the number of times
+    # to retry, and +:delay+ may be specified as the time in seconds
+    # to delay between retries.
+    # A negative value for +:tries+ indicates the listen will be
+    # retried indefinitely, this is useful when workers belonging to
+    # different masters are spawned during a transparent upgrade.
     def listen(address, opt = {}.merge(listener_opts[address] || {}))
+      address = config.expand_addr(address)
       return if String === address && listener_names.include?(address)
 
-      delay, tries = 0.5, 5
+      delay = opt[:delay] || 0.5
+      tries = opt[:tries] || 5
       begin
         io = bind_listen(address, opt)
         unless TCPServer === io || UNIXServer === io
@@ -192,7 +224,8 @@ module Unicorn
         logger.error "adding listener failed addr=#{address} (in use)"
         raise err if tries == 0
         tries -= 1
-        logger.error "retrying in #{delay} seconds (#{tries} tries left)"
+        logger.error "retrying in #{delay} seconds " \
+                     "(#{tries < 0 ? 'infinite' : tries} tries left)"
         sleep(delay)
         retry
       end
@@ -350,7 +383,7 @@ module Unicorn
           logger.error "reexec-ed child already running PID:#{reexec_pid}"
           return
         rescue Errno::ESRCH
-          reexec_pid = 0
+          self.reexec_pid = 0
         end
       end
 
@@ -578,7 +611,9 @@ module Unicorn
     end
 
     # unlinks a PID file at given +path+ if it contains the current PID
-    # useful as an at_exit handler.
+    # still potentially racy without locking the directory (which is
+    # non-portable and may interact badly with other programs), but the
+    # window for hitting the race condition is small
     def unlink_pid_safe(path)
       (File.read(path).to_i == $$ and File.unlink(path)) rescue nil
     end
@@ -586,14 +621,15 @@ module Unicorn
     # returns a PID if a given path contains a non-stale PID file,
     # nil otherwise.
     def valid_pid?(path)
-      if File.exist?(path) && (wpid = File.read(path).to_i) > 1
-        begin
-          Process.kill(0, wpid)
-          return wpid
-        rescue Errno::ESRCH
-        end
+      wpid = File.read(path).to_i
+      wpid <= 0 and return nil
+      begin
+        Process.kill(0, wpid)
+        return wpid
+      rescue Errno::ESRCH
+        # don't unlink stale pid files, racy without non-portable locking...
       end
-      nil
+      rescue Errno::ENOENT
     end
 
     def load_config!

data/lib/unicorn/app/exec_cgi.rb

@@ -36,7 +36,7 @@ module Unicorn::App
       self.args = args
       first = args[0] or
         raise ArgumentError, "need path to executable"
-      first[0..0] == "/" or args[0] = ::File.expand_path(first)
+      first[0] == ?/ or args[0] = ::File.expand_path(first)
       File.executable?(args[0]) or
         raise ArgumentError, "#{args[0]} is not executable"
     end
@@ -125,10 +125,10 @@ module Unicorn::App
       else
         tmp = Unicorn::Util.tmpio
 
-        buf = Unicorn::Z.dup
-        while inp.read(CHUNK_SIZE, buf)
+        buf = inp.read(CHUNK_SIZE)
+        begin
           tmp.syswrite(buf)
-        end
+        end while inp.read(CHUNK_SIZE, buf)
         tmp.sysseek(0)
         tmp
       end

data/lib/unicorn/app/inetd.rb

@@ -33,13 +33,12 @@ module Unicorn::App
         inp_pid = fork {
           input = env['rack.input']
           [ err_rd, out_rd ].each { |io| io.close }
-          buf = Unicorn::Z.dup
 
           # this is dependent on input.read having readpartial semantics:
-          while input.read(16384, buf)
+          buf = input.read(16384)
+          begin
             in_wr.write(buf)
-          end
-          in_wr.close
+          end while input.read(16384, buf)
         }
         in_wr.close
         self.pid_map = {

data/lib/unicorn/cgi_wrapper.rb

@@ -59,21 +59,20 @@ class Unicorn::CGIWrapper < ::CGI
     @status = nil
     @head = {}
     @headv = Hash.new { |hash,key| hash[key] = [] }
-    @body = StringIO.new
+    @body = StringIO.new("")
     super(*args)
   end
 
   # finalizes the response in a way Rack applications would expect
   def rack_response
     # @head[CONTENT_LENGTH] ||= @body.size
-    @headv[SET_COOKIE] += @output_cookies if @output_cookies
+    @headv[SET_COOKIE].concat(@output_cookies) if @output_cookies
     @headv.each_pair do |key,value|
       @head[key] ||= value.join("\n") unless value.empty?
     end
 
     # Capitalized "Status:", with human-readable status code (e.g. "200 OK")
-    parseable_status = @head.delete(Status)
-    @status ||= parseable_status.split(/ /)[0].to_i rescue 500
+    @status ||= @head.delete(Status)
 
     [ @status || 500, @head, [ @body.string ] ]
   end
@@ -138,13 +137,8 @@ class Unicorn::CGIWrapper < ::CGI
     @env_table[RACK_INPUT]
   end
 
-  # The stdoutput should be completely bypassed but we'll drop a
-  # warning just in case
+  # return a pointer to the StringIO body since it's STDOUT-like
   def stdoutput
-    err = @env_table[RACK_ERRORS]
-    err.puts "WARNING: Your program is doing something not expected."
-    err.puts "Please tell Eric that stdoutput was used and what software " \
-             "you are running.  Thanks."
     @body
   end
 

data/lib/unicorn/configurator.rb

@@ -5,35 +5,68 @@ require 'logger'
 
 module Unicorn
 
-  # Implements a simple DSL for configuring a unicorn server.
+  # Implements a simple DSL for configuring a Unicorn server.
   #
   # Example (when used with the unicorn config file):
   #   worker_processes 4
   #   listen '/tmp/my_app.sock', :backlog => 1
-  #   listen '0.0.0.0:9292'
+  #   listen 9292, :tcp_nopush => true
   #   timeout 10
   #   pid "/tmp/my_app.pid"
-  #   after_fork do |server,worker|
-  #     server.listen("127.0.0.1:#{9293 + worker.nr}") rescue nil
+  #
+  #   # combine REE with "preload_app true" for memory savings
+  #   # http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+  #   preload_app true
+  #   GC.respond_to?(:copy_on_write_friendly=) and
+  #     GC.copy_on_write_friendly = true
+  #
+  #   before_fork do |server, worker|
+  #     # the following is recomended for Rails + "preload_app true"
+  #     # as there's no need for the master process to hold a connection
+  #     defined?(ActiveRecord::Base) and
+  #       ActiveRecord::Base.connection.disconnect!
+  #
+  #     # the following allows a new master process to incrementally
+  #     # phase out the old master process with SIGTTOU to avoid a
+  #     # thundering herd (especially in the "preload_app false" case)
+  #     # when doing a transparent upgrade.  The last worker spawned
+  #     # will then kill off the old master process with a SIGQUIT.
+  #     old_pid = "#{server.config[:pid]}.oldbin"
+  #     if old_pid != server.pid
+  #     begin
+  #       sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+  #       Process.kill(sig, File.read(old_pid).to_i)
+  #     rescue Errno::ENOENT, Errno::ESRCH
+  #     end
+  #
+  #     # optionally throttle the master from forking too quickly by sleeping
+  #     sleep 1
+  #   end
+  #
+  #   after_fork do |server, worker|
+  #     # per-process listener ports for debugging/admin/migrations
+  #     addr = "127.0.0.1:#{9293 + worker.nr}"
+  #     server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
+  #
+  #     # the following is required for Rails + "preload_app true",
+  #     defined?(ActiveRecord::Base) and
+  #       ActiveRecord::Base.establish_connection
+  #
+  #     # if preload_app is true, then you may also want to check and
+  #     # restart any other shared sockets/descriptors such as Memcached,
+  #     # and Redis.  TokyoCabinet file handles are safe to reuse
+  #     # between any number of forked children (assuming your kernel
+  #     # correctly implements pread()/pwrite() system calls)
   #   end
   class Configurator < Struct.new(:set, :config_file)
-    # The default logger writes its output to $stderr
-    DEFAULT_LOGGER = Logger.new($stderr)
 
     # Default settings for Unicorn
     DEFAULTS = {
       :timeout => 60,
-      :logger => DEFAULT_LOGGER,
+      :logger => Logger.new($stderr),
       :worker_processes => 1,
       :after_fork => lambda { |server, worker|
           server.logger.info("worker=#{worker.nr} spawned pid=#{$$}")
-
-          # per-process listener ports for debugging/admin:
-          # "rescue nil" statement is needed because USR2 will
-          # cause the master process to reexecute itself and the
-          # per-worker ports can be taken, necessitating another
-          # HUP after QUIT-ing the original master:
-          # server.listen("127.0.0.1:#{8081 + worker.nr}") rescue nil
         },
       :before_fork => lambda { |server, worker|
           server.logger.info("worker=#{worker.nr} spawning...")
@@ -51,6 +84,9 @@ module Unicorn
       self.config_file = defaults.delete(:config_file)
       set.merge!(DEFAULTS) if use_defaults
       defaults.each { |key, value| self.send(key, value) }
+      Hash === set[:listener_opts] or
+          set[:listener_opts] = Hash.new { |hash,key| hash[key] = {} }
+      Array === set[:listeners] or set[:listeners] = []
       reload
     end
 
@@ -89,11 +125,13 @@ module Unicorn
     #
     #  after_fork do |server,worker|
     #    # per-process listener ports for debugging/admin:
-    #    # "rescue nil" statement is needed because USR2 will
-    #    # cause the master process to reexecute itself and the
-    #    # per-worker ports can be taken, necessitating another
-    #    # HUP after QUIT-ing the original master:
-    #    server.listen("127.0.0.1:#{9293 + worker.nr}") rescue nil
+    #    addr = "127.0.0.1:#{9293 + worker.nr}"
+    #
+    #    # the negative :tries parameter indicates we will retry forever
+    #    # waiting on the existing process to exit with a 5 second :delay
+    #    # Existing options for Unicorn::Configurator#listen such as
+    #    # :backlog, :rcvbuf, :sndbuf are available here as well.
+    #    server.listen(addr, :tries => -1, :delay => 5, :backlog => 128)
     #
     #    # drop permissions to "www-data" in the worker
     #    # generally there's no reason to start Unicorn as a priviledged user
@@ -102,7 +140,7 @@ module Unicorn
     #    user, group = 'www-data', 'www-data'
     #    target_uid = Etc.getpwnam(user).uid
     #    target_gid = Etc.getgrnam(group).gid
-    #    worker.tempfile.chown(target_uid, target_gid)
+    #    worker.tmp.chown(target_uid, target_gid)
     #    if uid != target_uid || gid != target_gid
     #      Process.initgroups(user, target_gid)
     #      Process::GID.change_privilege(target_gid)
@@ -170,7 +208,7 @@ module Unicorn
     #
     # The following options may be specified (but are generally not needed):
     #
-    # +backlog+: this is the backlog of the listen() syscall.
+    # +:backlog+: this is the backlog of the listen() syscall.
     #
     # Some operating systems allow negative values here to specify the
     # maximum allowable value.  In most cases, this number is only
@@ -185,7 +223,7 @@ module Unicorn
     #
     # Default: 1024
     #
-    # +rcvbuf+, +sndbuf+: maximum send and receive buffer sizes of sockets
+    # +:rcvbuf+, +:sndbuf+: maximum receive and send buffer sizes of sockets
     #
     # These correspond to the SO_RCVBUF and SO_SNDBUF settings which
     # can be set via the setsockopt(2) syscall.  Some kernels
@@ -199,13 +237,13 @@ module Unicorn
     #
     # Defaults: operating system defaults
     #
-    # +tcp_nodelay+: disables Nagle's algorithm on TCP sockets
+    # +:tcp_nodelay+: disables Nagle's algorithm on TCP sockets
     #
     # This has no effect on UNIX sockets.
     #
     # Default: operating system defaults (usually Nagle's algorithm enabled)
     #
-    # +tcp_nopush+: enables TCP_CORK in Linux or TCP_NOPUSH in FreeBSD
+    # +:tcp_nopush+: enables TCP_CORK in Linux or TCP_NOPUSH in FreeBSD
     #
     # This will prevent partial TCP frames from being sent out.
     # Enabling +tcp_nopush+ is generally not needed or recommended as
@@ -215,12 +253,21 @@ module Unicorn
     #
     # This has no effect on UNIX sockets.
     #
+    # +:tries+: times to retry binding a socket if it is already in use
+    #
+    # A negative number indicates we will retry indefinitely, this is
+    # useful for migrations and upgrades when individual workers
+    # are binding to different ports.
+    #
+    # Default: 5
+    #
+    # +:delay+: seconds to wait between successive +tries+
+    #
+    # Default: 0.5 seconds
     def listen(address, opt = {})
       address = expand_addr(address)
       if String === address
-        Hash === set[:listener_opts] or
-          set[:listener_opts] = Hash.new { |hash,key| hash[key] = {} }
-        [ :backlog, :sndbuf, :rcvbuf ].each do |key|
+        [ :backlog, :sndbuf, :rcvbuf, :tries ].each do |key|
           value = opt[key] or next
           Integer === value or
             raise ArgumentError, "not an integer: #{key}=#{value.inspect}"
@@ -230,10 +277,13 @@ module Unicorn
           TrueClass === value || FalseClass === value or
             raise ArgumentError, "not boolean: #{key}=#{value.inspect}"
         end
+        unless (value = opt[:delay]).nil?
+          Numeric === value or
+            raise ArgumentError, "not numeric: delay=#{value.inspect}"
+        end
         set[:listener_opts][address].merge!(opt)
       end
 
-      set[:listeners] = [] unless Array === set[:listeners]
       set[:listeners] << address
     end
 
@@ -277,7 +327,30 @@ module Unicorn
       set_path(:stdout_path, path)
     end
 
-    private
+    # expands "unix:path/to/foo" to a socket relative to the current path
+    # expands pathnames of sockets if relative to "~" or "~username"
+    # expands "*:port and ":port" to "0.0.0.0:port"
+    def expand_addr(address) #:nodoc
+      return "0.0.0.0:#{address}" if Integer === address
+      return address unless String === address
+
+      case address
+      when %r{\Aunix:(.*)\z}
+        File.expand_path($1)
+      when %r{\A~}
+        File.expand_path(address)
+      when %r{\A(?:\*:)?(\d+)\z}
+        "0.0.0.0:#$1"
+      when %r{\A(.*):(\d+)\z}
+        # canonicalize the name
+        packed = Socket.pack_sockaddr_in($2.to_i, $1)
+        Socket.unpack_sockaddr_in(packed).reverse!.join(':')
+      else
+        address
+      end
+    end
+
+  private
 
     def set_path(var, path) #:nodoc:
       case path
@@ -308,28 +381,5 @@ module Unicorn
       set[var] = my_proc
     end
 
-    # expands "unix:path/to/foo" to a socket relative to the current path
-    # expands pathnames of sockets if relative to "~" or "~username"
-    # expands "*:port and ":port" to "0.0.0.0:port"
-    def expand_addr(address) #:nodoc
-      return "0.0.0.0:#{address}" if Integer === address
-      return address unless String === address
-
-      case address
-      when %r{\Aunix:(.*)\z}
-        File.expand_path($1)
-      when %r{\A~}
-        File.expand_path(address)
-      when %r{\A(?:\*:)?(\d+)\z}
-        "0.0.0.0:#$1"
-      when %r{\A(.*):(\d+)\z}
-        # canonicalize the name
-        packed = Socket.pack_sockaddr_in($2.to_i, $1)
-        Socket.unpack_sockaddr_in(packed).reverse!.join(':')
-      else
-        address
-      end
-    end
-
   end
 end