sitehub 0.4.3 → 0.4.6

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

@@ -0,0 +1,24 @@
+require 'sitehub/equality'
+class SiteHub
+  module Middleware
+    module Logging
+      class LogWrapper
+        include Equality
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+class SiteHub
+  module Middleware
+    module Logging
+      class RequestLog
+        FORMAT = %(%s - %s [%s] transaction_id:%s: "%s %s%s => %s %s" %d %s %0.4f\n).freeze
+        ZERO_STRING = '0'.freeze
+
+        attr_reader :request, :response
+        def initialize(request, response)
+          @request = request
+          @response = response
+        end
+
+        def to_s
+          format(FORMAT, *data)
+        end
+
+        def extract_content_length
+          (value = response.headers[Constants::HttpHeaderKeys::CONTENT_LENGTH]) || (return HYPHEN)
+          value.to_s == ZERO_STRING ? HYPHEN : value
+        end
+
+        private
+
+        def data
+          [source_address, remote_user,
+           response_time,
+           request.transaction_id,
+           request_method,
+           request.path,
+           query_string,
+           mapped_url,
+           request.http_version,
+           status,
+           extract_content_length,
+           time_taken]
+        end
+
+        def time_taken
+          response.time - request.time
+        end
+
+        def response_time
+          response.time.strftime(TIME_STAMP_FORMAT)
+        end
+
+        def request_method
+          request.request_method.upcase
+        end
+
+        def status
+          response.status
+        end
+
+        def remote_user
+          request.remote_user || HYPHEN
+        end
+
+        def source_address
+          request.source_address || HYPHEN
+        end
+
+        def mapped_url
+          request.mapped? ? request.mapping.mapped_url.to_s : EMPTY_STRING
+        end
+
+        def query_string
+          query_string = request.query_string
+          query_string.empty? ? EMPTY_STRING : QUESTION_MARK + query_string
+        end
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/reverse_proxy.rb

@@ -0,0 +1,37 @@
+require 'sitehub/cookie_rewriting'
+require 'sitehub/location_rewriters'
+require 'sitehub/request_mapping'
+require 'sitehub/constants'
+
+class SiteHub
+  module Middleware
+    class ReverseProxy
+      include CookieRewriting, Constants::HttpHeaderKeys
+
+      attr_reader :path_directives
+
+      def initialize(app, directives)
+        @app = app
+        @path_directives = LocationRewriters.new(directives)
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env).to_a
+        mapping = env[REQUEST].mapping
+
+        headers[LOCATION_HEADER] = location(headers, mapping.source_url) if headers[LOCATION_HEADER]
+
+        rewrite_cookies(headers, substitute_domain: mapping.host) if headers[SET_COOKIE]
+
+        [status, HttpHeaders.new(headers), body]
+      end
+
+      private
+
+      def location(headers, source_url)
+        location_header = headers[LOCATION_HEADER]
+        path_directives.find(location_header).apply(location_header, source_url)
+      end
+    end
+  end
+end

data/lib/sitehub/middleware/transaction_id.rb

@@ -0,0 +1,18 @@
+require 'uuid'
+require 'sitehub/constants'
+class SiteHub
+  module Middleware
+    class TransactionId
+      include Constants
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[RackHttpHeaderKeys::TRANSACTION_ID] ||= UUID.generate(:compact)
+        @app.call env
+      end
+    end
+  end
+end

data/lib/sitehub/nil_location_rewriter.rb

@@ -0,0 +1,7 @@
+class SiteHub
+  class NilLocationRewriter
+    def apply(url, _source_url)
+      url
+    end
+  end
+end

data/lib/sitehub/nil_proxy.rb

@@ -0,0 +1,11 @@
+require 'sitehub/resolver'
+class SiteHub
+  class NilProxy
+    include Resolver
+    NOT_FOUND = Rack::Response.new(['page not found'], 404, {})
+
+    def call(_env)
+      NOT_FOUND
+    end
+  end
+end

data/lib/sitehub/request.rb

@@ -0,0 +1,101 @@
+require 'rack/request'
+require 'sitehub/string_utils'
+require 'sitehub/http_headers'
+require 'sitehub/memoize'
+require 'forwardable'
+class SiteHub
+  class Request
+    include Constants, Constants::HttpHeaderKeys
+
+    extend Forwardable, Memoize
+
+    def_delegator :@rack_request, :params
+    def_delegator :@rack_request, :url
+    def_delegator :@rack_request, :path
+    def_delegator :@rack_request, :query_string
+
+    attr_reader :env, :rack_request, :mapped_path, :mapped_url, :time
+
+    def initialize(env:)
+      @rack_request = Rack::Request.new(env)
+      @env = HttpHeaders.from_rack_env(env)
+      @time = Time.now
+    end
+
+    def map(path, url)
+      @mapped_path = path
+      @mapped_url = url
+    end
+
+    def request_method
+      rack_request.request_method.downcase.to_sym
+    end
+
+    def body
+      rack_request.body.read
+    end
+
+    def headers
+      @env.tap do |headers|
+        headers[X_FORWARDED_FOR_HEADER] = x_forwarded_for
+
+        headers[X_FORWARDED_HOST_HEADER] = x_forwarded_host
+
+        headers[HOST_HEADER] = if mapped?
+                                 mapped_uri = URI(mapped_url)
+                                 "#{mapped_uri.host}:#{mapped_uri.port}"
+                               end
+      end
+    end
+
+    def mapping
+      RequestMapping.new(source_url: rack_request.url, mapped_url: mapped_url.to_s, mapped_path: mapped_path)
+    end
+
+    def mapped?
+      mapped_path.is_a?(String)
+    end
+
+    def remote_user
+      rack_request.env[RackHttpHeaderKeys::REMOTE_USER]
+    end
+
+    def transaction_id
+      env[HttpHeaderKeys::TRANSACTION_ID]
+    end
+
+    def http_version
+      rack_env[RackHttpHeaderKeys::HTTP_VERSION]
+    end
+
+    def source_address
+      rack_env[RackHttpHeaderKeys::X_FORWARDED_FOR] || rack_env[RackHttpHeaderKeys::REMOTE_ADDR]
+    end
+
+    def uri
+      mapping.computed_uri
+    end
+
+    memoize :url, :path, :uri, :mapped?, :mapping, :headers, :body, :request_method
+
+    private
+
+    def rack_env
+      rack_request.env
+    end
+
+    def remote_address
+      rack_request.env[RackHttpHeaderKeys::REMOTE_ADDRESS_ENV_KEY]
+    end
+
+    def x_forwarded_host
+      StringUtils.split(env[HttpHeaderKeys::X_FORWARDED_HOST_HEADER])
+                 .push(env[HttpHeaderKeys::HOST_HEADER])
+                 .join(COMMA)
+    end
+
+    def x_forwarded_for
+      StringUtils.split(env[HttpHeaderKeys::X_FORWARDED_FOR_HEADER]).push(remote_address).join(COMMA)
+    end
+  end
+end

data/lib/sitehub/request_mapping.rb

@@ -1,40 +1,38 @@
 require 'sitehub/constants'
+require 'sitehub/memoize'
 class SiteHub
   class RequestMapping
+    extend Memoize
+    include Equality
+
     attr_reader :source_url, :mapped_url, :mapped_path
 
     BASE_URL_MATCHER = %r{^\w+://[\w+\.-]+(:\d+)?}
     CAPTURE_GROUP_REFERENCE = '$%s'.freeze
     USER_SUPPLIED_CAPTURE = 1..-1
 
-    def initialize(source_url:, downstream_url: EMPTY_STRING, mapped_url: EMPTY_STRING, mapped_path:)
+    def initialize(source_url:, mapped_url: EMPTY_STRING, mapped_path:)
       @source_url = source_url
-      @mapped_url = mapped_url.dup
+      @mapped_url = mapped_url.to_s.dup
+      mapped_path = mapped_path.to_s.dup
       @mapped_path = mapped_path.is_a?(Regexp) ? mapped_path : Regexp.new(mapped_path)
-      @downstream_url = downstream_url
-    end
-
-    def cookie_path
-      mapped_path.source[/^(.*)?\(/, 1].gsub(%r{/$}, '') if mapped_path.is_a?(Regexp)
     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
+      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
+      URI(mapped_url)
     end
+    memoize :computed_uri
 
-    def ==(other)
-      other.is_a?(RequestMapping) &&
-        source_url == other.source_url &&
-        mapped_url == other.mapped_url &&
-        mapped_path == other.mapped_path
+    def host
+      URI(source_url).host
     end
+    memoize :host
 
     private
 

data/lib/sitehub/resolver.rb

@@ -1,4 +1,4 @@
-# TODO: - this helper module is for the benefit of middleware that may not otherwse respond to resolve.
+# this helper module is for the benefit of middleware that may not otherwse respond to resolve.
 # THis is to ensure that middleware wrapping the core forward proxy apps had the resolve method also.
 #
 class SiteHub

data/lib/sitehub/response.rb

@@ -0,0 +1,10 @@
+class SiteHub
+  class Response < Rack::Response
+    attr_reader :status, :headers, :body, :time
+    def initialize(body, status, headers)
+      super
+      @time = Time.now
+    end
+    alias headers header
+  end
+end

data/lib/sitehub/string_utils.rb

@@ -0,0 +1,13 @@
+class SiteHub
+  module StringUtils
+    class << self
+      def split(header_value)
+        header_value.to_s.split(COMMA)
+      end
+
+      def sanitise(string)
+        string.to_s.chomp.strip
+      end
+    end
+  end
+end

data/lib/sitehub/version.rb

@@ -1,3 +1,3 @@
 class SiteHub
-  VERSION = '0.4.3'.freeze
+  VERSION = '0.4.6'.freeze
 end

data/sitehub.gemspec

@@ -29,13 +29,16 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 3.2.0'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
   spec.add_development_dependency 'webmock'
   spec.add_development_dependency 'rack-test'
   spec.add_development_dependency 'geminabox'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'memory_profiler'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'timecop'
 
   spec.add_development_dependency 'ruby-prof'
 end

data/spec/equality_spec.rb

@@ -0,0 +1,32 @@
+class SiteHub
+  describe Equality do
+    subject(:test_class) do
+      Class.new do
+        include Equality
+
+        def initialize(first_attribute, second_attribute)
+          @first_attribute = first_attribute
+          @second_attribute = second_attribute
+        end
+      end
+    end
+    subject do
+      test_class.new(:foo, :bar)
+    end
+
+    describe '#==' do
+      context 'match' do
+        it 'returns true' do
+          match = test_class.new(:foo, :bar)
+          expect(subject).to eq(match)
+        end
+      end
+      context 'mismatch' do
+        it 'returns false' do
+          match = test_class.new(:wrong, :bar)
+          expect(subject).to_not eq(match)
+        end
+      end
+    end
+  end
+end

data/spec/sitehub/builder_spec.rb

@@ -24,7 +24,8 @@ class SiteHub
         end
 
         it 'the defined route is used 100% of the time' do
-          expected_proxy = ForwardProxyBuilder.new(mapped_path: '/path').tap do |route|
+          expected_proxy = ForwardProxyBuilder.new(mapped_path: '/app1',
+                                                   sitehub_cookie_name: RECORDED_ROUTES_COOKIE).tap do |route|
             route.default(url: :endpoint)
           end
           expect(subject.forward_proxies.forward_proxies['/app1']).to eq(expected_proxy)
@@ -41,7 +42,8 @@ class SiteHub
         end
 
         it 'passes the block to the route constructor' do
-          expected_route = ForwardProxyBuilder.new(mapped_path: '/path').tap do |route|
+          expected_route = ForwardProxyBuilder.new(mapped_path: '/app',
+                                                   sitehub_cookie_name: RECORDED_ROUTES_COOKIE).tap do |route|
             route.split url: :endpoint, percentage: 100, label: :label
           end
 
@@ -54,16 +56,16 @@ class SiteHub
       it ' sets the logger' do
         subject.access_logger :access_logger
         sitehub = subject.build
-        logger_middleware = find_middleware(sitehub, Logging::AccessLogger)
-        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:access_logger))
+        logger_middleware = find_middleware(sitehub, Middleware::Logging::AccessLogger)
+        expect(logger_middleware.logger).to eq(Middleware::Logging::LogWrapper.new(:access_logger))
       end
 
       it 'defaults to STDOUT' do
         allow(::Logger).to receive(:new).and_return(:a_logger)
         expect(::Logger).to receive(:new).with(STDOUT).and_return(:stdout_logger)
         sitehub = subject.build
-        logger_middleware = find_middleware(sitehub, Logging::AccessLogger)
-        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:stdout_logger))
+        logger_middleware = find_middleware(sitehub, Middleware::Logging::AccessLogger)
+        expect(logger_middleware.logger).to eq(Middleware::Logging::LogWrapper.new(:stdout_logger))
       end
     end
 
@@ -90,16 +92,16 @@ class SiteHub
       it 'sets the logger' do
         subject.error_logger :error_logger
         sitehub = subject.build
-        logger_middleware = find_middleware(sitehub, SiteHub::Logging::ErrorLogger)
-        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:error_logger))
+        logger_middleware = find_middleware(sitehub, Middleware::Logging::ErrorLogger)
+        expect(logger_middleware.logger).to eq(Middleware::Logging::LogWrapper.new(:error_logger))
       end
 
       it 'defaults to STDERR' do
         allow(::Logger).to receive(:new).and_return(:a_logger)
         expect(::Logger).to receive(:new).with(STDERR).and_return(:stderr_logger)
         sitehub = subject.build
-        logger_middleware = find_middleware(sitehub, SiteHub::Logging::ErrorLogger)
-        expect(logger_middleware.logger).to eq(Logging::LogWrapper.new(:stderr_logger))
+        logger_middleware = find_middleware(sitehub, Middleware::Logging::ErrorLogger)
+        expect(logger_middleware.logger).to eq(Middleware::Logging::LogWrapper.new(:stderr_logger))
       end
     end
 
@@ -111,34 +113,38 @@ class SiteHub
 
       context 'default middleware' do
         it 'adds TransactionId middleware to the sitehub' do
-          expect(subject.build).to be_using(TransactionId)
+          expect(subject.build).to be_using(Middleware::TransactionId)
         end
 
         it 'adds a forward proxies' do
-          expect(subject.build).to be_using(ForwardProxies)
+          expect(subject.build).to be_using(Middleware::ForwardProxies)
         end
 
         it 'adds a AccessLogger' do
-          expect(subject.build).to be_using(Logging::AccessLogger)
+          expect(subject.build).to be_using(Middleware::Logging::AccessLogger)
         end
 
         it 'adds a ErrorLogger' do
-          expect(subject.build).to be_using(Logging::ErrorLogger)
+          expect(subject.build).to be_using(Middleware::Logging::ErrorLogger)
         end
         it 'adds a Rack FiberPool' do
           expect(subject.build).to be_using(Rack::FiberPool)
         end
 
+        it 'adds a ErrorHandler' do
+          expect(subject.build).to be_using(Middleware::ErrorHandling)
+        end
+
         context 'reverse proxy' do
           it 'adds a reverse proxy' do
-            expect(subject.build).to be_using(ReverseProxy)
+            expect(subject.build).to be_using(Middleware::ReverseProxy)
           end
 
           it 'uses configured reverse proxy directives' do
             subject.reverse_proxy(downstream_url: :upstream_path.to_s)
-            reverse_proxy = find_middleware(subject.build, ReverseProxy)
+            reverse_proxy = find_middleware(subject.build, Middleware::ReverseProxy)
 
-            expect(reverse_proxy.path_directives).to eq(PathDirectives.new(downstream_url: :upstream_path.to_s))
+            expect(reverse_proxy.path_directives).to eq(LocationRewriters.new(downstream_url: :upstream_path.to_s))
           end
         end
 
@@ -146,11 +152,12 @@ class SiteHub
           middleware_stack = collect_middleware(subject.build).collect(&:class)
 
           expected_middleware = [Rack::FiberPool,
-                                 Logging::ErrorLogger,
-                                 Logging::AccessLogger,
-                                 TransactionId,
-                                 ReverseProxy,
-                                 ForwardProxies]
+                                 Middleware::Logging::ErrorLogger,
+                                 Middleware::Logging::AccessLogger,
+                                 Middleware::ErrorHandling,
+                                 Middleware::TransactionId,
+                                 Middleware::ReverseProxy,
+                                 Middleware::ForwardProxies]
 
           expect(middleware_stack).to eq(expected_middleware)
         end