test/unit/test_server.rb

   1 # -*- encoding: binary -*-
   2
   3 # Copyright (c) 2005 Zed A. Shaw
   4 # You can redistribute it and/or modify it under the same terms as Ruby.
   5 #
   6 # Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html
   7 # for more information.
   8
   9 require 'test/test_helper'
  10
  11 include Unicorn
  12
  13 class TestHandler
  14
  15   def call(env)
  16     while env['rack.input'].read(4096)
  17     end
  18     [200, { 'Content-Type' => 'text/plain' }, ['hello!\n']]
  19     rescue Unicorn::ClientShutdown, Unicorn::HttpParserError => e
  20       $stderr.syswrite("#{e.class}: #{e.message} #{e.backtrace.empty?}\n")
  21       raise e
  22   end
  23 end
  24
  25
  26 class WebServerTest < Test::Unit::TestCase
  27
  28   def setup
  29     @valid_request = "GET / HTTP/1.1\r\nHost: www.zedshaw.com\r\nContent-Type: text/plain\r\n\r\n"
  30     @port = unused_port
  31     @tester = TestHandler.new
  32     redirect_test_io do
  33       @server = HttpServer.new(@tester, :listeners => [ "127.0.0.1:#{@port}" ] )
  34       @server.start
  35     end
  36   end
  37
  38   def teardown
  39     redirect_test_io do
  40       wait_workers_ready("test_stderr.#$$.log", 1)
  41       File.truncate("test_stderr.#$$.log", 0)
  42       @server.stop(false)
  43     end
  44     reset_sig_handlers
  45   end
  46
  47   def test_preload_app_config
  48     teardown
  49     tmp = Tempfile.new('test_preload_app_config')
  50     ObjectSpace.undefine_finalizer(tmp)
  51     app = lambda { ||
  52       tmp.sysseek(0)
  53       tmp.truncate(0)
  54       tmp.syswrite($$)
  55       lambda { |env| [ 200, { 'Content-Type' => 'text/plain' }, [ "#$$\n" ] ] }
  56     }
  57     redirect_test_io do
  58       @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"] )
  59       @server.start
  60     end
  61     results = hit(["http://localhost:#@port/"])
  62     worker_pid = results[0].to_i
  63     assert worker_pid != 0
  64     tmp.sysseek(0)
  65     loader_pid = tmp.sysread(4096).to_i
  66     assert loader_pid != 0
  67     assert_equal worker_pid, loader_pid
  68     teardown
  69
  70     redirect_test_io do
  71       @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"],
  72                                :preload_app => true)
  73       @server.start
  74     end
  75     results = hit(["http://localhost:#@port/"])
  76     worker_pid = results[0].to_i
  77     assert worker_pid != 0
  78     tmp.sysseek(0)
  79     loader_pid = tmp.sysread(4096).to_i
  80     assert_equal $$, loader_pid
  81     assert worker_pid != loader_pid
  82     ensure
  83       tmp.close!
  84   end
  85
  86   def test_broken_app
  87     teardown
  88     app = lambda { |env| raise RuntimeError, "hello" }
  89     # [200, {}, []] }
  90     redirect_test_io do
  91       @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"] )
  92       @server.start
  93     end
  94     sock = nil
  95     assert_nothing_raised do
  96       sock = TCPSocket.new('127.0.0.1', @port)
  97       sock.syswrite("GET / HTTP/1.0\r\n\r\n")
  98     end
  99
 100     assert_match %r{\AHTTP/1.[01] 500\b}, sock.sysread(4096)
 101     assert_nothing_raised { sock.close }
 102   end
 103
 104   def test_simple_server
 105     results = hit(["http://localhost:#{@port}/test"])
 106     assert_equal 'hello!\n', results[0], "Handler didn't really run"
 107   end
 108
 109   def test_client_shutdown_writes
 110     sock = nil
 111     buf = nil
 112     bs = 15609315 * rand
 113     assert_nothing_raised do
 114       sock = TCPSocket.new('127.0.0.1', @port)
 115       sock.syswrite("PUT /hello HTTP/1.1\r\n")
 116       sock.syswrite("Host: example.com\r\n")
 117       sock.syswrite("Transfer-Encoding: chunked\r\n")
 118       sock.syswrite("Trailer: X-Foo\r\n")
 119       sock.syswrite("\r\n")
 120       sock.syswrite("%x\r\n" % [ bs ])
 121       sock.syswrite("F" * bs)
 122       sock.syswrite("\r\n0\r\nX-")
 123       "Foo: bar\r\n\r\n".each_byte do |x|
 124         sock.syswrite x.chr
 125         sleep 0.05
 126       end
 127       # we wrote the entire request before shutting down, server should
 128       # continue to process our request and never hit EOFError on our sock
 129       sock.shutdown(Socket::SHUT_WR)
 130       buf = sock.read
 131     end
 132     assert_equal 'hello!\n', buf.split(/\r\n\r\n/).last
 133     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
 134     assert_equal 'hello!\n', next_client
 135     lines = File.readlines("test_stderr.#$$.log")
 136     assert lines.grep(/^Unicorn::ClientShutdown: /).empty?
 137     assert_nothing_raised { sock.close }
 138   end
 139
 140   def test_client_shutdown_write_truncates
 141     sock = nil
 142     buf = nil
 143     bs = 15609315 * rand
 144     assert_nothing_raised do
 145       sock = TCPSocket.new('127.0.0.1', @port)
 146       sock.syswrite("PUT /hello HTTP/1.1\r\n")
 147       sock.syswrite("Host: example.com\r\n")
 148       sock.syswrite("Transfer-Encoding: chunked\r\n")
 149       sock.syswrite("Trailer: X-Foo\r\n")
 150       sock.syswrite("\r\n")
 151       sock.syswrite("%x\r\n" % [ bs ])
 152       sock.syswrite("F" * (bs / 2.0))
 153
 154       # shutdown prematurely, this will force the server to abort
 155       # processing on us even during app dispatch
 156       sock.shutdown(Socket::SHUT_WR)
 157       IO.select([sock], nil, nil, 60) or raise "Timed out"
 158       buf = sock.read
 159     end
 160     assert_equal "", buf
 161     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
 162     assert_equal 'hello!\n', next_client
 163     lines = File.readlines("test_stderr.#$$.log")
 164     lines = lines.grep(/^Unicorn::ClientShutdown: bytes_read=\d+/)
 165     assert_equal 1, lines.size
 166     assert_match %r{\AUnicorn::ClientShutdown: bytes_read=\d+ true$}, lines[0]
 167     assert_nothing_raised { sock.close }
 168   end
 169
 170   def test_client_malformed_body
 171     sock = nil
 172     bs = 15653984
 173     assert_nothing_raised do
 174       sock = TCPSocket.new('127.0.0.1', @port)
 175       sock.syswrite("PUT /hello HTTP/1.1\r\n")
 176       sock.syswrite("Host: example.com\r\n")
 177       sock.syswrite("Transfer-Encoding: chunked\r\n")
 178       sock.syswrite("Trailer: X-Foo\r\n")
 179       sock.syswrite("\r\n")
 180       sock.syswrite("%x\r\n" % [ bs ])
 181       sock.syswrite("F" * bs)
 182     end
 183     begin
 184       File.open("/dev/urandom", "rb") { |fp| sock.syswrite(fp.sysread(16384)) }
 185     rescue
 186     end
 187     assert_nothing_raised { sock.close }
 188     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
 189     assert_equal 'hello!\n', next_client
 190     lines = File.readlines("test_stderr.#$$.log")
 191     lines = lines.grep(/^Unicorn::HttpParserError: .* true$/)
 192     assert_equal 1, lines.size
 193   end
 194
 195   def do_test(string, chunk, close_after=nil, shutdown_delay=0)
 196     # Do not use instance variables here, because it needs to be thread safe
 197     socket = TCPSocket.new("127.0.0.1", @port);
 198     request = StringIO.new(string)
 199     chunks_out = 0
 200
 201     while data = request.read(chunk)
 202       chunks_out += socket.write(data)
 203       socket.flush
 204       sleep 0.2
 205       if close_after and chunks_out > close_after
 206         socket.close
 207         sleep 1
 208       end
 209     end
 210     sleep(shutdown_delay)
 211     socket.write(" ") # Some platforms only raise the exception on attempted write
 212     socket.flush
 213   end
 214
 215   def test_trickle_attack
 216     do_test(@valid_request, 3)
 217   end
 218
 219   def test_close_client
 220     assert_raises IOError do
 221       do_test(@valid_request, 10, 20)
 222     end
 223   end
 224
 225   def test_bad_client
 226     redirect_test_io do
 227       do_test("GET /test HTTP/BAD", 3)
 228     end
 229   end
 230
 231   def test_logger_set
 232     assert_equal @server.logger, Unicorn::HttpRequest::DEFAULTS["rack.logger"]
 233   end
 234
 235   def test_logger_changed
 236     tmp = Logger.new($stdout)
 237     @server.logger = tmp
 238     assert_equal tmp, Unicorn::HttpRequest::DEFAULTS["rack.logger"]
 239   end
 240
 241   def test_bad_client_400
 242     sock = nil
 243     assert_nothing_raised do
 244       sock = TCPSocket.new('127.0.0.1', @port)
 245       sock.syswrite("GET / HTTP/1.0\r\nHost: foo\rbar\r\n\r\n")
 246     end
 247     assert_match %r{\AHTTP/1.[01] 400\b}, sock.sysread(4096)
 248     assert_nothing_raised { sock.close }
 249   end
 250
 251   def test_http_0_9
 252     sock = nil
 253     assert_nothing_raised do
 254       sock = TCPSocket.new('127.0.0.1', @port)
 255       sock.syswrite("GET /hello\r\n")
 256     end
 257     assert_match 'hello!\n', sock.sysread(4096)
 258     assert_nothing_raised { sock.close }
 259   end
 260
 261   def test_header_is_too_long
 262     redirect_test_io do
 263       long = "GET /test HTTP/1.1\r\n" + ("X-Big: stuff\r\n" * 15000) + "\r\n"
 264       assert_raises Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EINVAL, IOError do
 265         do_test(long, long.length/2, 10)
 266       end
 267     end
 268   end
 269
 270   def test_file_streamed_request
 271     body = "a" * (Unicorn::Const::MAX_BODY * 2)
 272     long = "PUT /test HTTP/1.1\r\nContent-length: #{body.length}\r\n\r\n" + body
 273     do_test(long, Unicorn::Const::CHUNK_SIZE * 2 - 400)
 274   end
 275
 276   def test_file_streamed_request_bad_body
 277     body = "a" * (Unicorn::Const::MAX_BODY * 2)
 278     long = "GET /test HTTP/1.1\r\nContent-ength: #{body.length}\r\n\r\n" + body
 279     assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
 280                   Errno::EBADF) {
 281       do_test(long, Unicorn::Const::CHUNK_SIZE * 2 - 400)
 282     }
 283   end
 284
 285   def test_listener_names
 286     assert_equal [ "127.0.0.1:#@port" ], Unicorn.listener_names
 287   end
 288 end