yahns 0.0.1 → 0.0.2

data/test/test_reopen_logs.rb

@@ -4,7 +4,7 @@ require_relative 'server_helper'
 require 'rack/commonlogger'
 
 class TestReopenLogs < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
@@ -32,10 +32,7 @@ class TestReopenLogs < Testcase
       end
       worker_processes 1 if worker
     end
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      Yahns::Server.new(cfg).start.join
-    end
+    pid = mkserver(cfg)
     Net::HTTP.start(host, port) do |http|
       res = http.request(Net::HTTP::Get.new("/aaa"))
       assert_equal 200, res.code.to_i
@@ -55,9 +52,6 @@ class TestReopenLogs < Testcase
         end until File.read(opath) =~ /bbb/
       end
     end
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     quit_wait(pid)
   end

data/test/test_serve_static.rb

@@ -4,12 +4,50 @@ require_relative 'server_helper'
 require 'rack/file'
 
 class TestServeStatic < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
 
   def test_serve_static
+    tmpdir = Dir.mktmpdir
+    sock = "#{tmpdir}/sock"
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      GTL.synchronize do
+        app(:rack, Rack::File.new(Dir.pwd)) {
+          listen sock
+          listen "#{host}:#{port}"
+        }
+      end
+      logger(Logger.new(err.path))
+    end
+    pid = mkserver(cfg)
+    gplv3 = File.read("COPYING")
+    Net::HTTP.start(host, port) do |http|
+      res = http.request(Net::HTTP::Get.new("/COPYING"))
+      assert_equal gplv3, res.body
+
+      req = Net::HTTP::Get.new("/COPYING", "Range" => "bytes=5-46")
+      res = http.request(req)
+      assert_match %r{bytes 5-46/\d+\z}, res["Content-Range"]
+      assert_equal gplv3[5..46], res.body
+    end
+
+    # ensure sendfile works on Unix sockets
+    s = UNIXSocket.new(sock)
+    s.close_on_exec = true
+    s.write "GET /COPYING\r\n\r\n"
+    assert_equal gplv3, Timeout.timeout(30) { s.read }
+    s.close
+  ensure
+    quit_wait(pid)
+    FileUtils.rm_rf tmpdir
+  end
+
+  def test_serve_static_blocked_header
     err = @err
     cfg = Yahns::Config.new
     host, port = @srv.addr[3], @srv.addr[1]
@@ -19,10 +57,10 @@ class TestServeStatic < Testcase
       end
       logger(Logger.new(err.path))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
+    pid = mkserver(cfg) do
+      $_tw_blocked = 0
+      $_tw_block_on = [1]
+      Yahns::HttpClient.__send__(:include, TrywriteBlocked)
     end
     gplv3 = File.read("COPYING")
     Net::HTTP.start(host, port) do |http|
@@ -33,10 +71,68 @@ class TestServeStatic < Testcase
       res = http.request(req)
       assert_equal gplv3[5..46], res.body
     end
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     quit_wait(pid)
   end
+
+  def mksparse(tmpdir)
+    sparse = "#{tmpdir}/sparse"
+    off = 100 * 1024 * 1024
+    File.open(sparse, "w") do |fp|
+      fp.sysseek(off)
+      fp.syswrite '.'
+    end
+    [ off + 1, sparse ]
+  end
+
+  def test_truncated_sendfile
+    tmpdir = Dir.mktmpdir
+    size, sparse = mksparse(tmpdir)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        app(:rack, Rack::File.new(tmpdir)) { listen "#{host}:#{port}" }
+        stderr_path err.path
+      end
+    end
+    c = get_tcp_client(host, port)
+    c.write "GET /sparse HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    wait_for_full(c)
+    File.truncate(sparse, 5)
+    buf = Timeout.timeout(60) { c.read }
+    c.close
+    assert_operator buf.size, :<, size
+  ensure
+    quit_wait(pid)
+    FileUtils.rm_rf(tmpdir)
+  end
+
+  def test_expanded_sendfile
+    tmpdir = Dir.mktmpdir
+    size, sparse = mksparse(tmpdir)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        app(:rack, Rack::File.new(tmpdir)) { listen "#{host}:#{port}" }
+        stderr_path err.path
+      end
+    end
+    c = get_tcp_client(host, port)
+    c.write "GET /sparse\r\n\r\n"
+    wait_for_full(c)
+
+    File.open(sparse, "w") do |fp|
+      fp.sysseek(size * 2)
+      fp.syswrite '.'
+    end
+    Timeout.timeout(60) do
+      bytes = IO.copy_stream(c, "/dev/null")
+      assert_equal bytes, size
+      assert_raises(EOFError) { c.readpartial 1 }
+    end
+    c.close
+  ensure
+    quit_wait(pid)
+    FileUtils.rm_rf(tmpdir)
+  end
 end

data/test/test_server.rb

@@ -3,7 +3,7 @@
 require_relative 'server_helper'
 
 class TestServer < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
 
   alias setup server_helper_setup
@@ -18,13 +18,9 @@ class TestServer < Testcase
       GTL.synchronize { app(:rack, ru) { listen "#{host}:#{port}" } }
       logger(Logger.new(err.path))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
+    pid = mkserver(cfg)
     run_client(host, port) { |res| assert_equal "HI", res.body }
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
 
     # test pipelining
     r = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
@@ -60,9 +56,6 @@ class TestServer < Testcase
     _, status = Timeout.timeout(10) { Process.waitpid2(pid) }
     assert status.success?, status.inspect
     c.close
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   end
 
   def test_input_body_true; input_body(true); end
@@ -83,12 +76,8 @@ class TestServer < Testcase
       end
       logger(Logger.new(err.path))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
-    c = TCPSocket.new(host, port)
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
     buf = "PUT / HTTP/1.0\r\nContent-Length: 2\r\n\r\nHI"
     c.write(buf)
     IO.select([c], nil, nil, 5)
@@ -100,7 +89,7 @@ class TestServer < Testcase
 
     # pipelined oneshot
     buf = "PUT / HTTP/1.1\r\nContent-Length: 2\r\n\r\nHI"
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
     c.write(buf + buf)
     buf = ""
     Timeout.timeout(10) do
@@ -132,9 +121,6 @@ class TestServer < Testcase
     first = $1
     assert rv
     assert_equal first, buf
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     c.close if c
     quit_wait(pid)
@@ -165,12 +151,8 @@ class TestServer < Testcase
       end
       logger(Logger.new(err.path))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
-    c = TCPSocket.new(host, port)
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
     buf = "PUT / HTTP/1.0\r\nTrailer:xbt\r\nTransfer-Encoding: chunked\r\n\r\n"
     c.write(buf)
     xbt = btype.to_s
@@ -199,7 +181,7 @@ class TestServer < Testcase
     msgs = %w(ZZ zz)
     err = @err
     cfg = Yahns::Config.new
-    bpipe = IO.pipe
+    bpipe = cloexec_pipe
     host, port = @srv.addr[3], @srv.addr[1]
     cfg.instance_eval do
       ru = lambda { |e|
@@ -237,7 +219,7 @@ class TestServer < Testcase
     # ensure we set worker_threads correctly
     eggs = srv.instance_variable_get(:@config).qeggs
     assert_equal 1, eggs.size
-    assert_equal 1, eggs[:default].instance_variable_get(:@worker_threads)
+    assert_equal 1, eggs.first[1].instance_variable_get(:@worker_threads)
 
     pid = fork do
       bpipe[1].close
@@ -245,8 +227,8 @@ class TestServer < Testcase
       srv.start.join
     end
     bpipe[0].close
-    a = TCPSocket.new(host, port)
-    b = TCPSocket.new(host, port)
+    a = get_tcp_client(host, port)
+    b = get_tcp_client(host, port)
     a.write("GET /sleep HTTP/1.0\r\n\r\n")
     r = IO.select([a], nil, nil, 4)
     assert r, "nothing ready"
@@ -288,37 +270,6 @@ class TestServer < Testcase
     end
   end
 
-  # Linux blocking accept() has fair behavior between multiple tasks
-  def test_mp_balance
-    skip("this fails occasionally on Linux, still...")
-    skip("linux-only test") unless RUBY_PLATFORM =~ /linux/
-    pid, host, port = new_mp_server(2)
-    seen = {}
-
-    # wait for both processes to spin up
-    Timeout.timeout(10) do
-      run_client(host, port) { |res| seen[res.body] = 1 } until seen.size == 2
-    end
-
-    prev = nil
-    req = Net::HTTP::Get.new("/")
-    # we should bounce new connections between 2 processes
-    4.times do
-      Net::HTTP.start(host, port) do |http|
-        res = http.request(req)
-        assert_equal 200, res.code.to_i
-        assert_equal "keep-alive", res["Connection"]
-        refute_equal prev, res.body, "same PID accepted twice"
-        prev = res.body.dup
-        seen[prev] += 1
-        666.times { Thread.pass } # have the other acceptor to wake up
-      end
-    end
-    assert_equal 2, seen.size
-  ensure
-    quit_wait(pid)
-  end
-
   def test_mp_worker_die
     pid, host, port = new_mp_server
     wpid1 = wpid2 = nil
@@ -349,7 +300,7 @@ class TestServer < Testcase
   end
 
   def run_client(host, port)
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
     Net::HTTP.start(host, port) do |http|
       res = http.request(Net::HTTP::Get.new("/"))
       assert_equal 200, res.code.to_i
@@ -381,11 +332,7 @@ class TestServer < Testcase
       GTL.synchronize { app(:rack, ru.path) { listen "#{host}:#{port}" } }
       logger(Logger.new(File.open(err.path, "a")))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
+    pid = mkserver(cfg)
     [ pid, host, port ]
   end
 
@@ -403,12 +350,8 @@ class TestServer < Testcase
       }
       logger(Logger.new(err.path))
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
-    c = TCPSocket.new(host, port)
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
     c.write("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
     buf = Timeout.timeout(10) { c.read }
     assert_match(/Connection: close/, buf)
@@ -416,4 +359,436 @@ class TestServer < Testcase
   ensure
     quit_wait(pid)
   end
+
+  def test_ttin_ttou
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    ru = lambda { |_|
+      b = "#$$"
+      [ 200, {'Content-Length'=>b.size.to_s}, [b] ]
+    }
+    cfg.instance_eval do
+      GTL.synchronize { app(:rack, ru) { listen "#{host}:#{port}" } }
+      worker_processes 1
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+
+    read_pid = lambda do
+      c = get_tcp_client(host, port)
+      c.write("GET /\r\n\r\n")
+      body = Timeout.timeout(10) { c.read }
+      c.close
+      assert_match(/\A\d+\z/, body)
+      body
+    end
+
+    orig_worker_pid = read_pid.call.to_i
+    assert_equal 1, Process.kill(0, orig_worker_pid)
+
+    Process.kill(:TTOU, pid)
+    poke_until_dead(orig_worker_pid)
+
+    Process.kill(:TTIN, pid)
+    second_worker_pid = read_pid.call.to_i
+
+    # PID recycling is rare, hope it doesn't fail here
+    refute_equal orig_worker_pid, second_worker_pid
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_mp_hooks
+    err = @err
+    out = tmpfile(%w(mp_hooks .out))
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda {|_|x="#$$";[200,{'Content-Length'=>x.size.to_s },[x]]}
+      GTL.synchronize {
+        app(:rack, ru) {
+          listen "#{host}:#{port}"
+          persistent_connections false
+          atfork_child { warn "INFO hihi from app.atfork_child" }
+        }
+        worker_processes(1) do
+          atfork_child { puts "af #$$ worker is running" }
+          atfork_prepare { puts "af #$$ parent about to spawn" }
+          atfork_parent { puts "af #$$ this is probably not useful" }
+        end
+      }
+      stderr_path err.path
+      stdout_path out.path
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    c.write("GET / HTTP/1.0\r\nHost: example.com\r\n\r\n")
+    buf = Timeout.timeout(10) { c.read }
+    c.close
+    head, body = buf.split(/\r\n\r\n/)
+    assert_match(/200 OK/, head)
+    assert_match(/\A\d+\z/, body)
+    worker_pid = body.to_i
+    lines = out.readlines.map!(&:chomp!)
+    out.close!
+
+    assert_match %r{INFO hihi from app\.atfork_child}, File.read(err.path)
+
+    assert_equal 3, lines.size
+    assert_equal("af #{pid} parent about to spawn", lines.shift)
+
+    # child/parent ordering is not guaranteed
+    assert_equal 1, lines.grep(/\Aaf #{pid} this is probably not useful\z/).size
+    assert_equal 1, lines.grep(/\Aaf #{worker_pid} worker is running\z/).size
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_mp_hooks_worker_nr
+    err = @err
+    out = tmpfile(%w(mp_hooks .out))
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda {|_|x="#$$";[200,{'Content-Length'=>x.size.to_s },[x]]}
+      GTL.synchronize {
+        app(:rack, ru) {
+          listen "#{host}:#{port}"
+          persistent_connections false
+          atfork_child { |nr| warn "INFO hihi.#{nr} from app.atfork_child" }
+        }
+        worker_processes(1) do
+          atfork_child { |nr| puts "af.#{nr} #$$ worker is running" }
+          atfork_prepare { |nr| puts "af.#{nr} #$$ parent about to spawn" }
+          atfork_parent { |nr| puts "af.#{nr} #$$ this is probably not useful" }
+        end
+      }
+      stderr_path err.path
+      stdout_path out.path
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    c.write("GET / HTTP/1.0\r\nHost: example.com\r\n\r\n")
+    buf = Timeout.timeout(10) { c.read }
+    c.close
+    head, body = buf.split(/\r\n\r\n/)
+    assert_match(/200 OK/, head)
+    assert_match(/\A\d+\z/, body)
+    worker_pid = body.to_i
+    lines = out.readlines.map!(&:chomp!)
+    out.close!
+
+    assert_match %r{INFO hihi\.0 from app\.atfork_child}, File.read(err.path)
+    assert_equal 3, lines.size
+    assert_equal("af.0 #{pid} parent about to spawn", lines.shift)
+
+    # child/parent ordering is not guaranteed
+    assert_equal 1,
+        lines.grep(/\Aaf\.0 #{pid} this is probably not useful\z/).size
+    assert_equal 1,
+        lines.grep(/\Aaf\.0 #{worker_pid} worker is running\z/).size
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_pidfile_usr2
+    tmpdir = Dir.mktmpdir
+    pidf = "#{tmpdir}/pid"
+    old = "#{pidf}.oldbin"
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      GTL.synchronize {
+        app(:rack, lambda { |_| [ 200, {}, [] ] }) { listen "#{host}:#{port}" }
+        pid pidf
+      }
+      stderr_path err.path
+    end
+    pid = mkserver(cfg) do
+      Yahns::START[0] = "sh"
+      Yahns::START[:argv] = [ '-c', "echo $$ > #{pidf}; sleep 10" ]
+    end
+
+    # ensure server is running
+    c = get_tcp_client(host, port)
+    c.write("GET / HTTP/1.0\r\n\r\n")
+    buf = Timeout.timeout(10) { c.read }
+    assert_match(/Connection: close/, buf)
+    c.close
+
+    assert_equal pid, File.read(pidf).to_i
+    before = File.stat(pidf)
+
+    # start the upgrade
+    Process.kill(:USR2, pid)
+    Timeout.timeout(10) { sleep(0.01) until File.exist?(old) }
+    after = File.stat(old)
+    assert_equal after.ino, before.ino
+    Timeout.timeout(10) { sleep(0.01) until File.exist?(pidf) }
+    new = File.read(pidf).to_i
+    refute_equal pid, new
+
+    # abort the upgrade (just wait for it to finish)
+    Process.kill(:TERM, new)
+    poke_until_dead(new)
+
+    # ensure reversion is OK
+    Timeout.timeout(10) { sleep(0.01) while File.exist?(old) }
+    after = File.stat(pidf)
+    assert_equal before.ino, after.ino
+    assert_equal before.mtime, after.mtime
+    assert_equal pid, File.read(pidf).to_i
+
+    lines = File.readlines(err.path).grep(/ERROR/)
+    assert_equal 1, lines.size
+    assert_match(/reaped/, lines[0], lines)
+    File.truncate(err.path, 0)
+  ensure
+    quit_wait(pid)
+    FileUtils.rm_rf(tmpdir)
+  end
+
+  module MockSwitchUser
+    def self.included(cls)
+      cls.__send__(:remove_method, :switch_user)
+      cls.__send__(:alias_method, :switch_user, :mock_switch_user)
+    end
+
+    def mock_switch_user(user, group = nil)
+      $yahns_user = [ $$, user, group ]
+    end
+  end
+
+  def test_user_no_workers
+    refute defined?($yahns_user), "$yahns_user global should be undefined"
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda do |_|
+        b = $yahns_user.inspect
+        [ 200, {'Content-Length'=>b.size.to_s }, [b] ]
+      end
+      GTL.synchronize { app(:rack, ru) { listen "#{host}:#{port}" } }
+      user "nobody"
+      stderr_path err.path
+    end
+    pid = mkserver(cfg) { Yahns::Server.__send__(:include, MockSwitchUser) }
+    expect = [ pid, "nobody", nil ].inspect
+    run_client(host, port) { |res| assert_equal expect, res.body }
+    refute defined?($yahns_user), "$yahns_user global should be undefined"
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_user_workers
+    refute defined?($yahns_user), "$yahns_user global should be undefined"
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda do |_|
+        b = $yahns_user.inspect
+        [ 200, {'Content-Length'=>b.size.to_s, 'X-Pid' => "#$$" }, [b] ]
+      end
+      GTL.synchronize { app(:rack, ru) { listen "#{host}:#{port}" } }
+      user "nobody"
+      stderr_path err.path
+      worker_processes 1
+    end
+    pid = mkserver(cfg) { Yahns::Server.__send__(:include, MockSwitchUser) }
+    run_client(host, port) do |res|
+      worker_pid = res["X-Pid"].to_i
+      assert_operator worker_pid, :>, 0
+      refute_equal pid, worker_pid
+      refute_equal $$, worker_pid
+      expect = [ worker_pid, "nobody", nil ].inspect
+      assert_equal expect, res.body
+    end
+    refute defined?($yahns_user), "$yahns_user global should be undefined"
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_working_directory
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    ru = lambda { |_|
+      [ 200, {'Content-Length'=>Dir.pwd.size.to_s }, [Dir.pwd] ]
+    }
+    Dir.mktmpdir do |tmpdir|
+      begin
+        pid = mkserver(cfg) do
+          $LOAD_PATH << File.expand_path("lib")
+          cfg.instance_eval do
+            working_directory tmpdir
+            app(:rack, ru) { listen "#{host}:#{port}" }
+            stderr_path err.path
+          end
+        end
+        refute_equal Dir.pwd, tmpdir
+        Net::HTTP.start(host, port) do |http|
+          assert_equal tmpdir, http.request(Net::HTTP::Get.new("/")).body
+        end
+      ensure
+        quit_wait(pid)
+      end
+    end
+  end
+
+  def test_errors
+    tmpdir = Dir.mktmpdir
+    sock = "#{tmpdir}/sock"
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    re = tmpfile(%w(rack .errors))
+    ru = lambda { |e|
+      e["rack.errors"].write "INFO HIHI\n"
+      [ 200, {'Content-Length'=>'2' }, %w(OK) ]
+    }
+    cfg.instance_eval do
+      GTL.synchronize {
+        app(:rack, ru) {
+          listen "#{host}:#{port}"
+          errors re.path
+        }
+        app(:rack, ru) { listen sock }
+      }
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    Net::HTTP.start(host, port) do |http|
+      assert_equal "OK", http.request(Net::HTTP::Get.new("/")).body
+    end
+    assert_equal "INFO HIHI\n", re.read
+
+    c = UNIXSocket.new(sock)
+    c.close_on_exec = true
+    c.write "GET /\r\n\r\n"
+    assert_equal c, c.wait(30)
+    assert_equal "OK", c.read
+    c.close
+    assert_match %r{INFO HIHI}, File.read(err.path)
+  ensure
+    re.close!
+    quit_wait(pid)
+    FileUtils.rm_rf(tmpdir)
+  end
+
+  def test_persistent_shutdown_timeout; _persistent_shutdown(nil); end
+  def test_persistent_shutdown_timeout_mp; _persistent_shutdown(1); end
+
+  def _persistent_shutdown(nr_workers)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      ru = lambda { |e| [ 200, {'Content-Length'=>'2'}, %w(OK) ] }
+      cfg.instance_eval do
+        app(:rack, ru) { listen "#{host}:#{port}" }
+        stderr_path err.path
+        shutdown_timeout 1
+        worker_processes(nr_workers) if nr_workers
+      end
+    end
+    c = get_tcp_client(host, port)
+    c.write "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    assert_equal c, c.wait(30)
+    buf = ""
+    re = /\r\n\r\nOK\z/
+    Timeout.timeout(30) do
+      begin
+        buf << c.readpartial(666)
+      end until re =~ buf
+    end
+    refute_match %r{Connection: close}, buf
+    assert_nil c.wait(0.001), "connection should still be alive"
+    Process.kill(:QUIT, pid)
+    _, status = Timeout.timeout(5) { Process.waitpid2(pid) }
+    assert status.success?, status.inspect
+    assert_nil c.wait(1)
+    assert_nil c.read(666)
+  end
+
+  def test_before_exec
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    ru = lambda { |e| [ 200, {'Content-Length'=>'2' }, %w(OK) ] }
+    tmp = tmpfile(%w(exec .pid))
+    x = "echo $$ >> #{tmp.path}"
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        app(:rack, ru) { listen "#{host}:#{port}" }
+        before_exec do |exec_cmd|
+          exec_cmd.replace(%W(/bin/sh -c #{x}))
+        end
+        stderr_path err.path
+      end
+    end
+
+    # did we start properly?
+    Net::HTTP.start(host, port) do |http|
+      assert_equal "OK", http.request(Net::HTTP::Get.new("/")).body
+    end
+
+    Process.kill(:USR2, pid)
+    Timeout.timeout(30) { sleep(0.01) until tmp.size > 0 }
+    buf = tmp.read
+    assert_match %r{\A\d+}, buf
+    exec_pid = buf.to_i
+    poke_until_dead exec_pid
+
+    # ensure it recovered
+    Net::HTTP.start(host, port) do |http|
+      assert_equal "OK", http.request(Net::HTTP::Get.new("/")).body
+    end
+    assert_match %r{reaped}, err.read
+    err.truncate(0)
+  ensure
+    tmp.close!
+    quit_wait(pid)
+  end
+
+  def test_app_controls_close
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        ru = lambda { |env|
+          h = { 'Content-Length' => '2' }
+          if env["PATH_INFO"] =~ %r{\A/(.+)}
+            h["Connection"] = $1
+          end
+          [ 200, h, ['HI'] ]
+        }
+        app(:rack, ru) { listen "#{host}:#{port}" }
+        stderr_path err.path
+      end
+    end
+    c = get_tcp_client(host, port)
+
+    # normal response
+    c.write "GET /keep-alive HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    buf = ""
+    Timeout.timeout(30) do
+      buf << c.readpartial(4096) until buf =~ /HI\z/
+    end
+    assert_match %r{^Connection: keep-alive}, buf
+    assert_raises(Errno::EAGAIN,IO::WaitReadable) { c.read_nonblock(666) }
+
+    # we allow whatever in the response, but don't send it
+    c.write "GET /whatever HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    buf = ""
+    Timeout.timeout(30) do
+      buf << c.readpartial(4096) until buf =~ /HI\z/
+    end
+    assert_match %r{^Connection: keep-alive}, buf
+    assert_raises(Errno::EAGAIN,IO::WaitReadable) { c.read_nonblock(666) }
+
+    c.write "GET /close HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    buf = ""
+    Timeout.timeout(30) do
+      buf << c.readpartial(4096) until buf =~ /HI\z/
+    end
+    assert_match %r{^Connection: close}, buf
+    assert_equal c, IO.select([c], nil, nil, 30)[0][0]
+    assert_raises(EOFError) { c.readpartial(666) }
+    c.close
+  ensure
+    quit_wait(pid)
+  end
 end