unicorn 0.4.2 → 0.5.0

data/lib/unicorn/app/old_rails.rb

@@ -13,9 +13,15 @@ class Unicorn::App::OldRails
 
   def call(env)
     cgi = Unicorn::CGIWrapper.new(env)
-    Dispatcher.dispatch(cgi,
-        ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
-        cgi.body)
+    begin
+      Dispatcher.dispatch(cgi,
+          ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS,
+          cgi.body)
+    rescue Object => e
+      err = env['rack.errors']
+      out.write("#{e} #{e.message}\n")
+      e.backtrace.each { |line| out.write("#{line}\n") }
+    end
     cgi.out  # finalize the response
     cgi.rack_response
   end

data/lib/unicorn/cgi_wrapper.rb

@@ -71,11 +71,9 @@ class Unicorn::CGIWrapper < ::CGI
 
     # Capitalized "Status:", with human-readable status code (e.g. "200 OK")
     parseable_status = @head.delete(Status)
-    unless @status
-      @status ||= parseable_status.split(/ /)[0].to_i rescue 404
-    end
+    @status ||= parseable_status.split(/ /)[0].to_i rescue 500
 
-    [ @status, @head, [ @body.string ] ]
+    [ @status || 500, @head, [ @body.string ] ]
   end
 
   # The header is typically called to send back the header.  In our case we

data/lib/unicorn/configurator.rb

@@ -12,8 +12,8 @@ module Unicorn
   #   listen '0.0.0.0:9292'
   #   timeout 10
   #   pid "/tmp/my_app.pid"
-  #   after_fork do |server,worker_nr|
-  #     server.listen("127.0.0.1:#{9293 + worker_nr}") rescue nil
+  #   after_fork do |server,worker|
+  #     server.listen("127.0.0.1:#{9293 + worker.nr}") rescue nil
   #   end
   class Configurator
     # The default logger writes its output to $stderr
@@ -25,18 +25,18 @@ module Unicorn
       :listeners => [],
       :logger => DEFAULT_LOGGER,
       :worker_processes => 1,
-      :after_fork => lambda { |server, worker_nr|
-          server.logger.info("worker=#{worker_nr} spawned pid=#{$$}")
+      :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
+          # server.listen("127.0.0.1:#{8081 + worker.nr}") rescue nil
         },
-      :before_fork => lambda { |server, worker_nr|
-          server.logger.info("worker=#{worker_nr} spawning...")
+      :before_fork => lambda { |server, worker|
+          server.logger.info("worker=#{worker.nr} spawning...")
         },
       :before_exec => lambda { |server|
           server.logger.info("forked child re-executing...")
@@ -97,23 +97,37 @@ module Unicorn
     # the worker after forking.  The following is an example hook which adds
     # a per-process listener to every worker:
     #
-    #  after_fork do |server,worker_nr|
+    #  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
+    #    server.listen("127.0.0.1:#{9293 + worker.nr}") rescue nil
+    #
+    #    # drop permissions to "www-data" in the worker
+    #    # generally there's no reason to start Unicorn as a priviledged user
+    #    # as it is not recommended to expose Unicorn to public clients.
+    #    uid, gid = Process.euid, Process.egid
+    #    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)
+    #    if uid != target_uid || gid != target_gid
+    #      Process.initgroups(user, target_gid)
+    #      Process::GID.change_privilege(target_gid)
+    #      Process::UID.change_privilege(target_uid)
+    #    end
     #  end
-    def after_fork(&block)
-      set_hook(:after_fork, block)
+    def after_fork(*args, &block)
+      set_hook(:after_fork, block_given? ? block : args[0])
     end
 
     # sets before_fork got be a given Proc object.  This Proc
     # object will be called by the master process before forking
     # each worker.
-    def before_fork(&block)
-      set_hook(:before_fork, block)
+    def before_fork(*args, &block)
+      set_hook(:before_fork, block_given? ? block : args[0])
     end
 
     # sets the before_exec hook to a given Proc object.  This
@@ -122,8 +136,8 @@ module Unicorn
     # for freeing certain OS resources that you do NOT wish to
     # share with the reexeced child process.
     # There is no corresponding after_exec hook (for obvious reasons).
-    def before_exec(&block)
-      set_hook(:before_exec, block, 1)
+    def before_exec(*args, &block)
+      set_hook(:before_exec, block_given? ? block : args[0], 1)
     end
 
     # sets the timeout of worker processes to +seconds+.  Workers
@@ -192,10 +206,6 @@ module Unicorn
     #   specified.
     #
     #   Defaults: operating system defaults
-    #
-    # Due to limitations of the operating system, options specified here
-    # cannot affect existing listener sockets in any way, sockets must be
-    # completely closed and rebound.
     def listen(address, opt = { :backlog => 1024 })
       address = expand_addr(address)
       if String === address

data/lib/unicorn/const.rb

@@ -58,7 +58,7 @@ module Unicorn
     REQUEST_URI='REQUEST_URI'.freeze
     REQUEST_PATH='REQUEST_PATH'.freeze
     
-    UNICORN_VERSION="0.4.2".freeze
+    UNICORN_VERSION="0.5.0".freeze
 
     UNICORN_TMP_BASE="unicorn".freeze
 

data/lib/unicorn/http_request.rb

@@ -19,7 +19,6 @@ module Unicorn
        "rack.multiprocess" => true,
        "rack.multithread" => false,
        "rack.run_once" => false,
-       "rack.url_scheme" => "http",
        "rack.version" => [0, 1],
        "SCRIPT_NAME" => "",
 

data/lib/unicorn/socket.rb

@@ -1,29 +1,4 @@
 require 'socket'
-require 'io/nonblock'
-
-# non-portable Socket code goes here:
-class Socket
-  module Constants
-    # configure platform-specific options (only tested on Linux 2.6 so far)
-    case RUBY_PLATFORM
-    when /linux/
-      # from /usr/include/linux/tcp.h
-      TCP_DEFER_ACCEPT = 9 unless defined?(TCP_DEFER_ACCEPT)
-      TCP_CORK = 3 unless defined?(TCP_CORK)
-    when /freebsd(([1-4]\..{1,2})|5\.[0-4])/
-    when /freebsd/
-      # Use the HTTP accept filter if available.
-      # The struct made by pack() is defined in /usr/include/sys/socket.h
-      # as accept_filter_arg
-      unless `/sbin/sysctl -nq net.inet.accf.http`.empty?
-        unless defined?(SO_ACCEPTFILTER_HTTPREADY)
-          SO_ACCEPTFILTER_HTTPREADY = ['httpready',nil].pack('a16a240').freeze
-        end
-
-      end
-    end
-  end
-end
 
 class UNIXSocket
   UNICORN_PEERADDR = '127.0.0.1'.freeze
@@ -42,19 +17,15 @@ module Unicorn
   module SocketHelper
     include Socket::Constants
 
-    def set_client_sockopt(sock)
-      sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) if defined?(TCP_NODELAY)
-      sock.setsockopt(SOL_TCP, TCP_CORK, 1) if defined?(TCP_CORK)
-    end
-
-    def set_server_sockopt(sock)
-      if defined?(TCP_DEFER_ACCEPT)
-        sock.setsockopt(SOL_TCP, TCP_DEFER_ACCEPT, 1) rescue nil
-      end
-      if defined?(SO_ACCEPTFILTER_HTTPREADY)
-        sock.setsockopt(SOL_SOCKET, SO_ACCEPTFILTER,
-                        SO_ACCEPTFILTER_HTTPREADY) rescue nil
+    def set_server_sockopt(sock, opt)
+      opt ||= {}
+      if opt[:rcvbuf] || opt[:sndbuf]
+        log_buffer_sizes(sock, "before: ")
+        sock.setsockopt(SOL_SOCKET, SO_RCVBUF, opt[:rcvbuf]) if opt[:rcvbuf]
+        sock.setsockopt(SOL_SOCKET, SO_SNDBUF, opt[:sndbuf]) if opt[:sndbuf]
+        log_buffer_sizes(sock, " after: ")
       end
+      sock.listen(opt[:backlog] || 1024)
     end
 
     def log_buffer_sizes(sock, pfx = '')
@@ -70,7 +41,7 @@ module Unicorn
     def bind_listen(address = '0.0.0.0:8080', opt = { :backlog => 1024 })
       return address unless String === address
 
-      domain, bind_addr = if address[0..0] == "/"
+      sock = if address[0..0] == "/"
         if File.exist?(address)
           if File.socket?(address)
             if self.respond_to?(:logger)
@@ -82,29 +53,18 @@ module Unicorn
                   "socket=#{address} specified but it is not a socket!"
           end
         end
-        [ AF_UNIX, Socket.pack_sockaddr_un(address) ]
+        old_umask = File.umask(0)
+        begin
+          UNIXServer.new(address)
+        ensure
+          File.umask(old_umask)
+        end
       elsif address =~ /^(\d+\.\d+\.\d+\.\d+):(\d+)$/
-        [ AF_INET, Socket.pack_sockaddr_in($2.to_i, $1) ]
+        TCPServer.new($1, $2.to_i)
       else
         raise ArgumentError, "Don't know how to bind: #{address}"
       end
-
-      sock = Socket.new(domain, SOCK_STREAM, 0)
-      sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) if defined?(SO_REUSEADDR)
-      begin
-        sock.bind(bind_addr)
-      rescue Errno::EADDRINUSE
-        sock.close rescue nil
-        return nil
-      end
-      if opt[:rcvbuf] || opt[:sndbuf]
-        log_buffer_sizes(sock, "before: ")
-        sock.setsockopt(SOL_SOCKET, SO_RCVBUF, opt[:rcvbuf]) if opt[:rcvbuf]
-        sock.setsockopt(SOL_SOCKET, SO_SNDBUF, opt[:sndbuf]) if opt[:sndbuf]
-        log_buffer_sizes(sock, " after: ")
-      end
-      sock.listen(opt[:backlog] || 1024)
-      set_server_sockopt(sock) if domain == AF_INET
+      set_server_sockopt(sock, opt)
       sock
     end
 

data/local.mk.sample

@@ -33,6 +33,7 @@ publish_doc:
 	$(MAKE) doc
 	$(MAKE) doc_gz
 	rsync -av --delete doc/ dcvr:/srv/unicorn/
+	git ls-files | xargs touch
 
 # Create gzip variants of the same timestamp as the original so nginx
 # "gzip_static on" can serve the gzipped versions directly.

data/test/exec/test_exec.rb

@@ -39,8 +39,8 @@ end
 worker_processes 4
 timeout 30
 logger Logger.new('#{COMMON_TMP.path}')
-before_fork do |server, worker_nr|
-  server.logger.info "before_fork: worker=\#{worker_nr}"
+before_fork do |server, worker|
+  server.logger.info "before_fork: worker=\#{worker.nr}"
 end
   EOS
 
@@ -231,6 +231,38 @@ end
     end
   end
 
+  def test_unicorn_config_listener_swap
+    port_cli = unused_port
+    File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
+    ucfg = Tempfile.new('unicorn_test_config')
+    ucfg.syswrite("listen '#@addr:#@port'\n")
+    pid = xfork do
+      redirect_test_io do
+        exec($unicorn_bin, "-c#{ucfg.path}", "-l#@addr:#{port_cli}")
+      end
+    end
+    results = retry_hit(["http://#@addr:#{port_cli}/"])
+    assert_equal String, results[0].class
+    results = retry_hit(["http://#@addr:#@port/"])
+    assert_equal String, results[0].class
+
+    port2 = unused_port(@addr)
+    ucfg.sysseek(0)
+    ucfg.truncate(0)
+    ucfg.syswrite("listen '#@addr:#{port2}'\n")
+    Process.kill(:HUP, pid)
+
+    results = retry_hit(["http://#@addr:#{port2}/"])
+    assert_equal String, results[0].class
+    results = retry_hit(["http://#@addr:#{port_cli}/"])
+    assert_equal String, results[0].class
+    assert_nothing_raised do
+      reuse = TCPServer.new(@addr, @port)
+      reuse.close
+    end
+    assert_shutdown(pid)
+  end
+
   def test_unicorn_config_listen_with_options
     File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
     ucfg = Tempfile.new('unicorn_test_config')
@@ -254,7 +286,7 @@ end
     File.unlink(tmp.path)
     ucfg = Tempfile.new('unicorn_test_config')
     ucfg.syswrite("listen '#@addr:#@port'\n")
-    ucfg.syswrite("before_fork { |s,nr|\n")
+    ucfg.syswrite("before_fork { |s,w|\n")
     ucfg.syswrite("  s.listen('#{tmp.path}', :backlog => 5, :sndbuf => 8192)\n")
     ucfg.syswrite("  s.listen('#@addr:#{port2}', :rcvbuf => 8192)\n")
     ucfg.syswrite("\n}\n")
@@ -407,6 +439,38 @@ end
     reexec_basic_test(pid, pid_file)
   end
 
+  def test_socket_unlinked_restore
+    results = nil
+    sock = Tempfile.new('unicorn_test_sock')
+    sock_path = sock.path
+    sock.close!
+    ucfg = Tempfile.new('unicorn_test_config')
+    ucfg.syswrite("listen \"#{sock_path}\"\n")
+
+    File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
+    pid = xfork { redirect_test_io { exec($unicorn_bin, "-c#{ucfg.path}") } }
+    wait_for_file(sock_path)
+    assert File.socket?(sock_path)
+    assert_nothing_raised do
+      sock = UNIXSocket.new(sock_path)
+      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+      results = sock.sysread(4096)
+    end
+    assert_equal String, results.class
+    assert_nothing_raised do
+      File.unlink(sock_path)
+      Process.kill(:HUP, pid)
+    end
+    wait_for_file(sock_path)
+    assert File.socket?(sock_path)
+    assert_nothing_raised do
+      sock = UNIXSocket.new(sock_path)
+      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+      results = sock.sysread(4096)
+    end
+    assert_equal String, results.class
+  end
+
   def test_unicorn_config_file
     pid_file = "#{@tmpdir}/test.pid"
     sock = Tempfile.new('unicorn_test_sock')
@@ -442,7 +506,7 @@ end
     assert_equal String, results.class
 
     # try reloading the config
-    sock = Tempfile.new('unicorn_test_sock')
+    sock = Tempfile.new('new_test_sock')
     new_sock_path = sock.path
     @sockets << new_sock_path
     sock.close!
@@ -452,6 +516,7 @@ end
 
     assert_nothing_raised do
       ucfg = File.open(ucfg.path, "wb")
+      ucfg.syswrite("listen \"#{sock_path}\"\n")
       ucfg.syswrite("listen \"#{new_sock_path}\"\n")
       ucfg.syswrite("pid \"#{pid_file}\"\n")
       ucfg.syswrite("logger Logger.new('#{new_log.path}')\n")
@@ -522,6 +587,7 @@ end
     end
 
     wait_master_ready(log.path)
+    File.truncate(log.path, 0)
     wait_for_file(pid_file)
     orig_pid = pid = File.read(pid_file).to_i
     orig_fds = `ls -l /proc/#{pid}/fd`.split(/\n/)
@@ -535,6 +601,8 @@ end
     end
     wait_for_death(pid)
 
+    wait_master_ready(log.path)
+    File.truncate(log.path, 0)
     wait_for_file(pid_file)
     pid = File.read(pid_file).to_i
     assert_not_equal orig_pid, pid
@@ -542,7 +610,7 @@ end
     assert $?.success?
 
     # we could've inherited descriptors the first time around
-    assert expect_size >= curr_fds.size
+    assert expect_size >= curr_fds.size, curr_fds.inspect
     expect_size = curr_fds.size
 
     assert_nothing_raised do
@@ -552,11 +620,13 @@ end
     end
     wait_for_death(pid)
 
+    wait_master_ready(log.path)
+    File.truncate(log.path, 0)
     wait_for_file(pid_file)
     pid = File.read(pid_file).to_i
     curr_fds = `ls -l /proc/#{pid}/fd`.split(/\n/)
     assert $?.success?
-    assert_equal expect_size, curr_fds.size
+    assert_equal expect_size, curr_fds.size, curr_fds.inspect
 
     Process.kill(:QUIT, pid)
     wait_for_death(pid)

data/test/test_helper.rb

@@ -35,8 +35,9 @@ end
 def redirect_test_io
   orig_err = STDERR.dup
   orig_out = STDOUT.dup
-  STDERR.reopen("test_stderr.#{$$}.log")
-  STDOUT.reopen("test_stdout.#{$$}.log")
+  STDERR.reopen("test_stderr.#{$$}.log", "a")
+  STDOUT.reopen("test_stdout.#{$$}.log", "a")
+  STDERR.sync = STDOUT.sync = true
 
   at_exit do
     File.unlink("test_stderr.#{$$}.log") rescue nil

data/test/unit/test_configurator.rb

@@ -4,7 +4,7 @@ require 'unicorn/configurator'
 
 class TestConfigurator < Test::Unit::TestCase
 
-  def test_config_defaults
+  def test_config_init
     assert_nothing_raised { Unicorn::Configurator.new {} }
   end
 
@@ -91,4 +91,19 @@ class TestConfigurator < Test::Unit::TestCase
     end
   end
 
+  def test_after_fork_proc
+    [ proc { |a,b| }, Proc.new { |a,b| }, lambda { |a,b| } ].each do |my_proc|
+      Unicorn::Configurator.new(:after_fork => my_proc).commit!(self)
+      assert_equal my_proc, @after_fork
+    end
+  end
+
+  def test_after_fork_wrong_arity
+    [ proc { |a| }, Proc.new { }, lambda { |a,b,c| } ].each do |my_proc|
+      assert_raises(ArgumentError) do
+        Unicorn::Configurator.new(:after_fork => my_proc)
+      end
+    end
+  end
+
 end