hatetepe 0.4.1 → 0.5.0.pre

data/lib/hatetepe/client/keep_alive.rb

@@ -1,32 +0,0 @@
-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.
-    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

@@ -1,19 +0,0 @@
-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/server/app.rb

@@ -1,85 +0,0 @@
-require "async-rack"
-require "rack"
-
-Rack::STREAMING = "Rack::STREAMING"
-
-class Hatetepe::Server
-  ASYNC_RESPONSE = [-1, {}, []].freeze
-  
-  ERROR_RESPONSE = [500, {"Content-Type" => "text/html"},
-                    ["Internal Server Error"]].freeze
-  
-  # Interface between Rack-compatible applications and Hatetepe's server.
-  # Provides support for both synchronous and asynchronous responses.
-  class App
-    attr_reader :app
-    
-    # Initializes a new App object.
-    #
-    # @param [#call] app
-    #   The Rack app.
-    #
-    def initialize(app)
-      @app = app
-    end
-    
-    # Processes the request.
-    #
-    # Will call #postprocess with the Rack app's response. Catches :async
-    # as an additional indicator for an asynchronous response. Uses a standard
-    # 500 response if the Rack app raises an error.
-    #
-    # @param [Hash] env
-    #   The Rack environment.
-    #
-    def call(env)
-      env["async.callback"] = proc do |response|
-        postprocess env, response
-      end
-      
-      response = ASYNC_RESPONSE
-      catch :async do
-        response = begin
-          app.call env
-        rescue => ex
-          raise ex if ENV["RACK_ENV"] == "testing"
-          ERROR_RESPONSE
-        end
-      end
-      
-      postprocess env, response
-    end
-    
-    # Sends the response.
-    #
-    # Does nothing if response status is indicating an asynchronous response.
-    # This is the case if the response +Array+'s first element equals -1.
-    # Otherwise it will start sending the response (status and headers).
-    #
-    # If the body indicates streaming it will return after sending the status
-    # and headers. This happens if the body equals +Rack::STREAMING+ or isn't
-    # set. Otherwise it sends each body chunk and then closes the response
-    # stream.
-    #
-    # Sending an empty body is as simple as passing an object that responds to
-    # +each+ but doesn't actually yield anything.
-    #
-    # @param [Hash] env
-    #   The Rack environment.
-    # @param [Array] response
-    #   An array of 1..3 length containing the status, headers, body.
-    #
-    def postprocess(env, response)
-      return if response[0] == ASYNC_RESPONSE[0]
-      
-      env["stream.start"].call response[0..1]
-      return if !response[2] || response[2] == Rack::STREAMING
-      
-      begin
-        response[2].each &env["stream.send"]
-      ensure
-        env["stream.close"].call
-      end
-    end
-  end
-end

data/lib/hatetepe/server/proxy.rb

@@ -1,48 +0,0 @@
-require "hatetepe/client"
-require "hatetepe/request"
-require "uri"
-
-class Hatetepe::Server
-  class Proxy
-    attr_reader :app
-    
-    def initialize(app)
-      @app = app
-    end
-    
-    def call(env)
-      env["proxy.start"] = proc do |target, client = nil|
-        start env, target, client
-      end
-      app.call env
-    end
-    
-    def start(env, target, client)
-      target = URI.parse(target)
-      env.delete "proxy.start"
-      
-      env["proxy.callback"] ||= env["async.callback"]
-      
-      cl = client || Hatetepe::Client.start(:host => target.host,
-                                            :port => target.port)
-      build_request(env, target).tap do |req|
-        cl << req
-        EM::Synchrony.sync req
-        req.response.body.callback { cl.stop } unless client
-        env["proxy.callback"].call req.response
-      end
-    end
-    
-    # TODO use only +env+ to build the request
-    def build_request(env, target)
-      unless base = env["hatetepe.request"]
-        raise ArgumentError, "Proxying requires env[hatetepe.request] to be set"
-      end
-      
-      uri = target.path + base.uri
-      host = "#{target.host}:#{target.port}"
-      headers = base.headers.merge("Host" => host)
-      Hatetepe::Request.new base.verb, uri, headers, base.body
-    end
-  end
-end

data/spec/unit/app_spec.rb

@@ -1,125 +0,0 @@
-require "spec_helper"
-require "hatetepe/server"
-
-describe Hatetepe::Server::App do
-  let(:inner_app) { stub "inner app", :call => response }
-  let(:app) { Hatetepe::Server::App.new inner_app }
-  let(:env) {
-    {
-      "stream.start" => proc {},
-      "stream.send" => proc {},
-      "stream.close" => proc {}
-    }
-  }
-  
-  let(:status) { 123 }
-  let(:headers) { stub "headers" }
-  let(:body) { [stub("chunk#1"), stub("chunk#2")] }
-  let(:response) { [status, headers, body] }
-  
-  context "#initialize(inner_app)" do
-    it "keeps the inner app" do
-      Hatetepe::Server::App.new(inner_app).app.should equal(inner_app)
-    end
-  end
-  
-  context "#call(env)" do
-    it "sets env[async.callback] before #call'ing inner_app" do
-      app.call env
-      
-      app.should_receive(:postprocess) {|e, res|
-        e.should equal(env)
-        res.should equal(response)
-      }
-      env["async.callback"].call response
-    end
-    
-    it "calls #postprocess with the return of inner_app#call(env)" do
-      inner_app.stub :call => response
-      app.should_receive(:postprocess) {|e, res|
-        e.should equal(env)
-        res.should equal(response)
-      }
-      
-      app.call env
-    end
-    
-    let(:error_response) {
-      [500, {"Content-Type" => "text/html"}, ["Internal Server Error"]]
-    }
-    
-    it "responds with 500 when catching an error" do
-      ENV.delete "RACK_ENV"
-      
-      inner_app.stub(:call) { raise }
-      app.should_receive(:postprocess) {|e, res|
-        res.should == error_response
-      }
-      
-      app.call env
-    end
-    
-    describe "if server's :env option is testing" do
-      let(:error) { StandardError.new }
-      
-      it "doesn't catch errors" do
-        inner_app.stub(:call) { raise error }
-        expect { app.call env }.to raise_error(error)
-      end
-    end
-    
-    let(:async_response) { [-1, {}, []] }
-    
-    it "catches :async for Thin compatibility" do
-      inner_app.stub(:call) { throw :async }
-      app.should_receive(:postprocess) {|e, res|
-        res.should == async_response
-      }
-      
-      app.call env
-    end
-  end
-  
-  context "#postprocess(env, response)" do
-    it "does nothing if the response status is lighter than 0" do
-      env["stream.start"].should_not_receive :call
-      app.postprocess env, [-1]
-    end
-    
-    it "starts the response stream" do
-      env["stream.start"].should_receive(:call).with([status, headers])
-      app.postprocess env, [status, headers, []]
-    end
-    
-    it "streams the body" do
-      body.should_receive :each do |&blk|
-        blk.should equal(env["stream.send"])
-      end
-      app.postprocess env, [status, headers, body]
-    end
-    
-    it "doesn't stream the body if it equals Rack::STREAMING" do
-      body.should_not_receive :each
-      app.postprocess env, [status, headers, Rack::STREAMING]
-    end
-    
-    it "doesn't try to stream a body that isn't set" do
-      body.should_not_receive :each
-      app.postprocess env, [status, headers]
-    end
-    
-    it "closes the response stream after streaming the body" do
-      env["stream.close"].should_receive :call
-      app.postprocess env, [status, headers, body]
-    end
-    
-    it "closes the response even if streaming the body fails" do
-      body.should_receive(:each).and_raise
-      env["stream.close"].should_receive :call
-      
-      proc {
-        app.postprocess env, [status, headers, body]
-      }.should raise_error
-    end
-  end
-end

data/spec/unit/client/pipeline_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-require "hatetepe/client"
-
-describe Hatetepe::Client::Pipeline do
-  let(:app) { stub "app", :call => nil }
-  let(:pipeline) { Hatetepe::Client::Pipeline.new app }
-  
-  describe "#initialize(app)" do
-    it "sets the app" do
-      pipeline.app.should equal(app)
-    end
-  end
-  
-  let(:requests) {
-    [stub("previous_request"), stub("request")]
-  }
-  let(:lock) { stub "lock" }
-  let(:pending) { {requests.first.object_id => lock} }
-  let(:client) do
-    stub "client", :requests => requests, :pending_transmission => pending
-  end
-  let(:response) { stub "response" }
-  
-  before do
-    requests.last.stub :connection => client
-    EM::Synchrony.stub :sync
-  end
-  
-  describe "#call(request)" do
-    it "waits until the previous request has been transmitted" do
-      EM::Synchrony.should_receive(:sync).with lock
-      pipeline.call requests.last
-    end
-    
-    it "calls the app" do
-      app.should_receive(:call).with(requests.last) { response }
-      pipeline.call(requests.last).should equal(response)
-    end
-  end
-end

data/spec/unit/proxy_spec.rb

@@ -1,145 +0,0 @@
-require "spec_helper"
-require "hatetepe/server"
-
-describe Hatetepe::Server::Proxy do
-  let(:app) { stub "app" }
-  
-  describe "#initialize(app)" do
-    it "sets the app" do
-      Hatetepe::Server::Proxy.new(app).app.should equal(app)
-    end
-  end
-  
-  let(:proxy) { Hatetepe::Server::Proxy.new app }
-  let(:target) { stub "target" }
-  let(:env) { {} }
-  let(:client) { stub "client", :<< => nil }
-  
-  describe "#call(env)" do
-    it "sets env[proxy.start]" do
-      app.stub :call do |env|
-        env["proxy.start"].should respond_to(:call)
-      end
-      proxy.call env
-    end
-    
-    let(:response) { stub "response" }
-    
-    it "calls the app" do
-      app.should_receive(:call).with(env) { response }
-      proxy.call(env).should equal(response)
-    end
-    
-    describe "env[proxy.start]" do
-      it "forwards to #start" do
-        proxy.should_receive(:start).with(env, target, client)
-        app.stub :call do |env|
-          env["proxy.start"].call target, client
-        end
-        proxy.call env
-      end
-    end
-  end
-  
-  describe "#start(env, target, client)" do
-    let(:request) { stub "request" }
-    let(:response) { stub "response" }
-    let(:callback) { stub "async.callback", :call => nil }
-    
-    let(:host) { stub "host" }
-    let(:port) { stub "port" }
-    let(:target) { stub "target", :host => host, :port => port }
-    
-    before do
-      URI.stub :parse => target
-      proxy.stub :build_request => request
-      
-      request.stub :dup => request, :response => response
-      request.extend EM::Deferrable
-      env["async.callback"] = callback
-    end
-    
-    it "deletes env[proxy.start] from the env hash" do
-      env.should_receive(:delete).with "proxy.start"
-      Fiber.new { proxy.start env, target, client }.resume
-    end
-    
-    it "defaults env[proxy.callback] to env[async.callback]" do
-      Fiber.new { proxy.start env, target, client }.resume
-      env["proxy.callback"].should equal(env["async.callback"])
-    end
-    
-    let(:new_client) { stub "new client" }
-    
-    it "starts a client if none was passed" do
-      Hatetepe::Client.stub :start do |config|
-        config[:host].should equal(host)
-        config[:port].should equal(port)
-        new_client
-      end
-      new_client.should_receive(:<<).with request
-      Fiber.new { proxy.start env, target, nil }.resume
-    end
-    
-    it "doesn't stop a client that was passed" do
-      client.should_not_receive :stop
-      Fiber.new { proxy.start env, target, client }.resume
-      request.succeed
-    end
-    
-    it "passes the request to the client" do
-      proxy.should_receive :build_request do |e, t|
-        env.should equal(e)
-        target.should equal(t)
-        request
-      end
-      client.should_receive(:<<).with request
-      Fiber.new { proxy.start env, target, client }.resume
-    end
-    
-    it "passes the response to env[async.callback]" do
-      callback.should_receive(:call).with response
-      Fiber.new { proxy.start env, target, client }.resume
-      request.succeed
-    end
-    
-    it "waits for the request to succeed" do
-      succeeded = false
-      callback.stub(:call) {|response| succeeded = true }
-      
-      Fiber.new { proxy.start env, target, client }.resume
-      succeeded.should be_false
-      
-      request.succeed
-      succeeded.should be_true
-    end
-  end
-  
-  describe "#build_request(env, target)" do
-    let(:target) { URI.parse "http://localhost:3000/bar" }
-    let(:base_request) { Hatetepe::Request.new "GET", "/foo" }
-    
-    before do
-      env["hatetepe.request"] = base_request
-      env["REMOTE_ADDR"] = "123.234.123.234"
-    end
-    
-    it "fails if env[hatetepe.request] isn't set" do
-      env.delete "hatetepe.request"
-      proc { proxy.build_request env, target }.should raise_error(ArgumentError)
-    end
-    
-    it "combines the original URI with the target URI" do
-      proxy.build_request(env, target).uri.should == "/bar/foo"
-    end
-    
-    it "builds a new request" do
-      proxy.build_request(env, target).should_not equal(base_request)
-    end
-    
-    it "sets version to HTTP/1.1" do
-      base_request.http_version = "1.0"
-      proxy.build_request(env, target).http_version.should == "1.1"
-    end
-  end
-end