message_bus 2.0.0.beta.4 → 2.0.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d49bdd78a0d4f079d8e51b1025ce6a96b137585d
-  data.tar.gz: 56e40e067dbb28f37cabe3e8c81b601b75291a11
+  metadata.gz: b91a7d621707536a33738a736ffd00bba4639d46
+  data.tar.gz: b5a445c066617c126b4bfaeb6444ad0f473ec670
 SHA512:
-  metadata.gz: a827d7367f608068c934340736cce46e04464ffacae2f4c0d504efff10d9e184ab3ecaf575f6768931f5661186a48d080d9825f8f61f42f29595fc24cd148126
-  data.tar.gz: aabd193e53d443f806745fe1d3bee1f7f4a494c9a511035d471c546a55ddeac78d18f3f11622c85994ef800169688c89fab19e2d612bc6acd32d9f51f49a8899
+  metadata.gz: adb5ec754024c6a62873a98dd2e3978d669f057bda86ffac0a6842787a9b8e14d0280315d6f499f40da9e86ed0a412c8ce0675262318f9330d023e2e58afe4c3
+  data.tar.gz: 50c1ee4d6b4e485198011c08a5632014321f34ceb388dd93568513d2762d1d9c539a0a3c7b4d2e6e74d7485e4ce5d3ace9d7f0e9bf8be6812df5f4d72f27c10a

data/CHANGELOG

@@ -1,5 +1,10 @@
 29-02-2016
 
+- Version 2.0.0.beta.5
+
+- Fix: JavaScript unsubscribe was not updating publicly visible MessageBus.callbacks @sam
+- Fix: When MessageBus is talking to a readonly redis buffering may cause a infinite loop @tgxworld
+
 - Version 2.0.0.beta.4
 
 - Feature: allow verbose redis logging by specifying `enable_redis_logger` in config, default disabled

data/README.md

@@ -18,6 +18,10 @@ Live chat demo per [examples/chat](https://github.com/SamSaffron/message_bus/tre
 
 **Yes**, MessageBus uses Rack Hijack, this interface allows us to take control of the underlying socket. MessageBus can handle thousands of concurrent long polls on all popular Ruby webservers. MessageBus runs as middleware in your Rack (or by extension Rails) application and does not require a dedicated server. Background work is minimized to ensure it does not interfere with existing non MessageBus traffic.
 
+## Is this used in production at scale?
+
+**Yes**, MessageBus was extracted out of [Discourse](http://www.discourse.org/) and is used in thousands of production Discourse sites at scale. 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -216,7 +220,19 @@ message_bus also supports PostgreSQL as the backend:
 MessageBus.configure(backend: :postgres, backend_options: {user: 'message_bus', dbname: 'message_bus'})
 ```
 
-The PostgreSQL client message_bus uses is [ruby-pg](https://bitbucket.org/ged/ruby-pg), so you can visit it's repo to see what options you can configure.
+The PostgreSQL client message_bus uses is [ruby-pg](https://bitbucket.org/ged/ruby-pg), so you can visit it's repo to see what options you can configure inside `:backend_options`.
+
+A `:clear_every` option is also supported, which only clears the backlogs on every number of requests given.  So if you set `clear_every: 100`, the backlog will only be cleared every 100 requests.  This can improve performance in cases where exact backlog clearing are not required.
+
+### Memory
+
+message_bus also supports an in-memory backend.  This can be used for testing or simple single-process environments that do not require persistence.
+
+```ruby
+MessageBus.configure(backend: :memory)
+```
+
+The `:clear_every` option supported by the PostgreSQL backend is also supported by the in-memory backend.
 
 ### Forking/threading app servers
 
@@ -237,6 +253,23 @@ if defined?(PhusionPassenger)
 end
 ```
 
+MessageBus uses long polling which needs to be configured in Passenger
+
+* for passenger version < 5.0.21
+
+`PhusionPassenger.advertised_concurrency_level = 0` to application.rb
+
+* for passenger version > 5.0.21
+
+```
+   location /message-bus {
+       passenger_app_group_name foo_websocket;
+       passenger_force_max_concurrent_requests_per_process 0;
+   }
+```
+to nginx.conf.
+For more information see [Passenger documentation](https://www.phusionpassenger.com/library/config/nginx/tuning_sse_and_websockets/)
+
 #### Puma
 ```ruby
 # path/to/your/config/puma.rb
@@ -261,6 +294,7 @@ end
 
 If you are looking to contribute to this project here are some ideas
 
+- Add a test suite for JavaScript message-bus.js
 - Build backends for other providers (zeromq, rabbitmq, disque)
 - Improve and properly document admin dashboard (add opt-in stats, better diagnostics into queues)
 - Improve general documentation (Add examples, refine existing examples)

data/Rakefile

@@ -17,12 +17,16 @@ run_spec = proc do |backend|
   end
 end
 
-task :spec => [:spec_redis, :spec_postgres]
+task :spec => [:spec_redis, :spec_postgres, :spec_memory]
 
 task :spec_redis do
   run_spec.call('redis')
 end
 
+task :spec_memory do
+  run_spec.call('memory')
+end
+
 task :spec_postgres do
   run_spec.call('postgres')
 end

data/assets/message-bus.js

@@ -345,22 +345,26 @@ window.MessageBus = (function() {
         last_id: lastId
       });
       if (me.longPoll) {
-        return me.longPoll.abort();
+        me.longPoll.abort();
       }
+
+      return func;
     },
 
     // Unsubscribe from a channel
     unsubscribe: function(channel, func) {
-      // TODO proper globbing
+      // TODO allow for globbing in the middle of a channel name
+      // like /something/*/something
+      // at the moment we only support globbing /something/*
       var glob;
       if (channel.indexOf("*", channel.length - 1) !== -1) {
         channel = channel.substr(0, channel.length - 1);
         glob = true;
       }
 
-      var filtered = [];
+      var removed = false;
 
-      for (var i=0; i<callbacks.length; i++) {
+      for (var i=callbacks.length-1; i>=0; i--) {
 
         callback = callbacks[i];
         var keep;
@@ -375,16 +379,17 @@ window.MessageBus = (function() {
           keep = true;
         }
 
-        if (keep) {
-          filtered.push(callback);
+        if (!keep) {
+          callbacks.splice(i,1);
+          removed = true;
         }
       }
 
-      callbacks = filtered;
-
-      if (me.longPoll) {
-        return me.longPoll.abort();
+      if (removed && me.longPoll) {
+        me.longPoll.abort();
       }
+
+      return removed;
     }
   };
 

data/examples/chat/Gemfile

@@ -0,0 +1,3 @@
+gem 'puma'
+gem 'redis'
+gem 'sinatra'

data/lib/message_bus.rb

@@ -473,7 +473,7 @@ module MessageBus::Implementation
         globals, locals, local_globals, global_globals = nil
 
         @mutex.synchronize do
-          raise MessageBus::BusDestroyed if @destroyed
+          return if @destroyed
           next unless @subscriptions
 
           globals = @subscriptions[nil]

data/lib/message_bus/backends/memory.rb

@@ -0,0 +1,286 @@
+module MessageBus::Memory; end
+
+class MessageBus::Memory::Client
+  class Listener
+    attr_reader :do_sub, :do_unsub, :do_message
+
+    def subscribe(&block)
+      @do_sub = block
+    end
+
+    def unsubscribe(&block)
+      @do_unsub = block
+    end
+
+    def message(&block)
+      @do_message = block
+    end
+  end
+
+  def initialize(config)
+    @mutex = Mutex.new
+    @listeners = []
+    reset!
+  end
+
+  def add(channel, value)
+    listeners = nil
+    id = nil
+    sync do
+      id = @global_id += 1
+      chan(channel) << [id, value]
+      listeners = @listeners.dup
+    end
+    msg = MessageBus::Message.new id, id, channel, value
+    payload = msg.encode
+    listeners.each{|l| l.push(payload)}
+    id
+  end
+
+  def clear_global_backlog(backlog_id, num_to_keep)
+    if backlog_id > num_to_keep
+      oldest = backlog_id - num_to_keep
+      sync do
+        @channels.each_value do |entries|
+          entries.delete_if{|id, _| id <= oldest}
+        end
+      end
+      nil
+    end
+  end
+
+  def clear_channel_backlog(channel, backlog_id, num_to_keep)
+    oldest = backlog_id - num_to_keep
+    sync{chan(channel).delete_if{|id, _| id <= oldest}}
+    nil
+  end
+
+  def backlog(channel, backlog_id)
+    sync{chan(channel).select{|id, _| id > backlog_id}}
+  end
+
+  def global_backlog(backlog_id)
+    sync do
+      @channels.dup.flat_map do |channel, messages|
+        messages.select{|id, _| id > backlog_id}.map{|id, value| [id, channel, value]}
+      end.sort
+    end
+  end
+
+  def get_value(channel, id)
+    sync{chan(channel).find{|i, _| i == id}.last}
+  end
+
+  # Dangerous, drops the message_bus table containing the backlog if it exists.
+  def reset!
+    sync do
+      @global_id = 0
+      @channels = {}
+    end
+  end
+
+  def max_id(channel=nil)
+    if channel
+      sync do
+        if entry = chan(channel).last
+          entry.first
+        end
+      end
+    else
+      sync{@global_id - 1}
+    end || 0
+  end
+
+  def subscribe
+    listener = Listener.new
+    yield listener
+
+    q = Queue.new
+    sync do
+      @listeners << q
+    end
+
+    listener.do_sub.call
+    while msg = q.pop
+      listener.do_message.call(nil, msg)
+    end
+    listener.do_unsub.call
+    sync do
+      @listeners.delete(q)
+    end
+
+    nil
+  end
+
+  def unsubscribe
+    sync{@listeners.each{|l| l.push(nil)}}
+  end
+
+  private
+
+  def chan(channel)
+    @channels[channel] ||= []
+  end
+
+  def sync
+    @mutex.synchronize{yield}
+  end
+end
+
+class MessageBus::Memory::ReliablePubSub
+  attr_reader :subscribed
+  attr_accessor :max_backlog_size, :max_global_backlog_size, :clear_every
+
+  UNSUB_MESSAGE = "$$UNSUBSCRIBE"
+
+  # max_backlog_size is per multiplexed channel
+  def initialize(config = {}, max_backlog_size = 1000)
+    @config = config
+    @max_backlog_size = max_backlog_size
+    @max_global_backlog_size = 2000
+    # after 7 days inactive backlogs will be removed
+    @clear_every = config[:clear_every] || 1
+  end
+
+  def new_connection
+    MessageBus::Memory::Client.new(@config)
+  end
+
+  def backend
+    :memory
+  end
+
+  def after_fork
+    nil
+  end
+
+  def client
+    @client ||= new_connection
+  end
+
+  # use with extreme care, will nuke all of the data
+  def reset!
+    client.reset!
+  end
+
+  def publish(channel, data, queue_in_memory=true)
+    client = self.client
+    backlog_id = client.add(channel, data)
+    if backlog_id % clear_every == 0
+      client.clear_global_backlog(backlog_id, @max_global_backlog_size)
+      client.clear_channel_backlog(channel, backlog_id, @max_backlog_size)
+    end
+
+    backlog_id
+  end
+
+  def last_id(channel)
+    client.max_id(channel)
+  end
+
+  def backlog(channel, last_id = nil)
+    items = client.backlog channel, last_id.to_i
+
+    items.map! do |id, data|
+      MessageBus::Message.new id, id, channel, data
+    end
+  end
+
+  def global_backlog(last_id = nil)
+    last_id = last_id.to_i
+
+    items = client.global_backlog last_id.to_i
+
+    items.map! do |id, channel, data|
+      MessageBus::Message.new id, id, channel, data
+    end
+  end
+
+  def get_message(channel, message_id)
+    if data = client.get_value(channel, message_id)
+      MessageBus::Message.new message_id, message_id, channel, data
+    else
+      nil
+    end
+  end
+
+  def subscribe(channel, last_id = nil)
+    # trivial implementation for now,
+    #   can cut down on connections if we only have one global subscriber
+    raise ArgumentError unless block_given?
+
+    global_subscribe(last_id) do |m|
+      yield m if m.channel == channel
+    end
+  end
+
+  def process_global_backlog(highest_id)
+    if highest_id > client.max_id
+      highest_id = 0
+    end
+
+    global_backlog(highest_id).each do |old|
+      yield old
+      highest_id = old.global_id
+    end
+
+    highest_id
+  end
+
+  def global_unsubscribe
+    client.unsubscribe
+    @subscribed = false
+  end
+
+  def global_subscribe(last_id=nil, &blk)
+    raise ArgumentError unless block_given?
+    highest_id = last_id
+
+    begin
+      client.subscribe do |on|
+        h = {}
+
+        on.subscribe do
+          if highest_id
+            process_global_backlog(highest_id) do |m|
+              h[m.global_id] = true
+              yield m
+            end
+          end
+          @subscribed = true
+        end
+
+        on.unsubscribe do
+          @subscribed = false
+        end
+
+        on.message do |c,m|
+          m = MessageBus::Message.decode m
+
+          # we have 3 options
+          #
+          # 1. message came in the correct order GREAT, just deal with it
+          # 2. message came in the incorrect order COMPLICATED, wait a tiny bit and clear backlog
+          # 3. message came in the incorrect order and is lowest than current highest id, reset
+
+          if h
+            # If already yielded during the clear backlog when subscribing,
+            # don't yield a duplicate copy.
+            unless h.delete(m.global_id)
+              h = nil if h.empty?
+              yield m
+            end
+          else
+            yield m
+          end
+        end
+      end
+    rescue => error
+      MessageBus.logger.warn "#{error} subscribe failed, reconnecting in 1 second. Call stack\n#{error.backtrace.join("\n")}"
+      sleep 1
+      retry
+    end
+  end
+
+  MessageBus::BACKENDS[:memory] = self
+end

data/lib/message_bus/backends/postgres.rb

@@ -103,25 +103,19 @@ class MessageBus::Postgres::Client
     sync{@listening_on[channel] = obj}
     listener = Listener.new
     yield listener
-    pid = Process.pid
     
     conn = raw_pg_connection
     conn.exec "LISTEN #{channel}"
     listener.do_sub.call
     while listening_on?(channel, obj)
       conn.wait_for_notify(10) do |_,_,payload|
+        break unless listening_on?(channel, obj)
         listener.do_message.call(nil, payload)
       end
-      break if pid != Process.pid
     end
     listener.do_unsub.call
 
-    if pid != Process.pid
-      sync{INHERITED_CONNECTIONS << conn}
-    else
-      conn.exec "UNLISTEN #{channel}"
-    end
-
+    conn.exec "UNLISTEN #{channel}"
     nil
   end
 
@@ -139,7 +133,7 @@ class MessageBus::Postgres::Client
   end
 
   def create_table(conn)
-    conn.exec 'CREATE TABLE message_bus (id bigserial PRIMARY KEY, channel text NOT NULL, value text NOT NULL, added_at timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL)'
+    conn.exec 'CREATE TABLE message_bus (id bigserial PRIMARY KEY, channel text NOT NULL, value text NOT NULL CHECK (octet_length(value) >= 2), added_at timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL)'
     conn.exec 'CREATE INDEX table_channel_id_index ON message_bus (channel, id)'
     conn.exec 'CREATE INDEX table_added_at_index ON message_bus (added_at)'
     nil
@@ -150,7 +144,6 @@ class MessageBus::Postgres::Client
     if current_pid != @pid
       @pid = current_pid
       sync do
-        @listening_on.clear
         INHERITED_CONNECTIONS.concat(@available)
         @available.clear
       end
@@ -214,9 +207,7 @@ end
 
 class MessageBus::Postgres::ReliablePubSub
   attr_reader :subscribed
-  attr_accessor :max_publish_retries, :max_publish_wait, :max_backlog_size,
-                :max_global_backlog_size, :max_in_memory_publish_backlog,
-                :max_backlog_age
+  attr_accessor :max_backlog_size, :max_global_backlog_size, :max_backlog_age, :clear_every
 
   UNSUB_MESSAGE = "$$UNSUBSCRIBE"
 
@@ -229,15 +220,9 @@ class MessageBus::Postgres::ReliablePubSub
     @config = config
     @max_backlog_size = max_backlog_size
     @max_global_backlog_size = 2000
-    @max_publish_retries = 10
-    @max_publish_wait = 500 #ms
-    @max_in_memory_publish_backlog = 1000
-    @in_memory_backlog = []
-    @lock = Mutex.new
-    @flush_backlog_thread = nil
     # after 7 days inactive backlogs will be removed
     @max_backlog_age = 604800
-    @h = {}
+    @clear_every = config[:clear_every] || 1
   end
 
   def new_connection
@@ -272,9 +257,11 @@ class MessageBus::Postgres::ReliablePubSub
     msg = MessageBus::Message.new backlog_id, backlog_id, channel, data
     payload = msg.encode
     client.publish postgresql_channel_name, payload
-    client.clear_global_backlog(backlog_id, @max_global_backlog_size)
-    client.expire(@max_backlog_age)
-    client.clear_channel_backlog(channel, backlog_id, @max_backlog_size)
+    if backlog_id % clear_every == 0
+      client.clear_global_backlog(backlog_id, @max_global_backlog_size)
+      client.expire(@max_backlog_age)
+      client.clear_channel_backlog(channel, backlog_id, @max_backlog_size)
+    end
 
     backlog_id
   end

data/lib/message_bus/backends/redis.rb

@@ -10,9 +10,7 @@ require 'redis'
 module MessageBus::Redis; end
 class MessageBus::Redis::ReliablePubSub
   attr_reader :subscribed
-  attr_accessor :max_publish_retries, :max_publish_wait, :max_backlog_size,
-                :max_global_backlog_size, :max_in_memory_publish_backlog,
-                :max_backlog_age
+  attr_accessor :max_backlog_size, :max_global_backlog_size, :max_in_memory_publish_backlog, :max_backlog_age
 
   UNSUB_MESSAGE = "$$UNSUBSCRIBE"
 
@@ -33,8 +31,6 @@ class MessageBus::Redis::ReliablePubSub
     end
     @max_backlog_size = max_backlog_size
     @max_global_backlog_size = 2000
-    @max_publish_retries = 10
-    @max_publish_wait = 500 #ms
     @max_in_memory_publish_backlog = 1000
     @in_memory_backlog = []
     @lock = Mutex.new
@@ -151,11 +147,21 @@ class MessageBus::Redis::ReliablePubSub
   end
 
   def ensure_backlog_flushed
-    while true
+    flushed = false
+
+    while !flushed
       try_again = false
 
+      if is_readonly?
+        sleep 1
+        next
+      end
+
       @lock.synchronize do
-        break if @in_memory_backlog.length == 0
+        if @in_memory_backlog.length == 0
+          flushed = true
+          break
+        end
 
         begin
           publish(*@in_memory_backlog[0],false)
@@ -171,13 +177,6 @@ class MessageBus::Redis::ReliablePubSub
 
         @in_memory_backlog.delete_at(0) unless try_again
       end
-
-      if try_again
-        sleep 0.005
-        # in case we are not connected to the correct server
-        # which can happen when sharing ips
-        pub_redis.client.reconnect
-      end
     end
   ensure
     @lock.synchronize do
@@ -342,5 +341,21 @@ class MessageBus::Redis::ReliablePubSub
     end
   end
 
+  private
+
+  def is_readonly?
+    key = "__mb_is_readonly".freeze
+
+    begin
+      # in case we are not connected to the correct server
+      # which can happen when sharing ips
+      pub_redis.client.reconnect
+      pub_redis.client.call([:set, key, '1'])
+      false
+    rescue Redis::CommandError => e
+      return true if e.message =~ /^READONLY/
+    end
+  end
+
   MessageBus::BACKENDS[:redis] = self
 end

data/lib/message_bus/version.rb

@@ -1,3 +1,3 @@
 module MessageBus
-  VERSION = "2.0.0.beta.4"
+  VERSION = "2.0.0.beta.5"
 end

data/spec/lib/message_bus/backends/postgres_spec.rb

@@ -1,7 +1,7 @@
 require_relative '../../../spec_helper'
 require 'message_bus'
 
-if MESSAGE_BUS_CONFIG[:backend] == :postgres
+if MESSAGE_BUS_CONFIG[:backend] == :postgres || MESSAGE_BUS_CONFIG[:backend] == :memory
 describe PUB_SUB_CLASS do
 
   def new_test_bus
@@ -56,24 +56,37 @@ describe PUB_SUB_CLASS do
   it "should truncate channels correctly" do
     @bus.max_backlog_size = 2
     4.times do |t|
-      @bus.publish "/foo", t.to_s
+      @bus.publish "/foo", "1#{t}"
     end
 
     @bus.backlog("/foo").to_a.must_equal [
-      MessageBus::Message.new(3,3,'/foo','2'),
-      MessageBus::Message.new(4,4,'/foo','3'),
+      MessageBus::Message.new(3,3,'/foo','12'),
+      MessageBus::Message.new(4,4,'/foo','13'),
     ]
   end
 
   it "should truncate global backlog correctly" do
     @bus.max_global_backlog_size = 2
-    @bus.publish "/foo", "1"
-    @bus.publish "/bar", "2"
-    @bus.publish "/baz", "3"
+    @bus.publish "/foo", "11"
+    @bus.publish "/bar", "21"
+    @bus.publish "/baz", "31"
 
     @bus.global_backlog.length.must_equal 2
   end
 
+  it "should support clear_every setting" do
+    @bus.clear_every = 5
+    @bus.max_global_backlog_size = 2
+    @bus.publish "/foo", "11"
+    @bus.publish "/bar", "21"
+    @bus.publish "/baz", "31"
+    @bus.publish "/bar", "41"
+    @bus.global_backlog.length.must_equal 4
+
+    @bus.publish "/baz", "51"
+    @bus.global_backlog.length.must_equal 2
+  end
+
   it "should be able to grab a message by id" do
     id1 = @bus.publish "/foo", "bar"
     id2 = @bus.publish "/foo", "baz"
@@ -97,14 +110,14 @@ describe PUB_SUB_CLASS do
 
   it "should correctly omit dropped messages from the global backlog" do
     @bus.max_backlog_size = 1
-    @bus.publish "/foo", "a"
-    @bus.publish "/foo", "b"
-    @bus.publish "/bar", "a"
-    @bus.publish "/bar", "b"
+    @bus.publish "/foo", "a1"
+    @bus.publish "/foo", "b1"
+    @bus.publish "/bar", "a1"
+    @bus.publish "/bar", "b1"
 
     @bus.global_backlog.to_a.must_equal [
-      MessageBus::Message.new(2, 2, "/foo", "b"),
-      MessageBus::Message.new(4, 4, "/bar", "b")
+      MessageBus::Message.new(2, 2, "/foo", "b1"),
+      MessageBus::Message.new(4, 4, "/bar", "b1")
     ]
   end
 
@@ -112,9 +125,9 @@ describe PUB_SUB_CLASS do
     threads = []
     4.times do
       threads << Thread.new do
-        bus = new_test_bus
+        bus = @bus
         25.times {
-          bus.publish "/foo", "."
+          bus.publish "/foo", ".."
         }
       end
     end
@@ -124,17 +137,17 @@ describe PUB_SUB_CLASS do
   end
 
   it "should be able to subscribe globally with recovery" do
-    @bus.publish("/foo", "1")
-    @bus.publish("/bar", "2")
+    @bus.publish("/foo", "11")
+    @bus.publish("/bar", "12")
     got = []
 
     t = Thread.new do
-      new_test_bus.global_subscribe(0) do |msg|
+      @bus.global_subscribe(0) do |msg|
         got << msg
       end
     end
 
-    @bus.publish("/bar", "3")
+    @bus.publish("/bar", "13")
 
     wait_for(100) do
       got.length == 3
@@ -143,7 +156,7 @@ describe PUB_SUB_CLASS do
     t.kill
 
     got.length.must_equal 3
-    got.map{|m| m.data}.must_equal ["1","2","3"]
+    got.map{|m| m.data}.must_equal ["11","12","13"]
   end
 
   it "should be able to encode and decode messages properly" do
@@ -152,17 +165,17 @@ describe PUB_SUB_CLASS do
   end
 
   it "should handle subscribe on single channel, with recovery" do
-    @bus.publish("/foo", "1")
-    @bus.publish("/bar", "2")
+    @bus.publish("/foo", "11")
+    @bus.publish("/bar", "12")
     got = []
 
     t = Thread.new do
-      new_test_bus.subscribe("/foo",0) do |msg|
+      @bus.subscribe("/foo",0) do |msg|
         got << msg
       end
     end
 
-    @bus.publish("/foo", "3")
+    @bus.publish("/foo", "13")
 
     wait_for(100) do
       got.length == 2
@@ -170,15 +183,15 @@ describe PUB_SUB_CLASS do
 
     t.kill
 
-    got.map{|m| m.data}.must_equal ["1","3"]
+    got.map{|m| m.data}.must_equal ["11","13"]
   end
 
   it "should not get backlog if subscribe is called without params" do
-    @bus.publish("/foo", "1")
+    @bus.publish("/foo", "11")
     got = []
 
     t = Thread.new do
-      new_test_bus.subscribe("/foo") do |msg|
+      @bus.subscribe("/foo") do |msg|
         got << msg
       end
     end
@@ -187,7 +200,7 @@ describe PUB_SUB_CLASS do
     #   I thought about adding a subscribed callback, but outside of testing it matters less
     sleep 0.05
 
-    @bus.publish("/foo", "2")
+    @bus.publish("/foo", "12")
 
     wait_for(100) do
       got.length == 1
@@ -195,12 +208,12 @@ describe PUB_SUB_CLASS do
 
     t.kill
 
-    got.map{|m| m.data}.must_equal ["2"]
+    got.map{|m| m.data}.must_equal ["12"]
   end
 
   it "should allow us to get last id on a channel" do
     @bus.last_id("/foo").must_equal 0
-    @bus.publish("/foo", "1")
+    @bus.publish("/foo", "11")
     @bus.last_id("/foo").must_equal 1
   end
 

data/spec/lib/message_bus/backends/redis_spec.rb

@@ -26,16 +26,22 @@ describe PUB_SUB_CLASS do
       @bus.pub_redis.slaveof "127.0.0.80", "666"
       @bus.max_in_memory_publish_backlog = 2
 
+      current_threads = Thread.list
+      current_threads_length  = current_threads.count
+
       3.times do
         result = @bus.publish "/foo", "bar"
         result.must_equal nil
+        Thread.list.length.must_equal (current_threads_length + 1)
       end
 
       @bus.pub_redis.slaveof "no", "one"
       sleep 0.01
 
-      @bus.backlog("/foo", 0).map(&:data).must_equal ["bar","bar"]
+      (Thread.list - current_threads).each(&:join)
+      Thread.list.length.must_equal current_threads_length
 
+      @bus.backlog("/foo", 0).map(&:data).must_equal ["bar","bar"]
     end
   end
 

data/spec/lib/message_bus/client_spec.rb

@@ -7,7 +7,7 @@ describe MessageBus::Client do
 
     before do
       @bus = MessageBus::Instance.new
-      @bus.redis_config = MESSAGE_BUS_CONFIG
+      @bus.configure(MESSAGE_BUS_CONFIG)
       @client = MessageBus::Client.new client_id: 'abc', message_bus: @bus
     end
 

data/spec/lib/message_bus/multi_process_spec.rb

@@ -1,6 +1,7 @@
 require_relative '../../spec_helper'
 require 'message_bus'
 
+unless MESSAGE_BUS_CONFIG[:backend] == :memory
 describe PUB_SUB_CLASS do
   def self.error!
     @error = true
@@ -44,7 +45,7 @@ describe PUB_SUB_CLASS do
       new_bus.reset!
       begin
         pids = (1..10).map{spawn_child}
-        expected_responses = pids.map{|x| (0...10).map{|i| "#{i}-#{x}"}}.flatten
+        expected_responses = pids.map{|x| (0...10).map{|i| "0#{i}-#{x}"}}.flatten
         unexpected_responses = []
         bus = new_bus
         t = Thread.new do
@@ -56,7 +57,7 @@ describe PUB_SUB_CLASS do
             end
           end
         end
-        10.times{|i| bus.publish("/echo", i.to_s)}
+        10.times{|i| bus.publish("/echo", "0#{i}")}
         wait_for 4000 do
           expected_responses.empty?
         end
@@ -83,3 +84,4 @@ describe PUB_SUB_CLASS do
     end
   end
 end
+end

data/spec/lib/message_bus/rack/middleware_spec.rb

@@ -10,7 +10,7 @@ describe MessageBus::Rack::Middleware do
 
   before do
     bus = @bus = MessageBus::Instance.new
-    @bus.redis_config = MESSAGE_BUS_CONFIG
+    @bus.configure(MESSAGE_BUS_CONFIG)
     @bus.long_polling_enabled = false
 
     e_m = extra_middleware
@@ -23,9 +23,10 @@ describe MessageBus::Rack::Middleware do
 
     @async_middleware = builder.to_app
     @message_bus_middleware = @async_middleware.app
+    @bus.reset!
   end
 
-  after do |x|
+  after do
     @message_bus_middleware.stop_listener
     @bus.reset!
     @bus.destroy

data/spec/lib/message_bus_spec.rb

@@ -10,7 +10,7 @@ describe MessageBus do
     @bus.site_id_lookup do
       "magic"
     end
-    @bus.redis_config = MESSAGE_BUS_CONFIG
+    @bus.configure(MESSAGE_BUS_CONFIG)
   end
 
   after do
@@ -43,11 +43,11 @@ describe MessageBus do
     @bus.publish("/chuck", {:norris => true})
     @bus.publish("/chuck", {:norris => true})
 
-    @bus.reliable_pub_sub.pub_redis.flushall
+    @bus.reliable_pub_sub.reset!
 
     @bus.publish("/chuck", {:yeager => true})
 
-    wait_for(2000){ data["yeager"]}
+    wait_for(2000){ data && data["yeager"]}
 
     data["yeager"].must_equal true
 
@@ -184,39 +184,40 @@ describe MessageBus do
 
   end
 
-  it "should support forking properly do" do
-    data = nil
-    @bus.subscribe do |msg|
-      data = msg.data
-    end
-
-    @bus.publish("/hello", "world")
-
-    wait_for(2000){ data }
+  unless MESSAGE_BUS_CONFIG[:backend] == :memory
+    it "should support forking properly do" do
+      data = nil
+      @bus.subscribe do |msg|
+        data = msg.data
+      end
 
-    if child = Process.fork
-      wait_for(2000) { data == "ready" }
-      @bus.publish("/hello", "world1")
-      wait_for(2000) { data == "got it" }
-      data.must_equal "got it"
-      Process.wait(child)
-    else
-      begin
-        @bus.after_fork
-        @bus.publish("/hello", "ready")
-        wait_for(2000) { data == "world1" }
-        if(data=="world1")
-          @bus.publish("/hello", "got it")
+      @bus.publish("/hello", "world")
+
+      wait_for(2000){ data }
+
+      if child = Process.fork
+        wait_for(2000) { data == "ready" }
+        @bus.publish("/hello", "world1")
+        wait_for(2000) { data == "got it" }
+        data.must_equal "got it"
+        Process.wait(child)
+      else
+        begin
+          @bus.after_fork
+          @bus.publish("/hello", "ready")
+          wait_for(2000) { data == "world1" }
+          if(data=="world1")
+            @bus.publish("/hello", "got it")
+          end
+
+          $stdout.reopen("/dev/null", "w")
+          $stderr.reopen("/dev/null", "w")
+
+        ensure
+          exit!(0)
         end
-
-        $stdout.reopen("/dev/null", "w")
-        $stderr.reopen("/dev/null", "w")
-
-      ensure
-        exit!(0)
       end
-    end
 
+    end
   end
-
 end

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

@@ -345,22 +345,26 @@ window.MessageBus = (function() {
         last_id: lastId
       });
       if (me.longPoll) {
-        return me.longPoll.abort();
+        me.longPoll.abort();
       }
+
+      return func;
     },
 
     // Unsubscribe from a channel
     unsubscribe: function(channel, func) {
-      // TODO proper globbing
+      // TODO allow for globbing in the middle of a channel name
+      // like /something/*/something
+      // at the moment we only support globbing /something/*
       var glob;
       if (channel.indexOf("*", channel.length - 1) !== -1) {
         channel = channel.substr(0, channel.length - 1);
         glob = true;
       }
 
-      var filtered = [];
+      var removed = false;
 
-      for (var i=0; i<callbacks.length; i++) {
+      for (var i=callbacks.length-1; i>=0; i--) {
 
         callback = callbacks[i];
         var keep;
@@ -375,16 +379,17 @@ window.MessageBus = (function() {
           keep = true;
         }
 
-        if (keep) {
-          filtered.push(callback);
+        if (!keep) {
+          callbacks.splice(i,1);
+          removed = true;
         }
       }
 
-      callbacks = filtered;
-
-      if (me.longPoll) {
-        return me.longPoll.abort();
+      if (removed && me.longPoll) {
+        me.longPoll.abort();
       }
+
+      return removed;
     }
   };
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: message_bus
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.4
+  version: 2.0.0.beta.5
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-28 00:00:00.000000000 Z
+date: 2016-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -79,6 +79,7 @@ files:
 - examples/bench/puma.rb
 - examples/bench/unicorn.conf.rb
 - examples/bench/wrk.sample
+- examples/chat/Gemfile
 - examples/chat/chat.rb
 - examples/chat/config.ru
 - examples/chat/docker_container/chat.yml
@@ -86,6 +87,7 @@ files:
 - examples/minimal/Gemfile
 - examples/minimal/config.ru
 - lib/message_bus.rb
+- lib/message_bus/backends/memory.rb
 - lib/message_bus/backends/postgres.rb
 - lib/message_bus/backends/redis.rb
 - lib/message_bus/client.rb