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

data/lib/httpkit/server.rb

@@ -2,10 +2,6 @@
 
 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
@@ -16,7 +12,9 @@ module HTTPkit
     attr_reader :config
 
     def initialize(config, connection)
+      @sequence = 0
       @config = config
+      (@config[:handlers] ||= []).push(MandatoryHandler.new, BodyHandler.new)
 
       setup_connection(connection)
       setup_handlers
@@ -26,37 +24,34 @@ module HTTPkit
       served = Promise.new
       served.then { |response| respond(request, response) }
 
-      Fiber.new { @handlers.notify(:serve, request, served) }.resume
+      serve!(request, served).resume
     end
 
     def respond(request, response)
       fiber = Fiber.new do
-        add_extra_headers(response)
-        respond!(request, response)
-        response.closed { finish(request) }
+        request, response = @handlers.invoke(:respond, request, response)
+        @connection.serialize(response)
+        finish(request)
       end
       fiber.resume
     end
 
     def finish(request)
-      @handlers.notify(:finish, request)
+      @handlers.invoke(: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
+
+    def serve!(request, served)
+      Fiber.new do
+        request.sequence(self, @sequence += 1)
+        request, _ = @handlers.invoke(:serve, request, served)
+      end
+    end
   end
 end

data/lib/httpkit/server/body_handler.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Server::BodyHandler
+    def respond(request, response)
+      response = response.with_headers(response.body_headers)
+
+      yield request, banana_response(request, response)
+    end
+
+    private
+
+    def banana_response(request, response)
+      if !response.body_included? || head?(request)
+        response.with_body('')
+      else
+        response
+      end
+    end
+
+    def head?(request)
+      request.http_method == :head
+    end
+  end
+end

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

@@ -1,48 +1,57 @@
 # encoding: utf-8
 
 module HTTPkit
-  class Server::KeepAlive
+  class Server::KeepAliveHandler
     CONNECTION = 'Connection'.freeze
     CLOSE = 'close'.freeze
     KEEP_ALIVE = 'keep-alive'.freeze
 
     def setup(_, server, _)
       @server = server
-      @requests, @previous = {}, nil
+      @requests = {}
     end
 
     def serve(request, served)
-      @requests[request] = [served, @previous]
-      @previous = request
+      @requests[sequence(request)] = served
     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 }
+        yield request, close_response(response)
       else
-        response.headers[CONNECTION] = KEEP_ALIVE
+        yield request, keep_alive_response(response)
       end
     end
 
     def finish(request)
-      @requests.delete(request)
+      @requests.delete(sequence(request))
     end
 
     private
 
-    def synchronize_responses(request)
-      _, previous = @requests[request]
-      served, _   = @requests[previous]
+    def sequence(request)
+      request.sequence(@server)
+    end
+
+    def close_response(response)
+      # XXX: possible race condition with other locations waiting for this
+      response.closed { @server.close }
+      response.with_headers(CONNECTION => CLOSE)
+    end
 
+    def keep_alive_response(response)
+      response.with_headers(CONNECTION => KEEP_ALIVE)
+    end
+
+    def synchronize_responses(request)
+      served = @requests[sequence(request) - 1]
       served.sync.closed! if served
     end
 
     def connection_header(request)
-      response = @requests[request][0].value
+      response = @requests[sequence(request)].value
       request.headers[CONNECTION] || response.headers[CONNECTION]
     end
 

data/lib/httpkit/server/mandatory_handler.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module HTTPkit
+  class Server::MandatoryHandler
+    SERVER = 'Server'.freeze
+    SERVER_VALUE = "httpkit/#{HTTPkit::VERSION}".freeze
+    DATE = 'Date'.freeze
+
+    def respond(request, response)
+      yield request, response.with_headers(missing_headers(response))
+    end
+
+    private
+
+    def missing_headers(response)
+      headers.reject { |k, _| response.headers.key?(k) }
+    end
+
+    def headers
+      { SERVER => SERVER_VALUE, DATE => Time.now.httpdate }
+    end
+  end
+end

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

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

data/lib/httpkit/support/handler_manager.rb

@@ -7,17 +7,20 @@ module HTTPkit
         @handlers = handlers
       end
 
-      def notify(message, *args)
-        @handlers.each do |handler|
-          handler.public_send(message, *args) if handler.respond_to?(message)
-        end
+      def invoke(message, *arguments)
+        @handlers
+          .select { |handler| handler.respond_to?(message) }
+          .reduce(arguments) do |args, handler|
+            handler.send(message, *args) { |*new_args| args = new_args }
+            args
+          end
       end
 
       # XXX not mutation covered
       module Setup
         def setup_handlers
           @handlers = Support::HandlerManager.new(@config[:handlers] || [])
-          @handlers.notify(:setup, @config, self, @connection)
+          @handlers.invoke(:setup, @config, self, @connection)
         end
       end
     end

data/lib/httpkit/support/message.rb

@@ -3,6 +3,10 @@
 module HTTPkit
   module Support
     module Message
+      TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+      CHUNKED = 'chunked'.freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+
       def closed?
         !body.closed.pending?
       end
@@ -23,11 +27,29 @@ module HTTPkit
         body.closed.reject(reason)
       end
 
-      def add_extra_headers(extra)
-        extra.each { |k, v| headers.key?(k) || headers[k] = v }
+      def body_headers
+        length, encoding = nil, nil
+
+        if body_present?
+          if body.length_known?
+            length = body.length.to_i
+          else
+            encoding = CHUNKED
+          end
+        end
+
+        { CONTENT_LENGTH => length, TRANSFER_ENCODING => encoding }
       end
 
       def self.build(parser)
+        message = build_message(parser)
+        message.close if !message.body_included? || !message.body_present?
+        message
+      end
+
+      private
+
+      def self.build_message(parser)
         if parser.http_method
           build_request(parser)
         else
@@ -35,23 +57,14 @@ module HTTPkit
         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
+        Request.new(http_method_from(parser), parser.request_url,
+                    parser.headers, Body.new, http_version_from(parser))
       end
 
       def self.build_response(parser)
-        response = Response.new(parser.status_code,
-                                parser.headers,
-                                Body.new)
-        response.http_version = http_version_from(parser)
-        response
+        Response.new(parser.status_code, parser.headers, Body.new,
+                     http_version_from(parser))
       end
 
       def self.http_method_from(parser)

data/lib/httpkit/version.rb

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

data/spec/integration/keep_alive_spec.rb

@@ -6,10 +6,10 @@ describe reactor: true do
   include_context :server_client_pair
 
   let(:server_config) do
-    { handlers: [HTTPkit::Server::KeepAlive.new, SpecHandler.new] }
+    { handlers: [HTTPkit::Server::KeepAliveHandler.new, SpecHandler.new] }
   end
   let(:client_config) do
-    { handlers: [HTTPkit::Client::KeepAlive.new] }
+    { handlers: [HTTPkit::Client::KeepAliveHandler.new] }
   end
 
   let!(:served) do
@@ -17,7 +17,7 @@ describe reactor: true do
   end
   let(:responses) { served.map(&:sync) }
 
-  describe HTTPkit::Server, 'with KeepAlive' do
+  describe HTTPkit::Server, 'with KeepAliveHandler' do
     let(:requests) do
       [closed_request(:get, '/sleep'), closed_request]
     end
@@ -41,7 +41,7 @@ describe reactor: true do
 
     describe 'and HTTP/1.0 request' do
       let(:requests) do
-        [closed_request.tap { |r| r.http_version = 1.0 }]
+        [closed_request(:get, '/', {}, nil, 1.0)]
       end
 
       it 'assumes Connection: close' do
@@ -56,8 +56,7 @@ describe reactor: true do
 
     describe 'and Connection: keep-alive' do
       let(:requests) do
-        [closed_request(:get, '/', 'Connection' => 'keep-alive')
-          .tap { |r| r.http_version = 1.0 }]
+        [closed_request(:get, '/', { 'Connection' => 'keep-alive' }, nil, 1.0)]
       end
 
       it 'keeps the connection open' do
@@ -84,7 +83,7 @@ describe reactor: true do
     end
   end
 
-  describe HTTPkit::Client, 'with KeepAlive' do
+  describe HTTPkit::Client, 'with KeepAliveHandler' do
     let(:requests) do
       [open_request(:get, '/?1'), closed_request(:get, '/?2')]
     end

data/spec/integration/smoke_spec.rb

@@ -9,13 +9,13 @@ describe 'Smoke test', reactor: true do
   let(:request)  { intercepted_requests[0] }
 
   it 'exchanges request and response' do
-    expect(response.status).to  be(200)
+    expect(response.status).to be(200)
     expect(response.headers).to include('Content-Length' => '1')
     expect(response.body.to_s).to eq('/')
 
     expect(request.http_method).to be(:get)
-    expect(request.uri).to         eq('/')
-    expect(request.headers).to     include('Content-Length' => '0')
-    expect(request.body.to_s).to   eq('')
+    expect(request.uri).to eq('/')
+    expect(request.headers).not_to have_key('Content-Length')
+    expect(request.body.to_s).to eq('')
   end
 end

data/spec/integration/streaming_spec.rb

@@ -8,8 +8,7 @@ describe 'Request body streaming', reactor: true do
   let(:chunks) { [] }
 
   before do
-    client.perform(request)
-    tick(2)
+    client.perform(request).sync
     Fiber.new do
       intercepted_requests[0].body.each do |chunk|
         chunks << chunk
@@ -21,7 +20,7 @@ describe 'Request body streaming', reactor: true do
 
   subject! do
     %w[foo bar baz].each do |chunk|
-      request.body.closed.progress(chunk)
+      request.body.write(chunk)
       tick
     end
     request.close

data/spec/integration/timeouts_spec.rb

@@ -7,7 +7,7 @@ describe HTTPkit::Client, 'in connecting state', reactor: true do
   let(:address) { '1.2.3.4' }
   let(:client_config) do
     { address: address, port: random_port,
-      handlers: [HTTPkit::Client::Timeouts.new] }
+      handlers: [HTTPkit::Client::TimeoutsHandler.new] }
   end
   let!(:client)  { HTTPkit::Client.start(client_config) }
 
@@ -21,7 +21,7 @@ describe HTTPkit::Client, 'in connecting state', reactor: true do
   describe 'with :connect_timeout option' do
     let(:client_config) do
       { address: address, port: random_port, connect_timeout: 0.01,
-        handlers: [HTTPkit::Client::Timeouts.new] }
+        handlers: [HTTPkit::Client::TimeoutsHandler.new] }
     end
 
     it 'times out after $n seconds' do
@@ -38,7 +38,7 @@ end
 describe HTTPkit::Client, 'in idle state', reactor: true do
   include_context :server_client_pair
 
-  let(:client_config) { { handlers: [HTTPkit::Client::Timeouts.new] } }
+  let(:client_config) { { handlers: [HTTPkit::Client::TimeoutsHandler.new] } }
 
   it 'times out after 2 seconds' do
     # only test the config, and don't actually wait for 2 seconds
@@ -47,7 +47,7 @@ describe HTTPkit::Client, 'in idle state', reactor: true do
 
   describe 'with :timeout option' do
     let(:client_config) do
-      { timeout: 0.01, handlers: [HTTPkit::Client::Timeouts.new] }
+      { timeout: 0.01, handlers: [HTTPkit::Client::TimeoutsHandler.new] }
     end
 
     it 'times out after $n seconds' do
@@ -61,7 +61,7 @@ end
 describe HTTPkit::Server, 'in idle state', reactor: true do
   include_context :server_client_pair
 
-  let(:server_config) { { handlers: [HTTPkit::Server::Timeouts.new] } }
+  let(:server_config) { { handlers: [HTTPkit::Server::TimeoutsHandler.new] } }
 
   it 'times out after 2 seconds' do
     # only test the config, and don't actually wait for 2 seconds
@@ -70,7 +70,7 @@ describe HTTPkit::Server, 'in idle state', reactor: true do
 
   describe 'with :timeout option' do
     let(:server_config) do
-      { timeout: 0.01, handlers: [HTTPkit::Server::Timeouts.new] }
+      { timeout: 0.01, handlers: [HTTPkit::Server::TimeoutsHandler.new] }
     end
 
     it 'times out after $n seconds' do