hatetepe 0.5.2 → 0.6.0.pre

data/lib/hatetepe/response.rb

@@ -1,28 +1,88 @@
-require "hatetepe/message"
+# encoding: utf-8
 
 module Hatetepe
-  class Response < Message
-    attr_accessor :status, :request
-    
-    def initialize(status, headers = {}, body = nil, http_version = "1.1")
-      @status = status
-      super headers, body, http_version
-    end
-    
-    def success?
-      status.between? 100, 399
-    end
-    
-    def failure?
-      status.between? 400, 599
-    end
-    
-    def to_a
-      [status, headers, body]
+  class Response
+    include Promise::Attribute
+    promise :finished
+
+    attr_reader :status, :headers, :body
+    attr_accessor :http_version
+
+    def initialize(status, headers = {}, body = '')
+      @status, @headers, @body = status, headers, body
+      @http_version = 1.1
+      super()
     end
-    
-    def [](idx)
-      to_a[idx]
+
+    def status_name
+      STATUS_NAMES[status.to_i] || UNKNOWN_STATUS
     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/hatetepe/serializer/encoding.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Hatetepe
+  class Serializer
+    module Encoding
+      TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+      CHUNKED = 'chunked'.freeze
+      CHUNK = "%d\r\n%s\r\n".freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+
+      def setup_body
+        if finished.pending?
+          setup_chunked_encoding
+          setup_chunked_streaming
+        else
+          setup_identity_encoding
+        end
+      end
+
+      def setup_chunked_encoding
+        headers.delete(CONTENT_LENGTH)
+        headers[TRANSFER_ENCODING] = CHUNKED
+      end
+
+      def setup_chunked_streaming
+        finished.on_progress do |chunk|
+          write_chunk(chunk)
+        end
+        finished.then { |_| write_chunk!('') }
+      end
+
+      def setup_identity_encoding
+        headers.delete(TRANSFER_ENCODING)
+        headers[CONTENT_LENGTH] = body.bytesize
+      end
+
+      def write_body
+        if finished.pending?
+          write_chunk(body)
+        else
+          write(body)
+        end
+      end
+
+      def write_chunk(chunk)
+        write_chunk!(chunk) unless chunk.empty?
+      end
+
+      def write_chunk!(chunk)
+        write(body_chunk(chunk))
+      end
+
+      def body_chunk(chunk)
+        sprintf(CHUNK, chunk.bytesize, chunk)
+      end
+    end
+  end
+end

data/lib/hatetepe/serializer.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'forwardable'
+
+module Hatetepe
+  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_delegator :@message, :finished
+
+    def initialize(message, writer)
+      @message = message
+      @writer = writer
+    end
+
+    def serialize
+      setup_body
+
+      write(banana_line)
+      write(header_block)
+
+      write_body
+    end
+
+    private
+
+    def write(data)
+      @writer.call(data)
+    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 << sprintf(HEADER, *e) } + CRLF
+    end
+  end
+end

data/lib/hatetepe/server/keep_alive.rb

@@ -1,23 +1,63 @@
-module Hatetepe::Server
-  class KeepAlive
-    def initialize(app, connection)
-      @app, @connection = app, connection
+# encoding: utf-8
+
+module Hatetepe
+  class Server::KeepAlive
+    CONNECTION = 'Connection'.freeze
+    CLOSE = 'close'.freeze
+    KEEP_ALIVE = 'keep-alive'.freeze
+
+    include Support::KeepAlive
+
+    def initialize(config, server, connection)
+      @config, @server = config, server
+      @connection = connection
+      @requests = []
     end
 
-    def call(request, &respond)
-      @app.call(request) do |response|
-        respond.call(response)
-        maybe_close(request, response)
+    def serve(request)
+      @requests << request
+    end
+
+    def respond(request, response)
+      synchronize_responses(request, response)
+
+      version = request.http_version
+      header  = connection_header(request, response)
+
+      if close_connection?(version, header)
+        response.headers[CONNECTION] = CLOSE
+        close_connection(response)
+      else
+        response.headers[CONNECTION] = KEEP_ALIVE
       end
     end
 
-    def maybe_close(request, response)
-      version = request.http_version.to_f
-      header  = request.headers["Connection"] || response.headers["Connection"]
+    private
 
-      if (version < 1.1 && header != "keep-alive") || header == "close"
-        @connection.stop!
+    def synchronize_responses(request, response)
+      wait_for_previous(request)
+
+      callback = proc { @requests.delete(request) }
+      response.finished.then(callback, callback)
+    end
+
+    def wait_for_previous(request)
+      previous = @requests[@requests.index(request) - 1]
+      if previous
+        response = previous.served.sync
+        response.finished.sync
       end
     end
+
+    def connection_header(request, response)
+      header = request.headers[CONNECTION] || response.headers[CONNECTION]
+      header.to_s.downcase
+    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)
+    end
   end
 end

data/lib/hatetepe/server/timeouts.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Hatetepe
+  # @see EM.heartbeat_interval
+  class Server::Timeouts
+    def initialize(config, server, connection)
+      @config, @server = config, server
+      @connection = connection
+
+      @config[:timeout] ||= 2.0
+    end
+
+    def post_init
+      @connection.comm_inactivity_timeout = @config[:timeout]
+    end
+  end
+end

data/lib/hatetepe/server.rb

@@ -1,102 +1,54 @@
-require "eventmachine"
-require "em-synchrony"
-
-require "hatetepe/builder"
-require "hatetepe/connection"
-require "hatetepe/parser"
-require "hatetepe/server/keep_alive"
-require "hatetepe/server/pipeline"
-require "hatetepe/server/rack_app"
-require "hatetepe/version"
-
-module Hatetepe::Server
-  include Hatetepe::Connection
-
-  attr_reader :config, :requests
+# encoding: utf-8
+
+module Hatetepe
+  class Server
+    def self.start(config)
+      callback = proc { |connection| new(config, connection) }
+      EM.start_server(config[:address], config[:port],
+                      Connection::EventMachine, callback)
+    end
 
-  CONFIG_DEFAULTS = {
-    :timeout => 5.0,
-    :app     => [ Pipeline, KeepAlive, RackApp ]
-  }
+    include Support::Handlers
+    include Connection::Status
 
-  # @api public
-  def self.start(config)
-    EM.start_server(config[:host], config[:port], self, config)
-  end
+    attr_reader :config
 
-  # @api semipublic
-  def initialize(config)
-    @config = CONFIG_DEFAULTS.merge(config).freeze
-  end
+    def initialize(config, connection)
+      @config = config
+      @connection = connection
 
-  # @api semipublic
-  def post_init
-    @parser, @builder = Hatetepe::Parser.new, Hatetepe::Builder.new
-    @parser.on_request &method(:process_request)
-    @builder.on_write  &method(:send_data)
-    # @builder.on_write {|data| p "<--| #{data}" }
+      setup_handlers
+      setup_connection
 
-    @app = build_app(config[:app])
+      notify_handlers(:post_init)
+    end
 
-    self.comm_inactivity_timeout = config[:timeout]
-  end
+    def serve(request)
+      request.served.then { |response| respond(request, response) }
 
-  # @api semipubic
-  def receive_data(data)
-    # p "-->| #{data}"
-    @parser << data
-  rescue Object => ex
-    puts [ex.message, *ex.backtrace].join("\n\t")
-    close_connection
-  end
-
-  # @api private
-  def process_request(request)
-    Fiber.new do
-      @app.call(request) do |response|
-        send_response(request, response)
+      fiber = Fiber.new do
+        notify_handlers(:serve, request)
       end
-    end.resume
-  end
-
-  # @api private
-  def send_response(request, response)
-    self.comm_inactivity_timeout = 0
-    @builder.response(response.to_a)
-    self.comm_inactivity_timeout = config[:timeout]
-
-    if response.failure?
-      request.fail(response)
-    else
-      request.succeed(response)
+      fiber.resume
     end
-  end
 
-  # @api semipublic
-  def unbind(reason)
-    super
-  end
+    def respond(request, response)
+      notify_handlers(:respond, request, response)
+      @connection.serialize(response)
+    end
 
-  # @api public
-  def stop
-  end
+    def close
+      @connection.close
+    end
 
-  # @api public
-  def stop!
-    close_connection_after_writing
-  end
+    private
 
-  private
+    def setup_connection
+      @connection.parse(method(:serve))
+      @connection.closed.then(method(:shutdown))
+    end
 
-  def build_app(app)
-    app =
-      if app.respond_to?(:call)
-        [ *CONFIG_DEFAULTS[:app], app ]
-      else
-        app.dup
-      end
-    app.inject(app.pop) do |inner, outer|
-      outer.new(inner, self)
+    def shutdown(_)
     end
   end
 end

data/lib/hatetepe/support/handlers.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Hatetepe
+  module Support
+    module Handlers
+      def setup_handlers
+        @handlers = @config[:handlers].map do |klass|
+          klass.new(@config, self, @connection)
+        end
+      end
+
+      def notify_handlers(hook, *args)
+        @handlers.each do |handler|
+          handler.send(hook, *args) if handler.respond_to?(hook)
+        end
+      end
+    end
+  end
+end

data/lib/hatetepe/support/keep_alive.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Hatetepe
+  module Support
+    module KeepAlive
+      CLOSE = 'close'.freeze
+      KEEP_ALIVE = 'keep-alive'.freeze
+
+      def close_connection?(version, header)
+        (version < 1.1 && header != KEEP_ALIVE) || header == CLOSE
+      end
+    end
+  end
+end

data/lib/hatetepe/support/message.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Hatetepe
+  module Support
+    class Message
+      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)
+        request.http_version = http_version_from(parser)
+        request
+      end
+
+      def self.build_response(parser)
+        response = Response.new(parser.status_code,
+                                parser.headers)
+        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/hatetepe/version.rb

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

data/lib/hatetepe.rb

@@ -1,7 +1,29 @@
-require "hatetepe/builder"
-require "hatetepe/client"
-require "hatetepe/parser"
-require "hatetepe/request"
-require "hatetepe/response"
-require "hatetepe/server"
-require "hatetepe/version"
+# encoding: utf-8
+
+require 'eventmachine'
+require 'fiber'
+require 'promise'
+require 'http/parser'
+
+require 'hatetepe/version'
+
+require 'hatetepe/errors'
+require 'hatetepe/support/handlers'
+require 'hatetepe/support/keep_alive'
+require 'hatetepe/support/message'
+
+require 'hatetepe/promise'
+require 'hatetepe/request'
+require 'hatetepe/response'
+
+require 'hatetepe/connection/eventmachine'
+require 'hatetepe/connection/status'
+require 'hatetepe/serializer/encoding'
+require 'hatetepe/serializer'
+
+require 'hatetepe/client'
+require 'hatetepe/client/keep_alive'
+require 'hatetepe/client/timeouts'
+require 'hatetepe/server'
+require 'hatetepe/server/keep_alive'
+require 'hatetepe/server/timeouts'

data/spec/integration/error_handling_spec.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Error handling' do
+  specify { pending('Needs more thought') }
+end