hatetepe 0.4.1 → 0.5.0.pre

data/lib/hatetepe/server/keep_alive.rb

@@ -1,61 +1,23 @@
-class Hatetepe::Server
+module Hatetepe::Server
   class KeepAlive
-    attr_reader :app
-    
-    def initialize(app)
-      @app = app
+    def initialize(app, connection)
+      @app, @connection = app, connection
     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
+
+    def call(request, &respond)
+      @app.call(request) do |response|
+        respond.call(response)
+        maybe_close(request, response)
       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
+
+    def maybe_close(request, response)
+      version = request.http_version.to_f
+      header  = request.headers["Connection"] || response.headers["Connection"]
+
+      if (version < 1.1 && header != "keep-alive") || header == "close"
+        @connection.stop!
       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

@@ -1,24 +1,20 @@
-require "em-synchrony"
-
-class Hatetepe::Server
-  # TODO move specs from server_spec.rb to server/pipeline_spec.rb
+module Hatetepe::Server
   class Pipeline
-    attr_reader :app
-    
-    def initialize(app)
-      @app = app
+    def initialize(app, connection)
+      @requests, @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
+
+    def call(request, &respond)
+      begin
+        previous  =  @requests.last
+        @requests << request
+        @app.call(request) do |response|
+          EM::Synchrony.sync(previous) if previous
+          respond.call(response)
+        end
+      ensure
+        @requests.delete(request)
       end
-      
-      app.call env
     end
   end
 end

data/lib/hatetepe/server/rack_app.rb

@@ -0,0 +1,39 @@
+module Hatetepe::Server
+  class RackApp
+    def initialize(app, connection)
+      @app, @connection = app, connection
+    end
+
+    def call(request, &respond)
+      env = env_for(request)
+      env["async.callback"] = proc do |response|
+        async_callback(response, &respond)
+      end
+
+      response = [ -1 ]
+      catch :async do
+        response = @app.call(env)
+      end
+
+      async_callback(response, &respond)
+    end
+
+    def async_callback(response, &respond)
+      if response[0] >= 0
+        respond.call(Hatetepe::Response.new(*response))
+      end
+    end
+
+    def env_for(request)
+      request.to_h.merge({
+        "SERVER_NAME"       => @connection.config[:host],
+        "SERVER_PORT"       => @connection.config[:port].to_s,
+        "rack.errors"       => $stderr,
+        "rack.multithread"  => false,
+        "rack.multiprocess" => false,
+        "rack.run_once"     => false,
+        "rack.url_scheme"   => "http"
+      })
+    end
+  end
+end

data/lib/hatetepe/server.rb

@@ -1,137 +1,89 @@
 require "eventmachine"
 require "em-synchrony"
-require "rack"
 
 require "hatetepe/builder"
 require "hatetepe/connection"
 require "hatetepe/parser"
+require "hatetepe/server/keep_alive"
+require "hatetepe/server/pipeline"
+require "hatetepe/server/rack_app"
 require "hatetepe/version"
 
-module Hatetepe
-  class Server < Hatetepe::Connection; end
-end
+module Hatetepe::Server
+  include Hatetepe::Connection
 
-require "hatetepe/server/app"
-require "hatetepe/server/keep_alive"
-require "hatetepe/server/pipeline"
-require "hatetepe/server/proxy"
+  attr_reader :config, :requests
+
+  CONFIG_DEFAULTS = { :timeout => 5.0 }
 
-class Hatetepe::Server
+  # @api public
   def self.start(config)
-    EM.start_server config[:host], config[:port], self, 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
+  # @api semipublic
+  def initialize(config)
+    @config = CONFIG_DEFAULTS.merge(config)
   end
-  
+
+  # @api semipublic
   def post_init
-    @requests = []
     @parser, @builder = Hatetepe::Parser.new, Hatetepe::Builder.new
-    
-    parser.on_request << requests.method(:<<)
-    parser.on_headers << method(:process)
-
-    # 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
+    @parser.on_request &method(:process_request)
+    @builder.on_write  &method(:send_data)
+    # @builder.on_write {|data| p "<--| #{data}" }
+
+    @app = [
+      Pipeline,
+      KeepAlive,
+      RackApp
+    ].reverse.inject(config[:app]) {|inner, outer| outer.new(inner, self) }
+
     self.comm_inactivity_timeout = config[:timeout]
   end
-  
+
+  # @api semipubic
   def receive_data(data)
-    #p "server << #{data}"
-    parser << data
-  rescue Hatetepe::ParserError => ex
+    # p "-->| #{data}"
+    @parser << data
+  rescue Object => ex
+    p 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
+
+  # @api private
+  def process_request(request)
+    Fiber.new do
+      @app.call(request) do |response|
+        send_response(request, response)
+      end
+    end.resume
   end
-  
-  def process(*)
-    return unless processing_enabled?
-    request = requests.last
-    
+
+  # @api private
+  def send_response(request, response)
     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
-    
-    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
+    @builder.response(response.to_a)
+    self.comm_inactivity_timeout = config[:timeout]
+
+    if response.failure?
+      request.fail(response)
+    else
+      request.succeed(response)
     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]
+
+  # @api semipublic
+  def unbind(reason)
+    super
   end
-  
-  def close_response(request)
-    builder.complete
-    requests.delete(request).succeed
+
+  # @api public
+  def stop
   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
+
+  # @api public
+  def stop!
+    close_connection_after_writing
   end
 end

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.4.1"
+  VERSION = "0.5.0.pre"
 end

data/lib/rack/handler/hatetepe.rb

@@ -1,5 +1,7 @@
 require "eventmachine"
+require "em-synchrony"
 require "hatetepe/server"
+require "rack"
 
 module Rack
   module Handler

data/spec/integration/cli/start_spec.rb

@@ -1,120 +1,112 @@
 require "spec_helper"
 require "hatetepe/cli"
+require "hatetepe/server"
+require "hatetepe/version"
+require "rack/builder"
+
+describe Hatetepe::CLI do
+  let :rackup do
+    [ proc {|*| }, {} ]
+  end
 
-describe "The `hatetepe start' command" do
   before do
-    ENV.delete "RACK_ENV"
-    
-    $stderr = StringIO.new
-    
-    FakeFS.activate!
-    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 'run proc {|env| [501, {}, ["Herp derp"]] }'
-    end
+    file = File.expand_path("config.ru")
+    Rack::Builder.stub(:parse_file).with(file) { rackup }
+
+    $stdout, $stderr = StringIO.new, StringIO.new
+    @old_env         = ENV.delete("RACK_ENV")
   end
   
   after do
-    $stderr = STDERR
-    
-    FakeFS.deactivate!
-    FakeFS::FileSystem.clear
+    $stdout, $stderr = STDOUT, STDERR
+    ENV["RACK_ENV"]  = @old_env
   end
-  
-  describe "without options" do
-    it "starts a Hatetepe::Server with default options" do
-      command "" do
-        Socket.tcp("127.0.0.1", 3000) {|*| }
+
+  describe "#version" do
+    it "prints Hatetepe's version" do
+      Hatetepe::CLI.start([ "version" ])
+      $stdout.rewind
+      $stdout.read.should include(Hatetepe::VERSION)
+    end
+  end
+
+  describe "#start" do
+    it "starts a server running the default configuration" do
+      Hatetepe::Server.should_receive(:start) do |config|
+        config[:host].should    == "127.0.0.1"
+        config[:port].should    equal(3000)
+        config[:timeout].should == 5
+        
+        config[:app].should    equal(rackup[0])
         ENV["RACK_ENV"].should == "development"
-        $stderr.string.should include("config.ru", "127.0.0.1:3000", "development")
       end
+      Hatetepe::CLI.start([])
     end
-    
-    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
+
+    it "writes stuff to stderr" do
+      Hatetepe::CLI.start([])
+      $stderr.rewind
+      $stderr.read.should include("config.ru", "127.0.0.1:3000", "development")
     end
-  end
-  
-  ["--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
+
+    it "starts an EventMachine reactor" do
+      EM.should_receive(:synchrony)
+      Hatetepe::CLI.start([])
     end
-  end
-  
-  ["--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
+
+    it "enables epoll" do
+      EM.should_receive(:epoll)
+      Hatetepe::CLI.start([])
     end
-  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
+
+    it "doesn't overwrite RACK_ENV" do
+      ENV["RACK_ENV"] = "foobar"
+      Hatetepe::CLI.start([])
+      ENV["RACK_ENV"].should == "foobar"
+    end
+
+    describe "with --bind option" do
+      it "passes the :host option to Server.start" do
+        Hatetepe::Server.should_receive(:start) do |config|
+          config[:host].should == "127.0.5.1"
         end
+        Hatetepe::CLI.start([ "--bind", "127.0.5.1" ])
       end
     end
-  end
-  
-  ["--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"
+
+    describe "with --port option" do
+      it "passes the :port option to Server.start" do
+        Hatetepe::Server.should_receive(:start) do |config|
+          config[:port].should == 5234
         end
+        Hatetepe::CLI.start([ "--port", "5234" ])
       end
-      
-      ["dev", "devel", "develop"].each do |value|
-        it "expands #{value} to `development'" do
-          command "#{opt} #{value}" do
-            ENV["RACK_ENV"].should == "development"
-          end
+    end
+
+    describe "with --timeout option" do
+      it "passes the :timeout option to Server.start" do
+        Hatetepe::Server.should_receive(:start) do |config|
+          config[:timeout].should == 123.4
         end
+        Hatetepe::CLI.start([ "--timeout", "123.4" ])
       end
-      
-      it "expands test to `testing'" do
-        command "#{opt} test" do
-          ENV["RACK_ENV"].should == "testing"
+    end
+
+    describe "with --rackup option" do
+      it "boots from the specified RackUp file" do
+        file = File.expand_path("./other_config.ru")
+        Rack::Builder.should_receive(:parse_file).with(file) { rackup }
+        Hatetepe::Server.should_receive(:start) do |config|
+          config[:app].should equal(rackup[0])
         end
+        Hatetepe::CLI.start([ "--rackup", "other_config.ru" ])
       end
     end
-  end
-  
-  ["--timeout", "-t"].each do |opt|
-    describe "with #{opt} option" do
-      let :client do
-        Hatetepe::Client.start :host => "127.0.0.1", :port => 3000
-      end
-      
-      it "times out a connection after the specified amount of seconds" do
-        command "#{opt} 0.5", 1 do
-          client.should_not be_closed
 
-          EM::Synchrony.sleep 0.45
-          client.should_not be_closed
-
-          EM::Synchrony.sleep 0.1
-          client.should be_closed_by_remote
-        end
+    describe "with --env option" do
+      it "sets RACK_ENV to the specified value" do
+        Hatetepe::CLI.start([ "--env", "production" ])
+        ENV["RACK_ENV"].should == "production"
       end
     end
   end

data/spec/integration/client/keep_alive_spec.rb

@@ -5,70 +5,19 @@ 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 "keeps the connection open"
   
-  it "sends Connection: keep-alive" do
-    command "-p 30001" do
-      client.get("/").body.read.should == "keep-alive"
-    end
-  end
+  it "sends Connection: keep-alive"
   
   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 "sends Connection: close"
     
-    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
+    it "closes the connection immediately after the response"
   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
+  it "closes the connection if the server tells it to"
 end