yahns 1.14.1 → 1.18.0

data/lib/yahns/http_response.rb

@@ -46,10 +46,9 @@ module Yahns::HttpResponse # :nodoc:
     @hs.response_start_sent ? ''.freeze : 'HTTP/1.1 '.freeze
   end
 
-  def response_wait_write(rv)
-    # call the kgio_wait_readable or kgio_wait_writable method
-    ok = __send__("kgio_#{rv}") and return ok
+  def response_wait_write(rv) # rv = [:wait_writable | :wait_readable ]
     k = self.class
+    ok = __send__(rv, k.client_timeout) and return ok
     k.logger.info("fd=#{fileno} ip=#@kgio_addr timeout on :#{rv} after "\
                   "#{k.client_timeout}s")
     false
@@ -200,7 +199,7 @@ module Yahns::HttpResponse # :nodoc:
       return step_write
     end
 
-    wbuf = rv = nil
+    headers = wbuf = rv = nil
     body.each do |x|
       if wbuf
         rv = wbuf.wbuf_write(self, x)

data/lib/yahns/openssl_client.rb

@@ -40,15 +40,31 @@ module Yahns::OpenSSLClient # :nodoc:
   def kgio_trywrite(buf)
     len = buf.bytesize
     return if len == 0
-    buf = @ssl_blocked = buf.dup
+
+    case @ssl_blocked
+    when nil # likely
+      buf = @ssl_blocked = buf.dup
+    when Exception
+      raise @ssl_blocked
+    when String
+      if @ssl_blocked != buf
+        pfx = object_id
+        warn("#{pfx} BUG: ssl_blocked != buf\n" \
+             "#{pfx} ssl_blocked=#{@ssl_blocked.inspect}\n" \
+             "#{pfx} buf=#{buf.inspect}\n")
+        raise 'BUG: ssl_blocked} != buf'
+      end
+    end
+
     case rv = @ssl.write_nonblock(buf, exception: false)
     when :wait_readable, :wait_writable
-      return rv # do not clear ssl_blocked
+      rv # do not clear ssl_blocked
     when Integer
-      rv = len == rv ? nil : buf.byteslice(rv, len - rv)
+      @ssl_blocked = len == rv ? nil : buf.byteslice(rv, len - rv)
     end
-    @ssl_blocked = nil
-    rv
+  rescue SystemCallError => e # ECONNRESET/EPIPE
+    e.set_backtrace([])
+    raise(@ssl_blocked = e)
   end
 
   def kgio_trywritev(buf)
@@ -75,22 +91,28 @@ module Yahns::OpenSSLClient # :nodoc:
   def trysendio(io, offset, count)
     return 0 if count == 0
 
-    unless buf = @ssl_blocked
-      count = 0x4000 if count > 0x4000
-      buf = Thread.current[:yahns_sfbuf] ||= ''.dup
-      io.pos = offset
-      buf = io.read(count, buf) or return # nil for EOF
+    case buf = @ssl_blocked
+    when nil
+      buf = do_pread(io, count, offset) or return # nil for EOF
       buf = @ssl_blocked = buf.dup
+    when Exception
+      raise buf
+    # when String # just use it as-is
     end
 
     # call write_nonblock directly since kgio_trywrite allocates
     # an unnecessary string
+    len = buf.size
     case rv = @ssl.write_nonblock(buf, exception: false)
     when :wait_readable, :wait_writable
       return rv # do not clear ssl_blocked
+    when Integer
+      @ssl_blocked = len == rv ? nil : buf.byteslice(rv, len - rv)
     end
-    @ssl_blocked = nil
     rv
+  rescue SystemCallError => e # ECONNRESET/EPIPE
+    e.set_backtrace([])
+    raise(@ssl_blocked = e)
   end
 
   def shutdown # we never call this with a how=SHUT_* arg

data/lib/yahns/proxy_http_response.rb

@@ -132,7 +132,9 @@ module Yahns::HttpResponse # :nodoc:
 
     # send the headers
     case rv = kgio_syssend(res, flags)
-    when nil then break # all done, likely
+    when nil # all done, likely
+      res.clear
+      break
     when String # partial write, highly unlikely
       flags = MSG_DONTWAIT
       res = rv # hope the skb grows

data/lib/yahns/proxy_pass.rb

@@ -1,18 +1,76 @@
 # -*- 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)
+# Copyright (C) 2013-2019 all contributors <yahns-public@yhbt.net>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require 'socket'
 require 'rack/request'
-require 'timeout'
-
+require 'timeout' # only for Timeout::Error
 require_relative 'proxy_http_response'
 require_relative 'req_res'
 
-class Yahns::ProxyPass # :nodoc:
-  attr_reader :proxy_buffering, :response_headers
+# Yahns::ProxyPass is a Rack (hijack) app which allows yahns to
+# act as a fully-buffering reverse proxy to protect backends
+# from slow HTTP clients.
+#
+# Yahns::ProxyPass relies on the default behavior of yahns to do
+# full input and output buffering. Output buffering is lazy,
+# meaning it allows streaming output in the best case and
+# will only buffer if the client cannot keep up with the server.
+#
+# The goal of this reverse proxy is to act as a sponge on the same LAN
+# or host to any backend HTTP server not optimized for slow clients.
+# Yahns::ProxyPass accomplishes this by handling all the slow clients
+# internally within yahns itself to minimize time spent in the backend
+# HTTP server waiting on slow clients.
+#
+# It does not do load balancing (we rely on Varnish for that).
+# Here is the exact config we use with Varnish, which uses
+# the +:response_headers+ option to hide some Varnish headers
+# from clients:
+#
+#    run Yahns::ProxyPass.new('http://127.0.0.1:6081',
+#            response_headers: {
+#              'Age' => :ignore,
+#              'X-Varnish' => :ignore,
+#              'Via' => :ignore
+#            })
+#
+# This is NOT a generic Rack app and must be run with yahns.
+# It uses +rack.hijack+, so compatibility with logging
+# middlewares (e.g. Rack::CommonLogger) is not great and
+# timing information gets lost.
+#
+# This provides HTTPS termination for our mail archives:
+# https://yhbt.net/yahns-public/
+#
+# See https://yhbt.net/yahns.git/tree/examples/https_proxy_pass.conf.rb
+# and https://yhbt.net/yahns.git/tree/examples/proxy_pass.ru for examples
+class Yahns::ProxyPass
+  attr_reader :proxy_buffering, :response_headers # :nodoc:
 
-  def initialize(dest, opts = {})
+  # +dest+ must be an HTTP URL with optional variables prefixed with '$'.
+  # +dest+ may refer to the path to a Unix domain socket in the form:
+  #
+  #     unix:/absolute/path/to/socket
+  #
+  # Variables which may be used in the +dest+ parameter include:
+  #
+  # - $url - the entire URL used to make the request
+  # - $path - the unescaped PATH_INFO of the HTTP request
+  # - $fullpath - $path with QUERY_STRING
+  # - $host - the hostname in the Host: header
+  #
+  # For Unix domain sockets, variables may be separated from the
+  # socket path via: ":/".  For example:
+  #
+  #     unix:/absolute/path/to/socket:/$host/$fullpath
+  #
+  # Currently :response_headers is the only +opts+ supported.
+  # :response_headers is a Hash containing a "from => to" mapping
+  # of response headers.  The special value of +:ignore+ indicates
+  # the header from the backend HTTP server will be ignored instead
+  # of being blindly passed on to the client.
+  def initialize(dest, opts = { response_headers: { 'Server' => :ignore } })
     case dest
     when %r{\Aunix:([^:]+)(?::(/.*))?\z}
       path = $2
@@ -35,7 +93,7 @@ class Yahns::ProxyPass # :nodoc:
     init_path_vars(path)
   end
 
-  def init_path_vars(path)
+  def init_path_vars(path) # :nodoc:
     path ||= '$fullpath'
     # methods from Rack::Request we want:
     allow = %w(fullpath host_with_port host port url path)
@@ -48,10 +106,10 @@ class Yahns::ProxyPass # :nodoc:
     @path = path.gsub(%r{\A/(\$(?:fullpath|path))}, '\1')
   end
 
-  def call(env)
+  def call(env) # :nodoc:
     # 3-way handshake for TCP backends while we generate the request header
     rr = Yahns::ReqRes.start(@sockaddr)
-    c = env['rack.hijack'].call
+    c = env['rack.hijack'].call # Yahns::HttpClient#call
 
     req = Rack::Request.new(env)
     req = @path.gsub(/\$(\w+)/) { req.__send__($1) }

data/lib/yahns/queue_epoll.rb

@@ -32,6 +32,10 @@ class Yahns::Queue < SleepyPenguin::Epoll::IO # :nodoc:
     epoll_ctl(Epoll::CTL_MOD, io, flags)
   end
 
+  def queue_del(io)
+    epoll_ctl(Epoll::CTL_DEL, io, 0)
+  end
+
   def thr_init
     Thread.current[:yahns_rbuf] = ''.dup
     Thread.current[:yahns_fdmap] = @fdmap

data/lib/yahns/queue_kqueue.rb

@@ -17,12 +17,6 @@ class Yahns::Queue < SleepyPenguin::Kqueue::IO # :nodoc:
 
   ADD_ONESHOT = Ev::ADD | Ev::ONESHOT # private
 
-  def self.new
-    rv = super
-    rv.close_on_exec = true
-    rv
-  end
-
   # 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)

data/lib/yahns/queue_quitter_pipe.rb

@@ -7,7 +7,6 @@ class Yahns::QueueQuitter # :nodoc:
   attr_reader :to_io
   def initialize
     @reader, @to_io = IO.pipe
-    @to_io.close_on_exec = true
   end
 
   def yahns_step
@@ -22,4 +21,8 @@ class Yahns::QueueQuitter # :nodoc:
     @reader.close
     @to_io.close
   end
+
+  def closed?
+    @to_io.closed?
+  end
 end

data/lib/yahns/rackup_handler.rb

@@ -16,14 +16,10 @@ module Yahns::RackupHandler # :nodoc:
       # fine for most apps, but we have SIGUSR2 restarts to support
       working_directory(Yahns::START[:cwd])
 
-      app(:rack, app) do
+      app(:rack, app) do # Yahns::Config#app
         addr = o[:listen] || "#{o[:Host]||default_host}:#{o[:Port]||8080}"
-        # allow listening to multiple addresses
-        if addr.include?(',')
-          addr.split(',').each { |l| listen(l) }
-        else
-          listen addr
-        end
+        # allow listening to multiple addresses (Yahns::Config#listen)
+        addr.split(',').each { |l| listen(l) } unless addr == 'inherit'
 
         val = o[:client_timeout] and client_timeout(val)
       end

data/lib/yahns/server.rb

@@ -237,24 +237,23 @@ class Yahns::Server # :nodoc:
       end
     end
 
-    # We cannot use Process.spawn here because of redirects + close-on-exec
-    # We must keep close_on_exec=true in the parent process and only set
-    # close_on_exec=false in the child.  There must be no opportunity
-    # for the user app to ever get a listen socket with close_on_exec=false
-    @reexec_pid = fork do
-      redirects = {}
-      @listeners.each do |sock|
-        sock.close_on_exec = false
-        redirects[sock.fileno] = sock
+    opt = {}
+    @listeners.each { |sock| opt[sock.fileno] = sock }
+    env = ENV.to_hash
+    env['YAHNS_FD'] = opt.keys.join(',')
+    opt[:close_others] = true
+    cmd = [ Yahns::START[0] ].concat(Yahns::START[:argv])
+    dir = @config.value(:working_directory) || Yahns::START[:cwd]
+    @logger.info "spawning #{cmd.inspect} (in #{dir})"
+    @reexec_pid = if @before_exec
+      fork do
+        Dir.chdir(dir)
+        @before_exec.call(cmd)
+        exec(env, *cmd, opt)
       end
-      ENV['YAHNS_FD'] = redirects.keys.join(',')
-      redirects[:close_others] = true
-      Dir.chdir(@config.value(:working_directory) || Yahns::START[:cwd])
-      cmd = [ Yahns::START[0] ].concat(Yahns::START[:argv])
-      @logger.info "executing #{cmd.inspect} (in #{Dir.pwd})"
-      @before_exec.call(cmd) if @before_exec
-      cmd << redirects
-      exec(*cmd)
+    else
+      opt[:chdir] = dir
+      spawn(env, *cmd, opt)
     end
   end
 
@@ -328,7 +327,9 @@ class Yahns::Server # :nodoc:
       opts = sock_opts(io)
       io = server_cast(io, opts)
       set_server_sockopt(io, opts)
-      @logger.info "inherited addr=#{sock_name(io)} fd=#{io.fileno}"
+      name = sock_name(io)
+      @logger.info "inherited addr=#{name} fd=#{io.fileno}"
+      @config.register_inherited(name)
       io
     end
 
@@ -395,7 +396,9 @@ class Yahns::Server # :nodoc:
 
         # call OpenSSL::SSL::SSLContext#setup explicitly here to detect
         # errors and avoid race conditions.  We avoid calling this in the
-        # parent process since
+        # parent process (if we have multiple workers) in case the
+        # setup code starts TCP connections to memcached or similar
+        # for session caching.
         ssl_ctx.setup
       end
       ctx_list << ctx
@@ -435,25 +438,28 @@ class Yahns::Server # :nodoc:
   # This just injects the QueueQuitter object which acts like a
   # monkey wrench thrown into a perfectly good engine :)
   def quit_finish
-    quitter = Yahns::QueueQuitter.new
+    # we must not let quitters get GC-ed if we have any worker threads leftover
+    @quitter = Yahns::QueueQuitter.new
 
     # throw the monkey wrench into the worker threads
-    @queues.each { |q| q.queue_add(quitter, Yahns::Queue::QEV_QUIT) }
+    @queues.each { |q| q.queue_add(@quitter, Yahns::Queue::QEV_QUIT) }
 
     # watch the monkey wrench destroy all the threads!
     # 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) }
+      # Workaround Linux 5.5+ bug (fixed in 5.13+)
+      # https://yhbt.net/lore/lkml/20210405231025.33829-1-dave@stgolabs.net/
+      @wthr[0] && @queues[0].respond_to?(:queue_del) and @queues.each do |q|
+        q.queue_del(@quitter)
+        q.queue_add(@quitter, Yahns::Queue::QEV_QUIT)
+      end
     end while @wthr[0] && Yahns.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
+    @quitter.close # keep object around in case @wthr isn't empty
   rescue => e
     Yahns::Log.exception(@logger, "quit finish", e)
   ensure
@@ -473,7 +479,8 @@ class Yahns::Server # :nodoc:
   end
 
   def sp_sig_handle(alive)
-    @sev.kgio_wait_readable(alive ? nil : 0.01)
+    tout = alive ? (@sig_queue.empty? ? nil : 0) : 0.01
+    @sev.wait_readable(tout)
     @sev.yahns_step
     case sig = @sig_queue.shift
     when :QUIT, :TERM, :INT
@@ -497,6 +504,19 @@ class Yahns::Server # :nodoc:
     if drop_acceptors[0] || fdmap.size > 0
       timeout = @shutdown_expire < Yahns.now ? -1 : @shutdown_timeout
       n = fdmap.desperate_expire(timeout)
+      return false if n == 0 && @listeners.empty? # all done!
+
+      # FIXME: sometimes shutdowns take a long time when using proxy_pass
+      # Still not sure what's going on and it takes a while to reproduce..
+      if timeout == -1
+        @logger.error(
+"exiting on shutdown_timeout=#@shutdown_timeout #{fdmap.size} FD(s) remain"
+        )
+
+        system('lsof', '-n', '-p', "#$$") if RUBY_PLATFORM =~ /linux/
+        return false
+      end
+
       $0 = "yahns quitting, #{n} FD(s) remain"
       true
     else

data/lib/yahns/server_mp.rb

@@ -31,8 +31,6 @@ module Yahns::ServerMP # :nodoc:
     # daemon_pipe may be true for non-initial workers
     @daemon_pipe = @daemon_pipe.close if @daemon_pipe.respond_to?(:close)
 
-    srand # in case this pops up again: https://bugs.ruby-lang.org/issues/4338
-
     # The OpenSSL PRNG is seeded with only the pid, and apps with frequently
     # dying workers can recycle pids
     OpenSSL::Random.seed(rand.to_s) if defined?(OpenSSL::Random)
@@ -91,7 +89,7 @@ module Yahns::ServerMP # :nodoc:
     @logger.info "master process ready"
     daemon_ready
     begin
-      @sev.kgio_wait_readable
+      @sev.wait_readable
       @sev.yahns_step
       reap_all
       case @sig_queue.shift
@@ -159,7 +157,8 @@ 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.1)
+    tout = alive ? (@sig_queue.empty? ? nil : 0) : 0.01
+    if r = select(watch, nil, nil, tout)
       r[0].each(&:yahns_step)
     end
     case @sig_queue.shift

data/lib/yahns/sigevent_efd.rb

@@ -3,7 +3,6 @@
 # License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
 # frozen_string_literal: true
 class Yahns::Sigevent < SleepyPenguin::EventFD # :nodoc:
-  include Kgio::DefaultWaiters
   def self.new
     super(0, :CLOEXEC)
   end

data/lib/yahns/sigevent_pipe.rb

@@ -5,21 +5,24 @@
 class Yahns::Sigevent # :nodoc:
   attr_reader :to_io
   def initialize
-    @to_io, @wr = Kgio::Pipe.new
-    @to_io.close_on_exec = @wr.close_on_exec = true
+    @to_io, @wr = IO.pipe
   end
 
-  def kgio_wait_readable(*args)
-    @to_io.kgio_wait_readable(*args)
+  def wait_readable(*args)
+    @to_io.wait_readable(*args)
+  end
+
+  def fileno
+    @to_io.fileno
   end
 
   def sev_signal
-    @wr.kgio_trywrite(".")
+    @wr.write_nonblock(".", exception: false)
   end
 
   def yahns_step
     # 11 byte strings -> no malloc on YARV
-    while String === @to_io.kgio_tryread(11)
+    while String === @to_io.read_nonblock(11, exception: false)
     end
     :wait_readable
   end
@@ -28,4 +31,8 @@ class Yahns::Sigevent # :nodoc:
     @to_io.close
     @wr.close
   end
+
+  def closed?
+    @to_io.closed?
+  end
 end

data/lib/yahns/socket_helper.rb

@@ -19,7 +19,7 @@ module Yahns::SocketHelper # :nodoc:
 
   def set_server_sockopt(sock, opt)
     opt = {backlog: 1024}.merge!(opt)
-    sock.close_on_exec = true
+    sock.close_on_exec = true # needed for inherited sockets
 
     TCPSocket === sock and sock.setsockopt(:IPPROTO_TCP, :TCP_NODELAY, 1)
     sock.setsockopt(:SOL_SOCKET, :SO_KEEPALIVE, 1)

data/lib/yahns/stream_input.rb

@@ -43,8 +43,9 @@ class Yahns::StreamInput # :nodoc:
         length < 0 and raise ArgumentError, "negative length #{length} given"
         rv.replace(@rbuf.slice!(0, length))
       else
-        to_read = length - @rbuf.size
-        rv.replace(@rbuf.slice!(0, @rbuf.size))
+        cur = @rbuf.size
+        to_read = length - cur
+        cur == 0 ? rv.clear : rv.replace(@rbuf.slice!(0, cur))
         until to_read == 0 || eof? || (rv.size > 0 && @chunked)
           @client.yahns_read(to_read, @buf) or eof!
           filter_body(@rbuf, @buf)

data/lib/yahns/tee_input.rb

@@ -104,9 +104,7 @@ class Yahns::TeeInput < Yahns::StreamInput # :nodoc:
   end
 
   def tee(buffer)
-    if buffer && buffer.size > 0
-      @tmp.write(buffer)
-    end
+    @tmp.write(buffer) if buffer
     buffer
   end
 

data/lib/yahns/version.rb

@@ -1 +1 @@
-Yahns::VERSION = '1.14.1'.freeze # :nodoc:
+Yahns::VERSION = '1.18.0'.freeze # :nodoc:

data/lib/yahns/wbuf.rb

@@ -31,6 +31,7 @@ require_relative 'wbuf_common'
 class Yahns::Wbuf # :nodoc:
   include Yahns::WbufCommon
   attr_reader :busy
+  IO_WRITEV = RUBY_VERSION.to_r >= 2.5 # IO#write uses writev
 
   def initialize(body, persist)
     @tmpio = nil
@@ -40,9 +41,15 @@ class Yahns::Wbuf # :nodoc:
     @busy = false
   end
 
-  def wbuf_writev(buf)
-    @tmpio.kgio_writev(buf)
-    buf.inject(0) { |n, s| n += s.size }
+  if IO_WRITEV
+    def wbuf_writev(buf)
+      @tmpio.write(*buf)
+    end
+  else
+    def wbuf_writev(buf)
+      @tmpio.kgio_writev(buf)
+      buf.inject(0) { |n, s| n += s.size }
+    end
   end
 
   def wbuf_write(c, buf)

data/lib/yahns/worker.rb

@@ -9,6 +9,14 @@ class Yahns::Worker # :nodoc:
   def initialize(nr)
     @nr = nr
     @to_io, @wr = Kgio::Pipe.new
+
+    begin
+      # F_SETPIPE_SZ = 1031, PAGE_SIZE = 4096
+      # (fcntl will handle minimum size on platforms where PAGE_SIZE > 4096)
+      @to_io.fcntl(1031, 4096)
+    rescue SystemCallError
+      # old kernel (EINVAL, EPERM)
+    end if RUBY_PLATFORM =~ /\blinux\b/
   end
 
   def atfork_child

data/lib/yahns.rb

@@ -1,10 +1,11 @@
-# Copyright (C) 2013-2016 all contributors <yahns-public@yhbt.net>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# Copyright (C) 2013-2019 all contributors <yahns-public@yhbt.net>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 $stdout.sync = $stderr.sync = true
 
 require 'unicorn' # pulls in raindrops, kgio, fcntl, etc, stringio, and logger
 require 'sleepy_penguin'
+require 'io/wait'
 
 # kill off some unicorn internals we don't need
 # we'll probably just make kcar into a server parser so we don't depend
@@ -15,11 +16,15 @@ require 'sleepy_penguin'
     Unicorn.__send__(:remove_const, sym) if Unicorn.const_defined?(sym)
 end
 
-# yahns exposes no user-visible API outside of the config file.
-# See https://yhbt.net/yahns/yahns_config.txt for the config documentation
-# and https://yhbt.net/yahns/ for the homepage.
-# Internals are subject to change.
-
+# yahns exposes little user-visible API outside of the config file.
+# See https://yhbt.net/yahns/yahns_config.txt
+# for the config documentation (or yahns_config(5) manpage)
+# and https://yhbt.net/yahns.git/about/ for the homepage.
+#
+# Yahns::ProxyPass is currently the only public API.
+#
+# Documented APIs and options are supported forever,
+# internals are subject to change.
 module Yahns
   # :stopdoc:
   # We populate this at startup so we can figure out how to reexecute