message_bus 0.0.2 → 0.9.3

data/lib/message_bus/reliable_pub_sub.rb

@@ -10,6 +10,8 @@ require 'redis'
 
 class MessageBus::ReliablePubSub
 
+  UNSUB_MESSAGE = "$$UNSUBSCRIBE"
+
   class NoMoreRetries < StandardError; end
   class BackLogOutOfOrder < StandardError
     attr_accessor :highest_id
@@ -57,6 +59,10 @@ class MessageBus::ReliablePubSub
     ::Redis.new(@redis_config)
   end
 
+  def after_fork
+    pub_redis.client.reconnect
+  end
+
   def redis_channel_name
     db = @redis_config[:db] || 0
     "discourse_#{db}"
@@ -126,9 +132,8 @@ class MessageBus::ReliablePubSub
   end
 
   def last_id(channel)
-    redis = pub_redis
     backlog_id_key = backlog_id_key(channel)
-    redis.get(backlog_id_key).to_i
+    pub_redis.get(backlog_id_key).to_i
   end
 
   def backlog(channel, last_id = nil)
@@ -206,6 +211,15 @@ class MessageBus::ReliablePubSub
     highest_id
   end
 
+  def global_unsubscribe
+    # TODO mutex
+    if @redis_global
+      pub_redis.publish(redis_channel_name, UNSUB_MESSAGE)
+      @redis_global.disconnect
+      @redis_global = nil
+    end
+  end
+
   def global_subscribe(last_id=nil, &blk)
     raise ArgumentError unless block_given?
     highest_id = last_id
@@ -224,19 +238,23 @@ class MessageBus::ReliablePubSub
 
 
     begin
-      redis = new_redis_connection
+      @redis_global = new_redis_connection
 
       if highest_id
         clear_backlog.call(&blk)
       end
 
-      redis.subscribe(redis_channel_name) do |on|
+      @redis_global.subscribe(redis_channel_name) do |on|
         on.subscribe do
           if highest_id
             clear_backlog.call(&blk)
           end
         end
         on.message do |c,m|
+          if m == UNSUB_MESSAGE
+            @redis_global.unsubscribe
+            return
+          end
           m = MessageBus::Message.decode m
 
           # we have 2 options

data/lib/message_bus/version.rb

@@ -1,3 +1,3 @@
 module MessageBus
-  VERSION = "0.0.2"
+  VERSION = "0.9.3"
 end

data/message_bus.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/message_bus/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sam Saffron"]
+  gem.email         = ["sam.saffron@gmail.com"]
+  gem.description   = %q{A message bus for rack}
+  gem.summary       = %q{}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "message_bus"
+  gem.require_paths = ["lib"]
+  gem.version       = MessageBus::VERSION
+  gem.add_runtime_dependency 'rack', '>= 1.1.3'
+  gem.add_runtime_dependency 'eventmachine'
+  gem.add_runtime_dependency 'redis'
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'message_bus'
+
+describe MessageBus::Client do
+
+  describe "subscriptions" do
+
+    before do
+      @client = MessageBus::Client.new :client_id => 'abc'
+    end
+
+    it "should provide a list of subscriptions" do
+      @client.subscribe('/hello', nil)
+      @client.subscriptions['/hello'].should_not be_nil
+    end
+
+    it "should provide backlog for subscribed channel" do
+      @client.subscribe('/hello', nil)
+      MessageBus.publish '/hello', 'world'
+      log = @client.backlog
+      log.length.should == 1
+      log[0].channel.should == '/hello'
+      log[0].data.should == 'world'
+    end
+
+    context "targetted at group" do
+      before do
+        @message = MessageBus::Message.new(1,2,'/test', 'hello')
+        @message.group_ids = [1,2,3]
+      end
+
+      it "denies users that are not members of group" do
+        @client.group_ids = [77,0,10]
+        @client.allowed?(@message).should be_false
+      end
+
+      it "allows users that are members of group" do
+        @client.group_ids = [1,2,3]
+        @client.allowed?(@message).should be_true
+      end
+
+      it "allows all users if groups not set" do
+        @message.group_ids = nil
+        @client.group_ids = [77,0,10]
+        @client.allowed?(@message).should be_true
+      end
+    end
+  end
+
+end

data/spec/lib/connection_manager_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'message_bus'
+
+class FakeAsync
+
+  attr_accessor :cleanup_timer
+
+  def <<(val)
+    @sent ||= ""
+    @sent << val
+  end
+
+  def sent; @sent; end
+  def done; @done = true; end
+  def done?; @done; end
+end
+
+class FakeTimer
+  attr_accessor :cancelled
+  def cancel; @cancelled = true; end
+end
+
+describe MessageBus::ConnectionManager do
+
+  before do
+    @manager = MessageBus::ConnectionManager.new
+    @client = MessageBus::Client.new(client_id: "xyz", user_id: 1, site_id: 10)
+    @resp = FakeAsync.new
+    @client.async_response = @resp
+    @client.subscribe('test', -1)
+    @manager.add_client(@client)
+    @client.cleanup_timer = FakeTimer.new
+  end
+
+  it "should cancel the timer after its responds" do
+    m = MessageBus::Message.new(1,1,"test","data")
+    m.site_id = 10
+    @manager.notify_clients(m)
+    @client.cleanup_timer.cancelled.should == true
+  end
+
+  it "should be able to lookup an identical client" do
+    @manager.lookup_client(@client.client_id).should == @client
+  end
+
+  it "should be subscribed to a channel" do
+    @manager.stats[:subscriptions][10]["test"].length == 1
+  end
+
+  it "should not notify clients on incorrect site" do
+    m = MessageBus::Message.new(1,1,"test","data")
+    m.site_id = 9
+    @manager.notify_clients(m)
+    @resp.sent.should == nil
+  end
+
+  it "should notify clients on the correct site" do
+    m = MessageBus::Message.new(1,1,"test","data")
+    m.site_id = 10
+    @manager.notify_clients(m)
+    @resp.sent.should_not == nil
+  end
+
+  it "should strip site id and user id from the payload delivered" do
+    m = MessageBus::Message.new(1,1,"test","data")
+    m.user_ids = [1]
+    m.site_id = 10
+    @manager.notify_clients(m)
+    parsed = JSON.parse(@resp.sent)
+    parsed[0]["site_id"].should == nil
+    parsed[0]["user_id"].should == nil
+  end
+
+  it "should not deliver unselected" do
+    m = MessageBus::Message.new(1,1,"test","data")
+    m.user_ids = [5]
+    m.site_id = 10
+    @manager.notify_clients(m)
+    @resp.sent.should == nil
+  end
+
+
+end

data/spec/lib/fake_async_middleware.rb

@@ -0,0 +1,134 @@
+require 'http/parser'
+class FakeAsyncMiddleware
+
+  def self.simulate_thin_async
+    @@simulate_thin_async = true
+    @@simulate_hijack = false
+  end
+
+  def self.simulate_hijack
+    @@simulate_thin_async = false
+    @@simulate_hijack = true
+  end
+
+  def self.in_async?
+    @@in_async if defined? @@in_async
+  end
+
+  def initialize(app,config={})
+    @app = app
+  end
+
+  def simulate_thin_async
+    @@simulate_thin_async && MessageBus.long_polling_enabled?
+  end
+
+  def simulate_hijack
+    @@simulate_hijack && MessageBus.long_polling_enabled?
+  end
+
+  def call(env)
+    if simulate_thin_async
+      call_thin_async(env)
+    elsif simulate_hijack
+      call_rack_hijack(env)
+    else 
+      @app.call(env)
+    end
+  end
+
+  def translate_io_result(io)
+    data = io.string
+    body = ""
+
+    parser = Http::Parser.new
+    parser.on_body = proc { |chunk| body << chunk }
+    parser << data
+
+    [parser.status_code, parser.headers, [body]]
+  end
+
+
+  def call_rack_hijack(env)
+    # this is not to spec, the spec actually return, but here we will simply simulate and block
+    result = nil
+    hijacked = false
+    io = nil
+
+    EM.run {
+      env['rack.hijack'] = lambda {
+        hijacked = true
+        io = StringIO.new
+      }
+
+      env['rack.hijack_io'] = io
+
+      result = @app.call(env)
+      
+      EM::Timer.new(1) { EM.stop }
+
+      defer = lambda {
+        if !io || !io.closed?
+          @@in_async = true
+          EM.next_tick do
+            defer.call
+          end
+        else
+          if io.closed?
+            result = translate_io_result(io)
+          end
+          EM.next_tick { EM.stop }
+        end
+      }
+
+      if !hijacked
+        EM.next_tick { EM.stop }
+      else
+        defer.call
+      end
+    }
+
+    @@in_async = false
+    result || [500, {}, ['timeout']]
+
+  end
+
+  def call_thin_async(env)
+    result = nil
+    EM.run {
+      env['async.callback'] = lambda { |r|
+        # more judo with deferrable body, at this point we just have headers
+        r[2].callback do
+          # even more judo cause rack test does not call each like the spec says
+          body = ""
+          r[2].each do |m|
+            body << m
+          end
+          r[2] = [body]
+          result = r
+        end
+      }
+      catch(:async) {
+        result = @app.call(env)
+      }
+
+      EM::Timer.new(1) { EM.stop }
+
+      defer = lambda {
+        if !result
+          @@in_async = true
+          EM.next_tick do
+            defer.call
+          end
+        else
+          EM.next_tick { EM.stop }
+        end
+      }
+      defer.call
+    }
+
+    @@in_async = false
+    result || [500, {}, ['timeout']]
+  end
+end
+

data/spec/lib/handlers/demo_message_handler.rb

@@ -0,0 +1,5 @@
+class DemoMessageHandler < MessageBus::MessageHandler
+  handle "/dupe" do |m, uid|
+    "#{m}#{m}"
+  end
+end

data/spec/lib/message_bus_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'message_bus'
+require 'redis'
+
+
+describe MessageBus do
+
+  before do
+    @bus = MessageBus::Instance.new
+    @bus.site_id_lookup do
+      "magic"
+    end
+    @bus.redis_config = {}
+  end
+
+  after do
+    @bus.destroy
+  end
+
+  it "should automatically decode hashed messages" do
+    data = nil
+    @bus.subscribe("/chuck") do |msg|
+      data = msg.data
+    end
+    @bus.publish("/chuck", {:norris => true})
+    wait_for(2000){ data }
+
+    data["norris"].should == true
+  end
+
+  it "should get a message if it subscribes to it" do
+    user_ids,data,site_id,channel = nil
+
+    @bus.subscribe("/chuck") do |msg|
+      data = msg.data
+      site_id = msg.site_id
+      channel = msg.channel
+      user_ids = msg.user_ids
+    end
+
+    @bus.publish("/chuck", "norris", user_ids: [1,2,3])
+
+    wait_for(2000){data}
+
+    data.should == 'norris'
+    site_id.should == 'magic'
+    channel.should == '/chuck'
+    user_ids.should == [1,2,3]
+
+  end
+
+
+  it "should get global messages if it subscribes to them" do
+    data,site_id,channel = nil
+
+    @bus.subscribe do |msg|
+      data = msg.data
+      site_id = msg.site_id
+      channel = msg.channel
+    end
+
+    @bus.publish("/chuck", "norris")
+
+    wait_for(2000){data}
+
+    data.should == 'norris'
+    site_id.should == 'magic'
+    channel.should == '/chuck'
+
+  end
+
+  it "should have the ability to grab the backlog messages in the correct order" do
+    id = @bus.publish("/chuck", "norris")
+    @bus.publish("/chuck", "foo")
+    @bus.publish("/chuck", "bar")
+
+    r = @bus.backlog("/chuck", id)
+
+    r.map{|i| i.data}.to_a.should == ['foo', 'bar']
+  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 }
+    if child = Process.fork
+      wait_for(2000) { data == "ready" }
+      @bus.publish("/hello", "world1")
+      wait_for(2000) { data == "got it" }
+      data.should == "got it"
+      Process.wait(child)
+    else
+      @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")
+      exit
+    end
+
+  end
+
+end