hatetepe 0.3.1 → 0.4.0

data/lib/hatetepe/client/keep_alive.rb

@@ -0,0 +1,58 @@
+class Hatetepe::Client
+  class KeepAlive
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    # XXX should we be explicit about Connection: keep-alive?
+    #     i think it doesn't matter if we send it as we don't wait
+    #     for the first response to see if we're talking to an HTTP/1.1
+    #     server. we're sending more requests anyway.
+    
+    # priority
+    # 1. if X-Hatetepe-Single then Connection header, Client#request closes
+    # 2. if req.Connection == close then Connection header and close
+    # 3. if res.Connection == close then close
+    def call(request)
+      req, conn = request, request.connection
+      
+      single = req.headers.delete("X-Hatetepe-Single")
+      req.headers["Connection"] ||= if single
+        "close"
+      else
+        "keep-alive"
+      end
+      close = req.headers["Connection"] == "close"
+      
+      # stop processing further requests as early as possible
+      conn.processing_enabled = false if close
+      
+      app.call(request).tap do |response|
+        if !single && response.headers["Connection"] == "close"
+          conn.processing_enabled = false
+        end
+      end
+    end
+    
+    def call(request)
+      req, conn = request, request.connection
+      
+      single = req.headers.delete("X-Hatetepe-Single")
+      req.headers["Connection"] = "close" if single
+      
+      req.headers["Connection"] ||= "keep-alive"
+      close = req.headers["Connection"] == "close"
+      
+      conn.processing_enabled = false if close
+      
+      app.call(request).tap do |res|
+        if !single && (close || res.headers["Connection"] == "close")
+          conn.processing_enabled = false
+          conn.stop
+        end
+      end
+    end
+  end
+end

data/lib/hatetepe/client/pipeline.rb

@@ -0,0 +1,19 @@
+require "em-synchrony"
+
+class Hatetepe::Client
+  class Pipeline
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(request)
+      previous = request.connection.requests[-2]
+      lock = request.connection.pending_transmission[previous.object_id]
+      EM::Synchrony.sync lock if previous != request && lock
+      
+      app.call request
+    end
+  end
+end

data/lib/hatetepe/connection.rb

@@ -0,0 +1,42 @@
+require "eventmachine"
+
+module Hatetepe
+  class Connection < EM::Connection
+    attr_accessor :processing_enabled
+    alias_method :processing_enabled?, :processing_enabled
+    
+    def remote_address
+      sockaddr && sockaddr[1]
+    end
+    
+    def remote_port
+      sockaddr && sockaddr[0]
+    end
+    
+    def sockaddr
+      @sockaddr ||= Socket.unpack_sockaddr_in(get_peername) rescue nil
+    end
+    
+    def closed?
+      !!@closed_by
+    end
+    
+    def closed_by_remote?
+      @closed_by == :remote
+    end
+    
+    def closed_by_self?
+      closed? && !closed_by_remote?
+    end
+    
+    def close_connection(after_writing = false)
+      @closed_by = :self
+      super after_writing
+    end
+    
+    # TODO how to detect closed-by-timeout?
+    def unbind
+      @closed_by = :remote unless closed?
+    end
+  end
+end

data/lib/hatetepe/deferred_status_fix.rb

@@ -0,0 +1,11 @@
+require "eventmachine"
+
+module EM::Deferrable
+  def set_deferred_status_with_status_fix(status, *args)
+    return if defined?(@deferred_status) && ![:unknown, status].include?(@deferred_status)
+    set_deferred_status_without_status_fix status, *args
+  end
+  
+  alias_method :set_deferred_status_without_status_fix, :set_deferred_status
+  alias_method :set_deferred_status, :set_deferred_status_with_status_fix
+end

data/lib/hatetepe/message.rb

@@ -3,11 +3,11 @@ require "hatetepe/body"
 module Hatetepe
   class Message
     attr_accessor :http_version, :headers, :body
+    attr_accessor :connection
     
-    def initialize(http_version = "1.1")
-      @http_version = http_version
-      @headers = {}
-      @body = Body.new
+    def initialize(headers = {}, body = nil, http_version = "1.1")
+      @headers, @http_version = headers, http_version
+      @body = body || Body.new
     end
   end
 end

data/lib/hatetepe/parser.rb

@@ -23,16 +23,15 @@ module Hatetepe
         p.on_headers_complete = proc do
           version = p.http_version.join(".")
           if p.http_method
-            @message = Request.new(p.http_method, p.request_url, version)
+            @message = Request.new(p.http_method, p.request_url,
+                                   p.headers, Body.new, version)
             event! :request, message
           else
-            @message = Response.new(p.status_code, version)
+            @message = Response.new(p.status_code, p.headers, Body.new, version)
             event! :response, message
           end
           
-          message.headers = p.headers
           event! :headers, message.headers
-          
           event! :body, message.body
           nil
         end

data/lib/hatetepe/request.rb

@@ -1,17 +1,28 @@
+require "hatetepe/deferred_status_fix"
 require "hatetepe/message"
 
 module Hatetepe
   class Request < Message
     include EM::Deferrable
     
-    attr_accessor :verb, :uri, :response
+    attr_reader :verb
+    attr_accessor :uri, :response
     
-    def initialize(verb, uri, http_version = "1.1")
-      @verb, @uri = verb, uri
-      super http_version
+    def initialize(verb, uri, headers = {}, body = nil, http_version = "1.1")
+      self.verb = verb
+      @uri = uri
+      super headers, body, http_version
     end
     
-    def to_hash
+    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,
@@ -20,13 +31,15 @@ module Hatetepe
         "REQUEST_URI" => uri.dup
       }.tap do |hsh|
         headers.each do |key, value|
-          key = key.upcase.gsub! /[^A-Z]/, "_"
+          key = key.upcase.gsub /[^A-Z]/, "_"
           key = "HTTP_#{key}" unless key =~ /^CONTENT_(TYPE|LENGTH)$/
           hsh[key] = value.dup
         end
 
         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
     end
   end

data/lib/hatetepe/response.rb

@@ -2,11 +2,19 @@ require "hatetepe/message"
 
 module Hatetepe
   class Response < Message
-    attr_accessor :status
+    attr_accessor :status, :request
     
-    def initialize(status, http_version = "1.1")
+    def initialize(status, headers = {}, body = nil, http_version = "1.1")
       @status = status
-      super http_version
+      super headers, body, http_version
+    end
+    
+    def success?
+      status.between? 100, 399
+    end
+    
+    def failure?
+      status.between? 400, 599
     end
     
     def to_a

data/lib/hatetepe/server.rb

@@ -2,106 +2,136 @@ require "eventmachine"
 require "em-synchrony"
 require "rack"
 
-require "hatetepe/app"
 require "hatetepe/builder"
+require "hatetepe/connection"
 require "hatetepe/parser"
-require "hatetepe/pipeline"
-require "hatetepe/proxy"
-require "hatetepe/request"
 require "hatetepe/version"
 
 module Hatetepe
-  class Server < EM::Connection
-    def self.start(config)
-      EM.start_server config[:host], config[:port], self, config
-    end
-    
-    attr_reader :app, :config, :errors
-    attr_reader :requests, :parser, :builder
-    
-    def initialize(config)
-      @config = config
-      @errors = config[:errors] || $stderr
+  class Server < Hatetepe::Connection; end
+end
 
-      @app = Rack::Builder.new.tap do |b|
-        b.use Hatetepe::Pipeline
-        b.use Hatetepe::App
-        b.use Hatetepe::Proxy
-        b.run config[:app]
-      end.to_app
+require "hatetepe/server/app"
+require "hatetepe/server/keep_alive"
+require "hatetepe/server/pipeline"
+require "hatetepe/server/proxy"
 
-      super
-    end
+class Hatetepe::Server
+  def self.start(config)
+    EM.start_server config[:host], config[:port], self, config
+  end
+  
+  attr_reader :app, :config, :errors
+  attr_reader :requests, :parser, :builder
+  
+  def initialize(config)
+    @config = {:timeout => 1}.merge(config)
+    @errors = @config.delete(:errors) || $stderr
+
+    super
+  end
+  
+  def post_init
+    @requests = []
+    @parser, @builder = Hatetepe::Parser.new, Hatetepe::Builder.new
     
-    def post_init
-      @requests = []
-      @parser, @builder = Parser.new, Builder.new
-      
-      parser.on_request << requests.method(:<<)
-      parser.on_headers << method(:process)
+    parser.on_request << requests.method(:<<)
+    parser.on_headers << method(:process)
 
-      builder.on_write << method(:send_data)
-    end
+    # XXX check if the connection is still present
+    builder.on_write << method(:send_data)
+    #builder.on_write {|data| p "server >> #{data}" }
+
+    @app = Rack::Builder.new.tap do |b|
+      # middleware is NOT ordered alphabetically
+      b.use Pipeline
+      b.use App
+      b.use KeepAlive
+      b.use Proxy
+      b.run config[:app]
+    end.to_app
+    
+    self.processing_enabled = true
+    self.comm_inactivity_timeout = config[:timeout]
+  end
+  
+  def receive_data(data)
+    #p "server << #{data}"
+    parser << data
+  rescue Hatetepe::ParserError => ex
+    close_connection
+    raise ex if ENV["RACK_ENV"] == "testing"
+  rescue Exception => ex
+    close_connection_after_writing
+    backtrace = ex.backtrace.map {|line| "\t#{line}" }.join("\n")
+    errors << "#{ex.class}: #{ex.message}\n#{backtrace}\n"
+    errors.flush
+    raise ex if ENV["RACK_ENV"] == "testing"
+  end
+  
+  # XXX fail response bodies properly
+  # XXX make sure no more data is sent
+  def unbind
+    super
+    #requests.map(&:body).each &:fail
+  end
+  
+  def process(*)
+    return unless processing_enabled?
+    request = requests.last
     
-    def receive_data(data)
-      parser << data
-    rescue ParserError
-      close_connection
-    rescue Exception => ex
-      close_connection_after_writing
-      backtrace = ex.backtrace.map {|line| "\t#{line}" }.join("\n")
-      errors << "#{ex.class}: #{ex.message}\n#{backtrace}\n"
-      errors.flush
+    self.comm_inactivity_timeout = 0
+    reset_timeout = proc do
+      self.comm_inactivity_timeout = config[:timeout] if requests.empty?
     end
+    request.callback &reset_timeout
+    request.errback &reset_timeout
     
-    def process(*)
-      request = requests.last
-      
-      env = request.to_hash.tap do |e|
-        inject_environment e
-        e["stream.start"] = proc do |response|
-          e.delete "stream.start"
-          start_response response
-        end
-        e["stream.send"] = builder.method(:body_chunk)
-        e["stream.close"] = proc do
-          e.delete "stream.send"
-          e.delete "stream.close"
-          close_response request
-        end
+    env = request.to_h.tap do |e|
+      inject_environment e
+      e["stream.start"] = proc do |response|
+        e.delete "stream.start"
+        start_response response
+      end
+      e["stream.send"] = builder.method(:body_chunk)
+      e["stream.close"] = proc do
+        e.delete "stream.send"
+        e.delete "stream.close"
+        close_response request
       end
-      
-      Fiber.new { app.call env }.resume
     end
     
-    def start_response(response)
-      builder.response_line response[0]
-      response[1]["Server"] = "hatetepe/#{VERSION}"
-      builder.headers response[1]
-    end
+    Fiber.new { app.call env }.resume
+  end
+  
+  def start_response(response)
+    builder.response_line response[0]
+    response[1]["Server"] ||= "hatetepe/#{Hatetepe::VERSION}"
+    builder.headers response[1]
+  end
+  
+  def close_response(request)
+    builder.complete
+    requests.delete(request).succeed
+  end
     
-    def close_response(request)
-      builder.complete
-      requests.delete request
-      close_connection_after_writing if requests.empty?
-    end
-      
-    def inject_environment(env)
-      env["hatetepe.connection"] = self
-      env["rack.url_scheme"] = "http"
-      env["rack.input"].source = self
-      env["rack.errors"] = errors
-      
-      env["rack.multithread"] = false
-      env["rack.multiprocess"] = false
-      env["rack.run_once"] = false
-      
-      env["SERVER_NAME"] = config[:host].dup
-      env["SERVER_PORT"] = String(config[:port])
-      
-      host = env["HTTP_HOST"] || config[:host].dup
-      host += ":#{config[:port]}" unless host.include? ":"
-      env["HTTP_HOST"] = host
-    end
+  def inject_environment(env)
+    env["hatetepe.connection"] = self
+    env["rack.url_scheme"] = "http"
+    env["rack.input"].source = self
+    env["rack.errors"] = errors
+    
+    env["rack.multithread"] = false
+    env["rack.multiprocess"] = false
+    env["rack.run_once"] = false
+    
+    env["SERVER_NAME"] = config[:host].dup
+    env["SERVER_PORT"] = String(config[:port])
+    env["REMOTE_ADDR"] = remote_address.dup
+    env["REMOTE_PORT"] = String(remote_port)
+    
+    host = env["HTTP_HOST"] || config[:host].dup
+    host += ":#{config[:port]}" unless host.include? ":"
+    env["HTTP_HOST"] = host
   end
 end