yahns 0.0.0TP1

data/lib/yahns/daemon.rb

@@ -0,0 +1,51 @@
+# -*- 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)
+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
+  #     and can be set in config.ru and config_file, so making it
+  #     0000 and potentially exposing sensitive log data can be bad
+  #     policy.
+  #   * don't bother to chdir("/") here since yahns is designed to
+  #     run inside APP_ROOT.  Yahns will also re-chdir() to
+  #     the directory it was started in when being re-executed
+  #     to pickup code changes if the original deployment directory
+  #     is a symlink or otherwise got replaced.
+  def self.daemon(yahns_server)
+    $stdin.reopen("/dev/null")
+
+    # We only start a new process group if we're not being reexecuted
+    # and inheriting file descriptors from our parent
+    unless ENV['YAHNS_FD']
+      # grandparent - reads pipe, exits when master is ready
+      #  \_ parent  - exits immediately ASAP
+      #      \_ yahns master - writes to pipe when ready
+
+      # We cannot use Yahns::Sigevent (eventfd) here because we need
+      # to detect EOF on unexpected death, not just read/write
+      rd, wr = IO.pipe
+      grandparent = $$
+      if fork
+        wr.close # grandparent does not write
+      else
+        rd.close # yahns master does not read
+        Process.setsid
+        exit if fork # parent dies now
+      end
+
+      if grandparent == $$
+        # this will block until Server#join runs (or it dies)
+        master_pid = (rd.readpartial(16) rescue nil).to_i
+        unless master_pid > 1
+          warn "master failed to start, check stderr log for details"
+          exit!(1)
+        end
+        exit 0
+      else # yahns master process
+        yahns_server.daemon_pipe = wr
+      end
+    end
+    # $stderr/$stderr can/will be redirected separately in the Yahns config
+  end
+end

data/lib/yahns/fdmap.rb

@@ -0,0 +1,90 @@
+# 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 'thread'
+
+# only initialize this after forking, this is highly volatile and won't
+# be able to share data across processes at all.
+# This is really a singleton
+
+class Yahns::Fdmap # :nodoc:
+  def initialize(logger, client_expire_threshold)
+    @logger = logger
+
+    if Float === client_expire_threshold
+      client_expire_threshold *= Process.getrlimit(:NOFILE)[0]
+    elsif client_expire_threshold < 0
+      client_expire_threshold = Process.getrlimit(:NOFILE)[0] +
+                                client_expire_threshold
+    end
+    @client_expire_threshold = client_expire_threshold.to_i
+
+    # This is an array because any sane OS will frequently reuse FDs
+    # to keep this tightly-packed and favor lower FD numbers
+    # (consider select(2) performance (not that we use select))
+    # An (unpacked) Hash (in MRI) uses 5 more words per entry than an Array,
+    # and we should expect this array to have around 60K elements
+    @fdmap_ary = []
+    @fdmap_mtx = Mutex.new
+    @last_expire = 0.0
+    @count = 0
+  end
+
+  # called immediately after accept()
+  def add(io)
+    fd = io.fileno
+    @fdmap_mtx.synchronize do
+      if (@count += 1) > @client_expire_threshold
+        __expire_for(io)
+      else
+        @fdmap_ary[fd] = io
+      end
+    end
+  end
+
+  # this is only called in Errno::EMFILE/Errno::ENFILE situations
+  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 }
+  end
+
+  def delete(io) # use with rack.hijack (via yahns)
+    fd = io.fileno
+    @fdmap_mtx.synchronize do
+      @fdmap_ary[fd] = nil
+      @count -= 1
+    end
+  end
+
+  # expire a bunch of idle clients and register the current one
+  # We should not be calling this too frequently, it is expensive
+  # This is called while @fdmap_mtx is held
+  def __expire_for(io, timeout = nil)
+    nr = 0
+    now = Time.now.to_f
+    (now - @last_expire) >= 1.0 or return # don't expire too frequently
+
+    # @fdmap_ary may be huge, so always expire a bunch at once to
+    # 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)
+    end
+
+    @fdmap_ary[io.fileno] = io
+    @last_expire = Time.now.to_f
+    msg = timeout ? "timeout=#{timeout})" : "client_timeout"
+    @logger.info("dropping #{nr} of #@count clients for #{msg}")
+  end
+
+  # used for graceful shutdown
+  def size
+    @fdmap_mtx.synchronize { @count }
+  end
+end

data/lib/yahns/http_client.rb

@@ -0,0 +1,198 @@
+# -*- 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)
+class Yahns::HttpClient < Kgio::Socket # :nodoc:
+  NULL_IO = StringIO.new("")
+
+  # FIXME: we shouldn't have this at all
+  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
+  RACK_INPUT = 'rack.input'.freeze
+  RACK_HIJACK = 'rack.hijack'.freeze
+  RACK_HIJACK_IO = "rack.hijack_io".freeze
+
+  # called from acceptor thread
+  def yahns_init
+    @hs = Unicorn::HttpRequest.new
+    @response_start_sent = false
+    @state = :headers # :body, :trailers, :pipelined, Wbuf, StreamFile
+    @input = nil
+  end
+
+  # use if writes are deferred by buffering, this return value goes to
+  # the main epoll/kqueue worker loop
+  # returns :wait_readable, :wait_writable, or nil
+  def step_write
+    case rv = @state.wbuf_flush(self)
+    when :wait_writable, :wait_readable
+      return rv # tell epoll/kqueue to wait on this more
+    when :delete # :delete on hijack
+      @state = :delete
+      return :delete
+    when Yahns::StreamFile
+      @state = rv # continue looping
+    when true, false # done
+      return http_response_done(rv)
+    else
+      raise "BUG: #{@state.inspect}#wbuf_flush returned #{rv.inspect}"
+    end while true
+  end
+
+  def mkinput_preread
+    @state = :body
+    @input = self.class.tmpio_for(@hs.content_length)
+    rbuf = Thread.current[:yahns_rbuf]
+    @hs.filter_body(rbuf, @hs.buf)
+    @input.write(rbuf)
+  end
+
+  def input_ready
+    empty_body = 0 == @hs.content_length
+    k = self.class
+    case k.input_buffering
+    when true
+      # common case is an empty body
+      return NULL_IO if empty_body
+
+      # content_length is nil (chunked) or len > 0
+      mkinput_preread # keep looping
+      false
+    else # :lazy, false
+      empty_body ? NULL_IO : (@input = k.mkinput(self, @hs))
+    end
+  end
+
+  # the main entry point of the epoll/kqueue worker loop
+  def yahns_step
+    # always write unwritten data first if we have any
+    return step_write if Yahns::WbufCommon === @state
+
+    # only read if we had nothing to write in this event loop iteration
+    k = self.class
+    rbuf = Thread.current[:yahns_rbuf] # running under spawn_worker_threads
+
+    case @state
+    when :pipelined
+      if @hs.parse
+        input = input_ready and return app_call(input)
+        # @state == :body if we get here point (input_ready -> mkinput_preread)
+      else
+        @state = :headers
+      end
+      # continue to outer loop
+    when :headers
+      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
+        end
+        # keep looping on kgio_tryread
+      when :wait_readable, :wait_writable, nil
+        return rv
+      end while true
+    when :body
+      if @hs.body_eof?
+        if @hs.content_length || @hs.parse # hp.parse == trailers done!
+          @input.rewind
+          return app_call(@input)
+        else # possible Transfer-Encoding:chunked, keep looping
+          @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)
+      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
+    end while true # outer loop
+  rescue => e
+    handle_error(e)
+  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) }
+    end
+
+    # run the rack app
+    response = k.app.call(env.merge!(k.app_defaults))
+    return :delete if env.include?(RACK_HIJACK_IO)
+
+    # this returns :wait_readable, :wait_writable, :delete, or nil:
+    http_response_write(*response)
+  end
+
+  def hijack_proc(env)
+    proc { env[RACK_HIJACK_IO] = self }
+  end
+
+  # called automatically by kgio_write
+  def kgio_wait_writable(timeout = self.class.client_timeout)
+    super timeout
+  end
+
+  # called automatically by kgio_read
+  def kgio_wait_readable(timeout = self.class.client_timeout)
+    super timeout
+  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
+  # nil to ensure the socket is closed at the end of this function
+  def handle_error(e)
+    code = case e
+    when EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::ENOTCONN
+      return # don't send response, drop the connection
+    when Unicorn::RequestURITooLongError
+      414
+    when Unicorn::RequestEntityTooLargeError
+      413
+    when Unicorn::HttpParserError # try to tell the client they're bad
+      400
+    else
+      Yahns::Log.exception(@hs.env["rack.logger"], "app error", e)
+      500
+    end
+    kgio_trywrite(err_response(code))
+  rescue
+  ensure
+    shutdown rescue nil
+    return # always drop the connection on uncaught errors
+  end
+end

data/lib/yahns/http_context.rb

@@ -0,0 +1,65 @@
+# -*- 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)
+
+# subclasses of Yahns::HttpClient will class extend this
+
+module Yahns::HttpContext # :nodoc:
+  attr_accessor :check_client_connection
+  attr_accessor :client_body_buffer_size
+  attr_accessor :client_header_buffer_size
+  attr_accessor :client_max_body_size
+  attr_accessor :client_max_header_size
+  attr_accessor :input_buffering  # :lazy, true, false
+  attr_accessor :output_buffering # true, false
+  attr_accessor :persistent_connections # true or false only
+  attr_accessor :client_timeout
+  attr_accessor :qegg
+  attr_reader :app
+  attr_reader :app_defaults
+
+  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_header_buffer_size = 4000
+    @client_max_body_size = 1024 * 1024
+    @input_buffering = true
+    @output_buffering = true
+    @persistent_connections = true
+    @client_timeout = 15
+    @qegg = nil
+  end
+
+  # call this after forking
+  def after_fork_init
+    @app = @yahns_rack.app_after_fork
+  end
+
+  # call this immediately after successful accept()/accept4()
+  def logger=(l) # cold
+    @logger = @app_defaults["rack.logger"] = l
+  end
+
+  def logger
+    @app_defaults["rack.logger"]
+  end
+
+  def mkinput(client, hs)
+    (@input_buffering ? Yahns::TeeInput : Yahns::StreamInput).new(client, hs)
+  end
+
+  def errors=(dest)
+    @app_defaults["rack.errors"] = dest
+  end
+
+  def errors
+    @app_defaults["rack.errors"]
+  end
+
+  def tmpio_for(len)
+    len && len <= @client_body_buffer_size ?
+      StringIO.new("") : Yahns::TmpIO.new
+  end
+end

data/lib/yahns/http_response.rb

@@ -0,0 +1,184 @@
+# -*- 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_relative 'stream_file'
+
+# Writes a Rack response to your client using the HTTP/1.1 specification.
+# You use it by simply doing:
+#
+#   status, headers, body = rack_app.call(env)
+#   http_response_write(status, headers, body)
+#
+# Most header correctness (including Content-Length and Content-Type)
+# is the job of Rack, with the exception of the "Date" header.
+module Yahns::HttpResponse # :nodoc:
+  include Unicorn::HttpResponse
+
+  # avoid GC overhead for frequently used-strings:
+  CONN_KA = "Connection: keep-alive\r\n\r\n"
+  CONN_CLOSE = "Connection: close\r\n\r\n"
+  Z = ""
+  RESPONSE_START = "HTTP/1.1 "
+
+  def response_start
+    @response_start_sent ? Z : RESPONSE_START
+  end
+
+  def response_wait_write(rv)
+    # call the kgio_wait_readable or kgio_wait_writable method
+    ok = __send__("kgio_#{rv}") and return ok
+    k = self.class
+    k.logger.info("fd=#{fileno} ip=#@kgio_addr timeout on :#{rv} after "\
+                  "#{k.client_timeout}s")
+    nil
+  end
+
+  def err_response(code)
+    "#{response_start}#{CODES[code]}\r\n\r\n"
+  end
+
+  def response_header_blocked(ret, header, body, alive, offset, count)
+    if body.respond_to?(:to_path)
+      alive = Yahns::StreamFile.new(body, alive, offset, count)
+      body = nil
+    end
+    wbuf = Yahns::Wbuf.new(body, alive)
+    rv = wbuf.wbuf_write(self, header)
+    body.each { |chunk| rv = wbuf.wbuf_write(self, chunk) } if body
+    wbuf_maybe(wbuf, rv, alive)
+  end
+
+  def wbuf_maybe(wbuf, rv, alive)
+    case rv # trysendfile return value
+    when nil
+      case alive
+      when :delete
+        @state = :delete
+      when true, false
+        http_response_done(alive)
+      end
+    else
+      @state = wbuf
+      rv
+    end
+  end
+
+  def http_response_done(alive)
+    @input = @input.close if @input
+    if alive
+      @response_start_sent = false
+      # @hs.buf will have data if the client pipelined
+      if @hs.buf.empty?
+        @state = :headers
+        :wait_readable
+      else
+        @state = :pipelined
+        # may need to wait for readability if SSL,
+        # only need writability if plain TCP
+        :wait_readwrite
+      end
+    else
+      # shutdown is needed in case the app forked, we rescue here since
+      # StreamInput may issue shutdown as well
+      shutdown rescue nil
+      nil # trigger close
+    end
+  end
+
+  # writes the rack_response to socket as an HTTP response
+  # returns :wait_readable, :wait_writable, :forget, or nil
+  def http_response_write(status, headers, body)
+    status = CODES[status.to_i] || status
+    offset = 0
+    count = hijack = nil
+    k = self.class
+    alive = @hs.next? && k.persistent_connections
+
+    if @hs.headers?
+      buf = "#{response_start}#{status}\r\nDate: #{httpdate}\r\n"
+      headers.each do |key, value|
+        case key
+        when %r{\ADate\z}
+          next
+        when %r{\AContent-Range\z}i
+          if %r{\Abytes (\d+)-(\d+)/\d+\z} =~ value
+            offset = $1.to_i
+            count = $2.to_i - offset + 1
+          end
+        when %r{\AConnection\z}i
+          # allow Rack apps to tell us they want to drop the client
+          alive = !!(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
+        end
+      end
+      buf << (alive ? CONN_KA : CONN_CLOSE)
+      case rv = kgio_trywrite(buf)
+      when nil # all done, likely
+        break
+      when String
+        buf = rv # hope the skb grows
+      when :wait_writable, :wait_readable
+        if k.output_buffering
+          alive = hijack ? hijack : alive
+          rv = response_header_blocked(rv, buf, body, alive, offset, count)
+          body = nil # ensure we do not close body in ensure
+          return rv
+        else
+          response_wait_write(rv) or return
+        end
+      end while true
+    end
+
+    if hijack
+      hijack.call(self)
+      return :delete # trigger EPOLL_CTL_DEL
+    end
+
+    if body.respond_to?(:to_path)
+      @state = body = Yahns::StreamFile.new(body, alive, offset, count)
+      return step_write
+    end
+
+    wbuf = rv = nil
+    body.each do |chunk|
+      if wbuf
+        rv = wbuf.wbuf_write(self, chunk)
+      else
+        case rv = kgio_trywrite(chunk)
+        when nil # all done, likely and good!
+          break
+        when String
+          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)
+            rv = wbuf.wbuf_write(self, chunk)
+            break
+          else
+            response_wait_write(rv) or return
+          end
+        end while true
+      end
+    end
+
+    # if we buffered the write body, we must return :wait_writable
+    # (or :wait_readable for SSL) and hit Yahns::HttpClient#step_write
+    if wbuf
+      body = nil # ensure we do not close the body in ensure
+      wbuf_maybe(wbuf, rv, alive)
+    else
+      http_response_done(alive)
+    end
+  ensure
+    body.respond_to?(:close) and body.close
+  end
+end