tom 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.9.2-p290@leonard

data/Gemfile

@@ -0,0 +1,23 @@
+source "http://rubygems.org"
+
+group :default do
+  gem "goliath"
+  gem "em-synchrony"
+  gem "em-http-request"
+  gem "mp-deployment", "0.0.21"
+  gem "json"
+  gem "rake"
+end
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "shoulda", ">= 0"
+  gem "rcov", ">= 0"
+  gem "ruby-debug19"
+  gem "rspec"
+  gem "webmock"
+  gem "yard"
+end

data/Gemfile.lock

@@ -0,0 +1,128 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    archive-tar-minitar (0.5.2)
+    async-rack (0.5.1)
+      rack (~> 1.1)
+    capistrano (2.5.21)
+      highline
+      net-scp (>= 1.0.0)
+      net-sftp (>= 2.0.0)
+      net-ssh (>= 2.0.14)
+      net-ssh-gateway (>= 1.0.0)
+    capistrano-ext (1.2.1)
+      capistrano (>= 1.0.0)
+    columnize (0.3.5)
+    crack (0.3.1)
+    diff-lcs (1.1.3)
+    em-http-request (1.0.0)
+      addressable (>= 2.2.3)
+      em-socksify
+      eventmachine (>= 1.0.0.beta.3)
+      http_parser.rb (>= 0.5.2)
+    em-socksify (0.1.0)
+      eventmachine
+    em-synchrony (1.0.0)
+      eventmachine (>= 1.0.0.beta.1)
+    eventmachine (1.0.0.beta.4)
+    facter (1.6.3)
+    git (1.2.5)
+    goliath (0.9.4)
+      async-rack
+      em-synchrony (>= 1.0.0)
+      eventmachine (>= 1.0.0.beta.3)
+      http_parser.rb
+      http_router (~> 0.9.0)
+      log4r
+      multi_json
+      rack (>= 1.2.2)
+      rack-contrib
+      rack-respond_to
+    hashie (1.0.0)
+    highline (1.6.8)
+    http_parser.rb (0.5.3)
+    http_router (0.9.7)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    json (1.6.2)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    log4r (1.1.9)
+    mp-deployment (0.0.21)
+      capistrano (~> 2.5.20)
+      capistrano-ext (~> 1.2.1)
+      facter (~> 1.6.0)
+      hashie (~> 1.0.0)
+      newrelic_rpm (~> 3.3.0)
+      rpm_contrib (~> 2.1.3)
+      rvm (~> 1.6.20)
+    multi_json (1.0.3)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-sftp (2.0.5)
+      net-ssh (>= 2.0.9)
+    net-ssh (2.2.1)
+    net-ssh-gateway (1.1.0)
+      net-ssh (>= 1.99.1)
+    newrelic_rpm (3.3.0)
+    rack (1.3.5)
+    rack-accept-media-types (0.9)
+    rack-contrib (1.1.0)
+      rack (>= 0.9.1)
+    rack-respond_to (0.9.8)
+      rack-accept-media-types (>= 0.6)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rpm_contrib (2.1.6)
+      newrelic_rpm (>= 3.1.1)
+      newrelic_rpm (>= 3.1.1)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    rvm (1.6.32)
+    shoulda (2.11.3)
+    url_mount (0.2.1)
+      rack
+    webmock (1.7.8)
+      addressable (~> 2.2, > 2.2.5)
+      crack (>= 0.1.7)
+    yard (0.7.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  em-http-request
+  em-synchrony
+  goliath
+  jeweler (~> 1.6.4)
+  json
+  mp-deployment (= 0.0.21)
+  rake
+  rcov
+  rspec
+  ruby-debug19
+  shoulda
+  webmock
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jannis Hermanns
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,112 @@
+![Tom Smykowski](http://dl.dropbox.com/u/1953503/tom%20smykowsky.jpg)
+# Tom Smykowski - I have people skills!
+
+Tom Smykowski, Tom for short, is a gem that takes the specifications from the customers and brings them down to the engineers. He has people skills. He is good at dealing with people. If this does not make sense to you, please refer to [this introductory video](http://www.youtube.com/watch?v=mGS2tKQhdhY) and, of course, [the movie](http://www.imdb.com/video/screenplay/vi3215851801/).
+
+To go into technical detail: Tom uses [Goliath](http://goliath.io) to dispatch HTTP requests to multiple other APIs (via `Adapter`s) in parallel. In a next step, a `Merger` merges the result and responds to the clients request.
+
+All you have to do is define some `Adapter`s that get activated for certain routes and some `Merger`s for certain routes.
+
+# TL;DR
+
+The general flow goes like this:
+
+     TIME            Request
+      |                 |
+      |             Dispatcher
+      |      .__________|___________.
+      |      |          |           |
+      |    Adapter1  Adapter3   AdapterN   (in parallel)
+      |      |________. | ._________|
+      |               | | |
+      |               Merger
+      |                 |
+      V             Response
+
+So per request there can be many `Adapter`s that talk to different APIs, and one `Merger` that combines the responses of all APIs to one response.
+
+# How to use
+## Tom::Dispatcher
+
+This class basically does what is pictured in the flow above:
+
+1. Take the request
+2. Find all `Adapter`s that registered for a matching route
+3. Dispatch the requests to them
+4. Collect results
+5. Merge results into one and respond
+
+To add APIs or change the behavior of Tom, you don't have to touch this class, though. `Adapter` and `Merger` is what you're looking for.
+
+## Tom::Adapter
+
+The `Adapter` class comes with the class methods:
+
+- `host=` (set the api to talk to)
+- `rewrite_request` (overwrite if you don't want to pass on URIs 1:1)
+- `forward_request` (takes env, calls the `rewrite_request` method and returns the result)
+
+To hook Tom up to an API, you would first create an `Adapter` that inherits from the `Tom::Adapter` class, register some routes (they become regular expressions) and finally implement the logic by overwriting the `handle` method:
+
+    class Sheldon < Tom::Adapter
+      register_route "/nodes/*"
+
+      def self.handle(env)
+        # Insert biz logic here
+        forward_request(env)
+      end
+    end
+
+The handle method takes a rack env, does some stuff like removing things that are not needed in Sheldon and then forwards the request on to the API.
+
+In your initializer you can configure `Adapter`s like this:
+
+    Sheldon.host = 'http://localhost:9292'
+
+This causes the aforementioned `rewrite_request` method to use that host name. The `forward_request` method uses an instance variable called `@request` to know what to do. `rewrite_request`, for example, takes a rack env and initializes `@request` with `:host`, `:method` and `:uri`. 
+
+If the method is `POST` or `PUT`, then you should also set the appropriate `@request[:body]` if you want to use the automatic `forward_request` method.
+
+## Tom::Merger
+
+`Mergers` work very similar to `Adapter`s. But all you have to do here is subclass it and implement the `merge` method. For example we could create a `Merger` that always ignores everything and just returns the response from Sheldon:
+
+    class OnlySheldon < Tom::Merger
+    
+      register_route "^/nodes/[0-9]+$"
+    
+      def self.merge(env, responses)
+        responses[Sheldon]
+      end
+    end
+
+You can use the rack `env` to decide what to do, and you get a hash of `responses` that has the Adapter class as keys and their respective rack `responses``:
+
+    { MyAdapter      => [[200,{},"first response" ],
+                         [200,{},"second response"]],
+      MyOtherAdapter => […]
+    }
+
+## On registering routes
+
+If you call
+
+    class Foo < Tom::Adapter
+      register_route "^/nodes/[0-9]+$"
+      …
+    end
+
+the adapter will be registered for all methods (namely `head`, `get`, `put`, `post`, `delete`). If you just want to register for some methods, you can do that with
+
+    register_route "^/nodes/[0-9]_$", :get, :put
+
+Same goes for mergers.
+
+# Todo
+
+- handle adapter errors/states in mergers
+- register routes with concurrency on and off
+- use Goliath::Rack::Params
+- use Goliath::Rack::Heartbeat
+- think about consensus protocols
+- ...

data/Rakefile

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+require 'yard'
+require 'rspec/core/rake_task'
+require 'jeweler'
+
+
+#
+#  Jeweler Stuff
+#
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "tom"
+  gem.homepage = "http://github.com/moviepilot/tom"
+  gem.license = "MIT"
+  gem.summary = %Q{Parallel request dispatcher and merger for goliath.io}
+  gem.description = %Q{ Tom uses Goliath to dispatch HTTP requests to multiple other APIs (via Adapters) in parallel. In a next step, a Merger merges the result and responds to the clients request.}
+  gem.email = "jannis@gmail.com"
+  gem.authors = ["Jannis Hermanns"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+#
+#  Rcov
+#
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+
+#
+#  RSpec
+#
+task :default => [:spec]
+task :test => [:spec]
+desc "run spec tests"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+
+#
+#  Yard
+#
+desc 'Generate documentation'
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', '-', 'LICENSE']
+  t.options = ['--main', 'README.md', '--no-private']
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/adapter.rb

@@ -0,0 +1,96 @@
+require 'em-synchrony/em-http'
+require_relative 'http'
+
+module Tom
+  class Adapter
+    class << self
+      attr_accessor :host
+    end
+
+    #
+    #  Registers a route with the request dispatcher
+    #  so that this classes subclass gets called when
+    #  a request is made. One that matches the route.
+    #
+    #  The route can be a string, but it becomes a 
+    #  regular expression in here, followed by methods.
+    #
+    def self.register_route(*args)
+      route = args[0]
+      methods = args[1..-1]
+      Dispatcher.register(route: /#{route}/, adapter: self, methods: methods)
+    end
+
+    def initialize
+      @request = {}
+    end
+
+    #
+    #  Takes a request from rack and issues the same
+    #  request again, just to a different host. This
+    #  method is to be used by subclasses.
+    #
+    def forward_request(env)
+      rewrite_request(env)
+      options = http_request_options(env)
+      url = @request[:host] + @request[:uri]
+
+      result = Tom::Http.make_request(@request[:method], url, options)
+
+      headers = {"Downstream-Url" => url}.merge result.response_header
+      [result.response_header.status, headers, result.response]
+    end
+
+    #
+    #  Takes a request and generates the options for calling
+    #  HttpRequest.put (or whatever the the requested
+    #  REQUEST_METHOD is).
+    #
+    #  It's content depends on the request method, for PUTs
+    #  and POSTs this will add the request body
+    #
+    def http_request_options(env)
+      opts = {}
+      if [:put, :post].include? @request[:method]
+        opts[:body] = @request[:body] || extract_request_body(env)
+      end
+      opts
+    end
+
+    #
+    #  Extracts the given POT/PUST (hehe) body
+    #
+    def extract_request_body(env)
+      Rack::Request.new(env).POST.keys.first rescue "{}"
+    end
+
+    #
+    #  Takes a request from rack and extracts the request
+    #  method, uri and returns the host this adapter talks
+    #  to. Can be overwritten if you want to change stuff
+    #  before forwarding it.
+    #
+    def rewrite_request(env)
+      rewritten = rewrite_host(env)
+      @request = rewritten.merge(@request)
+    end
+
+    def handle(env)
+      raise "Subclass, implement #handle(env)!"
+    end
+
+    private
+
+    #
+    #  Returns a hash that can be used as the @request variable,
+    #  which is exactly like the given env except for a changed
+    #  hostname.
+    #
+    def rewrite_host(env)
+      { host:   self.class.host,
+        uri:    env["REQUEST_URI"],
+        method: env["REQUEST_METHOD"].downcase.to_sym
+      }
+    end
+  end
+end

data/lib/dispatcher.rb

@@ -0,0 +1,160 @@
+require "em-synchrony/fiber_iterator"
+require 'logger'
+
+module Tom
+
+  LOG = ::Logger.new(STDOUT)
+  LOG.level = ::Logger::ERROR
+  LOG.datetime_format = "%H:%M:%S:"
+  Logger::Formatter.module_eval(
+    %q{ def call(severity, time, progname, msg)} +
+    %q{ "#{format_datetime(time)} #{msg2str(msg)}\n" end}
+  )
+
+  class Dispatcher
+
+    #
+    #  Dispatches this request to all adapters that registered
+    #  for the route and then calls the merger for this route
+    #  to compose a response
+    #
+    def self.dispatch(env)
+      adapters = adapters_for_route(env)
+      return [404, {}, '{reason: "No adapters for this route"}'] if adapters.empty?
+
+      # Hit APIs. All at the same time. Oh, mygodd!
+      responses = {}
+      Tom::LOG.info "#{env['REQUEST_METHOD'].upcase} #{env['REQUEST_URI']}"
+      Tom::LOG.info "Dispatching to:"
+      EM::Synchrony::FiberIterator.new(adapters, adapters.count).map do |clazz|
+        Tom::LOG.info "  -> #{clazz}"
+        (responses[clazz] ||= []) <<  clazz.new.handle(env)
+      end
+
+      merged = merge(env, responses)
+      Tom::LOG.info "-------------------------------------------------------n"
+      merged
+    end
+
+    #
+    #  Takes a request (rack env) and a couple of responses
+    #  generated by api adapters and composes a response for the
+    #  client.
+    #
+    #  The merger used depends on the route.
+    #
+    def self.merge(env, responses)
+      merger = merger_for_route(env)
+      Tom::LOG.info "Merging with:"
+      Tom::LOG.info "  -> #{merger}"
+      merger.new.merge env, responses
+    end
+
+    #
+    #  Registers a opts[:adapter] or opts[:merger] for the 
+    #  given opts[:route].
+    #
+    #  This method should not be called directly, use register_route
+    #  in Tom::Adapter or Tom::Merger instead.
+    #
+    def self.register(opts)
+      return register_adapter(opts) if opts[:adapter]
+      return register_merger(opts)  if opts[:merger]
+      raise "You need to supply opts[:adapter] or opts[:merger]"
+    end
+
+    private
+
+    #
+    #  Registers an adapter for a given route and request method
+    #
+    def self.register_adapter(opts)
+      validate_type(opts[:adapter], Adapter)
+      methods = get_methods(opts)
+      @adapters ||= default_methods_hash
+      methods.each do |method|
+        @adapters[method][opts[:route]] ||= []
+        @adapters[method][opts[:route]] << opts[:adapter]
+      end
+    end
+
+    #
+    #  Registers merger for a given route and request method
+    #
+    def self.register_merger(opts)
+      validate_type(opts[:merger], Merger)
+      methods = get_methods(opts)
+      @mergers ||= default_methods_hash
+      methods.each do |method|
+        @mergers[method][opts[:route]] ||= []
+        @mergers[method][opts[:route]] << opts[:merger]
+      end
+    end
+
+    #
+    #  Fetches the methods from the options hash, defaults
+    #  to all methods.
+    #
+    def self.get_methods(opts)
+      return opts[:methods] unless opts[:methods].empty?
+      [:head, :get, :put, :post, :delete]
+    end
+
+    #
+    #  Just some defaults to initialize thing
+    #
+    def self.default_methods_hash
+      { head:   {},
+        get:    {},
+        put:    {},
+        post:   {},
+        delete: {}
+      }
+    end
+
+    #
+    #  Find the right adapter for a route
+    #
+    def self.adapters_for_route(env)
+      @adapters ||= default_methods_hash
+      route, method = route_and_method(env)
+      matches = []
+      @adapters[method].map do |reg_route, adapters|
+        next unless reg_route.match(route)
+        matches += adapters
+      end
+      matches.uniq
+    end
+
+    #
+    #  Find the right merger for a route
+    #
+    def self.merger_for_route(env)
+      @mergers ||= default_methods_hash
+      route, method = route_and_method(env)
+      @mergers[method].each do |reg_route, mergers|
+        next unless reg_route.match(route)
+        return mergers.first
+      end
+      raise "Found no merger for route #{route}"
+    end
+
+    #
+    #  Extract the route/request uri and the method from a
+    #  rack env
+    #
+    def self.route_and_method(env)
+      [env["REQUEST_PATH"],
+       env["REQUEST_METHOD"].downcase.to_sym]
+    end
+
+    #
+    #  Make sure one class is a subclass of another class
+    #
+    def self.validate_type(c, expected)
+      return if c < expected
+      raise "Invalid type. Expected #{expected} got #{c}"
+    end
+
+  end
+end

data/lib/http.rb

@@ -0,0 +1,35 @@
+module Tom
+  module Http
+
+    #
+    #  Makes a http request of the given method to the given url.
+    #  Passes the options on to EM::HttpRequest.put (or whatever
+    #  method has to be called) and does some error handling and
+    #  works around some EM:HttpRequest oddities (see handle_errors).
+    #
+    def self.make_request(method, url, options = {})
+      Tom::LOG.info "     curl -X#{method.upcase} -d '#{options[:body]}' #{url}"
+
+      conn = EM::HttpRequest.new(url, connection_options)
+      result  = conn.send(method, options)
+      handle_errors(method, url, result)
+
+      result
+    end
+
+    private
+
+    def self.connection_options
+      { connect_timeout: Tom.config[:timeouts][:connect_timeout],
+        inactivity_timeout: Tom.config[:timeouts][:inactivity_timeout]}
+    end
+
+    def self.handle_errors(method, url, result)
+      result.errback do
+        raise "Tom::Adapter.forward_request error #{method} #{url}"
+      end
+      return unless result.response_header.status == 0
+      raise "EM::HttpRequest returned response code 0 for #{url} - timeout?"
+    end
+  end
+end

data/lib/init.rb

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler.require :default
+
+module Tom; end
+
+require_relative 'dispatcher'
+require_relative 'adapter'
+require_relative 'merger'

data/lib/merger.rb

@@ -0,0 +1,34 @@
+module Tom
+  class Merger
+
+    #
+    #  Registers a route with the request dispatcher
+    #  so that this classes subclass gets called when
+    #  a request is made. One that matches the route.
+    #
+    #  The route can be a string, but it becomes a 
+    #  regular expression in here. When matching in
+    #  order to find a merger for a request, the first
+    #  one matching wins.
+    #
+    def self.register_route(*args)
+      route = args[0]
+      methods = args[1..-1]
+      Dispatcher.register(route: /#{route}/, merger: self, methods: methods)
+    end
+
+    #
+    #  When the request dispatcher made all the requests,
+    #  it will call the merge method of the subclass with
+    #  the responses as a hash in the form
+    #
+    #  {MyAdapter: rack_env, MyOtherAdapter: other_env}
+    #
+    #  Has to return a rack response (for example, something
+    #  like [200, {}, "body"])
+    #
+    def merge(env, responses)
+      raise "Subclass, implement #merge(env, responses)!"
+    end
+  end
+end

data/lib/tom.rb

@@ -0,0 +1,62 @@
+require_relative 'init'
+
+# Init Goliath env unless it was done already
+Goliath.env rescue Goliath.env = (ENV['RACK_ENV'] || 'development').to_sym
+
+# In dev mode, we do some logging (defaults to Logger::ERROR in other
+# envs)
+if Goliath.env == :development
+  Tom::LOG.level = Logger::INFO
+end
+Tom::LOG.info "Started goliath in #{Goliath.env} environment (change with ruby your_app.rb -e development or by setting $RACK_ENV)"
+
+module Tom
+
+  def self.config
+    @config || default_config
+  end
+
+  def self.config=(config)
+    @config = config
+  end
+
+  #
+  #  WE HAZ ALL TEH GOLIATH REQUESTS AND FORWARDETH
+  #  THEM TO DEH DISPATCHERETH.
+  #
+  #  We have to see if this is the right way to do
+  #  it when it comes to parallel stuff and so on...
+  #
+  class GoliathAPI < Goliath::API
+    use Goliath::Rack::JSONP
+    use Goliath::Rack::Params
+    use Goliath::Rack::Formatters::JSON
+    use Goliath::Rack::Render
+
+    def response(env)
+      begin
+        Tom::Dispatcher.dispatch(env)
+      rescue => e
+        handle_exception e, env
+      end
+    end
+
+    def handle_exception(e, env)
+      trace = e.backtrace.join "\n"
+      Tom::LOG.info e
+      Tom::LOG.info trace
+      [500, {}, {error: e,
+        stacktrace: trace,
+        url:        env["REQUEST_URI"]
+      }.to_json]
+    end
+  end
+
+  private
+
+  def self.default_config
+    { timeouts:
+        { connect_timeout: 5,
+          inactivity_timeout: 10 } }
+  end
+end

data/spec/lib/adapter_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+class ForwardingAdapter1 <  Tom::Adapter
+  register_route "^/manatees/[0-9]+$"
+  def handle(env)
+    forward_request(env)
+  end
+end
+ForwardingAdapter1.host = 'http://webmocked-host-1.com'
+
+describe Tom::Adapter do
+
+  let(:env){ {'REQUEST_URI'    =>  '/manatees/15?foo',
+              'REQUEST_METHOD' =>  'GET'} }
+
+  it "forward_request uses rewrite_request to change the host" do
+    rewritten = {host: "http://webmocked-host-1.com", uri: "/o", method: "get" }
+    ForwardingAdapter1.any_instance.should_receive(:rewrite_host).and_return(rewritten)
+    with_api(Tom::GoliathAPI) do
+      request = get_request(:path => '/manatees/15?foo')
+    end
+  end
+
+  it "rewrite_request changes the host" do
+    rewritten = ForwardingAdapter1.new.rewrite_request(env)
+
+    rewritten[:host].should   == "http://webmocked-host-1.com"
+    rewritten[:uri].should    == "/manatees/15?foo"
+    rewritten[:method].should == :get
+  end
+
+  it "rubs the lotion on its skin" do
+    true
+  end
+end

data/spec/lib/dispatcher_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../spec_helper'
+
+class APIAdapter1 <  Tom::Adapter
+  register_route "^/manatees/[0-9]+$"
+  def handle(env);end
+end
+APIAdapter1.host = 'http://api_host_1.com'
+
+class APIAdapter2 <  Tom::Adapter
+  register_route "^/manatees/[0-9]+$"
+  def handle(env);end
+end
+APIAdapter2.host = 'http://api_host_2.com'
+
+class Merger < Tom::Merger
+  register_route ".*"
+end
+
+describe Tom do
+
+  before(:each) do
+
+  end
+
+  it "emits a 404 when there are no adapters for the route" do
+    with_api(Tom::GoliathAPI) do
+      request = get_request(:path => '/walruses/5')
+      request.response_header.status.should == 404
+    end
+  end
+
+  it "makes requests to all registered adapters" do
+    expected_rack_env = hash_including("REQUEST_URI"    => "/manatees/15",
+                                       "REQUEST_METHOD" => "GET")
+
+    APIAdapter1.any_instance.should_receive(:handle).with(expected_rack_env).and_return true
+    APIAdapter2.any_instance.should_receive(:handle).with(expected_rack_env).and_return true
+
+    with_api(Tom::GoliathAPI) do
+      request = get_request(:path => '/manatees/15')
+    end
+  end
+
+  # Until we figure out how to properly mock EM:HttpRequest's with em-synchrony
+  # and Webmock, testing doesn't make too much sense here. So we'll discard it
+  # until then.
+  it "merges the result"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'bundler'
+
+Bundler.setup
+Bundler.require :default, :test
+
+require 'goliath/test_helper'
+require 'ruby-debug'
+require 'webmock/rspec'
+
+Goliath.env = :test
+RSpec.configure do |c| 
+  c.include Goliath::TestHelper, :example_group => {
+    :file_path => /spec/
+  }
+end
+
+RSpec.configure do |config|
+  # Until we figured out the Webmock/em-synchrony/em-http-request woes
+  config.before(:suite) do
+    WebMock.allow_net_connect!
+  end
+
+  config.before(:each) do
+    # I don't always make http requests. But when I do, 
+    # they are successful.
+    stub_request(:any, /.*webmocked-host.*/)
+  end
+
+  config.after(:each) do
+    EM.stop rescue nil
+  end
+
+end
+
+require_relative '../lib/tom'
+
+class Merger < Tom::Merger
+  register_route ".*"
+  def merge(a,b);[200, {}, ""]; end
+end

data/tom.gemspec

@@ -0,0 +1,96 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "tom"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jannis Hermanns"]
+  s.date = "2011-12-02"
+  s.description = " Tom uses Goliath to dispatch HTTP requests to multiple other APIs (via Adapters) in parallel. In a next step, a Merger merges the result and responds to the clients request."
+  s.email = "jannis@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    ".document",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "lib/adapter.rb",
+    "lib/dispatcher.rb",
+    "lib/http.rb",
+    "lib/init.rb",
+    "lib/merger.rb",
+    "lib/tom.rb",
+    "spec/lib/adapter_spec.rb",
+    "spec/lib/dispatcher_spec.rb",
+    "spec/spec_helper.rb",
+    "tom.gemspec"
+  ]
+  s.homepage = "http://github.com/moviepilot/tom"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Parallel request dispatcher and merger for goliath.io"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<goliath>, [">= 0"])
+      s.add_runtime_dependency(%q<em-synchrony>, [">= 0"])
+      s.add_runtime_dependency(%q<em-http-request>, [">= 0"])
+      s.add_runtime_dependency(%q<mp-deployment>, ["= 0.0.21"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<goliath>, [">= 0"])
+      s.add_dependency(%q<em-synchrony>, [">= 0"])
+      s.add_dependency(%q<em-http-request>, [">= 0"])
+      s.add_dependency(%q<mp-deployment>, ["= 0.0.21"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<webmock>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<goliath>, [">= 0"])
+    s.add_dependency(%q<em-synchrony>, [">= 0"])
+    s.add_dependency(%q<em-http-request>, [">= 0"])
+    s.add_dependency(%q<mp-deployment>, ["= 0.0.21"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<webmock>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,224 @@
+--- !ruby/object:Gem::Specification
+name: tom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jannis Hermanns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: goliath
+  requirement: &70256849153920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849153920
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: &70256849153340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849153340
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: &70256849152840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849152840
+- !ruby/object:Gem::Dependency
+  name: mp-deployment
+  requirement: &70256849152280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.0.21
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849152280
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70256849151680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849151680
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70256849151080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70256849151080
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70256849150560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70256849150560
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70256849150000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70256849150000
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70256849149420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849149420
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70256849148740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849148740
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70256849148120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849148120
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70256849147600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849147600
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70256849147020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849147020
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70256849146400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70256849146400
+description: ! ' Tom uses Goliath to dispatch HTTP requests to multiple other APIs
+  (via Adapters) in parallel. In a next step, a Merger merges the result and responds
+  to the clients request.'
+email: jannis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.markdown
+files:
+- .document
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/adapter.rb
+- lib/dispatcher.rb
+- lib/http.rb
+- lib/init.rb
+- lib/merger.rb
+- lib/tom.rb
+- spec/lib/adapter_spec.rb
+- spec/lib/dispatcher_spec.rb
+- spec/spec_helper.rb
+- tom.gemspec
+homepage: http://github.com/moviepilot/tom
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4016356889838983520
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Parallel request dispatcher and merger for goliath.io
+test_files: []