sitehub 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8eab93145788748ecc28ef5f14aea92b7595f846
+  data.tar.gz: 69f240e1d1d707424bf2e6a07e4791b767441427
+SHA512:
+  metadata.gz: a4d317b035c62e2513261872065ef428ae0342fc8a40c5807b8b597908d53b9f288b6aa310cda0ece34b57e6d1d77068040af6ce27c96fc5e22aaf762e0a1f24
+  data.tar.gz: 4fbf75725640bbc3dcf06e742bb7b549c444048fb8e4f00d0a64888198d62acd1d0b541a4f225b91928107da2e2bc8b70104144ff8697c8035d03c01aef1a266

data/.gitignore

@@ -0,0 +1,6 @@
+*.iml
+.idea
+test.rb
+coverage
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sitehub.gemspec
+gemspec
+
+

data/Gemfile.lock

@@ -0,0 +1,114 @@
+PATH
+  remote: .
+  specs:
+    sitehub (0.4.1)
+      em-http-request
+      em-synchrony
+      faraday
+      rack
+      rack-fiber_pool
+      rack-ssl-enforcer
+      thin
+      uuid
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.8)
+    builder (3.2.2)
+    cookiejar (0.3.0)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    daemons (1.2.3)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    em-http-request (1.1.3)
+      addressable (>= 2.3.4)
+      cookiejar (<= 0.3.0)
+      em-socksify (>= 0.3)
+      eventmachine (>= 1.0.3)
+      http_parser.rb (>= 0.6.0)
+    em-socksify (0.3.1)
+      eventmachine (>= 1.0.0.beta.4)
+    em-synchrony (1.0.4)
+      eventmachine (>= 1.0.0.beta.1)
+    eventmachine (1.0.8)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    geminabox (0.12.4)
+      builder
+      faraday
+      httpclient (>= 2.2.7)
+      nesty
+      sinatra (>= 1.2.7)
+    hashdiff (0.2.3)
+    http_parser.rb (0.6.0)
+    httpclient (2.7.1)
+    json (1.8.3)
+    macaddr (1.7.1)
+      systemu (~> 2.6.2)
+    memory_profiler (0.9.6)
+    multipart-post (2.0.0)
+    nesty (1.0.2)
+    rack (1.6.4)
+    rack-fiber_pool (0.9.3)
+    rack-protection (1.5.3)
+      rack
+    rack-ssl-enforcer (0.2.9)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rake (10.4.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    ruby-prof (0.15.9)
+    safe_yaml (1.0.4)
+    simplecov (0.11.1)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    sinatra (1.4.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    systemu (2.6.5)
+    thin (1.6.4)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0, >= 1.0.4)
+      rack (~> 1.0)
+    tilt (2.0.2)
+    uuid (2.3.8)
+      macaddr (~> 1.0)
+    webmock (1.22.5)
+      addressable (< 2.4.0)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  geminabox
+  memory_profiler
+  rack-test
+  rake
+  rspec (~> 3.2.0)
+  ruby-prof
+  simplecov
+  sitehub!
+  webmock
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2015, Ladtech Ltd
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of sitehub nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,198 @@
+# SiteHub
+SiteHub is a HTTP proxy written in Ruby with support for A|B testing baked in. SiteHub sits in front of your web application(s) routing all HTTP traffics between it and your users. 
+
+Wouldn't it be cool to write something like: 
+```ruby
+sitehub = SiteHub.build do 
+  proxy %r{/catalogue/(.*)} do
+    split percentage: 50, url: 'http://version1.com/$1', label: :prototype_1
+    split percentage: 50, url: 'http://version2.com/$1', label: :prototype_2
+  end
+end
+
+run sitehub
+```
+or 
+```ruby
+user_eligible = proc{} #perform check and return boolean
+
+sitehub = SiteHub.build do 
+  proxy %r{/catalogue/(.*)} do
+    route url: 'http://new_catalogue.com/catalogue/$1', label: :new_version, rule: user_eligbile 
+    
+    default url: 'http://current_catalogue.com/$1'
+  end
+  # other proxy definitions ...
+end
+
+run sitehub
+```
+
+With SiteHub you can:
+- A|B testing new features
+- Silently release new features - SiteHub can be used to put a new version of you application live but inaccessible to users. This new version can still be accessed by teams to peform final checks before opening up the new version to the public.
+- Modular Web Applications - SiteHub can be used to front discrete applications and present a unified root.
+
+## Installation
+`gem install sitehub`
+
+## Definning a SiteHub
+A SiteHub is a rack application so needs to be passed to the `run` method in your rackup file
+
+example config.ru
+```ruby
+require 'sitehub'
+sitehub = SiteHub.build do
+  proxy '/' => 'http://downstream.url.com'
+end
+run sitehub
+```
+
+## Defining proxies
+Proxies can have either routes or splits defined within them but not both at the same time.
+- Splits - define the percentage chance that a downstream url will be used to proxy a user request.
+- Routes - routes are defined with a rule that determines whether or not a user request can be sent to its downstream url
+
+### Version affinity
+Once a downstream route has been chosen for a given route it is sticky. Meaning that users will stay with a version and not flip flop between them.
+
+Sitehub does this by dropping a cookie that holds the route version that a request is sent to.
+
+By default the cookie will be given the name `sitehub.recorded_route` and will have the path of the request.
+
+#### Overiding the name
+This is done at the top level of your sitehub definition. The name you supply will be used for all sitehub cookies dropped by all proxies.
+```ruby
+sitehub = SiteHub.build do
+  sitehub_cookie_name :your_custom_name
+end
+```
+
+#### Overiding the path
+This is done a proxy by proxy basis
+```ruby
+sitehub = SiteHub.build do
+  proxy '/' do
+    sitehub_cookie_path '/your/path'
+    #splits/routes defined here
+  end
+end
+```
+**Caution:** 
+By default sitehub is going to use the path of the request. If you have used a regular expression to define a proxy, this will be different for each unique request that is made.
+
+e.g. for the following example, calls to /path1, and /path2 would each be given a cookie meaning that users could flip between different version for the same proxy definition. In this case you are definately going to want to set the `sitehub_cookie_path` to keep things consistent.
+
+```ruby
+sitehub = SiteHub.build do
+  proxy %r{/*} do
+    #splits/routes defined here
+  end
+end
+```
+
+### Routes with Rules
+Define a route inside a proxy defintion as follows
+```ruby
+sitehub = SiteHub.build do 
+  proxy '/catalogue' do
+    route url: 'http://new_catalogue.com/catalogue', label: :new_version, rule: user_eligbile
+    # ...
+  end
+end
+```
+Rules must be an object that responds to call with a single parameter that returns a boolean. True means that the rule applies and false means that it does not.
+
+The parameter passed to call is the request environment hash. This lets you write things like:
+```ruby
+has_special_parameter = proc do |env|
+  Rack::Request.new(env).params.include?(:special_param)
+end
+```
+
+### Splits
+Splits are defined as follows
+```ruby
+sitehub = SiteHub.build do 
+  proxy '/catalogue' do
+    split percentage: 50, url: 'http://version1.com', label: :prototype_1
+    split percentage: 50, url: 'http://version2.com', label: :prototype_2
+  end
+end
+```
+Split percentages must add up to 100% unless a default is defined.
+
+### Default routes
+When defining either Splits or Routes a default can be defined. Defaults are used as a fallback if a route with a rule that applies can't be found or a split can't be chosen on the first time of trying (This can happen when the splits don't add up to 100%).
+```ruby
+sitehub = SiteHub.build do 
+  proxy '/catalogue' do
+    route url: 'http://new_catalogue.com/catalogue', label: :new_version, rule: a_rule
+    default url: 'http://current_catalogue.com'
+  end
+end
+```
+### Labels
+Splits and Routes must be defined with a label. Within a proxy defintion, this label must be unique. This is the value that SiteHub will use to identify the version of a downstream url that a user should stick to once it has been selected.
+
+### Matching
+Proxy can be defined to capture specific paths using a literal string or be defined to have a broader appeal using regexs
+```ruby
+sitehub = SiteHub.build do 
+  proxy '/catalogue' => 'http://downstream.catalogue.com'
+  proxy %r{/orders/*} => 'http://downstream.orders.com'
+end
+```
+
+### Substitution
+Portions of the request path can be captured and passed downstream by specifying capture groups your path regular expression.
+```ruby
+sitehub = SiteHub.build do 
+  proxy %r{'/orders/(.*)} => 'http://downstream.orders.com/$1'
+end
+```
+
+## Using middleware
+You can `use` middleware in conjunction with a particular proxy definition or the SiteHub as a whole. 
+### Proxy specifc middleware
+```ruby
+sitehub = SiteHub.build do 
+  proxy '/catalogue/(.*)' do
+    use AuthenticationMiddlware
+  end
+end
+```
+In this example, only requests received by the proxy definition will be made to go through the AuthenticationMiddleware
+
+### SiteHub wide middlware
+```ruby
+sitehub = SiteHub.build do 
+  use AuthenticationMiddleware
+  proxy '/catalogue' => 'http://downstream.catalogue.com'
+  proxy '/orders' => 'http://downstream.orders.com'
+end
+```
+In this example, all requests handled by the SiteHub will go through the AuthenticationMiddleware
+### Reverse Proxying
+In order to ensure that you applications stay firmly behind your SiteHub, you are going need to ensure that any responses that they return have are rewritten to remove references to your downstream URLs. SiteHub does this for the `Location` header (set for redirects) and will soon do it for the [Content-Location](https://github.com/bskyb-commerce/sitehub/issues/8) header also.
+```ruby
+sitehub = SiteHub.build do
+  proxy %r{/orders/(.*)} => 'http://downstream.orders.com/$1'
+  reverse_proxy %r{http://downstream.orders.com/(.*)} => '/orders/$1'
+end
+```
+*Note* The above example also performs substitution from the downstream URL in to the upstream mapping. This is not mandatory
+
+## SiteHub Transaction ID
+SiteHub introduces a custom header to downstream requests called `sitehub_transaction_id` that is unique to every request. The idea is that if a request is made from the downstream system to another then this header should be passed on also. If access/errors in each system are logged along with this id, then tracing things in distributed systems will become easier.
+
+The transaction id, if passed on through out, could also be used for request scoped caching.
+
+## Logging
+By default SiteHub will log requests and errors to STDOUT and STDERR respectively. You can overide this with your own logging devices. For example you may want to send requests and errors to syslog. Just make sure that your logger object responds to `<<` or `write` and SiteHub will do the rest.
+```ruby
+sitehub = SiteHub.build do
+  access_logger YourLogger.new
+  error_logger YourLogger.new
+end
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new(:spec) do
+  ENV['coverage'] = 'true'
+end
+
+task :default => :spec

data/lib/sitehub.rb

@@ -0,0 +1,9 @@
+require 'sitehub/constants'
+require 'sitehub/builder'
+class SiteHub
+  class << self
+    def build &block
+      Builder.new(&block).build
+    end
+  end
+end

data/lib/sitehub/builder.rb

@@ -0,0 +1,82 @@
+require 'sitehub/forward_proxies'
+require 'sitehub/transaction_id'
+require 'sitehub/middleware'
+require 'sitehub/forward_proxy_builder'
+require 'sitehub/reverse_proxy'
+require 'rack/ssl-enforcer'
+require 'sitehub/logging'
+require 'rack/fiber_pool'
+require 'logger'
+
+
+class SiteHub
+
+  class InvalidProxyDefinitionException < Exception;
+  end
+  class Builder
+
+    attr_reader :sitehub, :forward_proxies, :reverse_proxies
+
+    include Middleware
+
+    def force_ssl except: []
+      @force_ssl = true
+      @ssl_exclusions = except
+    end
+
+    def initialize(&block)
+      @forward_proxies = ForwardProxies.new
+      @reverse_proxies = {}
+      instance_eval &block if block
+    end
+
+    def access_logger logger=nil
+      return @access_logger unless logger
+      @access_logger = logger
+    end
+
+    def error_logger logger=nil
+      return @error_logger unless logger
+      @error_logger = logger
+    end
+
+    def sitehub_cookie_name name=nil
+      @sitehub_cookie_name ||= RECORDED_ROUTES_COOKIE
+
+      return @sitehub_cookie_name unless name
+      @sitehub_cookie_name = name
+    end
+
+    def build
+      forward_proxies.init
+      use ReverseProxy, reverse_proxies
+      use TransactionId
+      use Logging::AccessLogger, access_logger || ::Logger.new(STDOUT)
+      use Logging::ErrorLogger, error_logger || ::Logger.new(STDERR)
+      use Rack::FiberPool
+      use Rack::SslEnforcer, except: @ssl_exclusions if @force_ssl
+      middlewares.reverse!
+
+      apply_middleware(forward_proxies)
+    end
+
+    def proxy opts={}, &block
+      args = {sitehub_cookie_name: sitehub_cookie_name}
+
+      if opts.is_a?(Hash)
+        mapped_path = opts.keys.first
+        url = opts.values.first
+        args.merge!(url: url, mapped_path: mapped_path)
+      else
+        args.merge!(mapped_path: opts)
+      end
+
+      forward_proxies << ForwardProxyBuilder.new(args, &block)
+    end
+
+    def reverse_proxy hash
+      reverse_proxies.merge!(hash)
+    end
+  end
+
+end