unicorn-simon 0.0.1

data/lib/unicorn/http_request.rb

@@ -0,0 +1,122 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# no stable API here
+require 'unicorn_http'
+
+# TODO: remove redundant names
+Unicorn.const_set(:HttpRequest, Unicorn::HttpParser)
+class Unicorn::HttpParser
+
+  # default parameters we merge into the request env for Rack handlers
+  DEFAULTS = {
+    "rack.errors" => $stderr,
+    "rack.multiprocess" => true,
+    "rack.multithread" => false,
+    "rack.run_once" => false,
+    "rack.version" => [1, 2],
+    "rack.hijack?" => true,
+    "SCRIPT_NAME" => "",
+
+    # this is not in the Rack spec, but some apps may rely on it
+    "SERVER_SOFTWARE" => "Unicorn #{Unicorn::Const::UNICORN_VERSION}"
+  }
+
+  NULL_IO = StringIO.new("")
+
+  # :stopdoc:
+  # A frozen format for this is about 15% faster
+  # Drop these frozen strings when Ruby 2.2 becomes more prevalent,
+  # 2.2+ optimizes hash assignments when used with literal string keys
+  HTTP_RESPONSE_START = [ 'HTTP', '/1.1 ']
+  @@input_class = Unicorn::TeeInput
+  @@check_client_connection = false
+
+  # TCP_TIME_WAIT: 6, TCP_CLOSE: 7, TCP_CLOSE_WAIT: 8, TCP_LAST_ACK: 9
+  IGNORED_CHECK_CLIENT_SOCKET_STATES = (6..9)
+
+  def self.input_class
+    @@input_class
+  end
+
+  def self.input_class=(klass)
+    @@input_class = klass
+  end
+
+  def self.check_client_connection
+    @@check_client_connection
+  end
+
+  def self.check_client_connection=(bool)
+    @@check_client_connection = bool
+  end
+
+  # :startdoc:
+
+  # Does the majority of the IO processing.  It has been written in
+  # Ruby using about 8 different IO processing strategies.
+  #
+  # It is currently carefully constructed to make sure that it gets
+  # the best possible performance for the common case: GET requests
+  # that are fully complete after a single read(2)
+  #
+  # Anyone who thinks they can make it faster is more than welcome to
+  # take a crack at it.
+  #
+  # returns an environment hash suitable for Rack if successful
+  # This does minimal exception trapping and it is up to the caller
+  # to handle any socket errors (e.g. user aborted upload).
+  def read(socket)
+    clear
+    e = env
+
+    # From http://www.ietf.org/rfc/rfc3875:
+    # "Script authors should be aware that the REMOTE_ADDR and
+    #  REMOTE_HOST meta-variables (see sections 4.1.8 and 4.1.9)
+    #  may not identify the ultimate source of the request.  They
+    #  identify the client for the immediate request to the server;
+    #  that client may be a proxy, gateway, or other intermediary
+    #  acting on behalf of the actual source client."
+    e['REMOTE_ADDR'] = socket.kgio_addr
+
+    # short circuit the common case with small GET requests first
+    socket.kgio_read!(16384, buf)
+    if parse.nil?
+      # Parser is not done, queue up more data to read and continue parsing
+      # an Exception thrown from the parser will throw us out of the loop
+      false until add_parse(socket.kgio_read!(16384))
+    end
+
+    # detect if the socket is valid by checking client connection.
+    if @@check_client_connection
+      if defined?(Raindrops::TCP_Info)
+        tcp_info = Raindrops::TCP_Info.new(socket)
+        if IGNORED_CHECK_CLIENT_SOCKET_STATES.cover?(tcp_info.state)
+          socket.close
+          raise Errno::EPIPE
+        end
+      elsif headers?
+        self.response_start_sent = true
+        HTTP_RESPONSE_START.each { |c| socket.write(c) }
+      end
+    end
+
+    e['rack.input'] = 0 == content_length ?
+                      NULL_IO : @@input_class.new(socket, self)
+
+    # for Rack hijacking in Rack 1.5 and later
+    e['unicorn.socket'] = socket
+    e['rack.hijack'] = self
+
+    e.merge!(DEFAULTS)
+  end
+
+  # for rack.hijack, we respond to this method so no extra allocation
+  # of a proc object
+  def call
+    env['rack.hijack_io'] = env['unicorn.socket']
+  end
+
+  def hijacked?
+    env.include?('rack.hijack_io'.freeze)
+  end
+end

data/lib/unicorn/http_response.rb

@@ -0,0 +1,60 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# 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(socket, status, headers, body)
+#
+# Most header correctness (including Content-Length and Content-Type)
+# is the job of Rack, with the exception of the "Date" and "Status" header.
+module Unicorn::HttpResponse
+
+  STATUS_CODES = defined?(Rack::Utils::HTTP_STATUS_CODES) ?
+                 Rack::Utils::HTTP_STATUS_CODES : {}
+
+  # internal API, code will always be common-enough-for-even-old-Rack
+  def err_response(code, response_start_sent)
+    "#{response_start_sent ? '' : 'HTTP/1.1 '}" \
+      "#{code} #{STATUS_CODES[code]}\r\n\r\n"
+  end
+
+  # writes the rack_response to socket as an HTTP response
+  def http_response_write(socket, status, headers, body,
+                          response_start_sent=false)
+    hijack = nil
+
+    if headers
+      code = status.to_i
+      msg = STATUS_CODES[code]
+      start = response_start_sent ? ''.freeze : 'HTTP/1.1 '.freeze
+      buf = "#{start}#{msg ? %Q(#{code} #{msg}) : status}\r\n" \
+            "Date: #{httpdate}\r\n" \
+            "Connection: close\r\n"
+      headers.each do |key, value|
+        case key
+        when %r{\A(?:Date|Connection)\z}i
+          next
+        when "rack.hijack"
+          # This should only be hit under Rack >= 1.5, as this was an illegal
+          # key in Rack < 1.5
+          hijack = value
+        else
+          if value =~ /\n/
+            # avoiding blank, key-only cookies with /\n+/
+            value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
+          else
+            buf << "#{key}: #{value}\r\n"
+          end
+        end
+      end
+      socket.write(buf << "\r\n".freeze)
+    end
+
+    if hijack
+      hijack.call(socket)
+    else
+      body.each { |chunk| socket.write(chunk) }
+    end
+  end
+end