firehose 1.0.0 → 1.1.0

data/lib/assets/javascripts/firehose/consumer.js.coffee

@@ -22,22 +22,25 @@ class Firehose.Consumer
     this
 
   connect: (delay=0) =>
+    @config.connectionVerified = @_upgradeTransport
     if Firehose.WebSocket.supported()
       @upgradeTimeout = setTimeout =>
-        @config.connectionVerified = @_upgradeTransport
         ws = new Firehose.WebSocket @config
         ws.connect delay
       , 500
     @transport = new Firehose.LongPoll @config
     @transport.connect delay
+    return
 
   stop: =>
     if @upgradeTimeout?
       clearTimeout @upgradeTimeout
       @upgradeTimeout = null
     @transport.stop()
+    return
 
   _upgradeTransport: (ws) =>
     @transport.stop()
     ws.sendStartingMessageSequence @transport.getLastMessageSequence()
     @transport = ws
+    return

data/lib/assets/javascripts/firehose/long_poll.js.coffee

@@ -26,18 +26,8 @@ class Firehose.LongPoll extends Firehose.Transport
     @_lagTime         = 5000
     @_timeout         = @config.longPoll.timeout + @_lagTime
     @_okInterval      = 0
-    @_isConnected     = false
     @_stopRequestLoop = false
 
-  connect: (delay = 0) =>
-    unless @_isConnected
-      @_isConnected = true
-      @config.connected()
-    super(delay)
-
-  getLastMessageSequence: =>
-    @_lastMessageSequence or 0
-
   _request: =>
     return if @_stopRequestLoop
     # Set the Last Message Sequence in a query string.
@@ -47,7 +37,7 @@ class Firehose.LongPoll extends Firehose.Transport
     data.last_message_sequence = @_lastMessageSequence
     # TODO: Some of these options will be deprecated in jQuery 1.8
     #       See: http://api.jquery.com/jQuery.ajax/#jqXHR
-    $.ajax
+    @_lastRequest = $.ajax
       url:          @config.longPoll.url
       crossDomain:  true
       data:         data
@@ -58,9 +48,17 @@ class Firehose.LongPoll extends Firehose.Transport
 
   stop: =>
     @_stopRequestLoop = true
+    if @_lastRequest?
+      try @_lastRequest.abort() catch e
+      delete @_lastRequest
+    if @_lastPingRequest?
+      try @_lastPingRequest.abort() catch e
+      delete @_lastPingRequest
 
   _success: (data, status, jqXhr) =>
-    @_open data unless @_succeeded
+    if @_needToNotifyOfReconnect or not @_succeeded
+      @_needToNotifyOfReconnect = false
+      @_open data
     return if @_stopRequestLoop
     if jqXhr.status is 200
       # Of course, IE's XDomainRequest doesn't support non-200 success codes.
@@ -75,18 +73,22 @@ class Firehose.LongPoll extends Firehose.Transport
     # Ping long poll server to verify internet connectivity
     # jQuery CORS doesn't support timeouts and there is no way to access xhr2 object
     # directly so we can't manually set a timeout.
-    $.ajax
-      url: @config.longPoll.url
-      method: 'HEAD'
-      crossDomain: true
-      data: @config.params
-      success: @config.connected
+    @_lastPingRequest = $.ajax
+      url:          @config.longPoll.url
+      method:       'HEAD'
+      crossDomain:  true
+      data:         @config.params
+      success:      =>
+        if @_needToNotifyOfReconnect
+          @_needToNotifyOfReconnect = false
+          @config.connected @
 
   # We need this custom handler to have the connection status
   # properly displayed
   _error: (jqXhr, status, error) =>
-    @_isConnected = false
-    @config.disconnected()
+    unless @_needToNotifyOfReconnect or @_stopRequestLoop
+      @_needToNotifyOfReconnect = true
+      @config.disconnected()
     unless @_stopRequestLoop
       # Ping the server to make sure this isn't a network connectivity error
       setTimeout @_ping, @_retryDelay + @_lagTime

data/lib/assets/javascripts/firehose/transport.js.coffee

@@ -6,8 +6,8 @@ class Firehose.Transport
     false
 
   constructor: (config={}) ->
-    @config = config
-    @_retryDelay = 5000 
+    @config      = config
+    @_retryDelay = 3000
 
   # Lets rock'n'roll! Connect to the server.
   connect: (delay = 0) =>
@@ -34,4 +34,8 @@ class Firehose.Transport
 
   # Default connection closed handler
   _close: (event) =>
-    @config.disconnected()
+    @config.disconnected()
+
+  # Useful for reconnecting after any networking hiccups
+  getLastMessageSequence: =>
+    @_lastMessageSequence or 0

data/lib/assets/javascripts/firehose/web_socket.js.coffee

@@ -27,25 +27,35 @@ class Firehose.WebSocket extends Firehose.Transport
     @socket.onerror   = @_error
     @socket.onmessage = @_lookForInitialPong
 
+  _open: =>
+    sendPing @socket
+
   _lookForInitialPong: (event) =>
+    @_restartKeepAlive()
     if isPong(try JSON.parse event.data catch e then {})
-      @config.webSocket.connectionVerified @
+      if @_lastMessageSequence?
+        # don't callback to connectionVerified on subsequent reconnects
+        @sendStartingMessageSequence @_lastMessageSequence
+      else @config.webSocket.connectionVerified @
 
   sendStartingMessageSequence: (message_sequence) =>
-    @socket.onmessage = @_message
+    @_lastMessageSequence = message_sequence
+    @socket.onmessage     = @_message
     @socket.send JSON.stringify {message_sequence}
+    @_needToNotifyOfDisconnect = true
+    Firehose.Transport::_open.call @
 
   stop: =>
     @_cleanUp()
 
-  _open: =>
-    sendPing @socket
-    super
-
   _message: (event) =>
+    frame = @config.parse event.data
     @_restartKeepAlive()
-    msg = @config.parse event.data
-    @config.message msg if not isPong msg
+    unless isPong frame
+      try
+        @_lastMessageSequence = frame.last_sequence
+        @config.message @config.parse frame.message
+      catch e
 
   _close: (event) =>
     if event?.wasClean then @_cleanUp()
@@ -53,7 +63,11 @@ class Firehose.WebSocket extends Firehose.Transport
 
   _error: (event) =>
     @_cleanUp()
-    super
+    if @_needToNotifyOfDisconnect
+      @_needToNotifyOfDisconnect = false
+      @config.disconnected()
+    if @_succeeded then @connect @_retryDelay
+    else @config.failed @
 
   _cleanUp: =>
     @_clearKeepalive()

data/lib/firehose/rack/consumer_app.rb

@@ -93,74 +93,69 @@ module Firehose
       end
 
 
-      # It _may_ be more memory efficient if we used the same instance of this
-      # class (or even if we just used a proc/lambda) for every
-      # request/connection. However, we couldn't use instance variables, and
-      # so I'd need to confirm that local variables would be accessible from
-      # the callback blocks.
+      # It _may_ be more memory efficient if we used the same instance of
+      # this class (or if we even just used a lambda) for every connection.
       class WebSocket
         def call(env)
-          req = ::Rack::Request.new(env)
-          ws  = Faye::WebSocket.new(env)
+          req   = ::Rack::Request.new env
+          @ws   = Faye::WebSocket.new env
           @path = req.path
+          @ws.onopen    = method :handle_open
+          @ws.onclose   = method :handle_close
+          @ws.onerror   = method :handle_error
+          @ws.onmessage = method :handle_message
+          return @ws.rack_response
+        end
 
-          subscribe = Proc.new do |last_sequence|
-            @channel = Channel.new(@path)
-            @deferrable = @channel.next_message(last_sequence).callback do |message, sequence|
-              Firehose.logger.debug "WS sent `#{message}` to `#{@path}` with sequence `#{sequence}`"
-              ws.send message
-              subscribe.call(sequence)
-            end.errback { |e| EM.next_tick { raise e.inspect } unless e == :disconnect }
-          end
+      private
 
-          handle_ping = lambda do |event|
-            msg = JSON.parse(event.data, :symbolize_names => true) rescue {}
-            if msg[:ping] == 'PING'
-              Firehose.logger.debug "WS ping received, sending pong"
-              ws.send JSON.generate :pong => 'PONG'
-            end
+        def subscribe(last_sequence)
+          @subscribed = true
+          @channel    = Channel.new @path
+          @deferrable = @channel.next_message last_sequence
+          @deferrable.callback do |message, sequence|
+            Firehose.logger.debug "WS sent `#{message}` to `#{@path}` with sequence `#{sequence}`"
+            @ws.send self.class.wrap_frame(message, last_sequence)
+            subscribe sequence
           end
-
-          wait_for_starting_sequence = lambda do |event|
-            msg = JSON.parse(event.data, :symbolize_names => true) rescue {}
-            seq = msg[:message_sequence]
-            if seq.kind_of? Integer
-              Firehose.logger.debug "Subscribing at message_sequence #{seq}"
-              subscribe.call seq
-              ws.onmessage = handle_ping
-            end
+          @deferrable.errback do |e|
+            EM.next_tick { raise e.inspect } unless e == :disconnect
           end
+        end
 
-          wait_for_ping = lambda do |event|
-            msg = JSON.parse(event.data, :symbolize_names => true) rescue {}
-            if msg[:ping] == 'PING'
-              Firehose.logger.debug "WS ping received, sending pong and waiting for starting sequence..."
-              ws.send JSON.generate :pong => 'PONG'
-              ws.onmessage = wait_for_starting_sequence
-            end
+        def handle_message(event)
+          msg = JSON.parse(event.data, :symbolize_names => true) rescue {}
+          seq = msg[:message_sequence]
+          if msg[:ping] == 'PING'
+            Firehose.logger.debug "WS ping received, sending pong"
+            @ws.send JSON.generate :pong => 'PONG'
+          elsif !@subscribed && seq.kind_of?(Integer)
+            Firehose.logger.debug "Subscribing at message_sequence #{seq}"
+            subscribe seq
           end
+        end
 
-          ws.onopen = lambda do |event|
-            Firehose.logger.debug "WebSocket subscribed to `#{@path}`. Waiting for ping..."
-            ws.onmessage = wait_for_ping
-          end
+        def handle_open(event)
+          Firehose.logger.debug "WebSocket subscribed to `#{@path}`. Waiting for message_sequence..."
+        end
 
-          ws.onclose = lambda do |event|
-            if @deferrable
-              @deferrable.fail :disconnect
-              @channel.unsubscribe(@deferrable) if @channel
-            end
-            Firehose.logger.debug "WS connection `#{@path}` closing. Code: #{event.code.inspect}; Reason #{event.reason.inspect}"
+        def handle_close(event)
+          if @deferrable
+            @deferrable.fail :disconnect
+            @channel.unsubscribe(@deferrable) if @channel
           end
+          Firehose.logger.debug "WS connection `#{@path}` closing. Code: #{event.code.inspect}; Reason #{event.reason.inspect}"
+        end
 
-          ws.onerror = lambda do |event|
-            Firehose.logger.error "WS connection `#{@path}` error `#{error}`: #{error.backtrace}"
-          end
+        def handle_error(event)
+          Firehose.logger.error "WS connection `#{@path}` error `#{error}`: #{error.backtrace}"
+        end
 
-          # Return async Rack response
-          ws.rack_response
+        def self.wrap_frame(message, last_sequence)
+          JSON.generate :message => message, :last_sequence => last_sequence
         end
       end
+
     end
   end
 end

data/lib/firehose/version.rb

@@ -1,4 +1,4 @@
 module Firehose
-  VERSION  = "1.0.0"
-  CODENAME = "Concerted Connection Upgrades"
+  VERSION  = "1.1.0"
+  CODENAME = "Rockin' Reconnect"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: firehose
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000 Z
+date: 2012-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine