hatetepe 0.4.1 → 0.5.0.pre

data/examples/parallel_requests.rb

@@ -0,0 +1,32 @@
+require "hatetepe"
+require "awesome_print"
+
+EM.synchrony do
+  # one server
+  app = proc do |env|
+    [200, {"Content-Type" => "text/plain"}, ["Hello, world!"]]
+  end
+  Hatetepe::Server.start :host => "127.0.0.1", :port => 3123, :app => app
+
+  # two clients
+  clients = 2.times.map { Hatetepe::Client.start :host => "127.0.0.1", :port => 3123 }
+
+  # six requests
+  requests = 6.times.map do |i|
+    # no extra headers, empty body
+    req = Hatetepe::Request.new(:get, "/", {}, [])
+
+    # response status between 100 and 399
+    req.callback {|res| puts "request ##{i} finished with #{res.status} response" }
+
+    # response status between 400 and 599 or connection failure
+    req.errback {|res| puts "request ##{i} finished with #{res ? res.status : 'no'} response" }
+
+    clients[i % clients.length] << req
+    req
+  end
+
+  # Client#stop waits until all of its requests have finished
+  clients.map &:stop
+  EM.stop
+end

data/hatetepe.gemspec

@@ -5,6 +5,7 @@ require "hatetepe/version"
 Gem::Specification.new do |s|
   s.name        = "hatetepe"
   s.version     = Hatetepe::VERSION
+  s.date        = Date.today.to_s
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Lars Gierth"]
   s.email       = ["lars.gierth@gmail.com"]
@@ -13,14 +14,12 @@ Gem::Specification.new do |s|
   #s.description = %q{TODO: write description}
 
   s.add_dependency "http_parser.rb", "~> 0.5.3"
-  s.add_dependency "eventmachine"
-  s.add_dependency "em-synchrony", "~> 1.0"
+  s.add_dependency "eventmachine",   "~> 1.0.0.beta.4"
+  s.add_dependency "em-synchrony",   "~> 1.0"
   s.add_dependency "rack"
-  s.add_dependency "async-rack"
   s.add_dependency "thor"
   
   s.add_development_dependency "rspec"
-  s.add_development_dependency "fakefs"
   s.add_development_dependency "yard"
   s.add_development_dependency "rdiscount"
 

data/lib/hatetepe/builder.rb

@@ -135,6 +135,7 @@ module Hatetepe
         @state = :writing_body
       end
       
+      chunk = chunk.to_s
       if chunked?
         write "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
       else

data/lib/hatetepe/cli.rb

@@ -23,11 +23,12 @@ module Hatetepe
     method_option :env, :aliases => "-e", :type => :string,
       :banner => "Boot the app in the specified environment (default: development)"
     method_option :timeout, :aliases => "-t", :type => :numeric,
-      :banner => "Time out connections after the specified admount of seconds (default: 1)"
+      :banner => "Time out connections after the specified admount of seconds (default: see Hatetepe::Server::CONFIG_DEFAULTS)"
     def start
       require "hatetepe/server"
+      require "rack"
       
-      ENV["RACK_ENV"] = expand_env(options[:env]) || ENV["RACK_ENV"] || "development"
+      ENV["RACK_ENV"] = options[:env] || ENV["RACK_ENV"] || "development"
       $stderr << "We're in #{ENV["RACK_ENV"]}\n"
       $stderr.flush
       
@@ -42,30 +43,20 @@ module Hatetepe
         trap("INT") { EM.stop }
         trap("TERM") { EM.stop }
         
-        host = options[:bind] || "127.0.0.1"
-        port = options[:port] || 3000
+        host    = options[:bind]    || "127.0.0.1"
+        port    = options[:port]    || 3000
+        timeout = options[:timeout] || Hatetepe::Server::CONFIG_DEFAULTS[:timeout]
         
         $stderr << "Binding to #{host}:#{port}\n"
         $stderr.flush
+
         Server.start({
-          :app => app,
-          :errors => $stderr,
-          :host => host,
-          :port => port,
-          :timeout => (options[:timeout] || 1)
+          app:     app,
+          host:    host,
+          port:    port,
+          timeout: timeout
         })
       end
     end
-    
-    protected
-    
-    def expand_env(env)
-      env &&= env.dup.downcase
-      case env
-        when /^dev(el(op)?)?$/ then "development"
-        when /^test(ing)?$/ then "testing"
-        else env
-      end
-    end
   end
 end

data/lib/hatetepe/client.rb

@@ -1,218 +1,247 @@
 require "em-synchrony"
 require "eventmachine"
-require "rack"
-require "uri"
 
 require "hatetepe/builder"
 require "hatetepe/connection"
-require "hatetepe/deferred_status_fix"
 require "hatetepe/parser"
 require "hatetepe/request"
 require "hatetepe/version"
 
-module Hatetepe
-  class Client < Hatetepe::Connection; end
-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
+  }
 
-require "hatetepe/client/keep_alive"
-require "hatetepe/client/pipeline"
+  # The configuration for this Client instance.
+  #
+  # @api public
+  attr_reader :config
 
-class Hatetepe::Client
-  attr_reader :app, :config
-  attr_reader :parser, :builder
-  attr_reader :requests, :pending_transmission, :pending_response
-  
+  # 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
-    @parser,  @builder = Hatetepe::Parser.new, Hatetepe::Builder.new
-    
-    @requests = []
-    @pending_transmission, @pending_response = {}, {}
-    
-    @app = Rack::Builder.new.tap do |b|
-      b.use KeepAlive
-      b.use Pipeline
-      b.run method(:send_request)
-    end.to_app
-    
-    super
+    @config = CONFIG_DEFAULTS.merge(config)
   end
-  
+
+  # Initializes the parser, request queue, and middleware pipe.
+  #
+  # TODO: Use +Rack::Builder+ for building the app pipe. 
+  #
+  # @see EM::Connection#post_init
+  #
+  # @api semipublic
   def post_init
-    parser.on_response << method(:receive_response)
-    # XXX check if the connection is still present
-    builder.on_write << method(:send_data)
-    #builder.on_write {|data| p "client >> #{data}" }
-    
-    self.processing_enabled = true
+    @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 = method(:send_request)
+
+    self.comm_inactivity_timeout = config[:timeout]
+    self.pending_connect_timeout = config[:connect_timeout]
   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 "client << #{data}"
-    parser << data
-  rescue => e
-    close_connection
-    raise e
-  end
-  
-  def send_request(request)
-    id = request.object_id
-    
-    request.headers.delete "X-Hatetepe-Single"
-    builder.request request.to_a
-    pending_transmission[id].succeed
-    
-    pending_response[id] = EM::DefaultDeferrable.new
-    EM::Synchrony.sync pending_response[id]
-  ensure
-    pending_response.delete id
+    # p "|<-- #{data}"
+    @parser << data
   end
-  
-  def receive_response(response)
-    requests.find {|req| !req.response }.tap do |req|
-      req.response = response
-      pending_response[req.object_id].succeed response
-    end
+
+  # Aborts all outstanding requests.
+  #
+  # @see EM::Connection#unbind
+  #
+  # @api semipublic
+  def unbind(reason)
+    super
+    @queue.each {|job| job.fiber.resume(:kill) }
   end
-  
-  def <<(request)
-    request.headers["Host"] ||= "#{config[:host]}:#{config[:port]}"
 
-    request.connection = self
-    unless processing_enabled?
-      request.fail
-      return
-    end
-    
-    requests << request
-    
+  # 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.
+  #
+  # @api public
+  def <<(request)
     Fiber.new do
-      begin
-        pending_transmission[request.object_id] = EM::DefaultDeferrable.new
-        
-        app.call(request).tap do |response|
-          request.response = response
-          # XXX check for response.nil?
-          status = (response && response.success?) ? :succeed : :fail
-          requests.delete(request).send status, response
-        end
-      ensure
-        pending_transmission.delete request.object_id
+      response = @app.call(request)
+
+      if !response || response.failure?
+        request.fail(response)
+      else
+        request.succeed(response)
       end
     end.resume
   end
-  
-  def request(verb, uri, headers = {}, body = nil, http_version = "1.1")
-    headers["User-Agent"] ||= "hatetepe/#{Hatetepe::VERSION}"
-    
-    body = wrap_body(body)
-    headers, body = encode_body(headers.dup, body)
-    
-    request = Hatetepe::Request.new(verb, uri, headers, body, http_version)
-    self << request
-
-    # XXX shouldn't this happen in ::request ?
-    self.processing_enabled = false
-    
-    EM::Synchrony.sync request
-    
-    request.response.body.close_write if request.verb == "HEAD"
-    
-    request.response
+
+  # 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 = [])
+    request =  Hatetepe::Request.new(verb, uri, headers, body)
+    self    << request
+    EM::Synchrony.sync(request)
   end
-  
+
+  # Gracefully stops the client.
+  #
+  # Waits for all requests to finish and then stops the client.
+  #
+  # @api public
   def stop
-    unless requests.empty?
-      last_response = EM::Synchrony.sync(requests.last)
-      EM::Synchrony.sync last_response.body if last_response.body
-    end
+    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
-  
-  def unbind
-    super
-    
-    EM.next_tick do
-      requests.each do |req|
-        # fail state triggers
-        req.object_id.tap do |id|
-          pending_transmission[id].fail if pending_transmission[id]
-          pending_response[id].fail if pending_response[id]
-        end
-        # fail reponse body if the response has already been started
-        if req.response
-          req.response.body.tap {|b| b.close_write unless b.closed_write? }
-        end
-        # XXX FiberError: dead fiber called because req already succeeded
-        #     or failed, see github.com/eventmachine/eventmachine/issues/287
-        req.fail req.response
-      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
     end
   end
-  
-  def wrap_body(body)
-    if body.respond_to? :each
-      body
-    elsif body.respond_to? :read
-      [body.read]
-    elsif body
-      [body]
-    else
-      []
-    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
-  
-  def encode_body(headers, body)
-    multipart, urlencoded = false, false
-    if Hash === body
-      query = lambda do |value|
-        case value
-        when Array
-          value.each &query
-        when Hash
-          value.values.each &query
-        when Rack::Multipart::UploadedFile
-          multipart = true
-        end
-      end
-      body.values.each &query
-      urlencoded = !multipart
-    end
-    
-    body = if multipart
-      boundary = Rack::Multipart::MULTIPART_BOUNDARY
-      headers["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
-      [Rack::Multipart.build_multipart(body)]
-    elsif urlencoded
-      headers["Content-Type"] = "application/x-www-form-urlencoded"
-      [Rack::Utils.build_nested_query(body)]
-    else
-      body
-    end
-    
-    [headers, body]
+
+  # @api public
+  def self.request(verb, uri, headers = {}, body = [])
   end
-  
-  class << self
-    def start(config)
-      EM.connect config[:host], config[:port], self, config
+
+  # 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
+
+    # wait for the previous request to be sent
+    while previous && !previous.sent
+      return if Fiber.yield == :kill
     end
-    
-    def request(verb, uri, headers = {}, body = nil)
-      uri = URI(uri)
-      client = start(:host => uri.host, :port => uri.port)
-      
-      headers["X-Hatetepe-Single"] = true
-      client.request(verb, uri.request_uri, headers, body).tap do |*|
-        client.stop
-      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
     end
+
+    # clean up and return response
+    @queue.delete(current)
+    current.response
   end
-  
-  [self, self.singleton_class].each do |cls|
-    [:get, :head, :post, :put, :delete,
-     :options, :trace, :connect].each do |verb|
-      cls.send(:define_method, verb) {|uri, *args| request verb, uri, *args }
+
+  # 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? }
+
+    if job = @queue.find(&query)
+      job.response = response
+      job.fiber.resume
+    else
+      raise "Received response but didn't expect one: #{response.status}"
     end
   end
 end

data/lib/hatetepe/connection.rb

@@ -1,7 +1,5 @@
-require "eventmachine"
-
 module Hatetepe
-  class Connection < EM::Connection
+  module Connection
     attr_accessor :processing_enabled
     alias_method :processing_enabled?, :processing_enabled
     
@@ -16,9 +14,17 @@ module Hatetepe
     def sockaddr
       @sockaddr ||= Socket.unpack_sockaddr_in(get_peername) rescue nil
     end
+
+    def connection_completed
+      @connected = true
+    end
+
+    def connected?
+      defined?(@connected) && @connected
+    end
     
     def closed?
-      !!@closed_by
+      !!defined?(@closed_by)
     end
     
     def closed_by_remote?
@@ -26,17 +32,30 @@ module Hatetepe
     end
     
     def closed_by_self?
-      closed? && !closed_by_remote?
+      @closed_by == :self
     end
-    
-    def close_connection(after_writing = false)
-      @closed_by = :self
-      super after_writing
+
+    def closed_by_timeout?
+      connected? && @closed_by == :timeout
+    end
+
+    def closed_by_connect_timeout?
+      !connected? && @closed_by == :timeout
     end
     
-    # TODO how to detect closed-by-timeout?
-    def unbind
-      @closed_by = :remote unless closed?
+    def close_connection(after_writing = false)
+      @closed_by = :self unless closed?
+      super
+    end
+    
+    def unbind(reason)
+      unless closed?
+        @closed_by = if reason == Errno::ETIMEDOUT
+          :timeout
+        else
+          :remote
+        end
+      end
     end
   end
 end