yahns 1.12.3 → 1.12.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be964a6d1a0a80744bd419b896f4aa83cdadbd06
-  data.tar.gz: 907c5f15f7d6c2d49609326b1a8175d56a09cad7
+  metadata.gz: 9dc252e71729c27f38d5ef8bb6f82274d80408e5
+  data.tar.gz: ba8aa4cbf09b75919f065ba64924f1f6e76603d8
 SHA512:
-  metadata.gz: 7bb344b77483d6fbb091b721fcc7b7d6f789738aa8552f7c7b85e856ca15b2edd2dd12b299b5af80a5d1484bded048c31599c5c187433bbf37987910a6effd47
-  data.tar.gz: 0d1226f4bddf82eb366f71d020cafaedf0b7a0b63eed07792588d902f14aaf26cebee084d8e07379455bf91c1653823887ad35234d20abb09c6581aaab7818b1
+  metadata.gz: d768bd39c63353df5d086f6a5c1dfcb7c5e4725b4198ac2bf273a2c43865b3f804a1c4cd0d029bc8b95dc0eb4ecde6803e49a56eeba936df50da11a5458896ed
+  data.tar.gz: e0a962d0514d0c0fd19ab83b3109c0b75ed07e551900c87307c0fba8300b346b1bedd9bb84036ede20ce0bc55fff509c1306e53f5c0074e0aa2e0e58ca8da10b

data/Documentation/yahns-rackup.pod

@@ -159,6 +159,16 @@ The RACK_ENV variable is set by the aforementioned -E switch.
 If RACK_ENV is already set, it will be used unless -E is used.
 See rackup documentation for more details.
 
+=head1 CAVEATS
+
+yahns is strict about buggy, non-compliant Rack applications.
+Some existing servers work fine without "Content-Length" or
+"Transfer-Encoding: chunked" 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.
+
 =head1 CONTACT
 
 All feedback welcome via plain-text mail to L<mailto:yahns-public@yhbt.net>

data/GIT-VERSION-GEN

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

data/examples/yahns_rack_basic.conf.rb

@@ -30,6 +30,12 @@
   worker_threads 50
 end
 
+# note: Rack requires responses set "Content-Length" or use
+# "Transfer-Encoding: chunked".  Some Rack servers tolerate
+# the lack of these, yahns does not.  Thus you should load
+# Rack::Chunked and/or Rack::ContentLength middleware in your
+# config.ru to ensure clients know when your application
+# responses terminate.
 app(:rack, "config.ru", preload: false) do
   listen 80
 

data/extras/exec_cgi.rb

@@ -12,6 +12,14 @@
 #  (delfater: ensure that parent body is always closed)
 # Otherwise you will get zombies from HEAD requests which accept compressed
 # responses.
+#
+# Usage in config.ru using cgit as an example:
+#
+#   use Rack::Chunked
+#   # other Rack middlewares can go here...
+#
+#   run ExecCgi.new('/path/to/cgit.cgi') # cgit: https://git.zx2c4.com/cgit/
+#
 class ExecCgi
   class MyIO < Kgio::Pipe
     attr_writer :my_pid

data/lib/yahns/proxy_http_response.rb

@@ -43,7 +43,12 @@ def proxy_err_response(code, req_res, exc, wbuf)
                      Rack::Utils::HTTP_STATUS_CODES[code]}\r\n\r\n") rescue nil
 
     shutdown rescue nil
-    req_res.shutdown rescue nil
+    @input = @input.close if @input
+
+    # this is safe ONLY because we are in an :ignore state after
+    # Fdmap#forget when we got hijacked:
+    close
+
     nil # signal close of req_res from yahns_step in yahns/proxy_pass.rb
   ensure
     wbuf.wbuf_abort if wbuf
@@ -56,6 +61,7 @@ def wait_on_upstream(req_res, alive, wbuf)
     :wait_readable # self remains in :ignore, wait on upstream
   end
 
+  # start streaming the response once upstream is done sending headers to us.
   # returns :wait_readable if we need to read more from req_res
   # returns :ignore if we yield control to the client(self)
   # returns nil if completely done
@@ -101,7 +107,6 @@ def proxy_response_start(res, tip, kcar, req_res)
     # but the backend does not terminate properly
     if alive && ! term && (env['HTTP_VERSION'] == 'HTTP/1.1'.freeze)
       res << "Transfer-Encoding: chunked\r\n".freeze
-      alive = true
     end
     res << (alive ? "Connection: keep-alive\r\n\r\n".freeze
                   : "Connection: close\r\n\r\n".freeze)
@@ -168,6 +173,7 @@ def proxy_response_start(res, tip, kcar, req_res)
           tmp = chunk_out(tmp) if alive
           wbuf = proxy_write(wbuf, tmp, alive)
         when nil
+          wbuf = proxy_write(wbuf, "0\r\n\r\n".freeze, true) if alive
           req_res.shutdown
           break
         when :wait_readable
@@ -177,16 +183,15 @@ def proxy_response_start(res, tip, kcar, req_res)
       end
     end
 
-    return proxy_busy_mod_done(alive) unless wbuf
-    req_res.resbuf = wbuf
-    proxy_busy_mod_blocked(wbuf, wbuf.busy)
+    # all done reading response from upstream, req_res will be discarded
+    # when we return nil:
+    wbuf ? proxy_busy_mod_blocked(wbuf, wbuf.busy) : proxy_busy_mod_done(alive)
   rescue => e
     proxy_err_response(502, req_res, e, wbuf)
   end
 
   def proxy_response_finish(kcar, wbuf, req_res)
     rbuf = Thread.current[:yahns_rbuf]
-    alive = wbuf.wbuf_persist
     if len = kcar.body_bytes_left # known Content-Length
 
       case tmp = req_res.kgio_tryread(0x2000, rbuf)
@@ -232,6 +237,7 @@ def proxy_response_finish(kcar, wbuf, req_res)
 
     else # no Content-Length or Transfer-Encoding: chunked, wait on EOF!
 
+      alive = wbuf.wbuf_persist
       case tmp = req_res.kgio_tryread(0x2000, rbuf)
       when String
         tmp = chunk_out(tmp) if alive
@@ -247,7 +253,7 @@ def proxy_response_finish(kcar, wbuf, req_res)
     end
 
     busy = wbuf.busy and return proxy_busy_mod_blocked(wbuf, busy)
-    proxy_busy_mod_done(alive) # returns nil
+    proxy_busy_mod_done(wbuf.wbuf_persist) # returns nil to close req_res
   end
 
   def proxy_wait_next(qflags)
@@ -288,23 +294,23 @@ def proxy_busy_mod_done(alive)
     when :close then close
     end
 
-    nil # close the req_res, too
+    nil # signal close for ReqRes#yahns_step
   end
 
   def proxy_busy_mod_blocked(wbuf, busy)
-    q = Thread.current[:yahns_queue]
     # we are completely done reading and buffering the upstream response,
     # but have not completely written the response to the client,
     # yield control to the client socket:
     @state = wbuf
-    case busy
-    when :wait_readable then q.queue_mod(self, Yahns::Queue::QEV_RD)
-    when :wait_writable then q.queue_mod(self, Yahns::Queue::QEV_WR)
-    else
-      abort "BUG: invalid wbuf.busy: #{busy.inspect}"
-    end
-    # no touching self after queue_mod
-    :ignore
+    proxy_wait_next(case busy
+      when :wait_readable then Yahns::Queue::QEV_RD
+      when :wait_writable then Yahns::Queue::QEV_WR
+      else
+        abort "BUG: invalid wbuf.busy: #{busy.inspect}"
+      end)
+    # no touching self after proxy_wait_next, we may be running
+    # HttpClient#yahns_step in a different thread at this point
+    nil # signal close for ReqRes#yahns_step
   end
 
   # n.b.: we can use String#size for optimized dispatch under YARV instead

data/lib/yahns/proxy_pass.rb

@@ -63,7 +63,8 @@ def yahns_step # yahns event loop entry point
 
         when Yahns::WbufCommon # streaming/buffering the response body
 
-          return c.proxy_response_finish(req, resbuf, self)
+          # we assign wbuf for rescue below:
+          return c.proxy_response_finish(req, wbuf = resbuf, self)
 
         end while true # case @resbuf
 
@@ -79,7 +80,7 @@ def yahns_step # yahns event loop entry point
       when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE
         e.set_backtrace([])
       end
-      c.proxy_err_response(502, self, e, nil)
+      c.proxy_err_response(502, self, e, wbuf)
     end
 
     # returns :wait_readable if complete, :wait_writable if not

data/lib/yahns/wbuf_common.rb

@@ -38,6 +38,7 @@ def wbuf_flush(client)
     end while @sf_count > 0
     wbuf_close(client)
   rescue
+    @wbuf_persist = false # ensure a hijack response is not called
     wbuf_close(client)
     raise
   end

data/test/test_proxy_pass.rb

@@ -586,6 +586,21 @@ def check_eof_body(host, port)
       assert_match %r{\AHTTP/1\.1 200 OK\r\n}, res
       assert_match %r{\r\n\r\neof-body-slow\z}, res
       s.close
+
+      # we auto-chunk on 1.1 requests and 1.0 backends
+      %w(eof-body-slow eof-body-fast).each do |x|
+        s = TCPSocket.new(host, port)
+        s.write("GET /#{x} HTTP/1.1\r\nHost: example.com\r\n\r\n")
+        res = ''.dup
+        res << s.readpartial(512) until res =~ /0\r\n\r\n\z/
+        s.close
+        head, body = res.split("\r\n\r\n", 2)
+        head = head.split("\r\n")
+        assert_equal 'HTTP/1.1 200 OK', head[0]
+        assert head.include?('Connection: keep-alive')
+        assert head.include?('Transfer-Encoding: chunked')
+        assert_match %r{\Ad\r\n#{x}\r\n0\r\n\r\n\z}, body
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yahns
 version: !ruby/object:Gem::Version
-  version: 1.12.3
+  version: 1.12.4
 platform: ruby
 authors:
 - yahns hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-08 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kgio