experella-proxy 0.0.6

data/spec/experella-proxy/experella-proxy_spec.rb

@@ -0,0 +1,471 @@
+require 'spec_helper'
+
+# Dirty integration tests for the proxy connection logic
+#
+# uses the simple echo server in spec/echo-server/echo_server.rb and the test_config.rb
+#
+# Proxy logfile in spec/log/spec.log
+#
+describe ExperellaProxy do
+  include POSIX::Spawn
+  include ExperellaProxy::Globals
+  let(:echo_server) {
+    File.expand_path("../../echo-server/echo_server.rb", __FILE__)
+  }
+  let(:experella_proxy) {
+    File.expand_path("../../../bin/experella-proxy", __FILE__)
+  }
+
+
+
+  describe "EchoServer" do
+    before :each do
+      @pid = spawn("ruby", "#{echo_server}", "127.0.0.10", "7654")
+      sleep(0.8) #let the server startup, specs may fail if this is set to low
+    end
+    after :each do
+      Process.kill('QUIT', @pid)
+      sleep(1.0) # give the kill command some time
+    end
+
+    it "should get response from the echoserver" do
+      lambda {
+        EM.run do
+          http = EventMachine::HttpRequest.new("http://127.0.0.10:7654").get({:connect_timeout => 1})
+          http.errback {
+            EventMachine.stop
+            raise "http request failed"
+          }
+          http.callback {
+            http.response.should start_with "you sent: "
+            EventMachine.stop
+          }
+        end
+      }.should_not raise_error
+    end
+  end
+
+  describe "Proxy" do
+    before :each do
+      @pid = spawn("ruby", "#{echo_server}", "127.0.0.10", "7654")
+      @pid2 = spawn("#{experella_proxy}", "run", "--", "--config=#{File.join(File.dirname(__FILE__),"/../fixtures/test_config.rb")}")
+      sleep(0.8) #let the server startup, specs may fail if this is set to low
+      ExperellaProxy.init(:configfile => File.join(File.dirname(__FILE__),"/../fixtures/test_config.rb"))
+      config.backends.each do |backend|
+        connection_manager.add_backend(ExperellaProxy::BackendServer.new(backend[:host], backend[:port], backend))
+      end
+    end
+    after :each do
+      log.close
+      Process.kill('QUIT', @pid)
+      Process.kill('TERM', @pid2)
+      sleep(1.0) # give the kill command some time
+    end
+
+    it "should get response from the echoserver via the proxy" do
+      log.info "should get response from the echoserver via the proxy"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+            ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            http.errback {
+              EventMachine.stop
+              raise "http request failed"
+            }
+            http.callback {
+              http.response.should start_with "you sent: "
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should respond with 404" do
+      log.info "should respond with 404"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+
+            multi = EventMachine::MultiRequest.new
+            multi_shuffle = []
+            multi_shuffle[0] = Proc.new {
+              multi.add :head, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+              ).head({:connect_timeout => 1})
+            }
+            multi_shuffle[1] = Proc.new {
+              multi.add :get, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+              ).get({:connect_timeout => 1})
+            }
+            multi_shuffle.shuffle!
+            multi_shuffle.each do |p|
+              p.call
+            end
+
+            multi.callback do
+              unless multi.responses[:errback].empty?
+                EventMachine.stop
+                raise "http request failed"
+              end
+              multi.responses[:callback][:head].response.empty?.should be_true
+              multi.responses[:callback][:head].response_header.status.should == 404
+              multi.responses[:callback][:get].response_header.status.should == 404
+              multi.responses[:callback][:get].response.should start_with "<!DOCTYPE html>"
+              EventMachine.stop
+            end
+
+
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should respond with 400 on malformed request" do
+      log.info "should respond with 400 on malformed request"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com", "Transfer-Encoding" => "chunked"},
+                   :body => "9\r\nMalformed\r\na\r\nchunked da\r\n2\rta HERE\r\n0\r\n\r\n"})
+            http.errback {
+              EventMachine.stop
+              raise "http request failed"
+            }
+            http.callback {
+              http.response_header.status.should == 400
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should respond with 503" do
+      log.info "should respond with 503"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+
+            multi = EventMachine::MultiRequest.new
+            multi_shuffle = []
+            multi_shuffle[0] = Proc.new {
+              multi.add :head, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/oneroute"
+              ).head({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            }
+            multi_shuffle[1] = Proc.new {
+              multi.add :get, EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/anotherpath"
+              ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            }
+            multi_shuffle.shuffle!
+            multi_shuffle.each do |p|
+              p.call
+            end
+
+            multi.callback do
+              unless multi.responses[:errback].empty?
+                EventMachine.stop
+                raise "http request failed"
+              end
+              multi.responses[:callback][:head].response.empty?.should be_true
+              multi.responses[:callback][:head].response_header.status.should == 503
+              multi.responses[:callback][:get].response_header.status.should == 503
+              multi.responses[:callback][:get].response.should start_with "<!DOCTYPE html>"
+              EventMachine.stop
+            end
+
+
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should reuse keep-alive connections" do
+      log.info "should reuse keep-alive connections"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
+            req1 = conn.get({:connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+
+            req1.errback {
+              EventMachine.stop
+              raise "http request 1 failed"
+            }
+            req1.callback {
+              req1.response.should start_with "you sent: "
+              req2 = conn.get({:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+              req2.errback {
+                EventMachine.stop
+                raise "http request 2 failed"
+              }
+              req2.callback {
+                req2.response.should start_with "you sent: "
+                req3 = conn.get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+                req3.errback {
+                  EventMachine.stop
+                  raise "http request 3 failed"
+                }
+                req3.callback {
+                  req3.response.should start_with "you sent: "
+                  EventMachine.stop
+                }
+              }
+            }
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should handle chunked post requests and strip invalid Content-Length" do
+      log.info "should stream chunked post requests"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            # this will issue a Post Request with Content-Length AND Transfer-Encoding chunked, where the data is
+            # correctly encoded in chunks. The Proxy should therefor strip the Content-Length and forward the data
+            # in chunks.
+            expected_headers = []
+            expected_headers << "POST / HTTP/1.1"
+            expected_headers << "Host: experella.com"
+            expected_headers << "Connection: close"
+            expected_headers << "Via: 1.1 experella"
+            expected_headers << "User-Agent: EventMachine HttpClient"
+            expected_headers << "Transfer-Encoding: chunked"
+
+            # generate random chunked message
+            body = String.new
+            expected_body = String.new
+            chunks = 20 + rand(20)
+            # all alphanumeric characters
+            o = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map { |i| i.to_a }.flatten
+            while chunks > 0 do
+              #chunksize 10 to 1510 characters
+              string = (0...(10 + rand(1500))).map { o[rand(o.length)] }.join
+              body << string.size.to_s(16)
+              body << "\r\n"
+              body << string
+              expected_body << string
+              body << "\r\n"
+              chunks -= 1
+            end
+            body << "0\r\n\r\n"
+
+            http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com", "Transfer-Encoding" => "chunked"},
+                   :body => body})
+            http.errback {
+              EventMachine.stop
+              raise "http request failed"
+            }
+            http.callback {
+              # as the proxy can rechunk large data in different chunks, it's required to remove all chunk encoding
+              # characters and compare it to the unchunked random data saved in expected_body
+
+              # split header and body
+              response = http.response.partition("\\r\\n\\r\\n")
+              # split by chunked encoding delimiter
+              response[2] = response[2].split("\\r\\n").map { |i|
+                # delete all strings containing the hex-size information (FFF = length 3 = 4500 chars)
+                if i.length <= 3
+                  i = ""
+                else
+                  i = i
+                end
+              }.join
+              response = response.join
+              expected_headers.each do |header|
+                response.should include header
+              end
+              response.should include expected_body
+
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+
+    end
+
+    # check echo_server for the response
+    it "should rechunk and stream Transfer-Encoding chunked responses" do
+      log.info "should rechunk and stream Transfer-Encoding chunked responses"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}/chunked"
+            ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            http.errback {
+              EventMachine.stop
+              raise "http request failed"
+            }
+            received_chunks = ""
+            http.stream { |chunk|
+             received_chunks << chunk
+            }
+            http.callback {
+              true.should be_true
+              received_chunks.should == "chunk one chunk two chunk three chunk four chunk 123456789abcdef"
+              http.response_header["Transfer-Encoding"].should == "chunked"
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+
+    end
+
+    it "should timeout inactive connections after config.timeout" do
+      log.info "should timeout inactive connections after config.timeout"
+      EM.epoll
+      EM.run do
+
+        lambda {
+          EventMachine.add_timer(0.2) do
+            time = Time.now
+            conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
+            req1 = conn.get({:connect_timeout => 1, :inactivity_timeout => config.timeout + 5,
+                             :keepalive => true, :head => {"Host" => "experella.com"}})
+            req1.errback {
+              time = Time.now - time
+              time.should >= config.timeout
+              time.should < config.timeout + 5
+              EventMachine.stop
+              raise "http request failed"
+            }
+            req1.callback {
+              req1.response.should start_with "you sent: "
+            }
+            #check for inactivity timeout
+            EventMachine.add_periodic_timer(1) do
+              if conn.conn.get_idle_time.nil?
+                time = Time.now - time
+                time.should >= config.timeout
+                time.should <= config.timeout + 5
+                EventMachine.stop
+              elsif Time.now - time > config.timeout + 6
+                EventMachine.stop
+                raise "Timeout failed completly"
+              end
+            end
+          end
+        }.should_not raise_error
+      end
+    end
+
+
+    it "should handle pipelined requests correctly" do
+      log.info "should handle pipelined requests correctly"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            conn = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}")
+
+            pipe1 = conn.get({:connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+            pipe2 = conn.get({:path => '/about/', :connect_timeout => 1, :keepalive => true, :head => {"Host" => "experella.com"}})
+            pipe3 = conn.get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+            pipe1.errback {
+              EventMachine.stop
+              raise "http request 1 failed"
+            }
+            pipe1.callback {
+              pipe1.response.should start_with "you sent: "
+              pipe2.finished?.should be_false
+              pipe3.finished?.should be_false
+            }
+            pipe2.errback {
+              EventMachine.stop
+              raise "http request 2 failed"
+            }
+            pipe2.callback {
+              pipe2.response.should start_with "you sent: "
+              pipe1.finished?.should be_true
+              pipe3.finished?.should be_false
+            }
+            pipe3.errback {
+              EventMachine.stop
+              raise "http request 3 failed"
+            }
+            pipe3.callback {
+              pipe3.response.should start_with "you sent: "
+              pipe1.finished?.should be_true
+              pipe2.finished?.should be_true
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should accept requests on all set proxy domains" do
+      log.info "should accept requests on all set proxy domains"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+
+            multi = EventMachine::MultiRequest.new
+            multi_shuffle = []
+            i = 0
+            while config.proxy.length > i do
+              multi_shuffle[i] = Proc.new { |i|
+                multi.add i, EventMachine::HttpRequest.new("http://#{config.proxy[i][:host]}:#{config.proxy[i][:port]}"
+                ).get({:connect_timeout => 1, :head => {"Host" => "experella.com"}})
+              }
+              i += 1
+            end
+            multi_shuffle.shuffle!
+            i = 0
+            multi_shuffle.each do |p|
+              p.call(i)
+              i += 1
+            end
+
+            multi.callback do
+              unless multi.responses[:errback].empty?
+                EventMachine.stop
+                raise "http request failed"
+              end
+              multi.responses[:callback].each_value do |resp|
+                resp.response.should start_with "you sent: "
+              end
+              EventMachine.stop
+            end
+          end
+        }.should_not raise_error
+      end
+    end
+
+    it "should be able to handle post requests" do
+      log.info "should be able to handle post requests"
+      EM.epoll
+      EM.run do
+        lambda {
+          EventMachine.add_timer(0.2) do
+            http = EventMachine::HttpRequest.new("http://#{config.proxy[0][:host]}:#{config.proxy[0][:port]}"
+            ).post({:connect_timeout => 1, :head => {"Host" => "experella.com"}, :body => "Message body"})
+            http.errback {
+              EventMachine.stop
+              raise "http post failed"
+            }
+            http.callback {
+              http.response.should start_with "you sent: "
+              http.response.should end_with "Message body\""
+              EventMachine.stop
+            }
+          end
+        }.should_not raise_error
+      end
+    end
+
+  end
+end

data/spec/experella-proxy/request_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ExperellaProxy::Request do
+
+  let(:request) {
+    ExperellaProxy::Request.new("conn")
+  }
+
+  describe "#new" do
+
+    it "initializes connection variable and reader" do
+      request.conn.should eql("conn")
+    end
+
+    it "initializes header hash and reader" do
+      request.header.should be_an_instance_of Hash
+    end
+
+    it "initializes uri hash and reader" do
+      request.uri.should be_an_instance_of Hash
+    end
+
+    it "initializes keep_alive boolean and reader" do
+      request.keep_alive.should be_true
+      request.keep_alive = false
+      request.keep_alive.should be_false
+    end
+
+    it "initializes chunked boolean and reader" do
+      request.chunked.should be_false
+      request.chunked = true
+      request.chunked.should be_true
+    end
+  end
+
+  describe "#<<" do
+    it "adds data to send_buffer" do
+      request << "hel"
+      request << "lo"
+      request.flush.should eql("hello")
+    end
+  end
+
+  describe "#flush" do
+    it "returns and clears the send_buffer" do
+      request << "hello"
+      request.flush.should eql("hello")
+      request.flushed?.should == true
+    end
+  end
+
+  describe "#add_uri" do
+    it "adds a hash to the URI hash" do
+      request.add_uri({:path => "/hello"})
+      request.uri[:path].should eql("/hello")
+    end
+  end
+
+  describe "#update_header" do
+    it "updates the header hash and symbolizes input keys" do
+      request.update_header("Host" => "xyz", :request_url => "abcd")
+      request.header[:Host].should eql("xyz")
+      request.header[:request_url].should eql("abcd")
+      request.header["Host"].should be_nil
+    end
+
+    it "overwrites values of existing keys" do
+      request.update_header("Host" => "xyz", :request_url => "abcd")
+      request.update_header("Host" => "abc")
+      request.header.should eql({:Host => "abc", :request_url => "abcd"})
+    end
+  end
+
+  describe "#reconstruct_header" do
+    it "writes a valid http header into send_buffer" do
+      request << "HeaderDummy\r\n\r\n"
+      request.update_header({:http_method => "GET", :request_url => "/index",
+                            "Host" => "localhost", "Connection" => "keep-alive", :"Via-X" => ["Lukas", "Amy", "George"]})
+      request.reconstruct_header
+      data = request.flush
+      data.start_with?("GET /index HTTP/1.1\r\n").should be_true
+      data.should include("Connection: keep-alive\r\n")
+      data.should include("Via-X: Lukas,Amy,George\r\n")
+      data.end_with?("\r\n\r\n").should be_true
+    end
+  end
+
+end

data/spec/experella-proxy/response_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe ExperellaProxy::Response do
+
+  let(:response) {
+    ExperellaProxy::Response.new(ExperellaProxy::Request.new("conn"))
+  }
+
+  describe "#new" do
+
+    it "initializes header hash and reader" do
+      response.header.should be_an_instance_of Hash
+    end
+  end
+
+  describe "#update_header" do
+    it "updates the header hash and symbolizes input keys" do
+      response.update_header("Host" => "xyz", :response_url => "abcd")
+      response.header[:Host].should eql("xyz")
+      response.header[:response_url].should eql("abcd")
+      response.header["Host"].should be_nil
+    end
+
+    it "overwrites values of existing keys" do
+      response.update_header("Host" => "xyz", :response_url => "abcd")
+      response.update_header("Host" => "abc")
+      response.header.should eql({:Host => "abc", :response_url => "abcd"})
+    end
+  end
+
+  describe "#reconstruct_header" do
+    it "writes a valid http header into send_buffer" do
+      response.update_header({"Connection" => "keep-alive",
+                              :"Via-X" => ["Lukas", "Amy", "George"]})
+      response.reconstruct_header
+      data = response.flush
+      data.start_with?("HTTP/1.1 500 Internal Server Error\r\n").should be_true
+      data.should include("Connection: keep-alive\r\n")
+      data.should include("Via-X: Lukas,Amy,George\r\n")
+      data.end_with?("\r\n\r\n").should be_true
+    end
+  end
+
+end

data/spec/fixtures/404.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style type="text/css"> body {
+        text-align: center;
+        font-family: helvetica, arial;
+        font-size: 22px;
+        color: #000;
+        margin: 20px
+    }
+    </style>
+</head>
+<body>
+<h2>404 Page not found!</h2>
+</body>
+</html>

data/spec/fixtures/503.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style type="text/css"> body {
+        text-align: center;
+        font-family: helvetica, arial;
+        font-size: 22px;
+        color: #000;
+        margin: 20px
+
+    }
+
+    </style>
+</head>
+<body>
+<h2> 503 Service unavailable!</h2>
+</body>
+</html>