yahns 0.0.1 → 0.0.2

data/lib/yahns/daemon.rb

@@ -1,6 +1,8 @@
 # -*- 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)
+require 'yahns'
+
 module Yahns::Daemon # :nodoc:
   # We don't do a lot of standard daemonization stuff:
   #   * umask is whatever was set by the parent process at startup

data/lib/yahns/fdmap.rb

@@ -29,6 +29,20 @@ class Yahns::Fdmap # :nodoc:
     @count = 0
   end
 
+  # Yes, we call IO#close inside the lock(!)
+  #
+  # We don't want to race with __expire_for.  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
+  def sync_close(io)
+    @fdmap_mtx.synchronize do
+      @count -= 1
+      io.close
+    end
+  end
+
   # called immediately after accept()
   def add(io)
     fd = io.fileno
@@ -42,16 +56,19 @@ class Yahns::Fdmap # :nodoc:
   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) }
   end
 
-  # called before IO#close
-  def decr
-    # don't bother clearing the element in @fdmap_ary, it'll just be
-    # overwritten when another client connects (soon).  We must not touch
-    # @fdmap_ary[io.fileno] after IO#close on io
-    @fdmap_mtx.synchronize { @count -= 1 }
+  # only called on hijack
+  def forget(io)
+    fd = io.fileno
+    @fdmap_mtx.synchronize do
+      # prevent rack.hijacked IOs from being expired by us
+      @fdmap_ary[fd] = nil
+      @count -= 1
+    end
   end
 
   # expire a bunch of idle clients and register the current one
@@ -66,12 +83,14 @@ class Yahns::Fdmap # :nodoc:
     # avoid getting to this method too frequently
     @fdmap_ary.each do |c|
       c.respond_to?(:yahns_expire) or next
-      nr += c.yahns_expire(timeout || c.class.client_timeout)
+      ctimeout = c.class.client_timeout
+      tout = (timeout && timeout < ctimeout) ? timeout : ctimeout
+      nr += c.yahns_expire(tout)
     end
 
-    @fdmap_ary[io.fileno] = io
+    @fdmap_ary[io.fileno] = io if io
     @last_expire = Time.now.to_f
-    msg = timeout ? "timeout=#{timeout})" : "client_timeout"
+    msg = timeout ? "timeout=#{timeout}" : "client_timeout"
     @logger.info("dropping #{nr} of #@count clients for #{msg}")
   end
 

data/lib/yahns/http_client.rb

@@ -8,9 +8,7 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
   Unicorn::HttpParser.keepalive_requests = 0xffffffff
 
   include Yahns::HttpResponse
-  include Yahns::ClientExpire
   QEV_FLAGS = Yahns::Queue::QEV_RD # used by acceptor
-  HTTP_RESPONSE_START = [ 'HTTP', '/1.1 ' ]
 
   # A frozen format for this is about 15% faster (note from Mongrel)
   REMOTE_ADDR = 'REMOTE_ADDR'.freeze
@@ -40,6 +38,9 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
       @state = rv # continue looping
     when true, false # done
       return http_response_done(rv)
+    when :ccc_done, :r100_done
+      @state = rv
+      return :wait_writable
     else
       raise "BUG: #{@state.inspect}#wbuf_flush returned #{rv.inspect}"
     end while true
@@ -56,6 +57,7 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     end
     @state = :body
     @input = k.tmpio_for(len)
+
     rbuf = Thread.current[:yahns_rbuf]
     @hs.filter_body(rbuf, @hs.buf)
     @input.write(rbuf)
@@ -66,6 +68,8 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     k = self.class
     case k.input_buffering
     when true
+      rv = http_100_response(@hs.env) and return rv
+
       # common case is an empty body
       return NULL_IO if empty_body
 
@@ -77,6 +81,38 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     end
   end
 
+  # returns true if we want to keep looping on this
+  # returns :wait_readable/wait_writable/nil to yield back to epoll
+  def fill_body(rsize, rbuf)
+    case rv = kgio_tryread(rsize, rbuf)
+    when String
+      @hs.filter_body(rbuf, @hs.buf << rbuf)
+      @input.write(rbuf)
+      true # keep looping on kgio_tryread (but check body_eof? first)
+    when :wait_readable, :wait_writable
+      rv # have epoll/kqueue wait for more
+    when nil # unexpected EOF
+      @input.close # nil
+    end
+  end
+
+  # returns true if we are ready to dispatch the app
+  # returns :wait_readable/wait_writable/nil to yield back to epoll
+  def read_trailers(rsize, rbuf)
+    case rv = kgio_tryread(rsize, rbuf)
+    when String
+      if @hs.add_parse(rbuf)
+        @input.rewind
+        return true
+      end
+      # keep looping on kgio_tryread...
+    when :wait_readable, :wait_writable
+      return rv # wait for more
+    when nil # unexpected EOF
+      return @input.close # nil
+    end while true
+  end
+
   # the main entry point of the epoll/kqueue worker loop
   def yahns_step
     # always write unwritten data first if we have any
@@ -89,7 +125,12 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     case @state
     when :pipelined
       if @hs.parse
-        input = input_ready and return app_call(input)
+        case input = input_ready
+        when :wait_readable, :wait_writable, :close then return input
+        when false # keep looping on @state
+        else
+          return app_call(input)
+        end
         # @state == :body if we get here point (input_ready -> mkinput_preread)
       else
         @state = :headers
@@ -99,8 +140,12 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
       case rv = kgio_tryread(k.client_header_buffer_size, rbuf)
       when String
         if @hs.add_parse(rv)
-          input = input_ready and return app_call(input)
-          break # to outer loop to reevaluate @state == :body
+          case input = input_ready
+          when :wait_readable, :wait_writable, :close then return input
+          when false then break # to outer loop to reevaluate @state == :body
+          else
+            return app_call(input)
+          end
         end
         # keep looping on kgio_tryread
       when :wait_readable, :wait_writable, nil
@@ -115,58 +160,75 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
           @state = :trailers
         end
       else
-        case rv = kgio_tryread(k.client_body_buffer_size, rbuf)
-        when String
-          @hs.filter_body(rbuf, @hs.buf << rbuf)
-          @input.write(rbuf)
-          # keep looping on kgio_tryread...
-        when :wait_readable, :wait_writable
-          return rv # have epoll/kqueue wait for more
-        when nil # unexpected EOF
-          return @input.close # nil
-        end # continue to outer loop (case @state)
+        rv = fill_body(k.client_body_buffer_size, rbuf)
+        return rv unless true == rv
       end
     when :trailers
-      case rv = kgio_tryread(k.client_header_buffer_size, rbuf)
-      when String
-        if @hs.add_parse(rbuf)
-          @input.rewind
-          return app_call(@input)
-        end
-        # keep looping on kgio_tryread...
-      when :wait_readable, :wait_writable
-        return rv # wait for more
-      when nil # unexpected EOF
-        return @input.close # nil
-      end while true
+      rv = read_trailers(k.client_header_buffer_size, rbuf)
+      return true == rv ? app_call(@input) : rv
+    when :ccc_done # unlikely
+      return app_call(nil)
+    when :r100_done # unlikely
+      rv = r100_done
+      return rv unless rv == true
+      raise "BUG: body=#@state " if @state != :body
+      # @state == :body, keep looping
     end while true # outer loop
   rescue => e
     handle_error(e)
   end
 
+  # returns :wait_readable, :wait_writable, :ignore, or nil for epoll
+  # returns false to keep looping inside yahns_step
+  def r100_done
+    k = self.class
+    case k.input_buffering
+    when true
+      empty_body = 0 == @hs.content_length
+      # common case is an empty body
+      return app_call(NULL_IO) if empty_body
+
+      # content_length is nil (chunked) or len > 0
+      mkinput_preread # keep looping (@state == :body)
+      true
+    else # :lazy, false
+      http_response_write(*k.app.call(@hs.env))
+    end
+  end
+
   def app_call(input)
     env = @hs.env
-    env[REMOTE_ADDR] = @kgio_addr
-    env[RACK_HIJACK] = hijack_proc(env)
-    env[RACK_INPUT] = input
     k = self.class
 
-    if k.check_client_connection && @hs.headers?
-      @response_start_sent = true
-      # FIXME: we should buffer this just in case
-      HTTP_RESPONSE_START.each { |c| kgio_write(c) }
+    # input is nil if we needed to wait for writability with
+    # check_client_connection
+    if input
+      env[REMOTE_ADDR] = @kgio_addr
+      env[RACK_HIJACK] = hijack_proc(env)
+      env[RACK_INPUT] = input
+
+      if k.check_client_connection && @hs.headers?
+        rv = do_ccc and return rv
+      end
     end
 
     # run the rack app
-    response = k.app.call(env.merge!(k.app_defaults))
+    status, headers, body = k.app.call(env.merge!(k.app_defaults))
     return :ignore if env.include?(RACK_HIJACK_IO)
+    if status.to_i == 100
+      rv = http_100_response(env) and return rv
+      status, headers, body = k.app.call(env)
+    end
 
     # this returns :wait_readable, :wait_writable, :ignore, or nil:
-    http_response_write(*response)
+    http_response_write(status, headers, body)
   end
 
   def hijack_proc(env)
-    proc { env[RACK_HIJACK_IO] = self }
+    proc do
+      self.class.queue.queue_del(self) # EPOLL_CTL_DEL
+      env[RACK_HIJACK_IO] = self
+    end
   end
 
   # called automatically by kgio_write
@@ -179,6 +241,28 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     super timeout
   end
 
+  # used by StreamInput (and thus TeeInput) for input_buffering {false|:lazy}
+  def yahns_read(bytes, buf)
+    case rv = kgio_tryread(bytes, buf)
+    when String, nil
+      return rv
+    when :wait_readable
+      kgio_wait_readable or raise Yahns::ClientTimeout, "waiting for read", []
+    when :wait_writable
+      kgio_wait_writable or raise Yahns::ClientTimeout, "waiting for write", []
+    end while true
+  end
+
+  def response_hijacked(fn)
+    # we must issue EPOLL_CTL_DEL before hijacking (if we issue it at all),
+    # because the hijacker may close use before we get back to the epoll worker
+    # loop.  EPOLL_CTL_DEL saves about 200 bytes of unswappable kernel memory,
+    # so it can matter if we have lots of hijacked sockets.
+    self.class.queue.queue_del(self)
+    fn.call(self)
+    :ignore
+  end
+
   # if we get any error, try to write something back to the client
   # assuming we haven't closed the socket, but don't get hung up
   # if the socket is already closed or broken.  We'll always return
@@ -187,6 +271,8 @@ class Yahns::HttpClient < Kgio::Socket # :nodoc:
     code = case e
     when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::ENOTCONN
       return # don't send response, drop the connection
+    when Yahns::ClientTimeout
+      408
     when Unicorn::RequestURITooLongError
       414
     when Unicorn::RequestEntityTooLargeError

data/lib/yahns/http_context.rb

@@ -15,14 +15,17 @@ module Yahns::HttpContext # :nodoc:
   attr_accessor :persistent_connections # true or false only
   attr_accessor :client_timeout
   attr_accessor :qegg
+  attr_accessor :queue # set right before spawning acceptors
   attr_reader :app
   attr_reader :app_defaults
+  attr_writer :input_buffer_tmpdir
+  attr_writer :output_buffer_tmpdir
 
   def http_ctx_init(yahns_rack)
     @yahns_rack = yahns_rack
     @app_defaults = yahns_rack.app_defaults
     @check_client_connection = false
-    @client_body_buffer_size = 112 * 1024
+    @client_body_buffer_size = 8 * 1024
     @client_header_buffer_size = 4000
     @client_max_body_size = 1024 * 1024 # nil => infinity
     @input_buffering = true
@@ -30,6 +33,11 @@ module Yahns::HttpContext # :nodoc:
     @persistent_connections = true
     @client_timeout = 15
     @qegg = nil
+    @queue = nil
+
+    # Dir.tmpdir can change while running, so leave these as nil
+    @input_buffer_tmpdir = nil
+    @output_buffer_tmpdir = nil
   end
 
   # call this after forking
@@ -72,10 +80,20 @@ module Yahns::HttpContext # :nodoc:
 
   def tmpio_for(len)
     if len # Content-Length given
-      len <= @client_body_buffer_size ? StringIO.new("") : Yahns::TmpIO.new
+      len <= @client_body_buffer_size ? StringIO.new("")
+           : Yahns::TmpIO.new(input_buffer_tmpdir)
     else # chunked, unknown length
       mbs = @client_max_body_size
-      mbs ? Yahns::CapInput.new(mbs) : Yahns::TmpIO.new
+      tmpdir = input_buffer_tmpdir
+      mbs ? Yahns::CapInput.new(mbs, tmpdir) : Yahns::TmpIO.new(tmpdir)
     end
   end
+
+  def input_buffer_tmpdir
+    @input_buffer_tmpdir || Dir.tmpdir
+  end
+
+  def output_buffer_tmpdir
+    @output_buffer_tmpdir || Dir.tmpdir
+  end
 end

data/lib/yahns/http_response.rb

@@ -2,6 +2,7 @@
 # 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 'stream_file'
+require_relative 'wbuf_str'
 
 # Writes a Rack response to your client using the HTTP/1.1 specification.
 # You use it by simply doing:
@@ -18,7 +19,11 @@ module Yahns::HttpResponse # :nodoc:
   CONN_KA = "Connection: keep-alive\r\n\r\n"
   CONN_CLOSE = "Connection: close\r\n\r\n"
   Z = ""
-  RESPONSE_START = "HTTP/1.1 "
+  CCC_RESPONSE_START = [ 'HTTP', '/1.1 ' ].map!(&:freeze)
+  RESPONSE_START = CCC_RESPONSE_START.join('')
+  R100_RAW = "HTTP/1.1 100 Continue\r\n\r\n"
+  R100_CCC = "100 Continue\r\n\r\nHTTP/1.1 "
+  HTTP_EXPECT = "HTTP_EXPECT"
 
   def response_start
     @response_start_sent ? Z : RESPONSE_START
@@ -30,7 +35,7 @@ module Yahns::HttpResponse # :nodoc:
     k = self.class
     k.logger.info("fd=#{fileno} ip=#@kgio_addr timeout on :#{rv} after "\
                   "#{k.client_timeout}s")
-    nil
+    false
   end
 
   def err_response(code)
@@ -42,7 +47,7 @@ module Yahns::HttpResponse # :nodoc:
       alive = Yahns::StreamFile.new(body, alive, offset, count)
       body = nil
     end
-    wbuf = Yahns::Wbuf.new(body, alive)
+    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)
@@ -53,7 +58,10 @@ module Yahns::HttpResponse # :nodoc:
     when nil
       case alive
       when :ignore
-        @state = :ignore
+        @state = alive
+      when Yahns::StreamFile
+        @state = alive
+        :wait_writable
       when true, false
         http_response_done(alive)
       end
@@ -81,7 +89,16 @@ module Yahns::HttpResponse # :nodoc:
       # shutdown is needed in case the app forked, we rescue here since
       # StreamInput may issue shutdown as well
       shutdown rescue nil
-      nil # trigger close
+      :close
+    end
+  end
+
+  def kv_str(key, value)
+    if value =~ /\n/
+      # avoiding blank, key-only cookies with /\n+/
+      value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join
+    else
+      "#{key}: #{value}\r\n"
     end
   end
 
@@ -105,19 +122,15 @@ module Yahns::HttpResponse # :nodoc:
             offset = $1.to_i
             count = $2.to_i - offset + 1
           end
+          buf << kv_str(key, value)
         when %r{\AConnection\z}i
           # allow Rack apps to tell us they want to drop the client
-          alive = !!(value =~ /\bclose\b/i)
+          alive = false if value =~ /\bclose\b/i
         when "rack.hijack"
           hijack = value
           body = nil # ensure we do not close body
         else
-          if value =~ /\n/
-            # avoiding blank, key-only cookies with /\n+/
-            buf << value.split(/\n+/).map! { |v| "#{key}: #{v}\r\n" }.join
-          else
-            buf << "#{key}: #{value}\r\n"
-          end
+          buf << kv_str(key, value)
         end
       end
       buf << (alive ? CONN_KA : CONN_CLOSE)
@@ -133,15 +146,12 @@ module Yahns::HttpResponse # :nodoc:
           body = nil # ensure we do not close body in ensure
           return rv
         else
-          response_wait_write(rv) or return
+          response_wait_write(rv) or return :close
         end
       end while true
     end
 
-    if hijack
-      hijack.call(self)
-      return :ignore
-    end
+    return response_hijacked(hijack) if hijack
 
     if body.respond_to?(:to_path)
       @state = body = Yahns::StreamFile.new(body, alive, offset, count)
@@ -160,11 +170,11 @@ module Yahns::HttpResponse # :nodoc:
           chunk = rv # hope the skb grows when we loop into the trywrite
         when :wait_writable, :wait_readable
           if k.output_buffering
-            wbuf = Yahns::Wbuf.new(body, alive)
+            wbuf = Yahns::Wbuf.new(body, alive, k.output_buffer_tmpdir)
             rv = wbuf.wbuf_write(self, chunk)
             break
           else
-            response_wait_write(rv) or return
+            response_wait_write(rv) or return :close
           end
         end while true
       end
@@ -181,4 +191,55 @@ module Yahns::HttpResponse # :nodoc:
   ensure
     body.respond_to?(:close) and body.close
   end
+
+  # returns nil on success
+  # :wait_readable/:wait_writable/:close for epoll
+  def do_ccc
+    @response_start_sent = true
+    wbuf = nil
+    rv = nil
+    CCC_RESPONSE_START.each do |buf|
+      if wbuf
+        wbuf << buf
+      else
+        case rv = kgio_trywrite(buf)
+        when nil
+          break
+        when String
+          buf = rv
+        when :wait_writable, :wait_readable
+          if self.class.output_buffering
+            wbuf = buf.dup
+            @state = Yahns::WbufStr.new(wbuf, :ccc_done)
+            break
+          else
+            response_wait_write(rv) or return :close
+          end
+        end while true
+      end
+    end
+    rv
+  end
+
+  # only used if input_buffering is true (not :lazy or false)
+  # input_buffering==:lazy/false gives control to the app
+  # returns nil on success
+  # returns :close, :wait_writable, or :wait_readable
+  def http_100_response(env)
+    env.delete(HTTP_EXPECT) =~ /\A100-continue\z/i or return nil
+    buf = @response_start_sent ? R100_CCC : R100_RAW
+    case rv = kgio_trywrite(buf)
+    when String
+      buf = rv
+    when :wait_writable, :wait_readable
+      if self.class.output_buffering
+        @state = Yahns::WbufStr.new(buf, :r100_done)
+        return rv
+      else
+        response_wait_write(rv) or return :close
+      end
+    else
+      return rv
+    end while true
+  end
 end