hatetepe 0.6.0.pre → 0.6.0.pre.1

data/lib/hatetepe/promise.rb

@@ -51,12 +51,17 @@ module Hatetepe
         klass.extend(ClassMethods)
       end
 
-      def initialize
-        self.class.send(:promises).map { |name| send(name) }
+      def initialize(*args)
+        super(*args)
+        promises.map { |name| send(name) }
       end
 
       private
 
+      def promises
+        self.class.send(:promises)
+      end
+
       def get_or_set_promise(ivar)
         if instance_variable_defined?(ivar)
           instance_variable_get(ivar)

data/lib/hatetepe/request.rb

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

data/lib/hatetepe/response.rb

@@ -1,17 +1,15 @@
 # encoding: utf-8
 
 module Hatetepe
+  Response = Struct.new(:status, :headers, :body, :http_version)
+
   class Response
-    include Promise::Attribute
-    promise :finished
+    private :status=, :headers=, :body=
 
-    attr_reader :status, :headers, :body
-    attr_accessor :http_version
+    include Support::Message
 
     def initialize(status, headers = {}, body = '')
-      @status, @headers, @body = status, headers, body
-      @http_version = 1.1
-      super()
+      super(status, headers, Body.build(body), 1.1)
     end
 
     def status_name

data/lib/hatetepe/serializer.rb

@@ -14,7 +14,6 @@ module Hatetepe
     extend Forwardable
     def_delegator :@message, :headers
     def_delegator :@message, :body
-    def_delegator :@message, :finished
 
     def initialize(message, writer)
       @message = message
@@ -32,8 +31,8 @@ module Hatetepe
 
     private
 
-    def write(data)
-      @writer.call(data)
+    def write(*data)
+      data.each { |str| @writer.call(str) }
     end
 
     def banana_line

data/lib/hatetepe/serializer/encoding.rb

@@ -5,11 +5,11 @@ module Hatetepe
     module Encoding
       TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
       CHUNKED = 'chunked'.freeze
-      CHUNK = "%d\r\n%s\r\n".freeze
+      CRLF = "\r\n".freeze
       CONTENT_LENGTH = 'Content-Length'.freeze
 
       def setup_body
-        if finished.pending?
+        if body.closed.pending?
           setup_chunked_encoding
           setup_chunked_streaming
         else
@@ -23,22 +23,18 @@ module Hatetepe
       end
 
       def setup_chunked_streaming
-        finished.on_progress do |chunk|
-          write_chunk(chunk)
-        end
-        finished.then { |_| write_chunk!('') }
+        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.bytesize
+        headers[CONTENT_LENGTH] = body.to_s.bytesize
       end
 
       def write_body
-        if finished.pending?
-          write_chunk(body)
-        else
-          write(body)
+        if headers.key?(CONTENT_LENGTH)
+          write(body.to_s)
         end
       end
 
@@ -47,11 +43,7 @@ module Hatetepe
       end
 
       def write_chunk!(chunk)
-        write(body_chunk(chunk))
-      end
-
-      def body_chunk(chunk)
-        sprintf(CHUNK, chunk.bytesize, chunk)
+        write(chunk.bytesize, CRLF, chunk, CRLF)
       end
     end
   end

data/lib/hatetepe/server.rb

@@ -15,26 +15,30 @@ module Hatetepe
 
     def initialize(config, connection)
       @config = config
-      @connection = connection
 
+      setup_connection(connection)
       setup_handlers
-      setup_connection
-
-      notify_handlers(:post_init)
+      notify_handlers(:setup)
     end
 
     def serve(request)
-      request.served.then { |response| respond(request, response) }
+      served = Promise.new
+      served.then { |response| respond(request, response) }
+
+      Fiber.new { notify_handlers(:serve, request, served) }.resume
+    end
 
+    def respond(request, response)
       fiber = Fiber.new do
-        notify_handlers(:serve, request)
+        notify_handlers(:respond, request, response)
+        @connection.serialize(response)
+        response.closed { finish(request) }
       end
       fiber.resume
     end
 
-    def respond(request, response)
-      notify_handlers(:respond, request, response)
-      @connection.serialize(response)
+    def finish(request)
+      notify_handlers(:finish, request)
     end
 
     def close
@@ -43,7 +47,8 @@ module Hatetepe
 
     private
 
-    def setup_connection
+    def setup_connection(connection)
+      @connection = connection
       @connection.parse(method(:serve))
       @connection.closed.then(method(:shutdown))
     end

data/lib/hatetepe/server/keep_alive.rb

@@ -6,58 +6,53 @@ module Hatetepe
     CLOSE = 'close'.freeze
     KEEP_ALIVE = 'keep-alive'.freeze
 
-    include Support::KeepAlive
-
-    def initialize(config, server, connection)
-      @config, @server = config, server
-      @connection = connection
-      @requests = []
+    def initialize(_, server, _)
+      @server = server
+      @requests, @previous = {}, nil
     end
 
-    def serve(request)
-      @requests << request
+    def serve(request, served)
+      @requests[request] = [served, @previous]
+      @previous = request
     end
 
     def respond(request, response)
-      synchronize_responses(request, response)
-
-      version = request.http_version
-      header  = connection_header(request, response)
+      synchronize_responses(request)
 
-      if close_connection?(version, header)
+      if close_connection?(request)
         response.headers[CONNECTION] = CLOSE
-        close_connection(response)
+        # 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, response)
-      wait_for_previous(request)
+    def synchronize_responses(request)
+      _, previous = @requests[request]
+      served, _   = @requests[previous]
 
-      callback = proc { @requests.delete(request) }
-      response.finished.then(callback, callback)
+      served.sync.closed! if served
     end
 
-    def wait_for_previous(request)
-      previous = @requests[@requests.index(request) - 1]
-      if previous
-        response = previous.served.sync
-        response.finished.sync
-      end
+    def connection_header(request)
+      response = @requests[request][0].value
+      request.headers[CONNECTION] || response.headers[CONNECTION]
     end
 
-    def connection_header(request, response)
-      header = request.headers[CONNECTION] || response.headers[CONNECTION]
-      header.to_s.downcase
+    def close_connection?(request)
+      header = connection_header(request).to_s.downcase
+      header == CLOSE || http10_close?(request.http_version, header)
     end
 
-    def close_connection(response)
-      callback = proc { |arg| @server.close }
-      # XXX possible race condition with other locations waiting for this
-      response.finished.then(callback, callback)
+    def http10_close?(version, header)
+      version < 1.1 && header != KEEP_ALIVE
     end
   end
 end

data/lib/hatetepe/server/timeouts.rb

@@ -3,14 +3,14 @@
 module Hatetepe
   # @see EM.heartbeat_interval
   class Server::Timeouts
-    def initialize(config, server, connection)
-      @config, @server = config, server
+    def initialize(config, _, connection)
+      @config = config
       @connection = connection
 
       @config[:timeout] ||= 2.0
     end
 
-    def post_init
+    def setup
       @connection.comm_inactivity_timeout = @config[:timeout]
     end
   end

data/lib/hatetepe/support/message.rb

@@ -2,7 +2,27 @@
 
 module Hatetepe
   module Support
-    class Message
+    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 self.build(parser)
         if parser.http_method
           build_request(parser)
@@ -16,14 +36,16 @@ module Hatetepe
       def self.build_request(parser)
         request = Request.new(http_method_from(parser),
                               parser.request_url,
-                              parser.headers)
+                              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)
+                                parser.headers,
+                                Body.new)
         response.http_version = http_version_from(parser)
         response
       end

data/lib/hatetepe/version.rb

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

data/spec/integration/keep_alive_spec.rb

@@ -6,36 +6,29 @@ describe do
   include_context :server_client_pair
 
   let(:server_config) do
-    { handlers: [SpecHandler, Hatetepe::Server::KeepAlive] }
+    { handlers: [Hatetepe::Server::KeepAlive, SpecHandler] }
   end
   let(:client_config) do
     { handlers: [Hatetepe::Client::KeepAlive] }
   end
 
-  let(:responses) do
-    requests.each do |request|
-      client.perform(request)
-    end
-
-    requests.map do |request|
-      request.served.sync.tap do |response|
-        response.finished.sync if response
-      end
-    end
+  let!(:served) do
+    requests.map { |request| client.perform(request) }
   end
+  let(:responses) { served.map(&:sync) }
 
   describe Hatetepe::Server, 'with KeepAlive' do
     let(:requests) do
-      [finished_request(:get, '/sleep'), finished_request]
+      [closed_request(:get, '/sleep'), closed_request]
     end
 
     it 'sends responses in the correct order' do
-      expect(responses[0].body).to eq('/sleep')
-      expect(responses[1].body).to eq('/')
+      expect(responses[0].body.to_s).to eq('/sleep')
+      expect(responses[1].body.to_s).to eq('/')
     end
 
     describe 'and HTTP/1.1 request' do
-      let(:requests) { [finished_request] }
+      let(:requests) { [closed_request] }
 
       it 'assumes Connection: keep-alive' do
         expect(client).not_to be_closed
@@ -47,7 +40,7 @@ describe do
 
     describe 'and HTTP/1.0 request' do
       let(:requests) do
-        [finished_request.tap { |r| r.http_version = 1.0 }]
+        [closed_request.tap { |r| r.http_version = 1.0 }]
       end
 
       it 'assumes Connection: close' do
@@ -62,7 +55,7 @@ describe do
 
     describe 'and Connection: keep-alive' do
       let(:requests) do
-        [finished_request(:get, '/', { 'Connection' => 'keep-alive' })
+        [closed_request(:get, '/', { 'Connection' => 'keep-alive' })
           .tap { |r| r.http_version = 1.0 }]
       end
 
@@ -76,7 +69,7 @@ describe do
 
     describe 'and Connection: close' do
       let(:requests) do
-        [finished_request(:get, '/', 'Connection' => 'close')]
+        [closed_request(:get, '/', 'Connection' => 'close')]
       end
 
       it 'closes the connection after sending the response' do
@@ -92,15 +85,16 @@ describe do
 
   describe Hatetepe::Client, 'with KeepAlive' do
     let(:requests) do
-      [finished_request(:get, '/close'), finished_request]
+      [open_request(:get, '/?1'), closed_request(:get, '/?2')]
     end
 
-    it 'negotiates keep-alive before sending further requests' do
-      expect_any_instance_of(SpecHandler)
-        .to receive(:serve).once.and_call_original
+    before do
+      requests[0].close
+    end
 
-      expect(responses[0].body).to eq('/close')
-      expect(responses[1]).to be_nil
+    it 'sends one request at a time' do
+      expect(responses[0].body.to_s).to eq('/?1')
+      expect(responses[1].body.to_s).to eq('/?2')
     end
   end
 end