yahns 1.12.5 → 1.13.0

data/lib/yahns/req_res.rb

@@ -0,0 +1,164 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013-2016 all contributors <yahns-public@yhbt.net>
+# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# frozen_string_literal: true
+# Only used by Yahns::ProxyPass
+require 'kcar' # gem install kcar
+require 'kgio'
+
+class Yahns::ReqRes < Kgio::Socket # :nodoc:
+  attr_accessor :resbuf
+  attr_accessor :proxy_trailers
+  attr_accessor :alive
+  attr_reader :proxy_pass
+
+  def req_start(c, req, input, chunked, proxy_pass)
+    @hdr = @resbuf = nil
+    @yahns_client = c
+    @rrstate = input ? [ req, input, chunked ] : req
+    @proxy_pass = proxy_pass
+    Thread.current[:yahns_queue].queue_add(self, Yahns::Queue::QEV_WR)
+  end
+
+  def yahns_step # yahns event loop entry point
+    c = @yahns_client
+    case req = @rrstate
+    when Kcar::Parser # reading response...
+      buf = Thread.current[:yahns_rbuf]
+
+      case resbuf = @resbuf # where are we at the response?
+      when nil # common case, catch the response header in a single read
+
+        case rv = kgio_tryread(0x2000, buf)
+        when String
+          if res = req.headers(@hdr = [], rv)
+            return c.proxy_response_start(res, rv, req, self)
+          else # ugh, big headers or tricked response
+            # we must reinitialize the thread-local rbuf if it may
+            # live beyond the current thread
+            buf = Thread.current[:yahns_rbuf] = ''.dup
+            @resbuf = rv
+          end
+          # continue looping in middle "case @resbuf" loop
+        when :wait_readable
+          return rv # spurious wakeup
+        when nil
+          return c.proxy_err_response(502, self, 'upstream EOF (headers)')
+        end # NOT looping here
+
+      when String # continue reading trickled response headers from upstream
+
+        case rv = kgio_tryread(0x2000, buf)
+        when String then res = req.headers(@hdr, resbuf << rv) and break
+        when :wait_readable then return rv
+        when nil
+          return c.proxy_err_response(502, self, 'upstream EOF (big headers)')
+        end while true
+        @resbuf = false
+
+        return c.proxy_response_start(res, resbuf, req, self)
+
+      when Yahns::WbufCommon # streaming/buffering the response body
+
+        return c.proxy_response_finish(req, self)
+
+      end while true # case @resbuf
+
+    when Array # [ (str|vec), rack.input, chunked? ]
+      send_req_body(req) # returns nil or :wait_writable
+    when String # buffered request header
+      send_req_buf(req)
+    end
+  rescue => e
+    # avoid polluting logs with a giant backtrace when the problem isn't
+    # fixable in code.
+    case e
+    when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE
+      e.set_backtrace([])
+    end
+    c.proxy_err_response(502, self, e)
+  end
+
+  def send_req_body_chunk(buf)
+    case rv = String === buf ? kgio_trywrite(buf) : kgio_trywritev(buf)
+    when String, Array
+      buf.replace(rv) # retry loop on partial write
+    when :wait_writable, nil
+      # :wait_writable = upstream is reading slowly and making us wait
+      return rv
+    else
+      abort "BUG: #{rv.inspect} from kgio_trywrite*"
+    end while true
+  end
+
+  # returns :wait_readable if complete, :wait_writable if not
+  def send_req_body(req) # @rrstate == [ (str|vec), rack.input, chunked? ]
+    buf, input, chunked = req
+
+    # send the first buffered chunk or vector
+    rv = send_req_body_chunk(buf) and return rv # :wait_writable
+
+    # yay, sent the first chunk, now read the body!
+    rbuf = buf
+    if chunked
+      if String === buf # initial body
+        req[0] = buf = []
+      else
+        # try to reuse the biggest non-frozen buffer we just wrote;
+        rbuf = buf.max_by(&:size)
+        rbuf = ''.dup if rbuf.frozen? # unlikely...
+      end
+    end
+
+    # Note: input (env['rack.input']) is fully-buffered by default so
+    # we should not be waiting on a slow network resource when reading
+    # input.  However, some weird configs may disable this on LANs
+    # and we may wait indefinitely on input.read here...
+    while input.read(0x2000, rbuf)
+      if chunked
+        buf[0] = "#{rbuf.size.to_s(16)}\r\n".freeze
+        buf[1] = rbuf
+        buf[2] = "\r\n".freeze
+      end
+      rv = send_req_body_chunk(buf) and return rv # :wait_writable
+    end
+
+    rbuf.clear # all done, clear the big buffer
+
+    # we cannot use respond_to?(:close) here since Rack::Lint::InputWrapper
+    # tries to prevent that (and hijack means all Rack specs go out the door)
+    case input
+    when Yahns::TeeInput, IO
+      input.close
+    end
+
+    # note: we do not send any trailer, they are folded into the header
+    # because this relies on full request buffering
+    # prepare_wait_readable is called by send_req_buf
+    chunked ? send_req_buf("0\r\n\r\n".freeze) : prepare_wait_readable
+  rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN
+    # no more reading off the client socket, just prepare to forward
+    # the rejection response from the upstream (if any)
+    @yahns_client.to_io.shutdown(Socket::SHUT_RD)
+    prepare_wait_readable
+  end
+
+  def prepare_wait_readable
+    @rrstate = Kcar::Parser.new
+    :wait_readable # all done sending the request, wait for response
+  end
+
+  # n.b. buf must be a detached string not shared with
+  # Thread.current[:yahns_rbuf] of any thread
+  def send_req_buf(buf)
+    case rv = kgio_trywrite(buf)
+    when String
+      buf = rv # retry inner loop
+    when :wait_writable
+      @rrstate = buf
+      return :wait_writable
+    when nil
+      return prepare_wait_readable
+    end while true
+  end
+end # class ReqRes

data/lib/yahns/server.rb

@@ -496,7 +496,8 @@ class Yahns::Server # :nodoc:
   def dropping(fdmap)
     if drop_acceptors[0] || fdmap.size > 0
       timeout = @shutdown_expire < Yahns.now ? -1 : @shutdown_timeout
-      fdmap.desperate_expire(timeout)
+      n = fdmap.desperate_expire(timeout)
+      $0 = "yahns quitting, #{n} FD(s) remain"
       true
     else
       false

data/lib/yahns/server_mp.rb

@@ -159,7 +159,7 @@ module Yahns::ServerMP # :nodoc:
   def mp_sig_handle(watch, alive)
     # not performance critical
     watch.delete_if { |io| io.to_io.closed? }
-    if r = IO.select(watch, nil, nil, alive ? nil : 0.01)
+    if r = IO.select(watch, nil, nil, alive ? nil : 0.1)
       r[0].each(&:yahns_step)
     end
     case @sig_queue.shift

data/lib/yahns/version.rb

@@ -1 +1 @@
-Yahns::VERSION = '1.12.5'.freeze # :nodoc:
+Yahns::VERSION = '1.13.0'.freeze # :nodoc:

data/lib/yahns/wbuf.rb

@@ -31,15 +31,13 @@ require_relative 'wbuf_common'
 class Yahns::Wbuf # :nodoc:
   include Yahns::WbufCommon
   attr_reader :busy
-  attr_reader :wbuf_persist
 
-  def initialize(body, persist, tmpdir, busy)
+  def initialize(body, persist)
     @tmpio = nil
-    @tmpdir = tmpdir
     @sf_offset = @sf_count = 0
     @wbuf_persist = persist # whether or not we keep the connection alive
-    @body = body
-    @busy = busy # may be false
+    @body = body # something we call #close on when done writing
+    @busy = false
   end
 
   def wbuf_writev(buf)
@@ -59,7 +57,8 @@ class Yahns::Wbuf # :nodoc:
       @busy = rv
     end until @busy
 
-    @tmpio ||= Yahns::TmpIO.new(@tmpdir)
+    @tmpio ||= Yahns::TmpIO.new(c.class.output_buffer_tmpdir)
+    # n.b.: we rely on O_APPEND in TmpIO, here
     @sf_count += String === buf ? @tmpio.write(buf) : wbuf_writev(buf)
 
     # we spent some time copying to the FS, try to write to

data/lib/yahns/wbuf_common.rb

@@ -2,14 +2,6 @@
 # Copyright (C) 2013-2016 all contributors <yahns-public@yhbt.net>
 # License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
 # frozen_string_literal: true
-begin
-  raise LoadError, "SENDFILE_BROKEN env set" if ENV["SENDFILE_BROKEN"]
-  require 'sendfile'
-rescue LoadError
-  require_relative 'sendfile_compat'
-  IO.__send__ :include, Yahns::SendfileCompat
-end
-
 module Yahns::WbufCommon # :nodoc:
   # returns true / false for persistent/non-persistent connections
   # returns :wait_*able when blocked
@@ -19,7 +11,10 @@ module Yahns::WbufCommon # :nodoc:
   def wbuf_flush(client)
     case rv = client.trysendfile(@tmpio, @sf_offset, @sf_count)
     when Integer
-      return wbuf_close(client) if (@sf_count -= rv) == 0 # all sent!
+      if (@sf_count -= rv) == 0 # all sent!
+        @sf_offset = 0
+        return wbuf_close(client)
+      end
 
       @sf_offset += rv # keep going otherwise
     when :wait_writable, :wait_readable
@@ -48,7 +43,7 @@ module Yahns::WbufCommon # :nodoc:
     if @wbuf_persist.respond_to?(:call) # hijack
       client.response_hijacked(@wbuf_persist) # :ignore
     else
-      @wbuf_persist # true or false or Yahns::StreamFile
+      @wbuf_persist # true, false, :ignore, or Yahns::StreamFile
     end
   end
 end

data/lib/yahns/wbuf_lite.rb

@@ -0,0 +1,111 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2016 all contributors <yahns-public@yhbt.net>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
+# frozen_string_literal: true
+require 'stringio'
+require_relative 'wbuf_common'
+
+# This is only used for "proxy_buffering: false"
+class Yahns::WbufLite # :nodoc:
+  include Yahns::WbufCommon
+  attr_reader :busy
+  attr_writer :req_res
+
+  def initialize(req_res)
+    @tmpio = nil
+    @sf_offset = @sf_count = 0
+    @wbuf_persist = :ignore
+    @busy = false
+    @req_res = req_res
+  end
+
+  def wbuf_write(c, buf)
+    buf = buf.join if Array === buf
+    # try to bypass the VFS layer and write directly to the socket
+    # if we're all caught up
+    case rv = c.kgio_trywrite(buf)
+    when String
+      buf = rv # retry in loop
+    when nil
+      return # yay! hopefully we don't have to buffer again
+    when :wait_writable, :wait_readable
+      @busy = rv
+    end until @busy
+
+    @tmpio ||= StringIO.new(''.dup) # relies on encoding: binary above
+    @tmpio.seek(0, 2) # fake O_APPEND behavior
+    @sf_count += @tmpio.write(buf)
+
+    # we spent some time copying to the FS, try to write to
+    # the socket again in case some space opened up...
+    case rv = c.trysendio(@tmpio, @sf_offset, @sf_count)
+    when Integer
+      @sf_count -= rv
+      @sf_offset += rv
+    when :wait_writable, :wait_readable
+      @busy = rv
+      return rv
+    else
+      raise "BUG: #{rv.nil? ? 'EOF' : rv.inspect} on " \
+            "tmpio.size=#{@tmpio.size} " \
+            "sf_offset=#@sf_offset sf_count=#@sf_count"
+    end while @sf_count > 0
+
+    # we're all caught up, try to save some memory if we can help it.
+    wbuf_abort
+    @busy = false
+    nil
+  rescue
+    @req_res = @req_res.close if @req_res
+    raise
+  end
+
+  def wbuf_flush(client)
+    case rv = client.trysendio(@tmpio, @sf_offset, @sf_count)
+    when Integer
+      return wbuf_close(client) if (@sf_count -= rv) == 0 # all sent!
+      @sf_offset += rv # keep going otherwise
+    when :wait_writable, :wait_readable
+      return rv
+    else
+      raise "BUG: #{rv.nil? ? 'EOF' : rv.inspect} on " \
+            "tmpio.size=#{@tmpio.size} " \
+            "sf_offset=#@sf_offset sf_count=#@sf_count"
+    end while @sf_count > 0
+    wbuf_close(client)
+  rescue
+    @wbuf_persist = false # ensure a hijack response is not called
+    @req_res = @req_res.close if @req_res
+    wbuf_close(client)
+    raise
+  end
+
+  # called by Yahns::HttpClient#step_write
+  def wbuf_close(client)
+    wbuf_abort if @tmpio
+
+    # resume the event loop when @blocked is empty
+    # The actual Yahns::ReqRes#yahns_step is actually read/write-event
+    # agnostic, and we should actually watch for writability here since
+    # the req_res socket itself could be completely drained of readable
+    # data and just waiting for another request (which we don't support, yet)
+    if @req_res
+      @busy = false
+      client.hijack_cleanup
+      Thread.current[:yahns_queue].queue_mod(@req_res, Yahns::Queue::QEV_WR)
+      return :ignore
+    end
+    @wbuf_persist
+  rescue
+    @req_res = @req_res.close if @req_res
+    raise
+  end
+
+  def wbuf_abort
+    @sf_offset = @sf_count = 0
+    # we can safely truncate since this is a StringIO, we cannot do this
+    # with a real file because zero-copy with sendfile means truncating
+    # a while could clobber in-flight data
+    @tmpio.truncate(0)
+  end
+end

data/man/yahns-rackup.1

@@ -1,4 +1,4 @@
-.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16)
+.\" Automatically generated by Pod::Man 2.28 (Pod::Simple 3.28)
 .\"
 .\" Standard preamble:
 .\" ========================================================================
@@ -38,6 +38,8 @@
 .    ds PI \(*p
 .    ds L" ``
 .    ds R" ''
+.    ds C`
+.    ds C'
 'br\}
 .\"
 .\" Escape single quotes in literal strings from groff's Unicode transform.
@@ -48,17 +50,24 @@
 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
 .\" entries marked with X<> in POD.  Of course, you'll have to process the
 .\" output yourself in some meaningful fashion.
-.ie \nF \{\
-.    de IX
-.    tm Index:\\$1\t\\n%\t"\\$2"
+.\"
+.\" Avoid warning from groff about undefined register 'F'.
+.de IX
 ..
-.    nr % 0
-.    rr F
-.\}
-.el \{\
-.    de IX
+.nr rF 0
+.if \n(.g .if rF .nr rF 1
+.if (\n(rF:(\n(.g==0)) \{
+.    if \nF \{
+.        de IX
+.        tm Index:\\$1\t\\n%\t"\\$2"
 ..
+.        if !\nF==2 \{
+.            nr % 0
+.            nr F 2
+.        \}
+.    \}
 .\}
+.rr rF
 .\"
 .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
 .\" Fear.  Run.  Save yourself.  No user-serviceable parts.
@@ -124,7 +133,7 @@
 .\" ========================================================================
 .\"
 .IX Title "YAHNS-RACKUP 1"
-.TH YAHNS-RACKUP 1 "1994-10-02" "yahns 1.12.4.8.gd5d0" "yahns user manual"
+.TH YAHNS-RACKUP 1 "1994-10-02" "yahns 1.12.5.48.g013d" "yahns user manual"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
@@ -140,7 +149,7 @@ A \fIrackup\fR\|(1)\-like command to launch Rack applications using yahns.
 It is expected to start in your application root (\s-1APP_ROOT\s0).
 .SH "RACKUP FILE"
 .IX Header "RACKUP FILE"
-This defaults to \*(L"config.ru\*(R" in \s-1APP_ROOT\s0.  It should be the same
+This defaults to \*(L"config.ru\*(R" in \s-1APP_ROOT. \s0 It should be the same
 file used by \fIrackup\fR\|(1) and other Rack launchers, it uses the
 *Rack::Builder* \s-1DSL\s0 documented at:
 .PP
@@ -157,8 +166,8 @@ default timeout.  Lower this if you run out of FDs.
 Default: 15 (seconds)
 .IP "\-O listen=ADDRESS[,ADDRESS...]" 4
 .IX Item "-O listen=ADDRESS[,ADDRESS...]"
-Listens on a given \s-1ADDRESS\s0.  \s-1ADDRESS\s0 may be in the form of
-\&\s-1HOST:PORT\s0 or \s-1PATH\s0, \s-1HOST:PORT\s0 is taken to mean a \s-1TCP\s0 socket
+Listens on a given \s-1ADDRESS.  ADDRESS\s0 may be in the form of
+\&\s-1HOST:PORT\s0 or \s-1PATH, HOST:PORT\s0 is taken to mean a \s-1TCP\s0 socket
 and \s-1PATH\s0 is meant to be a path to a \s-1UNIX\s0 domain socket.
 Defaults to \*(L"0.0.0.0:9292\*(R" (all addresses on \s-1TCP\s0 port 9292).
 Multiple addresses may be separated with commas.
@@ -204,11 +213,11 @@ Unless specified via stderr_path and stdout_path, stderr and stdout will
 also be redirected to \*(L"/dev/null\*(R".
 .IP "\-E, \-\-env \s-1RACK_ENV\s0" 4
 .IX Item "-E, --env RACK_ENV"
-Run under the given \s-1RACK_ENV\s0.  See the \*(L"\s-1RACK\s0 \s-1ENVIRONMENT\s0\*(R" section
+Run under the given \s-1RACK_ENV. \s0 See the \*(L"\s-1RACK ENVIRONMENT\*(R"\s0 section
 for more details.
 .IP "\-o, \-\-host \s-1HOST\s0" 4
 .IX Item "-o, --host HOST"
-Listen on a \s-1TCP\s0 socket belonging to \s-1HOST\s0, default is
+Listen on a \s-1TCP\s0 socket belonging to \s-1HOST,\s0 default is
 \&\*(L"0.0.0.0\*(R" (all addresses).
 If specified multiple times on the command-line, only the
 last-specified value takes effect.
@@ -216,7 +225,7 @@ This option only exists for compatibility with the \fIrackup\fR\|(1) command,
 use of \*(L"\-l\*(R"/\*(L"\-\-listen\*(R" switch is recommended instead.
 .IP "\-p, \-\-port \s-1PORT\s0" 4
 .IX Item "-p, --port PORT"
-Listen on the specified \s-1TCP\s0 \s-1PORT\s0, default is 9292.
+Listen on the specified \s-1TCP PORT,\s0 default is 9292.
 If specified multiple times on the command-line, only the last-specified
 value takes effect.
 This option only exists for compatibility with the \fIrackup\fR\|(1) command,
@@ -256,24 +265,15 @@ See Rack documentation for a description of the rackup file format.
 The \s-1RACK_ENV\s0 variable is set by the aforementioned \-E switch.
 If \s-1RACK_ENV\s0 is already set, it will be used unless \-E is used.
 See rackup documentation for more details.
-.SH "CAVEATS"
-.IX Header "CAVEATS"
-yahns is strict about buggy, non-compliant Rack applications.
-Some existing servers work fine without \*(L"Content-Length\*(R" or
-\&\*(L"Transfer-Encoding: chunked\*(R" response headers enforced by Rack::Lint.
-Forgetting these headers with yahns causes clients to stall as they
-assume more data is coming.  Loading the Rack::ContentLength and/or
-Rack::Chunked middlewares will set the necessary response headers
-and fix your app.
 .SH "CONTACT"
 .IX Header "CONTACT"
-All feedback welcome via plain-text mail to mailto:yahns\-public@yhbt.net <mailto:yahns-public@yhbt.net>
+All feedback welcome via plain-text mail to <mailto:yahns\-public@yhbt.net>
 No subscription is necessary to post to the mailing list.
-List archives are available at http://yhbt.net/yahns\-public/ <http://yhbt.net/yahns-public/>
+List archives are available at <http://yhbt.net/yahns\-public/>
 .SH "COPYRIGHT"
 .IX Header "COPYRIGHT"
-Copyright (C) 2013\-2016 all contributors mailto:yahns\-public@yhbt.net <mailto:yahns-public@yhbt.net>
-License: \s-1GPL\-3\s0.0+ http://www.gnu.org/licenses/gpl\-3.0.txt <http://www.gnu.org/licenses/gpl-3.0.txt>
+Copyright (C) 2013\-2016 all contributors <mailto:yahns\-public@yhbt.net>
+License: \s-1GPL\-3.0+ \s0<http://www.gnu.org/licenses/gpl\-3.0.txt>
 .SH "SEE ALSO"
 .IX Header "SEE ALSO"
 \&\fIyahns\fR\|(1), \fIyahns_config\fR\|(5),