message_bus 0.9.3.2 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc56c6496f2994b9144a4c546d588784d5d8f818
-  data.tar.gz: e6ffaf32700df3a6628fa858ba24596c898a3dc5
+  metadata.gz: bd00357fe6b7e4663c46c3c34c74a5d8529433c5
+  data.tar.gz: df3641a9d63749c6035ecd0b45d656bd53361e4d
 SHA512:
-  metadata.gz: 470786eff06753a648d739f4af5b45175139fb3d2a3bae53660d139cfb2768fe8c2272fec7c1b4b2163d95b1d246a3f53300262c2044baa9894ffa7843531228
-  data.tar.gz: b980a483a53b5665f83b36db886a2e8566ab2900b9a5d021ece1373afbb3812649c7254f0228a2d0a52a80ab793d60eca83b66a826fbb97ffafb67b878a60e9b
+  metadata.gz: c08c802702acc7c30db0c3ebfb1c0949644553b7fc6a63330a8f260d414a350e94c2fb40143bd3956a068eda1a8e764e3fc3f858568bedb5075d25d82392185d
+  data.tar.gz: 41c4d7584df49be995a21495841d63d65998aab5582c5ec6987fc620f86b995cc632e505fa641558c15568d8e6545075d075f4eec1c6501ad21fc4563220dc99

data/CHANGELOG

@@ -1,3 +1,11 @@
+13-01-2014
+- Version 0.9.4
+- Added support for /global/ channel to publish messages across a multisite
+- Cleaned up test harness so it uses local bus as opposed to global
+- Fix bug where we could subscribe to a channel but miss starting messages
+- Added method for destroying a local MessageBus instance
+- ensure_reactor could say the reactor is running, but it was not, on first call
+
 06-12-2013
 - Version 0.9.3.2
 - Fix permissions in gem

data/Guardfile

@@ -1,4 +1,4 @@
-guard 'rspec', :focus_on_failed => true do
+guard 'rspec' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }

data/README.md

@@ -60,6 +60,23 @@ end
 
 ```
 
+### Multisite support
+
+MessageBus can be used in an environment that hosts multiple sites by multiplexing channels. To use this mode
+
+```
+# define a site_id lookup method
+MessageBus.site_id_lookup do
+  some_method_that_returns_site_id_string
+end
+
+# you may post messages just to this site
+MessageBus.publish "/channel", "some message"
+
+# you may publish messages to ALL sites using the /global/ prefix
+MessageBus.publish "/global/channel", "will go to all sites"
+```
+
 JavaScript can listen on any channel (and receive notification via polling or long polling):
 
 ```html

data/assets/message-bus.js

@@ -119,6 +119,7 @@ window.MessageBus = (function() {
       },
       success: function(messages) {
         failCount = 0;
+        if (messages === null) return; // server unexpectedly closed connection
         $.each(messages,function(_,message) {
           gotData = true;
           $.each(callbacks, function(_,callback) {

data/examples/minimal/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'message_bus'

data/examples/minimal/config.ru

@@ -0,0 +1,7 @@
+require 'message_bus'
+
+#MessageBus.long_polling_interval = 1000 * 2
+
+use MessageBus::Rack::Middleware
+run lambda { |env| [200, {"Content-Type" => "text/html"}, ["Howdy"]]  }
+

data/lib/message_bus.rb

@@ -12,6 +12,7 @@ require "message_bus/message_handler"
 require "message_bus/diagnostics"
 require "message_bus/rack/middleware"
 require "message_bus/rack/diagnostics"
+require "monitor.rb"
 
 # we still need to take care of the logger
 if defined?(::Rails)
@@ -19,8 +20,20 @@ if defined?(::Rails)
 end
 
 module MessageBus; end
+class MessageBus::InvalidMessage < Exception; end
+class MessageBus::BusDestroyed < Exception; end
+
 module MessageBus::Implementation
 
+  # Like Mutex but safe for recursive calls
+  class Synchronizer
+    include MonitorMixin
+  end
+
+  def initialize
+    @mutex = Synchronizer.new
+  end
+
   def cache_assets=(val)
     @cache_assets = val
   end
@@ -164,7 +177,10 @@ module MessageBus::Implementation
   end
 
   def reliable_pub_sub
-    @reliable_pub_sub ||= MessageBus::ReliablePubSub.new redis_config
+    @mutex.synchronize do
+      return nil if @destroyed
+      @reliable_pub_sub ||= MessageBus::ReliablePubSub.new redis_config
+    end
   end
 
   def enable_diagnostics
@@ -173,6 +189,9 @@ module MessageBus::Implementation
 
   def publish(channel, data, opts = nil)
     return if @off
+    @mutex.synchronize do
+      raise ::MessageBus::BusDestroyed if @destroyed
+    end
 
     user_ids = nil
     group_ids = nil
@@ -181,6 +200,8 @@ module MessageBus::Implementation
       group_ids = opts[:group_ids]
     end
 
+    raise ::MessageBus::InvalidMessage if (user_ids || group_ids) && global?(channel)
+
     encoded_data = JSON.dump({
       data: data,
       user_ids: user_ids,
@@ -202,7 +223,7 @@ module MessageBus::Implementation
 
   # encode channel name to include site
   def encode_channel_name(channel)
-    if site_id_lookup
+    if site_id_lookup && !global?(channel)
       raise ArgumentError.new channel if channel.include? ENCODE_SITE_TOKEN
       "#{channel}#{ENCODE_SITE_TOKEN}#{site_id_lookup.call}"
     else
@@ -229,7 +250,7 @@ module MessageBus::Implementation
 
   # subscribe only on current site
   def local_subscribe(channel=nil, &blk)
-    site_id = site_id_lookup.call if site_id_lookup
+    site_id = site_id_lookup.call if site_id_lookup && ! global?(channel)
     subscribe_impl(channel, site_id, &blk)
   end
 
@@ -238,7 +259,7 @@ module MessageBus::Implementation
       if channel
         reliable_pub_sub.backlog(encode_channel_name(channel), last_id)
       else
-        reliable_pub_sub.global_backlog(encode_channel_name(channel), last_id)
+        reliable_pub_sub.global_backlog(last_id)
       end
 
     old.each{ |m|
@@ -247,14 +268,26 @@ module MessageBus::Implementation
     old
   end
 
-
   def last_id(channel)
     reliable_pub_sub.last_id(encode_channel_name(channel))
   end
 
+  def last_message(channel)
+    if last_id = last_id(channel)
+      messages = backlog(channel, last_id-1)
+      if messages
+        messages[0]
+      end
+    end
+  end
 
   def destroy
-    reliable_pub_sub.global_unsubscribe
+    @mutex.synchronize do
+      @subscriptions ||= {}
+      reliable_pub_sub.global_unsubscribe
+      @destroyed = true
+    end
+    @subscriber_thread.join if @subscriber_thread
   end
 
   def after_fork
@@ -262,8 +295,21 @@ module MessageBus::Implementation
     ensure_subscriber_thread
   end
 
+  def listening?
+    @subscriber_thread && @subscriber_thread.alive?
+  end
+
+  # will reset all keys
+  def reset!
+    reliable_pub_sub.reset!
+  end
+
   protected
 
+  def global?(channel)
+    channel && channel.start_with?('/global/'.freeze)
+  end
+
   def decode_message!(msg)
     channel, site_id = decode_channel_name(msg.channel)
     msg.channel = channel
@@ -275,15 +321,27 @@ module MessageBus::Implementation
   end
 
   def subscribe_impl(channel, site_id, &blk)
+
+    raise MessageBus::BusDestroyed if @destroyed
+
     @subscriptions ||= {}
     @subscriptions[site_id] ||= {}
     @subscriptions[site_id][channel] ||=  []
     @subscriptions[site_id][channel] << blk
     ensure_subscriber_thread
+
+    attempts = 100
+    while attempts > 0 && !reliable_pub_sub.subscribed
+      sleep 0.001
+      attempts-=1
+    end
+
+    raise MessageBus::BusDestroyed if @destroyed
     blk
   end
 
   def unsubscribe_impl(channel, site_id, &blk)
+
     @mutex.synchronize do
       if blk
         @subscriptions[site_id][channel].delete blk
@@ -291,42 +349,50 @@ module MessageBus::Implementation
         @subscriptions[site_id][channel] = []
       end
     end
+
   end
 
 
   def ensure_subscriber_thread
-    @mutex ||= Mutex.new
     @mutex.synchronize do
-      return if @subscriber_thread && @subscriber_thread.alive?
-      @subscriber_thread = Thread.new do
-        reliable_pub_sub.global_subscribe do |msg|
-          begin
-            decode_message!(msg)
+      return if (@subscriber_thread && @subscriber_thread.alive?) || @destroyed
+      @subscriber_thread = new_subscriber_thread
+    end
+  end
 
-            @mutex.synchronize do
-              globals = @subscriptions[nil]
-              locals = @subscriptions[msg.site_id] if msg.site_id
+  def new_subscriber_thread
+    Thread.new do
+      global_subscribe_thread unless @destroyed
+    end
+  end
 
-              global_globals = globals[nil] if globals
-              local_globals = locals[nil] if locals
+  def global_subscribe_thread
+    reliable_pub_sub.global_subscribe do |msg|
+      begin
+        decode_message!(msg)
+        globals, locals, local_globals, global_globals = nil
 
-              globals = globals[msg.channel] if globals
-              locals = locals[msg.channel] if locals
+        @mutex.synchronize do
+          raise MessageBus::BusDestroyed if @destroyed
+          globals = @subscriptions[nil]
+          locals = @subscriptions[msg.site_id] if msg.site_id
 
-              multi_each(globals,locals, global_globals, local_globals) do |c|
-                begin
-                  c.call msg
-                rescue => e
-                  MessageBus.logger.warn "failed to deliver message, skipping #{msg.inspect}\n ex: #{e} backtrace: #{e.backtrace}"
-                end
-              end
-            end
+          global_globals = globals[nil] if globals
+          local_globals = locals[nil] if locals
 
+          globals = globals[msg.channel] if globals
+          locals = locals[msg.channel] if locals
+        end
+
+        multi_each(globals,locals, global_globals, local_globals) do |c|
+          begin
+            c.call msg
           rescue => e
-            MessageBus.logger.warn "failed to process message #{msg.inspect}\n ex: #{e} backtrace: #{e.backtrace}"
+            MessageBus.logger.warn "failed to deliver message, skipping #{msg.inspect}\n ex: #{e} backtrace: #{e.backtrace}"
           end
-
         end
+      rescue => e
+        MessageBus.logger.warn "failed to process message #{msg.inspect}\n ex: #{e} backtrace: #{e.backtrace}"
       end
     end
   end
@@ -341,6 +407,7 @@ end
 
 module MessageBus
   extend MessageBus::Implementation
+  initialize
 end
 
 # allows for multiple buses per app

data/lib/message_bus/client.rb

@@ -6,6 +6,7 @@ class MessageBus::Client
     self.group_ids = opts[:group_ids] || []
     self.site_id = opts[:site_id]
     self.connect_time = Time.now
+    @bus = opts[:message_bus] || MessageBus
     @subscriptions = {}
   end
 
@@ -33,7 +34,7 @@ class MessageBus::Client
 
   def subscribe(channel, last_seen_id)
     last_seen_id = nil if last_seen_id == ""
-    last_seen_id ||= MessageBus.last_id(channel)
+    last_seen_id ||= @bus.last_id(channel)
     @subscriptions[channel] = last_seen_id.to_i
   end
 
@@ -61,7 +62,7 @@ class MessageBus::Client
   end
 
   def filter(msg)
-    filter = MessageBus.client_filter(msg.channel)
+    filter = @bus.client_filter(msg.channel)
 
     if filter
       filter.call(self.user_id, msg)
@@ -74,7 +75,7 @@ class MessageBus::Client
     r = []
     @subscriptions.each do |k,v|
       next if v.to_i < 0
-      messages = MessageBus.backlog(k,v)
+      messages = @bus.backlog(k,v)
       messages.each do |msg|
         r << msg if allowed?(msg)
       end
@@ -84,7 +85,7 @@ class MessageBus::Client
     @subscriptions.each do |k,v|
       if v.to_i == -1
         status_message ||= {}
-        status_message[k] = MessageBus.last_id(k)
+        status_message[k] = @bus.last_id(k)
       end
     end
     r << MessageBus::Message.new(-1, -1, '/__status', status_message) if status_message

data/lib/message_bus/connection_manager.rb

@@ -2,9 +2,10 @@ require 'json' unless defined? ::JSON
 
 class MessageBus::ConnectionManager
 
-  def initialize
+  def initialize(bus = nil)
     @clients = {}
     @subscriptions = {}
+    @bus = bus || MessageBus
   end
 
   def notify_clients(msg)
@@ -14,7 +15,7 @@ class MessageBus::ConnectionManager
 
       return unless subscription
 
-      around_filter = MessageBus.around_client_batch(msg.channel)
+      around_filter = @bus.around_client_batch(msg.channel)
 
       work = lambda do
         subscription.each do |client_id|

data/lib/message_bus/rack/diagnostics.rb

@@ -3,10 +3,11 @@ module MessageBus::Rack; end
 class MessageBus::Rack::Diagnostics
   def initialize(app, config = {})
     @app = app
+    @bus = config[:message_bus] || MessageBus
   end
 
   def js_asset(name)
-    return generate_script_tag(name) unless MessageBus.cache_assets
+    return generate_script_tag(name) unless @bus.cache_assets
     @@asset_cache ||= {}
     @@asset_cache[name] ||= generate_script_tag(name)
     @@asset_cache[name]
@@ -65,21 +66,21 @@ HTML
 
     route = env['PATH_INFO'].split('/message-bus/_diagnostics')[1]
 
-    if MessageBus.is_admin_lookup.nil? || !MessageBus.is_admin_lookup.call(env)
+    if @bus.is_admin_lookup.nil? || !@bus.is_admin_lookup.call(env)
       return [403, {}, ['not allowed']]
     end
 
     return index unless route
 
     if route == '/discover'
-      user_id =  MessageBus.user_id_lookup.call(env)
-      MessageBus.publish('/_diagnostics/discover', user_id: user_id)
+      user_id = @bus.user_id_lookup.call(env)
+      @bus.publish('/_diagnostics/discover', user_id: user_id)
       return [200, {}, ['ok']]
     end
 
     if route =~ /^\/hup\//
       hostname, pid = route.split('/hup/')[1].split('/')
-      MessageBus.publish('/_diagnostics/hup', {hostname: hostname, pid: pid.to_i})
+      @bus.publish('/_diagnostics/hup', {hostname: hostname, pid: pid.to_i})
       return [200, {}, ['ok']]
     end
 

data/lib/message_bus/rack/middleware.rb

@@ -3,19 +3,19 @@ module MessageBus::Rack; end
 
 class MessageBus::Rack::Middleware
 
-  def self.start_listener
+  def start_listener
     unless @started_listener
 
       require 'eventmachine'
       require 'message_bus/em_ext'
 
-      MessageBus.subscribe do |msg|
+      @subscription = @bus.subscribe do |msg|
         if EM.reactor_running?
           EM.next_tick do
             begin
-              @@connection_manager.notify_clients(msg) if @@connection_manager
+              @connection_manager.notify_clients(msg) if @connection_manager
             rescue
-              MessageBus.logger.warn "Failed to notify clients: #{$!} #{$!.backtrace}"
+              @bus.logger.warn "Failed to notify clients: #{$!} #{$!.backtrace}"
             end
           end
         end
@@ -26,8 +26,16 @@ class MessageBus::Rack::Middleware
 
   def initialize(app, config = {})
     @app = app
-    @@connection_manager = MessageBus::ConnectionManager.new
-    self.class.start_listener
+    @bus = config[:message_bus] || MessageBus
+    @connection_manager = MessageBus::ConnectionManager.new(@bus)
+    self.start_listener
+  end
+
+  def stop_listener
+    if @subscription
+      @bus.unsubscribe(&@subscription)
+      @started_listener = false
+    end
   end
 
   def self.backlog_to_json(backlog)
@@ -47,25 +55,25 @@ class MessageBus::Rack::Middleware
     return @app.call(env) unless env['PATH_INFO'] =~ /^\/message-bus\//
 
     # special debug/test route
-    if ::MessageBus.allow_broadcast? && env['PATH_INFO'] == '/message-bus/broadcast'.freeze
+    if @bus.allow_broadcast? && env['PATH_INFO'] == '/message-bus/broadcast'.freeze
         parsed = Rack::Request.new(env)
-        ::MessageBus.publish parsed["channel".freeze], parsed["data".freeze]
+        @bus.publish parsed["channel".freeze], parsed["data".freeze]
         return [200,{"Content-Type".freeze => "text/html".freeze},["sent"]]
     end
 
     if env['PATH_INFO'].start_with? '/message-bus/_diagnostics'.freeze
-      diags = MessageBus::Rack::Diagnostics.new(@app)
+      diags = MessageBus::Rack::Diagnostics.new(@app, message_bus: @bus)
       return diags.call(env)
     end
 
     client_id = env['PATH_INFO'].split("/")[2]
     return [404, {}, ["not found"]] unless client_id
 
-    user_id = MessageBus.user_id_lookup.call(env) if MessageBus.user_id_lookup
-    group_ids = MessageBus.group_ids_lookup.call(env) if MessageBus.group_ids_lookup
-    site_id = MessageBus.site_id_lookup.call(env) if MessageBus.site_id_lookup
+    user_id = @bus.user_id_lookup.call(env) if @bus.user_id_lookup
+    group_ids = @bus.group_ids_lookup.call(env) if @bus.group_ids_lookup
+    site_id = @bus.site_id_lookup.call(env) if @bus.site_id_lookup
 
-    client = MessageBus::Client.new(client_id: client_id, user_id: user_id, site_id: site_id, group_ids: group_ids)
+    client = MessageBus::Client.new(message_bus: @bus, client_id: client_id, user_id: user_id, site_id: site_id, group_ids: group_ids)
 
     request = Rack::Request.new(env)
     request.POST.each do |k,v|
@@ -79,22 +87,20 @@ class MessageBus::Rack::Middleware
 
     ensure_reactor
 
-    long_polling = MessageBus.long_polling_enabled? &&
+    long_polling = @bus.long_polling_enabled? &&
                    env['QUERY_STRING'] !~ /dlp=t/.freeze &&
                    EM.reactor_running? &&
-                   @@connection_manager.client_count < MessageBus.max_active_clients
+                   @connection_manager.client_count < @bus.max_active_clients
 
-    #STDERR.puts "LONG POLLING  lp enabled #{MessageBus.long_polling_enabled?}, reactor #{EM.reactor_running?} count: #{@@connection_manager.client_count} ,  active #{MessageBus.max_active_clients} #{long_polling}"
     if backlog.length > 0
       [200, headers, [self.class.backlog_to_json(backlog)] ]
-    elsif long_polling && env['rack.hijack'] && MessageBus.rack_hijack_enabled?
+    elsif long_polling && env['rack.hijack'] && @bus.rack_hijack_enabled?
       io = env['rack.hijack'].call
       client.io = io
 
       add_client_with_timeout(client)
       [418, {}, ["I'm a teapot, undefined in spec"]]
     elsif long_polling && env['async.callback']
-
       response = nil
       # load extension if needed
       begin
@@ -122,19 +128,24 @@ class MessageBus::Rack::Middleware
     # ensure reactor is running
     if EM.reactor_pid != Process.pid
       Thread.new { EM.run }
+      i = 100
+      while !EM.reactor_running? && i > 0
+        sleep 0.001
+        i -= 1
+      end
     end
   end
 
   def add_client_with_timeout(client)
-    @@connection_manager.add_client(client)
+    @connection_manager.add_client(client)
 
-    client.cleanup_timer = ::EM::Timer.new(MessageBus.long_polling_interval.to_f / 1000) {
+    client.cleanup_timer = ::EM::Timer.new( @bus.long_polling_interval.to_f / 1000) {
       begin
         client.cleanup_timer = nil
         client.ensure_closed!
-        @@connection_manager.remove_client(client)
+        @connection_manager.remove_client(client)
       rescue
-        MessageBus.logger.warn "Failed to clean up client properly: #{$!} #{$!.backtrace}"
+        @bus.logger.warn "Failed to clean up client properly: #{$!} #{$!.backtrace}"
       end
     }
   end

data/lib/message_bus/reliable_pub_sub.rb

@@ -9,6 +9,7 @@ require 'redis'
 
 
 class MessageBus::ReliablePubSub
+  attr_reader :subscribed
 
   UNSUB_MESSAGE = "$$UNSUBSCRIBE"
 
@@ -212,7 +213,6 @@ class MessageBus::ReliablePubSub
   end
 
   def global_unsubscribe
-    # TODO mutex
     if @redis_global
       pub_redis.publish(redis_channel_name, UNSUB_MESSAGE)
       @redis_global.disconnect
@@ -249,7 +249,13 @@ class MessageBus::ReliablePubSub
           if highest_id
             clear_backlog.call(&blk)
           end
+          @subscribed = true
         end
+
+        on.unsubscribe do
+          @subscribed = false
+        end
+
         on.message do |c,m|
           if m == UNSUB_MESSAGE
             @redis_global.unsubscribe

data/lib/message_bus/version.rb

@@ -1,3 +1,3 @@
 module MessageBus
-  VERSION = "0.9.3.2"
+  VERSION = "0.9.4"
 end

data/spec/lib/connection_manager_spec.rb

@@ -23,7 +23,8 @@ end
 describe MessageBus::ConnectionManager do
 
   before do
-    @manager = MessageBus::ConnectionManager.new
+    @bus = MessageBus
+    @manager = MessageBus::ConnectionManager.new(@bus)
     @client = MessageBus::Client.new(client_id: "xyz", user_id: 1, site_id: 10)
     @resp = FakeAsync.new
     @client.async_response = @resp

data/spec/lib/fake_async_middleware.rb

@@ -1,38 +1,47 @@
 require 'http/parser'
 class FakeAsyncMiddleware
 
-  def self.simulate_thin_async
-    @@simulate_thin_async = true
-    @@simulate_hijack = false
+  def initialize(app,config={})
+    @app = app
+    @bus = config[:message_bus] || MessageBus
+    @simulate_thin_async = false
+    @simulate_hijack = false
+    @in_async = false
   end
 
-  def self.simulate_hijack
-    @@simulate_thin_async = false
-    @@simulate_hijack = true
+  def app
+    @app
   end
 
-  def self.in_async?
-    @@in_async if defined? @@in_async
+  def simulate_thin_async
+    @simulate_thin_async = true
+    @simulate_hijack = false
   end
 
-  def initialize(app,config={})
-    @app = app
+  def simulate_hijack
+    @simulate_thin_async = false
+    @simulate_hijack = true
   end
 
-  def simulate_thin_async
-    @@simulate_thin_async && MessageBus.long_polling_enabled?
+  def in_async?
+    @in_async
   end
 
-  def simulate_hijack
-    @@simulate_hijack && MessageBus.long_polling_enabled?
+
+  def simulate_thin_async?
+    @simulate_thin_async && @bus.long_polling_enabled?
+  end
+
+  def simulate_hijack?
+    @simulate_hijack && @bus.long_polling_enabled?
   end
 
   def call(env)
-    if simulate_thin_async
+    if simulate_thin_async?
       call_thin_async(env)
-    elsif simulate_hijack
+    elsif simulate_hijack?
       call_rack_hijack(env)
-    else 
+    else
       @app.call(env)
     end
   end
@@ -64,12 +73,12 @@ class FakeAsyncMiddleware
       env['rack.hijack_io'] = io
 
       result = @app.call(env)
-      
+
       EM::Timer.new(1) { EM.stop }
 
       defer = lambda {
         if !io || !io.closed?
-          @@in_async = true
+          @in_async = true
           EM.next_tick do
             defer.call
           end
@@ -88,7 +97,7 @@ class FakeAsyncMiddleware
       end
     }
 
-    @@in_async = false
+    @in_async = false
     result || [500, {}, ['timeout']]
 
   end
@@ -116,7 +125,7 @@ class FakeAsyncMiddleware
 
       defer = lambda {
         if !result
-          @@in_async = true
+          @in_async = true
           EM.next_tick do
             defer.call
           end
@@ -127,7 +136,7 @@ class FakeAsyncMiddleware
       defer.call
     }
 
-    @@in_async = false
+    @in_async = false
     result || [500, {}, ['timeout']]
   end
 end

data/spec/lib/message_bus_spec.rb

@@ -14,6 +14,7 @@ describe MessageBus do
   end
 
   after do
+    @bus.reset!
     @bus.destroy
   end
 
@@ -79,6 +80,65 @@ describe MessageBus do
     r.map{|i| i.data}.to_a.should == ['foo', 'bar']
   end
 
+  it "allows you to look up last_message" do
+    @bus.publish("/bob", "dylan")
+    @bus.publish("/bob", "marley")
+    @bus.last_message("/bob").data.should == "marley"
+    @bus.last_message("/nothing").should == nil
+  end
+
+  context "global subscriptions" do
+    before do
+      seq = 0
+      @bus.site_id_lookup do
+        (seq+=1).to_s
+      end
+    end
+
+    it "can get last_message" do
+      @bus.publish("/global/test", "test")
+      @bus.last_message("/global/test").data.should == "test"
+    end
+
+    it "can subscribe globally" do
+
+      data = nil
+      @bus.subscribe do |message|
+        data = message.data
+      end
+
+      @bus.publish("/global/test", "test")
+      wait_for(1000){ data }
+
+      data.should == "test"
+    end
+
+    it "can subscribe to channel" do
+
+      data = nil
+      @bus.subscribe("/global/test") do |message|
+        data = message.data
+      end
+
+      @bus.publish("/global/test", "test")
+      wait_for(1000){ data }
+
+      data.should == "test"
+    end
+
+    it "should exception if publishing restricted messages to user" do
+      lambda do
+        @bus.publish("/global/test", "test", user_ids: [1])
+      end.should raise_error(MessageBus::InvalidMessage)
+    end
+
+    it "should exception if publishing restricted messages to group" do
+      lambda do
+        @bus.publish("/global/test", "test", user_ids: [1])
+      end.should raise_error(MessageBus::InvalidMessage)
+    end
+
+  end
 
   it "should support forking properly do" do
     data = nil

data/spec/lib/middleware_spec.rb

@@ -8,25 +8,37 @@ describe MessageBus::Rack::Middleware do
   include Rack::Test::Methods
 
   before do
-    MessageBus.long_polling_enabled = false
+    bus = @bus = MessageBus::Instance.new
+    @bus.long_polling_enabled = false
+
+    builder = Rack::Builder.new {
+      use FakeAsyncMiddleware, :message_bus => bus
+      use MessageBus::Rack::Middleware, :message_bus => bus
+      run lambda {|env| [500, {'Content-Type' => 'text/html'}, 'should not be called' ]}
+    }
+
+    @async_middleware = builder.to_app
+    @message_bus_middleware = @async_middleware.app
+  end
+
+  after do |x|
+    @message_bus_middleware.stop_listener
+    @bus.reset!
+    @bus.destroy
   end
 
   def app
-    @app ||= Rack::Builder.new {
-      use FakeAsyncMiddleware
-      use MessageBus::Rack::Middleware
-      run lambda {|env| [500, {'Content-Type' => 'text/html'}, 'should not be called' ]}
-    }.to_app
+    @async_middleware
   end
 
   shared_examples "long polling" do
     before do
-      MessageBus.long_polling_enabled = true
+      @bus.long_polling_enabled = true
     end
 
     it "should respond right away if dlp=t" do
       post "/message-bus/ABC?dlp=t", '/foo1' => 0
-      FakeAsyncMiddleware.in_async?.should == false
+      @async_middleware.in_async?.should == false
       last_response.should be_ok
     end
 
@@ -36,14 +48,16 @@ describe MessageBus::Rack::Middleware do
       parsed = JSON.parse(last_response.body)
       parsed.length.should == 1
       parsed[0]["channel"].should == "/__status"
-      parsed[0]["data"]["/foo"].should == MessageBus.last_id("/foo")
+      parsed[0]["data"]["/foo"].should == @bus.last_id("/foo")
     end
 
     it "should respond to long polls when data is available" do
+      middleware = @async_middleware
+      bus = @bus
 
       Thread.new do
-        wait_for(2000) { FakeAsyncMiddleware.in_async? }
-        MessageBus.publish "/foo", "םוֹלשָׁ"
+        wait_for(2000) {middleware.in_async?}
+        bus.publish "/foo", "םוֹלשָׁ"
       end
 
       post "/message-bus/ABC", '/foo' => nil
@@ -56,21 +70,24 @@ describe MessageBus::Rack::Middleware do
 
     it "should timeout within its alloted slot" do
       begin
-        MessageBus.long_polling_interval = 10
+        @bus.long_polling_interval = 10
         s = Time.now.to_f * 1000
         post "/message-bus/ABC", '/foo' => nil
         (Time.now.to_f * 1000 - s).should < 30
       ensure
-        MessageBus.long_polling_interval = 5000
+        @bus.long_polling_interval = 5000
       end
     end
 
     it "should support batch filtering" do
-      MessageBus.user_id_lookup do |env|
+      bus = @bus
+      async_middleware = @async_middleware
+
+      bus.user_id_lookup do |env|
         1
       end
 
-      MessageBus.around_client_batch("/demo") do |message, user_ids, callback|
+      bus.around_client_batch("/demo") do |message, user_ids, callback|
         begin
           Thread.current["test"] = user_ids
           callback.call
@@ -81,18 +98,18 @@ describe MessageBus::Rack::Middleware do
 
       test = nil
 
-      MessageBus.client_filter("/demo") do |user_id, message|
+      bus.client_filter("/demo") do |user_id, message|
         test = Thread.current["test"]
         message
       end
 
       client_id = "ABCD"
 
-      id = MessageBus.publish("/demo", "test")
+      id = bus.publish("/demo", "test")
 
       Thread.new do
-        wait_for(2000) { FakeAsyncMiddleware.in_async? }
-        MessageBus.publish "/demo", "test"
+        wait_for(2000) { async_middleware.in_async? }
+        bus.publish "/demo", "test"
       end
 
       post "/message-bus/#{client_id}", {
@@ -105,15 +122,15 @@ describe MessageBus::Rack::Middleware do
 
   describe "thin async" do
     before do
-      FakeAsyncMiddleware.simulate_thin_async
+      @async_middleware.simulate_thin_async
     end
     it_behaves_like "long polling"
   end
 
   describe "hijack" do
     before do
-      FakeAsyncMiddleware.simulate_hijack
-      MessageBus.rack_hijack_enabled = true
+      @async_middleware.simulate_hijack
+      @bus.rack_hijack_enabled = true
     end
     it_behaves_like "long polling"
   end
@@ -126,13 +143,13 @@ describe MessageBus::Rack::Middleware do
     end
 
     it "should get a 200 with html for an authorized user" do
-      MessageBus.stub(:is_admin_lookup).and_return(lambda{|env| true })
+      @bus.stub(:is_admin_lookup).and_return(lambda{|env| true })
       get "/message-bus/_diagnostics"
       last_response.status.should == 200
     end
 
     it "should get the script it asks for" do
-      MessageBus.stub(:is_admin_lookup).and_return(lambda{|env| true })
+      @bus.stub(:is_admin_lookup).and_return(lambda{|env| true })
       get "/message-bus/_diagnostics/assets/message-bus.js"
       last_response.status.should == 200
       last_response.content_type.should == "text/javascript;"
@@ -142,7 +159,7 @@ describe MessageBus::Rack::Middleware do
 
   describe "polling" do
     before do
-      MessageBus.long_polling_enabled = false
+      @bus.long_polling_enabled = false
     end
 
     it "should respond with a 200 to a subscribe" do
@@ -158,7 +175,7 @@ describe MessageBus::Rack::Middleware do
 
     it "should correctly understand that -1 means stuff from now onwards" do
 
-      MessageBus.publish('foo', 'bar')
+      @bus.publish('foo', 'bar')
 
       post "/message-bus/ABCD", {
         '/foo' => -1
@@ -167,15 +184,15 @@ describe MessageBus::Rack::Middleware do
       parsed = JSON.parse(last_response.body)
       parsed.length.should == 1
       parsed[0]["channel"].should == "/__status"
-      parsed[0]["data"]["/foo"].should == MessageBus.last_id("/foo")
+      parsed[0]["data"]["/foo"].should ==@bus.last_id("/foo")
 
     end
 
     it "should respond with the data if messages exist in the backlog" do
-      id = MessageBus.last_id('/foo')
+      id =@bus.last_id('/foo')
 
-      MessageBus.publish("/foo", "barbs")
-      MessageBus.publish("/foo", "borbs")
+      @bus.publish("/foo", "barbs")
+      @bus.publish("/foo", "borbs")
 
       client_id = "ABCD"
       post "/message-bus/#{client_id}", {
@@ -189,9 +206,46 @@ describe MessageBus::Rack::Middleware do
       parsed[1]["data"].should == "borbs"
     end
 
+    it "should have no cross talk" do
+
+      seq = 0
+      @bus.site_id_lookup do
+        (seq+=1).to_s
+      end
+
+      # published on channel 1
+      msg = @bus.publish("/foo", "test")
+
+      # subscribed on channel 2
+      post "/message-bus/ABCD", {
+        '/foo' => (msg-1)
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 0
+
+    end
+
+    it "should have global cross talk" do
+
+      seq = 0
+      @bus.site_id_lookup do
+        (seq+=1).to_s
+      end
+
+      msg = @bus.publish("/global/foo", "test")
+
+      post "/message-bus/ABCD", {
+        '/global/foo' => (msg-1)
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+    end
+
     it "should not get consumed messages" do
-      MessageBus.publish("/foo", "barbs")
-      id = MessageBus.last_id('/foo')
+      @bus.publish("/foo", "barbs")
+      id =@bus.last_id('/foo')
 
       client_id = "ABCD"
       post "/message-bus/#{client_id}", {
@@ -203,8 +257,8 @@ describe MessageBus::Rack::Middleware do
     end
 
     it "should filter by user correctly" do
-      id = MessageBus.publish("/foo", "test", user_ids: [1])
-      MessageBus.user_id_lookup do |env|
+      id =@bus.publish("/foo", "test", user_ids: [1])
+      @bus.user_id_lookup do |env|
         0
       end
 
@@ -216,7 +270,7 @@ describe MessageBus::Rack::Middleware do
       parsed = JSON.parse(last_response.body)
       parsed.length.should == 0
 
-      MessageBus.user_id_lookup do |env|
+      @bus.user_id_lookup do |env|
         1
       end
 
@@ -230,14 +284,14 @@ describe MessageBus::Rack::Middleware do
 
 
     it "should filter by client_filter correctly" do
-      id = MessageBus.publish("/filter", "test")
-      user_id = 0
+      id = @bus.publish("/filter", "test")
+      uid = 0
 
-      MessageBus.user_id_lookup do |env|
-        user_id
+      @bus.user_id_lookup do |env|
+        uid
       end
 
-      MessageBus.client_filter("/filter") do |user_id, message|
+      @bus.client_filter("/filter") do |user_id, message|
         if user_id == 0
           message = message.dup
           message.data += "_filter"
@@ -256,7 +310,7 @@ describe MessageBus::Rack::Middleware do
       parsed = JSON.parse(last_response.body)
       parsed[0]['data'].should == "test_filter"
 
-      user_id = 1
+      uid = 1
 
       post "/message-bus/#{client_id}", {
         '/filter' => id - 1
@@ -266,7 +320,7 @@ describe MessageBus::Rack::Middleware do
       parsed.length.should == 1
       parsed[0]["data"].should == "test"
 
-      user_id = 2
+      uid = 2
 
       post "/message-bus/#{client_id}", {
         '/filter' => id - 1
@@ -277,8 +331,8 @@ describe MessageBus::Rack::Middleware do
     end
 
     it "should filter by group correctly" do
-      id = MessageBus.publish("/foo", "test", group_ids: [3,4,5])
-      MessageBus.group_ids_lookup do |env|
+      id =@bus.publish("/foo", "test", group_ids: [3,4,5])
+      @bus.group_ids_lookup do |env|
         [0,1,2]
       end
 
@@ -290,7 +344,7 @@ describe MessageBus::Rack::Middleware do
       parsed = JSON.parse(last_response.body)
       parsed.length.should == 0
 
-      MessageBus.group_ids_lookup do |env|
+      @bus.group_ids_lookup do |env|
         [1,7,4,100]
       end
 

data/vendor/assets/javascripts/message-bus.js

@@ -119,6 +119,7 @@ window.MessageBus = (function() {
       },
       success: function(messages) {
         failCount = 0;
+        if (messages === null) return; // server unexpectedly closed connection
         $.each(messages,function(_,message) {
           gotData = true;
           $.each(callbacks, function(_,callback) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: message_bus
 version: !ruby/object:Gem::Version
-  version: 0.9.3.2
+  version: 0.9.4
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-06 00:00:00.000000000 Z
+date: 2014-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -80,6 +80,8 @@ files:
 - examples/bench/unicorn.conf.rb
 - examples/chat/chat.rb
 - examples/chat/config.ru
+- examples/minimal/Gemfile
+- examples/minimal/config.ru
 - lib/message_bus.rb
 - lib/message_bus/client.rb
 - lib/message_bus/connection_manager.rb