hatetepe 0.3.1 → 0.4.0

data/README.md

@@ -24,11 +24,13 @@ Using Hatetepe as your HTTP server is easy. Simply use the CLI that ships with
 the gem:
 
     $ hatetepe
+    We're in development
     Booting from /home/lars/workspace/hatetepe/config.ru
     Binding to 127.0.0.1:3000
 
 You can configure the network port and interface as well as the Rackup (.ru)
-file to be used. More help is available via the `hatetepe help` command.
+file to be used and the RACK_ENV to run in. More help is available via the
+`hatetepe help` command.
 
 
 Getting Started (Client)
@@ -37,7 +39,7 @@ Getting Started (Client)
 The `Hatetepe::Client` class can be used to make requests to an HTTP server.
 
     client = Hatetepe::Client.start(:host => "example.org", :port => 80)
-    request = Hatetepe::Request.new("POST", "/search", {}, :q => "herp derp")
+    request = Hatetepe::Request.new(:post, "/search", {}, :q => "herp derp")
     client << request
     request.callback do |response|
       puts "Results:"
@@ -56,7 +58,7 @@ The `Hatetepe::Client` class can be used to make requests to an HTTP server.
 - `#headers`
 - `#body`
 
-`Request` also has `#to_hash` which will turn the object into something your
+`Request` also has `#to_h` which will turn the object into something your
 app can respond to.
 
 
@@ -133,8 +135,8 @@ Sending and Receiving BLOBs
 ---------------------------
 
 Hatetepe provides a thin wrapper around StringIO that makes it easier to handle
-streaming of request and response bodies. That means your app will be `#call`ed as
-soon as all headers have arrived. It can then do stuff while it's still
+streaming of request and response bodies. That means your app will be `#call`ed
+as soon as all headers have arrived. It can then do stuff while it's still
 receiving body data. You might for example want to track upload progress.
 
     received = nil
@@ -177,13 +179,21 @@ License
 Hatetepe is subject to an MIT-style license (see LICENSE file).
 
 
-To Do and Ideas
----------------
+Roadmap
+-------
+
+- 0.5.0
+  - Direct IO via EM.enable_proxy
+  - Encoding support (ref. [github.com/tmm1/http_parser.rb#1](https://github.com/tmm1/http_parser.rb/pull/1))
+  - Optimize for performance
+  - Propagate connection errors to the app
 
-- Proxy
+
+Ideas
+-----
+
+- Support for rubygems-test
 - Code reloading
-- Keep-alive
-- Native file sending/receiving
 - Preforking
 - MVM support via Thread Pool
 - Support for SPDY
@@ -191,9 +201,4 @@ To Do and Ideas
 - Foreman support
 - Daemonizing and dropping privileges
 - Trailing headers
-- Propagating connection errors to the app
-
-- Fix http_parser.rb's parsing of chunked bodies
-- Does http_parser.rb recognize trailing headers?
-- Encoding support (see https://github.com/tmm1/http_parser.rb/pull/1)
-- Are there any good C libs for building HTTP messages?
+- REPL for Server and Client

data/hatetepe.gemspec

@@ -21,9 +21,8 @@ Gem::Specification.new do |s|
   
   s.add_development_dependency "rspec"
   s.add_development_dependency "fakefs"
-  s.add_development_dependency "em-http-request", "~> 1.0"
 
-  s.files         = `git ls-files`.split("\n") - [".gitignore"]
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rspec", ".travis.yml", ".yardopts"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]

data/lib/hatetepe/body.rb

@@ -2,6 +2,8 @@ require "em-synchrony"
 require "eventmachine"
 require "stringio"
 
+require "hatetepe/deferred_status_fix"
+
 module Hatetepe
   # Thin wrapper around StringIO for asynchronous body processing.
   class Body
@@ -158,9 +160,9 @@ module Hatetepe
     #   The number of bytes written.
     def write(data)
       ret = io.write data
-      Fiber.new do
-        @receivers.each {|r| r.call data }
-      end.resume
+      @receivers.each do |r|
+        Fiber.new { r.call data }.resume
+      end
       ret
     end
   end

data/lib/hatetepe/builder.rb

@@ -1,3 +1,5 @@
+require "rack/utils"
+
 module Hatetepe
   class BuilderError < StandardError; end
   
@@ -59,7 +61,7 @@ module Hatetepe
     end
     
     def request(req)
-      request_line req[0], req[1]
+      request_line req[0], req[1], (req[4] || "1.1")
       headers req[2]
       body req[3] if req[3]
       complete
@@ -72,7 +74,7 @@ module Hatetepe
     end
     
     def response(res)
-      response_line res[0]
+      response_line res[0], (res[3] || "1.1")
       headers res[1]
       body res[2] if res[2]
       complete
@@ -89,7 +91,8 @@ module Hatetepe
     end
     
     def header(name, value)
-      raw_header "#{name}: #{value}"
+      value = String(value)
+      raw_header "#{name}: #{value}" unless value.empty?
     end
     
     def headers(hash)

data/lib/hatetepe/cli.rb

@@ -1,7 +1,5 @@
 require "thor"
 
-require "hatetepe"
-
 module Hatetepe
   class CLI < Thor
     map "--version" => :version
@@ -11,20 +9,32 @@ module Hatetepe
     
     desc :version, "Print version information"
     def version
-      say Rity::VERSION
+      require "hatetepe/version"
+      say Hatetepe::VERSION
     end
     
-    desc :start, "Start an instance of Rity"
+    desc "[start]", "Start a server"
     method_option :bind, :aliases => "-b", :type => :string,
       :banner => "Bind to the specified TCP interface (default: 127.0.0.1)"
     method_option :port, :aliases => "-p", :type => :numeric,
       :banner => "Bind to the specified port (default: 3000)"
     method_option :rackup, :aliases => "-r", :type => :string,
       :banner => "Load specified rackup (.ru) file (default: config.ru)"
+    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)"
     def start
+      require "hatetepe/server"
+      
+      ENV["RACK_ENV"] = expand_env(options[:env]) || ENV["RACK_ENV"] || "development"
+      $stderr << "We're in #{ENV["RACK_ENV"]}\n"
+      $stderr.flush
+      
       rackup = File.expand_path(options[:rackup] || "config.ru")
       $stderr << "Booting from #{rackup}\n"
       $stderr.flush
+      
       app = Rack::Builder.parse_file(rackup)[0]
 
       EM.epoll
@@ -41,9 +51,21 @@ module Hatetepe
           :app => app,
           :errors => $stderr,
           :host => host,
-          :port => port
+          :port => port,
+          :timeout => (options[:timeout] || 1)
         })
       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,111 +1,186 @@
 require "em-synchrony"
 require "eventmachine"
+require "rack"
 require "uri"
 
-require "hatetepe/body"
 require "hatetepe/builder"
+require "hatetepe/connection"
+require "hatetepe/deferred_status_fix"
 require "hatetepe/parser"
 require "hatetepe/request"
-require "hatetepe/response"
 require "hatetepe/version"
 
 module Hatetepe
-  class Client < EM::Connection
-    def self.start(config)
-      EM.connect config[:host], config[:port], self, config
-    end
+  class Client < Hatetepe::Connection; end
+end
+
+require "hatetepe/client/keep_alive"
+require "hatetepe/client/pipeline"
+
+class Hatetepe::Client
+  attr_reader :app, :config
+  attr_reader :parser, :builder
+  attr_reader :requests, :pending_transmission, :pending_response
+  
+  def initialize(config)
+    @config = config
+    @parser,  @builder = Hatetepe::Parser.new, Hatetepe::Builder.new
     
-    def self.request(verb, uri, headers = {}, body = nil)
-      uri = URI.parse(uri)
-      client = start(:host => uri.host, :port => uri.port)
-      
-      headers["User-Agent"] ||= "hatetepe/#{VERSION}"
-      
-      Request.new(verb, uri.request_uri).tap do |req|
-        req.headers = headers
-        req.body = body || Body.new.tap {|b| b.close_write }
-        client << req
-        EM::Synchrony.sync req
-      end.response
+    @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
+  end
+  
+  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
+  end
+  
+  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
+  end
+  
+  def receive_response(response)
+    requests.find {|req| !req.response }.tap do |req|
+      req.response = response
+      pending_response[req.object_id].succeed response
+    end
+  end
+  
+  def <<(request)
+    request.connection = self
+    unless processing_enabled?
+      request.fail
+      return
     end
     
-    class << self
-      [:get, :head].each do |verb|
-        define_method verb do |uri, headers = {}|
-          request verb.to_s.upcase, uri, headers
-        end
-      end
-      [:options, :post, :put, :delete, :trace, :connect].each do |verb|
-        define_method verb do |uri, headers = {}, body = nil|
-          request verb.to_s.upcase, uri, headers, body
+    requests << 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
       end
+    end.resume
+  end
+  
+  def request(verb, uri, headers = {}, body = nil, http_version = "1.1")
+    headers["Host"] ||= "#{config[:host]}:#{config[:port]}"
+    headers["User-Agent"] ||= "hatetepe/#{Hatetepe::VERSION}"
+    
+    body = wrap_body(body)
+    if headers["Content-Type"] == "application/x-www-form-urlencoded"
+      enum = Enumerator.new(body)
+      headers["Content-Length"] = enum.inject(0) {|a, e| a + e.length }
     end
     
-    attr_reader :config
-    attr_reader :requests, :parser, :builder
+    request = Hatetepe::Request.new(verb, uri, headers, body, http_version)
+    self << request
+    self.processing_enabled = false
+    EM::Synchrony.sync request
     
-    def initialize(config)
-      @config = config
-      @requests = []
-      @parser, @builder = Parser.new, Builder.new
-      super
-    end
+    request.response.body.close_write if request.verb == "HEAD"
     
-    def post_init
-      parser.on_response do |response|
-        requests.find {|req| !req.response }.response = response
-      end
-      
-      parser.on_headers do
-        requests.reverse.find {|req| !!req.response }.tap do |req|
-          req.response.body.source = self
-          req.succeed req.response
-        end
-      end
-      
-      #builder.on_write {|chunk|
-      # ap "-> #{chunk}"
-      #}
-      builder.on_write << method(:send_data)
+    request.response
+  end
+  
+  def stop
+    unless requests.empty?
+      last_response = EM::Synchrony.sync(requests.last)
+      EM::Synchrony.sync last_response.body if last_response.body
     end
+    close_connection
+  end
+  
+  def unbind
+    super
     
-    def <<(request)
-      request.headers["Host"] = "#{config[:host]}:#{config[:port]}"
-
-      requests << request
-      Fiber.new do
-        builder.request_line request.verb, request.uri
-        
-        if request.headers["Content-Type"] == "application/x-www-form-urlencoded"
-          if request.body.respond_to? :read
-            request.headers["Content-Length"] = request.body.read.bytesize
-          else
-            request.headers["Content-Length"] = request.body.length
-          end
+    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
-        builder.headers request.headers
-        
-        b = request.body
-        if Body === b || b.respond_to?(:each)
-          builder.body b
-        elsif b.respond_to? :read
-          builder.body [b.read]
-        else
-          builder.body [b]
+        # 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
-        
-        builder.complete
-      end.resume
+        # XXX FiberError: dead fiber called because req already succeeded
+        #     or failed, see github.com/eventmachine/eventmachine/issues/287
+        req.fail req.response
+      end
     end
-    
-    def receive_data(data)
-      #ap "<- #{data}"
-      parser << data
+  end
+  
+  def wrap_body(body)
+    if body.respond_to? :each
+      body
+    elsif body.respond_to? :read
+      [body.read]
+    elsif body
+      [body]
+    else
+      []
+    end
+  end
+  
+  class << self
+    def start(config)
+      EM.connect config[:host], config[:port], self, config
     end
     
-    def stop
-      close_connection
+    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
+    end
+  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 }
     end
   end
 end