httpkit 0.6.0.pre.3

data/lib/httpkit/client.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Client
+    USER_AGENT = 'User-Agent'.freeze
+    USER_AGENT_VALUE = "httpkit/#{HTTPkit::VERSION}".freeze
+    HOST = 'Host'.freeze
+    HOST_VALUE = '%s:%d'.freeze
+
+    include Support::HandlerManager::Setup
+    include Connection::Status
+
+    def self.start(config)
+      Connection::EventMachine.start_client(config, self)
+    end
+
+    attr_reader :config
+
+    def initialize(config, connection)
+      @config = config
+      @requests = []
+
+      setup_connection(connection)
+      setup_handlers
+    end
+
+    def request(*args)
+      request = Request.new(*args)
+      perform(request).sync
+    end
+
+    def perform(request)
+      served = Promise.new
+
+      if closed?
+        served.reject(@connection.closed.reason)
+      else
+        @requests << [request, served]
+        perform!(request)
+      end
+
+      served
+    end
+
+    def receive(response)
+      request, served = find_request
+
+      if request
+        served.fulfill(response)
+        @handlers.notify(:receive, request, response)
+        response.closed { finish(request) }
+      end
+    end
+
+    def finish(request)
+      @requests.delete_if { |(req)| req == request }
+      @handlers.notify(:finish, request)
+    end
+
+    def teardown(reason)
+      @requests.each do |_, served|
+        served.reject(reason)
+        if (response = served.value)
+          response.reject_closed(reason)
+        end
+      end
+    end
+
+    private
+
+    def add_extra_headers(request)
+      host = sprintf(HOST_VALUE, config[:address], config[:port])
+      request.add_extra_headers(USER_AGENT => USER_AGENT_VALUE, HOST => host)
+    end
+
+    def perform!(request)
+      Fiber.new do
+        add_extra_headers(request)
+        @handlers.notify(:perform, request)
+        @connection.serialize(request)
+      end.resume
+    end
+
+    def find_request
+      @requests.detect { |_, served| served.pending? }
+    end
+
+    def setup_connection(connection)
+      @connection = connection
+      @connection.on_message = method(:receive)
+      @connection.closed.then(method(:teardown), method(:teardown))
+    end
+  end
+end

data/lib/httpkit/connection/eventmachine.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module HTTPkit
+  module Connection
+    class EventMachine < EM::Connection
+      def self.start_client(config, client_class)
+        connection = EM.connect(config[:address], config[:port], self)
+        client_class.new(config, connection)
+      end
+
+      def self.start_server(config, server_class)
+        EM.start_server(config[:address], config[:port], self,
+                        proc { |conn| server_class.new(config, conn) })
+      end
+
+      attr_reader :closed
+      attr_writer :on_message
+
+      def initialize(callback = proc {})
+        @closed = Promise.new
+        @parser = HTTP::Parser.new(self)
+        callback.call(self)
+      end
+
+      def serialize(message)
+        serializer = Serializer.new(message, method(:send_data))
+        serializer.setup_body
+        serializer.serialize
+      end
+
+      def receive_data(data)
+        # p [__id__, :receive, data]
+        # p data
+        @parser << data
+      rescue => ex
+        close(ex)
+      end
+
+      # def send_data(data)
+      #   # p [__id__, :send, data]
+      #   p data
+      #   super
+      # end
+
+      def close(reason = nil)
+        closed.reject(reason) if reason
+        close_connection_after_writing
+      end
+
+      def unbind(reason = nil)
+        if reason
+          closed.reject(reason)
+        else
+          closed.fulfill
+        end
+      end
+
+      def on_headers_complete(_)
+        @message = Support::Message.build(@parser)
+        @on_message.call(@message)
+      end
+
+      def on_body(chunk)
+        @message.body.closed.progress(chunk)
+      end
+
+      def on_message_complete
+        @message.close
+      end
+    end
+  end
+end

data/lib/httpkit/connection/status.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module HTTPkit
+  module Connection
+    module Status
+      def close(reason = nil)
+        @connection.close(reason)
+      end
+
+      def closed?
+        !@connection.closed.pending?
+      end
+
+      def error?
+        @connection.closed.rejected?
+      end
+
+      def network_fault?
+        [Errno::ENOTCONN, Errno::ENETUNREACH]
+          .include?(@connection.closed.reason)
+      end
+
+      def timeout?
+        @connection.closed.reason == Errno::ETIMEDOUT
+      end
+    end
+  end
+end

data/lib/httpkit/promise.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Promise < ::Promise
+    def wait
+      fiber  = Fiber.current
+      resume = proc { fiber.resume }
+      self.then(resume, resume)
+
+      Fiber.yield
+    end
+
+    private
+
+    def defer
+      EM.next_tick { yield } if EM.reactor_running?
+    end
+  end
+end

data/lib/httpkit/request.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module HTTPkit
+  Request = Struct.new(:http_method, :uri, :headers, :body, :http_version)
+
+  class Request
+    private :http_method=, :uri=, :headers=, :body=
+
+    include Support::Message
+
+    # TODO: URI.join is really slow
+    def initialize(http_method, uri, headers = {}, body = '')
+      super(http_method,
+            # URI('http://' + uri)
+            URI.join('http:///', uri).request_uri,
+            headers, Body.build(body), 1.1)
+    end
+  end
+end

data/lib/httpkit/response.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+module HTTPkit
+  Response = Struct.new(:status, :headers, :body, :http_version)
+
+  class Response
+    private :status=, :headers=, :body=
+
+    include Support::Message
+
+    def initialize(status, headers = {}, body = '')
+      super(status, headers, Body.build(body), 1.1)
+    end
+
+    def status_name
+      STATUS_NAMES[status.to_i] || UNKNOWN_STATUS
+    end
+
+    def status_class
+      status / 100
+    end
+
+    def informational?
+      status_class == 1
+    end
+
+    def successful?
+      status_class == 2
+    end
+
+    def redirection?
+      status_class == 3
+    end
+
+    def client_error?
+      status_class == 4
+    end
+
+    def server_error?
+      status_class == 5
+    end
+
+    UNKNOWN_STATUS = 'Unknown Status'.freeze
+
+    STATUS_NAMES =
+      { 100 => 'Continue'.freeze,
+        101 => 'Switching Protocols'.freeze,
+        102 => 'Processing'.freeze,
+        200 => 'OK'.freeze,
+        201 => 'Created'.freeze,
+        202 => 'Accepted'.freeze,
+        203 => 'Non-Authoritative Information'.freeze,
+        204 => 'No Content'.freeze,
+        205 => 'Reset Content'.freeze,
+        206 => 'Partial Content'.freeze,
+        207 => 'Multi-Status'.freeze,
+        208 => 'Already Reported'.freeze,
+        226 => 'IM Used'.freeze,
+        300 => 'Multiple Choices'.freeze,
+        301 => 'Moved Permanently'.freeze,
+        302 => 'Found'.freeze,
+        303 => 'See Other'.freeze,
+        304 => 'Not Modified'.freeze,
+        305 => 'Use Proxy'.freeze,
+        306 => 'Reserved'.freeze,
+        307 => 'Temporary Redirect'.freeze,
+        308 => 'Permanent Redirect'.freeze,
+        400 => 'Bad Request'.freeze,
+        401 => 'Unauthorized'.freeze,
+        402 => 'Payment Required'.freeze,
+        403 => 'Forbidden'.freeze,
+        404 => 'Not Found'.freeze,
+        405 => 'Method Not Allowed'.freeze,
+        406 => 'Not Acceptable'.freeze,
+        407 => 'Proxy Authentication Required'.freeze,
+        408 => 'Request Timeout'.freeze,
+        409 => 'Conflict'.freeze,
+        410 => 'Gone'.freeze,
+        411 => 'Length Required'.freeze,
+        412 => 'Precondition Failed'.freeze,
+        413 => 'Request Entity Too Large'.freeze,
+        414 => 'Request-URI Too Long'.freeze,
+        415 => 'Unsupported Media Type'.freeze,
+        416 => 'Requested Range Not Satisfiable'.freeze,
+        417 => 'Expectation Failed'.freeze,
+        422 => 'Unprocessable Entity'.freeze,
+        423 => 'Locked'.freeze,
+        424 => 'Failed Dependency'.freeze,
+        425 =>
+          'Reserved for WebDAV advanced collections expired proposal'.freeze,
+        426 => 'Upgrade Required'.freeze,
+        427 => 'Unassigned'.freeze,
+        428 => 'Precondition Required'.freeze,
+        429 => 'Too Many Requests'.freeze,
+        430 => 'Unassigned'.freeze,
+        431 => 'Request Header Fields Too Large'.freeze,
+        500 => 'Internal Server Error'.freeze,
+        501 => 'Not Implemented'.freeze,
+        502 => 'Bad Gateway'.freeze,
+        503 => 'Service Unavailable'.freeze,
+        504 => 'Gateway Timeout'.freeze,
+        505 => 'HTTP Version Not Supported'.freeze,
+        506 => 'Variant Also Negotiates (Experimental)'.freeze,
+        507 => 'Insufficient Storage'.freeze,
+        508 => 'Loop Detected'.freeze,
+        509 => 'Unassigned'.freeze,
+        510 => 'Not Extended'.freeze,
+        511 => 'Network Authentication Required'.freeze }
+  end
+end

data/lib/httpkit/serializer/encoding.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Serializer
+    module Encoding
+      TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+      CHUNKED = 'chunked'.freeze
+      CRLF = "\r\n".freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+
+      def setup_chunked_encoding
+        headers.delete(CONTENT_LENGTH)
+        headers[TRANSFER_ENCODING] = CHUNKED
+      end
+
+      def setup_chunked_streaming
+        body.closed.on_progress { |chunk| write_chunk(chunk) }
+        body.closed.then { |_| write_chunk!('') }
+      end
+
+      def setup_identity_encoding
+        headers.delete(TRANSFER_ENCODING)
+        headers[CONTENT_LENGTH] = body.to_s.bytesize
+      end
+
+      def write_body
+        if headers.key?(TRANSFER_ENCODING)
+          write_chunk(body.string)
+        else
+          write(body.to_s)
+        end
+      end
+
+      def write_chunk(chunk)
+        write_chunk!(chunk) unless chunk.empty?
+      end
+
+      def write_chunk!(chunk)
+        write(chunk.bytesize.to_s(16), CRLF, chunk, CRLF)
+      end
+    end
+  end
+end

data/lib/httpkit/serializer.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'forwardable'
+
+module HTTPkit
+  class Serializer
+    REQUEST_LINE = "%s %s HTTP/%.1f\r\n".freeze
+    RESPONSE_LINE = "HTTP/%.1f %d %s\r\n".freeze
+    HEADER = "%s: %s\r\n".freeze
+    CRLF = "\r\n".freeze
+
+    include Encoding
+
+    extend Forwardable
+    def_delegator :@message, :headers
+    def_delegator :@message, :body
+
+    def initialize(message, writer)
+      @message = message
+      @writer = writer
+    end
+
+    def serialize
+      write(banana_line)
+      write(header_block)
+
+      write_body
+    end
+
+    def setup_body
+      if body.closed.pending?
+        setup_chunked_encoding
+        setup_chunked_streaming
+      else
+        setup_identity_encoding
+      end
+    end
+
+    private
+
+    def write(*data)
+      @writer.call(data.join(''))
+    end
+
+    def banana_line
+      if Request === @message
+        request_line
+      else
+        response_line
+      end
+    end
+
+    def request_line
+      sprintf(REQUEST_LINE,
+              @message.http_method.upcase, @message.uri, @message.http_version)
+    end
+
+    def response_line
+      sprintf(RESPONSE_LINE,
+              @message.http_version, @message.status, @message.status_name)
+    end
+
+    def header_block
+      headers.reduce('') { |a, e| a << header_line(*e) } + CRLF
+    end
+
+    def header_line(key, value)
+      if value.to_s.empty?
+        ''
+      else
+        sprintf(HEADER, key, value)
+      end
+    end
+  end
+end

data/lib/httpkit/server/keep_alive.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Server::KeepAlive
+    CONNECTION = 'Connection'.freeze
+    CLOSE = 'close'.freeze
+    KEEP_ALIVE = 'keep-alive'.freeze
+
+    def setup(_, server, _)
+      @server = server
+      @requests, @previous = {}, nil
+    end
+
+    def serve(request, served)
+      @requests[request] = [served, @previous]
+      @previous = request
+    end
+
+    def respond(request, response)
+      synchronize_responses(request)
+
+      if close_connection?(request)
+        response.headers[CONNECTION] = CLOSE
+        # XXX: possible race condition with other locations waiting for this
+        response.closed { @server.close }
+      else
+        response.headers[CONNECTION] = KEEP_ALIVE
+      end
+    end
+
+    def finish(request)
+      @requests.delete(request)
+    end
+
+    private
+
+    def synchronize_responses(request)
+      _, previous = @requests[request]
+      served, _   = @requests[previous]
+
+      served.sync.closed! if served
+    end
+
+    def connection_header(request)
+      response = @requests[request][0].value
+      request.headers[CONNECTION] || response.headers[CONNECTION]
+    end
+
+    def close_connection?(request)
+      header = connection_header(request).to_s.downcase
+      header == CLOSE || http10_close?(request.http_version, header)
+    end
+
+    def http10_close?(version, header)
+      version < 1.1 && header != KEEP_ALIVE
+    end
+  end
+end

data/lib/httpkit/server/timeouts.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module HTTPkit
+  # @see EM.heartbeat_interval
+  class Server::Timeouts
+    def setup(config, _, connection)
+      @config = config
+      @connection = connection
+
+      @connection.comm_inactivity_timeout = @config[:timeout] ||= 2.0
+    end
+  end
+end

data/lib/httpkit/server.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Server
+    SERVER = 'Server'.freeze
+    SERVER_VALUE = "httpkit/#{HTTPkit::VERSION}".freeze
+    DATE = 'Date'.freeze
+
+    def self.start(config)
+      Connection::EventMachine.start_server(config, self)
+    end
+
+    include Support::HandlerManager::Setup
+    include Connection::Status
+
+    attr_reader :config
+
+    def initialize(config, connection)
+      @config = config
+
+      setup_connection(connection)
+      setup_handlers
+    end
+
+    def serve(request)
+      served = Promise.new
+      served.then { |response| respond(request, response) }
+
+      Fiber.new { @handlers.notify(:serve, request, served) }.resume
+    end
+
+    def respond(request, response)
+      fiber = Fiber.new do
+        add_extra_headers(response)
+        respond!(request, response)
+        response.closed { finish(request) }
+      end
+      fiber.resume
+    end
+
+    def finish(request)
+      @handlers.notify(:finish, request)
+    end
+
+    private
+
+    def add_extra_headers(response)
+      date = Time.now.httpdate
+      response.add_extra_headers(SERVER => SERVER_VALUE, DATE => date)
+    end
+
+    def respond!(request, response)
+      @handlers.notify(:respond, request, response)
+      @connection.serialize(response)
+    end
+
+    def setup_connection(connection)
+      @connection = connection
+      @connection.on_message = method(:serve)
+    end
+  end
+end

data/lib/httpkit/support/handler_manager.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module HTTPkit
+  module Support
+    class HandlerManager
+      def initialize(handlers)
+        @handlers = handlers
+      end
+
+      def notify(message, *args)
+        @handlers.each do |handler|
+          handler.public_send(message, *args) if handler.respond_to?(message)
+        end
+      end
+
+      # XXX not mutation covered
+      module Setup
+        def setup_handlers
+          @handlers = Support::HandlerManager.new(@config[:handlers] || [])
+          @handlers.notify(:setup, @config, self, @connection)
+        end
+      end
+    end
+  end
+end

data/lib/httpkit/support/message.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module HTTPkit
+  module Support
+    module Message
+      def closed?
+        !body.closed.pending?
+      end
+
+      def closed!
+        body.closed.sync
+      end
+
+      def closed(&block)
+        body.closed.then(&block)
+      end
+
+      def close
+        body.closed.fulfill
+      end
+
+      def reject_closed(reason)
+        body.closed.reject(reason)
+      end
+
+      def add_extra_headers(extra)
+        extra.each { |k, v| headers.key?(k) || headers[k] = v }
+      end
+
+      def self.build(parser)
+        if parser.http_method
+          build_request(parser)
+        else
+          build_response(parser)
+        end
+      end
+
+      private
+
+      def self.build_request(parser)
+        request = Request.new(http_method_from(parser),
+                              parser.request_url,
+                              parser.headers,
+                              Body.new)
+        request.http_version = http_version_from(parser)
+        request
+      end
+
+      def self.build_response(parser)
+        response = Response.new(parser.status_code,
+                                parser.headers,
+                                Body.new)
+        response.http_version = http_version_from(parser)
+        response
+      end
+
+      def self.http_method_from(parser)
+        parser.http_method.downcase.to_sym
+      end
+
+      def self.http_version_from(parser)
+        parser.http_version.join('.').to_f
+      end
+    end
+  end
+end

data/lib/httpkit/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module HTTPkit
+  VERSION = '0.6.0.pre.3'
+end