hatetepe 0.3.1 → 0.4.0

data/lib/hatetepe/{app.rb → server/app.rb}

@@ -3,7 +3,7 @@ require "rack"
 
 Rack::STREAMING = "Rack::STREAMING"
 
-module Hatetepe
+class Hatetepe::Server
   ASYNC_RESPONSE = [-1, {}, []].freeze
   
   ERROR_RESPONSE = [500, {"Content-Type" => "text/html"},
@@ -39,7 +39,12 @@ module Hatetepe
       
       response = ASYNC_RESPONSE
       catch :async do
-        response = app.call(env) rescue ERROR_RESPONSE
+        response = begin
+          app.call env
+        rescue => ex
+          raise ex if ENV["RACK_ENV"] == "testing"
+          ERROR_RESPONSE
+        end
       end
       
       postprocess env, response

data/lib/hatetepe/server/keep_alive.rb

@@ -0,0 +1,61 @@
+class Hatetepe::Server
+  class KeepAlive
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      m = case env["HTTP_CONNECTION"].to_s.downcase
+        when "close" then :close
+        when "keep-alive" then :keep_alive
+        else env["HTTP_VERSION"] =~ /^HTTP\/(0\.9|1\.0)$/ ? :close : :keep_alive
+      end
+      
+      send :"call_and_#{m}", env
+    end
+    
+    def call_and_close(env, response = nil)
+      req, conn = extract_request(env), extract_connection(env)
+      
+      conn.processing_enabled = false
+      req.callback &conn.method(:close_connection_after_writing)
+      req.errback &conn.method(:close_connection_after_writing)
+      
+      if response
+        response[1]["Connection"] = "close"
+      else
+        stream_start = env["stream.start"]
+        env["stream.start"] = proc do |res|
+          res[1]["Connection"] = "close"
+          stream_start.call res
+        end
+      end
+      
+      response || app.call(env)
+    end
+    
+    def call_and_keep_alive(env)
+      stream_start = env["stream.start"]
+      env["stream.start"] = proc do |res|
+        if res[1]["Connection"] == "close"
+          call_and_close env, res
+        else
+          res[1]["Connection"] = "keep-alive"
+        end
+        stream_start.call res
+      end
+      
+      app.call env
+    end
+    
+    def extract_request(env)
+      env["hatetepe.request"] || raise("env[hatetepe.request] not set")
+    end
+    
+    def extract_connection(env)
+      env["hatetepe.connection"] || raise("env[hatetepe.connection] not set")
+    end
+  end
+end

data/lib/hatetepe/server/pipeline.rb

@@ -0,0 +1,24 @@
+require "em-synchrony"
+
+class Hatetepe::Server
+  # TODO move specs from server_spec.rb to server/pipeline_spec.rb
+  class Pipeline
+    attr_reader :app
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      previous = env["hatetepe.connection"].requests[-2]
+      
+      stream_start = env["stream.start"]
+      env["stream.start"] = proc do |response|
+        EM::Synchrony.sync previous if previous
+        stream_start.call response
+      end
+      
+      app.call env
+    end
+  end
+end

data/lib/hatetepe/{proxy.rb → server/proxy.rb}

@@ -2,7 +2,7 @@ require "hatetepe/client"
 require "hatetepe/request"
 require "uri"
 
-module Hatetepe
+class Hatetepe::Server
   class Proxy
     attr_reader :app
     
@@ -23,7 +23,8 @@ module Hatetepe
       
       env["proxy.callback"] ||= env["async.callback"]
       
-      cl = client || Client.start(:host => target.host, :port => target.port)
+      cl = client || Hatetepe::Client.start(:host => target.host,
+                                            :port => target.port)
       build_request(env, target).tap do |req|
         cl << req
         EM::Synchrony.sync req
@@ -40,15 +41,8 @@ module Hatetepe
       
       uri = target.path + base.uri
       host = "#{target.host}:#{target.port}"
-      headers = base.headers.merge({
-        "X-Forwarded-For" => env["REMOTE_ADDR"],
-        "Host" => [base.headers["Host"], host].compact.join(", ")
-      })
-      
-      Request.new(base.verb, uri, base.http_version).tap do |req|
-        req.headers = headers
-        req.body = base.body
-      end
+      headers = base.headers.merge("Host" => host)
+      Hatetepe::Request.new base.verb, uri, headers, base.body
     end
   end
 end

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/rack/handler/hatetepe.rb

@@ -15,10 +15,7 @@ module Rack
         Signal.trap("TERM") { EM.stop }
         
         EM.epoll
-        EM.synchrony do
-          server = ::Hatetepe::Server.start options
-          yield server if block_given?
-        end
+        EM.synchrony { ::Hatetepe::Server.start options }
       end
 
       def self.valid_options

data/spec/integration/cli/start_spec.rb

@@ -1,27 +1,18 @@
 require "spec_helper"
 require "hatetepe/cli"
-require "socket"
 
-describe "start command" do
-  def hook_event_loop(&block)
-    EM.spec_hooks << block
-  end
-  
-  def add_stop_timer(timeout)
-    hook_event_loop do
-      EM.add_timer(timeout) { EM.stop }
-    end
-  end
-  
+describe "The `hatetepe start' command" do
   before do
-    $stderr = StringIO.new ""
+    ENV.delete "RACK_ENV"
+    
+    $stderr = StringIO.new
     
     FakeFS.activate!
-    File.open("config.ru", "w") do |f|
-      f.write %q{run proc {|e| [200, {"Content-Type" => "text/plain"}, [e["REQUEST_URI"]]] }}
+    File.open "config.ru", "w" do |f|
+      f.write 'run proc {|env| [200, {}, ["Hello world!"]] }'
     end
-    File.open("config2.ru", "w") do |f|
-      f.write %q{run proc {|e| [200, {"Content-Type" => "text/plain"}, ["config2.ru loaded"]] }}
+    File.open "config2.ru", "w" do |f|
+      f.write 'run proc {|env| [501, {}, ["Herp derp"]] }'
     end
   end
   
@@ -32,138 +23,99 @@ describe "start command" do
     FakeFS::FileSystem.clear
   end
   
-  it "starts an instance of Rity" do
-    add_stop_timer 0.05
-    hook_event_loop do
-      Socket.tcp("127.0.0.1", 3000) {|*| }
-    end
-    Hatetepe::CLI.start %w{}
-
-    $stderr.string.should include("127.0.0.1:3000")
-  end
-  
-  it "answers HTTP requests" do
-    add_stop_timer 0.02
-    hook_event_loop do
-      request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
-      response = EM::Synchrony.sync(request)
-      
-      response.response_header.status.should == 200
-      response.response_header["CONTENT_TYPE"].should == "text/plain"
-      response.response.should == "/"
-    end
-    Hatetepe::CLI.start %w{}
-  end
-  
-  describe "--port option" do
-    it "changes the listen port" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        Socket.tcp("127.0.0.1", 3001) {|*| }
+  describe "without options" do
+    it "starts a Hatetepe::Server with default options" do
+      command "" do
+        Socket.tcp("127.0.0.1", 3000) {|*| }
+        ENV["RACK_ENV"].should == "development"
+        $stderr.string.should include("config.ru", "127.0.0.1:3000", "development")
       end
-      Hatetepe::CLI.start %w{--port=3001}
-      
-      $stderr.string.should include(":3001")
     end
     
-    it "has an alias: -p" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        Socket.tcp("127.0.0.1", 3002) {|*| }
+    it "serves HTTP requests" do
+      command "" do
+        Hatetepe::Client.get("http://127.0.0.1:3000").tap do |response|
+          response.status.should equal(200)
+          response.body.read.should == "Hello world!"
+        end
       end
-      Hatetepe::CLI.start %w{-p 3002}
-      
-      $stderr.string.should include(":3002")
     end
   end
   
-  describe "--bind option" do
-    it "changes the listen interface" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        Socket.tcp("127.0.0.2", 3000) {|*| }
-      end
-      Hatetepe::CLI.start %w{--bind=127.0.0.2}
-      
-      $stderr.string.should include("127.0.0.2:")
-    end
-    
-    it "has an alias: -b" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        Socket.tcp("127.0.0.3", 3000) {|*| }
+  ["--port", "-p"].each do |opt|
+    describe "with #{opt} option" do
+      it "binds the Hatetepe::Server to the specified TCP port" do
+        command "#{opt} 3002" do
+          Socket.tcp("127.0.0.1", 3002) {|*| }
+        end
       end
-      Hatetepe::CLI.start %w{-b 127.0.0.3}
-      
-      $stderr.string.should include("127.0.0.3:")
     end
   end
   
-  describe "--rackup option" do
-    it "changes the rackup file that'll be loaded" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
-        response = EM::Synchrony.sync(request)
-        response.response.should include("config2.ru")
+  ["--bind", "-b"].each do |opt|
+    describe "with #{opt} option" do
+      it "binds the Hatetepe::Server to the specified TCP interface" do
+        command "#{opt} 127.0.0.2" do
+          Socket.tcp("127.0.0.2", 3000) {|*| }
+        end
       end
-      Hatetepe::CLI.start %w{--rackup=config2.ru}
     end
-    
-    it "has an alias: -r" do
-      add_stop_timer 0.05
-      hook_event_loop do
-        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
-        response = EM::Synchrony.sync(request)
-        response.response.should include("config2.ru")
+  end
+  
+  ["--rackup", "-r"].each do |opt|
+    describe "with #{opt} option" do
+      it "loads the specified rackup (.ru) file" do
+        command "#{opt} config2.ru" do
+          Hatetepe::Client.get("http://127.0.0.1:3000").tap do |response|
+            response.status.should equal(501)
+            response.body.read.should == "Herp derp"
+          end
+        end
       end
-      Hatetepe::CLI.start %w{-r config2.ru}
     end
   end
   
-  describe "--quiet option" do
-    it "discards all output" do
-      pending
-      
-      add_stop_timer 0.05
-      Hatetepe::CLI.start %w{--quiet}
-      
-      $stderr.string.should be_empty
-    end
-    
-    it "has an alias: -q" do
-      pending
+  ["--env", "-e"].each do |opt|
+    describe "with #{opt} option" do
+      it "boots the app in the specified environment" do
+        command "#{opt} herpderp" do
+          ENV["RACK_ENV"].should == "herpderp"
+        end
+      end
       
-      add_stop_timer 0.05
-      Hatetepe::CLI.start %w{-q}
+      ["dev", "devel", "develop"].each do |value|
+        it "expands #{value} to `development'" do
+          command "#{opt} #{value}" do
+            ENV["RACK_ENV"].should == "development"
+          end
+        end
+      end
       
-      $stderr.string.should be_empty
+      it "expands test to `testing'" do
+        command "#{opt} test" do
+          ENV["RACK_ENV"].should == "testing"
+        end
+      end
     end
   end
   
-  describe "--verbose option" do
-    it "prints debugging data" do
-      pending
-      
-      add_stop_timer 0.05
-      hook_event_loop do
-        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+  ["--timeout", "-t"].each do |opt|
+    describe "with #{opt} option" do
+      let :client do
+        Hatetepe::Client.start :host => "127.0.0.1", :port => 3000
       end
-      Hatetepe::CLI.start %w{--verbose}
       
-      $stderr.string.split("\n").size.should > 10
-    end
+      it "times out a connection after the specified amount of seconds" do
+        command "#{opt} 0.5", 1 do
+          client.should_not be_closed
 
-    it "has an alias: -V" do
-      pending
-      
-      add_stop_timer 0.05
-      hook_event_loop do
-        request = EM::HttpRequest.new("http://127.0.0.1:3000").aget
+          EM::Synchrony.sleep 0.45
+          client.should_not be_closed
+
+          EM::Synchrony.sleep 0.1
+          client.should be_closed_by_remote
+        end
       end
-      Hatetepe::CLI.start %w{-V}
-      
-      $stderr.string.split("\n").size.should > 10
     end
   end
 end

data/spec/integration/client/keep_alive_spec.rb

@@ -0,0 +1,74 @@
+require "hatetepe/cli"
+require "hatetepe/client"
+require "spec_helper"
+require "stringio"
+require "yaml"
+
+describe Hatetepe::Client, "with Keep-Alive" do
+  before do
+    $stderr = StringIO.new
+    
+    FakeFS.activate!
+    File.open "config.ru", "w" do |f|
+      f.write 'run proc {|env| [200,
+                                {"Content_Type" => "text/plain"},
+                                [env["HTTP_CONNECTION"]]] }'
+    end
+    File.open "config_close.ru", "w" do |f|
+      f.write 'run proc {|env| [200,
+                                {"Content-Type" => "text/plain",
+                                 "Connection" => "close"},
+                                [env["HTTP_CONNECTION"]]] }'
+    end
+  end
+  
+  after do
+    $stderr = STDERR
+    
+    FakeFS.deactivate!
+    FakeFS::FileSystem.clear
+  end
+  
+  let :client do
+    Hatetepe::Client.start :host => "127.0.0.1", :port => 30001
+  end
+  
+  it "keeps the connection open" do
+    command "-p 30001", 2 do
+      client
+      EM::Synchrony.sleep 1.95
+      client.should_not be_closed_by_self
+    end
+  end
+  
+  it "sends Connection: keep-alive" do
+    command "-p 30001" do
+      client.get("/").body.read.should == "keep-alive"
+    end
+  end
+  
+  describe "and an obviously single request" do
+    it "sends Connection: close" do
+      command "-p 30001" do
+        Hatetepe::Client.get "http://127.0.0.1:30001/" do |response|
+          YAML.load(response.body.read).should == "close"
+        end
+      end
+    end
+    
+    it "closes the connection immediately after the response" do
+      command "-p 30001" do
+        #Hatetepe::Client.any_instance.should_receive :stop
+        Hatetepe::Client.get "http://127.0.0.1:30001/"
+      end
+    end
+  end
+  
+  it "closes the connection if the server tells it to" do
+    #pending "Server can't send Conn: close as its Keep-Alive middleware overwrites it"
+    command "-p 30001 -r config_close.ru" do
+      client.get "/"
+      client.should be_closed
+    end
+  end
+end