unicorn-fork 6.1.1

data/test/unit/test_server.rb

@@ -0,0 +1,245 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+# Copyright (c) 2005 Zed A. Shaw
+# You can redistribute it and/or modify it under the same terms as Ruby 1.8 or
+# the GPLv2+ (GPLv3+ preferred)
+#
+# Additional work donated by contributors.  See git history
+# for more information.
+
+require './test/test_helper'
+
+include Unicorn
+
+class TestHandler
+
+  def call(env)
+    while env['rack.input'].read(4096)
+    end
+    [200, { 'content-type' => 'text/plain' }, ['hello!\n']]
+  rescue Unicorn::ClientShutdown, Unicorn::HttpParserError => e
+    $stderr.syswrite("#{e.class}: #{e.message} #{e.backtrace.empty?}\n")
+    raise e
+  end
+end
+
+class TestRackAfterReply
+  def initialize
+    @called = false
+  end
+
+  def call(env)
+    while env['rack.input'].read(4096)
+    end
+
+    env["rack.after_reply"] << -> { @called = true }
+
+    [200, { 'content-type' => 'text/plain' }, ["after_reply_called: #{@called}"]]
+  rescue Unicorn::ClientShutdown, Unicorn::HttpParserError => e
+    $stderr.syswrite("#{e.class}: #{e.message} #{e.backtrace.empty?}\n")
+    raise e
+  end
+end
+
+class WebServerTest < Test::Unit::TestCase
+
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\n\r\n"
+    @port = unused_port
+    @tester = TestHandler.new
+    redirect_test_io do
+      @server = HttpServer.new(@tester, :listeners => [ "127.0.0.1:#{@port}" ] )
+      @server.start
+    end
+  end
+
+  def teardown
+    redirect_test_io do
+      wait_workers_ready("test_stderr.#$$.log", 1)
+      File.truncate("test_stderr.#$$.log", 0)
+      @server.stop(false)
+    end
+    reset_sig_handlers
+  end
+
+  def test_preload_app_config
+    teardown
+    tmp = Tempfile.new('test_preload_app_config')
+    ObjectSpace.undefine_finalizer(tmp)
+    app = lambda { ||
+      tmp.sysseek(0)
+      tmp.truncate(0)
+      tmp.syswrite($$)
+      lambda { |env| [ 200, { 'content-type' => 'text/plain' }, [ "#$$\n" ] ] }
+    }
+    redirect_test_io do
+      @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"] )
+      @server.start
+    end
+    results = hit(["http://localhost:#@port/"])
+    worker_pid = results[0].to_i
+    assert worker_pid != 0
+    tmp.sysseek(0)
+    loader_pid = tmp.sysread(4096).to_i
+    assert loader_pid != 0
+    assert_equal worker_pid, loader_pid
+    teardown
+
+    redirect_test_io do
+      @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"],
+                               :preload_app => true)
+      @server.start
+    end
+    results = hit(["http://localhost:#@port/"])
+    worker_pid = results[0].to_i
+    assert worker_pid != 0
+    tmp.sysseek(0)
+    loader_pid = tmp.sysread(4096).to_i
+    assert_equal $$, loader_pid
+    assert worker_pid != loader_pid
+  ensure
+    tmp.close!
+  end
+
+  def test_after_reply
+    teardown
+
+    redirect_test_io do
+      @server = HttpServer.new(TestRackAfterReply.new,
+                               :listeners => [ "127.0.0.1:#@port"])
+      @server.start
+    end
+
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+
+    responses = sock.read(4096)
+    assert_match %r{\AHTTP/1.[01] 200\b}, responses
+    assert_match %r{^after_reply_called: false}, responses
+
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+
+    responses = sock.read(4096)
+    assert_match %r{\AHTTP/1.[01] 200\b}, responses
+    assert_match %r{^after_reply_called: true}, responses
+
+    sock.close
+  end
+
+  def test_simple_server
+    results = hit(["http://localhost:#{@port}/test"])
+    assert_equal 'hello!\n', results[0], "Handler didn't really run"
+  end
+
+  def test_client_malformed_body
+    bs = 15653984
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("PUT /hello HTTP/1.1\r\n")
+    sock.syswrite("Host: example.com\r\n")
+    sock.syswrite("Transfer-Encoding: chunked\r\n")
+    sock.syswrite("Trailer: X-Foo\r\n")
+    sock.syswrite("\r\n")
+    sock.syswrite("%x\r\n" % [ bs ])
+    sock.syswrite("F" * bs)
+    begin
+      File.open("/dev/urandom", "rb") { |fp| sock.syswrite(fp.sysread(16384)) }
+    rescue
+    end
+    assert_nil sock.close
+    next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
+    assert_equal 'hello!\n', next_client
+    lines = File.readlines("test_stderr.#$$.log")
+    lines = lines.grep(/^Unicorn::HttpParserError: .* true$/)
+    assert_equal 1, lines.size
+  end
+
+  def do_test(string, chunk, close_after=nil, shutdown_delay=0)
+    # Do not use instance variables here, because it needs to be thread safe
+    socket = tcp_socket("127.0.0.1", @port);
+    request = StringIO.new(string)
+    chunks_out = 0
+
+    while data = request.read(chunk)
+      chunks_out += socket.write(data)
+      socket.flush
+      sleep 0.2
+      if close_after and chunks_out > close_after
+        socket.close
+        sleep 1
+      end
+    end
+    sleep(shutdown_delay)
+    socket.write(" ") # Some platforms only raise the exception on attempted write
+    socket.flush
+  end
+
+  def test_trickle_attack
+    do_test(@valid_request, 3)
+  end
+
+  def test_close_client
+    assert_raises IOError do
+      do_test(@valid_request, 10, 20)
+    end
+  end
+
+  def test_bad_client
+    redirect_test_io do
+      do_test("GET /test HTTP/BAD", 3)
+    end
+  end
+
+  def test_logger_set
+    assert_equal @server.logger, Unicorn::HttpRequest::DEFAULTS["rack.logger"]
+  end
+
+  def test_logger_changed
+    tmp = Logger.new($stdout)
+    @server.logger = tmp
+    assert_equal tmp, Unicorn::HttpRequest::DEFAULTS["rack.logger"]
+  end
+
+  def test_bad_client_400
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\nHost: foo\rbar\r\n\r\n")
+    assert_match %r{\AHTTP/1.[01] 400\b}, sock.sysread(4096)
+    assert_nil sock.close
+  end
+
+  def test_http_0_9
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET /hello\r\n")
+    assert_match 'hello!\n', sock.sysread(4096)
+    assert_nil sock.close
+  end
+
+  def test_header_is_too_long
+    redirect_test_io do
+      long = "GET /test HTTP/1.1\r\n" + ("X-Big: stuff\r\n" * 15000) + "\r\n"
+      assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
+        do_test(long, long.length/2, 10)
+      end
+    end
+  end
+
+  def test_file_streamed_request
+    body = "a" * (Unicorn::Const::MAX_BODY * 2)
+    long = "PUT /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
+    do_test(long, Unicorn::Const::CHUNK_SIZE * 2 - 400)
+  end
+
+  def test_file_streamed_request_bad_body
+    body = "a" * (Unicorn::Const::MAX_BODY * 2)
+    long = "GET /test HTTP/1.1\r\nContent-ength: #{body.length}\r\n\r\n" + body
+    assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
+                  Errno::EBADF) {
+      do_test(long, Unicorn::Const::CHUNK_SIZE * 2 - 400)
+    }
+  end
+
+  def test_listener_names
+    assert_equal [ "127.0.0.1:#@port" ], Unicorn.listener_names
+  end
+end

data/test/unit/test_signals.rb

@@ -0,0 +1,189 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+# Copyright (c) 2009 Eric Wong
+# You can redistribute it and/or modify it under the same terms as Ruby 1.8 or
+# the GPLv2+ (GPLv3+ preferred)
+#
+# Ensure we stay sane in the face of signals being sent to us
+
+require './test/test_helper'
+
+include Unicorn
+
+class Dd
+  def initialize(bs, count)
+    @count = count
+    @buf = ' ' * bs
+  end
+
+  def each(&block)
+    @count.times { yield @buf }
+  end
+end
+
+class SignalsTest < Test::Unit::TestCase
+
+  def setup
+    @bs = 1 * 1024 * 1024
+    @count = 100
+    @port = unused_port
+    @sock = Tempfile.new('unicorn.sock')
+    @tmp = Tempfile.new('unicorn.write')
+    @tmp.sync = true
+    File.unlink(@sock.path)
+    File.unlink(@tmp.path)
+    @server_opts = {
+      :listeners => [ "127.0.0.1:#@port", @sock.path ],
+      :after_fork => lambda { |server,worker|
+        trap(:HUP) { @tmp.syswrite('.') }
+      },
+    }
+    @server = nil
+  end
+
+  def teardown
+    reset_sig_handlers
+  end
+
+  def test_worker_dies_on_dead_master
+    pid = fork {
+      app = lambda { |env| [ 200, {'x-pid' => "#$$" }, [] ] }
+      opts = @server_opts.merge(:timeout => 3)
+      redirect_test_io { HttpServer.new(app, opts).start.join }
+    }
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    buf = sock.readpartial(4096)
+    assert_nil sock.close
+    buf =~ /\bx-pid: (\d+)\b/ or raise Exception
+    child = $1.to_i
+    wait_master_ready("test_stderr.#{pid}.log")
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    Process.kill(:KILL, pid)
+    Process.waitpid(pid)
+    File.unlink("test_stderr.#{pid}.log", "test_stdout.#{pid}.log")
+    t0 = Time.now
+    assert child
+    assert t0
+    assert_raises(Errno::ESRCH) { loop { Process.kill(0, child); sleep 0.2 } }
+    assert((Time.now - t0) < 60)
+  end
+
+  def test_sleepy_kill
+    rd, wr = IO.pipe
+    pid = fork {
+      rd.close
+      app = lambda { |env| wr.syswrite('.'); sleep; [ 200, {}, [] ] }
+      redirect_test_io { HttpServer.new(app, @server_opts).start.join }
+    }
+    wr.close
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    buf = rd.readpartial(1)
+    wait_master_ready("test_stderr.#{pid}.log")
+    Process.kill(:INT, pid)
+    Process.waitpid(pid)
+    assert_equal '.', buf
+    buf = nil
+    assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
+                  Errno::EBADF) do
+      buf = sock.sysread(4096)
+    end
+    assert_nil buf
+  end
+
+  def test_timeout_slow_response
+    pid = fork {
+      app = lambda { |env| sleep }
+      opts = @server_opts.merge(:timeout => 3)
+      redirect_test_io { HttpServer.new(app, opts).start.join }
+    }
+    t0 = Time.now
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+
+    buf = nil
+    assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
+                  Errno::EBADF) do
+      buf = sock.sysread(4096)
+    end
+    diff = Time.now - t0
+    assert_nil buf
+    assert diff > 1.0, "diff was #{diff.inspect}"
+    assert diff < 60.0
+  ensure
+    Process.kill(:TERM, pid) rescue nil
+  end
+
+  def test_response_write
+    app = lambda { |env|
+      [ 200, { 'content-type' => 'text/plain', 'x-pid' => Process.pid.to_s },
+        Dd.new(@bs, @count) ]
+    }
+    redirect_test_io { @server = HttpServer.new(app, @server_opts).start }
+    wait_workers_ready("test_stderr.#{$$}.log", 1)
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    buf = ''
+    header_len = pid = nil
+    buf = sock.sysread(16384, buf)
+    pid = buf[/\r\nx-pid: (\d+)\r\n/, 1].to_i
+    header_len = buf[/\A(.+?\r\n\r\n)/m, 1].size
+    assert pid > 0, "pid not positive: #{pid.inspect}"
+    read = buf.size
+    size_before = @tmp.stat.size
+    assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
+                  Errno::EBADF) do
+      loop do
+        3.times { Process.kill(:HUP, pid) }
+        sock.sysread(16384, buf)
+        read += buf.size
+        3.times { Process.kill(:HUP, pid) }
+      end
+    end
+
+    redirect_test_io { @server.stop(true) }
+    # can't check for == since pending signals get merged
+    assert size_before < @tmp.stat.size
+    got = read - header_len
+    expect = @bs * @count
+    assert_equal(expect, got, "expect=#{expect} got=#{got}")
+    assert_nil sock.close
+  end
+
+  def test_request_read
+    app = lambda { |env|
+      while env['rack.input'].read(4096)
+      end
+      [ 200, {'content-type'=>'text/plain', 'x-pid'=>Process.pid.to_s}, [] ]
+    }
+    redirect_test_io { @server = HttpServer.new(app, @server_opts).start }
+
+    wait_workers_ready("test_stderr.#{$$}.log", 1)
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    pid = sock.sysread(4096)[/\r\nx-pid: (\d+)\r\n/, 1].to_i
+    assert_nil sock.close
+
+    assert pid > 0, "pid not positive: #{pid.inspect}"
+    sock = tcp_socket('127.0.0.1', @port)
+    sock.syswrite("PUT / HTTP/1.0\r\n")
+    sock.syswrite("Content-Length: #{@bs * @count}\r\n\r\n")
+    1000.times { Process.kill(:HUP, pid) }
+    size_before = @tmp.stat.size
+    killer = fork { loop { Process.kill(:HUP, pid); sleep(0.01) } }
+    buf = ' ' * @bs
+    @count.times { sock.syswrite(buf) }
+    Process.kill(:KILL, killer)
+    Process.waitpid2(killer)
+    redirect_test_io { @server.stop(true) }
+    # can't check for == since pending signals get merged
+    assert size_before < @tmp.stat.size
+    assert_equal pid, sock.sysread(4096)[/\r\nx-pid: (\d+)\r\n/, 1].to_i
+    assert_nil sock.close
+  end
+end

data/test/unit/test_socket_helper.rb

@@ -0,0 +1,160 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+require './test/test_helper'
+require 'tempfile'
+
+class TestSocketHelper < Test::Unit::TestCase
+  include Unicorn::SocketHelper
+  attr_reader :logger
+  GET_SLASH = "GET / HTTP/1.0\r\n\r\n".freeze
+
+  def setup
+    @log_tmp = Tempfile.new 'logger'
+    @logger = Logger.new(@log_tmp.path)
+    @test_addr = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+    @test6_addr = ENV['UNICORN_TEST6_ADDR'] || '::1'
+    GC.disable
+  end
+
+  def teardown
+    GC.enable
+  end
+
+  def test_bind_listen_tcp
+    port = unused_port @test_addr
+    @tcp_listener_name = "#@test_addr:#{port}"
+    @tcp_listener = bind_listen(@tcp_listener_name)
+    assert Socket === @tcp_listener
+    assert @tcp_listener.local_address.ip?
+    assert_equal @tcp_listener_name, sock_name(@tcp_listener)
+  end
+
+  def test_bind_listen_options
+    port = unused_port @test_addr
+    tcp_listener_name = "#@test_addr:#{port}"
+    tmp = Tempfile.new 'unix.sock'
+    unix_listener_name = tmp.path
+    File.unlink(tmp.path)
+    [ { :backlog => 5 }, { :sndbuf => 4096 }, { :rcvbuf => 4096 },
+      { :backlog => 16, :rcvbuf => 4096, :sndbuf => 4096 }
+    ].each do |opts|
+      tcp_listener = bind_listen(tcp_listener_name, opts)
+      assert tcp_listener.local_address.ip?
+      tcp_listener.close
+      unix_listener = bind_listen(unix_listener_name, opts)
+      assert unix_listener.local_address.unix?
+      unix_listener.close
+    end
+  end
+
+  def test_bind_listen_unix
+    old_umask = File.umask(0777)
+    tmp = Tempfile.new 'unix.sock'
+    @unix_listener_path = tmp.path
+    File.unlink(@unix_listener_path)
+    @unix_listener = bind_listen(@unix_listener_path)
+    assert Socket === @unix_listener
+    assert @unix_listener.local_address.unix?
+    assert_equal @unix_listener_path, sock_name(@unix_listener)
+    assert File.readable?(@unix_listener_path), "not readable"
+    assert File.writable?(@unix_listener_path), "not writable"
+    assert_equal 0777, File.umask
+    assert_equal @unix_listener, bind_listen(@unix_listener)
+  ensure
+    File.umask(old_umask)
+  end
+
+  def test_bind_listen_unix_umask
+    old_umask = File.umask(0777)
+    tmp = Tempfile.new 'unix.sock'
+    @unix_listener_path = tmp.path
+    File.unlink(@unix_listener_path)
+    @unix_listener = bind_listen(@unix_listener_path, :umask => 077)
+    assert_equal @unix_listener_path, sock_name(@unix_listener)
+    assert_equal 0140700, File.stat(@unix_listener_path).mode
+    assert_equal 0777, File.umask
+  ensure
+    File.umask(old_umask)
+  end
+
+  def test_bind_listen_unix_rebind
+    test_bind_listen_unix
+    new_listener = nil
+    assert_raises(Errno::EADDRINUSE) do
+      new_listener = bind_listen(@unix_listener_path)
+    end
+
+    File.unlink(@unix_listener_path)
+    new_listener = bind_listen(@unix_listener_path)
+
+    assert new_listener.fileno != @unix_listener.fileno
+    assert_equal sock_name(new_listener), sock_name(@unix_listener)
+    assert_equal @unix_listener_path, sock_name(new_listener)
+    pid = fork do
+      begin
+        client, _ = new_listener.accept
+        client.syswrite('abcde')
+        exit 0
+      rescue => e
+        warn "#{e.message} (#{e.class})"
+        exit 1
+      end
+    end
+    s = unix_socket(@unix_listener_path)
+    IO.select([s])
+    assert_equal 'abcde', s.sysread(5)
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_tcp_defer_accept_default
+    return unless defined?(TCP_DEFER_ACCEPT)
+    port = unused_port @test_addr
+    name = "#@test_addr:#{port}"
+    sock = bind_listen(name)
+    cur = sock.getsockopt(Socket::SOL_TCP, TCP_DEFER_ACCEPT).unpack('i')[0]
+    assert cur >= 1
+  end
+
+  def test_tcp_defer_accept_disable
+    return unless defined?(TCP_DEFER_ACCEPT)
+    port = unused_port @test_addr
+    name = "#@test_addr:#{port}"
+    sock = bind_listen(name, :tcp_defer_accept => false)
+    cur = sock.getsockopt(Socket::SOL_TCP, TCP_DEFER_ACCEPT).unpack('i')[0]
+    assert_equal 0, cur
+  end
+
+  def test_tcp_defer_accept_nr
+    return unless defined?(TCP_DEFER_ACCEPT)
+    port = unused_port @test_addr
+    name = "#@test_addr:#{port}"
+    sock = bind_listen(name, :tcp_defer_accept => 60)
+    cur = sock.getsockopt(Socket::SOL_TCP, TCP_DEFER_ACCEPT).unpack('i')[0]
+    assert cur > 1
+  end
+
+  def test_ipv6only
+    port = begin
+      unused_port "#@test6_addr"
+    rescue Errno::EINVAL
+      return
+    end
+    sock = bind_listen "[#@test6_addr]:#{port}", :ipv6only => true
+    cur = sock.getsockopt(:IPPROTO_IPV6, :IPV6_V6ONLY).unpack('i')[0]
+    assert_equal 1, cur
+  rescue Errno::EAFNOSUPPORT
+  end
+
+  def test_reuseport
+    return unless defined?(Socket::SO_REUSEPORT)
+    port = unused_port @test_addr
+    name = "#@test_addr:#{port}"
+    sock = bind_listen(name, :reuseport => true)
+    cur = sock.getsockopt(:SOL_SOCKET, :SO_REUSEPORT).int
+    assert_operator cur, :>, 0
+  rescue Errno::ENOPROTOOPT
+    # kernel does not support SO_REUSEPORT (older Linux)
+  end
+end