message_bus 1.1.1 → 2.0.0.beta.1

data/lib/message_bus/client.rb

@@ -1,7 +1,7 @@
 class MessageBus::Client
   attr_accessor :client_id, :user_id, :group_ids, :connect_time,
                 :subscribed_sets, :site_id, :cleanup_timer,
-                :async_response, :io, :headers, :seq
+                :async_response, :io, :headers, :seq, :use_chunked
 
   def initialize(opts)
     self.client_id = opts[:client_id]
@@ -10,8 +10,14 @@ class MessageBus::Client
     self.site_id = opts[:site_id]
     self.seq = opts[:seq].to_i
     self.connect_time = Time.now
+    @lock = Mutex.new
     @bus = opts[:message_bus] || MessageBus
     @subscriptions = {}
+    @chunks_sent = 0
+  end
+
+  def synchronize
+    @lock.synchronize { yield }
   end
 
   def cancel
@@ -27,9 +33,39 @@ class MessageBus::Client
     @async_response || @io
   end
 
+  def deliver_backlog(backlog)
+    if backlog.length > 0
+      if use_chunked
+        write_chunk(messages_to_json(backlog))
+      else
+        write_and_close messages_to_json(backlog)
+      end
+    end
+  end
+
+  def ensure_first_chunk_sent
+    if use_chunked && @chunks_sent == 0
+      write_chunk("[]".freeze)
+    end
+  end
+
   def ensure_closed!
     return unless in_async?
-    write_and_close "[]"
+    if use_chunked
+      write_chunk("[]".freeze)
+      if @io
+        @io.write("0\r\n\r\n".freeze)
+        @io.close
+        @io = nil
+      end
+      if @async_response
+        @async_response << ("0\r\n\r\n".freeze)
+        @async_response.done
+        @async_response = nil
+      end
+    else
+      write_and_close "[]"
+    end
   rescue
     # we may have a dead socket, just nil the @io
     @io = nil
@@ -37,12 +73,11 @@ class MessageBus::Client
   end
 
   def close
-    return unless in_async?
-    write_and_close "[]"
+    ensure_closed!
   end
 
-  def closed
-    !@async_response
+  def closed?
+    !@async_response && !@io
   end
 
   def subscribe(channel, last_seen_id)
@@ -56,7 +91,12 @@ class MessageBus::Client
   end
 
   def <<(msg)
-    write_and_close messages_to_json([msg])
+    json = messages_to_json([msg])
+    if use_chunked
+      write_chunk json
+    else
+      write_and_close json
+    end
   end
 
   def subscriptions
@@ -75,16 +115,6 @@ class MessageBus::Client
     )
   end
 
-  def filter(msg)
-    filter = @bus.client_filter(msg.channel)
-
-    if filter
-      filter.call(self.user_id, msg)
-    else
-      msg
-    end
-  end
-
   def backlog
     r = []
     @subscriptions.each do |k,v|
@@ -99,12 +129,11 @@ class MessageBus::Client
     @subscriptions.each do |k,v|
       if v.to_i == -1
         status_message ||= {}
-        status_message[k] = @bus.last_id(k, site_id)
+        @subscriptions[k] = status_message[k] = @bus.last_id(k, site_id)
       end
     end
     r << MessageBus::Message.new(-1, -1, '/__status', status_message) if status_message
 
-    r.map!{|msg| filter(msg)}.compact!
     r || []
   end
 
@@ -117,20 +146,69 @@ class MessageBus::Client
   HTTP_11 = "HTTP/1.1 200 OK\r\n".freeze
   CONTENT_LENGTH = "Content-Length: ".freeze
   CONNECTION_CLOSE = "Connection: close\r\n".freeze
+  CHUNKED_ENCODING = "Transfer-Encoding: chunked\r\n".freeze
+  NO_SNIFF = "X-Content-Type-Options: nosniff\r\n".freeze
+
+  TYPE_TEXT = "Content-Type: text/plain; charset=utf-8\r\n".freeze
+  TYPE_JSON = "Content-Type: application/json; charset=utf-8\r\n".freeze
+
+  def write_headers
+    @io.write(HTTP_11)
+    @headers.each do |k,v|
+      next if k == "Content-Type"
+      @io.write(k)
+      @io.write(COLON_SPACE)
+      @io.write(v)
+      @io.write(NEWLINE)
+    end
+    @io.write(CONNECTION_CLOSE)
+    if use_chunked
+      @io.write(TYPE_TEXT)
+    else
+      @io.write(TYPE_JSON)
+    end
+  end
+
+  def write_chunk(data)
+    @bus.logger.debug "Delivering messages #{data} to client #{client_id} for user #{user_id} (chunked)"
+    if @io && !@wrote_headers
+      write_headers
+      @io.write(CHUNKED_ENCODING)
+      # this is required otherwise chrome will delay onprogress calls
+      @io.write(NO_SNIFF)
+      @io.write(NEWLINE)
+      @wrote_headers = true
+    end
+
+    # chunked encoding may be "re-chunked" by proxies, so add a seperator
+    postfix = NEWLINE + "|" + NEWLINE
+    data = data.gsub(postfix, NEWLINE + "||" + NEWLINE)
+    chunk_length = data.bytesize + postfix.bytesize
+
+    @chunks_sent += 1
+
+    if @async_response
+      @async_response << chunk_length.to_s(16)
+      @async_response << NEWLINE
+      @async_response << data
+      @async_response << postfix
+      @async_response << NEWLINE
+    else
+      @io.write(chunk_length.to_s(16))
+      @io.write(NEWLINE)
+      @io.write(data)
+      @io.write(postfix)
+      @io.write(NEWLINE)
+    end
+  end
 
   def write_and_close(data)
+    @bus.logger.debug "Delivering messages #{data} to client #{client_id} for user #{user_id}"
     if @io
-      @io.write(HTTP_11)
-      @headers.each do |k,v|
-        @io.write(k)
-        @io.write(COLON_SPACE)
-        @io.write(v)
-        @io.write(NEWLINE)
-      end
+      write_headers
       @io.write(CONTENT_LENGTH)
       @io.write(data.bytes.to_a.length)
       @io.write(NEWLINE)
-      @io.write(CONNECTION_CLOSE)
       @io.write(NEWLINE)
       @io.write(data)
       @io.close

data/lib/message_bus/connection_manager.rb

@@ -19,38 +19,21 @@ class MessageBus::ConnectionManager
 
         return unless subscription
 
-        around_filter = @bus.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)
+        subscription.each do |client_id|
+          client = @clients[client_id]
+          if client && client.allowed?(msg)
+            begin
+              client.synchronize do
+                client << msg
               end
+            rescue
+              # pipe may be broken, move on
             end
+            # turns out you can delete from a set while itereating
+            remove_client(client) if client.closed?
           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

data/lib/message_bus/rack/middleware.rb

@@ -93,9 +93,7 @@ class MessageBus::Rack::Middleware
       end
     end
 
-    backlog = client.backlog
     headers = {}
-
     headers["Cache-Control"] = "must-revalidate, private, max-age=0"
     headers["Content-Type"] = "application/json; charset=utf-8"
     headers["Pragma"] = "no-cache"
@@ -115,14 +113,28 @@ class MessageBus::Rack::Middleware
                    env['QUERY_STRING'] !~ /dlp=t/.freeze &&
                    @connection_manager.client_count < @bus.max_active_clients
 
-    if backlog.length > 0
+    allow_chunked = env['HTTP_VERSION'.freeze] == 'HTTP/1.1'.freeze
+    allow_chunked &&= !env['HTTP_DONT_CHUNK'.freeze]
+    allow_chunked &&= @bus.chunked_encoding_enabled?
+
+    client.use_chunked = allow_chunked
+
+    backlog = client.backlog
+
+    if backlog.length > 0 && !allow_chunked
+      client.cancel
+      @bus.logger.debug "Delivering backlog #{backlog} to client #{client_id} for user #{user_id}"
       [200, headers, [self.class.backlog_to_json(backlog)] ]
     elsif long_polling && env['rack.hijack'] && @bus.rack_hijack_enabled?
       io = env['rack.hijack'].call
+      # TODO disable client till deliver backlog is called
       client.io = io
       client.headers = headers
-
-      add_client_with_timeout(client)
+      client.synchronize do
+        client.deliver_backlog(backlog)
+        add_client_with_timeout(client)
+        client.ensure_first_chunk_sent
+      end
       [418, {}, ["I'm a teapot, undefined in spec"]]
     elsif long_polling && env['async.callback']
       response = nil
@@ -137,11 +149,20 @@ class MessageBus::Rack::Middleware
       headers.each do |k,v|
         response.headers[k] = v
       end
-      response.status = 200
 
-      client.async_response = response
+      if allow_chunked
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["Transfer-Encoding"] = "chunked"
+        response.headers["Content-Type"] = "text/plain; charset=utf-8"
+      end
 
-      add_client_with_timeout(client)
+      response.status = 200
+      client.async_response = response
+      client.synchronize do
+        add_client_with_timeout(client)
+        client.deliver_backlog(backlog)
+        client.ensure_first_chunk_sent
+      end
 
       throw :async
     else

data/lib/message_bus/rails/railtie.rb

@@ -5,15 +5,18 @@ 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")
-
     # We want MessageBus to show up after the session middleware, but depending on how
     # the Rails app is configured that might be ActionDispatch::Session::CookieStore, or potentially
     # ActionDispatch::Session::ActiveRecordStore.
     #
     # To handle either case, we insert it before ActionDispatch::Flash.
     #
-    app.middleware.insert_before(ActionDispatch::Flash, MessageBus::Rack::Middleware)
+    begin
+      app.middleware.insert_before(ActionDispatch::Flash, MessageBus::Rack::Middleware)
+    rescue
+      app.middleware.use(MessageBus::Rack::Middleware)
+    end
+
     MessageBus.logger = Rails.logger
   end
 end

data/lib/message_bus/version.rb

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

data/spec/lib/fake_async_middleware.rb

@@ -23,6 +23,10 @@ class FakeAsyncMiddleware
     @simulate_hijack = true
   end
 
+  def allow_chunked
+    @allow_chunked = true
+  end
+
   def in_async?
     @in_async
   end
@@ -37,6 +41,9 @@ class FakeAsyncMiddleware
   end
 
   def call(env)
+    unless @allow_chunked
+      env['HTTP_DONT_CHUNK'] = 'True'
+    end
     if simulate_thin_async?
       call_thin_async(env)
     elsif simulate_hijack?

data/spec/lib/{assets → message_bus/assets}/asset_encoding_spec.rb

@@ -1,4 +1,4 @@
-asset_directory = File.expand_path('../../../../assets', __FILE__)
+asset_directory = File.expand_path('../../../../../assets', __FILE__)
 asset_file_paths = Dir.glob(File.join(asset_directory, 'message-bus.js'))
 asset_file_names = asset_file_paths.map{|e| File.basename(e) }
 

data/spec/lib/{client_spec.rb → message_bus/client_spec.rb}

@@ -15,6 +15,84 @@ describe MessageBus::Client do
       @bus.destroy
     end
 
+    def http_parse(message)
+      lines = message.split("\r\n")
+
+      status = lines.shift.split(" ")[1]
+      headers = {}
+      chunks = []
+
+      while line = lines.shift
+        break if line == ""
+        name,val = line.split(": ")
+        headers[name] = val
+      end
+
+      length = nil
+      while line = lines.shift
+        length = line.to_i(16)
+        break if length == 0
+        rest = lines.join("\r\n")
+        chunks << rest[0...length]
+        lines = (rest[length+2..-1] || "").split("\r\n")
+      end
+
+      # split/join gets tricky
+      chunks[-1] << "\r\n"
+
+      [status, headers, chunks]
+    end
+
+    def parse_chunk(data)
+      payload,_ = data.split(/\r\n\|\r\n/m)
+      JSON.parse(payload)
+    end
+
+    it "can chunk replies" do
+      @client.use_chunked = true
+      r,w = IO.pipe
+      @client.io = w
+      @client.headers = {"Content-Type" => "application/json; charset=utf-8"}
+      @client << MessageBus::Message.new(1, 1, '/test', 'test')
+      @client << MessageBus::Message.new(2, 2, '/test', "a|\r\n|\r\n|b")
+
+      lines = r.read_nonblock(8000)
+
+      status, headers, chunks = http_parse(lines)
+
+      headers["Content-Type"].should == "text/plain; charset=utf-8"
+      status.should == "200"
+      chunks.length.should == 2
+
+      chunk1 = parse_chunk(chunks[0])
+      chunk1.length.should == 1
+      chunk1.first["data"].should == 'test'
+
+      chunk2 = parse_chunk(chunks[1])
+      chunk2.length.should == 1
+      chunk2.first["data"].should == "a|\r\n|\r\n|b"
+
+      @client << MessageBus::Message.new(3, 3, '/test', 'test3')
+      @client.close
+
+      data = r.read
+
+      data[-5..-1].should == "0\r\n\r\n"
+
+      _,_,chunks = http_parse("HTTP/1.1 200 OK\r\n\r\n" << data)
+
+      chunks.length.should == 2
+
+      chunk1 = parse_chunk(chunks[0])
+      chunk1.length.should == 1
+      chunk1.first["data"].should == 'test3'
+
+      # end with []
+      chunk2 = parse_chunk(chunks[1])
+      chunk2.length.should == 0
+
+    end
+
     it "does not bleed data accross sites" do
       @client.site_id = "test"