unicorn 4.3.1 → 4.4.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v4.3.1.GIT
+DEF_VER=v4.4.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -32,16 +32,13 @@ MYLIBS = $(RUBYLIB):$(ISOLATE_LIBS)
 # dunno how to implement this as concisely in Ruby, and hell, I love awk
 awk_slow := awk '/def test_/{print FILENAME"--"$$2".n"}' 2>/dev/null
 
-rails_vers := $(subst test/rails/app-,,$(wildcard test/rails/app-*))
 slow_tests := test/unit/test_server.rb test/exec/test_exec.rb \
   test/unit/test_signals.rb test/unit/test_upload.rb
 log_suffix = .$(RUBY_ENGINE).$(RUBY_VERSION).log
-T_r := $(wildcard test/rails/test*.rb)
-T := $(filter-out $(slow_tests) $(T_r), $(wildcard test/*/test*.rb))
+T := $(filter-out $(slow_tests), $(wildcard test/*/test*.rb))
 T_n := $(shell $(awk_slow) $(slow_tests))
 T_log := $(subst .rb,$(log_suffix),$(T))
 T_n_log := $(subst .n,$(log_suffix),$(T_n))
-T_r_log := $(subst .r,$(log_suffix),$(T_r))
 test_prefix = $(CURDIR)/test/$(RUBY_ENGINE)-$(RUBY_VERSION)
 
 ext := ext/unicorn_http
@@ -93,7 +90,7 @@ $(slow_tests): $(test_prefix)/.stamp
 test-integration: $(test_prefix)/.stamp
 	$(MAKE) -C t
 
-test-all: test test-rails test-integration
+test-all: test test-integration
 
 TEST_OPTS = -v
 check_test = grep '0 failures, 0 errors' $(t) >/dev/null
@@ -199,30 +196,6 @@ doc_gz:
 	for i in $(docs); do \
 	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
 
-rails_git_url = git://github.com/rails/rails.git
-rails_git := vendor/rails.git
-$(rails_git)/info/cloned-stamp:
-	git clone --mirror -q $(rails_git_url) $(rails_git)
-	> $@
-
-$(rails_git)/info/v2.2.3-stamp: $(rails_git)/info/cloned-stamp
-	cd $(rails_git) && git fetch
-	cd $(rails_git) && git rev-parse --verify refs/tags/v2.2.3
-	> $@
-
-rails_tests := $(addsuffix .r,$(addprefix $(T_r).,$(rails_vers)))
-test-rails: $(rails_tests)
-$(T_r).%.r: t = $(addsuffix $(log_suffix),$@)
-$(T_r).%.r: rv = $(subst .r,,$(subst $(T_r).,,$@))
-$(T_r).%.r: extra = ' 'v$(rv)
-$(T_r).%.r: arg = $(T_r)
-$(T_r).%.r: export PATH := $(test_prefix)/bin:$(PATH)
-$(T_r).%.r: export RUBYLIB := $(test_prefix):$(test_prefix)/lib:$(MYLIBS)
-$(T_r).%.r: export UNICORN_RAILS_TEST_VERSION = $(rv)
-$(T_r).%.r: export RAILS_GIT_REPO = $(CURDIR)/$(rails_git)
-$(T_r).%.r: $(test_prefix)/.stamp $(rails_git)/info/v2.2.3-stamp
-	$(run_test)
-
 ifneq ($(VERSION),)
 rfproject := mongrel
 rfpackage := unicorn

data/lib/unicorn.rb

@@ -82,7 +82,7 @@ module Unicorn
   def self.listener_names
     Unicorn::HttpServer::LISTENERS.map do |io|
       Unicorn::SocketHelper.sock_name(io)
-    end
+    end + Unicorn::HttpServer::NEW_LISTENERS
   end
 
   def self.log_error(logger, prefix, exc)

data/lib/unicorn/const.rb

@@ -8,7 +8,7 @@
 # improve things much compared to constants.
 module Unicorn::Const
 
-  UNICORN_VERSION = "4.3.1"
+  UNICORN_VERSION = "4.4.0"
 
   # default TCP listen host address (0.0.0.0, all interfaces)
   DEFAULT_HOST = "0.0.0.0"

data/lib/unicorn/http_server.rb

@@ -28,6 +28,9 @@ class Unicorn::HttpServer
   # all bound listener sockets
   LISTENERS = []
 
+  # listeners we have yet to bind
+  NEW_LISTENERS = []
+
   # This hash maps PIDs to Workers
   WORKERS = {}
 
@@ -134,6 +137,7 @@ class Unicorn::HttpServer
 
     self.master_pid = $$
     build_app! if preload_app
+    bind_new_listeners!
     spawn_missing_workers
     self
   end
@@ -738,7 +742,14 @@ class Unicorn::HttpServer
       @init_listeners << Unicorn::Const::DEFAULT_LISTEN
       START_CTX[:argv] << "-l#{Unicorn::Const::DEFAULT_LISTEN}"
     end
-    config_listeners.each { |addr| listen(addr) }
+    NEW_LISTENERS.replace(config_listeners)
+  end
+
+  # call only after calling inherit_listeners!
+  # This binds any listeners we did NOT inherit from the parent
+  def bind_new_listeners!
+    NEW_LISTENERS.each { |addr| listen(addr) }
     raise ArgumentError, "no listeners" if LISTENERS.empty?
+    NEW_LISTENERS.clear
   end
 end

data/lib/unicorn/socket_helper.rb

@@ -28,7 +28,7 @@ module Unicorn
       :backlog => 1024,
 
       # favor latency over bandwidth savings
-      :tcp_nopush => false,
+      :tcp_nopush => nil,
       :tcp_nodelay => true,
     }
     #:startdoc:
@@ -62,12 +62,12 @@ module Unicorn
       end
 
       val = opt[:tcp_nopush]
-      val = DEFAULTS[:tcp_nopush] if nil == val
-      val = val ? 1 : 0
-      if defined?(TCP_CORK) # Linux
-        sock.setsockopt(IPPROTO_TCP, TCP_CORK, val)
-      elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is untested (FreeBSD)
-        sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val)
+      unless val.nil?
+        if defined?(TCP_CORK) # Linux
+          sock.setsockopt(IPPROTO_TCP, TCP_CORK, val)
+        elsif defined?(TCP_NOPUSH) # TCP_NOPUSH is lightly tested (FreeBSD)
+          sock.setsockopt(IPPROTO_TCP, TCP_NOPUSH, val)
+        end
       end
 
       # No good reason to ever have deferred accepts off

data/lib/unicorn/util.rb

@@ -7,6 +7,7 @@ module Unicorn::Util
     append_flags = File::WRONLY | File::APPEND
 
     ! fp.closed? &&
+      fp.stat.file? &&
       fp.sync &&
       (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
     rescue IOError, Errno::EBADF

data/script/isolate_for_tests

@@ -16,9 +16,6 @@ opts = {
 
 pid = fork do
   Isolate.now!(opts) do
-    if RUBY_VERSION.to_f < 2.0
-      gem 'sqlite3-ruby', '1.2.5'
-    end
     gem 'raindrops', '0.8.0'
     gem 'kgio-monkey', '0.4.0'
     gem 'kgio', '2.7.4'
@@ -33,18 +30,3 @@ File.open("#{dst}.#$$", "w") do |fp|
   fp.puts "ISOLATE_LIBS=#{lib_paths.join(':')}"
 end
 File.rename("#{dst}.#$$", dst)
-
-# pure Ruby gems can be shared across all Rubies
-%w(3.0.0).each do |rails_ver|
-  opts[:path] = "tmp/isolate/rails-#{rails_ver}"
-  pid = fork do
-    Isolate.now!(opts) do
-      gem 'rake', '0.8.7'
-      gem 'rails', rails_ver
-    end
-  end
-  _, status = Process.waitpid2(pid)
-  status.success? or abort status.inspect
-  more = Dir["#{opts[:path]}/gems/*-*/lib"].map { |x| File.expand_path(x) }
-  lib_paths.concat(more)
-end

data/t/listener_names.ru

@@ -0,0 +1,4 @@
+use Rack::ContentLength
+use Rack::ContentType, "text/plain"
+names = Unicorn.listener_names.inspect # rely on preload_app=true
+run(lambda { |_| [ 200, {}, [ names ] ] })

data/t/t0022-listener_names-preload_app.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+. ./test-lib.sh
+
+# Raindrops::Middleware depends on Unicorn.listener_names,
+# ensure we don't break Raindrops::Middleware when preload_app is true
+
+t_plan 4 "Unicorn.listener_names available with preload_app=true"
+
+t_begin "setup and startup" && {
+	unicorn_setup
+	echo preload_app true >> $unicorn_config
+	unicorn -E none -D listener_names.ru -c $unicorn_config
+	unicorn_wait_start
+}
+
+t_begin "read listener names includes listener" && {
+	resp=$(curl -sSf http://$listen/)
+	ok=false
+	t_info "resp=$resp"
+	case $resp in
+	*\"$listen\"*) ok=true ;;
+	esac
+	$ok
+}
+
+t_begin "killing succeeds" && {
+	kill $unicorn_pid
+}
+
+t_begin "check stderr" && check_stderr
+
+t_done

data/test/exec/test_exec.rb

@@ -229,11 +229,10 @@ EOF
       pid = xfork { redirect_test_io { exec($unicorn_bin, "-l#@addr:#@port") } }
       wait_master_ready("test_stderr.#{pid}.log")
       wait_workers_ready("test_stderr.#{pid}.log", 1)
-      status = nil
-      assert_nothing_raised do
-        Process.kill(sig, pid)
-        pid, status = Process.waitpid2(pid)
-      end
+
+      Process.kill(sig, pid)
+      pid, status = Process.waitpid2(pid)
+
       reaped = File.readlines("test_stderr.#{pid}.log").grep(/reaped/)
       assert_equal 1, reaped.size
       assert status.exited?
@@ -296,13 +295,13 @@ EOF
     log = "test_stderr.#{pid}.log"
     wait_master_ready(log)
     [ 2, 3].each { |i|
-      assert_nothing_raised { Process.kill(:TTIN, pid) }
+      Process.kill(:TTIN, pid)
       wait_workers_ready(log, i)
     }
     File.truncate(log, 0)
     reaped = nil
     [ 2, 1, 0].each { |i|
-      assert_nothing_raised { Process.kill(:TTOU, pid) }
+      Process.kill(:TTOU, pid)
       DEFAULT_TRIES.times {
         sleep DEFAULT_RES
         reaped = File.readlines(log).grep(/reaped.*\s*worker=#{i}$/)
@@ -381,7 +380,7 @@ EOF
     ucfg.syswrite("listen %(#@addr:#@port)\n")
     ucfg.syswrite("listen %(#@addr:#{port2})\n")
     ucfg.syswrite("pid %(#{pid_file})\n")
-    assert_nothing_raised { Process.kill(:USR2, current_pid) }
+    Process.kill(:USR2, current_pid)
 
     wait_for_file(old_file)
     wait_for_file(pid_file)
@@ -393,10 +392,8 @@ EOF
     assert_equal String, results[0].class
     assert_equal String, results[1].class
 
-    assert_nothing_raised do
-      Process.kill(:QUIT, current_pid)
-      Process.kill(:QUIT, new_pid)
-    end
+    Process.kill(:QUIT, current_pid)
+    Process.kill(:QUIT, new_pid)
   end
 
   def test_broken_reexec_ru
@@ -446,7 +443,7 @@ EOF
 
     # fix the bug
     File.open("config.ru", "wb") { |fp| fp.syswrite(HI) }
-    assert_nothing_raised { Process.kill(:USR2, current_pid) }
+    Process.kill(:USR2, current_pid)
     wait_for_file(old_file)
     wait_for_file(pid_file)
     new_pid = File.read(pid_file).to_i
@@ -455,10 +452,8 @@ EOF
     results = retry_hit(["http://#{@addr}:#{@port}/"])
     assert_equal String, results[0].class
 
-    assert_nothing_raised do
-      Process.kill(:QUIT, current_pid)
-      Process.kill(:QUIT, new_pid)
-    end
+    Process.kill(:QUIT, current_pid)
+    Process.kill(:QUIT, new_pid)
   end
 
   def test_unicorn_config_listener_swap
@@ -486,10 +481,8 @@ EOF
     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
+    reuse = TCPServer.new(@addr, @port)
+    reuse.close
     assert_shutdown(pid)
   end
 
@@ -531,7 +524,7 @@ EOF
     s.syswrite("GET / HTTP/1.0\r\n\r\n")
     results = ''
     loop { results << s.sysread(4096) } rescue nil
-    assert_nothing_raised { s.close }
+    s.close
     assert_equal worker_pid, results.split(/\r\n/).last.to_i
     results = hit(["http://#@addr:#{port2}/"])
     assert_equal String, results[0].class
@@ -574,10 +567,10 @@ EOF
     bf = File.readlines(COMMON_TMP.path).grep(/\bbefore_fork: worker=/)
     assert_equal 4, bf.size
     rotate = Tempfile.new('unicorn_rotate')
-    assert_nothing_raised do
-      File.rename(COMMON_TMP.path, rotate.path)
-      Process.kill(:USR1, pid)
-    end
+
+    File.rename(COMMON_TMP.path, rotate.path)
+    Process.kill(:USR1, pid)
+
     wait_for_file(COMMON_TMP.path)
     assert File.exist?(COMMON_TMP.path), "#{COMMON_TMP.path} exists"
     # USR1 should've been passed to all workers
@@ -599,9 +592,10 @@ EOF
     end
     assert_equal 5, log.grep(/done reopening logs/).size
     assert_equal 0, log.grep(/reopening logs\.\.\./).size
-    assert_nothing_raised { Process.kill(:QUIT, pid) }
-    status = nil
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+
+    Process.kill(:QUIT, pid)
+    pid, status = Process.waitpid2(pid)
+
     assert status.success?, "exited successfully"
   end
 
@@ -682,23 +676,21 @@ EOF
     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
+
+    sock = UNIXSocket.new(sock_path)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    results = sock.sysread(4096)
+
     assert_equal String, results.class
-    assert_nothing_raised do
-      File.unlink(sock_path)
-      Process.kill(:HUP, pid)
-    end
+    File.unlink(sock_path)
+    Process.kill(:HUP, pid)
     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
+
+    sock = UNIXSocket.new(sock_path)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    results = sock.sysread(4096)
+
     assert_equal String, results.class
   end
 
@@ -729,11 +721,11 @@ EOF
     assert File.exist?(pid_file), "pid_file created"
     assert_equal pid, File.read(pid_file).to_i
     assert File.socket?(sock_path), "socket created"
-    assert_nothing_raised do
-      sock = UNIXSocket.new(sock_path)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-      results = sock.sysread(4096)
-    end
+
+    sock = UNIXSocket.new(sock_path)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    results = sock.sysread(4096)
+
     assert_equal String, results.class
 
     # try reloading the config
@@ -745,24 +737,20 @@ EOF
     new_log.sync = true
     assert_equal 0, new_log.size
 
-    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")
-      ucfg.close
-      Process.kill(:HUP, pid)
-    end
+    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")
+    ucfg.close
+    Process.kill(:HUP, pid)
 
     wait_for_file(new_sock_path)
     assert File.socket?(new_sock_path), "socket exists"
     @sockets.each do |path|
-      assert_nothing_raised do
-        sock = UNIXSocket.new(path)
-        sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-        results = sock.sysread(4096)
-      end
+      sock = UNIXSocket.new(path)
+      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+      results = sock.sysread(4096)
       assert_equal String, results.class
     end
 
@@ -791,7 +779,7 @@ EOF
     assert_not_equal pid, new_pid
     pid, status = Process.waitpid2(pid)
     assert status.success?, "original process exited successfully"
-    assert_nothing_raised { Process.kill(0, new_pid) }
+    Process.kill(0, new_pid)
     reexec_usr2_quit_test(new_pid, pid_file)
   end
 
@@ -845,11 +833,10 @@ EOF
     assert $?.success?
     expect_size = orig_fds.size
 
-    assert_nothing_raised do
-      Process.kill(:USR2, pid)
-      wait_for_file("#{pid_file}.oldbin")
-      Process.kill(:QUIT, pid)
-    end
+    Process.kill(:USR2, pid)
+    wait_for_file("#{pid_file}.oldbin")
+    Process.kill(:QUIT, pid)
+
     wait_for_death(pid)
 
     wait_master_ready(log.path)
@@ -865,11 +852,10 @@ EOF
     assert expect_size >= curr_fds.size, curr_fds.inspect
     expect_size = curr_fds.size
 
-    assert_nothing_raised do
-      Process.kill(:USR2, pid)
-      wait_for_file("#{pid_file}.oldbin")
-      Process.kill(:QUIT, pid)
-    end
+    Process.kill(:USR2, pid)
+    wait_for_file("#{pid_file}.oldbin")
+    Process.kill(:QUIT, pid)
+
     wait_for_death(pid)
 
     wait_master_ready(log.path)
@@ -930,7 +916,7 @@ EOF
     assert daemon_pid > 0
     Process.kill(:HUP, daemon_pid)
     assert_equal '2', r.read(1)
-    assert_nothing_raised { Process.kill(:TERM, hitter) }
+    Process.kill(:TERM, hitter)
     _, hitter_status = Process.waitpid2(hitter)
     assert(hitter_status.success?,
            "invalid: #{hitter_status.inspect} #{File.read(pids.path)}" \
@@ -944,7 +930,7 @@ EOF
       assert x > 0
       assert pids[x] > 0
     }
-    assert_nothing_raised { Process.kill(:QUIT, daemon_pid) }
+    Process.kill(:QUIT, daemon_pid)
     wait_for_death(daemon_pid)
   end
 
@@ -960,12 +946,12 @@ EOF
     default_listen_lock do
       res, pid_path = default_listen_setup
       daemon_pid = File.read(pid_path).to_i
-      assert_nothing_raised { Process.kill(:HUP, daemon_pid) }
+      Process.kill(:HUP, daemon_pid)
       wait_workers_ready("test_stderr.#$$.log", 1)
       res2 = hit(["http://#{Unicorn::Const::DEFAULT_LISTEN}/"])
       assert_match %r{\d+}, res2.first
       assert res2.first != res.first
-      assert_nothing_raised { Process.kill(:QUIT, daemon_pid) }
+      Process.kill(:QUIT, daemon_pid)
       wait_for_death(daemon_pid)
     end
   end
@@ -974,13 +960,13 @@ EOF
     default_listen_lock do
       res, pid_path = default_listen_setup
       daemon_pid = File.read(pid_path).to_i
-      assert_nothing_raised {
-        Process.kill(:USR2, daemon_pid)
-        wait_for_file("#{pid_path}.oldbin")
-        wait_for_file(pid_path)
-        Process.kill(:QUIT, daemon_pid)
-        wait_for_death(daemon_pid)
-      }
+
+      Process.kill(:USR2, daemon_pid)
+      wait_for_file("#{pid_path}.oldbin")
+      wait_for_file(pid_path)
+      Process.kill(:QUIT, daemon_pid)
+      wait_for_death(daemon_pid)
+
       daemon_pid = File.read(pid_path).to_i
       wait_workers_ready("test_stderr.#$$.log", 1)
       File.truncate("test_stderr.#$$.log", 0)
@@ -989,13 +975,13 @@ EOF
       assert_match %r{\d+}, res2.first
       assert res2.first != res.first
 
-      assert_nothing_raised { Process.kill(:HUP, daemon_pid) }
+      Process.kill(:HUP, daemon_pid)
       wait_workers_ready("test_stderr.#$$.log", 1)
       File.truncate("test_stderr.#$$.log", 0)
       res3 = hit(["http://#{Unicorn::Const::DEFAULT_LISTEN}/"])
       assert res2.first != res3.first
 
-      assert_nothing_raised { Process.kill(:QUIT, daemon_pid) }
+      Process.kill(:QUIT, daemon_pid)
       wait_for_death(daemon_pid)
     end
   end