experella-proxy 0.0.6

data/lib/experella-proxy/backend_server.rb

@@ -0,0 +1,100 @@
+module ExperellaProxy
+
+  # BackendServer objects contain information on available BackendServers
+  #
+  # Accepts Requests based on Request header information matched to it's message_pattern
+  #
+  # See {#initialize}
+  class BackendServer
+
+    attr_accessor :host, :port, :concurrency, :workload, :name
+    attr_reader :message_pattern, :mangle
+
+    # Constructor of the BackendServer
+    #
+    # required keys
+    #
+    #     :host         Host address of the Server, can be IP or domain
+    #     :port         Port of the Server, Integervalue as String
+    #
+    # optional keys
+    #
+    #     :name         Name of the Server used in the Logger and Cashing, String
+    #                   Will default to #{host}:#{port} but needs to be unique, though theoretical there can be
+    #                   multiple servers with the same host:port value pair!
+    #
+    #     :concurrency  max Number of concurrent connections, Integervalue as String. Default is 1
+    #
+    #     :accepts      Hash containing keys matching HTTP headers or URI :path, :port, :query
+    #                   Values are Regexp as Strings or as Regex, use ^((?!pattern).)*$ to negate matching
+    #                   Care: Will match any Header/value pairs not defined in the accepts Hash
+    #
+    #     :mangle       Hash containing keys matching HTTP headers. Values can be callable block or Strings
+    #                   Mangle modifies the header value based on the given block or replaces the header value with the String
+    #
+    # mangle is applied in {Connection#connect_backendserver}
+    #
+    # @param host [String] host domain-URL oder IP
+    # @param port [String] port as string
+    # @param [Hash] options
+    # @option options [String] :name name used in logs and for storage. will use Host:Port if no name is specified
+    # @option options [String] :concurrency concurrency. will use 1 as default
+    # @option options [Hash|Proc] :accepts  message_pattern for request headers this BackendServer accepts or a lambda where the request is passed
+    #   Keys get symbolized and values create Regexp objects. Empty Hash is default
+    # @option options [Hash] :mangle Hash which can modify request headers. Keys get symbolized. nil is default
+    def initialize(host, port, options = {})
+      @host = host #host URL as string
+      @port = port #port as string
+      @name = options[:name] || "#{host}:#{port}"
+      if options[:concurrency].nil?
+        @concurrency = 1
+      else
+        @concurrency = options[:concurrency].to_i
+      end
+      @workload = 0
+
+      update_message_pattern(options[:accepts])
+
+      #mangle can be nil
+      @mangle = options[:mangle]
+                   #convert keys to symbols to match request header keys
+      @mangle = @mangle.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo } unless @mangle.nil?
+    end
+
+    # compares Backend servers accepted message_pattern to request object
+    #
+    # @param request [Request] a request object
+    # @return [Boolean] true if BackendServer accepts the Request, false otherwise
+    def accept?(request)
+      res=@message_pattern.call(request)
+      #puts "#{name} #{request.header['request_url']} #{res}"
+      res
+    end
+
+    # Updates the message_pattern
+    #
+    # @param hsh [Hash] hash containing additional message_pattern information. Keys get symbolized and values create
+    #   Regexp objects. Values of duplicate keys will be overwritten
+    def update_message_pattern(obj)
+      @message_pattern =if obj.respond_to?(:call)
+        obj
+      else
+        #precompile message pattern keys to symbols and values to regexp objects
+        keys = (obj||{}).inject({}) { |memo, (k, v)| memo[k.to_sym] = Regexp.new(v); memo }
+        lambda do |request| #TODO: ugly!
+          ret=true
+          keys.each do |key, pattern|
+            #use uri for :port :path and :query keys
+            if key == :port || key == :path || key == :query
+              ret=false unless request.uri[key] && request.uri[key].match(pattern)
+            else #use headers
+              ret=false unless request.header[key] && request.header[key].match(pattern)
+            end
+            break unless ret #stop as soon as possible
+          end
+          ret
+        end #lambda
+      end
+    end
+  end
+end

data/lib/experella-proxy/configuration.rb

@@ -0,0 +1,154 @@
+module ExperellaProxy
+
+  # static getter for the config variable
+  #
+  # @return [Configuration] config
+  def self.config
+    @config
+  end
+
+  # static setter for the config variable
+  #
+  # @param config [Configuration] a config object
+  # @return [Configuration] config
+  def self.config=(config)
+    @config=config
+  end
+  # The Configuration loader
+  #
+  # The config specifies following DSL options
+  #
+  # backend
+  #  Takes an options hash defining a backend_server, see {BackendServer}
+  #
+  # set_logger
+  #  specifies the Logger used by the program. The Logger must support debug/info/warn/error/fatal functions
+  #
+  # set_proxy
+  #  Add proxy as Hash with :host => "string-ip/domain" and :proxy => Fixnum
+  #  The proxy will listen on every host:port hash added with this function.
+  #
+  # set_timeout
+  #  Time as float when an idle persistent connection gets closed (no receive/send events occured)
+  #
+  # set_error_pages
+  #  Add html error-pages to the proxy, requires 2 arguments
+  #  1st arg: the error code as Fixnum
+  #  2nd arg: path to an error page html file relative to the config file directory
+  #  Currently 404 and 503 error codes are supported
+  #
+  class Configuration
+
+    # Error raised if the Config couldn't be load successfully
+    #
+    # Currently only raised if config filepath is invalid
+    class NoConfigError < StandardError
+
+    end
+
+    attr_reader :logger, :proxy, :timeout, :backends, :error_pages
+
+    require 'logger'
+
+    # The Configuration
+    #
+    # @param [Hash] options
+    # @option options [String] :configfile the config filepath
+    def initialize(options={})
+      @backends=[]
+      @proxy=[]
+      @error_pages = {404 => "", 503 => ""}
+      default_options={:timeout => 15.0, :logger => Logger.new($stdout)}
+      options=options.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+      options=default_options.merge(options)
+      options.each do |k,v|
+        self.instance_variable_set("@#{k}",v)
+      end
+      read_config_file(@configfile) if @configfile
+      ExperellaProxy.config=self
+    end
+
+    # Return filenames fullpath relative to configfile directory
+    #
+    # @param filename [String] the filename
+    # @return [String] full filepath
+    def join_config_path(filename)
+      File.expand_path(File.join(File.dirname(@configfile), filename))
+    end
+
+    # Opens the given config file and evaluates it's contents DSL
+    #
+    # @param configfile [String] the config filepath
+    # @return [Boolean] true on success, false if file can't be found
+    def read_config_file(configfile)
+      if !File.exists?(configfile)
+        puts "error reading #{configfile}"
+        raise NoConfigError.new("unable to read config file #{configfile}")
+      end
+      content=File.read(configfile)
+      instance_eval(content)
+      true
+    end
+
+    #DSL:
+
+    # Adds a {BackendServer} specified in the config file to {#backends}
+    # It allows some syntactic sugar to pass :host_port as an abbrev of host and port keys separated by ':'.
+    # @see {BackendServer#initialize}
+    #
+    # @param backend_options [Hash] backends option hash
+
+    def backend(backend_options)
+      host_port=backend_options.delete(:host_port)
+      if host_port
+        host,port = host_port.split(":")
+        backend_options[:host] = host
+        backend_options[:port] = port
+      end
+      @backends << backend_options
+    end
+
+    # Sets the {Connection} timeout specified in the config file
+    #
+    # @param to [Float] timeout as float
+    def set_timeout(to)
+      @timeout=to
+    end
+
+    # Sets the global Logger object specified in the config file
+    #
+    # Logger can be any object that responds to Ruby Loggers debug, info, warn, error, fatal functions
+    #
+    # @param logger [Logger] the logger object
+    def set_logger(logger)
+      @logger=logger
+    end
+
+    # Adds a Proxy specified in the config file to {#proxy}
+    #
+    # Multiple proxies can be added with multiple calls. Needs a Hash containing :host => "domain/ip", :port => fixnum
+    #
+    # @param proxy [Hash] proxy Hash with :host => "domain/ip", :port => fixnum, :options => options
+    # @option options [Boolean] :tls true if proxy uses TLS encryption
+    # @option options [String] :private_key_file file path to ssl private_key_file relative to config file directory
+    # @option options [String] :cert_chain_file file path to ssl cert_chain_file relative to config file directory
+    def set_proxy(proxy)
+      if proxy[:options] && proxy[:options][:tls]
+        proxy[:options][:private_key_file] = join_config_path(proxy[:options][:private_key_file])
+        proxy[:options][:cert_chain_file] = join_config_path(proxy[:options][:cert_chain_file])
+      end
+      @proxy << proxy
+    end
+
+    # Loads the Errorpages specified in the config file
+    #
+    # currently 404 and 503 errors are supported
+    #
+    # @param key [Fixnum] HTTP Error code
+    # @param page_path [String] page_path relative to config file directory
+    def set_error_pages(key, page_path)
+      @error_pages[key] = File.read(join_config_path(page_path))
+    end
+
+  end
+end