yahns 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32f85a4c4ed36a082242c5b58bae7f18528543c1
-  data.tar.gz: e741b37a8b0f62d47d9ea08ce36ab69b31536f15
+  metadata.gz: fff238b384ecd740912bd989b3f9f5940f1a8ed1
+  data.tar.gz: 4f0a23620f3de110285e6f0da568dbb8448713ec
 SHA512:
-  metadata.gz: 8eb0d76f793c6bc787ec789214e05f2f03face6e7772cad38ca7da67986e6a579f9b69c927ed39224b75f72e2dafaa3f886a4dc9c17eea24ccd0d3ae59aaf994
-  data.tar.gz: d9b233d340ef2ca35c5f5c085cac97bb6090d3ba2dbf2c89b57edcc1577d6ea5ef8b67f4821f6cbe04e36938b9d49ebd6d8898838f370baeb89da1845297bbe5
+  metadata.gz: 019a14bdaf0613f75c89b1b170f705373698645a115f06f260e008080f3cb1b365091a2cfface0695bc841b090fd1d528d35b0ea54f0fa4b74424c6d28fc4cd0
+  data.tar.gz: ff28c0cee74dc2602ca0eb74dca63e9b98e84c28179f043db8875f29537b15a3d6df9b93439fbdc12cdfe6deb7006575248d7e54cce56351baefde378ba62494

data/.gitignore

@@ -2,6 +2,7 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 /GIT-VERSION-FILE
 /NEWS
+/NEWS.atom.xml
 /pkg
 /lib/yahns/version.rb
 /coverage.dump

data/Documentation/yahns_config.txt

@@ -278,6 +278,11 @@ Ruby it is running under.
 
     HTTP request headers are always buffered in memory.
 
+    Do not be tempted to disable any buffering because it improves
+    numbers on a synthetic benchmark over a fast connection.
+    Slow, real-world clients can easily overwhelm servers without both
+    input and output buffering.
+
     Default: true
 
     The following OPTIONS may be specified:
@@ -418,12 +423,19 @@ Ruby it is running under.
 
     This enables or disables buffering of the HTTP response.  If enabled,
     buffering is only performed lazily.  In other words, buffering only
-    happens if socket buffers (in the kernel) are filled up.
+    happens if socket buffers (in the kernel) are filled up, and yahns
+    will continously try to flush the buffered data to the socket while
+    it is buffering.
 
-    Disabling output buffering is only recommended if all clients
+    Disabling output buffering is only recommended if ALL clients
     connecting to this application context are fast, trusted or
     you are willing and able to run many worker threads.
 
+    Do not be tempted to disable any buffering because it improves
+    numbers on a synthetic benchmark over a fast connection.
+    Slow, real-world clients can easily overwhelm servers without both
+    input and output buffering.
+
     If output buffering is disabled, client_timeout controls the maximum
     amount of time a worker thread will wait synchronously.
 
@@ -495,6 +507,12 @@ Ruby it is running under.
     pthread_atfork(3)-style hooks.  See WORKER_PROCESSES-LEVEL DIRECTIVES
     for details.
 
+    Using worker_processes is strongly recommended if your application
+    relies on using a SIGCHLD handler for reaping forked processes.
+    Without worker_processes, yahns must reserve SIGCHLD for rolling
+    back SIGUSR2 upgrades, leading to conflicts if the appplication
+    expects to handle SIGCHLD.
+
     Default: nil (single process, no master/worker separation)
 
 ## WORKER_PROCESSES-LEVEL DIRECTIVES

data/GIT-VERSION-GEN

@@ -4,7 +4,7 @@
 CONSTANT = "Yahns::VERSION"
 RVF = "lib/yahns/version.rb"
 GVF = "GIT-VERSION-FILE"
-DEF_VER = "v0.0.2"
+DEF_VER = "v0.0.3"
 vn = DEF_VER
 
 # First see if there is a version file (included in release tarballs),

data/Rakefile

@@ -2,59 +2,135 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require 'tempfile'
 include Rake::DSL
-task "NEWS" do
-  latest = nil
-  fp = Tempfile.new("NEWS", ".")
-  fp.sync = true
-  `git tag -l`.split(/\n/).reverse.each do |tag|
-    %r{\Av(.+)} =~ tag or next
-    version = $1
-    header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
-    header = header.split(/\n/)
-    tagger = header.grep(/\Atagger /)[0]
-    time = Time.at(tagger.split(/ /)[-2].to_i).utc
-    latest ||= time
-    date = time.strftime("%Y-%m-%d")
-    fp.puts "# #{version} / #{date}\n\n#{subject}"
-    if body && body.strip.size > 0
-      fp.puts "\n\n#{body}"
-    end
-    fp.puts
-  end
-  fp.write("Unreleased\n\n") unless fp.size > 0
-  fp.puts "# COPYRIGHT"
-  bdfl = 'Eric Wong <normalperson@yhbt.net>'
-  fp.puts "Copyright (C) 2013, #{bdfl} and all contributors"
-  fp.puts "License: GPLv3 or later (http://www.gnu.org/licenses/gpl-3.0.txt)"
-  fp.rewind
-  assert_equal fp.read, File.read("NEWS") rescue nil
-  fp.chmod 0644
-  File.rename(fp.path, "NEWS")
-  fp.close!
-end
 
-task rsync_docs: "NEWS" do
+gendocs = %w(NEWS NEWS.atom.xml)
+task rsync_docs: gendocs do
   dest = ENV["RSYNC_DEST"] || "yahns.yhbt.net:/srv/yahns/"
-  top = %w(INSTALL HACKING NEWS README COPYING)
-  files = []
+  top = %w(INSTALL HACKING README COPYING)
 
   # git-set-file-times is distributed with rsync,
   # Also available at: http://yhbt.net/git-set-file-times
   # on Debian systems: /usr/share/doc/rsync/scripts/git-set-file-times.gz
   sh("git", "set-file-times", "Documentation", "examples", *top)
 
-  `git ls-files Documentation/*.txt`.split(/\n/).concat(top).each do |txt|
+  do_gzip = lambda do |txt|
     gz = "#{txt}.gz"
     tmp = "#{gz}.#$$"
-    sh("gzip -9 < #{txt} > #{tmp}")
+    sh("gzip --rsyncable -9 < #{txt} > #{tmp}")
     st = File.stat(txt)
     File.utime(st.atime, st.mtime, tmp) # make nginx gzip_static happy
     File.rename(tmp, gz)
-    files << txt
-    files << gz
+    gz
   end
+
+  files = `git ls-files Documentation/*.txt`.split(/\n/)
+  files.concat(top)
+  files.concat(gendocs)
+  gzfiles = files.map { |txt| do_gzip.call(txt) }
+  files.concat(gzfiles)
+
   sh("rsync --chmod=Fugo=r -av #{files.join(' ')} #{dest}")
 
-  examples = `git ls-files examples`.split("\n")
+  examples = `git ls-files examples`.split(/\n/)
+  gzex = examples.map { |txt| do_gzip.call(txt) }
+  examples.concat(gzex)
+
   sh("rsync --chmod=Fugo=r -av #{examples.join(' ')} #{dest}/examples/")
 end
+
+def tags
+  timefmt = '%Y-%m-%dT%H:%M:%SZ'
+  @tags ||= `git tag -l`.split(/\n/).map do |tag|
+    if %r{\Av[\d\.]+} =~ tag
+      header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
+      header = header.split(/\n/)
+      tagger = header.grep(/\Atagger /).first
+      body ||= "initial"
+      time = Time.at(tagger.split(/ /)[-2].to_i).utc
+      {
+        time_obj: time,
+        time: time.strftime(timefmt),
+        tagger_name: %r{^tagger ([^<]+)}.match(tagger)[1].strip,
+        tagger_email: %r{<([^>]+)>}.match(tagger)[1].strip,
+        id: `git rev-parse refs/tags/#{tag}`.chomp!,
+        tag: tag,
+        subject: subject,
+        body: body,
+      }
+    end
+  end.compact.sort { |a,b| b[:time] <=> a[:time] }
+end
+
+url_base = 'http://yahns.yhbt.net'
+cgit_url = 'http://yhbt.net/yahns.git'
+git_url = 'git://yhbt.net/yahns.git'
+since = "v0.0.2"
+
+desc 'prints news as an Atom feed'
+task "NEWS.atom.xml" do
+  require 'nokogiri'
+  new_tags = tags[0,10]
+  time = nil
+  str = Nokogiri::XML::Builder.new do
+    feed :xmlns => "http://www.w3.org/2005/Atom" do
+      id! "#{url_base}/NEWS.atom.xml"
+      title "yahns news"
+      subtitle "sleepy, multi-threaded, non-blocking Ruby application server"
+      link! :rel => 'alternate', :type => 'text/plain',
+            :href => "#{url_base}/NEWS"
+      updated(new_tags.empty? ? "1970-01-01T00:00:00Z" : new_tags.first[:time])
+      new_tags.each do |tag|
+        time ||= tag[:time_obj]
+        entry do
+          title tag[:subject]
+          updated tag[:time]
+          published tag[:time]
+          author {
+            name tag[:tagger_name]
+            email tag[:tagger_email]
+          }
+          url = "#{cgit_url}/tag/?id=#{tag[:tag]}"
+          link! :rel => "alternate", :type => "text/html", :href =>url
+          id! url
+          message_only = tag[:body].split(/\n.+\(\d+\):\n {6}/).first.strip
+          content({:type =>:text}, message_only)
+          content(:type =>:xhtml) { pre tag[:body] }
+        end
+      end
+    end
+  end.to_xml
+
+  fp = Tempfile.new("NEWS.atom.xml", ".")
+  fp.sync = true
+  fp.write(str)
+  fp.chmod 0644
+  File.utime(time, time, fp.path) if time
+  File.rename(fp.path, "NEWS.atom.xml")
+  fp.close!
+end
+
+desc 'prints news as a text file'
+task "NEWS" do
+  fp = Tempfile.new("NEWS", ".")
+  fp.sync = true
+  time = nil
+  tags.each do |tag|
+    time ||= tag[:time_obj]
+    line = tag[:subject] + " / " + tag[:time].gsub(/T.*/, '')
+    fp.puts line
+    fp.puts("-" * line.length)
+    fp.puts
+    fp.puts tag[:body] #.gsub(/^/m, "  ").gsub(/[ \t]+$/m, "")
+    fp.puts
+  end
+  fp.write("Unreleased\n\n") unless fp.size > 0
+  fp.puts "COPYRIGHT"
+  fp.puts "---------"
+  bdfl = 'Eric Wong <normalperson@yhbt.net>'
+  fp.puts "Copyright (C) 2013, #{bdfl} and all contributors"
+  fp.puts "License: GPLv3 or later (http://www.gnu.org/licenses/gpl-3.0.txt)"
+  fp.chmod 0644
+  File.utime(time, time, fp.path) if time
+  File.rename(fp.path, "NEWS")
+  fp.close!
+end

data/extras/exec_cgi.rb

@@ -1,6 +1,9 @@
 # -*- encoding: binary -*-
 # Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
 # License: GPLv2 or later (https://www.gnu.org/licenses/gpl-2.0.txt)
+#
+# if running under yahns, worker_processes is recommended to avoid conflicting
+# with the SIGCHLD handler in yahns.
 class ExecCgi
   class MyIO < Kgio::Pipe
     attr_writer :my_pid
@@ -19,17 +22,24 @@ class ExecCgi
       end
       yield("0\r\n\r\n") if @chunked
       self
+    ensure
+      # do this sooner, since the response body may be buffered, we want
+      # to release our FD as soon as possible.
+      close
     end
 
     def close
+      # yahns will call this again after its done writing the response
+      # body, so we must ensure its idempotent.
+      # Note: this object (and any client-specific objects) will never
+      # be shared across different threads, so we do not need extra
+      # mutual exclusion here.
+      return if closed?
       super
-      if defined?(@my_pid) && @my_pid
-        begin
-          Process.waitpid(@my_pid)
-        rescue Errno::ECHILD
-        end
-      end
-      nil
+      begin
+        Process.waitpid(@my_pid)
+      rescue Errno::ECHILD
+      end if defined?(@my_pid) && @my_pid
     end
   end
 
@@ -67,7 +77,8 @@ class ExecCgi
     PASS_VARS.each { |key| val = env[key] and cgi_env[key] = val }
     env.each { |key,val| cgi_env[key] = val if key =~ /\AHTTP_/ }
     pipe = MyIO.pipe
-    pipe[0].my_pid = Process.spawn(cgi_env, *@args,
+    errbody = pipe[0]
+    errbody.my_pid = Process.spawn(cgi_env, *@args,
                                    out: pipe[1], close_others: true)
     pipe[1].close
     pipe = pipe[0]
@@ -100,9 +111,12 @@ class ExecCgi
           pipe.chunked = true
         end
       end
+      errbody = nil
       [ status, headers, pipe ]
     else
       [ 500, { "Content-Length" => "0", "Content-Type" => "text/plain" }, [] ]
     end
+  ensure
+    errbody.close if errbody
   end
 end

data/lib/yahns/acceptor.rb

@@ -56,7 +56,7 @@ module Yahns::Acceptor # :nodoc:
           end
         rescue Errno::EMFILE, Errno::ENFILE => e
           logger.error("#{e.message}, consider raising open file limits")
-          queue.fdmap.desperate_expire_for(nil, 5)
+          queue.fdmap.desperate_expire(5)
           sleep 1 # let other threads do some work
         rescue => e
           Yahns::Log.exception(logger, "accept loop", e)

data/lib/yahns/daemon.rb

@@ -19,7 +19,11 @@ module Yahns::Daemon # :nodoc:
 
     # We only start a new process group if we're not being reexecuted
     # and inheriting file descriptors from our parent
-    unless ENV['YAHNS_FD']
+    if ENV['YAHNS_FD']
+      # if we're inheriting, need to ensure this remains true so
+      # SIGWINCH works when worker processes are in play
+      yahns_server.daemon_pipe = true
+    else
       # grandparent - reads pipe, exits when master is ready
       #  \_ parent  - exits immediately ASAP
       #      \_ yahns master - writes to pipe when ready

data/lib/yahns/fdmap.rb

@@ -31,11 +31,16 @@ class Yahns::Fdmap # :nodoc:
 
   # Yes, we call IO#close inside the lock(!)
   #
-  # We don't want to race with __expire_for.  Theoretically, a Ruby
+  # We don't want to race with __expire.  Theoretically, a Ruby
   # implementation w/o GVL may end up issuing shutdown(2) on the same fd
   # as one which got accept-ed (a brand new IO object) so we must prevent
   # IO#close in worker threads from racing with any threads which may run
-  # __expire_for
+  # __expire
+  #
+  # We must never, ever call this while it is capable of being on the
+  # epoll ready list and returnable by epoll_wait.  So we can only call
+  # this on objects which were epoll_ctl-ed with EPOLLONESHOT (and now
+  # retrieved).
   def sync_close(io)
     @fdmap_mtx.synchronize do
       @count -= 1
@@ -48,17 +53,16 @@ class Yahns::Fdmap # :nodoc:
     fd = io.fileno
     @fdmap_mtx.synchronize do
       if (@count += 1) > @client_expire_threshold
-        __expire_for(io)
-      else
-        @fdmap_ary[fd] = io
+        __expire(nil)
       end
+      @fdmap_ary[fd] = io
     end
   end
 
   # this is only called in Errno::EMFILE/Errno::ENFILE situations
   # and graceful shutdown
-  def desperate_expire_for(io, timeout)
-    @fdmap_mtx.synchronize { __expire_for(io, timeout) }
+  def desperate_expire(timeout)
+    @fdmap_mtx.synchronize { __expire(timeout) }
   end
 
   # only called on hijack
@@ -74,7 +78,7 @@ class Yahns::Fdmap # :nodoc:
   # expire a bunch of idle clients and register the current one
   # We should not be calling this too frequently, it is expensive
   # This is called while @fdmap_mtx is held
-  def __expire_for(io, timeout = nil)
+  def __expire(timeout)
     nr = 0
     now = Time.now.to_f
     (now - @last_expire) >= 1.0 or return # don't expire too frequently
@@ -88,7 +92,6 @@ class Yahns::Fdmap # :nodoc:
       nr += c.yahns_expire(tout)
     end
 
-    @fdmap_ary[io.fileno] = io if io
     @last_expire = Time.now.to_f
     msg = timeout ? "timeout=#{timeout}" : "client_timeout"
     @logger.info("dropping #{nr} of #@count clients for #{msg}")

data/lib/yahns/http_client.rb

@@ -269,7 +269,8 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
   # nil to ensure the socket is closed at the end of this function
   def handle_error(e)
     code = case e
-    when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::ENOTCONN
+    when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::ENOTCONN,
+         Errno::ETIMEDOUT
       return # don't send response, drop the connection
     when Yahns::ClientTimeout
       408

data/lib/yahns/http_response.rb

@@ -50,20 +50,20 @@ module Yahns::HttpResponse # :nodoc:
     wbuf = Yahns::Wbuf.new(body, alive, self.class.output_buffer_tmpdir)
     rv = wbuf.wbuf_write(self, header)
     body.each { |chunk| rv = wbuf.wbuf_write(self, chunk) } if body
-    wbuf_maybe(wbuf, rv, alive)
+    wbuf_maybe(wbuf, rv)
   end
 
-  def wbuf_maybe(wbuf, rv, alive)
-    case rv # trysendfile return value
-    when nil
-      case alive
-      when :ignore
-        @state = alive
+  def wbuf_maybe(wbuf, rv)
+    case rv # wbuf_write return value
+    when nil # all done
+      case rv = wbuf.wbuf_close(self)
+      when :ignore # hijacked
+        @state = rv
       when Yahns::StreamFile
-        @state = alive
+        @state = rv
         :wait_writable
       when true, false
-        http_response_done(alive)
+        http_response_done(rv)
       end
     else
       @state = wbuf
@@ -81,9 +81,9 @@ module Yahns::HttpResponse # :nodoc:
         :wait_readable
       else
         @state = :pipelined
-        # may need to wait for readability if SSL,
-        # only need writability if plain TCP
-        :wait_readwrite
+        # we shouldn't start processing the application again until we know
+        # the socket is writable for the response
+        :wait_writable
       end
     else
       # shutdown is needed in case the app forked, we rescue here since
@@ -184,7 +184,7 @@ module Yahns::HttpResponse # :nodoc:
     # (or :wait_readable for SSL) and hit Yahns::HttpClient#step_write
     if wbuf
       body = nil # ensure we do not close the body in ensure
-      wbuf_maybe(wbuf, rv, alive)
+      wbuf_maybe(wbuf, rv)
     else
       http_response_done(alive)
     end

data/lib/yahns/queue_epoll.rb

@@ -1,6 +1,10 @@
 # -*- encoding: binary -*-
 # Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# This is the dangerous, low-level epoll interface for sleepy_penguin
+# It is safe as long as you're aware of all potential concurrency
+# issues given multithreading, GC, and epoll itself.
 class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
   include SleepyPenguin
   attr_accessor :fdmap # Yahns::Fdmap
@@ -9,7 +13,6 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
   QEV_QUIT = Epoll::OUT # Level Trigger for QueueQuitter
   QEV_RD = Epoll::IN | Epoll::ONESHOT
   QEV_WR = Epoll::OUT | Epoll::ONESHOT
-  QEV_RDWR = QEV_RD | QEV_WR
 
   def self.new
     super(SleepyPenguin::Epoll::CLOEXEC)
@@ -18,6 +21,8 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
   # for HTTP and HTTPS servers, we rely on the io writing to us, first
   # flags: QEV_RD/QEV_WR (usually QEV_RD)
   def queue_add(io, flags)
+    # order is very important here, this thread cannot do anything with
+    # io once we've issued epoll_ctl() because another thread may use it
     @fdmap.add(io)
     epoll_ctl(Epoll::CTL_ADD, io, flags)
   end
@@ -28,9 +33,14 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
   end
 
   # use only before hijacking, once hijacked, io may be unusable to us
+  # It is not safe to call this unless it is an unarmed EPOLLONESHOT
+  # object.
   def queue_del(io)
-    @fdmap.forget(io)
+    # order does not really matter here, however Epoll::CTL_DEL
+    # will free up ~200 bytes of unswappable kernel memory,
+    # so we call it first
     epoll_ctl(Epoll::CTL_DEL, io, 0)
+    @fdmap.forget(io)
   end
 
   # returns an array of infinitely running threads
@@ -39,13 +49,15 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
       thr_init
       begin
         epoll_wait(max_events) do |_, io| # don't care for flags for now
+
+          # Note: we absolutely must not do anything with io after
+          # we've called epoll_ctl on it, io is exclusive to this
+          # thread only until epoll_ctl is called on it.
           case rv = io.yahns_step
           when :wait_readable
             epoll_ctl(Epoll::CTL_MOD, io, QEV_RD)
           when :wait_writable
             epoll_ctl(Epoll::CTL_MOD, io, QEV_WR)
-          when :wait_readwrite
-            epoll_ctl(Epoll::CTL_MOD, io, QEV_RDWR)
           when :ignore # only used by rack.hijack
             # we cannot call Epoll::CTL_DEL after hijacking, the hijacker
             # may have already closed it  Likewise, io.fileno is not
@@ -59,6 +71,7 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
           end
         end
       rescue => e
+        break if closed? # can still happen due to shutdown_timeout
         Yahns::Log.exception(logger, 'queue loop', e)
       end while true
     end

data/lib/yahns/server.rb

@@ -20,6 +20,7 @@ class Yahns::Server # :nodoc:
   include Yahns::SocketHelper
 
   def initialize(config)
+    @shutdown_expire = nil
     @shutdown_timeout = nil
     @reexec_pid = 0
     @daemon_pipe = nil # writable IO or true
@@ -201,7 +202,7 @@ class Yahns::Server # :nodoc:
   end
 
   def daemon_ready
-    @daemon_pipe or return
+    @daemon_pipe.respond_to?(:syswrite) or return
     @daemon_pipe.syswrite("#$$")
     @daemon_pipe.close
     @daemon_pipe = true # for SIGWINCH
@@ -379,7 +380,8 @@ class Yahns::Server # :nodoc:
 
   def quit_enter(alive)
     if alive
-      @logger.info("gracefully exiting shutdown_timeout=#{@shutdown_timeout} s")
+      @logger.info("gracefully exiting shutdown_timeout=#@shutdown_timeout")
+      @shutdown_expire ||= Time.now + @shutdown_timeout + 1
     else # drop connections immediately if signaled twice
       @logger.info("graceful exit aborted, exiting immediately")
       # we will still call any app-defined at_exit hooks here
@@ -406,17 +408,25 @@ class Yahns::Server # :nodoc:
     @queues.each { |q| q.queue_add(quitter, Yahns::Queue::QEV_QUIT) }
 
     # watch the monkey wrench destroy all the threads!
-    @wthr.delete_if { |t| t.join(0.01) } while @wthr[0]
+    # Ugh, this may fail if we have dedicated threads trickling
+    # response bodies out (e.g. "tail -F")  Oh well, have a timeout
+    begin
+      @wthr.delete_if { |t| t.join(0.01) }
+    end while @wthr[0] && Time.now <= @shutdown_expire
 
     # cleanup, our job is done
     @queues.each(&:close).clear
+
+    # we must not let quitter get GC-ed if we have any worker threads leftover
+    @wthr.each { |t| t[:yahns_quitter] = quitter }
+
     quitter.close
   rescue => e
     Yahns::Log.exception(@logger, "quit finish", e)
   ensure
     if (@wthr.size + @listeners.size) > 0
-      @logger.error("BUG: still active wthr=#{@wthr.size} "\
-                    "listeners=#{@listeners.size}")
+      @logger.warn("still active wthr=#{@wthr.size} "\
+                   "listeners=#{@listeners.size}")
     end
   end
 
@@ -452,7 +462,8 @@ class Yahns::Server # :nodoc:
 
   def dropping(fdmap)
     if drop_acceptors[0] || fdmap.size > 0
-      fdmap.desperate_expire_for(nil, @shutdown_timeout)
+      timeout = @shutdown_expire < Time.now ? -1 : @shutdown_timeout
+      fdmap.desperate_expire(timeout)
       true
     else
       false

data/lib/yahns/stream_file.rb

@@ -24,7 +24,7 @@ class Yahns::StreamFile # :nodoc:
         rescue Errno::EMFILE, Errno::ENFILE
           raise if retried
           retried = true
-          Thread.current[:yahns_fdmap].desperate_expire_for(nil, 5)
+          Thread.current[:yahns_fdmap].desperate_expire(5)
           sleep(1)
           retry
         end

data/lib/yahns/tmpio.rb

@@ -20,7 +20,7 @@ class Yahns::TmpIO < File # :nodoc:
     rescue Errno::EMFILE, Errno::ENFILE
       raise if retried
       retried = true
-      Thread.current[:yahns_fdmap].desperate_expire_for(nil, 5)
+      Thread.current[:yahns_fdmap].desperate_expire(5)
       sleep(1)
       retry
     end

data/lib/yahns/wbuf.rb

@@ -3,6 +3,30 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative 'wbuf_common'
 
+# This class is triggered whenever we need write buffering for clients
+# reading responses slowly.  Small responses which fit into kernel socket
+# buffers do not trigger this.  yahns will always attempt to write to kernel
+# socket buffers first to avoid unnecessary copies in userspace.
+#
+# Thus, most data is into copied to the kernel only once, the kernel
+# will perform zero-copy I/O from the page cache to the socket.  The
+# only time data may be copied twice is the initial write()/send()
+# which triggers EAGAIN.
+#
+# We only buffer to the filesystem (note: likely not a disk, since this
+# is short-lived).  We let the sysadmin/kernel decide whether or not
+# the data needs to hit disk or not.
+#
+# This avoids large allocations from malloc, potentially limiting
+# fragmentation and keeping (common) smaller allocations fast.
+# General purpose malloc implementations in the 64-bit era tend to avoid
+# releasing memory back to the kernel, so large heap allocations are best
+# avoided as the kernel has little chance to reclaim memory used for a
+# temporary buffer.
+#
+# The biggest downside of this approach is it requires an FD, but yahns
+# configurations are configured for many FDs anyways, so it's unlikely
+# to be a scalability issue.
 class Yahns::Wbuf # :nodoc:
   include Yahns::WbufCommon
 

data/lib/yahns/wbuf_str.rb

@@ -3,12 +3,26 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative 'wbuf_common'
 
+# we only use this for buffering the tiniest responses (which are already
+# strings in memory and a handful of bytes).
+#
+#   "HTTP", "/1.1 "
+#   "HTTP/1.1 100 Continue\r\n\r\n"
+#   "100 Continue\r\n\r\nHTTP/1.1 "
+#
+# This is very, very rarely triggered.
+# 1) check_client_connection is enabled
+# 2) the client sent an "Expect: 100-continue" header
+#
+# Most output buffering goes through
+# the normal Yahns::Wbuf class which uses a temporary file as a buffer
+# (suitable for sendfile())
 class Yahns::WbufStr # :nodoc:
   include Yahns::WbufCommon
 
   def initialize(str, next_state)
     @str = str
-    @next = next_state # :check_client_connection, :http_100_response
+    @next = next_state # :ccc_done, :r100_done
   end
 
   def wbuf_flush(client)

data/test/server_helper.rb

@@ -16,6 +16,7 @@ module ServerHelper
   end
 
   def poke_until_dead(pid)
+    assert_operator pid, :>, 0
     Timeout.timeout(10) do
       begin
         Process.kill(0, pid)

data/test/test_extras_exec_cgi.rb

@@ -2,23 +2,24 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative 'server_helper'
 
+# note: we use worker_processes to avoid polling/excessive wakeup issues
+# in the test.  We recommend using worker_processes if using ExecCgi
 class TestExtrasExecCGI < Testcase
   ENV["N"].to_i > 1 and parallelize_me!
   include ServerHelper
   alias setup server_helper_setup
   alias teardown server_helper_teardown
+  RUNME = "#{Dir.pwd}/test/test_extras_exec_cgi.sh"
 
   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"
+    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
+        app(:rack, ExecCgi.new(RUNME)) { listen "#{host}:#{port}" }
         stderr_path err.path
+        worker_processes 1
       end
     end
 
@@ -75,7 +76,105 @@ class TestExtrasExecCGI < Testcase
       assert_nil body
       c.close
     end
+
+    Timeout.timeout(30) do # pid of executable
+      c = get_tcp_client(host, port)
+      c.write "GET /pid HTTP/1.0\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/, 2)
+      assert_match %r{200 OK}, head
+      assert_match %r{\A\d+\n\z}, body
+      exec_pid = body.to_i
+      c.close
+      poke_until_dead exec_pid
+    end
+  ensure
+    quit_wait(pid)
+  end
+
+  def test_cgi_died
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      require './extras/exec_cgi'
+      cfg.instance_eval do
+        app(:rack, ExecCgi.new(RUNME)) { listen "#{host}:#{port}" }
+        stderr_path err.path
+        worker_processes 1
+      end
+    end
+    exec_pid_tmp = tmpfile(%w(exec_cgi .pid))
+    c = get_tcp_client(host, port)
+    Timeout.timeout(20) do
+      c.write "GET /die HTTP/1.0\r\nX-PID-DEST: #{exec_pid_tmp.path}\r\n\r\n"
+      head, body = c.read.split(/\r\n\r\n/, 2)
+      assert_match %r{500 Internal Server Error}, head
+      assert_match "", body
+      exec_pid = exec_pid_tmp.read
+      assert_match %r{\A(\d+)\n\z}, exec_pid
+      poke_until_dead exec_pid.to_i
+    end
+  ensure
+    exec_pid_tmp.close! if exec_pid_tmp
+    quit_wait(pid)
+  end
+
+  [ 9, 10, 11 ].each do |rtype|
+    [ 1, 2, 3 ].each do |block_on|
+      define_method("test_block_on_block_on_#{block_on}_rtype_#{rtype}") do
+        _blocked_zombie([block_on], rtype)
+      end
+    end
+  end
+
+  def _blocked_zombie(block_on, rtype)
+    err, cfg, host, port = @err, Yahns::Config.new, @srv.addr[3], @srv.addr[1]
+    pid = mkserver(cfg) do
+      $_tw_blocked = 0
+      $_tw_block_on = block_on
+      Yahns::HttpClient.__send__(:include, TrywriteBlocked)
+      require './extras/exec_cgi'
+      cfg.instance_eval do
+        app(:rack, ExecCgi.new(RUNME)) { listen "#{host}:#{port}" }
+        stderr_path err.path
+        worker_processes 1
+      end
+    end
+
+    c = get_tcp_client(host, port)
+    Timeout.timeout(20) do
+      case rtype
+      when 9 # non-persistent (HTTP/0.9)
+        c.write "GET /pid\r\n\r\n"
+        body = c.read
+        assert_match %r{\A\d+\n\z}, body
+        exec_pid = body.to_i
+        poke_until_dead exec_pid
+      when 10 # non-persistent (HTTP/1.0)
+        c.write "GET /pid HTTP/1.0\r\n\r\n"
+        head, body = c.read.split(/\r\n\r\n/, 2)
+        assert_match %r{200 OK}, head
+        assert_match %r{\A\d+\n\z}, body
+        exec_pid = body.to_i
+        poke_until_dead exec_pid
+      when 11 # pid of executable, persistent
+        c.write "GET /pid HTTP/1.0\r\nConnection: keep-alive\r\n\r\n"
+        buf = ""
+        begin
+          buf << c.readpartial(666)
+        end until buf =~ /\r\n\r\n\d+\n/
+        head, body = buf.split(/\r\n\r\n/, 2)
+        assert_match %r{200 OK}, head
+        assert_match %r{\A\d+\n\z}, body
+        exec_pid = body.to_i
+        assert_raises(Errno::EAGAIN, IO::WaitReadable) { c.read_nonblock(666) }
+        poke_until_dead exec_pid
+        # still alive?
+        assert_raises(Errno::EAGAIN, IO::WaitReadable) { c.read_nonblock(666) }
+      else
+        raise "BUG in test, bad rtype"
+      end
+    end
   ensure
+    c.close if c
     quit_wait(pid)
   end
 end

data/test/test_extras_exec_cgi.sh

@@ -20,6 +20,23 @@ case $PATH_INFO in
 	stdhead
 	env
 	;;
+/pid)
+	stdhead
+	echo $$
+	;;
+/die)
+	if test -n "$HTTP_X_PID_DEST"
+	then
+		# obviously this is only for testing on a local machine:
+		echo $$ > "$HTTP_X_PID_DEST"
+		exit 1
+	else
+		echo Content-Type: text/plain
+		echo Status: 400 Bad Request
+		echo Content-Length: 0
+		echo
+	fi
+	;;
 /known-length)
 	echo Content-Type: text/plain
 	echo Status: 200 OK

data/test/test_extras_try_gzip_static.rb

@@ -53,7 +53,8 @@ class TestExtrasTryGzipStatic < Testcase
       c = get_tcp_client(host, port)
       begin
         c.write "#{req}\r\n\r\n"
-        head, body = c.read.split(/\r\n\r\n/)
+        buf = c.read(666000)
+        head, body = buf.split(/\r\n\r\n/)
         blk.call(head)
         body
       ensure

data/test/test_server.rb

@@ -702,7 +702,6 @@ class TestServer < Testcase
     Process.kill(:QUIT, pid)
     _, status = Timeout.timeout(5) { Process.waitpid2(pid) }
     assert status.success?, status.inspect
-    assert_nil c.wait(1)
     assert_nil c.read(666)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yahns
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - yahns hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio