hatetepe 0.5.2 → 0.6.0.pre

data/lib/hatetepe/client/keep_alive.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Hatetepe
+  class Client::KeepAlive
+    CONNECTION = 'Connection'.freeze
+
+    include Support::KeepAlive
+
+    def initialize(config, client, connection)
+      @config, @client = config, client
+      @connection = connection
+      @close = nil
+      @requests = []
+    end
+
+    def perform(request)
+      previous_request = current_request
+      @requests << request
+
+      if @close.nil?
+        await_connection_header(request)
+      elsif !@close
+        await_previous_response(previous_request) if previous_request
+      end
+    end
+
+    def receive(request, response)
+      @requests.delete(request)
+    end
+
+    private
+
+    def current_request
+      @requests.first
+    end
+
+    def await_connection_header(request)
+      if current_request == request
+        # first response has the relevant Connection header
+        assume_connection_header
+      else
+        # subsequent requests wait for first response
+        current_request.served.sync
+      end
+    end
+
+    def assume_connection_header
+      current_request.served.then do |response|
+        @close = close_connection?(response.http_version,
+                                   response.headers[CONNECTION])
+      end
+    end
+
+    def await_previous_response(request)
+      response = request.served.sync
+      response.finished.sync
+    end
+  end
+end

data/lib/hatetepe/client/timeouts.rb

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

data/lib/hatetepe/client.rb

@@ -1,327 +1,79 @@
-require "em-synchrony"
-require "eventmachine"
-
-require "hatetepe/builder"
-require "hatetepe/connection"
-require "hatetepe/parser"
-require "hatetepe/request"
-require "hatetepe/version"
+# encoding: utf-8
 
 module Hatetepe
-  HatetepeError = Class.new(StandardError)
-  RequestError  = Class.new(HatetepeError)
-  ClientError   = Class.new(RequestError)
-  ServerError   = Class.new(RequestError)
-end
-
-module Hatetepe::Client
-  include Hatetepe::Connection
-
-  # @api private
-  Job = Struct.new(:fiber, :request, :sent, :response)
-
-  # The default configuration.
-  #
-  # @api public
-  CONFIG_DEFAULTS = {
-    :timeout         => 5,
-    :connect_timeout => 5
-  }
-
-  # The configuration for this Client instance.
-  #
-  # @api public
-  attr_reader :config
-
-  # The pipe of middleware and request transmission/response reception.
-  #
-  # @api private
-  attr_reader :app
-
-  # Initializes a new Client instance.
-  #
-  # @param [Hash] config
-  #   Configuration values that overwrite the defaults.
-  #
-  # @api semipublic
-  def initialize(config)
-    @config = CONFIG_DEFAULTS.merge(config)
-    @ssl_handshake_completed = EM::DefaultDeferrable.new
-  end
-
-  # Initializes the parser, request queue, and middleware pipe.
-  #
-  # @see EM::Connection#post_init
-  #
-  # @api semipublic
-  def post_init
-    @builder, @parser   =  Hatetepe::Builder.new, Hatetepe::Parser.new
-    @builder.on_write   << method(:send_data)
-    # @builder.on_write {|data| p "|--> #{data}" }
-    @parser.on_response << method(:receive_response)
-
-    @queue = []
-
-    @app = proc {|request| send_request(request) }
+  class Client
+    include Support::Handlers
+    include Connection::Status
 
-    self.comm_inactivity_timeout = config[:timeout]
-    self.pending_connect_timeout = config[:connect_timeout]
+    attr_reader :config
 
-    start_tls if config[:ssl]
-  end
-
-  def ssl_handshake_completed
-    EM::Synchrony.next_tick { @ssl_handshake_completed.succeed }
-  end
-
-  # Feeds response data into the parser.
-  #
-  # @see EM::Connection#receive_data
-  #
-  # @param [String] data
-  #   The received data that's gonna be fed into the parser.
-  #
-  # @api semipublic
-  def receive_data(data)
-    # p "|<-- #{data}"
-    @parser << data
-  end
-
-  # Aborts all outstanding requests.
-  #
-  # @see EM::Connection#unbind
-  #
-  # @api semipublic
-  def unbind(reason)
-    super
-    @queue.each {|job| job.fiber.resume(:kill) }
-  end
+    def initialize(config)
+      @config = config
+      @requests = []
 
-  # Sends a request and waits for the response without blocking.
-  #
-  # Transmission and reception are performed within a separate +Fiber+.
-  # +#succeed+ and +#fail+ will be called on the +request+ passing the
-  # response, depending on whether the response indicates success (100-399)
-  # or failure (400-599).
-  #
-  # The request will +#fail+ with a +nil+ response if the connection was
-  # closed for whatever reason.
-  #
-  # TODO find out if there are more cases where the response body
-  #      should automatically be closed.
-  #
-  # @api public
-  def <<(request)
-    Fiber.new do
-      EM::Synchrony.sync(@ssl_handshake_completed) if config[:ssl]
+      setup_connection
+      setup_handlers
+      notify_handlers(:post_init)
+    end
 
-      response = @app.call(request)
+    def request(http_method, uri)
+      request = Request.new(http_method, uri)
+      request.finished.fulfill
+      perform(request)
+      request.served.sync
+    end
 
-      if response && (request.verb == "HEAD" || response.status == 204)
-        response.body.close_write
-      end
+    def perform(request)
+      @requests << request
 
-      if !response
-        request.fail
-      elsif response.failure?
-        request.fail(response)
-      else
-        request.succeed(response)
+      fiber = Fiber.new do
+        notify_handlers(:perform, request)
+        @connection.serialize(request)
       end
-    end.resume
-  end
-
-  # Builds a +Request+, sends it, and blocks while waiting for the response.
-  #
-  # @param [Symbol, String] verb
-  #   The HTTP method verb, e.g. +:get+ or +"PUT"+.
-  # @param [String, URI]    uri
-  #   The request URI.
-  # @param [Hash]           headers (optional)
-  #   The request headers.
-  # @param [#each]          body    (optional)
-  #   A request body object whose +#each+ method yields objects that respond
-  #   to +#to_s+.
-  #
-  # @return [Hatetepe::Response, nil]
-  #
-  # @api public
-  def request(verb, uri, headers = {}, body = [])
-    uri = URI(uri)
-    uri.scheme ||= @config[:ssl] ? 'http' : 'https'
-    uri.host ||= @config[:host]
-    uri.port ||= @config[:port]
-
-    headers['Host'] ||= "#{uri.host}:#{uri.port}"
-
-    request =  Hatetepe::Request.new(verb, URI(uri.to_s), headers, body)
-    self    << request
-    EM::Synchrony.sync(request)
-  end
-
-  # Like +#request+, but raises errors for 4xx and 5xx responses.
-  #
-  # @param [Symbol, String] verb
-  #   The HTTP method verb, e.g. +:get+ or +"PUT"+.
-  # @param [String, URI]    uri
-  #   The request URI.
-  # @param [Hash]           headers (optional)
-  #   The request headers.
-  # @param [#each]          body    (optional)
-  #   A request body object whose +#each+ method yields objects that respond
-  #   to +#to_s+.
-  #
-  # @return [Hatetepe]::Response, nil]
-  #
-  # @raise [Hatetepe::ClientError]
-  #   If the server responded with a 4xx status code.
-  # @raise [Hatetepe::ServerError]
-  #   If the server responded with a 5xx status code.
-  # @raise [Hatetepe::RequestError]
-  #   If the client failed to receive any response at all.
-  def request!(verb, uri, headers = {}, body = [])
-    response = request(verb, uri, headers, body)
-
-    if response.nil?
-      raise Hatetepe::RequestError
-    elsif response.status >= 500
-      raise Hatetepe::ServerError
-    elsif response.status >= 400
-      raise Hatetepe::ClientError
+      fiber.resume
     end
 
-    response
-  end
-
-  # Gracefully stops the client.
-  #
-  # Waits for all requests to finish and then stops the client.
-  #
-  # @api public
-  def stop
-    wait
-    stop!
-  end
-
-  # Immediately stops the client by closing the connection.
-  #
-  # This will lead to EventMachine's event loop calling {#unbind}, which fail
-  # all outstanding requests.
-  #
-  # @see #unbind
-  #
-  # @api public
-  def stop!
-    close_connection
-  end
-
-  # Blocks until the last request has finished receiving its response.
-  #
-  # Returns immediately if there are no outstanding requests.
-  #
-  # @api public
-  def wait
-    if job = @queue.last
-      EM::Synchrony.sync(job.request)
-      EM::Synchrony.sync(job.response.body) if job.response
+    def close
+      @connection.close
     end
-  end
 
-  # Starts a new Client.
-  #
-  # @param [Hash] config
-  #   The +:host+ and +:port+ the Client should connect to.
-  #
-  # @return [Hatetepe::Client]
-  #   The new Client instance.
-  #
-  # @api public
-  def self.start(config)
-    EM.connect(config[:host], config[:port], self, config)
-  end
-
-  # @api public
-  def self.request(verb, uri, headers = {}, body = [])
-    uri    = URI(uri)
-    client = start(host: uri.host, port: uri.port, ssl: uri.scheme == 'https')
-    client.request(verb, uri, headers, body)
-  end
-
-  # Feeds the request into the builder and blocks while waiting for the
-  # response to arrive.
-  #
-  # Supports the request bit of HTTP pipelining by waiting until the previous
-  # request has been sent.
-  #
-  # @param [Hatetepe::Request] request
-  #   The request that's gonna be sent.
-  #
-  # @return [Hatetepe::Response, nil]
-  #   The received response or +nil+ if the connection has been closed before
-  #   receiving a response.
-  #
-  # @api private
-  def send_request(request)
-    previous =  @queue.last
-    current  =  Job.new(Fiber.current, request, false)
-    @queue   << current
+    def receive(response)
+      unless (request = correlate(response))
+        raise ClientError, 'Unable to correlate with request'
+      end
 
-    # wait for the previous request to be sent
-    while previous && !previous.sent
-      return if Fiber.yield == :kill
+      setup_cleanup(request, response)
+      notify_handlers(:receive, request, response)
     end
 
-    # send the request
-    self.comm_inactivity_timeout = 0
-    @builder.request(request.to_a)
-    current.sent = true
-    self.comm_inactivity_timeout = config[:timeout]
-
-    # wait for the response
-    while !current.response
-      return if Fiber.yield == :kill
+    def teardown(reason)
+      while (request = @requests.shift)
+        if (response = request.served.value)
+          response.finished.reject(reason)
+        else
+          request.served.reject(reason)
+        end
+      end
     end
 
-    # clean up and return response
-    @queue.delete(current)
-    current.response
-  end
+    private
 
-  # Relates an incoming response to the corresponding request.
-  #
-  # Supports the response bit of HTTP pipelining by relating responses to
-  # requests in the order the requests were sent.
-  #
-  # TODO: raise a more meaningful error.
-  #
-  # @param [Hatetepe::Response] response
-  #   The incoming response
-  #
-  # @raise [RuntimeError]
-  #   There is no request that's waiting for a response.
-  #
-  # @api private
-  def receive_response(response)
-    query = proc {|j| j.response.nil? }
+    def setup_connection
+      @connection =
+        EM.connect(@config[:address], @config[:port], Connection::EventMachine)
+      @connection.parse(method(:receive))
+      @connection.closed.then(method(:teardown))
+    end
 
-    if job = @queue.find(&query)
-      job.response = response
-      job.fiber.resume
-    else
-      raise "Received response but didn't expect one: #{response.status}"
+    def correlate(response)
+      @requests
+        .detect { |request| request.served.pending? }
+        .tap    { |request| request.served.fulfill(response) if request }
     end
-  end
 
-  module VerbMethods
-    [
-      :get, :head, :options, :put, :post, :delete, :patch, :connect
-    ].each do |verb|
-      define_method(verb) do |uri, headers = {}, body = []|
-        request(verb, uri, headers, body)
-      end
+    def setup_cleanup(request, response)
+      callback = proc { @requests.delete(request) }
+      response.finished.then(callback, callback)
     end
   end
-
-  include VerbMethods
-  extend VerbMethods
 end

data/lib/hatetepe/connection/eventmachine.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Hatetepe
+  module Connection
+    class EventMachine < EM::Connection
+      include Promise::Attribute
+      promise :closed
+
+      def initialize(callback = nil)
+        @parser = HTTP::Parser.new(self)
+        callback.call(self) if callback
+      end
+
+      def parse(block)
+        @parse = block
+      end
+
+      def serialize(message)
+        serializer = Serializer.new(message, method(:send_data))
+        serializer.serialize
+      end
+
+      def receive_data(data)
+        # ap data
+        @parser << data
+      # rescue => error
+      #   $stderr.puts(error.to_s)
+      #   @message.finished.reject(error) if @message
+      #   close_connection
+      end
+
+      # def send_data(data)
+      #   ap data
+      #   super
+      # end
+
+      def close
+        @reason ||= :self
+        close_connection_after_writing
+      end
+
+      def unbind(reason)
+        closed.fulfill(@reason || reason)
+      end
+
+      def on_headers_complete(_)
+        @message = Support::Message.build(@parser)
+        @parse.call(@message)
+      end
+
+      def on_body(chunk)
+        @message.body << chunk
+        @message.finished.progress(chunk)
+      end
+
+      def on_message_complete
+        @message.finished.fulfill
+      end
+    end
+  end
+end

data/lib/hatetepe/connection/status.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Hatetepe
+  module Connection
+    module Status
+      def closed?
+        @connection.closed.fulfilled?
+      end
+
+      def closed_by_timeout?
+        closed? && @connection.closed.value == Errno::ETIMEDOUT
+      end
+
+      def closed_by_self?
+        closed? && @connection.closed.value == :self
+      end
+
+      def closed_by_remote?
+        closed? && !closed_by_timeout? && !closed_by_self?
+      end
+
+      # XXX this exists only to support spec/integration/timeout_spec
+      def closed_reason
+        @connection.closed.value
+      end
+    end
+  end
+end

data/lib/hatetepe/errors.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module Hatetepe
+  Error = Class.new(StandardError)
+
+  ClientError = Class.new(Error)
+end

data/lib/hatetepe/promise.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Hatetepe
+  class Promise < ::Promise
+    include ::Promise::Progress
+
+    def fulfill(value = nil)
+      super(value)
+    end
+
+    def reject(reason = nil)
+      super(reason)
+    end
+
+    def sync
+      if fulfilled?
+        return value
+      elsif rejected?
+        return reason
+      end
+
+      sync!
+    end
+
+    def sync!
+      fiber = Fiber.current
+      resume = proc do |arg|
+        EM.next_tick { fiber.resume(arg) }
+        # fiber.resume(arg)
+      end
+
+      self.then(resume, resume)
+      Fiber.yield
+    end
+
+    private
+
+    def defer(callback, arg)
+      EM.next_tick { safe_dispatch(callback, arg) }
+      # safe_dispatch(callback, arg)
+    end
+
+    def safe_dispatch(callback, arg)
+      callback.dispatch(arg)
+    # rescue => error
+    #   ...
+    end
+
+    module Attribute
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      def initialize
+        self.class.send(:promises).map { |name| send(name) }
+      end
+
+      private
+
+      def get_or_set_promise(ivar)
+        if instance_variable_defined?(ivar)
+          instance_variable_get(ivar)
+        else
+          instance_variable_set(ivar, Promise.new)
+        end
+      end
+
+      module ClassMethods
+        private
+
+        def promises
+          @promises ||= []
+        end
+
+        def promise(name)
+          promises << name
+          define_promise(name, "@#{name}")
+        end
+
+        def define_promise(name, ivar)
+          define_method(name) { get_or_set_promise(ivar) }
+        end
+      end
+    end
+  end
+end

data/lib/hatetepe/request.rb

@@ -1,45 +1,21 @@
-require "hatetepe/message"
+# encoding: utf-8
 
 module Hatetepe
-  class Request < Message
-    include EM::Deferrable
-    
-    attr_reader :verb
-    attr_accessor :uri, :response
-    
-    def initialize(verb, uri, headers = {}, body = nil, http_version = "1.1")
-      self.verb = verb
-      @uri = uri
-      super headers, body, http_version
-    end
-    
-    def verb=(verb)
-      @verb = verb.to_s.upcase
-    end
-    
-    def to_a
-      [verb, uri, headers, body, http_version]
-    end
-    
-    def to_h
-      {
-        "rack.version" => [1, 0],
-        "hatetepe.request" => self,
-        "rack.input" => body,
-        "REQUEST_METHOD" => verb.dup,
-        "REQUEST_URI" => uri.dup
-      }.tap do |hsh|
-        headers.each do |key, value|
-          key = key.upcase.gsub /[^A-Z]/, "_"
-          key = "HTTP_#{key}" unless key =~ /^CONTENT_(TYPE|LENGTH)$/
-          hsh[key] = value.dup
-        end
+  class Request
+    include Promise::Attribute
+    promise :finished
+    promise :served
+
+    attr_reader :http_method, :uri, :headers, :body
+    attr_accessor :http_version
 
-        hsh["REQUEST_PATH"], qm, hsh["QUERY_STRING"] = uri.partition("?")
-        hsh["PATH_INFO"], hsh["SCRIPT_NAME"] = hsh["REQUEST_PATH"].dup, ""
-        
-        hsh["HTTP_VERSION"] = "HTTP/#{http_version}"
-      end
+    # 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()
     end
   end
 end