yahns 0.0.1 → 0.0.2

data/lib/yahns/wbuf_str.rb

@@ -0,0 +1,24 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> et. al.
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative 'wbuf_common'
+
+class Yahns::WbufStr # :nodoc:
+  include Yahns::WbufCommon
+
+  def initialize(str, next_state)
+    @str = str
+    @next = next_state # :check_client_connection, :http_100_response
+  end
+
+  def wbuf_flush(client)
+    case rv = client.kgio_trywrite(@str)
+    when String
+      @str = rv
+    when :wait_writable, :wait_readable
+      return rv
+    when nil
+      return @next
+    end while true
+  end
+end

data/lib/yahns/worker.rb

@@ -23,36 +23,15 @@ class Yahns::Worker # :nodoc:
   # This causes the worker to gracefully exit if the master
   # dies unexpectedly.
   def yahns_step
-    @to_io.kgio_tryread(11) == nil and Process.kill(:QUIT, $$)
-    :wait_readable
+    if @to_io.kgio_tryread(11) == nil
+      Process.kill(:QUIT, $$)
+      @to_io.close
+    end
+    :ignore
   end
 
   # worker objects may be compared to just plain Integers
   def ==(other_nr) # :nodoc:
     @nr == other_nr
   end
-
-  # Changes the worker process to the specified +user+ and +group+
-  # This is only intended to be called from within the worker
-  # process from the +after_fork+ hook.  This should be called in
-  # the +after_fork+ hook after any privileged functions need to be
-  # run (e.g. to set per-worker CPU affinity, niceness, etc)
-  #
-  # Any and all errors raised within this method will be propagated
-  # directly back to the caller (usually the +after_fork+ hook.
-  # These errors commonly include ArgumentError for specifying an
-  # invalid user/group and Errno::EPERM for insufficient privileges
-  def user(user, group = nil)
-    # we do not protect the caller, checking Process.euid == 0 is
-    # insufficient because modern systems have fine-grained
-    # capabilities.  Let the caller handle any and all errors.
-    uid = Etc.getpwnam(user).uid
-    gid = Etc.getgrnam(group).gid if group
-    Yahns::Log.chown_all(uid, gid)
-    if gid && Process.egid != gid
-      Process.initgroups(user, gid)
-      Process::GID.change_privilege(gid)
-    end
-    Process.euid != uid and Process::UID.change_privilege(uid)
-  end
 end

data/test/helper.rb

@@ -3,6 +3,11 @@
 $stdout.sync = $stderr.sync = Thread.abort_on_exception = true
 $-w = true if RUBY_VERSION.to_f >= 2.0
 require 'thread'
+require 'fileutils'
+
+def rubyv
+  puts RUBY_DESCRIPTION
+end
 
 # Global Test Lock, to protect:
 #   Process.wait*, Dir.chdir, ENV, trap, require, etc...
@@ -11,13 +16,14 @@ GTL = Mutex.new
 # fork-aware coverage data gatherer, see also test/covshow.rb
 if ENV["COVERAGE"]
   require "coverage"
-  COVMATCH = %r{/lib/yahns\b.*rb\z}
+  COVMATCH = %r{(/lib/yahns\b|extras/).*rb\z}
+  COVDUMPFILE = File.expand_path("coverage.dump")
 
   def __covmerge
     res = Coverage.result
 
-    # do not create the file, Makefile does htis before any tests run
-    File.open("coverage.dump", IO::RDWR) do |covtmp|
+    # do not create the file, Makefile does this before any tests run
+    File.open(COVDUMPFILE, IO::RDWR) do |covtmp|
       covtmp.binmode
       covtmp.sync = true
 
@@ -69,20 +75,20 @@ at_exit do
   # skipping @@after_run stuff in minitest since we don't need it
   case $!
   when nil, SystemExit
-    mtobj.run(ARGV) if $$ == TSTART_PID
+    exit(mtobj.run(ARGV)) if $$ == TSTART_PID
   end
 end
 
 require "tempfile"
 require 'tmpdir'
 class Dir
-  require 'fileutils'
   def Dir.mktmpdir
     begin
       d = "#{Dir.tmpdir}/#$$.#{rand}"
       Dir.mkdir(d)
     rescue Errno::EEXIST
     end while true
+    return d unless block_given?
     begin
       yield d
     ensure
@@ -109,6 +115,10 @@ class IO
   end
 end if ! IO.method_defined?(:nread) && RUBY_PLATFORM =~ /linux/
 
+def cloexec_pipe
+  IO.pipe.each { |io| io.close_on_exec = true }
+end
+
 require 'yahns'
 
 # needed for parallel (MT) tests)

data/test/server_helper.rb

@@ -29,10 +29,16 @@ module ServerHelper
 
   def quit_wait(pid)
     pid or return
+    err = $!
     Process.kill(:QUIT, pid)
     _, status = Timeout.timeout(10) { Process.waitpid2(pid) }
     assert status.success?, status.inspect
-  rescue Timeout::Error
+  rescue Timeout::Error => tout
+    err ||= tout
+    begin
+      warn "#{err.message} (#{err.class})"
+      err.backtrace.each { |l| warn l }
+    end
     if RUBY_PLATFORM =~ /linux/
       system("lsof -p #{pid}")
       warn "#{pid} failed to die, waiting for user to inspect"
@@ -45,6 +51,7 @@ module ServerHelper
   def get_tcp_client(host, port, tries = 500)
     begin
       c = TCPSocket.new(host, port)
+      c.close_on_exec = true
       return c
     rescue Errno::ECONNREFUSED
       raise if tries < 0
@@ -63,4 +70,33 @@ module ServerHelper
     @err = tmpfile(%w(srv .err))
     @ru = nil
   end
+
+  def mkserver(cfg)
+    fork do
+      ENV["YAHNS_FD"] = @srv.fileno.to_s
+      yield if block_given?
+      Yahns::Server.new(cfg).start.join
+    end
+  end
+
+  def wait_for_full(c)
+    prev = 0
+    prev_time = Time.now
+    begin
+      nr = c.nread
+      break if nr > 0 && nr == prev && (Time.now - prev_time) > 0.5
+      if nr != prev
+        prev = nr
+        prev_time = Time.now
+      end
+      Thread.pass
+    end while sleep(0.1)
+  end
+end
+
+module TrywriteBlocked
+  def kgio_trywrite(*args)
+    return :wait_writable if $_tw_block_on.include?($_tw_blocked += 1)
+    super
+  end
 end

data/test/test_bin.rb

@@ -2,7 +2,7 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative 'server_helper'
 class TestBin < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias teardown server_helper_teardown
 
@@ -40,20 +40,32 @@ class TestBin < Testcase
     cfg.puts "  listen ENV['YAHNS_TEST_LISTEN']"
     cfg.puts "end"
     @cmd.concat(%W(-D -c #{cfg.path}))
-    addr = IO.pipe
+    addr = cloexec_pipe
     pid = fork do
+      opts = { close_others: true }
+      addr[0].close
       if inherit
-        @cmd << { @srv.fileno => @srv }
+        opts[@srv.fileno] = @srv
         ENV["YAHNS_FD"] = @srv.fileno.to_s
       else
+        # we must create the socket inside the child and tell the parent
+        # about it to avoid sharing
         @srv = TCPServer.new(ENV["TEST_HOST"] || "127.0.0.1", 0)
-        @srv.close_on_exec = true # needed for 1.9.3
       end
+      @cmd << opts
       host, port = @srv.addr[3], @srv.addr[1]
       listen = ENV["YAHNS_TEST_LISTEN"] = "#{host}:#{port}"
       addr[1].write(listen)
       addr[1].close
-      addr[0].close
+
+      # close/FD_CLOEXEC may be insufficient since the socket could be
+      # released asynchronously, leading to occasional test failures.
+      # Even with a synchronous FD_CLOEXEC, there's a chance of a race
+      # because the server does not bind right away.
+      unless inherit
+        @srv.shutdown
+        @srv.close
+      end
       exec(*@cmd)
     end
     addr[1].close
@@ -177,9 +189,6 @@ class TestBin < Testcase
     else
       poke_until_dead newpid
     end
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     File.unlink(exe) if exe
     cfg.close! if cfg

data/test/test_buffer_tmpdir.rb

@@ -0,0 +1,103 @@
+# 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 'sleepy_penguin'
+
+class TestBufferTmpdir < Testcase
+  ENV["N"].to_i > 1 and parallelize_me!
+  include ServerHelper
+  attr_reader :ino, :tmpdir
+
+  def setup
+    @ino = SleepyPenguin::Inotify.new(:CLOEXEC)
+    @tmpdir = Dir.mktmpdir
+    server_helper_setup
+  end
+
+  def teardown
+    server_helper_teardown
+    @ino.close
+    FileUtils.rm_rf @tmpdir
+  end
+
+  class GiantBody
+    # just spew until the client gives up
+    def each
+      nr = 16384
+      buf = "#{nr.to_s(16)}\r\n#{("!" * nr)}\r\n"
+      loop do
+        yield buf
+      end
+    end
+  end
+
+  def test_output_buffer_tmpdir
+    opts = { tmpdir: @tmpdir }
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        ru = lambda { |e|
+          h = {
+            "Transfer-Encoding" => "chunked",
+            "Content-Type" => "text/plain"
+          }
+          [ 200, h, GiantBody.new ]
+        }
+        app(:rack, ru) do
+          listen "#{host}:#{port}"
+          output_buffering true, opts
+        end
+        stderr_path err.path
+      end
+    end
+    @ino.add_watch @tmpdir, [:CREATE, :DELETE]
+    c = get_tcp_client(host, port)
+    c.write "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    Timeout.timeout(30) do
+      event = @ino.take
+      assert_equal [:CREATE], event.events
+      name = event.name
+      event = @ino.take
+      assert_equal [:DELETE], event.events
+      assert_equal name, event.name
+      refute File.exist?("#@tmpdir/#{name}")
+    end
+  ensure
+    c.close if c
+    quit_wait(pid)
+  end
+
+  def test_input_buffer_lazy; input_buffer(:lazy); end
+  def test_input_buffer_true; input_buffer(true); end
+
+  def input_buffer(btype)
+    opts = { tmpdir: @tmpdir }
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      cfg.instance_eval do
+        require 'rack/lobster'
+        app(:rack, Rack::Lobster.new) do
+          listen "#{host}:#{port}"
+          input_buffering btype, opts
+        end
+        stderr_path err.path
+      end
+    end
+    @ino.add_watch tmpdir, [:CREATE, :DELETE]
+    c = get_tcp_client(host, port)
+    nr = 16384 # must be > client_body_buffer_size
+    c.write "POST / HTTP/1.0\r\nContent-Length: #{nr}\r\n\r\n"
+    Timeout.timeout(30) do
+      event = ino.take
+      assert_equal [:CREATE], event.events
+      name = event.name
+      event = ino.take
+      assert_equal [:DELETE], event.events
+      assert_equal name, event.name
+      refute File.exist?("#{tmpdir}/#{name}")
+    end
+  ensure
+    c.close if c
+    quit_wait(pid)
+  end
+end if SleepyPenguin.const_defined?(:Inotify)

data/test/test_client_expire.rb

@@ -3,7 +3,7 @@
 require_relative 'server_helper'
 
 class TestClientExpire < Testcase
-  parallelize_me!
+  ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
@@ -22,11 +22,7 @@ class TestClientExpire < 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)
     Net::HTTP.start(host, port) { |h|
       res = h.get("/")
       assert_empty res.body
@@ -51,16 +47,13 @@ class TestClientExpire < 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
-    f = TCPSocket.new(host, port)
-    s = TCPSocket.new(host, port)
+    pid = mkserver(cfg)
+    f = get_tcp_client(host, port)
+    s = get_tcp_client(host, port)
     req = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
     s.write(req)
-    str = Timeout.timeout(20) { s.readpartial(666) }
+    str = ""
+    Timeout.timeout(20) { str << s.readpartial(666) until str =~ /\r\n\r\n/ }
     assert_match(%r{keep-alive}, str)
     sleep 2
     abe = tmpfile(%w(abe .err))
@@ -75,57 +68,100 @@ class TestClientExpire < Testcase
       end
       io.close
     end
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     quit_wait(pid)
   end
 
+  # test EMFILE handling
   def test_client_expire_desperate
-    skip "disabled since FD counts vary heavily in an MT process"
     err = @err
     cfg = Yahns::Config.new
     host, port = @srv.addr[3], @srv.addr[1]
     cfg.instance_eval do
       GTL.synchronize do
         h = { "Content-Length" => "0" }
-        app(:rack, lambda { |e| [ 200, h, [] ]}) do
+        queue { worker_threads 1 }
+        ru = lambda { |e|
+          sleep(0.01) unless e["PATH_INFO"] == "/_"
+          [ 200, h, [] ]
+        }
+        app(:rack, ru) do
           listen "#{host}:#{port}", sndbuf: 2048, rcvbuf: 2048
-          client_timeout 1
+          client_timeout 1.0
+          # FIXME: wbuf creation does not recover from EMFILE/ENFILE
+          output_buffering false
+          check_client_connection true
         end
         client_expire_threshold 1.0
       end
-      logger(Logger.new(err.path))
+      stderr_path err.path
     end
-    srv = Yahns::Server.new(cfg)
-    pid = fork do
-      Process.setrlimit :NOFILE, 512, 1024
-      ENV["YAHNS_FD"] = @srv.fileno.to_s
-      srv.start.join
+    pid = mkserver(cfg) do
+      keep = { $stderr => true, $stdout => true, $stdin => true, @srv => true }
+      ObjectSpace.each_object(IO) do |obj|
+        next if keep[obj]
+        begin
+          obj.close unless obj.closed?
+        rescue IOError # could be uninitialized
+        end
+      end
     end
-    f = TCPSocket.new(host, port)
-    s = TCPSocket.new(host, port)
+    f = get_tcp_client(host, port)
+    f.write "G"
+    s = get_tcp_client(host, port)
     req = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
     s.write(req)
-    str = Timeout.timeout(20) { s.readpartial(666) }
+    str = ""
+    Timeout.timeout(20) { str << s.readpartial(666) until str =~ /\r\n\r\n/ }
     assert_match(%r{keep-alive}, str)
-    sleep 3
-    system "ab -c 1000 -n 10000 -k http://#{host}:#{port}/ 2>&1"
+    sleep 1
 
+    # ignore errors, just beat the crap out of the process
+    nr = Process.getrlimit(:NOFILE)[0] # 1024 is common
+    assert_operator nr, :>, 666, "increase RLIM_NOFILE (ulimit -n)"
+    nr -= 50
+    opts = { out: "/dev/null", err: "/dev/null", close_others: true }
+    begin
+      pids = 2.times.map do
+        fork do
+          exec(*%W(ab -c #{nr} -n 9999999 -v1 -k http://#{host}:#{port}/), opts)
+        end
+      end
+
+      re1 = %r{consider raising open file limits}
+      re2 = %r{dropping (\d+) of \d+ clients for timeout=\d+}
+      Timeout.timeout(30) do
+        n = 0
+        begin
+          buf = File.read(err.path)
+          if buf =~ re1 && buf =~ re2
+            n += $1.to_i
+            break if n >= 2
+          end
+        end while sleep(0.01)
+      end
+    ensure
+      # don't care for ab errors, they're likely
+      pids.each do |_pid|
+        Process.kill(:KILL, _pid)
+        Process.waitpid2(_pid)
+      end
+    end
     [ f, s ].each do |io|
       assert_raises(Errno::EPIPE,Errno::ECONNRESET) do
         req.each_byte { |b| io.write(b.chr) }
       end
       io.close
     end
+
+    # make sure the server still works
+    res = Net::HTTP.start(host, port) { |h| h.get("/_") }
+    assert_equal 200, res.code.to_i
+
     errs = File.readlines(err.path).grep(/ERROR/)
     File.truncate(err.path, 0) # avoid error on teardown
-    re = %r{consider raising open file limits} # - accept, consider raising open file limits}
+    re = %r{consider raising open file limits}
     assert_equal errs.grep(re), errs
-  rescue => e
-    Yahns::Log.exception(Logger.new($stderr), "test", e)
-    raise
   ensure
     quit_wait(pid)
   end