sitehub 0.4.1

data/lib/sitehub/forward_proxy_builder.rb

@@ -0,0 +1,99 @@
+require 'uuid'
+require_relative 'collection/split_route_collection'
+require_relative 'rules'
+require_relative 'resolver'
+require_relative 'collection/route_collection'
+require_relative 'middleware'
+
+class SiteHub
+
+  class ForwardProxyBuilder
+    include Middleware
+    include Rules, Resolver
+
+    class InvalidDefinitionException < Exception;
+    end
+
+    attr_reader :mapped_path, :default_proxy, :routes, :middlewares, :splits, :sitehub_cookie_name
+
+    def initialize(url: nil, mapped_path:, rule:nil, sitehub_cookie_name: nil, &block)
+      @mapped_path = mapped_path
+      @middlewares = []
+      @splits = Collection::SplitRouteCollection.new
+      @routes = Collection::RouteCollection.new
+      @sitehub_cookie_name = sitehub_cookie_name
+      rule(rule) if rule
+      default(url: url) if url
+      if block
+        instance_eval(&block)
+        raise InvalidDefinitionException unless valid?
+      end
+    end
+
+    def valid?
+      return true if @default_proxy
+      endpoints.valid?
+    end
+
+    def endpoints collection=nil
+      return @endpoints || Collection::RouteCollection.new unless collection
+
+      raise InvalidDefinitionException, 'you cant register routes and splits at the same level' if @endpoints && @endpoints != collection
+      @endpoints = collection
+    end
+
+    def split(percentage:, url:, label:, &block)
+      endpoints(splits)
+      endpoints.add label.to_sym, forward_proxy(label: label, url: url), percentage
+    end
+
+    def route url:nil, label:nil, rule: nil, &block
+      endpoints(routes)
+
+      if block
+        raise InvalidDefinitionException, 'rule must be specified when supplying a block'unless rule
+        builder = self.class.new(mapped_path: mapped_path, rule: rule, &block).build
+        endpoints.add UUID.generate(:compact), builder
+      else
+        endpoints.add label.to_sym, forward_proxy(url: url, label: label, rule: rule)
+      end
+    end
+
+    def default(url:)
+      @default_proxy = forward_proxy(label: :default, url: url)
+    end
+
+    def sitehub_cookie_path path=nil
+      return @sitehub_cookie_path unless path
+      @sitehub_cookie_path = path
+    end
+
+
+    def build
+      endpoints.transform do |proxy|
+        apply_middleware(proxy).tap do |wrapped_proxy|
+          wrapped_proxy.extend(Rules)
+          wrapped_proxy.extend(Resolver) unless wrapped_proxy.is_a?(Resolver)
+          wrapped_proxy.rule(proxy.rule)
+        end
+      end
+      @default_proxy = apply_middleware(default_proxy) if default_proxy
+      self
+    end
+
+    def resolve(id: nil, env:)
+      id = id.to_s.to_sym
+      endpoints[id] || endpoints.resolve(env: env) || default_proxy
+    end
+
+    def == other
+      other.is_a?(ForwardProxyBuilder) && self.default_proxy == other.default_proxy && self.endpoints == other.endpoints
+    end
+
+
+    def forward_proxy(label:, url:, rule: nil)
+      ForwardProxy.new(url: url, id: label.to_sym, mapped_path: mapped_path, sitehub_cookie_path: sitehub_cookie_path, sitehub_cookie_name: sitehub_cookie_name, rule: rule)
+    end
+  end
+
+end

data/lib/sitehub/http_headers.rb

@@ -0,0 +1,60 @@
+require 'sitehub/constants'
+class SiteHub
+  module HttpHeaders
+    include Constants::HttpHeaderKeys
+    include Constants
+
+    HTTP_OR_SSL_PORT = /:80(?!\d+)|:443/
+    HTTP_PREFIX = /^HTTP_/
+    RACK_HTTP_HEADER_ID = /#{HTTP_PREFIX.source}[A-Z_]+$/
+    COMMAND_FOLLOWED_BY_SPACES = /,\s+/
+
+    def split_field(f)
+      f ? f.split(COMMAND_FOLLOWED_BY_SPACES).collect { |i| i.downcase } : []
+    end
+
+    def sanitise_headers(src)
+
+      sanitised_headers = {}
+
+      connections = split_field(src[CONNECTION_HEADER])
+      src.each do |key, value|
+        key = key.downcase.gsub(UNDERSCORE, HYPHEN)
+        if HopByHop.member?(key) ||
+            connections.member?(key) ||
+            ShouldNotTransfer.member?(key)
+          next
+        end
+        sanitised_headers[key] = value
+      end
+
+      sanitised_headers[LOCATION_HEADER].gsub!(HTTP_OR_SSL_PORT, EMPTY_STRING) if sanitised_headers[LOCATION_HEADER]
+
+      sanitised_headers
+    end
+
+
+
+    def extract_http_headers(env)
+      headers = env.reject do |k, v|
+        !RackHttpHeaderKeys::HTTP_HEADER_FILTER_EXCEPTIONS.include?(k.to_s.upcase) && (!(RACK_HTTP_HEADER_ID === k) || v.nil?)
+      end.map do |k, v|
+        [reconstruct_header_name(k), v]
+      end.inject(Rack::Utils::HeaderHash.new) do |hash, k_v|
+        k, v = k_v
+        hash[k] = v
+        hash
+      end
+
+      x_forwarded_for = (headers[X_FORWARDED_FOR_HEADER].to_s.split(COMMAND_FOLLOWED_BY_SPACES) << env[RackHttpHeaderKeys::REMOTE_ADDRESS_ENV_KEY]).join(COMMA_WITH_SPACE)
+
+      headers.merge!(X_FORWARDED_FOR_HEADER => x_forwarded_for)
+    end
+
+
+
+    def reconstruct_header_name(name)
+      name.sub(HTTP_PREFIX, EMPTY_STRING).gsub(UNDERSCORE, HYPHEN)
+    end
+  end
+end

data/lib/sitehub/logging.rb

@@ -0,0 +1,5 @@
+require_relative 'logging/access_logger'
+require_relative 'logging/error_logger'
+require_relative 'logging/log_entry'
+require_relative 'logging/log_stash'
+require_relative 'logging/log_wrapper'

data/lib/sitehub/logging/access_logger.rb

@@ -0,0 +1,74 @@
+require 'logger'
+require 'rack/commonlogger'
+require_relative 'log_wrapper'
+require 'sitehub/constants'
+
+#Very heavily based on Rack::CommonLogger
+class SiteHub
+  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
+      PATH_INFO = RackHttpHeaderKeys::PATH_INFO
+      REQUEST_METHOD = RackHttpHeaderKeys::REQUEST_METHOD
+      SCRIPT_NAME = RackHttpHeaderKeys::SCRIPT_NAME
+      QUERY_STRING = RackHttpHeaderKeys::QUERY_STRING
+      X_FORWARDED_FOR = RackHttpHeaderKeys::X_FORWARDED_FOR
+      REMOTE_ADDR = RackHttpHeaderKeys::REMOTE_ADDR
+      HTTP_VERSION = RackHttpHeaderKeys::HTTP_VERSION
+      REMOTE_USER = RackHttpHeaderKeys::REMOTE_USER
+      TRANSACTION_ID = RackHttpHeaderKeys::TRANSACTION_ID
+      CONTENT_LENGTH = HttpHeaderKeys::CONTENT_LENGTH
+      ZERO_STRING = '0'
+      STATUS_RANGE = 0..3
+
+      def initialize app, logger = ::Logger.new(STDOUT)
+        @app = app
+        @logger = LogWrapper.new(logger)
+      end
+
+      def call env
+        start_time = Time.now
+
+        @app.call(env).tap do |response|
+          status, headers, body = response.to_a
+          log env, status, headers, env[REQUEST_MAPPING], start_time
+        end
+      end
+
+      def log(env, status, header, mapped_request, began_at)
+        now = Time.now
+        length = extract_content_length(header)
+
+
+        msg = log_template % [
+            env[X_FORWARDED_FOR] || env[REMOTE_ADDR] || HYPHEN,
+            env[REMOTE_USER] || "-",
+            now.strftime(TIME_STAMP_FORMAT),
+            env[TRANSACTION_ID],
+            env[REQUEST_METHOD],
+            env[PATH_INFO],
+            env[QUERY_STRING].empty? ? EMPTY_STRING : QUESTION_MARK+env[QUERY_STRING],
+            mapped_request.mapped_url.to_s,
+            env[HTTP_VERSION],
+            status.to_s[STATUS_RANGE],
+            length,
+            now - began_at]
+
+        logger.write(msg)
+      end
+
+      def log_template
+        FORMAT
+      end
+
+      def extract_content_length(headers)
+        value = headers[CONTENT_LENGTH] or return HYPHEN
+        value.to_s == ZERO_STRING ? HYPHEN : value
+      end
+    end
+  end
+end

data/lib/sitehub/logging/error_logger.rb

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

data/lib/sitehub/logging/log_entry.rb

@@ -0,0 +1,14 @@
+class SiteHub
+  module Logging
+    class LogEntry
+      attr_reader :message, :time
+      def initialize message, time=Time.now
+        @message, @time = message, time
+      end
+
+      def == other
+        other.is_a?(LogEntry) && self.message == other.message && self.time == other.time
+      end
+    end
+  end
+end

data/lib/sitehub/logging/log_stash.rb

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

data/lib/sitehub/logging/log_wrapper.rb

@@ -0,0 +1,23 @@
+class SiteHub
+  module Logging
+    class LogWrapper
+      attr_reader :logger
+
+      def initialize logger
+        @logger = logger
+      end
+
+      def write msg
+        if logger.respond_to?(:<<)
+          logger << msg
+        elsif logger.respond_to?(:write)
+          logger.write(msg)
+        end
+      end
+
+      def == other
+        other.is_a?(LogWrapper) && self.logger == other.logger
+      end
+    end
+  end
+end

data/lib/sitehub/middleware.rb

@@ -0,0 +1,21 @@
+class SiteHub
+  module Middleware
+    def middlewares
+      @middleware ||= []
+    end
+
+    def use(middleware_clazz, *args, &block)
+      middlewares << [middleware_clazz, args, block|| proc{}]
+    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)
+      end
+    end
+  end
+end

data/lib/sitehub/path_directive.rb

@@ -0,0 +1,32 @@
+class SiteHub
+  class PathDirective
+    attr_reader :matcher, :path_template
+
+    def initialize matcher, path_template
+      @matcher, @path_template = matcher, path_template
+    end
+
+    def match? url
+      !!matcher.match(url)
+    end
+
+    def path_template
+      @path_template.dup
+    end
+
+    def apply url
+      url_components = matcher.match(url).captures
+
+      path_template.tap do |p|
+        url_components.each_with_index do |m, index|
+          p.gsub!(RequestMapping::CAPTURE_GROUP_REFERENCE % (index+1), m)
+        end
+      end
+
+    end
+
+    def == other
+      other.is_a?(PathDirective) && self.matcher == other.matcher && self.path_template == other.path_template
+    end
+  end
+end

data/lib/sitehub/path_directives.rb

@@ -0,0 +1,21 @@
+require 'sitehub/path_directive'
+class SiteHub
+  class PathDirectives < Array
+    def initialize map={}
+      enriched = map.map do |array|
+        matcher,path_template = array.first, array.last
+
+        matcher = matcher.is_a?(Regexp) ? matcher : %r{#{matcher}}
+        PathDirective.new(matcher, path_template)
+      end
+
+      super enriched
+    end
+
+    def find(url)
+      super() do |directive|
+        directive.match?(url)
+      end
+    end
+  end
+end

data/lib/sitehub/request_mapping.rb

@@ -0,0 +1,43 @@
+require 'sitehub/constants'
+class SiteHub
+  class RequestMapping
+    attr_reader :source_url, :mapped_url, :mapped_path
+
+    BASE_URL_MATCHER = %r{^\w+://[\w+\.-]+(:\d+)?}
+    CAPTURE_GROUP_REFERENCE='$%s'
+    USER_SUPPLIED_CAPTURE = 1..-1
+
+    def initialize(source_url:, downstream_url: EMPTY_STRING, mapped_url: EMPTY_STRING, mapped_path:)
+      @source_url, @mapped_url = source_url, mapped_url.dup
+      @mapped_path = mapped_path.is_a?(Regexp) ? mapped_path : Regexp.new(mapped_path)
+      @downstream_url = downstream_url
+    end
+
+    def cookie_path
+      if mapped_path.is_a?(Regexp)
+        mapped_path.source[/^(.*)?\(/,1].gsub(/\/$/, '')
+      end
+    end
+
+
+    def computed_uri
+      @computed_uri ||= begin
+        url_components = url_scanner_regex.match(source_url).captures[USER_SUPPLIED_CAPTURE]
+        mapped_url.tap do |url|
+          url_components.each_with_index do |match, index|
+            url.gsub!(CAPTURE_GROUP_REFERENCE % (index+1), match)
+          end
+        end
+      end
+    end
+
+    def == other
+      other.is_a?(RequestMapping) && source_url == other.source_url && mapped_url == other.mapped_url && mapped_path == other.mapped_path
+    end
+
+    private
+    def url_scanner_regex
+      %r{#{BASE_URL_MATCHER.source}#{mapped_path.source}}
+    end
+  end
+end