experella-proxy 0.0.6

data/lib/experella-proxy.rb

@@ -0,0 +1,93 @@
+require 'optparse'
+require 'eventmachine'
+require 'http_parser.rb'
+require 'experella-proxy/globals'
+require 'experella-proxy/http_status_codes'
+require 'experella-proxy/configuration'
+require 'experella-proxy/server'
+require 'experella-proxy/connection_manager'
+require 'experella-proxy/backend_server'
+require 'experella-proxy/connection'
+require 'experella-proxy/proxy'
+require 'experella-proxy/backend'
+require 'experella-proxy/request'
+require 'experella-proxy/response'
+
+# Namespace Module for the Proxy Server
+#
+# Startup code and options parser is defined here
+#
+# @example startup
+#   ARGV << '--help' if ARGV.empty?
+#
+#   options = {}
+#   OptionParser.new do |opt|
+#     opt.banner = "Usage: experella-proxy <command> <options> -- <application options>\n\n"
+#     opt.banner << "where <applicaion options> are"
+#
+#     opt.on("-c", "--config=CONFIGFILE", "start server with config in given filepath") do |v|
+#       options[:configfile] = File.expand_path(v)
+#       ExperellaProxy.run(options)
+#     end
+#
+#   end.parse!
+#
+# @see file:README.md README
+# @author Dennis-Florian Herr 2014 @Experteer GmbH
+module ExperellaProxy
+
+  # Initializes ExperellaProxy's {Configuration} and {ConnectionManager}
+  #
+  # @param [Hash] options Hash passed to the configuration
+  # @option option [String] :configfile the config filepath
+  # @return [Boolean] true if successful false if NoConfigError was raised
+  def self.init(options={})
+    begin
+    Configuration.new(options)
+    rescue Configuration::NoConfigError => e
+      puts e.message
+      puts e.backtrace.join("\n\t")
+      return false
+    end
+    @connection_manager = ConnectionManager.new
+    true
+  end
+
+  # Creates Server object and calls {Server#run} if {ExperellaProxy#init}
+  #
+  # @param [Hash] options Hash passed to the configuration
+  # @option option [String] :configfile the config filepath
+  def self.run(options={})
+    @server = Server.new(options).run if ExperellaProxy.init(options)
+  end
+
+  # Fresh restarts ExperellaProxy with same options.
+  #
+  # Loses all buffered data
+  def self.restart
+    opts = @server.options
+    self.stop
+    Server.new(opts).run if ExperellaProxy.init(opts)
+  end
+
+  # Stops ExperellaProxy
+  #
+  def self.stop
+     Proxy.stop
+  end
+
+end
+
+#startup
+ARGV << '--help' if ARGV.empty?
+
+options = {}
+OptionParser.new do |opt|
+  opt.banner = "Usage: experella-proxy <command> <options> -- <application options>\n\n"
+  opt.banner << "where <applicaion options> are"
+
+  opt.on("-c", "--config=CONFIGFILE", "start server with config in given filepath") do |v|
+    options[:configfile] = File.expand_path(v)
+    ExperellaProxy.run(options)
+  end
+end.parse!

data/spec/echo-server/echo_server.rb

@@ -0,0 +1,49 @@
+require 'eventmachine'
+require 'http_parser.rb'
+module EchoServer
+
+  def post_init
+    @parser = Http::Parser.new
+    @buffer = String.new
+
+    @parser.on_headers_complete = proc do |h|
+      if @parser.request_path == "/chunked"
+        @chunked = true
+      end
+    end
+
+    @parser.on_message_complete = proc do
+      if @chunked
+        answer = "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n"
+        answer << "9\r\nchunk one\r\n"
+        answer << "a\r\n chunk two\r\n"
+        answer << "d\r\n chunk three \r\n"
+        answer << "b\r\nchunk four \r\n"
+        answer << "15\r\nchunk 123456789abcdef\r\n0\r\n\r\n"
+      else
+        @buffer = "you sent: " + @buffer.dump
+        answer = "HTTP/1.1 200 OK\r\nContent-Length: #{@buffer.length}\r\nConnection: close\r\n\r\n"
+        answer << @buffer
+      end
+      send_data answer
+      close_connection_after_writing
+    end
+  end
+
+  def receive_data data
+    @buffer << data
+    @parser << data
+  end
+
+end
+
+EventMachine.run do
+  trap("QUIT") { EM.stop }
+
+  if ARGV.count == 2
+    EventMachine.start_server ARGV.first, ARGV.last.to_i, EchoServer
+  else
+    raise "invalid number of params, expected [server] [port]"
+  end
+
+end

data/spec/experella-proxy/backend_server_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe ExperellaProxy::BackendServer do
+
+  let(:backend) {
+    ExperellaProxy::BackendServer.new("host", "port", {:concurrency => "2", :name => "name",
+                                                       :accepts => {"Host" => "experella"},
+                                                       :mangle => {"Connection" => "close"}
+                                                      })
+  }
+  let(:min_backend) {
+    ExperellaProxy::BackendServer.new("host", "port")
+  }
+  let(:pattern) {
+    backend.message_pattern
+  }
+
+  describe "#new" do
+
+    it "returns a ExperellaProxy::BackendServer" do
+      backend.should be_an_instance_of ExperellaProxy::BackendServer
+    end
+
+    it "has a host" do
+      backend.host.should eql "host"
+    end
+
+    it "has a port" do
+      backend.port.should eql "port"
+    end
+
+    it "has a name" do
+      backend.name.should eql "name"
+      min_backend.name.should eql "host:port"
+    end
+
+    it "has a concurrency" do
+      backend.concurrency.should eql 2
+      min_backend.concurrency.should eql 1
+    end
+
+    it "has a message pattern" do
+      backend.message_pattern.should_not be_nil
+      min_backend.message_pattern.should_not be_nil
+    end
+
+    it "mangle should be nil" do
+      backend.mangle.should == {:Connection => "close"}
+      min_backend.mangle.should be_nil
+    end
+
+    it "has workload zero" do
+      backend.workload.should eql 0
+    end
+  end
+
+  shared_examples "the message pattern" do
+
+    it "returns a proc" do
+      pattern.should be_an_instance_of Proc
+    end
+
+  end
+
+
+  describe "#update_message_pattern" do
+
+    #it "adds the hash parameter to the message_pattern and overwrites values of duplicate keys" do
+    #  backend.update_message_pattern({"Host" => "experella.de", "Connection" => "keep-alive"})
+    #  pattern = backend.message_pattern
+    #  pattern[:Host].should eql Regexp.new("experella.de")
+    #  pattern[:Connection].should eql Regexp.new("keep-alive")
+    #end
+
+    it_should_behave_like "the message pattern"
+  end
+
+  describe "#accept?" do
+
+
+    it "returns false if request header doesn't have all keys of message_pattern" do
+      request = ExperellaProxy::Request.new("")
+      request.update_header(:request_url => "/docs")
+      backend.accept?(request).should be_false
+    end
+
+    it "returns false if request headers don't match full message_pattern" do
+      request = ExperellaProxy::Request.new("")
+      request.update_header(:Host => "google.com", :request_url => "/docs")
+      backend.accept?(request).should be_false
+    end
+
+    it "returns true if full message pattern finds matches in request headers" do
+      request = ExperellaProxy::Request.new("")
+      request.update_header(:Host => "experella.com", :request_url => "/docs")
+      backend.accept?(request).should be_true
+    end
+
+  end
+
+end

data/spec/experella-proxy/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ExperellaProxy::Configuration do
+  let(:config) {
+    ExperellaProxy.config
+  }
+
+  let(:no_config){
+    ExperellaProxy::Configuration.new(:configfile => "")
+  }
+
+  it "should load a config file" do
+    config.backends.size.should == 4
+    config.timeout.should == 6.0
+    config.proxy.size.should == 2
+  end
+
+  it "should load error pages" do
+    config.error_pages[404].empty?.should be_false
+    config.error_pages[503].empty?.should be_false
+  end
+
+  it "should raise NoConfigError if config filepath doesn't exist" do
+    lambda { config.read_config_file("/a/non/existing/filepath")
+    }.should raise_error(ExperellaProxy::Configuration::NoConfigError)
+  end
+end

data/spec/experella-proxy/connection_manager_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe ExperellaProxy::ConnectionManager do
+
+  let(:manager) {
+    ExperellaProxy::ConnectionManager.new
+  }
+
+  class Testconnection
+
+    def initialize()
+      @request = ExperellaProxy::Request.new(self)
+    end
+
+    def get_request
+      @request
+    end
+  end
+
+  describe "#backend_count" do
+    it "returns size of the backend_list" do
+      manager.backend_count.should == 0
+    end
+  end
+
+  describe "#backend_queue_count" do
+    it "returns size of the backend_queue" do
+      manager.backend_queue_count.should == 0
+    end
+  end
+
+  describe "#add_backend" do
+    it "should add a BackendServer to list and queue and return true" do
+      ret = manager.add_backend(ExperellaProxy::BackendServer.new("host", "port"))
+      manager.backend_count.should == 1
+      manager.backend_queue_count.should == 1
+      ret.should == true
+    end
+
+    it "should add a BackendServer to list and return conn if a queued conn matches" do
+      manager.add_backend(ExperellaProxy::BackendServer.new("host", "port"))
+      manager.backend_count.should == 1
+      manager.backend_queue_count.should == 1
+      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_count.should == 1
+      manager.backend_queue_count.should == 0
+      manager.connection_count.should == 1
+      ret = manager.add_backend(ExperellaProxy::BackendServer.new("hostx", "port"))
+      manager.backend_count.should == 2
+      manager.backend_queue_count.should == 0
+      ret.should be_an_instance_of Testconnection
+    end
+
+  end
+
+  describe "#remove_backend" do
+    it "should return true if a backend was removed" do
+      backend = ExperellaProxy::BackendServer.new("host", "port")
+      manager.add_backend(backend)
+      manager.backend_count.should == 1
+      manager.backend_queue_count.should == 1
+      ret = manager.remove_backend(backend)
+      ret.should be_true
+      manager.backend_count.should == 0
+      manager.backend_queue_count.should == 0
+    end
+
+    it "should return false if no backend was removed" do
+      backend = ExperellaProxy::BackendServer.new("host", "port")
+      manager.remove_backend(backend).should be_false
+    end
+  end
+
+  describe "#free_backend" do
+    it "should return a connection if any queued conn matches" do
+      backend = ExperellaProxy::BackendServer.new("host", "port")
+      manager.add_backend(backend)
+      manager.backend_available?(Testconnection.new().get_request)
+      manager.backend_available?(Testconnection.new().get_request)
+      ret = manager.free_backend(backend)
+      ret.should be_an_instance_of Testconnection
+    end
+
+    it "should return nil and requeue backend if no conn matches" do
+      backend = ExperellaProxy::BackendServer.new("host", "port")
+      manager.add_backend(backend)
+      manager.backend_available?(Testconnection.new().get_request)
+      backend_queue = manager.backend_queue_count
+      workload = backend.workload
+      ret = manager.free_backend(backend)
+      ret.should == nil
+      manager.backend_queue_count.should == (backend_queue + 1)
+      backend.workload.should == (workload - 1)
+    end
+
+  end
+
+  describe "#free_connection" do
+    it "should remove connection from queue" do
+      backend = ExperellaProxy::BackendServer.new("host", "port")
+      manager.add_backend(backend)
+      connections = []
+      connections[1] = Testconnection.new()
+      connections[2] = Testconnection.new()
+      manager.backend_available?(connections[1].get_request)
+      manager.backend_available?(connections[2].get_request)
+      count_before = manager.connection_count
+      manager.free_connection(connections[2])
+      manager.connection_count.should == (count_before - 1)
+    end
+  end
+
+  describe "#backend_available?" do
+    before(:each) do
+      manager.add_backend(ExperellaProxy::BackendServer.new("host", "port", {:concurrency => 3, :accepts => {"Host" => "test"}}))
+      manager.add_backend(ExperellaProxy::BackendServer.new("host2", "port", {:accepts => {"Host" => "bla"}}))
+      manager.add_backend(ExperellaProxy::BackendServer.new("host3", "port", {:accepts => {"Host" => "blax"}}))
+    end
+    it "returns first matching backend and removes it from queue" do
+      conn = Testconnection.new
+      conn.get_request.update_header("Host" => "loremblaxipsum")
+      before_count = manager.backend_queue_count
+      ret = manager.backend_available?(conn.get_request)
+      ret.name.should == "host2:port"
+      manager.backend_queue_count.should == (before_count - 1)
+    end
+
+    it "should requeue matching backend if concurrency is smaller than workload" do
+      conn = Testconnection.new
+      conn.get_request.update_header("Host" => "loremtestipsum")
+      before_count = manager.backend_queue_count
+      ret = manager.backend_available?(conn.get_request)
+      ret.name.should == "host:port"
+      manager.backend_queue_count.should == before_count
+    end
+
+    it "returns :queued if no matching backend is currently available" do
+      conn = Testconnection.new
+      conn.get_request.update_header("Host" => "loremblaipsum")
+      manager.backend_available?(conn.get_request)
+      before_count = manager.backend_queue_count
+      ret = manager.backend_available?(conn.get_request)
+      ret.should == :queued
+      manager.backend_queue_count.should == before_count
+    end
+
+    it "returns false if no registered backend matches" do
+      conn = Testconnection.new
+      conn.get_request.update_header("Host" => "loremipsum")
+      before_count = manager.backend_queue_count
+      ret = manager.backend_available?(conn.get_request)
+      ret.should be_false
+      manager.backend_queue_count.should == before_count
+    end
+
+  end
+
+end