httpkit 0.6.0.pre.3 → 0.6.0.pre.5

data/lib/httpkit/client.rb

@@ -1,11 +1,22 @@
 # encoding: utf-8
 
 module HTTPkit
+  Error = Class.new(StandardError)
+
   class Client
-    USER_AGENT = 'User-Agent'.freeze
-    USER_AGENT_VALUE = "httpkit/#{HTTPkit::VERSION}".freeze
-    HOST = 'Host'.freeze
-    HOST_VALUE = '%s:%d'.freeze
+    DoubleRequestError = Class.new(Error) do
+      attr_reader :client, :request
+
+      def initialize(client, request)
+        @client, @request = client, request
+        super(sprintf('%s %s already has sequence number %d',
+                      request.http_method, request.uri, sequence))
+      end
+
+      def sequence
+        request.sequence(client)
+      end
+    end
 
     include Support::HandlerManager::Setup
     include Connection::Status
@@ -14,9 +25,16 @@ module HTTPkit
       Connection::EventMachine.start_client(config, self)
     end
 
+    def self.request(*args)
+      uri = URI(args[1])
+      client = start(address: uri.host, port: uri.port)
+      client.request(*args)
+    end
+
     attr_reader :config
 
     def initialize(config, connection)
+      @sequence = 0
       @config = config
       @requests = []
 
@@ -32,12 +50,8 @@ module HTTPkit
     def perform(request)
       served = Promise.new
 
-      if closed?
-        served.reject(@connection.closed.reason)
-      else
-        @requests << [request, served]
-        perform!(request)
-      end
+      request.sequence(self, @sequence += 1)
+      perform!(request, served).resume if validate(request, served)
 
       served
     end
@@ -46,39 +60,49 @@ module HTTPkit
       request, served = find_request
 
       if request
+        # XXX: fulfillment should happen after invoke(:receive), so that all
+        #      handlers have run when the application code resumes
         served.fulfill(response)
-        @handlers.notify(:receive, request, response)
+        request, response = @handlers.invoke(:receive, request, response)
         response.closed { finish(request) }
       end
     end
 
     def finish(request)
-      @requests.delete_if { |(req)| req == request }
-      @handlers.notify(:finish, request)
+      @requests.delete_if do |(other)|
+        request.sequence(self) == other.sequence(self)
+      end
+      @handlers.invoke(:finish, request)
     end
 
     def teardown(reason)
       @requests.each do |_, served|
         served.reject(reason)
-        if (response = served.value)
-          response.reject_closed(reason)
-        end
+        next unless (response = served.value)
+        response.reject_closed(reason)
       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)
+    def validate(request, served)
+      if closed?
+        served.reject(@connection.closed.reason)
+        false
+      elsif request.sequence(self) != @sequence
+        served.reject(DoubleRequestError.new(self, request))
+        false
+      else
+        true
+      end
     end
 
-    def perform!(request)
+    def perform!(request, served)
       Fiber.new do
-        add_extra_headers(request)
-        @handlers.notify(:perform, request)
+        request, _ = @handlers.invoke(:perform, request)
+        @requests << [request, served]
         @connection.serialize(request)
-      end.resume
+      end
     end
 
     def find_request
@@ -90,5 +114,10 @@ module HTTPkit
       @connection.on_message = method(:receive)
       @connection.closed.then(method(:teardown), method(:teardown))
     end
+
+    def setup_handlers
+      (@config[:handlers] ||= []).push(MandatoryHandler.new, BodyHandler.new)
+      super
+    end
   end
 end

data/lib/httpkit/client/body_handler.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Client::BodyHandler
+    def perform(request)
+      request = request.with_headers(request.body_headers)
+
+      yield banana_request(request)
+    end
+
+    private
+
+    def banana_request(request)
+      if !request.body_included?
+        request.with_body('')
+      else
+        request
+      end
+    end
+  end
+end

data/lib/httpkit/client/{keep_alive.rb → keep_alive_handler.rb}

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module HTTPkit
-  class Client::KeepAlive
+  class Client::KeepAliveHandler
     def perform(request)
       @previous, previous = request, @previous
       previous.closed! if previous

data/lib/httpkit/client/mandatory_handler.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Client::MandatoryHandler
+    USER_AGENT = 'User-Agent'.freeze
+    USER_AGENT_VALUE = "httpkit/#{HTTPkit::VERSION}".freeze
+    HOST = 'Host'.freeze
+    HOST_VALUE = '%s:%d'.freeze
+
+    def setup(config, _, _)
+      @config = config
+    end
+
+    def perform(request)
+      yield request.with_headers(missing_headers(request))
+    end
+
+    private
+
+    def missing_headers(request)
+      headers.reject { |k, _| request.headers.key?(k) }
+    end
+
+    def headers
+      host = sprintf(HOST_VALUE, @config[:address], @config[:port])
+      { USER_AGENT => USER_AGENT_VALUE, HOST => host }
+    end
+  end
+end

data/lib/httpkit/client/{timeouts.rb → timeouts_handler.rb}

@@ -2,7 +2,7 @@
 
 module HTTPkit
   # @see EM.heartbeat_interval
-  class Client::Timeouts
+  class Client::TimeoutsHandler
     def setup(config, _, connection)
       @config = config
       @connection = connection

data/lib/httpkit/connection/eventmachine.rb

@@ -24,7 +24,6 @@ module HTTPkit
 
       def serialize(message)
         serializer = Serializer.new(message, method(:send_data))
-        serializer.setup_body
         serializer.serialize
       end
 
@@ -33,12 +32,13 @@ module HTTPkit
         # p data
         @parser << data
       rescue => ex
+        # puts [ex.message, *ex.backtrace].join("\n\t")
         close(ex)
       end
 
       # def send_data(data)
-      #   # p [__id__, :send, data]
-      #   p data
+      #   p [__id__, :send, data]
+      #   # p data
       #   super
       # end
 
@@ -61,7 +61,7 @@ module HTTPkit
       end
 
       def on_body(chunk)
-        @message.body.closed.progress(chunk)
+        @message.body.write(chunk)
       end
 
       def on_message_complete

data/lib/httpkit/request.rb

@@ -1,19 +1,55 @@
 # 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
+    include Adamantium
+
+    attr_reader :http_method, :uri, :headers, :body, :http_version
+
+    def initialize(http_method, uri, headers = {}, body = '',
+                   http_version = 1.1)
+      @http_method = http_method
+      # @uri = URI('http://' + uri)
+      @uri = URI.join('http:///', uri).request_uri
+      @headers = headers
+      @body = Body.build(body)
+      @http_version = http_version
+      @sequences = SequenceHash.new
+    end
+
+    def with_headers(new_headers)
+      with(2, headers.merge(new_headers))
+    end
+
+    def with_body(new_body)
+      with(3, Body.build(new_body))
+    end
 
-    # 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)
+    def with(index, argument)
+      args = [http_method, uri, headers, body, http_version]
+      args[index] = argument
+      new_self(args)
     end
+
+    def new_self(args)
+      other = self.class.new(*args)
+      @sequences.each { |(obj, id)| other.sequence(obj, id) }
+      other
+    end
+
+    def sequence(obj, id = nil)
+      @sequences[obj.object_id] ||= id
+    end
+
+    def body_included?
+      body_present?
+    end
+
+    def body_present?
+      !body.length_known? || !body.length.zero?
+    end
+
+    SequenceHash = Class.new(Hash) { include Adamantium::Mutable }
   end
 end

data/lib/httpkit/response.rb

@@ -1,15 +1,46 @@
 # encoding: utf-8
 
 module HTTPkit
-  Response = Struct.new(:status, :headers, :body, :http_version)
-
   class Response
-    private :status=, :headers=, :body=
+    NOT_INCLUDED = [204, 304]
+    NOT_PRESENT = [205]
 
     include Support::Message
+    include Adamantium
+
+    attr_reader :status, :headers, :body, :http_version
+
+    def initialize(status, headers = {}, body = '', http_version = 1.1)
+      @status = status
+      @headers = headers
+      @body = Body.build(body)
+      @http_version = http_version
+    end
+
+    def with_headers(new_headers)
+      with(1, headers.merge(new_headers))
+    end
+
+    def with_body(new_body)
+      with(2, Body.build(new_body))
+    end
+
+    def with(index, argument)
+      args = [status, headers, body, http_version]
+      args[index] = argument
+      new_self(args)
+    end
+
+    def new_self(args)
+      self.class.new(*args)
+    end
+
+    def body_included?
+      !informational? && !NOT_INCLUDED.include?(status)
+    end
 
-    def initialize(status, headers = {}, body = '')
-      super(status, headers, Body.build(body), 1.1)
+    def body_present?
+      !informational? && !NOT_PRESENT.include?(status)
     end
 
     def status_name
@@ -42,6 +73,7 @@ module HTTPkit
 
     UNKNOWN_STATUS = 'Unknown Status'.freeze
 
+    # TODO: double-check with RFC7230
     STATUS_NAMES =
       { 100 => 'Continue'.freeze,
         101 => 'Switching Protocols'.freeze,

data/lib/httpkit/serializer.rb

@@ -1,48 +1,36 @@
 # encoding: utf-8
 
-require 'forwardable'
-
 module HTTPkit
+  # Streaming HTTP message serializer.
+  #
+  # @api public
+  #
   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
+    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+    CHUNKED = 'chunked'.freeze
+    CONTENT_LENGTH = 'Content-Length'.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
+      @message, @writer = message, writer
     end
 
     def serialize
-      write(banana_line)
+      write(first_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(''))
+      @writer.call(data.join)
     end
 
-    def banana_line
+    def first_line
       if Request === @message
         request_line
       else
@@ -61,15 +49,35 @@ module HTTPkit
     end
 
     def header_block
-      headers.reduce('') { |a, e| a << header_line(*e) } + CRLF
+      @message.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)
+        sprintf(HEADER, key,
+                value.respond_to?(:join) ? value.join(', ') : value)
       end
     end
+
+    def write_body
+      body = @message.body
+      if !body.length_known?
+        body.each { |chunk| write_chunk(chunk) }
+        write_chunk!('')
+      else
+        write(body)
+      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