firehose 0.0.16 → 0.1.0

data/.rspec

@@ -1 +1 @@
---colour
+--colour --backtrace

data/README.md

@@ -13,11 +13,11 @@ Firehose is both a Rack application and JavasScript library that makes building
 
 # Getting Started
 
-First, you'll need to install and run RabbitMQ.
+First, you'll need to install and run Redis.
 
 ```sh
-$ apt-get install rabbitmq    # Install on Ubuntu
-$ brew install rabbitmq       # Install on Mac Homebrew
+$ apt-get install redis       # Install on Ubuntu
+$ brew install redis          # Install on Mac Homebrew
 ```
 
 Then install the gem.
@@ -34,7 +34,7 @@ Now fire up the server.
 $ firehose server
 >> Thin web server (v1.3.1 codename Triple Espresso)
 >> Maximum connections set to 1024
->> Listening on 127.0.0.1:7478, CTRL+C to stop
+>> Listening on 127.0.0.1:7474, CTRL+C to stop
 ```
 
 In case you're wondering, the Firehose application server runs the Rack app `Firehose::Rack::App.new` inside of Thin.
@@ -87,15 +87,14 @@ new Firehose.Consumer({
   },
   // Note that we do NOT specify a protocol here because we don't
   // know that yet.
-  uri: '//localhost:7478/hello'
+  uri: '//localhost:7474/hello'
 }).connect();
 ```
 
 Then publish another message.
 
-
 ```sh
-$ curl -X PUT -d "This is almost magical" "http://localhost:7478/hello"
+$ curl -X PUT -d "\"This is almost magical\"" "http://localhost:7474/hello"
 ```
 
 # How is it different from socket.io?

data/firehose.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   s.add_runtime_dependency "eventmachine", ">= 1.0.0.beta"
-  s.add_runtime_dependency "amqp", ">= 0.9.4"
+  s.add_runtime_dependency "em-hiredis"
   s.add_runtime_dependency "thin"
   s.add_runtime_dependency "thor"
   s.add_runtime_dependency "faraday"

data/lib/firehose.rb

@@ -1,31 +1,16 @@
 require 'firehose/version'
 
-require 'amqp'
+require 'em-hiredis'
 require 'logger'
 
 module Firehose
   autoload :Subscription, 'firehose/subscription'
   autoload :Publisher,    'firehose/publisher'
   autoload :Producer,     'firehose/producer'
-  autoload :Consumer,     'firehose/consumer'
   autoload :Default,      'firehose/default'
-  autoload :Broker,       'firehose/broker'
   autoload :Rack,         'firehose/rack'
   autoload :CLI,          'firehose/cli'
 
-  # 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
-
   # Logging
   def self.logger
     @logger ||= Logger.new($stdout)

data/lib/firehose/cli.rb

@@ -8,27 +8,15 @@ module Firehose
     method_option :host, :type => :string, :default => '0.0.0.0', :required => true, :aliases => '-h'
 
     def server
-      broker = Firehose::Broker.new
-
       server = Thin::Server.new(options[:host], options[:port]) do
-        # TODO move this into a socket... this is really janky, but I need to to troubleshoot
-        # connection reference issues. I'd like to have this ancillary stuff accessiable via
-        # a different port or even a socket.
-        map '/_firehose/stats' do
-          run Proc.new {
-            [200, {'Content-Type' => 'text/plain'}, [broker.stats.inspect]]
-          }
-        end
-
-        map '/' do
-          run Firehose::Rack::App.new(broker)
-        end
+        run Firehose::Rack::App.new
       end
 
       begin
         server.start!
-      rescue AMQP::TCPConnectionFailed => e
-        Firehose.logger.error "Unable to connect to AMQP, are you sure it's running?"
+      rescue RuntimeError
+        Firehose.logger.error "Unable to connect to Redis, are you sure it's running?"
+        raise
       end
     end
   end

data/lib/firehose/publisher.rb

@@ -1,13 +1,13 @@
 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.
-      Firehose.logger.debug "AMQP publishing `#{message}` to `#{path}`"
-      exchange.publish(message)
-      exchange.delete(:if_unused => true)
+    def publish(channel, message)
+      Firehose.logger.debug "Redis publishing `#{message}` to `#{channel}`"
+      redis.publish(channel, message).errback { raise 'Error publishing' }
+    end
+
+  private
+    def redis
+      @redis ||= EM::Hiredis.connect
     end
   end
 end

data/lib/firehose/rack.rb

@@ -5,16 +5,14 @@ module Firehose
     AsyncResponse = [-1, {}, []]
 
     class HttpLongPoll
-      def initialize(broker)
-        @broker = broker
-      end
-
       def call(env)
         req     = ::Rack::Request.new(env)
         cid     = req.params['cid']
         path    = req.path
         method  = req.request_method
         timeout = 30
+        queue_name = "#{cid}@#{path}"
+
         # TODO seperate out CORS logic as an async middleware with a Goliath web server.
         cors_origin = env['HTTP_ORIGIN']
         cors_headers  = {
@@ -33,20 +31,23 @@ module Firehose
             response_headers = cors_origin ? cors_headers : {}
 
             # Setup a subscription with a client id. We haven't subscribed yet here.
-            consumer = @broker.consumer(cid)
+            if queue = queues[queue_name]
+              queue.live
+            else
+              queue = queues[queue_name] = Firehose::Subscription::Queue.new(cid, path)
+            end
 
             # Setup a timeout timer to tell clients that time out that everything is OK
             # and they should come back for more
-            timer = EventMachine::Timer.new(timeout) do
+            long_poll_timer = EM::Timer.new(timeout) do
               # We send a 204 OK to tell the client to reconnect.
               env['async.callback'].call [204, response_headers, []]
               Firehose.logger.debug "HTTP wait `#{cid}@#{path}` timed out"
             end
 
             # Ok, now subscribe to the subscription.
-            consumer.subscribe_to path do |message, subscription|
-              timer.cancel # Turn off the heart beat so we don't execute any of that business.
-              consumer.unsubscribe
+            queue.pop do |message, subscription|
+              long_poll_timer.cancel # Turn off the heart beat so we don't execute any of that business.
               env['async.callback'].call [200, response_headers, [message]]
               Firehose.logger.debug "HTTP sent `#{message}` to `#{cid}@#{path}`"
             end
@@ -55,7 +56,11 @@ module Firehose
             # Unsubscribe from the subscription if its still open and something bad happened
             # or the heart beat triggered before we could finish.
             env['async.close'].callback do
-              consumer.unsubscribe if consumer
+              # Kill queue if we don't hear back in 30s
+              queue.kill timeout do
+                Firehose.logger.debug "Deleting queue to `#{queue_name}`"
+                queues.delete queue_name
+              end
               Firehose.logger.debug "HTTP connection `#{cid}@#{path}` closing"
             end
           end
@@ -67,7 +72,7 @@ module Firehose
         when 'PUT'
           body = env['rack.input'].read
           Firehose.logger.debug "HTTP published `#{body}` to `#{path}`"
-          Firehose::Publisher.new.publish(path, body)
+          publisher.publish(path, body)
 
           [202, {}, []]
         else
@@ -75,23 +80,28 @@ module Firehose
           [501, {'Content-Type' => 'text/plain'}, ["#{method} not supported."]]
         end
       end
+
+    private 
+      def publisher
+        @publisher ||= Firehose::Publisher.new
+      end
+
+      def queues
+        @queues ||= {}
+      end
     end
 
     class WebSocket < ::Rack::WebSocket::Application
-      attr_reader :cid, :path
+      attr_reader :cid, :path, :subscription
       
-      def initialize(broker)
-        @broker = broker
-      end
-
       # 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, path)
 
-        @consumer = @broker.consumer(@cid)
-        @consumer.subscribe_to path do |message|
+        subscription.subscribe do |message, subscription|
           Firehose.logger.debug "WS sent `#{message}` to `#{cid}@#{path}`"
           send_data message
         end
@@ -100,37 +110,28 @@ module Firehose
 
       # Delete the subscription if the thing even happened.
       def on_close(env)
-        @consumer.unsubscribe if @consumer
+        subscription.unsubscribe
         Firehose.logger.debug "WS connection `#{cid}@#{path}` closing"
       end
 
       # Log websocket level errors
       def on_error(env, error)
-        Firehose.logger.error "WS connection `#{cid}@#{path}` error `#{error}`: #{env.inspect}"
-        @consumer.unsubscribe if @consumer
+        Firehose.logger.error "WS connection `#{cid}@#{path}` error `#{error}`: #{error.backtrace}"
       end
     end
 
     class App
-      # Firehose broker that will be used to pub/sub messages.
-      attr_reader :broker
-
-      # Fire up a default broker if one is not specified.
-      def initialize(broker = Firehose::Broker.new)
-        @broker = broker
-      end
-
       def call(env)
         websocket_request?(env) ? websocket.call(env) : http_long_poll.call(env)
       end
 
     private
       def websocket
-        @websocket ||= WebSocket.new(broker)
+        WebSocket.new
       end
 
       def http_long_poll
-        @http_long_poll ||= HttpLongPoll.new(broker)
+        @http_long_poll ||= HttpLongPoll.new
       end
 
       def websocket_request?(env)

data/lib/firehose/subscription.rb

@@ -1,65 +1,75 @@
 module Firehose
   class Subscription
-    # Default TTL for how long a subscription should live on the server when the
-    # consumer disconnects.
-    # TODO should the Consumer handle TTL?
-    TTL = 15000
-
-    # Time to live for the amqp_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
-
-    # Consumer and channel for the subscription.
-    attr_reader :consumer
+    # consumer_id and channel for the subscription.
+    attr_reader :consumer_id
 
     # Channel that we'll use for the pub-sub activity. This probably maps to an URL
     attr_reader :channel
 
-    def initialize(consumer, channel)
-      @consumer, @channel = consumer, channel
+    def initialize(consumer_id, channel)
+      @consumer_id, @channel = consumer_id, channel
     end
 
-    # TODO - Move the channel to an initializer so that we can force on AMQP subscription per one
-    # Firehose subscription. As it stands now, you could fire off multple subscriptions to diff amqp_channels
+    # Subscribe to messages on the backend to fill up the subscription queue. consumer_ids of the messages
+    # will queue up units of "work" to process data from the subscription.
     def subscribe(&block)
-      amqp_queue_name = "#{consumer.guid}@#{channel}"
-      amqp_channel    = AMQP::Channel.new(Firehose.amqp.connection).prefetch(1)
-      amqp_exchange   = AMQP::Exchange.new(amqp_channel, :fanout, channel, :auto_delete => true)
-      amqp_queue      = AMQP::Queue.new(amqp_channel, amqp_queue_name, :arguments => {'x-expires' => ttl})
-      amqp_queue.bind(amqp_exchange)
-
-      # When we get a message, we want to remove the consumer from the amqp_queue so that the x-expires
-      # ttl starts ticking down. On the reconnect, the consumer connects to the amqp_queue and resets the
-      # timer on x-expires... in theory at least.
-      @amqp_consumer = AMQP::Consumer.new(amqp_channel, amqp_queue, consumer.guid)
-      @amqp_consumer.on_delivery do |metadata, message|
-        Firehose.logger.debug "AMQP delivering `#{message}` to `#{consumer.guid}@#{channel}`"
-        block.call(message, self)
-        # The ack needs to go after the block is called. This makes sure that all processing
-        # happens downstream before we remove it from the amqp_queue entirely.
-        metadata.ack
-      end.consume
-      Firehose.logger.debug "AMQP subscribed to `#{consumer.guid}@#{channel}`"
+      redis.subscribe(channel)
+      redis.on(:message) do |channel, message|
+        Firehose.logger.debug "Redis recieved `#{message}` to `#{consumer_id}@#{channel}`"
+        block.call message, self
+      end
+      Firehose.logger.debug "Redis subscribed to `#{consumer_id}@#{channel}`"
       self # Return the subscription for chaining.
     end
 
-    def unsubscribe
-      Firehose.logger.debug "AMQP unsubscribed"
-      @amqp_consumer.cancel if @amqp_consumer
-      @unsubscribe_callback.call self if @unsubscribe_callback
+    def unsubscribe(&block)
+      Firehose.logger.debug "Redis unsubscribed from `#{consumer_id}@#{channel}`"
+      redis.close
+      block.call(self) if block
+      self
+    end
+
+  private
+    def redis
+      @redis ||= EM::Hiredis.connect
+    end
+  end
+
+  # Queue subscription messages so that we can remember and/or operate on them
+  class Subscription::Queue
+    attr_reader :subscription, :channel
+
+    def initialize(consumer_id, channel)
+      @subscription = Subscription.new(consumer_id, channel)
+      # Start the subscription and start dropping mesasge onto the queue
+      subscription.subscribe do |message|
+        queue.push message
+      end
+    end
+
+    # Pop an item off the subscription queue so we can work on it.
+    def pop(&block)
+      queue.pop do |message|
+        block.call message, subscription
+      end
+    end
+
+    # Kill the queue in n seconds.
+    def kill(ttl=0, &block)
+      if ttl.zero?
+        subscription.unsubscribe &block
+      else
+        @timer = EM::Timer.new(ttl){ kill 0 }
+      end
     end
 
-    # Callback when consumer unsubscribes from subscription. The consumer uses this to remove 
-    # subscriptions from itself when an unsubscribe happens.
-    def on_unsubscribe(&block)
-      @unsubscribe_callback = block
+    def live
+      @timer.cancel if @timer
     end
 
-    # The time that a amqp_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
+  private
+    def queue
+      @queue ||= EM::Queue.new
     end
   end
 end

data/lib/firehose/version.rb

@@ -1,4 +1,4 @@
 module Firehose
-  VERSION = "0.0.16"
-  CODENAME = "Statistical Sam"
+  VERSION = "0.1.0"
+  CODENAME = "Redis Rodeo"
 end

data/spec/integrations/thin_spec.rb

@@ -12,12 +12,11 @@ describe Firehose::Rack do
   end
 
   let(:app)       { Firehose::Rack::App.new }
-  let(:messages)  { (1..1000).map(&:to_s) }
+  let(:messages)  { (1..2000).map(&:to_s) }
   let(:channel)   { "/firehose/integration/#{Time.now.to_i}" }
   let(:uri)       { Firehose::Default::URI }
   let(:http_url)  { "http://#{uri.host}:#{uri.port}#{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
@@ -39,7 +38,7 @@ describe Firehose::Rack do
 
     # Lets have an HTTP Long poll client
     http_long_poll = Proc.new do
-      http = EM::HttpRequest.new(http_url).get(:query => {'cid' => cid})
+      http = EM::HttpRequest.new(http_url).get(:query => {'cid' => 'alpha'})
       http.errback { em.stop }
       http.callback do
         received_http << http.response
@@ -53,7 +52,7 @@ describe Firehose::Rack do
 
     # And test a web socket client too, at the same time.
     websocket = Proc.new do
-      ws = EventMachine::WebSocketClient.connect(ws_url)
+      ws = EventMachine::WebSocketClient.connect("#{ws_url}?cid=bravo")
       ws.errback  { em.stop }
       ws.stream do |msg|
         received_ws << msg
@@ -64,7 +63,8 @@ describe Firehose::Rack do
     # Great, we have all the pieces in order, lets run this thing in the reactor.
     em do
       # Start the server
-      ::Thin::Server.new('0.0.0.0', uri.port, app).start
+      server = ::Thin::Server.new('0.0.0.0', uri.port, app)
+      server.start
 
       # Start the http_long_pollr.
       http_long_poll.call
@@ -75,7 +75,7 @@ describe Firehose::Rack do
     end
 
     # When EM stops, these assertions will be made.
-    received_http.should  =~ messages
     received_ws.should    =~ messages
+    received_http.should  =~ messages
   end
 end

data/spec/lib/broker_spec.rb

@@ -1,30 +1,30 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe Firehose::Broker do
-  include EM::TestHelper
+# describe Firehose::Broker do
+#   include EM::TestHelper
 
-  let(:broker)  { Firehose::Broker.new }
+#   let(:broker)  { Firehose::Broker.new }
 
-  it "should unsubscibe consumers and remove them from the collection" do
-    stats = nil
+#   it "should unsubscibe consumers and remove them from the collection" do
+#     stats = nil
 
-    em do
-      broker.consumer('1').subscribe_to('/the-channel')
-      broker.consumer('2').subscribe_to('/the-channel')
-      broker.consumer('2').subscribe_to('/a-channel')
+#     em do
+#       broker.consumer('1').subscribe_to('/the-channel')
+#       broker.consumer('2').subscribe_to('/the-channel')
+#       broker.consumer('2').subscribe_to('/a-channel')
 
-      em.add_timer(1) do
-        stats = broker.stats
-        broker.stop
-        em.stop
-      end
-    end
+#       em.add_timer(1) do
+#         stats = broker.stats
+#         broker.stop
+#         em.stop
+#       end
+#     end
 
-    stats.should == {
-      '1' => {'subscriptions' => ['/the-channel'] },
-      '2' => {'subscriptions' => ['/the-channel', '/a-channel']}
-    }
+#     stats.should == {
+#       '1' => {'subscriptions' => ['/the-channel'] },
+#       '2' => {'subscriptions' => ['/the-channel', '/a-channel']}
+#     }
 
-    broker.stats.should == {}
-  end
-end
+#     broker.stats.should == {}
+#   end
+# end

data/spec/lib/consumer_spec.rb

@@ -1,66 +1,66 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe Firehose::Consumer do
-  include EM::TestHelper
+# describe Firehose::Consumer do
+#   include EM::TestHelper
 
-  let(:consumer)  { Firehose::Consumer.new }
-  let(:publisher) { Firehose::Publisher.new }
-  let(:channel)   { '/papa-smurf' }
-  let(:another_channel)  { '/mama-smurf' }
+#   let(:consumer)  { Firehose::Consumer.new }
+#   let(:publisher) { Firehose::Publisher.new }
+#   let(:channel)   { '/papa-smurf' }
+#   let(:another_channel)  { '/mama-smurf' }
 
-  describe "subscriptions" do
-    it "should subscribe to channel" do
-      sent, recieved = 'hi', nil
+#   describe "subscriptions" do
+#     it "should subscribe to channel" do
+#       sent, recieved = 'hi', nil
 
-      em do
-        consumer.subscribe_to channel do |msg|
-          recieved = msg
-          em.stop
-        end
-        em.add_timer(1) do
-          publisher.publish(channel, sent)
-        end
-      end
+#       em do
+#         consumer.subscribe_to channel do |msg|
+#           recieved = msg
+#           em.stop
+#         end
+#         em.add_timer(1) do
+#           publisher.publish(channel, sent)
+#         end
+#       end
 
-      recieved.should == sent
-    end
+#       recieved.should == sent
+#     end
 
-    it "should track subscriptions" do
-      lambda{
-        em do
-          consumer.subscribe_to channel
-          consumer.subscribe_to another_channel
-          em.add_timer(1){ em.stop }
-        end
-      }.should change{ consumer.subscriptions.size }.by(2)
-    end
+#     it "should track subscriptions" do
+#       lambda{
+#         em do
+#           consumer.subscribe_to channel
+#           consumer.subscribe_to another_channel
+#           em.add_timer(1){ em.stop }
+#         end
+#       }.should change{ consumer.subscriptions.size }.by(2)
+#     end
 
-    it "should only allow one subscription per channel" do
-      lambda{
-        em do
-          3.times { consumer.subscribe_to channel }
-          em.add_timer(1){ em.stop }
-        end
-      }.should change{ consumer.subscriptions.size }.by(1)
-    end
+#     it "should only allow one subscription per channel" do
+#       lambda{
+#         em do
+#           3.times { consumer.subscribe_to channel }
+#           em.add_timer(1){ em.stop }
+#         end
+#       }.should change{ consumer.subscriptions.size }.by(1)
+#     end
 
-    it "should unsubscribe from all channels" do
-      subscribed_count, after_unsubscribe_count = 0, nil
+#     it "should unsubscribe from all channels" do
+#       subscribed_count, after_unsubscribe_count = 0, nil
 
-      em do
-        consumer.subscribe_to channel
-        consumer.subscribe_to another_channel
-        subscribed_count = consumer.subscriptions.size
-        em.add_timer(1) do 
-          consumer.unsubscribe
-          em.add_timer(1) do 
-            em.stop
-          end
-        end
-      end
+#       em do
+#         consumer.subscribe_to channel
+#         consumer.subscribe_to another_channel
+#         subscribed_count = consumer.subscriptions.size
+#         em.add_timer(1) do 
+#           consumer.unsubscribe
+#           em.add_timer(1) do 
+#             em.stop
+#           end
+#         end
+#       end
 
-      subscribed_count.should == 2
-      consumer.subscriptions.size.should == 0
-    end
-  end
-end
+#       subscribed_count.should == 2
+#       consumer.subscriptions.size.should == 0
+#     end
+#   end
+# end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require 'logger'
 require 'em-http'
 require 'em-websocket-client'
 
+# Skip logging if VERBOSE isn't set to true.
 require 'firehose'
 Firehose.logger = Logger.new('/dev/null') unless ENV['VERBOSE']
 
@@ -37,8 +38,4 @@ 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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: firehose
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-04 00:00:00.000000000 Z
+date: 2012-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70349732213400 !ruby/object:Gem::Requirement
+  requirement: &70097385746880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,21 +22,21 @@ dependencies:
         version: 1.0.0.beta
   type: :runtime
   prerelease: false
-  version_requirements: *70349732213400
+  version_requirements: *70097385746880
 - !ruby/object:Gem::Dependency
-  name: amqp
-  requirement: &70349732212540 !ruby/object:Gem::Requirement
+  name: em-hiredis
+  requirement: &70097385746460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70349732212540
+  version_requirements: *70097385746460
 - !ruby/object:Gem::Dependency
   name: thin
-  requirement: &70349732211460 !ruby/object:Gem::Requirement
+  requirement: &70097385746000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70349732211460
+  version_requirements: *70097385746000
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &70349732210400 !ruby/object:Gem::Requirement
+  requirement: &70097385745580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,10 +55,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70349732210400
+  version_requirements: *70097385745580
 - !ruby/object:Gem::Dependency
   name: faraday
-  requirement: &70349732209120 !ruby/object:Gem::Requirement
+  requirement: &70097385745160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -66,10 +66,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70349732209120
+  version_requirements: *70097385745160
 - !ruby/object:Gem::Dependency
   name: websocket-rack
-  requirement: &70349732223780 !ruby/object:Gem::Requirement
+  requirement: &70097385744740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +77,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70349732223780
+  version_requirements: *70097385744740
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &70349732222860 !ruby/object:Gem::Requirement
+  requirement: &70097385744240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -88,10 +88,10 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *70349732222860
+  version_requirements: *70097385744240
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70349732221260 !ruby/object:Gem::Requirement
+  requirement: &70097385743820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -99,10 +99,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732221260
+  version_requirements: *70097385743820
 - !ruby/object:Gem::Dependency
   name: webmock
-  requirement: &70349732220520 !ruby/object:Gem::Requirement
+  requirement: &70097385743360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -110,10 +110,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732220520
+  version_requirements: *70097385743360
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &70349732219740 !ruby/object:Gem::Requirement
+  requirement: &70097385742940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -121,10 +121,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732219740
+  version_requirements: *70097385742940
 - !ruby/object:Gem::Dependency
   name: guard-bundler
-  requirement: &70349732219100 !ruby/object:Gem::Requirement
+  requirement: &70097385742520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -132,10 +132,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732219100
+  version_requirements: *70097385742520
 - !ruby/object:Gem::Dependency
   name: guard-coffeescript
-  requirement: &70349732218080 !ruby/object:Gem::Requirement
+  requirement: &70097385742100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -143,10 +143,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732218080
+  version_requirements: *70097385742100
 - !ruby/object:Gem::Dependency
   name: em-websocket-client
-  requirement: &70349732217260 !ruby/object:Gem::Requirement
+  requirement: &70097385741680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -154,7 +154,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70349732217260
+  version_requirements: *70097385741680
 description: Firehose is a realtime web application toolkit for building realtime
   Ruby web applications.
 email:
@@ -184,16 +184,13 @@ files:
 - lib/assets/javascripts/firehose/transport.js.coffee
 - lib/assets/javascripts/firehose/web_socket.js.coffee
 - lib/firehose.rb
-- lib/firehose/broker.rb
 - lib/firehose/cli.rb
-- lib/firehose/consumer.rb
 - lib/firehose/default.rb
 - lib/firehose/producer.rb
 - lib/firehose/publisher.rb
 - lib/firehose/rack.rb
 - lib/firehose/subscription.rb
 - lib/firehose/version.rb
-- spec/integrations/amqp_resources_spec.rb
 - spec/integrations/thin_spec.rb
 - spec/lib/broker_spec.rb
 - spec/lib/consumer_spec.rb
@@ -225,7 +222,6 @@ signing_key:
 specification_version: 3
 summary: Build realtime Ruby web applications
 test_files:
-- spec/integrations/amqp_resources_spec.rb
 - spec/integrations/thin_spec.rb
 - spec/lib/broker_spec.rb
 - spec/lib/consumer_spec.rb

data/lib/firehose/broker.rb

@@ -1,34 +0,0 @@
-module Firehose
-  # TODO add support to broker for publishing, then abstract this out into a backend. A
-  # broker will eventually be passed into a web server front-end to serve up the web requests.
-  class Broker
-    def consumers
-      @consumers ||= Hash.new do |consumers, consumer_id|
-        consumer = Firehose::Consumer.new(consumer_id)
-        consumer.on_unsubscribe do
-          consumers.delete consumer_id
-        end
-        consumers[consumer_id] = consumer
-      end
-    end
-
-    # Don't like the [] syntax to get at consumers? No worries mate!
-    def consumer(consumer_id)
-      consumers[consumer_id]
-    end
-
-    # Gracefully unsubscribe all of the consumers and get rid of them from the consumers 
-    # collection.
-    def stop
-      consumers.values.each(&:unsubscribe)
-    end
-
-    # Returns a hash of the connected consumers with the number of their subscriptions
-    def stats
-      consumers.inject({}) do |memo, (consumer_id, consumer)|
-        memo[consumer_id] = { 'subscriptions' => consumer.subscriptions.keys }
-        memo
-      end
-    end
-  end
-end

data/lib/firehose/consumer.rb

@@ -1,49 +0,0 @@
-module Firehose
-  class Consumer
-    # Unique identifier for a consumer. Note that a consumer does not map directly to
-    # a user_id. In a web browser world, you might have a user with multiple tabs open,
-    # so you'll went to send each users tab a seperate message stream. Consider a convention
-    # such as :user_id-:guid for your application.
-    attr_reader :guid
-
-    def initialize(guid = self.class.next_guid)
-      @guid = guid
-    end
-
-    # Create a subscription and subscribe to a channel.
-    def subscribe_to(channel, &block)
-      subscriptions[channel].subscribe(&block)
-    end
-
-    # Active subscriptions to the backend.
-    def subscriptions
-      @subscriptions ||= Hash.new do |subscriptions, channel|
-        # Setup the hash to generate subscriptions that can delete themselves from
-        # their own collection on an unsubscription event.
-        subscription = Subscription.new(self, channel)
-        subscription.on_unsubscribe do
-          # Remove the subscription from the consumer.subscriptions 
-          # list when unsubscribe.
-          subscriptions.delete channel
-        end
-        subscriptions[channel] = subscription
-      end
-    end
-
-    # Unsubscribe from all subscriptions.
-    def unsubscribe
-      subscriptions.values.each(&:unsubscribe)
-      @on_unsubscribe.call(self) if @on_unsubscribe
-    end
-
-    # Define callback for when unsubscribe is called from the consumer.
-    def on_unsubscribe(&block)
-      @on_unsubscribe = block
-    end
-
-  protected
-    def self.next_guid
-      rand(999_999_999_999).to_s
-    end
-  end
-end

data/spec/integrations/amqp_resources_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe "Firehose amqp resources" do
-
-  let(:channel)   { "/resource-test-#{Time.now.to_i}" }
-  let(:consumer)  { Firehose::Consumer.new }
-
-  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(consumer, channel)
-      subscription.ttl = 1
-
-      subscription.subscribe 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