telecaster 0.1.1 → 0.1.2

data/README.rdoc

@@ -16,29 +16,22 @@ the backend responses will be aggregated by the master.
 
 == Usage
 
-We recommend an EventMachine-based server like Thin, to best take advantage of
-EventMachine's concurrency. Create a Telecaster with a list of backend hosts and
-a logger:
+Create a Telecaster with a list of backend hosts, a logger and a timeout in
+seconds, then tell it to listen on a port:
 
   require 'telecaster'
   require 'logger'
   
   telecaster = Telecaster.new(
     :backends => %w[http://concerts-service http://accounts-service],
-    :logger   => Logger.new($stdout)
+    :logger   => Logger.new($stdout),
+    :timeout  => 15
   )
-
-Then either boot it directly with Thin:
-
-  require 'rack'
-  Rack::Handler.get('thin').run(telecaster, :Port => 9000)
-
-or use a +rackup+ script
-
-  # config.ru
-  run telecaster
   
-  $ thin start -R config.ru -p 9000
+  telecaster.listen(9000)
+
+This boots a Thin server with the request timeout set high enough to accomodate
+your backend request timeout.
 
 
 == Protocol

data/example/servers.rb

@@ -7,14 +7,17 @@ require 'thin'
 Thin::Logging.silent = true
 
 EM.run {
-  Rack::Handler.get('thin').run(Responder, :Port => 9001)
-  Rack::Handler.get('thin').run(Blank, :Port => 9002)
-  Rack::Handler.get('thin').run(Error, :Port => 9003)
+  thin = Rack::Handler.get('thin')
   
-  hosts = (1..3).map { |n| "http://localhost:900#{n}" }
+  thin.run(Responder, :Port => 9001)
+  thin.run(Blank, :Port => 9002)
+  thin.run(Error, :Port => 9003)
+  thin.run(Slow,  :Port => 9004)
+  
+  hosts = (1..4).map { |n| "http://localhost:900#{n}" }
   logger = Logger.new($stdout)
-  telecaster = Telecaster.new(:backends => hosts, :logger => logger)
+  telecaster = Telecaster.new(:backends => hosts, :logger => logger, :timeout => 1)
   
-  Rack::Handler.get('thin').run(telecaster, :Port => 9000)
+  telecaster.listen(9000)
 }
 

data/lib/telecaster.rb

@@ -1,35 +1,50 @@
 require 'eventmachine'
-require 'em-http-request'
+require 'em-http'
+require 'em-http/version'
+require 'thin'
 require 'yajl'
 
 class Telecaster
-  ASYNC_RESPONSE = [-1, {}, []].freeze
-  TYPE_JSON      = 'application/json'
+  ASYNC_RESPONSE  = [-1, {}, []].freeze
+  DEFAULT_TIMEOUT = 10
+  EMHTTP_VERSION  = EM::HttpRequest::VERSION.split('.')[0].to_i
+  TYPE_JSON       = 'application/json'
   
   ROOT = File.expand_path('..', __FILE__)
   autoload :Multi, ROOT + '/telecaster/multi'
   
   def initialize(options)
     @backend_hosts = options[:backends]
-    @logger = options[:logger]
+    @logger        = options[:logger]
+    @timeout       = options[:timeout] || DEFAULT_TIMEOUT
+  end
+  
+  def listen(port)
+    app = self
+    server = Thin::Server.new('0.0.0.0', port) { run app }
+    server.timeout = 1.5 * @timeout
+    server.start
   end
   
   def call(env)
     ensure_reactor_running
     
+    start     = Time.now.to_f
     method    = env['REQUEST_METHOD'].downcase
     multi     = Multi.new
     callback  = env['async.callback']
-    start     = Time.now.to_f
+    args      = create_args(env)
     
     @backend_hosts.each do |host|
-      request, args = *create_request(env, host)
+      uri     = File.join(host, env['REQUEST_URI'])
+      request = create_request(uri)
+      
       multi.add(host, request.__send__(method, args))
     end
     
     multi.callback do |response|
       duration = ((Time.now.to_f - start) * 1000).round
-      summary = response.map { |r| '[' + [r['host'], r['status'], r['duration']] * ' ' + ']' }
+      summary = response.map { |r| '[' + [r['host'], r['status'] || '-', r['duration'] || '-'] * ' ' + ']' }
       @logger.info "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']} backends:#{response.size} duration:#{duration} #{summary * ' '}"
       
       json = Yajl::Encoder.encode(response, :pretty => true, :indent => '  ')
@@ -44,10 +59,9 @@ class Telecaster
   
 private
   
-  def create_request(env, host)
-    uri     = File.join(host, env['REQUEST_URI'])
-    request = EM::HttpRequest.new(uri)
-    args    = {:head => {}}
+  def create_args(env)
+    args = {:head => {}}
+    args[:timeout] = @timeout if EMHTTP_VERSION < 1
     
     env.each do |header, value|
       next unless header =~ /^HTTP_/ and header != 'HTTP_HOST'
@@ -71,7 +85,15 @@ private
       args[:body] = input.read
     end
     
-    [request, args]
+    args
+  end
+  
+  def create_request(uri)
+    if EMHTTP_VERSION >= 1
+      EM::HttpRequest.new(uri, :inactivity_timeout => @timeout)
+    else
+      EM::HttpRequest.new(uri)
+    end
   end
   
   def ensure_reactor_running

data/lib/telecaster/multi.rb

@@ -25,19 +25,21 @@ class Telecaster
         if content_type == TYPE_JSON
           response['data'] = Yajl::Parser.parse(http.response)
         end
-        @responses[host] = response
-        succeed if @responses.size == @requests.size
+        add_response(host, response)
       end
       
       request.errback do |http|
-        response = {'host' => host, 'status' => nil}
-        @responses[host] = response
-        succeed if @responses.size == @requests.size
+        add_response(host, {'host' => host, 'status' => nil})
       end
     end
     
   private
     
+    def add_response(host, response)
+      @responses[host] = response
+      succeed if @responses.size == @requests.size
+    end
+    
     def succeed
       responses = []
       @responses.each do |host, response|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: telecaster
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-19 00:00:00.000000000 Z
+date: 2012-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -123,22 +139,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: thin
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.2.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.2.0
 description: 
 email: james@songkick.com
 executables: []
@@ -148,12 +148,8 @@ extra_rdoc_files:
 files:
 - README.rdoc
 - example/servers.rb
-- lib/telecaster/multi.rb
 - lib/telecaster.rb
-- spec/backends.rb
-- spec/spec_helper.rb
-- spec/telecaster_spec.rb
-- spec/telecaster_steps.rb
+- lib/telecaster/multi.rb
 homepage: http://github.com/songkick/telecaster
 licenses: []
 post_install_message: 
@@ -179,6 +175,5 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: HTTP proxy for forwarding to multiple backends and collecting results
+summary: Multiplexing HTTP proxy for decoupled inter-service notifications
 test_files: []
-has_rdoc: 

data/spec/backends.rb

@@ -1,48 +0,0 @@
-require 'sinatra'
-
-class Responder < Sinatra::Base
-  before do
-    headers 'Content-Type' => 'application/json'
-  end
-  
-  get '/hello' do
-    Yajl::Encoder.encode('status' => 'ok')
-  end
-  
-  get '/error' do
-    status 503
-    Yajl::Encoder.encode('error' => 'down')
-  end
-  
-  get '/users/:username' do |username|
-    Yajl::Encoder.encode('username' => username)
-  end
-  
-  get '/search' do
-    Yajl::Encoder.encode('query' => params[:q])
-  end
-  
-  put '/blog' do
-    status 201
-    Yajl::Encoder.encode('title' => params[:title])
-  end
-end
-
-class Blank < Sinatra::Base
-  get '/hello' do
-    ''
-  end
-end
-
-class Slow < Sinatra::Base
-  get '/hello' do
-    EM.add_timer 2 do
-      env['async.callback'].call [200, {}, []]
-    end
-    [-1, {}, []]
-  end
-end
-
-class Error < Sinatra::Base
-end
-

data/spec/spec_helper.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require File.expand_path('../../lib/telecaster', __FILE__)
-
-require 'rack/proxy'
-require 'rack/test'
-require 'uri'
-
-require File.expand_path('../../vendor/em-rspec/lib/em-rspec', __FILE__)
-require File.expand_path('../telecaster_steps', __FILE__)
-
-class Proxy < Rack::Proxy
-  def initialize(host)
-    super()
-    @uri = URI.parse(host)
-  end
-  
-  def rewrite_env(env)
-    env['SERVER_NAME'] = @uri.host
-    env['SERVER_PORT'] = @uri.port.to_s
-    env['HTTP_HOST']   = [@uri.host, @uri.port].join(':')
-    env
-  end
-end
-

data/spec/telecaster_spec.rb

@@ -1,159 +0,0 @@
-require "spec_helper"
-require "backends"
-require "logger"
-
-describe Telecaster do
-  include TelecasterSteps
-  
-  let(:logger) { Logger.new(StringIO.new) }
-  
-  before do
-    Thread.new { EM.run }
-    Thread.pass until EM.reactor_running?
-  end
-  
-  after { stop_all_servers }
-  
-  describe "with a backend" do
-    let :app do
-      Proxy.new("http://localhost:9000")
-    end
-    
-    before do
-      telecaster = Telecaster.new(:backends => ["http://localhost:9001"], :logger => logger)
-      boot telecaster, 9000
-      
-      boot Responder, 9001
-    end
-    
-    after { sync }
-    
-    it "forwards a GET request" do
-      get "/hello", {}
-      check_status 200
-      check_json [{
-        "host"      => "http://localhost:9001",
-        "status"    => 200,
-        "duration"  => an_instance_of(Fixnum),
-        "data"      => {"status" => "ok"}
-      }]
-    end
-    
-    it "forwards a GET request with path params" do
-      get "/users/jcoglan", {}
-      check_status 200
-      check_json [{
-        "host"      => "http://localhost:9001",
-        "status"    => 200,
-        "duration"  => an_instance_of(Fixnum),
-        "data"      => {"username" => "jcoglan"}
-      }]
-    end
-    
-    it "forwards a GET request with query string params" do
-      get "/search?q=foo", {}
-      check_status 200
-      check_json [{
-        "host"      => "http://localhost:9001",
-        "status"    => 200,
-        "duration"  => an_instance_of(Fixnum),
-        "data"      => {"query" => "foo"}
-      }]
-    end
-    
-    it "forwards a PUT request with entity body params" do
-      put "/blog", :title => "A new post"
-      check_status 200
-      check_json [{
-        "host"      => "http://localhost:9001",
-        "status"    => 201,
-        "duration"  => an_instance_of(Fixnum),
-        "data"      => {"title" => "A new post"}
-      }]
-    end
-    
-    it "returns an error response" do
-      get "/error", {}
-      check_status 200
-      check_json [{
-        "host"      => "http://localhost:9001",
-        "status"    => 503,
-        "duration"  => an_instance_of(Fixnum),
-        "data"      => {"error" => "down"}
-      }]
-    end
-  end
-  
-  describe "with a backend that's down" do
-    let :app do
-      Proxy.new("http://localhost:9000")
-    end
-    
-    before do
-      telecaster = Telecaster.new(:backends => ["http://localhost:9001"], :logger => logger)
-      boot telecaster, 9000
-    end
-    
-    after { sync }
-    
-    it "returns a response with no status" do
-      get "/hello", {}
-      check_status 200
-      check_json [{ "host" => "http://localhost:9001", "status" => nil }]
-    end
-  end
-  
-  describe "with multiple backends" do
-    let :app do
-      Proxy.new("http://localhost:9000")
-    end
-    
-    before do
-      hosts = (1..3).map { |n| "http://localhost:900#{n}" }
-      telecaster = Telecaster.new(:backends => hosts, :logger => logger)
-      
-      boot telecaster, 9000
-      
-      boot Responder, 9001
-      boot Blank,     9002
-      boot Error,     9003
-    end
-    
-    after { sync }
-    
-    it "returns the responses from the backends" do
-      get "/hello", {}
-      check_status 200
-      check_json [
-        { "host" => "http://localhost:9001", "status" => 200, "duration" => an_instance_of(Fixnum), "data" => {"status" => "ok"} },
-        { "host" => "http://localhost:9002", "status" => 200, "duration" => an_instance_of(Fixnum) },
-        { "host" => "http://localhost:9003", "status" => 404, "duration" => an_instance_of(Fixnum) }
-      ]
-    end
-    
-    describe "delegation" do
-      let :app do
-        Proxy.new("http://localhost:9005")
-      end
-      
-      before do
-        telecaster = Telecaster.new(:backends => [0,4].map { |n| "http://localhost:900#{n}" }, :logger => logger)
-        boot telecaster, 9005
-        
-        boot Slow, 9004
-      end
-      
-      it "aggregates responses from delegate servers" do
-        get "/hello", {}
-        check_status 200
-        check_json [
-          { "host" => "http://localhost:9001", "status" => 200, "duration" => an_instance_of(Fixnum), "data" => {"status" => "ok"} },
-          { "host" => "http://localhost:9002", "status" => 200, "duration" => an_instance_of(Fixnum) },
-          { "host" => "http://localhost:9003", "status" => 404, "duration" => an_instance_of(Fixnum) },
-          { "host" => "http://localhost:9004", "status" => 200, "duration" => an_instance_of(Fixnum) }
-        ]
-      end
-    end
-  end
-end
-

data/spec/telecaster_steps.rb

@@ -1,55 +0,0 @@
-TelecasterSteps = EM::RSpec.async_steps do
-  include Rack::Test::Methods
-  
-  def boot(application, port, &callback)
-    @apps ||= {}
-    @apps[port] = application
-    application.extend(ThinRunner)
-    application.start(port)
-    EM.next_tick(&callback)
-  end
-  
-  def stop_all_servers(&callback)
-    @apps.each_value { |app| app.stop }
-    EM.next_tick(&callback)
-  end
-  
-  %w[get post put delete].each do |method|
-    class_eval %Q{
-      def #{method}(path, params, &callback)
-        EM.defer {
-          super(path, params)
-          callback.call
-        }
-      end
-    }
-  end
-  
-  def check_status(status, &callback)
-    last_response.status.to_i.should == status
-    callback.call
-  end
-  
-  def check_json(json, &callback)
-    last_response['Content-Type'].should == 'application/json'
-    Yajl::Parser.parse(last_response.body).should == json
-    callback.call
-  end
-end
-
-require 'thin'
-Thin::Logging.silent = true
-
-module ThinRunner
-  def start(port)
-    handler = Rack::Handler.get('thin')
-    handler.run(self, :Port => port) do |server|
-      @server = server
-    end
-  end
-  
-  def stop
-    @server.stop
-  end
-end
-