yahns 0.0.1 → 0.0.2

data/test/test_input.rb

@@ -0,0 +1,128 @@
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative 'server_helper'
+require 'digest/md5'
+
+class TestInput < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  alias setup server_helper_setup
+  alias teardown server_helper_teardown
+
+  MD5 = lambda do |e|
+    input = e["rack.input"]
+    buf = ""
+    md5 = Digest::MD5.new
+    while input.read(16384, buf)
+      md5 << buf
+    end
+    body = md5.hexdigest
+    h = { "Content-Length" => body.size.to_s, "Content-Type" => 'text/plain' }
+    [ 200, h, [body] ]
+  end
+
+  def test_input_timeout_lazybuffer
+    stream_input_timeout(:lazy)
+  end
+
+  def test_input_timeout_nobuffer
+    stream_input_timeout(false)
+  end
+
+  def stream_input_timeout(ibtype)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      GTL.synchronize do
+        app(:rack, MD5) do
+          listen "#{host}:#{port}"
+          input_buffering ibtype
+          client_timeout 1
+        end
+      end
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    c.write "PUT / HTTP/1.1\r\nContent-Length: 666\r\n\r\n"
+    assert_equal c, c.wait(6)
+    Timeout.timeout(30) { assert_match %r{HTTP/1\.1 408 }, c.read }
+    c.close
+  ensure
+    quit_wait(pid)
+  end
+
+  def input_server(ru, ibtype)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      GTL.synchronize do
+        app(:rack, ru) { listen "#{host}:#{port}"; input_buffering ibtype }
+      end
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    [ host, port, pid ]
+  end
+
+  def test_read_negative_lazy; _read_neg(:lazy); end
+  def test_read_negative_nobuffer; _read_neg(false); end
+
+  def _read_neg(ibtype)
+    ru = lambda do |env|
+      rv = []
+      input = env["rack.input"]
+      begin
+        input.read(-1)
+      rescue => e
+        rv << e.class.to_s
+      end
+      rv << input.read
+      rv << input.read(1).nil?
+      rv = rv.join(",")
+      h = { "Content-Length" => rv.size.to_s }
+      [ 200, h, [ rv ] ]
+    end
+    host, port, pid = input_server(ru, ibtype)
+    c = get_tcp_client(host, port)
+    c.write "PUT / HTTP/1.0\r\nContent-Length: 5\r\n\r\nhello"
+    assert_equal c, c.wait(30)
+    head, body = c.read.split(/\r\n\r\n/)
+    assert_match %r{ 200 OK}, head
+    exc, full, final = body.split(/,/)
+    assert_equal "hello", full
+    assert_equal "ArgumentError", exc
+    assert_equal true.to_s, final
+    c.close
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_gets_lazy; _gets(:lazy); end
+  def test_gets_nobuffer; _gets(false); end
+
+  def _gets(ibtype)
+    in_join = lambda do |input|
+      rv = []
+      while line = input.gets
+        rv << line
+      end
+      rv.join(",")
+    end
+    ru = lambda do |env|
+      rv = in_join.call(env["rack.input"])
+      h = { "Content-Length" => rv.size.to_s }
+      [ 200, h, [ rv ] ]
+    end
+    host, port, pid = input_server(ru, ibtype)
+    c = get_tcp_client(host, port)
+    buf = "a\nb\n\n"
+    c.write "PUT / HTTP/1.0\r\nContent-Length: 5\r\n\r\n#{buf}"
+    assert_equal c, c.wait(30)
+    head, body = c.read.split(/\r\n\r\n/)
+    assert_match %r{ 200 OK}, head
+    expect = in_join.call(StringIO.new(buf))
+    assert_equal expect, body
+    c.close
+  ensure
+    quit_wait(pid)
+  end
+end

data/test/test_mt_accept.rb

@@ -0,0 +1,48 @@
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative 'server_helper'
+require 'rack/lobster'
+
+class TestMtAccept < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  alias setup server_helper_setup
+  alias teardown server_helper_teardown
+
+  def test_mt_accept
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    opts = { threads: 1 }
+    cfg.instance_eval do
+      GTL.synchronize do
+        app(:rack, Rack::Lobster.new) { listen "#{host}:#{port}", threads: 1 }
+      end
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    Net::HTTP.start(host, port) do |http|
+      assert_equal 200, http.request(Net::HTTP::Get.new("/")).code.to_i
+    end
+    orig_count = Dir["/proc/#{pid}/task/*"].size
+    quit_wait(pid)
+
+    cfg = Yahns::Config.new
+    opts = { threads: 1 }
+    cfg.instance_eval do
+      GTL.synchronize do
+        app(:rack, Rack::Lobster.new) { listen "#{host}:#{port}", threads: 2 }
+      end
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    Net::HTTP.start(host, port) do |http|
+      assert_equal 200, http.request(Net::HTTP::Get.new("/")).code.to_i
+    end
+    Timeout.timeout(30) do
+      begin
+        new_count = Dir["/proc/#{pid}/task/*"].size
+      end until new_count == (orig_count + 1) && sleep(0.01)
+    end
+  ensure
+    quit_wait(pid)
+  end
+end if RUBY_PLATFORM =~ /linux/ && File.directory?("/proc")

data/test/test_output_buffering.rb

@@ -5,7 +5,7 @@ require 'digest/md5'
 require 'rack/file'
 
 class TestOutputBuffering < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
@@ -41,7 +41,7 @@ class TestOutputBuffering < Testcase
     output_buffer(true, :http09)
   end
 
-  def output_buffer(btype, check_type, delay = 4)
+  def output_buffer(btype, check_type)
     err = @err
     cfg = Yahns::Config.new
     host, port = @srv.addr[3], @srv.addr[1]
@@ -58,54 +58,47 @@ class TestOutputBuffering < 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
+    pid = mkserver(cfg)
 
     case check_type
     when :curl
-      # curl is faster for piping gigantic wads of data than Net::HTTP
-      sh_sleep = delay ? "sleep #{delay} && " : ""
-      md5 = `curl -sSf http://#{host}:#{port}/ | (#{sh_sleep} md5sum)`
-      assert $?.success?, $?.inspect
-      (md5 =~ /([a-f0-9]{32})/i) or raise "bad md5: #{md5.inspect}"
-      md5 = $1
-      assert_equal MD5.value, md5
+      # curl is faster for piping gigantic wads of data than Net::HTTP,
+      # and we need to be able to throttle a bit to force output buffering
+      c = IO.popen("curl -N -sSf http://#{host}:#{port}/")
+      wait_for_full(c)
+      dig, nr = md5sum(c)
+      c.close
+      assert_equal MD5.value, dig.hexdigest
     when :http09
       # HTTP/0.9
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write("GET /\r\n\r\n")
-      md5in = IO.pipe
-      md5out = IO.pipe
-      sleep(delay) if delay
-      md5pid = Process.spawn("md5sum", :in => md5in[0], :out => md5out[1])
-      md5in[0].close
-      md5out[1].close
-      assert_equal(NR * RAND.size, IO.copy_stream(c, md5in[1]))
+      wait_for_full(c)
+      dig, nr = md5sum(c)
+      assert_equal(NR * RAND.size, nr)
       c.shutdown
       c.close
-      md5in[1].close
-      _, status = Timeout.timeout(10) { Process.waitpid2(md5pid) }
-      assert status.success?, status.inspect
-      md5 = md5out[0].read
-      (md5 =~ /([a-f0-9]{32})/i) or raise "bad md5: #{md5.inspect}"
-      md5 = $1
-      assert_equal MD5.value, md5
-      md5out[0].close
+      assert_equal MD5.value, dig.hexdigest
     else
       raise "TESTBUG"
     end
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     quit_wait(pid)
   end
 
+  def md5sum(c)
+    dig = Digest::MD5.new
+    buf = ""
+    nr = 0
+    while c.read(8192, buf)
+      dig << buf
+      nr += buf.bytesize
+    end
+    [ dig, nr ]
+  end
+
   class BigHeader
-    A = "A" * 65536
+    A = "A" * 8192
     def initialize(h)
       @h = h
     end
@@ -157,20 +150,14 @@ class TestOutputBuffering < 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
+    pid = mkserver(cfg)
     threads = []
 
     # start with just a big header
     threads << Thread.new do
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write "GET / HTTP/1.0\r\n\r\n"
-      begin
-        sleep 1
-      end while c.nread == 0
+      wait_for_full(c)
       nr = 0
       last = nil
       c.each_line do |line|
@@ -186,11 +173,9 @@ class TestOutputBuffering < Testcase
     end
 
     threads << Thread.new do
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write "GET /COPYING HTTP/1.0\r\n\r\n"
-      begin
-        sleep 1
-      end while c.nread == 0
+      wait_for_full(c)
       nr = 0
       c.each_line do |line|
         case line
@@ -205,11 +190,9 @@ class TestOutputBuffering < Testcase
     end
 
     threads << Thread.new do
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write "GET /COPYING HTTP/1.0\r\nRange: bytes=5-46\r\n\r\n"
-      begin
-        sleep 1
-      end while c.nread == 0
+      wait_for_full(c)
       nr = 0
       c.each_line do |line|
         case line
@@ -236,6 +219,7 @@ class TestOutputBuffering < Testcase
     cfg = Yahns::Config.new
     size = RAND.size * NR
     host, port = @srv.addr[3], @srv.addr[1]
+    re = /timeout on :wait_writable after 0\.1s$/
     cfg.instance_eval do
       ru = lambda do |e|
         if e["PATH_INFO"] == "/bh"
@@ -249,30 +233,34 @@ class TestOutputBuffering < Testcase
         app(:rack, ru) do
           listen "#{host}:#{port}"
           output_buffering false
-          client_timeout 3
+          client_timeout 0.1
           logger(Logger.new(apperr.path))
         end
       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)
+
+    wait_for_timeout_msg = lambda do
+      Timeout.timeout(6) do
+        sleep(0.01) until File.readlines(apperr.path).grep(re).size == 2
+      end
     end
     threads = []
     threads << Thread.new do
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
-      sleep(5) # wait for timeout
+      wait_for_full(c)
+      wait_for_timeout_msg.call
       assert_operator c.nread, :>, 0
       c
     end
 
     threads << Thread.new do
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write("GET /bh HTTP/1.1\r\nHost: example.com\r\n\r\n")
-      sleep(5) # wait for timeout
+      wait_for_full(c)
+      wait_for_timeout_msg.call
       assert_operator c.nread, :>, 0
       c
     end
@@ -280,12 +268,51 @@ class TestOutputBuffering < Testcase
     assert_operator size, :>, threads[0].value.read.size
     assert_operator size, :>, threads[1].value.read.size
     msg = File.readlines(apperr.path)
-    msg = msg.grep(/timeout on :wait_writable after 3s$/)
+    msg = msg.grep(re)
     assert_equal 2, msg.size
     threads.each { |t| t.value.close }
   ensure
     apperr.close! if apperr
     quit_wait(pid)
   end
-end if `which curl 2>/dev/null`.strip =~ /curl/ &&
-       `which md5sum 2>/dev/null`.strip =~ /md5sum/
+
+  def test_hijacked
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      ru = lambda do |e|
+        h = {
+          "Content-Type" => "text/plain",
+          "Content-Length" => "4",
+          "rack.hijack" => proc { |x| x.write("HIHI"); x.close },
+        }
+        body = Object.new
+        def body.each; abort "body#each should not be used"; end
+        [ 200, BigHeader.new(h), body ]
+      end
+      GTL.synchronize do
+        app(:rack, ru) do
+          listen "#{host}:#{port}"
+        end
+      end
+      stderr_path err.path
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    c.write "GET / HTTP/1.0\r\n\r\n"
+    wait_for_full(c)
+    nr = 0
+    last = nil
+    c.each_line do |line|
+      case line
+      when %r{\AX-} then nr += 1
+      else
+        last = line
+      end
+    end
+    assert_equal NR, nr
+    assert_equal "HIHI", last
+    c.close
+  ensure
+    quit_wait(pid)
+  end
+end if `which curl 2>/dev/null`.strip =~ /curl/

data/test/test_rack.rb

@@ -4,7 +4,7 @@ require_relative 'helper'
 require 'rack/lobster'
 require 'yahns/rack'
 class TestRack < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
 
   def test_rack
     tmp = tmpfile(%W(config .ru))

data/test/test_rack_hijack.rb

@@ -3,7 +3,7 @@
 require_relative 'server_helper'
 
 class TestRackHijack < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
@@ -53,11 +53,7 @@ class TestRackHijack < Testcase
       GTL.synchronize { app(:rack, HIJACK_APP) { 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)
     res = Net::HTTP.start(host, port) { |h| h.get("/hijack_req") }
     assert_equal "request.hijacked", res.body
     assert_equal 200, res.code.to_i