message_bus 0.0.2 → 0.9.3

data/lib/message_bus/client.rb

@@ -1,5 +1,5 @@
 class MessageBus::Client
-  attr_accessor :client_id, :user_id, :group_ids, :connect_time, :subscribed_sets, :site_id, :cleanup_timer, :async_response
+  attr_accessor :client_id, :user_id, :group_ids, :connect_time, :subscribed_sets, :site_id, :cleanup_timer, :async_response, :io
   def initialize(opts)
     self.client_id = opts[:client_id]
     self.user_id = opts[:user_id]
@@ -9,8 +9,21 @@ class MessageBus::Client
     @subscriptions = {}
   end
 
+  def in_async?
+    @async_response || @io
+  end
+
+  def ensure_closed!
+    return unless in_async?
+    write_and_close "[]"
+  rescue
+    # we may have a dead socket, just nil the @io
+    @io = nil
+    @async_response = nil
+  end
+
   def close
-    return unless @async_response
+    return unless in_async?
     write_and_close "[]"
   end
 
@@ -19,8 +32,9 @@ class MessageBus::Client
   end
 
   def subscribe(channel, last_seen_id)
+    last_seen_id = nil if last_seen_id == ""
     last_seen_id ||= MessageBus.last_id(channel)
-    @subscriptions[channel] = last_seen_id
+    @subscriptions[channel] = last_seen_id.to_i
   end
 
   def subscriptions
@@ -46,6 +60,16 @@ class MessageBus::Client
     )
   end
 
+  def filter(msg)
+    filter = MessageBus.client_filter(msg.channel)
+
+    if filter
+      filter.call(self.user_id, msg)
+    else
+      msg
+    end
+  end
+
   def backlog
     r = []
     @subscriptions.each do |k,v|
@@ -64,15 +88,29 @@ class MessageBus::Client
       end
     end
     r << MessageBus::Message.new(-1, -1, '/__status', status_message) if status_message
-    r
+
+    r.map!{|msg| filter(msg)}.compact!
+    r || []
   end
 
   protected
 
   def write_and_close(data)
-    @async_response << data
-    @async_response.done
-    @async_response = nil
+    if @io
+      @io.write("HTTP/1.1 200 OK\r\n")
+      @io.write("Content-Type: application/json; charset=utf-8\r\n")
+      @io.write("Cache-Control: must-revalidate, private, max-age=0\r\n")
+      @io.write("Content-Length: #{data.bytes.to_a.length}\r\n")
+      @io.write("Connection: close\r\n")
+      @io.write("\r\n")
+      @io.write(data)
+      @io.close
+      @io = nil
+    else
+      @async_response << data
+      @async_response.done
+      @async_response = nil
+    end
   end
 
   def messages_to_json(msgs)

data/lib/message_bus/connection_manager.rb

@@ -14,14 +14,38 @@ class MessageBus::ConnectionManager
 
       return unless subscription
 
-      subscription.each do |client_id|
-        client = @clients[client_id]
-        if client && client.allowed?(msg)
-          client << msg
-          # turns out you can delete from a set while itereating
-          remove_client(client)
+      around_filter = MessageBus.around_client_batch(msg.channel)
+
+      work = lambda do
+        subscription.each do |client_id|
+          client = @clients[client_id]
+          if client && client.allowed?(msg)
+            if copy = client.filter(msg)
+              begin
+                client << copy
+              rescue
+                # pipe may be broken, move on
+              end
+              # turns out you can delete from a set while itereating
+              remove_client(client)
+            end
+          end
+        end
+      end
+
+      if around_filter
+        user_ids = subscription.map do |s|
+          c = @clients[s]
+          c && c.user_id
+        end.compact
+
+        if user_ids && user_ids.length > 0
+          around_filter.call(msg, user_ids, work)
         end
+      else
+        work.call
       end
+
     rescue => e
       MessageBus.logger.error "notify clients crash #{e} : #{e.backtrace}"
     end
@@ -40,7 +64,7 @@ class MessageBus::ConnectionManager
     @subscriptions[c.site_id].each do |k, set|
       set.delete c.client_id
     end
-    c.cleanup_timer.cancel
+    c.cleanup_timer.cancel if c.cleanup_timer
   end
 
   def lookup_client(client_id)
@@ -56,6 +80,10 @@ class MessageBus::ConnectionManager
     set << client.client_id
   end
 
+  def client_count
+    @clients.length
+  end
+
   def stats
     {
       client_count: @clients.length,

data/lib/message_bus/em_ext.rb

@@ -0,0 +1,5 @@
+module EM
+  def self.reactor_pid
+    @reactor_pid
+  end
+end

data/lib/message_bus/rack/middleware.rb

@@ -1,17 +1,22 @@
-# our little message bus, accepts long polling and web sockets
-require 'thin'
-require 'eventmachine'
-
+# our little message bus, accepts long polling and polling
 module MessageBus::Rack; end
 
 class MessageBus::Rack::Middleware
 
   def self.start_listener
     unless @started_listener
+
+      require 'eventmachine'
+      require 'message_bus/em_ext'
+
       MessageBus.subscribe do |msg|
         if EM.reactor_running?
           EM.next_tick do
-            @@connection_manager.notify_clients(msg) if @@connection_manager
+            begin
+              @@connection_manager.notify_clients(msg) if @@connection_manager
+            rescue
+              MessageBus.logger.warn "Failed to notify clients: #{$!} #{$!.backtrace}"
+            end
           end
         end
       end
@@ -39,16 +44,16 @@ class MessageBus::Rack::Middleware
 
   def call(env)
 
-    return @app.call(env) unless env['PATH_INFO'] =~ /^\/message-bus/
+    return @app.call(env) unless env['PATH_INFO'] =~ /^\/message-bus\//
 
     # special debug/test route
-    if ::MessageBus.allow_broadcast? && env['PATH_INFO'] == '/message-bus/broadcast'
+    if ::MessageBus.allow_broadcast? && env['PATH_INFO'] == '/message-bus/broadcast'.freeze
         parsed = Rack::Request.new(env)
-        ::MessageBus.publish parsed["channel"], parsed["data"]
-        return [200,{"Content-Type" => "text/html"},["sent"]]
+        ::MessageBus.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'
+    if env['PATH_INFO'].start_with? '/message-bus/_diagnostics'.freeze
       diags = MessageBus::Rack::Diagnostics.new(@app)
       return diags.call(env)
     end
@@ -62,8 +67,6 @@ class MessageBus::Rack::Middleware
 
     client = MessageBus::Client.new(client_id: client_id, user_id: user_id, site_id: site_id, group_ids: group_ids)
 
-    connection = env['em.connection']
-
     request = Rack::Request.new(env)
     request.POST.each do |k,v|
       client.subscribe(k, v)
@@ -74,98 +77,66 @@ class MessageBus::Rack::Middleware
     headers["Cache-Control"] = "must-revalidate, private, max-age=0"
     headers["Content-Type"] ="application/json; charset=utf-8"
 
+    ensure_reactor
+
+    long_polling = MessageBus.long_polling_enabled? &&
+                   env['QUERY_STRING'] !~ /dlp=t/.freeze &&
+                   EM.reactor_running? &&
+                   @@connection_manager.client_count < MessageBus.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 MessageBus.long_polling_enabled? && env['QUERY_STRING'] !~ /dlp=t/ && EM.reactor_running?
-      response = Thin::AsyncResponse.new(env)
-      response.headers["Cache-Control"] = "must-revalidate, private, max-age=0"
-      response.headers["Content-Type"] ="application/json; charset=utf-8"
+    elsif long_polling && env['rack.hijack'] && MessageBus.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
+        response = Thin::AsyncResponse.new(env)
+      rescue NameError
+        require 'message_bus/rack/thin_ext'
+        response = Thin::AsyncResponse.new(env)
+      end
+
+      response.headers["Cache-Control"] = "must-revalidate, private, max-age=0".freeze
+      response.headers["Content-Type"] ="application/json; charset=utf-8".freeze
       response.status = 200
-      client.async_response = response
 
-      @@connection_manager.add_client(client)
+      client.async_response = response
 
-      client.cleanup_timer = ::EM::Timer.new(MessageBus.long_polling_interval.to_f / 1000) {
-        client.close
-        @@connection_manager.remove_client(client)
-      }
+      add_client_with_timeout(client)
 
       throw :async
     else
       [200, headers, ["[]"]]
     end
-
   end
-end
 
-# there is also another in cramp this is from https://github.com/macournoyer/thin_async/blob/master/lib/thin/async.rb
-module Thin
-  unless defined?(DeferrableBody)
-    # Based on version from James Tucker <raggi@rubyforge.org>
-    class DeferrableBody
-      include ::EM::Deferrable
-
-      def initialize
-        @queue = []
-      end
-
-      def call(body)
-        @queue << body
-        schedule_dequeue
-      end
-
-      def each(&blk)
-        @body_callback = blk
-        schedule_dequeue
-      end
-
-      private
-        def schedule_dequeue
-          return unless @body_callback
-          ::EM.next_tick do
-            next unless body = @queue.shift
-            body.each do |chunk|
-              @body_callback.call(chunk)
-            end
-            schedule_dequeue unless @queue.empty?
-          end
-        end
+  def ensure_reactor
+    # ensure reactor is running
+    if EM.reactor_pid != Process.pid
+      Thread.new { EM.run }
     end
   end
 
-  # Response whos body is sent asynchronously.
-  class AsyncResponse
-    include Rack::Response::Helpers
-
-    attr_reader :headers, :callback, :closed
-    attr_accessor :status
-
-    def initialize(env, status=200, headers={})
-      @callback = env['async.callback']
-      @body = DeferrableBody.new
-      @status = status
-      @headers = headers
-      @headers_sent = false
-    end
-
-    def send_headers
-      return if @headers_sent
-      @callback.call [@status, @headers, @body]
-      @headers_sent = true
-    end
-
-    def write(body)
-      send_headers
-      @body.call(body.respond_to?(:each) ? body : [body])
-    end
-    alias :<< :write
-
-    # Tell Thin the response is complete and the connection can be closed.
-    def done
-      @closed = true
-      send_headers
-      ::EM.next_tick { @body.succeed }
-    end
+  def add_client_with_timeout(client)
+    @@connection_manager.add_client(client)
 
+    client.cleanup_timer = ::EM::Timer.new(MessageBus.long_polling_interval.to_f / 1000) {
+      begin
+        client.cleanup_timer = nil
+        client.ensure_closed!
+        @@connection_manager.remove_client(client)
+      rescue
+        MessageBus.logger.warn "Failed to clean up client properly: #{$!} #{$!.backtrace}"
+      end
+    }
   end
 end
+

data/lib/message_bus/rack/thin_ext.rb

@@ -0,0 +1,71 @@
+# there is also another in cramp this is from https://github.com/macournoyer/thin_async/blob/master/lib/thin/async.rb
+module Thin
+  unless defined?(DeferrableBody)
+    # Based on version from James Tucker <raggi@rubyforge.org>
+    class DeferrableBody
+      include ::EM::Deferrable
+
+      def initialize
+        @queue = []
+      end
+
+      def call(body)
+        @queue << body
+        schedule_dequeue
+      end
+
+      def each(&blk)
+        @body_callback = blk
+        schedule_dequeue
+      end
+
+      private
+        def schedule_dequeue
+          return unless @body_callback
+          ::EM.next_tick do
+            next unless body = @queue.shift
+            body.each do |chunk|
+              @body_callback.call(chunk)
+            end
+            schedule_dequeue unless @queue.empty?
+          end
+        end
+    end
+  end
+
+  # Response whos body is sent asynchronously.
+  class AsyncResponse
+    include Rack::Response::Helpers
+
+    attr_reader :headers, :callback, :closed
+    attr_accessor :status
+
+    def initialize(env, status=200, headers={})
+      @callback = env['async.callback']
+      @body = DeferrableBody.new
+      @status = status
+      @headers = headers
+      @headers_sent = false
+    end
+
+    def send_headers
+      return if @headers_sent
+      @callback.call [@status, @headers, @body]
+      @headers_sent = true
+    end
+
+    def write(body)
+      send_headers
+      @body.call(body.respond_to?(:each) ? body : [body])
+    end
+    alias :<< :write
+
+    # Tell Thin the response is complete and the connection can be closed.
+    def done
+      @closed = true
+      send_headers
+      ::EM.next_tick { @body.succeed }
+    end
+
+  end
+end

data/lib/message_bus/rails/railtie.rb

@@ -1,9 +1,12 @@
 module MessageBus; module Rails; end; end
 
+# rails engine for asset pipeline
+class MessageBus::Rails::Engine < ::Rails::Engine; end
+
 class MessageBus::Rails::Railtie < ::Rails::Railtie
   initializer "message_bus.configure_init" do |app|
     MessageBus::MessageHandler.load_handlers("#{Rails.root}/app/message_handlers")
-    app.middleware.use MessageBus::Rack::Middleware
+    app.middleware.insert_after(ActiveRecord::QueryCache, MessageBus::Rack::Middleware)
     MessageBus.logger = Rails.logger
   end
 end