yahns 0.0.1 → 0.0.2

data/test/test_client_max_body_size.rb

@@ -3,7 +3,7 @@
 require_relative 'server_helper'
 
 class TestClientMaxBodySize < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
@@ -27,14 +27,6 @@ class TestClientMaxBodySize < Testcase
     "Content-Length: #{bytes}\r\n\r\n#{'*' * body_bytes}"
   end
 
-  def mkserver(cfg)
-    fork do
-      srv = Yahns::Server.new(cfg)
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
-    end
-  end
-
   def test_0_lazy; cmbs_test_0(:lazy); end
   def test_0_true; cmbs_test_0(true); end
   def test_0_false; cmbs_test_0(false); end
@@ -138,24 +130,24 @@ class TestClientMaxBodySize < Testcase
 
   def default_identity_checks(host, port, defmax = DEFMBS)
     if defmax >= 666
-      c = TCPSocket.new(host, port)
+      c = get_tcp_client(host, port)
       c.write(identity_req(666))
       assert_equal "666", c.read.split(/\r\n\r\n/)[1]
       c.close
     end
 
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
     c.write(identity_req(0))
     assert_equal "0", c.read.split(/\r\n\r\n/)[1]
     c.close
 
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
     c.write(identity_req(defmax))
     assert_equal "#{defmax}", c.read.split(/\r\n\r\n/)[1]
     c.close
 
     toobig = defmax + 1
-    c = TCPSocket.new(host, port)
+    c = get_tcp_client(host, port)
     c.write(identity_req(toobig, false))
     assert_match(%r{\AHTTP/1\.[01] 413 }, Timeout.timeout(10) { c.read })
     c.close

data/test/test_config.rb

@@ -4,7 +4,7 @@ require_relative 'helper'
 require 'rack/lobster'
 
 class TestConfig < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
 
   def test_initialize
     cfg = Yahns::Config.new

data/test/test_expect_100.rb

@@ -0,0 +1,176 @@
+# 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'
+
+class TestExpect100 < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  alias setup server_helper_setup
+  alias teardown server_helper_teardown
+
+  APP = lambda do |env|
+    h = [ %w(Content-Length 0), %w(Content-Type text/plain) ]
+    if env["HTTP_EXPECT"] =~ /100-continue/
+      code = env["HTTP_X_FORCE_RCODE"] || 100
+      [ code, h, [] ]
+    else
+      env["rack.input"].read
+      [ 201, h, [] ]
+    end
+  end
+
+  def test_buffer_noccc; _test_expect_100(true, false); end
+  def test_nobuffer_noccc; _test_expect_100(false, false); end
+  def test_lazybuffer_noccc; _test_expect_100(:lazy, false); end
+  def test_buffer_ccc; _test_expect_100(true, true); end
+  def test_nobuffer_ccc; _test_expect_100(false, true); end
+  def test_lazybuffer_ccc; _test_expect_100(:lazy, true); end
+
+  def _test_expect_100(btype, ccc)
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      stderr_path err.path
+      GTL.synchronize {
+        app(:rack, APP) {
+          listen "#{host}:#{port}"
+          input_buffering btype
+          check_client_connection ccc
+        }
+      }
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    r = "PUT / HTTP/1.0\r\nExpect: 100-continue\r\n\r\n"
+    c.write(r)
+    assert c.wait(10), "timed out"
+    buf = c.read
+    assert_match(%r{\AHTTP/1\.1 100 Continue\r\n\r\nHTTP/1\.1 201}, buf)
+
+    rc = system("curl -sSf -T- http://#{host}:#{port}/", in: "/dev/null")
+    assert $?.success?, $?.inspect
+    assert rc
+  ensure
+    quit_wait(pid)
+  end
+
+  def _test_reject(btype, ccc)
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      stderr_path err.path
+      GTL.synchronize {
+        app(:rack, APP) {
+          listen "#{host}:#{port}"
+          input_buffering btype
+          check_client_connection ccc
+        }
+      }
+    end
+    pid = mkserver(cfg)
+    c = get_tcp_client(host, port)
+    r = "PUT / HTTP/1.0\r\nExpect: 100-continue\r\nX-Force-RCODE: 666\r\n\r\n"
+    c.write(r)
+    assert c.wait(10), "timed out"
+    buf = c.read
+    assert_match(%r{\AHTTP/1\.1 666\r\n}, buf)
+
+    url = "http://#{host}:#{port}/"
+    rc = system("curl -sf -T- -HX-Force-Rcode:666 #{url}", in: "/dev/null")
+    refute $?.success?, $?.inspect
+    refute rc
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_reject_lazy_noccc; _test_reject(:lazy, false); end
+  def test_reject_true_noccc; _test_reject(false, false); end
+  def test_reject_lazy_ccc; _test_reject(:lazy, true); end
+  def test_reject_true_ccc; _test_reject(false, true); end
+
+  def test_swait_t_t; _swait(true, true, [1]); end
+  def test_swait_f_f; _swait(false, false, [1]); end
+  def test_swait_t_f; _swait(true, false, [1]); end
+  def test_swait_f_t; _swait(false, true, [1]); end
+  def test_swait_l_t; _swait(:lazy, true, [1]); end
+  def test_swait_l_f; _swait(:lazy, false, [1]); end
+
+  def test_swait2_t_t; _swait(true, true, [1,2]); end
+  def test_swait2_f_f; _swait(false, false, [1,2]); end
+  def test_swait2_t_f; _swait(true, false, [1,2]); end
+  def test_swait2_f_t; _swait(false, true, [1,2]); end
+  def test_swait2_l_t; _swait(:lazy, true, [1,2]); end
+  def test_swait2_l_f; _swait(:lazy, false, [1,2]); end
+
+  def test_swait3_t_t; _swait(true, true, [1,3]); end
+  def test_swait3_f_f; _swait(false, false, [1,3]); end
+  def test_swait3_t_f; _swait(true, false, [1,3]); end
+  def test_swait3_f_t; _swait(false, true, [1,3]); end
+  def test_swait3_l_t; _swait(:lazy, true, [1,3]); end
+  def test_swait3_l_f; _swait(:lazy, false, [1,3]); end
+
+  def test_swait_t_t_ccc; _swait(true, true, [1], true); end
+  def test_swait_f_f_ccc; _swait(false, false, [1], true); end
+  def test_swait_t_f_ccc; _swait(true, false, [1], true); end
+  def test_swait_f_t_ccc; _swait(false, true, [1], true); end
+  def test_swait_l_t_ccc; _swait(:lazy, true, [1], true); end
+  def test_swait_l_f_ccc; _swait(:lazy, false, [1], true); end
+
+  def test_swait2_t_t_ccc; _swait(true, true, [1,2], true); end
+  def test_swait2_f_f_ccc; _swait(false, false, [1,2], true); end
+  def test_swait2_t_f_ccc; _swait(true, false, [1,2], true); end
+  def test_swait2_f_t_ccc; _swait(false, true, [1,2], true); end
+  def test_swait2_l_t_ccc; _swait(:lazy, true, [1,2], true); end
+  def test_swait2_l_f_ccc; _swait(:lazy, false, [1,2], true); end
+
+  def test_swait3_t_t_ccc; _swait(true, true, [1,3], true); end
+  def test_swait3_f_f_ccc; _swait(false, false, [1,3], true); end
+  def test_swait3_t_f_ccc; _swait(true, false, [1,3], true); end
+  def test_swait3_f_t_ccc; _swait(false, true, [1,3], true); end
+  def test_swait3_l_t_ccc; _swait(:lazy, true, [1,3], true); end
+  def test_swait3_l_f_ccc; _swait(:lazy, false, [1,3], true); end
+
+  def test_swait3_t_t_ccc_body; _swait(true, true, [1,3], true, "HI"); end
+  def test_swait3_f_f_ccc_body; _swait(false, false, [1,3], true, "HI"); end
+  def test_swait3_t_f_ccc_body; _swait(true, false, [1,3], true, "HI"); end
+  def test_swait3_f_t_ccc_body; _swait(false, true, [1,3], true, "HI"); end
+  def test_swait3_l_t_ccc_body; _swait(:lazy, true, [1,3], true, "HI"); end
+  def test_swait3_l_f_ccc_body; _swait(:lazy, false, [1,3], true, "HI"); end
+
+  def _swait(ibtype, obtype, block_on, ccc = false, body = "")
+    err = @err
+    cfg = Yahns::Config.new
+    host, port = @srv.addr[3], @srv.addr[1]
+    cfg.instance_eval do
+      stderr_path err.path
+      GTL.synchronize {
+        app(:rack, APP) {
+         listen "#{host}:#{port}"
+         output_buffering obtype
+         input_buffering ibtype
+         check_client_connection ccc
+        }
+      }
+    end
+    pid = mkserver(cfg) do
+      $_tw_blocked = 0
+      $_tw_block_on = block_on
+      Yahns::HttpClient.__send__(:include, TrywriteBlocked)
+    end
+    c = get_tcp_client(host, port)
+    if body.size > 0
+      r = "PUT / HTTP/1.0\r\nExpect: 100-continue\r\n"
+      r << "Content-Length: #{body.size}\r\n\r\n#{body}"
+    else
+      r = "PUT / HTTP/1.0\r\nExpect: 100-continue\r\n\r\n"
+    end
+    c.write(r)
+    assert c.wait(10), "timed out"
+    buf = c.read
+    assert_match(%r{\AHTTP/1\.1 100 Continue\r\n\r\nHTTP/1\.1 201}, buf)
+  ensure
+    quit_wait(pid)
+  end
+end

data/test/test_extras_autoindex.rb

@@ -0,0 +1,53 @@
+# 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 'zlib'
+require 'time'
+
+class TestExtrasAutoindex < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+
+  def setup
+    @tmpdir = Dir.mktmpdir
+    server_helper_setup
+  end
+
+  def teardown
+    server_helper_teardown
+    FileUtils.rm_rf @tmpdir
+  end
+
+  def test_autoindex
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    tmpdir = @tmpdir
+    pid = mkserver(cfg) do
+      $LOAD_PATH.unshift "#{Dir.pwd}/extras"
+      require 'try_gzip_static'
+      require 'autoindex'
+      cfg.instance_eval do
+        app(:rack, Autoindex.new(TryGzipStatic.new(tmpdir))) do
+          listen "#{host}:#{port}"
+        end
+        stderr_path err.path
+      end
+    end
+
+    Net::HTTP.start(host, port) do |http|
+      res = http.request(Net::HTTP::Get.new("/"))
+      assert_equal 200, res.code.to_i
+      File.open("#@tmpdir/foo", "w").close
+      res = http.request(Net::HTTP::Get.new("/"))
+      assert_equal 200, res.code.to_i
+      assert_match %r{foo}, res.body
+      Dir.mkdir "#@tmpdir/bar"
+
+      res = http.request(Net::HTTP::Get.new("/"))
+      assert_equal 200, res.code.to_i
+      assert_match %r{foo}, res.body
+      assert_match %r{bar/}, res.body
+    end
+  ensure
+    quit_wait pid
+  end
+end

data/test/test_extras_exec_cgi.rb

@@ -0,0 +1,81 @@
+# 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'
+
+class TestExtrasExecCGI < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  alias setup server_helper_setup
+  alias teardown server_helper_teardown
+
+  def test_exec_cgi
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    runme = "#{Dir.pwd}/test/test_extras_exec_cgi.sh"
+    assert File.executable?(runme), "run test in project root"
+    pid = mkserver(cfg) do
+      require './extras/exec_cgi'
+      cfg.instance_eval do
+        app(:rack, ExecCgi.new(runme)) do
+          listen "#{host}:#{port}"
+        end
+        stderr_path err.path
+      end
+    end
+
+    Timeout.timeout(30) do # we can chunk
+      c = get_tcp_client(host, port)
+      c.write "GET / HTTP/1.1\r\nConnection: close\r\n" \
+              "Host: example.com\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/, 2)
+      assert_match %r{^Transfer-Encoding: chunked\b}, head
+      assert_equal "5\r\nHIHI\n\r\n0\r\n\r\n", body
+      c.close
+      cerr = tmpfile(%w(curl .err))
+      assert_equal "HIHI\n", `curl -sSfv 2>#{cerr.path} http://#{host}:#{port}/`
+      assert_match %r{\bTransfer-Encoding: chunked\b}, cerr.read
+      cerr.close!
+    end
+
+    Timeout.timeout(30) do # do not chunk on clients who can't handle chunking
+      c = get_tcp_client(host, port)
+      c.write "GET / HTTP/1.0\r\nHost: example.com\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/)
+      assert_equal "HIHI\n", body
+      refute_match %r{^Transfer-Encoding: chunked\b}, head
+      c.close
+    end
+
+    Timeout.timeout(30) do # sure env is sane
+      c = get_tcp_client(host, port)
+      c.write "GET /env\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/)
+      assert_nil body
+      assert_match %r{^REQUEST_METHOD=GET$}, head
+      assert_match %r{^PATH_INFO=/env$}, head
+      assert_match %r{^QUERY_STRING=$}, head
+      c.close
+    end
+
+    Timeout.timeout(30) do # known length should not chunk
+      c = get_tcp_client(host, port)
+      c.write "GET /known-length HTTP/1.1\r\nConnection: close\r\n" \
+              "Host: example.com\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/, 2)
+      refute_match %r{^Transfer-Encoding: chunked\b}, head
+      assert_match %r{^Content-Length: 5\b}, head
+      assert_equal "HIHI\n", body
+      c.close
+    end
+
+    Timeout.timeout(30) do # 404
+      c = get_tcp_client(host, port)
+      c.write "GET /not-found HTTP/1.0\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/)
+      assert_match %r{\AHTTP/1\.1 404 Not Found}, head
+      assert_nil body
+      c.close
+    end
+  ensure
+    quit_wait(pid)
+  end
+end

data/test/test_extras_exec_cgi.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# test CGI program, this remains portable POSIX shell (not bash)
+set -e
+
+stdhead () {
+	echo Content-Type: text/plain
+	echo Status: 200 OK
+	echo
+}
+
+case $PATH_INFO in
+/)
+	stdhead
+	echo HIHI
+	;;
+/env)
+	stdhead
+	env
+	;;
+/known-length)
+	echo Content-Type: text/plain
+	echo Status: 200 OK
+	echo Content-Length: 5
+	echo
+	echo HIHI
+	;;
+*)
+	echo Content-Type: text/plain
+	echo Status: 404 Not Found
+	echo
+	;;
+esac

data/test/test_extras_try_gzip_static.rb

@@ -0,0 +1,177 @@
+# 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 'zlib'
+require 'time'
+
+class TestExtrasTryGzipStatic < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  GPL_TEXT = IO.binread("COPYING").freeze
+
+  def setup
+    @tmpdir = Dir.mktmpdir
+    server_helper_setup
+  end
+
+  def teardown
+    server_helper_teardown
+    FileUtils.rm_rf @tmpdir
+  end
+
+  def test_gzip_static
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    tmpdir = @tmpdir
+    pid = mkserver(cfg) do
+      require './extras/try_gzip_static'
+      cfg.instance_eval do
+        app(:rack, TryGzipStatic.new(tmpdir)) do
+          listen "#{host}:#{port}"
+        end
+        stderr_path err.path
+      end
+    end
+
+    begin # setup
+      gpl = "#{tmpdir}/COPYING"
+      gplgz = "#{tmpdir}/COPYING.gz"
+      FileUtils.cp("COPYING", gpl)
+      _, status = Process.waitpid2(fork do
+        File.open(gplgz, "w") do |fp|
+          Zlib::GzipWriter.wrap(fp.dup) { |io| io.write(GPL_TEXT) }
+        end
+        exit!(0)
+      end)
+      assert status.success?, status.inspect
+      st = File.stat(gpl)
+      gz_st = File.stat(gplgz)
+      assert_equal GPL_TEXT, `zcat #{gplgz}`, "Eric screwed up using zlib"
+      File.utime(st.atime, st.mtime, gplgz)
+    end
+
+    check = lambda do |req, &blk|
+      c = get_tcp_client(host, port)
+      begin
+        c.write "#{req}\r\n\r\n"
+        head, body = c.read.split(/\r\n\r\n/)
+        blk.call(head)
+        body
+      ensure
+        c.close
+      end
+    end
+
+    Timeout.timeout(30) do # basic tests
+      %w(GET HEAD).each do |m|
+        body = check.call("#{m} /COPYING HTTP/1.0") do |head|
+          refute_match %r{^Content-Encoding: gzip\b}, head
+          assert_match %r{^Content-Type: text/plain\b}, head
+          assert_match %r{^Content-Length: #{st.size}\b}, head
+        end
+        case m
+        when "GET" then assert_equal GPL_TEXT, body
+        when "HEAD" then assert_nil body
+        end
+
+        req = "#{m} /COPYING HTTP/1.0\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          assert_match %r{^Content-Encoding: gzip\b}, head
+          assert_match %r{^Content-Type: text/plain\b}, head
+          assert_match %r{^Content-Length: #{gz_st.size}\b}, head
+        end
+        case m
+        when "GET"
+          assert_equal GPL_TEXT, Zlib::GzipReader.new(StringIO.new(body)).read
+        when "HEAD" then assert_nil body
+        end
+      end
+    end
+
+    Timeout.timeout(30) do # range tests
+      %w(HEAD GET).each do |m|
+        req = "#{m} /COPYING HTTP/1.0\r\n" \
+              "Range: bytes=5-46\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          assert_match %r{\AHTTP/1\.1 206 Partial Content\r\n}, head
+          refute_match %r{^Content-Encoding: gzip\b}, head
+          assert_match %r{^Content-Type: text/plain\b}, head
+          assert_match %r{^Content-Length: 42\b}, head
+          assert_match %r{^Content-Range: bytes 5-46/#{st.size}\r\n}, head
+        end
+        case m
+        when "GET" then assert_equal GPL_TEXT[5..46], body
+        when "HEAD" then assert_nil body
+        end
+
+        req = "#{m} /COPYING HTTP/1.0\r\n" \
+              "Range: bytes=66666666-\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          assert_match %r{^Content-Range: bytes \*/#{st.size}\r\n}, head
+          assert_match %r{\AHTTP/1\.1 416 }, head
+        end
+        assert_nil body
+      end
+    end
+
+    Timeout.timeout(30) do # gzip counterpart is nonexistent
+      File.link(gpl, "#{gpl}.hardlink")
+      %w(GET HEAD).each do |m|
+        req = "#{m} /COPYING.hardlink HTTP/1.0\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          refute_match %r{^Content-Encoding: gzip\b}, head
+          assert_match %r{^Content-Type: text/plain\b}, head
+          assert_match %r{^Content-Length: #{st.size}\b}, head
+        end
+        case m
+        when "GET" then assert_equal GPL_TEXT, body
+        when "HEAD" then assert_nil body
+        end
+      end
+    end
+
+    Timeout.timeout(30) do # If-Modified-Since
+      %w(GET HEAD).each do |m|
+        req = "#{m} /COPYING HTTP/1.0\r\n" \
+              "If-Modified-Since: #{st.mtime.httpdate}"
+        body = check.call(req) do |head|
+          assert_match %r{\AHTTP/1\.1 304 Not Modified}, head
+        end
+        assert_nil body
+      end
+    end
+
+    # skew the times of the gzip file, should now fail to use gzipped
+    Timeout.timeout(30) do
+      File.utime(Time.at(0), Time.at(0), gplgz)
+
+      %w(GET HEAD).each do |m|
+        req = "#{m} /COPYING HTTP/1.0\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          refute_match %r{^Content-Encoding: gzip\b}, head
+          assert_match %r{^Content-Type: text/plain\b}, head
+          assert_match %r{^Content-Length: #{st.size}\b}, head
+        end
+        case m
+        when "GET" then assert_equal GPL_TEXT, body
+        when "HEAD" then assert_nil body
+        end
+      end
+    end
+
+    Timeout.timeout(30) do # 404
+      %w(GET HEAD).each do |m|
+        req = "#{m} /cp-ing HTTP/1.0\r\nAccept-Encoding: gzip"
+        body = check.call(req) do |head|
+          assert_match %r{HTTP/1\.1 404 }, head
+        end
+        assert_nil body
+      end
+      body = check.call("FOO /COPYING HTTP/1.0") do |head|
+        assert_match %r{HTTP/1\.1 405 }, head
+      end
+      assert_nil body
+    end
+  ensure
+    quit_wait(pid)
+  end
+end