yahns 1.6.0 → 1.7.0

data/lib/yahns/proxy_pass.rb

@@ -0,0 +1,248 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013-2015 all contributors <yahns-public@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'socket'
+require 'kgio'
+require 'kcar' # gem install kcar
+require 'rack/request'
+require 'timeout'
+
+require_relative 'proxy_http_response'
+
+class Yahns::ProxyPass # :nodoc:
+  class ReqRes < Kgio::Socket
+    attr_writer :resbuf
+    attr_accessor :proxy_trailers
+
+    def req_start(c, req, input, chunked)
+      @hdr = @resbuf = nil
+      @yahns_client = c
+      @rrstate = input ? [ req, input, chunked ] : req
+      Thread.current[:yahns_queue].queue_add(self, Yahns::Queue::QEV_WR)
+    end
+
+    # we must reinitialize the thread-local rbuf if it may get beyond the
+    # current thread
+    def detach_rbuf!
+      Thread.current[:yahns_rbuf] = ''
+    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
+              buf = detach_rbuf!
+              @resbuf = rv
+            end
+            # continue looping in middle "case @resbuf" loop
+          when :wait_readable
+            return rv # spurious wakeup
+          when nil then return c.proxy_err_response(502, self, nil, nil)
+          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 then return c.proxy_err_response(502, self, nil, nil)
+          end while true
+
+          return c.proxy_response_start(res, resbuf, req, self)
+
+        when Yahns::WbufCommon # streaming/buffering the response body
+
+          return c.proxy_response_finish(req, resbuf, 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.
+      e.set_backtrace([]) if Errno::ECONNREFUSED === e
+      c.proxy_err_response(502, self, e, nil)
+    end
+
+    # returns :wait_readable if complete, :wait_writable if not
+    def send_req_body(req)
+      buf, input, chunked = req
+
+      # get the first buffered chunk or vector
+      case rv = String === buf ? kgio_trywrite(buf) : kgio_trywritev(buf)
+      when String, Array
+        buf = rv # retry inner loop
+      when :wait_writable
+        req[0] = buf
+        return :wait_writable
+      when nil
+        break # onto writing body
+      end while true
+
+      buf = Thread.current[:yahns_rbuf]
+
+      # 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
+
+      if chunked
+        while input.read(0x2000, buf)
+          vec = [ "#{buf.size.to_s(16)}\r\n", buf, "\r\n".freeze ]
+          case rv = kgio_trywritev(vec)
+          when Array
+            vec = rv # partial write, retry in case loop
+          when :wait_writable
+            detach_rbuf!
+            req[0] = vec
+            return :wait_writable
+          when nil
+            break # continue onto reading next chunk
+          end while true
+        end
+        close_req_body(input)
+
+        # note: we do not send any trailer, they are folded into the header
+        # because this relies on full request buffering
+        send_req_buf("0\r\n\r\n".freeze)
+        # prepare_wait_readable already called by send_req_buf
+      else # identity request, easy:
+        while input.read(0x2000, buf)
+          case rv = kgio_trywrite(buf)
+          when String
+            buf = rv # partial write, retry in case loop
+          when :wait_writable
+            detach_rbuf!
+            req[0] = buf
+            return :wait_writable
+          when nil
+            break # continue onto reading next block
+          end while true
+        end
+
+        close_req_body(input)
+        prepare_wait_readable
+      end
+    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
+
+    def close_req_body(input)
+      case input
+      when Yahns::TeeInput, IO, StringIO
+        input.close
+      end
+    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
+
+  def initialize(dest)
+    case dest
+    when %r{\Aunix:([^:]+)(?::(/.*))?\z}
+      path = $2
+      @sockaddr = Socket.sockaddr_un($1)
+    when %r{\Ahttp://([^/]+)(/.*)?\z}
+      path = $2
+      host, port = $1.split(':')
+      @sockaddr = Socket.sockaddr_in(port || 80, host)
+    else
+      raise ArgumentError, "destination must be an HTTP URL or unix: path"
+    end
+    init_path_vars(path)
+  end
+
+  def init_path_vars(path)
+    path ||= '$fullpath'
+    # methods from Rack::Request we want:
+    allow = %w(fullpath host_with_port host port url path)
+    want = path.scan(/\$(\w+)/).flatten! || []
+    diff = want - allow
+    diff.empty? or
+             raise ArgumentError, "vars not allowed: #{diff.uniq.join(' ')}"
+
+    # kill leading slash just in case...
+    @path = path.gsub(%r{\A/(\$(?:fullpath|path))}, '\1')
+  end
+
+  def call(env)
+    # 3-way handshake for TCP backends while we generate the request header
+    rr = ReqRes.start(@sockaddr)
+    c = env['rack.hijack'].call
+
+    req = Rack::Request.new(env)
+    req = @path.gsub(/\$(\w+)/) { req.__send__($1) }
+
+    # start the connection asynchronously and early so TCP can do a
+    case ver = env['HTTP_VERSION']
+    when 'HTTP/1.1' # leave alone, response may be chunked
+    else # no chunking for HTTP/1.0 and HTTP/0.9
+      ver = 'HTTP/1.0'.freeze
+    end
+
+    req = "#{env['REQUEST_METHOD']} #{req} #{ver}\r\n" \
+          "X-Forwarded-For: #{env["REMOTE_ADDR"]}\r\n"
+
+    # pass most HTTP_* headers through as-is
+    chunked = false
+    env.each do |key, val|
+      %r{\AHTTP_(\w+)\z} =~ key or next
+      key = $1
+      # trailers are folded into the header, so do not send the Trailer:
+      # header in the request
+      next if /\A(?:VERSION|CONNECTION|KEEP_ALIVE|X_FORWARDED_FOR|TRAILER)/ =~
+         key
+      'TRANSFER_ENCODING'.freeze == key && val =~ /\bchunked\b/i and
+        chunked = true
+      key.tr!('_'.freeze, '-'.freeze)
+      req << "#{key}: #{val}\r\n"
+    end
+
+    # special cases which Rack does not prefix:
+    ctype = env["CONTENT_TYPE"] and req << "Content-Type: #{ctype}\r\n"
+    clen = env["CONTENT_LENGTH"] and req << "Content-Length: #{clen}\r\n"
+    input = chunked || (clen && clen.to_i > 0) ? env['rack.input'] : nil
+
+    # finally, prepare to emit the headers
+    rr.req_start(c, req << "\r\n".freeze, input, chunked)
+
+    # this probably breaks fewer middlewares than returning whatever else...
+    [ 500, [], [] ]
+  rescue => e
+    Yahns::Log.exception(env['rack.logger'], 'proxy_pass', e)
+    [ 502, { 'Content-Length' => '0', 'Content-Type' => 'text/plain' }, [] ]
+  end
+end

data/lib/yahns/queue_epoll.rb

@@ -27,20 +27,14 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
     epoll_ctl(Epoll::CTL_ADD, io, flags)
   end
 
+  def queue_mod(io, flags)
+    epoll_ctl(Epoll::CTL_MOD, io, flags)
+  end
+
   def thr_init
     Thread.current[:yahns_rbuf] = ""
     Thread.current[:yahns_fdmap] = @fdmap
-  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)
-    # 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)
+    Thread.current[:yahns_queue] = self
   end
 
   # returns an array of infinitely running threads
@@ -64,13 +58,13 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
             # expected to work, so we had to erase it from fdmap before hijack
           when nil, :close
             # this must be the ONLY place where we call IO#close on
-            # things that got inside the queue
+            # things that got inside the queue AND fdmap
             @fdmap.sync_close(io)
           else
             raise "BUG: #{io.inspect}#yahns_step returned: #{rv.inspect}"
           end
         end
-      rescue => e
+      rescue StandardError, LoadError, SyntaxError => e
         break if closed? # can still happen due to shutdown_timeout
         Yahns::Log.exception(logger, 'queue loop', e)
       end while true

data/lib/yahns/queue_kqueue.rb

@@ -36,15 +36,14 @@ class Yahns::Queue < SleepyPenguin::Kqueue::IO # :nodoc:
     kevent(Kevent[io.fileno, flags, fflags, 0, 0, io])
   end
 
+  def queue_mod(io, flags)
+    kevent(Kevent[io.fileno, flags, ADD_ONESHOT, 0, 0, io])
+  end
+
   def thr_init
     Thread.current[:yahns_rbuf] = ""
     Thread.current[:yahns_fdmap] = @fdmap
-  end
-
-  def queue_del(io)
-    # do not bother with kevent EV_DELETE, it may be tricky to get right,
-    # we only did it in epoll since Eric knows the epoll internals well.
-    @fdmap.forget(io)
+    Thread.current[:yahns_queue] = self
   end
 
   # returns an array of infinitely running threads
@@ -67,13 +66,13 @@ class Yahns::Queue < SleepyPenguin::Kqueue::IO # :nodoc:
             # expected to work, so we had to erase it from fdmap before hijack
           when nil, :close
             # this must be the ONLY place where we call IO#close on
-            # things that got inside the queue
+            # things that got inside the queue AND fdmap
             @fdmap.sync_close(io)
           else
             raise "BUG: #{io.inspect}#yahns_step returned: #{rv.inspect}"
           end
         end
-      rescue => e
+      rescue StandardError, LoadError, SyntaxError => e
         break if closed? # can still happen due to shutdown_timeout
         Yahns::Log.exception(logger, 'queue loop', e)
       end while true

data/lib/yahns/rackup_handler.rb

@@ -32,7 +32,6 @@ module Yahns::RackupHandler # :nodoc:
       end
 
       %w(stderr_path stdout_path).each do |x|
-        x = x.to_sym
         val = o[x] and __send__(x, val)
       end
     end

data/lib/yahns/socket_helper.rb

@@ -8,7 +8,7 @@ module Yahns::SocketHelper # :nodoc:
   def so_reuseport
     if defined?(Socket::SO_REUSEPORT)
       Socket::SO_REUSEPORT
-    elsif RUBY_PLATFORM =~ /linux/
+    elsif RUBY_PLATFORM.include?('linux')
       15 # only tested on x86_64 and i686
     else
       nil
@@ -108,7 +108,7 @@ module Yahns::SocketHelper # :nodoc:
   # returns rfc2732-style (e.g. "[::1]:666") addresses for IPv6
   def tcp_name(sock)
     port, addr = Socket.unpack_sockaddr_in(sock.getsockname)
-    /:/ =~ addr ? "[#{addr}]:#{port}" : "#{addr}:#{port}"
+    addr.include?(':') ? "[#{addr}]:#{port}" : "#{addr}:#{port}"
   end
 
   # Returns the configuration name of a socket as a string.  sock may

data/lib/yahns/tee_input.rb

@@ -19,7 +19,7 @@ class Yahns::TeeInput < Yahns::StreamInput # :nodoc:
   def initialize(client, request)
     @len = request.content_length
     super
-    @tmp = client.class.tmpio_for(@len)
+    @tmp = client.class.tmpio_for(@len, request.env)
   end
 
   # :call-seq:

data/lib/yahns/tmpio.rb

@@ -7,14 +7,15 @@ require 'tmpdir'
 # well with unlinked files.  This one is much shorter, easier
 # to understand, and slightly faster (no delegation).
 class Yahns::TmpIO < File # :nodoc:
+  include Kgio::PipeMethods
 
   # creates and returns a new File object.  The File is unlinked
   # immediately, switched to binary mode, and userspace output
   # buffering is disabled
-  def self.new(tmpdir = Dir.tmpdir)
+  def self.new(dir)
     retried = false
     begin
-      fp = super("#{tmpdir}/#{rand}", RDWR|CREAT|EXCL|APPEND, 0600)
+      fp = super("#{dir || Dir.tmpdir}/#{rand}", RDWR|CREAT|EXCL|APPEND, 0600)
     rescue Errno::EEXIST
       retry
     rescue Errno::EMFILE, Errno::ENFILE
@@ -29,4 +30,7 @@ class Yahns::TmpIO < File # :nodoc:
     fp.sync = true
     fp
   end
+
+  # pretend we're Tempfile for Rack::TempfileReaper
+  alias close! close
 end

data/lib/yahns/wbuf.rb

@@ -29,34 +29,46 @@ require_relative 'wbuf_common'
 # to be a scalability issue.
 class Yahns::Wbuf # :nodoc:
   include Yahns::WbufCommon
+  attr_reader :busy
+  attr_reader :wbuf_persist
 
-  def initialize(body, persist, tmpdir)
+  def initialize(body, persist, tmpdir, busy)
     @tmpio = nil
     @tmpdir = tmpdir
     @sf_offset = @sf_count = 0
     @wbuf_persist = persist # whether or not we keep the connection alive
     @body = body
-    @bypass = false
+    @busy = busy # may be false
   end
 
-  def wbuf_write(client, buf)
-    # try to bypass the VFS layer if we're all caught up
-    case rv = client.kgio_trywrite(buf)
-    when String
+  def wbuf_writev(buf)
+    @tmpio.kgio_writev(buf)
+    buf.inject(0) { |n, s| n += s.size }
+  end
+
+  def wbuf_write(c, buf)
+    # try to bypass the VFS layer and write directly to the socket
+    # if we're all caught up
+    case rv = String === buf ? c.kgio_trywrite(buf) : c.kgio_trywritev(buf)
+    when String, Array
       buf = rv # retry in loop
     when nil
       return # yay! hopefully we don't have to buffer again
     when :wait_writable, :wait_readable
-      @bypass = false # ugh, continue to buffering to file
-    end while @bypass
+      @busy = rv
+    end until @busy
 
     @tmpio ||= Yahns::TmpIO.new(@tmpdir)
-    @sf_count += @tmpio.write(buf)
-    case rv = client.trysendfile(@tmpio, @sf_offset, @sf_count)
+    @sf_count += String === buf ? @tmpio.write(buf) : wbuf_writev(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.trysendfile(@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 " \
@@ -65,15 +77,19 @@ class Yahns::Wbuf # :nodoc:
 
     # we're all caught up, try to prevent dirty data from getting flushed
     # to disk if we can help it.
-    @tmpio = @tmpio.close
+    wbuf_abort
     @sf_offset = 0
-    @bypass = true
+    @busy = false
     nil
   end
 
   # called by last wbuf_flush
   def wbuf_close(client)
-    @tmpio = @tmpio.close if @tmpio
+    wbuf_abort
     wbuf_close_common(client)
   end
+
+  def wbuf_abort
+    @tmpio = @tmpio.close if @tmpio
+  end
 end