firehose 0.0.3

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.DS_Store
+Gemfile.lock
+log/*
+pkg/*

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p125

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem 'goliath', :git => 'git://github.com/postrank-labs/goliath.git'
+# Specify your gem's dependencies in firehose.gemspec
+gemspec

data/Procfile

@@ -0,0 +1 @@
+firehose: bundle exec thin -p $PORT -R config.ru --debug start

data/README.md

@@ -0,0 +1,105 @@
+      __ _          _                    
+     / _(_)        | |                   
+    | |_ _ _ __ ___| |__   ___  ___  ___ 
+    |  _| | '__/ _ \ '_ \ / _ \/ __|/ _ \
+    | | | | | |  __/ | | | (_) \__ \  __/
+    |_| |_|_|  \___|_| |_|\___/|___/\___|
+    
+    Build Realtime web applications in Ruby
+
+# What is Firehose?
+
+Firehose is both a Rack application and JavasSript library that makes building scalable real-time web applications possible.
+
+# How is it different from socket.io?
+
+socket.io attempts to store connection state per node instance. Firehose makes no attempt to store connection state.
+
+Also, socket.io attempts to abstract a low-latency full-duplex port. Firehose assumes that its impossible to simulate this in older web browsers that don't support WebSockets. As such, Firehose focuses on low-latency server-to-client connections and encourages the use of HTTP transports for client-to-server communications.
+
+Finally, firehose attempts to solve data consistency issues and authentication by encourage the use of proxying to the web application.
+
+# Getting Started
+
+First, you'll need to install and run RabbitMQ.
+
+```
+apt-get install rabbitmq    # Install on Ubuntu
+brew install rabbitmq       # Install on Mac Homebrew
+```
+
+## The Consumer
+
+The consumer is the web server that your client connects to for real-time updates. Create a config.ru file with the following:
+
+```ruby
+require 'rubygems'
+require 'firehose'
+
+run Firehose::Transport::Dispatcher.new do |config|
+  config.timeout = 20
+  
+  # Extract the consumer ID from the HTTP session. This could be a cookie
+  # query param, or whatever.
+  config.consumer = Proc.new do |env|
+    Firehose::Consumer.new(env['HTTP_CONSUMER_ID'])
+  end
+  
+  # Use the /url/path for the queue channel. You could change this to a query
+  # param, or whatever
+  config.channel = Proc.new do |env|
+    env['PATH_INFO']
+  end
+end
+```
+
+Now run the config.ru file in a server that supports async Rack callbacks (like thin or rainbows)
+
+```ruby
+thin -R config.ru -p 4000 start
+```
+
+## The Producer
+
+Lets test the producer! Open two terminal windows. In one window, curl the consumer server:
+
+```sh
+curl "http://localhost:4000/"
+```
+
+Then run the following script in another terminal:
+
+```ruby
+require 'rubygems'
+require 'firehose'
+
+Firehose::Producer.new.publish('hi there!').to('/greetings')
+```
+
+## JavaScript Client
+
+Then in your browser create a new Firehose Client object as such:
+
+```javascript
+new Firehose.Client()
+  .url({
+    websocket: 'ws://some_websocket_url.com',
+    longpoll:  'http://some_longpoll_url.com'
+  })
+  .params({
+    cid: '024023948234'
+  })
+  .options({
+    timeout: 5000
+  })
+  .message(function(msg){
+    alert(msg); // Fires when a message is received from the server.
+  })
+  .connected(function(){
+    alert('Howdy friend!');
+  })
+  .disconnected(function(){
+    alert('Bu bye');
+  })
+  .connect()
+```

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new

data/bin/firehose

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'firehose'

data/bin/firehose-test

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../..', __FILE__)
+
+require 'rubygems'
+require 'test/long_poll_test'

data/config.ru

@@ -0,0 +1,6 @@
+require 'firehose'
+require 'rack'
+
+use Rack::Reloader
+
+run Firehose::Rack::App.new

data/firehose.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "firehose/version"
+
+Gem::Specification.new do |s|
+  s.name        = "firehose"
+  s.version     = Firehose::VERSION
+  s.authors     = ["Brad Gessler"]
+  s.email       = ["brad@bradgessler.com"]
+  s.homepage    = ""
+  s.summary     = %q{Build realtime Ruby web applications}
+  s.description = %q{Firehose is a realtime web application toolkit for building realtime Ruby web applications.}
+
+  s.rubyforge_project = "firehose"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+#  s.add_runtime_dependency "goliath", "=> 0.9.4"
+  s.add_runtime_dependency "eventmachine", ">= 1.0.0.beta"
+  s.add_runtime_dependency "amqp", ">= 0.9.4"
+  s.add_runtime_dependency "thin"
+  s.add_runtime_dependency "websocket-rack"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-bundler"
+  s.add_development_dependency "thin"
+  # em-http dropped support for WS as of version 1.0+ (https://github.com/igrigorik/em-http-request/issues/164)
+  s.add_development_dependency "em-http-request", "~> 0.3.0" 
+  s.add_development_dependency "guard-coffeescript"
+end

data/lib/firehose.rb

@@ -0,0 +1,23 @@
+require 'firehose/version'
+
+require 'amqp'
+
+module Firehose
+  autoload :Subscription, 'firehose/subscription'
+  autoload :Publisher,    'firehose/publisher'
+  autoload :Goliath,      'firehose/goliath'
+  autoload :Rack,         'firehose/rack'
+
+  # TODO move this into a configuration or session class.
+  # Hang on to AMQP configuration settings.
+  def self.amqp
+    @amqp ||= Struct.new(:connection).new(AMQP.connect)
+  end
+
+  # TODO figure out a better way to memoize AMQP connection for production runtimes, and 
+  # make it resetable for testing environment. Some sort of Firehose::Session object is probably
+  # in order
+  def self.reset!
+    @amqp = nil
+  end
+end

data/lib/firehose/goliath.rb

@@ -0,0 +1,69 @@
+require 'goliath'
+require 'goliath/websocket'
+
+module Firehose
+  module Goliath
+    class WebSocket < ::Goliath::WebSocket
+      use ::Goliath::Rack::Params
+
+      def on_open(env)
+        # TODO Fix the Firehose::App app to not need '/ws' in front of the socket.
+        path    = env['REQUEST_PATH'].gsub(/^\/ws/, '') # Name of the queue in AMQP we'll be pulling from.
+        cid     = params[:cid]
+
+        @subscription = Firehose::Subscription.new(cid)
+        @subscription.subscribe path do |payload|
+          env.stream_send(payload)
+        end
+      end
+
+      def on_close(env)
+        @subscription.unsubscribe if @subscription
+      end
+    end
+
+    class LongPolling < ::Goliath::API
+      use ::Goliath::Rack::Params
+
+      def response(env)
+        method  = env['REQUEST_METHOD'] # We use this to figure out if we're producing or consuming.
+        path    = env['REQUEST_PATH'] # Name of the queue in AMQP we'll be pulling from.
+        cid     = params[:cid]
+
+        case method
+        # GET is how clients subscribe to the queue. When a messages comes in, we flush out a response,
+        # close down the requeust, and the client then reconnects.
+        when 'GET'
+          subscription = Firehose::Subscription.new(cid)
+          subscription.subscribe path do |payload|
+            subscription.unsubscribe
+            env.chunked_stream_send(payload)
+            env.chunked_stream_close
+          end
+          chunked_streaming_response(200, 'Content-Type' => 'text/plain')
+        # PUT is how we throw messages on to the fan-out queue.
+        when 'PUT'
+          body = env['rack.input'].read
+          p [:put, path, body]
+          Firehose::Publisher.new.publish(path, body)
+
+          [202, {}, []]
+        else
+          [501, {}, ["#{method} not supported."]]
+        end
+      end
+
+    private
+      def self.connection
+        @connection ||= AMQP.connect
+      end
+    end
+
+    class App < ::Goliath::API
+      # TODO Figure out how to route this on schema (ws) or HTTP_UGPRADE header... it 
+      # all uses HTTP router under the covers, so it should be doable.
+      map '/ws/*',  WebSocket
+      map '/*',     LongPolling
+    end
+  end
+end

data/lib/firehose/http_publisher.rb

@@ -0,0 +1,32 @@
+require "net/http"
+require "uri"
+
+module Firehose
+  class HttpPublisher
+    attr_reader :uri
+
+    class RequestBuilder
+      attr_reader :uri, :message, :channel
+
+      def initialize(uri, message)
+        @uri, @message = uri, message
+      end
+
+      def to(channel)
+        req = Net::HTTP::Put.new(channel)
+        req.body = message
+        res = Net::HTTP.start(uri.host, uri.port) do |http|
+          response = http.request(req)
+        end
+      end
+    end
+
+    def initialize(uri)
+      @uri = URI.parse(uri)
+    end
+
+    def publish(message)
+      RequestBuilder.new(uri, message)
+    end
+  end
+end

data/lib/firehose/publisher.rb

@@ -0,0 +1,12 @@
+module Firehose
+  class Publisher
+    def publish(path, message)
+      channel   = AMQP::Channel.new(Firehose.amqp.connection)
+      exchange  = AMQP::Exchange.new(channel, :fanout, path, :auto_delete => true)
+      # TODO How do I clean up this exchange at this point? Do I close it somehow or the channel?
+      # The exchange just hangs out indefinitely now.
+      exchange.publish(message)
+      exchange.delete(:if_unused => true)
+    end
+  end
+end

data/lib/firehose/rack.rb

@@ -0,0 +1,76 @@
+require 'rack/websocket'
+
+module Firehose
+  module Rack
+    AsyncResponse = [-1, {}, []]
+
+    class HttpLongPoll
+      def call(env)
+        req     = ::Rack::Request.new(env)
+        cid     = req.params['cid']
+        path    = req.path
+        method  = req.request_method
+
+        case method
+        # GET is how clients subscribe to the queue. When a messages comes in, we flush out a response,
+        # close down the requeust, and the client then reconnects.
+        when 'GET'
+          EM.next_tick do
+            subscription = Firehose::Subscription.new(cid)
+            subscription.subscribe path do |payload|
+              subscription.unsubscribe
+              env['async.callback'].call([200, {}, [payload]])
+            end
+          end
+
+          Firehose::Rack::AsyncResponse
+
+        # PUT is how we throw messages on to the fan-out queue.
+        when 'PUT'
+          body = env['rack.input'].read
+          p [:put, path, body]
+          Firehose::Publisher.new.publish(path, body)
+
+          [202, {}, []]
+        else
+          [501, {}, ["#{method} not supported."]]
+        end
+      end
+    end
+
+    class WebSocket < ::Rack::WebSocket::Application
+      # Subscribe to a path and make some magic happen, mmkmay?
+      def on_open(env)
+        req   = ::Rack::Request.new(env)
+        cid   = req.params['cid']
+        path  = req.path
+
+        @subscription = Firehose::Subscription.new(cid)
+        @subscription.subscribe path do |payload|
+          send_data payload
+        end
+      end
+
+      # Delete the subscription if the thing even happened.
+      def on_close(env)
+        @subscription.unsubscribe if @subscription
+      end
+
+      # Log websocket level errors
+      def on_error(env, error)
+        @subscription.unsubscribe if @subscription
+      end
+    end
+
+    class App
+      def call(env)
+        websocket_request?(env) ? WebSocket.new.call(env) : HttpLongPoll.new.call(env)
+      end
+
+    private
+      def websocket_request?(env)
+        env['HTTP_UPGRADE'] =~ /websocket/i
+      end
+    end
+  end
+end

data/lib/firehose/subscription.rb

@@ -0,0 +1,54 @@
+require 'securerandom'
+
+module Firehose
+  class Subscription
+    TTL = 15000
+
+    # Time to live for the queue on the server after the subscription is canceled. This
+    # is mostly for flakey connections where the client may reconnect after *ttl* and continue
+    # receiving messages.
+    attr_accessor :ttl
+
+    # Globally unique subscription id
+    attr_reader :subscriber_id
+
+    def initialize(subscriber_id=nil)
+      @subscriber_id = subscriber_id || self.class.subscriber_id
+    end
+
+    def subscribe(path, &block)
+      queue_name  = "#{subscriber_id}@#{path}"
+      channel     = AMQP::Channel.new(Firehose.amqp.connection).prefetch(1)
+      exchange    = AMQP::Exchange.new(channel, :fanout, path, :auto_delete => true)
+      queue       = AMQP::Queue.new(channel, queue_name, :arguments => {'x-expires' => ttl})
+      queue.bind(exchange)
+
+      # When we get a message, we want to remove the consumer from the queue so that the x-expires
+      # ttl starts ticking down. On the reconnect, the consumer connects to the queue and resets the
+      # timer on x-expires... in theory at least.
+      @consumer = AMQP::Consumer.new(channel, queue, subscriber_id)
+      @consumer.on_delivery do |metadata, payload|
+        p [:get, subscriber_id, @consumer.consumer_tag, path, payload]
+        block.call(payload)
+        # The ack needs to go after the block is called. This makes sure that all processing
+        # happens downstream before we remove it from the queue entirely.
+        metadata.ack
+      end.consume
+    end
+
+    def unsubscribe
+      @consumer.cancel if @consumer
+    end
+
+    # The time that a queue should live *after* the client unsubscribes. This is useful for
+    # flakey network connections, like HTTP Long Polling or even broken web sockets.
+    def ttl
+      @ttl ||= TTL
+    end
+
+  protected
+    def self.subscriber_id
+      SecureRandom.uuid
+    end
+  end
+end

data/lib/firehose/thin.rb

@@ -0,0 +1,7 @@
+require 'thin'
+require 'thin/websockets'
+
+module Firehose
+  module Thin
+  end
+end

data/lib/firehose/version.rb

@@ -0,0 +1,3 @@
+module Firehose
+  VERSION = "0.0.3"
+end

data/spec/integrations/amqp_resources_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "Firehose amqp resources" do
+
+  let(:channel) { "/resource-test-#{Time.now.to_i}" }
+
+  it "should clean up exchanges and queues" do
+    sent, received = 'howdy!', nil
+    
+    before_exchange_count = `rabbitmqctl list_exchanges`.lines.count
+    before_queue_count    = `rabbitmqctl list_queues`.lines.count
+
+    during_exchange_count = nil
+    during_queue_count    = nil
+
+    EM.run do
+      # Kill test if it runs longer than 5s
+      EM.add_timer(5) { EM.stop }
+
+      subscription = Firehose::Subscription.new
+      subscription.ttl = 1
+
+      subscription.subscribe channel do |payload|
+        received = payload
+        subscription.unsubscribe
+
+        during_exchange_count = `rabbitmqctl list_exchanges`.lines.count
+        during_queue_count = `rabbitmqctl list_queues`.lines.count
+
+        # I wait 1 second before killing em so that unsubscribe
+        # can talk to AMQP before the whole thing dies.
+        EM.add_timer(1){ EM.stop }
+      end
+
+      # Let the subscriber subscribe before publishing messages.
+      EM.add_timer(1){ Firehose::Publisher.new.publish(channel, sent) }
+    end
+
+    after_exchange_count = `rabbitmqctl list_exchanges`.lines.count
+    after_queue_count =    `rabbitmqctl list_queues`.lines.count
+
+    received.should == sent
+
+    after_exchange_count.should == before_exchange_count
+    after_queue_count.should    == before_queue_count
+
+    during_exchange_count.should == before_exchange_count + 1
+    during_queue_count.should    == before_queue_count + 1
+  end
+end

data/spec/integrations/goliath_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'goliath'
+require 'em-http'
+
+describe Firehose::Goliath do
+  let(:app)       { Firehose::Goliath::App.new }
+  let(:messages)  { (1..1000).map(&:to_s) }
+  let(:channel)   { "/firehose/integration/#{Time.now.to_i}" }
+  let(:uri)       { URI.parse('http://127.0.0.1:9876') }
+  let(:url)       { "#{uri}#{channel}" }
+  let(:cid)       { "client-#{Time.now.to_i}" }
+
+  it "should pub-sub" do
+    outgoing, received = messages.dup, []
+
+    Goliath.env = :production
+    server = Goliath::Server.new
+    server.address  = uri.host
+    server.port     = uri.port
+    server.api      = app
+    server.app      = Goliath::Rack::Builder.build(Firehose::Goliath::App, server.api)
+    server.logger   = Log4r::Logger.new('goliath')
+
+    server.start do
+      EM.add_timer(30) { EM.stop } # Stop the server no matter what happens.
+
+      publish = Proc.new do
+        http = EM::HttpRequest.new(url).put(:body => outgoing.pop)
+        http.errback  { EM.stop }
+        http.callback { publish.call unless outgoing.empty? }
+      end
+
+      subscribe = Proc.new do
+        http = EM::HttpRequest.new(url).get(:query => {'cid' => cid})
+        http.errback { EM.stop }
+        http.callback do
+          received << http.response
+          if received.size < messages.size
+            subscribe.call
+          else
+            EM.stop
+          end
+        end
+      end
+
+      # Start the subscriber.
+      subscribe.call
+
+      # Wait a sec to let our subscribe setup.
+      EM.add_timer(1){ publish.call }
+    end
+
+    received.should =~ messages
+  end
+end

data/spec/integrations/thin_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'thin'
+require 'em-http'
+
+describe Firehose::Rack do
+  let(:app)       { Firehose::Rack::App.new }
+  let(:messages)  { (1..1000).map(&:to_s) }
+  let(:channel)   { "/firehose/integration/#{Time.now.to_i}" }
+  let(:uri)       { URI.parse('http://127.0.0.1:9876') }
+  let(:url)       { "#{uri}#{channel}" }
+  let(:ws_url)    { "ws://#{uri.host}:#{uri.port}#{channel}" }
+  let(:cid)       { "client-#{Time.now.to_i}" }
+
+  it "should pub-sub http and websockets" do
+    # Setup variables that we'll use after we turn off EM to validate our
+    # test assertions.
+    outgoing, received_http, received_ws = messages.dup, [], []
+
+    # Our WS and Http clients call this when they have received their messages to determine
+    # when to turn off EM and make the test assertion at the very bottom.
+    succeed = Proc.new do
+      EM.stop if received_http.size == messages.size and received_ws.size == messages.size
+    end
+
+    # Setup a publisher
+    publish = Proc.new do
+      http = EM::HttpRequest.new(url).put(:body => outgoing.pop)
+      http.errback  { EM.stop }
+      http.callback { publish.call unless outgoing.empty? }
+    end
+
+    # Lets have an HTTP Long poll client
+    http_long_poll = Proc.new do
+      http = EM::HttpRequest.new(url).get(:query => {'cid' => cid})
+      http.errback { EM.stop }
+      http.callback do
+        received_http << http.response
+        if received_http.size < messages.size
+          http_long_poll.call
+        else
+          succeed.call
+        end
+      end
+    end
+
+    # And test a web socket client too, at the same time.
+    websocket = Proc.new do
+      http = EventMachine::HttpRequest.new(ws_url).get
+      http.errback  { EM.stop }
+      http.stream do |msg|
+        received_ws << msg
+        succeed.call unless received_ws.size < messages.size
+      end
+    end
+
+    # Great, we have all the pieces in order, lets run this thing in the reactor.
+    EM.run do
+      # Stop the server no matter what happens.
+      EM.add_timer(30) { EM.stop }
+
+      # Start the server
+      ::Thin::Server.new(uri.host, uri.port, app).start
+
+      # Start the http_long_pollr.
+      http_long_poll.call
+      websocket.call
+
+      # Wait a sec to let our http_long_poll setup.
+      EM.add_timer(1){ publish.call }
+    end
+
+    # When EM stops, these assertions will be made.
+    received_http.should  =~ messages
+    received_ws.should    =~ messages
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'firehose'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.before(:each) do
+    # For now, this resets the AMQP configuration between runs.
+    Firehose.reset!
+  end
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: firehose
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Brad Gessler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70282339770020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282339770020
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: &70282339769280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282339769280
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &70282339768720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282339768720
+- !ruby/object:Gem::Dependency
+  name: websocket-rack
+  requirement: &70282339768120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70282339768120
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70282339767660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339767660
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70282339767140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339767140
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70282339766600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339766600
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: &70282339765920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339765920
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &70282339752660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339752660
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: &70282339751820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *70282339751820
+- !ruby/object:Gem::Dependency
+  name: guard-coffeescript
+  requirement: &70282339750760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70282339750760
+description: Firehose is a realtime web application toolkit for building realtime
+  Ruby web applications.
+email:
+- brad@bradgessler.com
+executables:
+- firehose
+- firehose-test
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-version
+- .rspec
+- Gemfile
+- Procfile
+- README.md
+- Rakefile
+- bin/firehose
+- bin/firehose-test
+- config.ru
+- firehose.gemspec
+- lib/assets/flash/WebSocketMain.swf
+- lib/firehose.rb
+- lib/firehose/goliath.rb
+- lib/firehose/http_publisher.rb
+- lib/firehose/publisher.rb
+- lib/firehose/rack.rb
+- lib/firehose/subscription.rb
+- lib/firehose/thin.rb
+- lib/firehose/version.rb
+- spec/integrations/amqp_resources_spec.rb
+- spec/integrations/goliath_spec.rb
+- spec/integrations/thin_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: firehose
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Build realtime Ruby web applications
+test_files:
+- spec/integrations/amqp_resources_spec.rb
+- spec/integrations/goliath_spec.rb
+- spec/integrations/thin_spec.rb
+- spec/spec_helper.rb