jubilee 1.1.0-java

data/test/jubilee/test_response.rb

@@ -0,0 +1,272 @@
+require 'test_helper'
+require 'timeout'
+require 'socket'
+class TestResponse < MiniTest::Unit::TestCase
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @close_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Close\r\n\r\n"
+    @http10_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @keep_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Keep-Alive\r\n\r\n"
+
+    @valid_post = "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello"
+    @valid_no_body = "GET / HTTP/1.1\r\nHost: test.com\r\nX-Status: 204\r\nContent-Type: text/plain\r\n\r\n"
+
+    @headers = { "X-Header" => "Works" }
+    @body = ["Hello"]
+    @inputs = []
+
+    @simple = lambda do |env|
+      @inputs << env['rack.input']
+      status = Integer(env['HTTP_X_STATUS'] || 200)
+      [status, @headers, @body]
+    end
+
+    @host = "127.0.0.1"
+    @port = 8080
+
+    @server = Jubilee::Server.new @simple
+    @server.start
+    sleep 0.1
+    @client = TCPSocket.new @host, @port
+  end
+
+  def teardown
+    @client.close
+    sleep 0.1 # in case server shutdown before request is submitted
+    @server.stop
+  end
+
+  def lines(count, s=@client)
+    str = ""
+    timeout(5) do
+      count.times { str << s.gets }
+    end
+    str
+  end
+
+  def valid_response(size)
+    Regexp.new("HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{size}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n", true)
+  end
+
+  def test_one_with_content_length
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_two_back_to_back
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_post_then_get
+    @client << @valid_post
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match valid_response(sz), lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+=begin
+  def test_no_body_then_get
+    @client << @valid_no_body
+    assert_match %r{HTTP/1.1 204 No Content\r\nX-Header: Works(.*?\r\n)*?Connection: keep-alive\r\n\r\n}, lines(6)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+=end
+
+  def test_chunked
+    @body << "Chunked"
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\nServer(.*\r\n)*?Transfer-Encoding: chunked\r\nDate(.*?)\r\n\r\n5\r\nHello\r\n7\r\nChunked\r\n0\r\n\r\n}, lines(13)
+  end
+
+  def test_no_chunked_in_http10
+    @body << "Chunked"
+
+    @client << @http10_request
+
+    assert_match %r{HTTP/1.0 200 OK\r\nX-Header: Works(.*?\r\n)*?Connection: close\r\nDate(.*?)\r\n\r\n}, lines(6)
+    assert_equal "HelloChunked", @client.read
+  end
+
+  def test_hex
+    str = "This is longer and will be in hex"
+    @body << str
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Transfer-Encoding: chunked\r\nDate(.*?)\r\n\r\n5\r\nHello\r\n#{str.size.to_s(16)}\r\n#{str}\r\n0\r\n\r\n}, lines(13)
+
+  end
+
+  def test_client11_close
+    @client << @close_request
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: close\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_client10_close
+    @client << @http10_request
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.0 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: close\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_one_with_keep_alive_header
+    @client << @keep_request
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.0 200 OK\r\nX-Header: Works\r\nServer(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+=begin
+  def test_persistent_timeout
+    @server.persistent_timeout = 2
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    sleep 3
+
+    assert_raises EOFError do
+      @client.read_nonblock(1)
+    end
+  end
+=end
+
+  def test_app_sets_content_length
+    @body = ["hello", " world"]
+    @headers['Content-Length'] = "11"
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: 11\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "hello world", @client.read(11)
+  end
+
+  def test_allow_app_to_chunk_itself
+    skip "body should not be chunked before sent to jubilee"
+    @headers = {'Transfer-Encoding' => "chunked" }
+
+    @body = ["5\r\nhello\r\n0\r\n\r\n"]
+
+    @client << @valid_request
+
+    assert_match %r{HTTP/1.1 200 OK\r\n(.*?\r\n)*?Transfer-Encoding: chunked\r\nDate(.*?)\r\n\r\n5\r\nhello\r\n0\r\n}, lines(10)
+  end
+
+
+  def test_two_requests_in_one_chunk
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_second_request_not_in_first_req_body
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7)
+    assert_equal "Hello", @client.read(5)
+
+    #assert_kind_of Jubilee::NullIO, @inputs[0]
+    #assert_kind_of Jubilee::NullIO, @inputs[1]
+  end
+
+  def test_keepalive_doesnt_starve_clients
+    sz = @body[0].size.to_s
+
+    @client << @valid_request
+
+    c2 = TCPSocket.new @host, @port
+    c2 << @valid_request
+
+    out = IO.select([c2], nil, nil, 1)
+
+    assert out, "select returned nil"
+    assert_equal c2, out.first.first
+
+    assert_match %r{HTTP/1.1 200 OK\r\nX-Header: Works\r\n(.*?\r\n)*?Content-Length: #{sz}\r\nConnection: keep-alive\r\nDate(.*?)\r\n\r\n}, lines(7, c2)
+    assert_equal "Hello", c2.read(5)
+  end
+
+=begin
+  def test_client_shutdown_writes
+    bs = 15609315 * rand
+    sock = TCPSocket.new('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)
+    sock.syswrite("\r\n0\r\nX-")
+    "Foo: bar\r\n\r\n".each_byte do |x|
+      sock.syswrite x.chr
+      sleep 0.05
+    end
+    # we wrote the entire request before shutting down, server should
+    # continue to process our request and never hit EOFError on our sock
+    sock.shutdown(Socket::SHUT_WR)
+    buf = sock.read
+    assert_equal 'Hello', buf.split(/\r\n\r\n/).last
+    next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
+    assert_equal 'Hello', next_client
+    lines = File.readlines("test_stderr.#$$.log")
+    assert lines.grep(/^Unicorn::ClientShutdown: /).empty?
+    assert_nil sock.close
+  end
+=end
+end

data/test/jubilee/test_server.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+require 'net/http'
+
+class TestJubileeServer < MiniTest::Unit::TestCase
+  def setup
+    @host, @port = "localhost", 8080
+    @server = nil
+  end
+
+  def teardown
+    @server.stop if @server
+  end
+
+  def test_server_lambda
+    app = lambda {|env| [200, {"Content-Type" => "text/plain"}, ["http"]] }
+    @server = Jubilee::Server.new(app)
+    @server.start
+    sleep 0.1
+
+    http, body = Net::HTTP.new(@host, @port), nil
+    http.start do
+      req = Net::HTTP::Get.new "/", {}
+      http.request(req) do |resp|
+        body = resp.body
+      end
+    end
+    assert_equal "http", body
+  end
+
+  def test_server_embeded
+    config = Jubilee::Configuration.new(rackup: File.join(File.dirname(__FILE__), "../config/app.rb"))
+    @server = Jubilee::Server.new(config.app)
+    @server.start
+    sleep 0.1
+    http, body = Net::HTTP.new(@host, @port), nil
+    http.start do
+      req = Net::HTTP::Get.new "/", {}
+      http.request(req) do |resp|
+        body = resp.body
+      end
+    end
+    assert_equal "embeded app", body
+  end
+
+  def test_large_post_body
+    skip
+  end
+
+  def test_url_scheme_for_https
+    app = lambda { |env| [200, {}, [env['rack.url_scheme']]] }
+    @server = Jubilee::Server.new(app, {port:@port, ssl:true, 
+                                 keystore_path: File.join(File.dirname(__FILE__), "../../examples/jubilee/server-keystore.jks"),
+    keystore_password: "wibble"})
+    @server.start
+    sleep 0.1
+    http = Net::HTTP.new @host, @port
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    body = nil
+    http.start do
+      req = Net::HTTP::Get.new "/", {}
+
+      http.request(req) do |rep|
+        body = rep.body
+      end
+    end
+
+    assert_equal "https", body
+  end
+
+end

data/test/jubilee/test_upload.rb

@@ -0,0 +1,301 @@
+# -*- encoding: binary -*-
+
+require 'test_helper'
+require 'digest/md5'
+
+class TestUpload < MiniTest::Unit::TestCase
+
+  def setup
+    @addr = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+    @port = 8080
+    @hdr = {'Content-Type' => 'text/plain', 'Content-Length' => '0'}
+    @bs = 4096
+    @count = 256
+    @server = nil
+    @sha1 = Digest::SHA1.new
+
+    # we want random binary data to test 1.9 encoding-aware IO craziness
+    @random = File.open('/dev/urandom','rb')
+    @sha1_app = lambda do |env|
+      sha1 = Digest::SHA1.new
+      input = env['rack.input']
+      resp = {}
+
+      i = 0
+      while buf = input.read(@bs)
+        sha1.update(buf)
+        i += buf.size
+      end
+      resp[:sha1] = sha1.hexdigest
+
+      # rewind and read again
+      input.rewind
+      sha1.reset
+
+      while buf = input.read(@bs)
+        sha1.update(buf)
+      end
+
+      if resp[:sha1] == sha1.hexdigest
+        resp[:sysread_read_byte_match] = true
+      end
+
+      if expect_size = env['HTTP_X_EXPECT_SIZE']
+        if expect_size.to_i == i
+          resp[:expect_size_match] = true
+        end
+      end
+      resp[:size] = i
+      resp[:expect_size] = expect_size
+
+      [ 200, @hdr.merge({'X-Resp' => resp.inspect}), [] ]
+    end
+  end
+
+  def teardown
+    @server.stop
+    @random.close
+  end
+
+  def test_put
+    start_server(@sha1_app)
+    sock = TCPSocket.new(@addr, @port)
+    sock.syswrite("PUT / HTTP/1.0\r\nContent-Length: #{length}\r\n\r\n")
+    @count.times do |i|
+      buf = @random.sysread(@bs)
+      @sha1.update(buf)
+      sock.syswrite(buf)
+    end
+    read = sock.read.split(/\r\n/)
+    assert_equal "HTTP/1.0 200 OK", read[0]
+    resp = eval(read.grep(/^X-Resp: /).first.sub!(/X-Resp: /, ''))
+    assert_equal @sha1.hexdigest, resp[:sha1]
+  end
+
+  def test_put_content_md5
+    start_server(@sha1_app)
+    skip "Vert.x doesn't hendle trailing headers"
+    md5 = Digest::MD5.new
+    sock = TCPSocket.new(@addr, @port)
+    sock.syswrite("PUT / HTTP/1.0\r\nTransfer-Encoding: chunked\r\n" \
+                  "Trailer: Content-MD5\r\n\r\n")
+    @count.times do |i|
+      buf = @random.sysread(@bs)
+      @sha1.update(buf)
+      md5.update(buf)
+      sock.syswrite("#{'%x' % buf.size}\r\n")
+      sock.syswrite(buf << "\r\n")
+    end
+    sock.syswrite("0\r\n")
+
+    content_md5 = [ md5.digest! ].pack('m').strip.freeze
+    sock.syswrite("Content-MD5: #{content_md5}\r\n\r\n")
+    read = sock.read.split(/\r\n/)
+    assert_equal "HTTP/1.0 200 OK", read[0]
+    resp = eval(read.grep(/^X-Resp: /).first.sub!(/X-Resp: /, ''))
+    assert_equal @sha1.hexdigest, resp[:sha1]
+    assert_equal content_md5, resp[:content_md5]
+  end
+
+  def test_put_trickle_small
+    start_server(@sha1_app)
+    @count, @bs = 2, 128
+    assert_equal 256, length
+    sock = TCPSocket.new(@addr, @port)
+    hdr = "PUT / HTTP/1.0\r\nContent-Length: #{length}\r\n\r\n"
+    @count.times do
+      buf = @random.sysread(@bs)
+      @sha1.update(buf)
+      hdr << buf
+      sock.syswrite(hdr)
+      hdr = ''
+      sleep 0.6
+    end
+    read = sock.read.split(/\r\n/)
+    assert_equal "HTTP/1.0 200 OK", read[0]
+    resp = eval(read.grep(/^X-Resp: /).first.sub!(/X-Resp: /, ''))
+    assert_equal @sha1.hexdigest, resp[:sha1]
+  end
+
+  def test_put_keepalive_truncates_small_overwrite
+    start_server(@sha1_app)
+    sock = TCPSocket.new(@addr, @port)
+    to_upload = length + 1
+    sock.syswrite("PUT / HTTP/1.0\r\nContent-Length: #{to_upload}\r\n\r\n")
+    @count.times do
+      buf = @random.sysread(@bs)
+      @sha1.update(buf)
+      sock.syswrite(buf)
+    end
+    sock.syswrite('12345') # write 4 bytes more than we expected
+    @sha1.update('1')
+
+    buf = sock.readpartial(4096)
+    while buf !~ /\r\n\r\n/
+      buf << sock.readpartial(4096)
+    end
+    read = buf.split(/\r\n/)
+    assert_equal "HTTP/1.0 200 OK", read[0]
+    resp = eval(read.grep(/^X-Resp: /).first.sub!(/X-Resp: /, ''))
+    #assert_equal to_upload, resp[:size]
+    assert_equal @sha1.hexdigest, resp[:sha1]
+  end
+
+  def test_put_excessive_overwrite_closed
+    tmp = Tempfile.new('overwrite_check')
+    tmp.sync = true
+    start_server(lambda { |env|
+      nr = 0
+      while buf = env['rack.input'].read(65536)
+        nr += buf.size
+      end
+      tmp.write(nr.to_s)
+      [ 200, @hdr, [] ]
+    })
+    sock = TCPSocket.new(@addr, @port)
+    buf = ' ' * @bs
+    sock.syswrite("PUT / HTTP/1.0\r\nContent-Length: #{length}\r\n\r\n")
+
+    @count.times { sock.syswrite(buf) }
+    assert_raises(Errno::ECONNRESET, Errno::EPIPE) do
+      16384.times { sock.syswrite(buf) }
+    end
+    sock.gets
+    tmp.rewind
+    assert_equal length, tmp.read.to_i
+  end
+
+  def test_uncomfortable_with_onenine_encodings
+    # POSIX doesn't require all of these to be present on a system
+    which('curl') or return
+    which('sha1sum') or return
+    which('dd') or return
+
+    start_server(@sha1_app)
+
+    tmp = Tempfile.new('dd_dest')
+    assert(system("dd", "if=#{@random.path}", "of=#{tmp.path}",
+                        "bs=#{@bs}", "count=#{@count}"),
+           "dd #@random to #{tmp}")
+    sha1_re = %r!\b([a-f0-9]{40})\b!
+    sha1_out = `sha1sum #{tmp.path}`
+
+    assert $?.success?, 'sha1sum ran OK'
+
+    assert_match(sha1_re, sha1_out)
+    sha1 = sha1_re.match(sha1_out)[1]
+    resp = `curl -isSfN -T#{tmp.path} http://#@addr:#@port/`
+
+    assert $?.success?, 'curl ran OK'
+    assert_match(%r!\b#{sha1}\b!, resp)
+    assert_match(/sysread_read_byte_match/, resp)
+
+    # small StringIO path
+    assert(system("dd", "if=#{@random.path}", "of=#{tmp.path}",
+                        "bs=1024", "count=1"),
+           "dd #@random to #{tmp}")
+    sha1_re = %r!\b([a-f0-9]{40})\b!
+    sha1_out = `sha1sum #{tmp.path}`
+    assert $?.success?, 'sha1sum ran OK'
+
+    assert_match(sha1_re, sha1_out)
+    sha1 = sha1_re.match(sha1_out)[1]
+    resp = `curl -isSfN -T#{tmp.path} http://#@addr:#@port/`
+    assert $?.success?, 'curl ran OK'
+    assert_match(%r!\b#{sha1}\b!, resp)
+    assert_match(/sysread_read_byte_match/, resp)
+  end
+
+=begin
+  def test_chunked_upload_via_curl
+    # POSIX doesn't require all of these to be present on a system
+    which('curl') or return
+    which('sha1sum') or return
+    which('dd') or return
+
+    start_server(@sha1_app)
+
+    tmp = Tempfile.new('dd_dest')
+    assert(system("dd", "if=#{@random.path}", "of=#{tmp.path}",
+                        "bs=#{@bs}", "count=#{@count}"),
+           "dd #@random to #{tmp}")
+    sha1_re = %r!\b([a-f0-9]{40})\b!
+    sha1_out = `sha1sum #{tmp.path}`
+    assert $?.success?, 'sha1sum ran OK'
+
+    assert_match(sha1_re, sha1_out)
+    sha1 = sha1_re.match(sha1_out)[1]
+    cmd = "curl -H 'X-Expect-Size: #{tmp.size}' --tcp-nodelay \
+           -isSf --no-buffer -T- " \
+          "http://#@addr:#@port/"
+    resp = Tempfile.new('resp')
+    resp.sync = true
+
+    rd, wr = IO.pipe
+    wr.sync = rd.sync = true
+    pid = fork {
+      STDIN.reopen(rd)
+      rd.close
+      wr.close
+      STDOUT.reopen(resp)
+      exec cmd
+    }
+    rd.close
+
+    tmp.rewind
+    @count.times { |i|
+      wr.write(tmp.read(@bs))
+      sleep(rand / 10) if 0 == i % 8
+    }
+    wr.close
+    pid, status = Process.waitpid2(pid)
+
+    resp.rewind
+    resp = resp.read
+    assert status.success?, 'curl ran OK'
+    assert_match(%r!\b#{sha1}\b!, resp)
+    assert_match(/sysread_read_byte_match/, resp)
+    assert_match(/expect_size_match/, resp)
+  end
+=end
+
+  def test_curl_chunked_small
+    # POSIX doesn't require all of these to be present on a system
+    which('curl') or return
+    which('sha1sum') or return
+    which('dd') or return
+
+    start_server(@sha1_app)
+
+    tmp = Tempfile.new('dd_dest')
+    # small StringIO path
+    assert(system("dd", "if=#{@random.path}", "of=#{tmp.path}",
+                        "bs=1024", "count=1"),
+           "dd #@random to #{tmp}")
+    sha1_re = %r!\b([a-f0-9]{40})\b!
+    sha1_out = `sha1sum #{tmp.path}`
+    assert $?.success?, 'sha1sum ran OK'
+
+    assert_match(sha1_re, sha1_out)
+    sha1 = sha1_re.match(sha1_out)[1]
+    resp = `curl -H 'X-Expect-Size: #{tmp.size}' --tcp-nodelay \
+            -isSf --no-buffer -T- http://#@addr:#@port/ < #{tmp.path}`
+    assert $?.success?, 'curl ran OK'
+    assert_match(%r!\b#{sha1}\b!, resp)
+    assert_match(/sysread_read_byte_match/, resp)
+    assert_match(/expect_size_match/, resp)
+  end
+
+  private
+
+  def length
+    @bs * @count
+  end
+
+  def start_server(app)
+    @server = Jubilee::Server.new app
+    @server.start
+    sleep 0.1
+  end
+
+end