experella-proxy 0.0.6

data/lib/experella-proxy/connection_manager.rb

@@ -0,0 +1,167 @@
+module ExperellaProxy
+
+  # static getter for the connection_manager variable
+  #
+  # @return [ConnectionManager] connection_manager
+  def self.connection_manager
+    @connection_manager
+  end
+
+  # The ConnectionManager is responsible for queueing and matching frontend {Connection} and {BackendServer} objects
+  class ConnectionManager
+
+    # The constructor
+    #
+    def initialize
+      @connection_queue = [] #array queue of client connection objects
+      @backend_queue = [] #array queue of available backend servers
+      @backend_list = {} #list of all backend servers
+    end
+
+    # Matches {Request} to queued {BackendServer}
+    #
+    # Removes first matching {BackendServer} from queue and returns it.
+    # It will requeue the {BackendServer} instantly,
+    # if {BackendServer#workload} is smaller than {BackendServer#concurrency}
+    #
+    # Queues {Request#conn} if no available {BackendServer} matches
+    #
+    # Returns false if no registered {BackendServer} matches
+    #
+    # @return [BackendServer] first matching BackendServer from the queue
+    # @return [Symbol] :queued if Connection was queued
+    # @return [Boolean] false if no registered Backend matches the Request
+    def backend_available?(request)
+      @backend_queue.each do |backend|
+        if backend.accept?(request)
+          #connect backend to requests connection if request matches
+          backend.workload += 1
+          ret = @backend_queue.delete(backend)
+          #requeue backend if concurrency isnt maxed
+          @backend_queue.push(backend) if backend.workload < backend.concurrency
+          return ret
+        end
+      end
+      if match_any_backend?(request)
+        #push requests connection on queue if no backend was connected
+        @connection_queue.push(request.conn)
+        :queued
+      else
+        false
+      end
+    end
+
+    # Called by a {Connection} when the {BackendServer} is done.
+    #
+    # Connects backend to a matching queued {Connection} or pushes server back on queue
+    #
+    # @param backend [BackendServer] BackendServer which got free
+    # @return [NilClass]
+    def free_backend(backend)
+      #check if any queued connections match new available backend
+      conn = match_connections(backend)
+      if conn
+        #return matching connection
+        #you should try to connect the new backend to this connection
+        return conn
+      else
+        #push free backend on queue if it wasn't used for a queued conn or is already queued (concurrency)
+        @backend_queue.push(backend) if @backend_list.include?(backend.name) && !@backend_queue.include?(backend)
+        backend.workload -= 1
+      end
+      nil
+    end
+
+    # Adds a new {BackendServer} to the list and queues or connects it
+    #
+    # @param backend [BackendServer] a new BackendServer
+    # @return [Connection] a queued connection that would match the BackendServer
+    # @return [Boolean] true if backend was added to list
+    def add_backend(backend)
+
+      @backend_list[backend.name] = backend
+
+      #check if any queued connections match new available backend
+      conn = match_connections(backend)
+      if conn
+        #return matching connection
+        #you should try to connect the new backend to this connection
+        return conn
+      else
+        #queue new backend
+        @backend_queue.push(backend)
+      end
+      true
+    end
+
+    # Removes a {BackendServer} from list and queue
+    #
+    # @param backend [BackendServer] the BackendServer to be removed
+    # @return [Boolean] true if a backend was removed, else returns false
+    def remove_backend(backend)
+
+      ret = @backend_list.delete(backend.name)
+      @backend_queue.delete(backend)
+
+      if ret
+        true
+      else
+        false
+      end
+    end
+
+    # Removes a connection from the connection_queue
+    #
+    # @param conn [Connection] Connection to be removed
+    def free_connection(conn)
+      @connection_queue.delete(conn)
+    end
+
+    # returns the count of the currently queued {BackendServer}s
+    #
+    # @return [int]
+    def backend_queue_count
+      @backend_queue.size
+    end
+
+    # returns the count of the registered{BackendServer}s
+    #
+    # @return [int]
+    def backend_count
+      @backend_list.size
+    end
+
+    # returns the count of the currently queued connections
+    #
+    # @return [int]
+    def connection_count
+      @connection_queue.size
+    end
+
+    private
+
+    # Matches request to all known backends
+    #
+    # @return [Boolean] true if it can be matched, false if request is not accepted at all
+    def match_any_backend?(request)
+      @backend_list.each_value do |v|
+        return true if v.accept?(request)
+      end
+      false
+    end
+
+    # Matches queued connections with a backend
+    #
+    # @return [Connection] matching connection
+    # @return [NilClass] nothing matched
+    def match_connections(backend)
+      @connection_queue.each do |conn|
+        if backend.accept?(conn.get_request)
+          return conn
+        end
+      end
+      nil
+    end
+
+  end
+end

data/lib/experella-proxy/globals.rb

@@ -0,0 +1,37 @@
+module ExperellaProxy
+
+  # defined hop by hop header fields
+  HOP_HEADERS = ["Connection", "Keep-Alive", "Proxy-Authorization", "TE", "Trailer", "Transfer-Encoding", "Upgrade"]
+
+  # Provides getters for global variables
+  #
+  # All methods are private. The module needs to be included in every Class which needs it.
+  module Globals
+
+    private
+
+    # @!visibility public
+
+    # Get the global config
+    #
+    # @return [Configuration] config object
+    def config
+      ExperellaProxy.config
+    end
+
+    # Get the global logger
+    #
+    # @return [Logger] logger set in config object
+    def log
+      ExperellaProxy.config.logger
+    end
+
+    # Get the global connection manager
+    #
+    # @return [ConnectionManager] connection_manager object
+    def connection_manager
+      ExperellaProxy.connection_manager
+    end
+
+  end
+end

data/lib/experella-proxy/http_status_codes.rb

@@ -0,0 +1,45 @@
+module ExperellaProxy
+
+  # Every standard HTTP code mapped to the appropriate message.
+  #
+  # @author Mongrel.
+  HTTP_STATUS_CODES = {
+      100 => 'Continue',
+      101 => 'Switching Protocols',
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non-Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Moved Temporarily',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Time-out',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Large',
+      415 => 'Unsupported Media Type',
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Time-out',
+      505 => 'HTTP Version not supported'
+  }
+end

data/lib/experella-proxy/proxy.rb

@@ -0,0 +1,61 @@
+module ExperellaProxy
+  # The proxy
+  #
+  # Controls the EventMachine, initializes backends from config and starts proxy servers
+  class Proxy
+    extend ExperellaProxy::Globals
+
+    # Starts the Eventmachine, initializes backends in {ConnectionManager} and starts the servers
+    # defined in config the proxy should listen on
+    #
+    # @param options [Hash] option Hash passed to the {Connection}
+    # @param blk [Block] Block evaluated in each new {Connection}
+    def self.start(options, &blk)
+
+      #initalize backend servers from config
+      config.backends.each do |backend|
+        connection_manager.add_backend(BackendServer.new(backend[:host], backend[:port], backend))
+        log.info "Initializing backend #{backend[:name]} at #{backend[:host]}:#{backend[:port]} with concurrency\
+                 #{backend[:concurrency]}"
+        log.info "Backend accepts: #{backend[:accepts].inspect}"
+        log.info "Backend mangles: #{backend[:mangle].inspect}"
+      end
+
+      #start eventmachine
+      EM.epoll
+      EM.run do
+        trap("TERM") { stop }
+        trap("INT") { stop }
+
+        if config.proxy.empty?
+          log.fatal "No proxy host:port address configured. Stopping experella-proxy."
+          return stop
+        else
+          config.proxy.each do |proxy|
+            opts = options
+            # pass proxy specific options
+            unless proxy[:options].nil?
+              opts = options.merge(proxy[:options])
+            end
+            log.info "Launching experella-proxy at #{proxy[:host]}:#{proxy[:port]} with #{config.timeout}s timeout..."
+            log.info "with options: #{opts.inspect}"
+            EventMachine::start_server(proxy[:host], proxy[:port],
+                                       Connection, opts) do |conn|
+              conn.instance_eval(&blk)
+            end
+          end
+        end
+      end
+    end
+
+    #
+    # Stops the Eventmachine and terminates all connections
+    #
+    def self.stop
+      if EM.reactor_running?
+        log.info("Terminating experella-proxy")
+        EventMachine::stop_event_loop
+      end
+    end
+  end
+end

data/lib/experella-proxy/request.rb

@@ -0,0 +1,106 @@
+module ExperellaProxy
+  #
+  # Request is used to store incoming (HTTP) requests and parsed data
+  #
+  # Every Request belongs to a client {Connection}
+  #
+  class Request
+
+    include ExperellaProxy::Globals
+
+    attr_accessor :keep_alive, :chunked
+    attr_reader :conn, :header, :uri, :response
+
+    # The constructor
+    #
+    # @param conn [Connection] Connection the request belongs to
+    def initialize(conn)
+      @conn = conn
+      @header = {}
+      @chunked = false # if true the parsed body will be chunked
+      @uri = {} #contains port, path and query information for faster backend selection
+      @keep_alive = true
+      @send_buffer = String.new
+      @response = Response.new(self)
+    end
+
+    # Adds data to the request object
+    #
+    # data must be formatted as string
+    #
+    # @param str [String] data as string
+    def <<(str)
+      @send_buffer << str
+    end
+
+    # Adds a hash with uri information to {#uri}
+    #
+    # duplicate key values will be overwritten with hsh values
+    #
+    # @param hsh [Hash] hash with keys :port :path :query containing URI information
+    def add_uri(hsh)
+      @uri.update(hsh)
+      log.debug hsh
+    end
+
+    # Returns the data in send_buffer and empties the send_buffer
+    #
+    # @return [String] data to send
+    def flush
+      @send_buffer.slice!(0, @send_buffer.length)
+    end
+
+    # Returns if the send_buffer is flushed? (empty)
+    #
+    # @return [Boolean]
+    def flushed?
+      @send_buffer.empty?
+    end
+
+    # Reconstructs modified http request in send_buffer
+    #
+    # Reconstructed request must be a valid request according to the HTTP Protocol
+    #
+    # First Header after Startline will always be "Host: ", after that order is determined by {#header}.each
+    #
+    def reconstruct_header
+      #split send_buffer into header and body part
+      buf = @send_buffer.split(/\r\n\r\n/, 2) unless flushed?
+      @send_buffer = ""
+      #start line
+      @send_buffer << @header[:http_method] + ' '
+      @send_buffer << @header[:request_url] + ' '
+      @send_buffer << "HTTP/1.1\r\n"
+      @send_buffer << "Host: " + @header[:Host] + "\r\n" #add Host first for better header readability
+      #header fields
+      @header.each do |key, value|
+        unless  key == :http_method || key == :request_url || key == :http_version || key == :Host #exclude startline parameters
+          @send_buffer << key.to_s + ": "
+          if value.is_a?(Array)
+            @send_buffer << value.shift
+            until value.empty? do
+              @send_buffer << "," + value.shift
+            end
+          else
+            @send_buffer << value
+          end
+          @send_buffer << "\r\n"
+        end
+      end
+      @send_buffer << "\r\n"
+      #reconstruction complete
+      @send_buffer << buf[1] unless buf.nil? #append buffered body
+      log.debug [:reconstructed_sendbuffer, @send_buffer]
+    end
+
+    # Adds a hash to {#header}
+    #
+    # symbolizes hsh keys, duplicate key values will be overwritten with hsh values
+    #
+    # @param hsh [Hash] hash with HTTP header Key:Value pairs
+    def update_header(hsh)
+      hsh = hsh.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
+      @header.update(hsh)
+    end
+  end
+end

data/lib/experella-proxy/response.rb

@@ -0,0 +1,204 @@
+module ExperellaProxy
+  #
+  # Response is used to store incoming (HTTP) responses and parsed data
+  #
+  # Every Response belongs to a request {Request}
+  #
+  class Response
+
+    include ExperellaProxy::Globals
+
+    attr_reader :header
+
+    # The constructor
+    #
+    # @param request [Request] Request the response belongs to
+    def initialize(request)
+      @request = request
+      @conn = request.conn
+      @header = {}
+      @status_code = 500
+      @chunked = false # if true the parsed body will be chunked
+      @buffer = false # default is false, so incoming data will be streamed,
+      # used for http1.0 clients and transfer-encoding chunked backend responses
+      @send_buffer = String.new
+      @response_parser = Http::Parser.new
+      init_http_parser
+    end
+
+    # Adds data to the response object
+    #
+    # data must be formatted as string
+    #
+    # On Http::Parser::Error parsing gets interrupted and the connection closed
+    #
+    # @param str [String] data as string
+    def <<(str)
+      begin
+        @response_parser << str
+      rescue Http::Parser::Error
+        log.warn ["Parser error caused by invalid response data", "@#{@conn.signature}"]
+        # on error unbind response_parser object, so additional data doesn't get parsed anymore
+        #
+        # assigning a string to the parser variable, will cause incoming data to get buffered
+        # imho this is a better solution than adding a condition for this rare error case
+        @response_parser = ""
+        @conn.close
+      end
+    end
+
+    # Returns the data in send_buffer and empties the send_buffer
+    #
+    # @return [String] data to send
+    def flush
+      log.debug [:data_to_user, @send_buffer]
+      @send_buffer.slice!(0, @send_buffer.length)
+    end
+
+    # Returns if the send_buffer is flushed? (empty)
+    #
+    # @return [Boolean]
+    def flushed?
+      @send_buffer.empty?
+    end
+
+    # Reconstructs modified http response in send_buffer
+    #
+    # Reconstructed response must be a valid response according to the HTTP Protocol
+    #
+    # Header order is determined by {#header}.each
+    #
+    def reconstruct_header
+      @send_buffer = ""
+      #start line
+      @send_buffer << "HTTP/1.1 "
+      @send_buffer << @status_code.to_s + ' '
+      @send_buffer << HTTP_STATUS_CODES[@status_code] + "\r\n"
+      #header fields
+      @header.each do |key, value|
+        @send_buffer << key.to_s + ": "
+        if value.is_a?(Array)
+          @send_buffer << value.shift
+          until value.empty? do
+            @send_buffer << "," + value.shift
+          end
+        else
+          @send_buffer << value
+        end
+        @send_buffer << "\r\n"
+      end
+      @send_buffer << "\r\n"
+      #reconstruction complete
+      log.debug [:response_reconstructed_header, @send_buffer]
+    end
+
+    # Adds a hash to {#header}
+    #
+    # symbolizes hsh keys, duplicate key values will be overwritten with hsh values
+    #
+    # @param hsh [Hash] hash with HTTP header Key:Value pairs
+    def update_header(hsh)
+      hsh = hsh.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
+      @header.update(hsh)
+    end
+
+    private
+
+    # initializes the response http parser
+    def init_http_parser
+      #called when response headers are completely parsed (first \r\n\r\n triggers this)
+      @response_parser.on_headers_complete = proc do |h|
+
+        @status_code = @response_parser.status_code
+
+        if @request.keep_alive
+          @header[:Connection] = "Keep-Alive"
+        end
+
+        # handle the transfer-encoding
+        #
+        # if no transfer encoding and no content-length is given, terminate connection after backend unbind
+        #
+        # if no transfer encoding is given, but there is content-length, just keep the content-length and send the message
+        #
+        # if a transfer-encoding is given, continue with Transfer-Encoding chunked and remove false content-length
+        # header if present. Old Transfer-Encoding header will be removed with all other hop-by-hop headers
+        #
+        if h["Transfer-Encoding"].nil?
+          # if no transfer-encoding and no content-length is present, set Connection: close
+          if h["Content-Length"].nil?
+            @request.keep_alive = false
+            @header[:Connection] = "close"
+          end
+        #chunked encoded
+        else
+          # buffer response data if client uses http 1.0 until message complete
+          if @request.header[:http_version][0] == 1 && @request.header[:http_version][1] == 0
+            @buffer = true
+          else
+            h.delete("Content-Length")
+            @chunked = true unless @request.header[:http_method] == "HEAD"
+            @header[:"Transfer-Encoding"] = "chunked"
+          end
+        end
+
+        # remove all hop-by-hop header fields
+        unless h["Connection"].nil?
+          h["Connection"].each do |s|
+            h.delete(s)
+          end
+        end
+        HOP_HEADERS.each do |s|
+          h.delete(s)
+        end
+
+
+        via = h.delete("Via")
+        if via.nil?
+          via = "1.1 experella"
+        else
+          via << "1.1 experella"
+        end
+        @header[:Via] = via
+
+
+        update_header(h)
+        unless @buffer
+          # called before any data is put into send_buffer
+          reconstruct_header
+          @conn.send_data flush
+        end
+      end
+
+      @response_parser.on_body = proc do |chunk|
+        if @chunked
+          # add hexadecimal chunk size
+          @send_buffer << chunk.size.to_s(16)
+          @send_buffer << "\r\n"
+          @send_buffer << chunk
+          @send_buffer << "\r\n"
+        else
+          @send_buffer << chunk
+        end
+        unless @buffer
+          @conn.send_data flush
+        end
+      end
+
+      @response_parser.on_message_complete = proc do
+        if @chunked
+          # send closing chunk
+          @send_buffer << "0\r\n\r\n"
+          @conn.send_data flush
+        elsif @buffer
+          @header[:"Content-Length"] = @send_buffer.size.to_s
+          body = flush
+          reconstruct_header
+          @send_buffer << body
+          @conn.send_data flush
+        end
+      end
+
+    end
+  end
+end

data/lib/experella-proxy/server.rb

@@ -0,0 +1,68 @@
+module ExperellaProxy
+  # The server starts the {Proxy} and provides callbacks/block hooks for client {Connection}s
+  class Server
+    include ExperellaProxy::Globals
+
+    # Constructor
+    #
+    # @param options [Hash] options Hash passed to the proxy
+    def initialize(options)
+      @options=options
+    end
+
+    attr_reader :options
+
+    # Runs the proxy server with given options
+    #
+    # Opens a block passed to every {Connection}
+    #
+    # You can add logic to
+    #
+    # {Connection#connected} in on_connect
+    # {Connection#receive_data} in on_data, must return data
+    # {Connection#relay_from_backend} in on_response, must return resp
+    # {Connection#unbind_backend} in on_finish
+    # {Connection#unbind} in on_unbind
+    #
+    def run
+
+      Proxy.start(options = {}) do |conn|
+
+        log.info msec + "new Connection @" + signature.to_s
+
+        # called on successful backend connection
+        # backend is the name of the connected server
+        conn.on_connect do |backend|
+
+        end
+
+        # modify / process request stream
+        # and return modified data
+        conn.on_data do |data|
+          data
+        end
+
+        # modify / process response stream
+        # and return modified response
+        conn.on_response do |backend, resp|
+          resp
+        end
+
+        # termination logic
+        conn.on_finish do |backend|
+
+        end
+
+        # called if client terminates connection
+        # or timeout occurs
+        conn.on_unbind do
+
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/experella-proxy/version.rb

@@ -0,0 +1,15 @@
+module ExperellaProxy
+  # ExperellaProxy Gemversion
+  # 0.0.6
+  # * updated homepage
+  # 0.0.5
+  # * added :host_port option to backend configuration
+  # 0.0.4
+  # * added lambda for accept filtering
+  #
+  # 0.0.3
+  # * added self-signed SSL certificate for TLS/HTTPS
+  # * added config template init functionality
+  #
+  VERSION = "0.0.6"
+end