unicorn-fork 6.1.1

data/test/unit/test_stream_input.rb

@@ -0,0 +1,211 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+require 'test/unit'
+require 'digest/sha1'
+require 'unicorn'
+
+class TestStreamInput < Test::Unit::TestCase
+  def setup
+    @rs = "\n"
+    $/ == "\n" or abort %q{test broken if \$/ != "\\n"}
+    @env = {}
+    @rd, @wr = UNIXSocket.pair
+    @rd.sync = @wr.sync = true
+    @start_pid = $$
+  end
+
+  def teardown
+    return if $$ != @start_pid
+    @rd.close rescue nil
+    @wr.close rescue nil
+    Process.waitall
+  end
+
+  def test_read_negative
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_raises(ArgumentError) { si.read(-1) }
+    assert_equal 'hello', si.read
+  end
+
+  def test_read_small
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal 'hello', si.read
+    assert_equal '', si.read
+    assert_nil si.read(5)
+    assert_nil si.gets
+  end
+
+  def test_gets_oneliner
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal 'hello', si.gets
+    assert_nil si.gets
+  end
+
+  def test_gets_multiline
+    r = init_request("a\nb\n\n")
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal "a\n", si.gets
+    assert_equal "b\n", si.gets
+    assert_equal "\n", si.gets
+    assert_nil si.gets
+  end
+
+  def test_gets_empty_rs
+    r = init_request("a\nb\n\n")
+    si = Unicorn::StreamInput.new(@rd, r)
+    pid = fork do # to avoid $/ warning (hopefully)
+      $/ = nil
+      @rd.close
+      @wr.write(si.gets)
+      @wr.close
+    end
+    @wr.close
+    assert_equal "a\nb\n\n", @rd.read
+    pid, status = Process.waitpid2(pid)
+    assert_predicate status, :success?
+  end
+
+  def test_read_with_equal_len
+    r = init_request("abcde")
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal "abcde", si.read(5)
+    assert_nil si.read(5)
+  end
+
+  def test_big_body_multi
+    r = init_request('.', Unicorn::Const::MAX_BODY + 1)
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal Unicorn::Const::MAX_BODY, @parser.content_length
+    assert ! @parser.body_eof?
+    nr = Unicorn::Const::MAX_BODY / 4
+    pid = fork {
+      @rd.close
+      nr.times { @wr.write('....') }
+      @wr.close
+    }
+    @wr.close
+    assert_equal '.', si.read(1)
+    nr.times { |x|
+      assert_equal '....', si.read(4), "nr=#{x}"
+    }
+    assert_nil si.read(1)
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_gets_long
+    r = init_request("hello", 5 + (4096 * 4 * 3) + "#{@rs}foo#{@rs}".size)
+    si = Unicorn::StreamInput.new(@rd, r)
+    status = line = nil
+    pid = fork {
+      @rd.close
+      3.times { @wr.write("ffff" * 4096) }
+      @wr.write "#{@rs}foo#{@rs}"
+      @wr.close
+    }
+    @wr.close
+    line = si.gets
+    assert_equal(4096 * 4 * 3 + 5 + $/.size, line.size)
+    assert_equal("hello" << ("ffff" * 4096 * 3) << "#{@rs}", line)
+    line = si.gets
+    assert_equal "foo#{@rs}", line
+    assert_nil si.gets
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_read_with_buffer
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    buf = ''
+    rv = si.read(4, buf)
+    assert_equal 'hell', rv
+    assert_equal 'hell', buf
+    assert_equal rv.object_id, buf.object_id
+    assert_equal 'o', si.read
+    assert_equal nil, si.read(5, buf)
+  end
+
+  def test_read_with_buffer_clobbers
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    buf = 'foo'
+    assert_equal 'hello', si.read(nil, buf)
+    assert_equal 'hello', buf
+    assert_equal '', si.read(nil, buf)
+    assert_equal '', buf
+    buf = 'asdf'
+    assert_nil si.read(5, buf)
+    assert_equal '', buf
+  end
+
+  def test_read_zero
+    r = init_request('hello')
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal '', si.read(0)
+    buf = 'asdf'
+    rv = si.read(0, buf)
+    assert_equal rv.object_id, buf.object_id
+    assert_equal '', buf
+    assert_equal 'hello', si.read
+    assert_nil si.read(5)
+    assert_equal '', si.read(0)
+    buf = 'hello'
+    rv = si.read(0, buf)
+    assert_equal rv.object_id, buf.object_id
+    assert_equal '', rv
+  end
+
+  def test_gets_read_mix
+    r = init_request("hello\nasdfasdf")
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal "hello\n", si.gets
+    assert_equal "asdfasdf", si.read(9)
+    assert_nil si.read(9)
+  end
+
+  def test_gets_read_mix_chunked
+    r = @parser = Unicorn::HttpParser.new
+    body = "6\r\nhello"
+    @buf = "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Transfer-Encoding: chunked\r\n" \
+           "\r\n#{body}"
+    assert_equal @env, @parser.headers(@env, @buf)
+    assert_equal body, @buf
+    si = Unicorn::StreamInput.new(@rd, r)
+    @wr.syswrite "\n\r\n"
+    assert_equal "hello\n", si.gets
+    @wr.syswrite "8\r\nasdfasdf\r\n"
+    assert_equal"asdfasdf", si.read(9) + si.read(9)
+    @wr.syswrite "0\r\n\r\n"
+    assert_nil si.read(9)
+  end
+
+  def test_gets_read_mix_big
+    r = init_request("hello\n#{'.' * 65536}")
+    si = Unicorn::StreamInput.new(@rd, r)
+    assert_equal "hello\n", si.gets
+    assert_equal '.' * 16384, si.read(16384)
+    assert_equal '.' * 16383, si.read(16383)
+    assert_equal '.' * 16384, si.read(16384)
+    assert_equal '.' * 16385, si.read(16385)
+    assert_nil si.gets
+  end
+
+  def init_request(body, size = nil)
+    @parser = Unicorn::HttpParser.new
+    body = body.to_s.freeze
+    @buf = "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Content-Length: #{size || body.size}\r\n" \
+           "\r\n#{body}"
+    assert_equal @env, @parser.headers(@env, @buf)
+    assert_equal body, @buf
+    @parser
+  end
+end

data/test/unit/test_tee_input.rb

@@ -0,0 +1,304 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+require 'test/unit'
+require 'digest/sha1'
+require 'unicorn'
+
+class TeeInput < Unicorn::TeeInput
+  attr_accessor :tmp, :len
+end
+
+class TestTeeInput < Test::Unit::TestCase
+  def setup
+    @rd, @wr = UNIXSocket.pair
+    @rd.sync = @wr.sync = true
+    @start_pid = $$
+    @rs = "\n"
+    $/ == "\n" or abort %q{test broken if \$/ != "\\n"}
+  end
+
+  def teardown
+    return if $$ != @start_pid
+    @rd.close rescue nil
+    @wr.close rescue nil
+    begin
+      Process.wait
+    rescue Errno::ECHILD
+      break
+    end while true
+  end
+
+  def check_tempfiles
+    tmp = @parser.env["rack.tempfiles"]
+    assert_instance_of Array, tmp
+    assert_operator tmp.size, :>=, 1
+    assert_instance_of Unicorn::TmpIO, tmp[0]
+  end
+
+  def test_gets_long
+    r = init_request("hello", 5 + (4096 * 4 * 3) + "#{@rs}foo#{@rs}".size)
+    ti = TeeInput.new(@rd, r)
+    status = line = nil
+    pid = fork {
+      @rd.close
+      3.times { @wr.write("ffff" * 4096) }
+      @wr.write "#{@rs}foo#{@rs}"
+      @wr.close
+    }
+    @wr.close
+    line = ti.gets
+    assert_equal(4096 * 4 * 3 + 5 + $/.size, line.size)
+    assert_equal("hello" << ("ffff" * 4096 * 3) << "#{@rs}", line)
+    line = ti.gets
+    assert_equal "foo#{@rs}", line
+    assert_nil ti.gets
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_gets_short
+    r = init_request("hello", 5 + "#{@rs}foo".size)
+    ti = TeeInput.new(@rd, r)
+    status = line = nil
+    pid = fork {
+      @rd.close
+      @wr.write "#{@rs}foo"
+      @wr.close
+    }
+    @wr.close
+    line = ti.gets
+    assert_equal("hello#{@rs}", line)
+    line = ti.gets
+    assert_equal "foo", line
+    assert_nil ti.gets
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_small_body
+    r = init_request('hello')
+    ti = TeeInput.new(@rd, r)
+    assert_equal 0, @parser.content_length
+    assert @parser.body_eof?
+    assert_equal StringIO, ti.tmp.class
+    assert_equal 0, ti.tmp.pos
+    assert_equal 5, ti.size
+    assert_equal 'hello', ti.read
+    assert_equal '', ti.read
+    assert_nil ti.read(4096)
+    assert_equal 5, ti.size
+  end
+
+  def test_read_with_buffer
+    r = init_request('hello')
+    ti = TeeInput.new(@rd, r)
+    buf = ''
+    rv = ti.read(4, buf)
+    assert_equal 'hell', rv
+    assert_equal 'hell', buf
+    assert_equal rv.object_id, buf.object_id
+    assert_equal 'o', ti.read
+    assert_equal nil, ti.read(5, buf)
+    assert_equal 0, ti.rewind
+    assert_equal 'hello', ti.read(5, buf)
+    assert_equal 'hello', buf
+  end
+
+  def test_big_body
+    r = init_request('.' * Unicorn::Const::MAX_BODY << 'a')
+    ti = TeeInput.new(@rd, r)
+    assert_equal 0, @parser.content_length
+    assert @parser.body_eof?
+    assert_kind_of File, ti.tmp
+    assert_equal 0, ti.tmp.pos
+    assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
+    check_tempfiles
+  end
+
+  def test_read_in_full_if_content_length
+    a, b = 300, 3
+    r = init_request('.' * b, 300)
+    assert_equal 300, @parser.content_length
+    ti = TeeInput.new(@rd, r)
+    pid = fork {
+      @wr.write('.' * 197)
+      sleep 1 # still a *potential* race here that would make the test moot...
+      @wr.write('.' * 100)
+    }
+    assert_equal a, ti.read(a).size
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    @wr.close
+  end
+
+  def test_big_body_multi
+    r = init_request('.', Unicorn::Const::MAX_BODY + 1)
+    ti = TeeInput.new(@rd, r)
+    assert_equal Unicorn::Const::MAX_BODY, @parser.content_length
+    assert ! @parser.body_eof?
+    assert_kind_of File, ti.tmp
+    assert_equal 0, ti.tmp.pos
+    assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
+    nr = Unicorn::Const::MAX_BODY / 4
+    pid = fork {
+      @rd.close
+      nr.times { @wr.write('....') }
+      @wr.close
+    }
+    @wr.close
+    assert_equal '.', ti.read(1)
+    assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
+    nr.times { |x|
+      assert_equal '....', ti.read(4), "nr=#{x}"
+      assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
+    }
+    assert_nil ti.read(1)
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+    check_tempfiles
+  end
+
+  def test_chunked
+    @parser = Unicorn::HttpParser.new
+    @parser.buf << "POST / HTTP/1.1\r\n" \
+                   "Host: localhost\r\n" \
+                   "Transfer-Encoding: chunked\r\n" \
+                   "\r\n"
+    assert @parser.parse
+    assert_equal "", @parser.buf
+
+    pid = fork {
+      @rd.close
+      5.times { @wr.write("5\r\nabcde\r\n") }
+      @wr.write("0\r\n\r\n")
+    }
+    @wr.close
+    ti = TeeInput.new(@rd, @parser)
+    assert_nil @parser.content_length
+    assert_nil ti.len
+    assert ! @parser.body_eof?
+    assert_equal 25, ti.size
+    assert @parser.body_eof?
+    assert_equal 25, ti.len
+    assert_equal 0, ti.tmp.pos
+    ti.rewind
+    assert_equal 0, ti.tmp.pos
+    assert_equal 'abcdeabcdeabcdeabcde', ti.read(20)
+    assert_equal 20, ti.tmp.pos
+    ti.rewind
+    assert_equal 0, ti.tmp.pos
+    assert_kind_of File, ti.tmp
+    status = nil
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+    check_tempfiles
+  end
+
+  def test_chunked_ping_pong
+    @parser = Unicorn::HttpParser.new
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Transfer-Encoding: chunked\r\n" \
+           "\r\n"
+    assert @parser.parse
+    assert_equal "", buf
+    chunks = %w(aa bbb cccc dddd eeee)
+    rd, wr = IO.pipe
+
+    pid = fork {
+      chunks.each do |chunk|
+        rd.read(1) == "." and
+          @wr.write("#{'%x' % [ chunk.size]}\r\n#{chunk}\r\n")
+      end
+      @wr.write("0\r\n\r\n")
+    }
+    ti = TeeInput.new(@rd, @parser)
+    assert_nil @parser.content_length
+    assert_nil ti.len
+    assert ! @parser.body_eof?
+    chunks.each do |chunk|
+      wr.write('.')
+      assert_equal chunk, ti.read(16384)
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_chunked_with_trailer
+    @parser = Unicorn::HttpParser.new
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Trailer: Hello\r\n" \
+           "Transfer-Encoding: chunked\r\n" \
+           "\r\n"
+    assert @parser.parse
+    assert_equal "", buf
+
+    pid = fork {
+      @rd.close
+      5.times { @wr.write("5\r\nabcde\r\n") }
+      @wr.write("0\r\n")
+      @wr.write("Hello: World\r\n\r\n")
+    }
+    @wr.close
+    ti = TeeInput.new(@rd, @parser)
+    assert_nil @parser.content_length
+    assert_nil ti.len
+    assert ! @parser.body_eof?
+    assert_equal 25, ti.size
+    assert_equal "World", @parser.env['HTTP_HELLO']
+    pid, status = Process.waitpid2(pid)
+    assert status.success?
+  end
+
+  def test_chunked_and_size_slow
+    @parser = Unicorn::HttpParser.new
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Trailer: Hello\r\n" \
+           "Transfer-Encoding: chunked\r\n" \
+           "\r\n"
+    assert @parser.parse
+    assert_equal "", buf
+
+    @wr.write("9\r\nabcde")
+    ti = TeeInput.new(@rd, @parser)
+    assert_nil @parser.content_length
+    assert_equal "abcde", ti.read(9)
+    assert ! @parser.body_eof?
+    @wr.write("fghi\r\n0\r\nHello: World\r\n\r\n")
+    assert_equal 9, ti.size
+    assert_equal "fghi", ti.read(9)
+    assert_equal nil, ti.read(9)
+    assert_equal "World", @parser.env['HTTP_HELLO']
+  end
+
+  def test_gets_read_mix
+    r = init_request("hello\nasdfasdf")
+    ti = Unicorn::TeeInput.new(@rd, r)
+    assert_equal "hello\n", ti.gets
+    assert_equal "asdfasdf", ti.read(9)
+    assert_nil ti.read(9)
+  end
+
+private
+
+  def init_request(body, size = nil)
+    @parser = Unicorn::HttpParser.new
+    body = body.to_s.freeze
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
+           "Host: localhost\r\n" \
+           "Content-Length: #{size || body.size}\r\n" \
+           "\r\n#{body}"
+    assert @parser.parse
+    assert_equal body, buf
+    @buf = buf
+    @parser
+  end
+
+end

data/test/unit/test_util.rb

@@ -0,0 +1,132 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+require './test/test_helper'
+require 'tempfile'
+
+class TestUtil < Test::Unit::TestCase
+
+  EXPECT_FLAGS = File::WRONLY | File::APPEND
+  def test_reopen_logs_noop
+    tmp = Tempfile.new('')
+    fp = File.open(tmp.path, 'ab')
+    fp.sync = true
+    ext = fp.external_encoding rescue nil
+    int = fp.internal_encoding rescue nil
+    before = fp.stat.inspect
+    Unicorn::Util.reopen_logs
+    assert_equal before, File.stat(fp.path).inspect
+    assert_equal ext, (fp.external_encoding rescue nil)
+    assert_equal int, (fp.internal_encoding rescue nil)
+    assert_equal(EXPECT_FLAGS, EXPECT_FLAGS & fp.fcntl(Fcntl::F_GETFL))
+    tmp.close!
+    fp.close
+  end
+
+  def test_reopen_logs_renamed
+    tmp = Tempfile.new('')
+    tmp_path = tmp.path.freeze
+    fp = File.open(tmp_path, 'ab')
+    fp.sync = true
+
+    ext = fp.external_encoding rescue nil
+    int = fp.internal_encoding rescue nil
+    before = fp.stat.inspect
+    to = Tempfile.new('')
+    File.rename(tmp_path, to.path)
+    assert ! File.exist?(tmp_path)
+    Unicorn::Util.reopen_logs
+    assert_equal tmp_path, tmp.path
+    assert File.exist?(tmp_path)
+    assert before != File.stat(tmp_path).inspect
+    assert_equal fp.stat.inspect, File.stat(tmp_path).inspect
+    assert_equal ext, (fp.external_encoding rescue nil)
+    assert_equal int, (fp.internal_encoding rescue nil)
+    assert_equal(EXPECT_FLAGS, EXPECT_FLAGS & fp.fcntl(Fcntl::F_GETFL))
+    assert fp.sync
+    tmp.close!
+    to.close!
+    fp.close
+  end
+
+  def test_reopen_logs_renamed_with_encoding
+    tmp = Tempfile.new('')
+    tmp_path = tmp.path.dup.freeze
+    Encoding.list.sample(5).each { |encoding|
+      File.open(tmp_path, "a:#{encoding.to_s}") { |fp|
+        fp.sync = true
+        assert_equal encoding, fp.external_encoding
+        assert_nil fp.internal_encoding
+        File.unlink(tmp_path)
+        assert ! File.exist?(tmp_path)
+        Unicorn::Util.reopen_logs
+        assert_equal tmp_path, fp.path
+        assert File.exist?(tmp_path)
+        assert_equal fp.stat.inspect, File.stat(tmp_path).inspect
+        assert_equal encoding, fp.external_encoding
+        assert_nil fp.internal_encoding
+        assert_equal(EXPECT_FLAGS, EXPECT_FLAGS & fp.fcntl(Fcntl::F_GETFL))
+        assert fp.sync
+      }
+    }
+    tmp.close!
+  end
+
+  def test_reopen_logs_renamed_with_internal_encoding
+    tmp = Tempfile.new('')
+    tmp_path = tmp.path.dup.freeze
+    full = Encoding.list
+    full.sample(2).each { |ext|
+      full.sample(2).each { |int|
+        next if ext == int
+        File.open(tmp_path, "a:#{ext.to_s}:#{int.to_s}") { |fp|
+          fp.sync = true
+          assert_equal ext, fp.external_encoding
+
+          if ext != Encoding::BINARY
+            assert_equal int, fp.internal_encoding
+          end
+
+          File.unlink(tmp_path)
+          assert ! File.exist?(tmp_path)
+          Unicorn::Util.reopen_logs
+          assert_equal tmp_path, fp.path
+          assert File.exist?(tmp_path)
+          assert_equal fp.stat.inspect, File.stat(tmp_path).inspect
+          assert_equal ext, fp.external_encoding
+          if ext != Encoding::BINARY
+            assert_equal int, fp.internal_encoding
+          end
+          assert_equal(EXPECT_FLAGS, EXPECT_FLAGS & fp.fcntl(Fcntl::F_GETFL))
+          assert fp.sync
+        }
+      }
+    }
+    tmp.close!
+  end
+
+  def test_pipe
+    r, w = Unicorn.pipe
+    assert r
+    assert w
+
+    return if RUBY_PLATFORM !~ /linux/
+
+    begin
+      f_getpipe_sz = 1032
+      IO.pipe do |a, b|
+        a_sz = a.fcntl(f_getpipe_sz)
+        b.fcntl(f_getpipe_sz)
+        assert_kind_of Integer, a_sz
+        r_sz = r.fcntl(f_getpipe_sz)
+        assert_equal Raindrops::PAGE_SIZE, r_sz
+        assert_operator a_sz, :>=, r_sz
+      end
+    rescue Errno::EINVAL
+      # Linux <= 2.6.34
+    end
+  ensure
+    w.close
+    r.close
+  end
+end

data/test/unit/test_waiter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'unicorn'
+require 'unicorn/select_waiter'
+class TestSelectWaiter < Test::Unit::TestCase
+
+  def test_select_timeout # n.b. this is level-triggered
+    sw = Unicorn::SelectWaiter.new
+    IO.pipe do |r,w|
+      sw.get_readers(ready = [], [r], 0)
+      assert_equal [], ready
+      w.syswrite '.'
+      sw.get_readers(ready, [r], 1000)
+      assert_equal [r], ready
+      sw.get_readers(ready, [r], 0)
+      assert_equal [r], ready
+    end
+  end
+
+  def test_linux # ugh, also level-triggered, unlikely to change
+    IO.pipe do |r,w|
+      wtr = Unicorn::Waiter.prep_readers([r])
+      wtr.get_readers(ready = [], [r], 0)
+      assert_equal [], ready
+      w.syswrite '.'
+      wtr.get_readers(ready = [], [r], 1000)
+      assert_equal [r], ready
+      wtr.get_readers(ready = [], [r], 1000)
+      assert_equal [r], ready, 'still ready (level-triggered :<)'
+      assert_nil wtr.close
+    end
+  rescue SystemCallError => e
+    warn "#{e.message} (#{e.class})"
+  end if Unicorn.const_defined?(:Waiter)
+end