sitehub 0.4.3 → 0.4.6

data/lib/sitehub/getter_setter_methods.rb

@@ -0,0 +1,21 @@
+class SiteHub
+  module GetterSetterMethods
+    def getter_setters(*method_names)
+      method_names.each do |method_name|
+        getter_setter method_name.to_sym
+      end
+    end
+
+    def getter_setter(method_name, default = nil)
+      define_method method_name do |arg = nil|
+        attribute_name = "@#{method_name}"
+        if arg
+          instance_variable_set(attribute_name, arg)
+          self
+        else
+          instance_variable_get(attribute_name) || default
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/http_headers.rb

@@ -1,73 +1,70 @@
-require 'sitehub/constants'
 class SiteHub
-  module HttpHeaders
-    include Constants::HttpHeaderKeys
-    include Constants
-
-    HTTP_OR_SSL_PORT = /:80(?!\d+)|:443/
+  class HttpHeaders < Hash
     HTTP_PREFIX = /^HTTP_/
     RACK_HTTP_HEADER_ID = /#{HTTP_PREFIX.source}[A-Z_]+$/
-    COMMAND_FOLLOWED_BY_SPACES = /,\s+/
-
-    SHOULD_NOT_TRANSFER = [PROXY_CONNECTION].freeze
 
-    HOP_BY_HOP = [CONNECTION_HEADER,
-                  KEEP_ALIVE,
-                  PROXY_AUTHENTICATE,
-                  PROXY_AUTHORIZATION,
-                  TE,
-                  TRAILERS,
-                  TRANSFER_ENCODING,
-                  CONTENT_ENCODING].freeze
+    class << self
+      def from_rack_env(env)
+        new(format_keys(remove_rack_specific_headers(env.dup)))
+      end
 
-    def split_field(f)
-      f ? f.split(COMMAND_FOLLOWED_BY_SPACES).collect(&:downcase) : []
-    end
+      private
 
-    def sanitise_headers(src)
-      connections = split_field(src[CONNECTION_HEADER])
+      def remove_rack_specific_headers(env)
+        env.reject do |key, value|
+          !Constants::RackHttpHeaderKeys::HTTP_HEADER_FILTER_EXCEPTIONS.include?(key.to_s.upcase) &&
+            (!RACK_HTTP_HEADER_ID.match(key) || !value)
+        end
+      end
 
-      {}.tap do |sanitised_headers|
-        src.each do |key, value|
-          key = key.downcase.gsub(UNDERSCORE, HYPHEN)
-          next if HOP_BY_HOP.member?(key) || connections.member?(key) || SHOULD_NOT_TRANSFER.member?(key)
-          sanitised_headers[key] = value
+      def format_keys(env)
+        env.each_with_object({}) do |key_value, hash|
+          key, value = *key_value
+          hash[header_name(key)] = value
         end
+      end
 
-        sanitised_headers[LOCATION_HEADER].gsub!(HTTP_OR_SSL_PORT, EMPTY_STRING) if sanitised_headers[LOCATION_HEADER]
+      def header_name(name)
+        name.sub(HTTP_PREFIX, EMPTY_STRING).downcase.gsub(UNDERSCORE, HYPHEN)
       end
     end
 
-    def extract_http_headers(env)
-      headers = remove_excluded_headers(env)
+    include Constants, Constants::HttpHeaderKeys
+
+    EXCLUDED_HEADERS = [CONNECTION_HEADER,
+                        KEEP_ALIVE,
+                        PROXY_CONNECTION,
+                        PROXY_AUTHENTICATE,
+                        PROXY_AUTHORIZATION,
+                        TE,
+                        TRAILERS,
+                        TRANSFER_ENCODING,
+                        CONTENT_ENCODING,
+                        UPGRADE].freeze
 
-      headers = headers.to_a.each_with_object(Rack::Utils::HeaderHash.new) do |k_v, hash|
-        k, v = k_v
-        hash[reconstruct_header_name(k)] = v
-        hash
+    def initialize(env)
+      env.each do |key, value|
+        self[key.to_s.downcase] = value
       end
 
-      remote_address = env[RackHttpHeaderKeys::REMOTE_ADDRESS_ENV_KEY]
-      headers.merge!(X_FORWARDED_FOR_HEADER => x_forwarded_for_value(headers, remote_address))
+      filter_prohibited_headers
     end
 
-    def x_forwarded_for_value(headers, remote_address)
-      (forwarded_address_list(headers) << remote_address).join(COMMA_WITH_SPACE)
-    end
+    private
 
-    def forwarded_address_list(headers)
-      headers[X_FORWARDED_FOR_HEADER].to_s.split(COMMAND_FOLLOWED_BY_SPACES)
+    def filter_prohibited_headers
+      remove_headers(hop_by_hop_headers.concat(EXCLUDED_HEADERS))
     end
 
-    def remove_excluded_headers(env)
-      env.reject do |k, v|
-        !RackHttpHeaderKeys::HTTP_HEADER_FILTER_EXCEPTIONS.include?(k.to_s.upcase) &&
-          (!RACK_HTTP_HEADER_ID.match(k) || v.nil?)
-      end
+    def hop_by_hop_headers
+      field = self[CONNECTION_HEADER] || EMPTY_STRING
+      field.split(COMMA).collect(&:downcase)
     end
 
-    def reconstruct_header_name(name)
-      name.sub(HTTP_PREFIX, EMPTY_STRING).gsub(UNDERSCORE, HYPHEN)
+    def remove_headers(excluded)
+      reject! do |key, _value|
+        excluded.member?(key)
+      end
     end
   end
 end

data/lib/sitehub/location_rewriter.rb

@@ -0,0 +1,29 @@
+require 'sitehub/equality'
+class SiteHub
+  class LocationRewriter
+    include Equality
+
+    attr_reader :matcher, :path_template
+
+    def initialize(matcher, path_template)
+      @matcher = matcher
+      @path_template = path_template
+    end
+
+    def match?(url)
+      matcher.match(url).is_a?(MatchData)
+    end
+
+    def apply(downstream_url, source_url)
+      url_components = matcher.match(downstream_url).captures
+
+      path = path_template.dup.tap do |template|
+        url_components.each.with_index(1) do |component, index|
+          template.gsub!(RequestMapping::CAPTURE_GROUP_REFERENCE % index, component)
+        end
+      end
+
+      "#{source_url[RequestMapping::BASE_URL_MATCHER]}#{path}"
+    end
+  end
+end

data/lib/sitehub/location_rewriters.rb

@@ -0,0 +1,23 @@
+require 'sitehub/location_rewriter'
+require 'sitehub/nil_location_rewriter'
+class SiteHub
+  class LocationRewriters < Array
+    DEFAULT = NilLocationRewriter.new
+
+    def initialize(map = {})
+      enriched = map.collect do |pattern, path_template|
+        matcher = pattern.is_a?(Regexp) ? pattern : /#{pattern}/
+        LocationRewriter.new(matcher, path_template)
+      end
+
+      super enriched
+    end
+
+    def find(url)
+      result = super() do |directive|
+        directive.match?(url)
+      end
+      result || DEFAULT
+    end
+  end
+end

data/lib/sitehub/memoize.rb

@@ -0,0 +1,25 @@
+class SiteHub
+  module Memoize
+    def memoize(*methods)
+      methods.each do |method|
+        method_alias = "_#{method}"
+        alias_method method_alias, method
+
+        define_memoized_method(method, method_alias)
+      end
+    end
+
+    private
+
+    def define_memoized_method(method, method_alias)
+      define_method(method) do |*args, &block|
+        attribute = "@#{method}".gsub('?', 'question_mark')
+        return instance_variable_get(attribute) if instance_variable_defined? attribute
+
+        send(method_alias, *args, &block).tap do |result|
+          instance_variable_set(attribute, result)
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware.rb

@@ -1,20 +1,30 @@
+$LOAD_PATH.unshift(__dir__)
+require 'middleware/logging'
+require 'middleware/transaction_id'
+require 'middleware/error_handling'
+require 'middleware/forward_proxies'
+require 'middleware/reverse_proxy'
+require 'rack/ssl-enforcer'
+require 'rack/fiber_pool'
+
 class SiteHub
   module Middleware
     def middlewares
       @middleware ||= []
     end
 
+    def middleware?
+      !middlewares.empty?
+    end
+
     def use(middleware_clazz, *args, &block)
-      middlewares << [middleware_clazz, args, block || proc {}]
+      middlewares << [middleware_clazz, args, block]
     end
 
     def apply_middleware(forward_proxy)
       middlewares.reverse.inject(forward_proxy) do |app, middleware_def|
-        middleware = middleware_def[0]
-        args = middleware_def[1] || []
-        block = middleware_def[2] || proc {}
-
-        middleware.new(app, *args, &block)
+        middleware, args, block = *middleware_def
+        middleware.new(app, *args, &(block || proc {}))
       end
     end
   end

data/lib/sitehub/middleware/error_handling.rb

@@ -0,0 +1,20 @@
+class SiteHub
+  module Middleware
+    class ErrorHandling
+      ERROR_RESPONSE = Rack::Response.new(['error'], 500, {})
+
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call env
+      rescue StandardError => exception
+        env[ERRORS] << exception.message
+        ERROR_RESPONSE.dup
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/forward_proxies.rb

@@ -0,0 +1,54 @@
+require 'sitehub/constants'
+require 'sitehub/nil_proxy'
+require 'rack/request'
+require 'rack/response'
+require 'rack/utils'
+require 'em-http'
+
+class SiteHub
+  module Middleware
+    class ForwardProxies
+      NIL_PROXY = NilProxy.new
+
+      def call(env)
+        source_request = Rack::Request.new(env)
+
+        forward_proxy = mapped_proxy(path: source_request.path, request: source_request)
+
+        forward_proxy.call(env)
+      end
+
+      def init
+        forward_proxies.values.each(&:build)
+        self
+      end
+
+      def <<(route)
+        forward_proxies[route.mapped_path] = route
+      end
+
+      def mapped_proxy(path:, request:)
+        forward_proxies[mapping(path)].resolve(id: request.cookies[RECORDED_ROUTES_COOKIE], env: request.env)
+      end
+
+      def mapping(path)
+        forward_proxies.keys.find do |key|
+          case key
+          when Regexp
+            key.match(path)
+          else
+            path == key
+          end
+        end
+      end
+
+      def forward_proxies
+        @forward_proxies ||= begin
+          {}.tap do |hash|
+            hash.default = NIL_PROXY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/logging/access_logger.rb

@@ -0,0 +1,36 @@
+require 'logger'
+require 'rack/commonlogger'
+require_relative 'log_wrapper'
+require 'sitehub/constants'
+require 'sitehub/middleware/logging/request_log'
+require 'sitehub/response'
+
+class SiteHub
+  module Middleware
+    module Logging
+      class AccessLogger
+        attr_reader :logger, :start_time
+
+        include Constants
+
+        FORMAT = %(%s - %s [%s] transaction_id:%s: "%s %s%s => %s %s" %d %s %0.4f\n).freeze
+        ZERO_STRING = '0'.freeze
+        STATUS_RANGE = 0..3
+
+        def initialize(app, logger = ::Logger.new(STDOUT))
+          @app = app
+          @logger = LogWrapper.new(logger)
+        end
+
+        def call(env)
+          request = env[REQUEST] = Request.new(env: env)
+          @app.call(env).tap do |response|
+            status, headers, body = response.to_a
+            response = Response.new(body, status, headers)
+            logger.write(RequestLog.new(request, response).to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/logging/error_logger.rb

@@ -0,0 +1,38 @@
+require 'logger'
+require 'sitehub/constants'
+require_relative 'log_wrapper'
+require_relative 'log_stash'
+class SiteHub
+  module Middleware
+    module Logging
+      class ErrorLogger
+        include Constants
+        LOG_TEMPLATE = '[%s] ERROR: %s - %s'.freeze
+
+        attr_reader :logger
+
+        def initialize(app, logger = Logger.new(STDERR))
+          @app = app
+          @logger = LogWrapper.new(logger)
+        end
+
+        def call(env)
+          errors = env[ERRORS] ||= LogStash.new
+          @app.call(env).tap do
+            unless errors.empty?
+              messages = errors.collect do |log_entry|
+                log_message(error: log_entry.message, transaction_id: env[RackHttpHeaderKeys::TRANSACTION_ID])
+              end
+
+              logger.write(messages.join(NEW_LINE))
+            end
+          end
+        end
+
+        def log_message(error:, transaction_id:)
+          format(LOG_TEMPLATE, Time.now.strftime(TIME_STAMP_FORMAT), transaction_id, error)
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/logging/log_entry.rb

@@ -0,0 +1,16 @@
+require 'sitehub/equality'
+class SiteHub
+  module Middleware
+    module Logging
+      class LogEntry
+        include Equality
+        attr_reader :message, :time
+
+        def initialize(message, time = Time.now)
+          @message = message
+          @time = time
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/logging/log_stash.rb

@@ -0,0 +1,12 @@
+require_relative 'log_entry'
+class SiteHub
+  module Middleware
+    module Logging
+      class LogStash < Array
+        def <<(message)
+          super(LogEntry.new(message))
+        end
+      end
+    end
+  end
+end