firehose 1.3.6 → 2.1.0

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

@@ -1,210 +0,0 @@
-class Firehose.LongPoll extends Firehose.Transport
-  messageSequenceHeader: 'Pragma'
-  name: -> 'LongPoll'
-
-  # CORS is kinda supported in IE8+ except that its implementation cannot
-  # access "simple request" response headers. This means we don't yet have a
-  # plan to support IE<10 (when it gets a real XHR2 implementation). Sucks...
-  # $.browser.msie and parseInt($.browser.version) >= 8 # DEPRECATED
-  @ieSupported: -> (document.documentMode || 10) >= 8
-
-  @supported: ->
-    # IE 8+, FF 3.5+, Chrome 4+, Safari 4+, Opera 12+, iOS 3.2+, Android 2.1+
-    if xhr = $.ajaxSettings.xhr()
-      "withCredentials" of xhr || Firehose.LongPoll.ieSupported()
-
-  constructor: (args) ->
-    super args
-
-    @config.ssl ?= false
-
-    # Configrations specifically for long polling
-    @config.longPoll         ||= {}
-    @config.longPoll.url     ||= "#{@_protocol()}:#{@config.uri}"
-    # How many ms should we wait before timing out the AJAX connection?
-    @config.longPoll.timeout ||= 25000
-    # TODO - What is @_lagTime for? Can't we just use the @_timeout value?
-    # We use the lag time to make the client live longer than the server.
-    @_lagTime                  = 5000
-    @_timeout                  = @config.longPoll.timeout + @_lagTime
-    @_okInterval               = @config.okInterval || 0
-    @_stopRequestLoop          = false
-    @_lastMessageSequence      = 0
-
-  # Protocol schema we should use for talking to firehose server.
-  _protocol: =>
-    if @config.ssl then "https" else "http"
-
-  _request: =>
-    return if @_stopRequestLoop
-    # Set the Last Message Sequence in a query string.
-    # Ideally we'd use an HTTP header, but android devices don't let us
-    # set any HTTP headers for CORS requests.
-    data = @_requestParams()
-    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
-    @_lastRequest = $.ajax
-      url:          @config.longPoll.url
-      firehose:     true
-      crossDomain:  true
-      data:         data
-      timeout:      @_timeout
-      success:      @_success
-      error:        @_error
-      cache:        false
-
-  _requestParams: =>
-    @config.params
-
-  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) =>
-    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.
-      try
-        {message, last_sequence} = JSON.parse jqXhr.responseText
-        @_lastMessageSequence    = last_sequence || 0
-        @config.message @config.parse message
-      catch e
-    @connect @_okInterval
-
-  _ping: =>
-    # 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.
-    @_lastPingRequest = $.ajax
-      url:          @config.uri
-      method:       'HEAD'
-      crossDomain:  true
-      firehose:     true
-      data:         @_requestParams()
-      success:      =>
-        if @_needToNotifyOfReconnect
-          @_needToNotifyOfReconnect = false
-          @config.connected @
-
-  # We need this custom handler to have the connection status
-  # properly displayed
-  _error: (jqXhr, status, error) =>
-    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
-      # Reconnect with delay
-      setTimeout @_request, @_retryDelay
-
-# Let's try to hack in support for IE8-9 via the XDomainRequest object!
-# This was adapted from code shamelessly stolen from:
-# https://github.com/jaubourg/ajaxHooks/blob/master/src/ajax/xdr.js
-if $?.browser?.msie and parseInt($.browser.version, 10) in [8, 9]
-  jQuery.ajaxTransport (s) ->
-    if s.crossDomain and s.async and s.firehose
-      if s.timeout
-        s.xdrTimeout = s.timeout
-        delete s.timeout
-      xdr = undefined
-      return {
-        send: (_, complete) ->
-          callback = (status, statusText, responses, responseHeaders) ->
-            xdr.onload = xdr.onerror = xdr.ontimeout = jQuery.noop
-            xdr = undefined
-            complete status, statusText, responses, responseHeaders
-
-          xdr = new XDomainRequest()
-
-          xdr.open s.type, s.url
-
-          xdr.onload = ->
-            headers = "Content-Type: #{xdr.contentType}"
-            callback 200, "OK", {text: xdr.responseText}, headers
-
-          xdr.onerror = -> callback 404, "Not Found"
-
-          # This is critical for long poll to work in IE9.
-          # Without it, the initial request will work but
-          # subsequent requests will fail silently.
-          # http://social.msdn.microsoft.com/Forums/ie/en-US/30ef3add-767c-4436-b8a9-f1ca19b4812e/ie9-rtm-xdomainrequest-issued-requests-may-abort-if-all-event-handlers-not-specified?forum=iewebdevelopment
-          xdr.onprogress = -> {}
-
-          if s.xdrTimeout?
-            xdr.ontimeout = -> callback 0, "timeout"
-            xdr.timeout   = s.xdrTimeout
-
-          xdr.send (s.hasContent and s.data) or null
-
-        abort: ->
-          if xdr?
-            xdr.onerror = jQuery.noop()
-            xdr.abort()
-      }
-
-class Firehose.MultiplexedLongPoll extends Firehose.LongPoll
-  constructor: (args) ->
-    super args
-    @_lastMessageSequence = {}
-
-  subscribe: (channel, opts) =>
-    # nothing to be done
-
-  unsubscribe: (channelNames...) =>
-    # same here
-
-  _request: =>
-    return if @_stopRequestLoop
-    data = @_subscriptions()
-
-    @_lastRequest = $.ajax
-      url:          @config.uri
-      firehose:     true
-      crossDomain:  true
-      method:       "POST"
-      data:         data
-      dataType:     "json"
-      timeout:      @_timeout
-      success:      @_success
-      error:        @_error
-      cache:        false
-
-  _updateLastMessageSequences: =>
-    for channel, opts of @config.channels
-      if seq = @_lastMessageSequence[channel]
-        opts.last_sequence = seq
-      else
-        unless opts.last_sequence
-          opts.last_sequence = 0
-
-  _subscriptions: =>
-    @_updateLastMessageSequences()
-    subs = {}
-    for channel, opts of @config.channels
-      subs[channel] = opts.last_sequence || 0
-    JSON.stringify(subs)
-
-  _success: (data, status, jqXhr) =>
-    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.
-      try
-        message = JSON.parse jqXhr.responseText
-        @_lastMessageSequence ||= {}
-        @_lastMessageSequence[message.channel] = message.last_sequence
-        @config.message message
-      catch e
-    @connect @_okInterval

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

@@ -1,74 +0,0 @@
-Firehose.multiplexChannel = "channels@firehose"
-
-class Firehose.MultiplexedConsumer extends Firehose.Consumer
-  @subscriptionQuery: (config) ->
-    {
-      subscribe: [
-        "#{channel}!#{opts.last_sequence || 0}" for channel, opts of config.channels
-      ].join(",")
-    }
-
-  @normalizeChannels: (config) ->
-    for chan, opts of config.channels
-      if chan[0] != "/"
-        delete config.channels[chan]
-        config.channels["/" + chan] = opts
-
-  @normalizeChannel: (channel) ->
-    if channel[0] != "/"
-      return "/" + channel
-    else
-      return channel
-
-  constructor: (@config = {}) ->
-    @messageHandlers = {}
-    @config.message ||= @message
-    @config.channels ||= {}
-    @config.uri += Firehose.multiplexChannel
-
-    @_updateSubscriptions()
-
-    for channel, opts of @config.channels
-      @_addSubscriptionHandler(channel, opts)
-
-    super(@config)
-
-  websocketTransport: (config) =>
-    new Firehose.MultiplexedWebSocket(config)
-
-  longpollTransport: (config) =>
-    new Firehose.MultiplexedLongPoll(config)
-
-  message: (msg) =>
-    if handler = @messageHandlers[msg.channel]
-      handler(@config.parse msg.message)
-
-  _addSubscriptionHandler: (channel, opts) =>
-    if opts.message
-      @messageHandlers[channel] = opts.message
-
-  _removeSubscriptionHandler: (channelNames...) =>
-    for chan in channelNames
-      delete @messageHandlers[chan]
-
-  _updateSubscriptions: =>
-    Firehose.MultiplexedConsumer.normalizeChannels(@config)
-
-  subscribe: (channel, opts = {}) =>
-    channel = Firehose.MultiplexedConsumer.normalizeChannel(channel)
-    @config.channels[channel] = opts
-
-    @_updateSubscriptions()
-    @_addSubscriptionHandler(channel, opts)
-    @transport.subscribe(channel, opts)
-
-  unsubscribe: (channelNames...) =>
-    return unless @connected()
-
-    for channel in channelNames
-      channel = Firehose.MultiplexedConsumer.normalizeChannel(channel)
-      delete @config.channels[channel]
-
-    @_updateSubscriptions()
-    @_removeSubscriptionHandler(channelNames...)
-    @transport.unsubscribe(channelNames...)

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

@@ -1,44 +0,0 @@
-class Firehose.Transport
-  # Class method to determine whether transport is supported by the current browser. Note that while
-  # the transport may be supported by the browser, its possible that the network connection won't
-  # succeed. That should be accounted for during the initial connecting to the server.
-  @supported: =>
-    false
-
-  constructor: (config={}) ->
-    @config = config
-    @config.params ||= {}
-
-    @_retryDelay = 3000
-    @
-
-  # Lets rock'n'roll! Connect to the server.
-  connect: (delay = 0) =>
-    setTimeout @_request, delay
-    this
-
-  # Hey subclasses:
-  name: ->     throw 'not implemented in base Transport' # implement this to identify transport type
-  stop: ->     throw 'not implemented in base Transport' # implement this to stop receiving messages
-  _request: -> throw 'not implemented in base Transport' # implement this to handle requests
-
-  # Default error handler
-  _error: (event) =>
-    if @_succeeded
-      # Lets try to connect again with delay
-      @config.disconnected()
-      @connect(@_retryDelay)
-    else @config.failed @
-
-  # Default connection established handler
-  _open: (event) =>
-    @_succeeded = true
-    @config.connected(@)
-
-  # Default connection closed handler
-  _close: (event) =>
-    @config.disconnected()
-
-  # Useful for reconnecting after any networking hiccups
-  getLastMessageSequence: =>
-    @_lastMessageSequence or 0

data/lib/assets/javascripts/firehose/version.js.coffee.erb

@@ -1,2 +0,0 @@
-Firehose.version = "<%= Firehose::VERSION %>"
-Firehose.codeName = "<%= Firehose::CODENAME %>"

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

@@ -1,148 +0,0 @@
-INITIAL_PING_TIMEOUT   =  2000
-KEEPALIVE_PING_TIMEOUT = 20000
-
-class Firehose.WebSocket extends Firehose.Transport
-  name: -> 'WebSocket'
-
-  @ieSupported:-> (document.documentMode || 10) > 9
-  @supported  :-> (if module?.exports? then global else window).WebSocket? # Check if WebSocket is an object in the window.
-
-  constructor: (args) ->
-    super args
-    # Configrations specifically for web sockets
-    @config.webSocket ||= {}
-    @config.webSocket.connectionVerified = @config.connectionVerified
-
-  _sendMessage: (message) =>
-    @socket?.send(JSON.stringify message)
-
-  _request: =>
-    # Run this in a try/catch block because IE10 inside of a .NET control
-    # complains about security zones.
-    try
-      @socket = new (if module?.exports? then global else window).WebSocket "#{@_protocol()}:#{@config.uri}?#{$.param @_requestParams()}"
-      @socket.onopen    = @_open
-      @socket.onclose   = @_close
-      @socket.onerror   = @_error
-      @socket.onmessage = @_lookForInitialPong
-    catch err
-      console?.log(err)
-
-  # Protocol schema we should use for talking to firehose server.
-  _protocol: =>
-    if @config.ssl then "wss" else "ws"
-
-  _requestParams: =>
-    @config.params
-
-  _open: =>
-    sendPing @socket
-
-  _lookForInitialPong: (event) =>
-    @_restartKeepAlive()
-    if isPong(try JSON.parse event.data catch e then {})
-      if @_lastMessageSequence?
-        # don't callback to connectionVerified on subsequent reconnects
-        @sendStartingMessageSequence @_lastMessageSequence
-      else @config.webSocket.connectionVerified @
-
-  sendStartingMessageSequence: (message_sequence) =>
-    @_lastMessageSequence = message_sequence
-    @socket.onmessage     = @_message
-    @_sendMessage({message_sequence})
-    @_needToNotifyOfDisconnect = true
-    Firehose.Transport::_open.call @
-
-  stop: =>
-    @_cleanUp()
-
-  _message: (event) =>
-    frame = @config.parse event.data
-    @_restartKeepAlive()
-    unless isPong frame
-      try
-        @_lastMessageSequence = frame.last_sequence
-        @config.message @config.parse frame.message
-      catch e
-
-  _close: (event) =>
-    if event?.wasClean then @_cleanUp()
-    else @_error event
-
-  _error: (event) =>
-    @_cleanUp()
-    if @_needToNotifyOfDisconnect
-      @_needToNotifyOfDisconnect = false
-      @config.disconnected()
-    if @_succeeded
-      @connect @_retryDelay
-    else if @config.failed
-      @config.failed @
-
-  _cleanUp: =>
-    @_clearKeepalive()
-    if @socket?
-      @socket.onopen    = null
-      @socket.onclose   = null
-      @socket.onerror   = null
-      @socket.onmessage = null
-      @socket.close()
-      delete @socket
-
-  _restartKeepAlive: =>
-    doPing = =>
-      sendPing @socket
-      setNextKeepAlive()
-    setNextKeepAlive = =>
-      @keepaliveTimeout = setTimeout doPing, KEEPALIVE_PING_TIMEOUT
-    @_clearKeepalive()
-    setNextKeepAlive()
-
-  _clearKeepalive: =>
-    if @keepaliveTimeout?
-      clearTimeout @keepaliveTimeout
-      @keepaliveTimeout = null
-
-class Firehose.MultiplexedWebSocket extends Firehose.WebSocket
-  constructor: (args) ->
-    super args
-
-  subscribe: (channel, opts) =>
-    @_sendMessage
-      multiplex_subscribe:
-        channel: channel
-        message_sequence: opts.last_sequence
-
-  unsubscribe: (channelNames...) =>
-    @_sendMessage
-      multiplex_unsubscribe: channelNames
-
-  getLastMessageSequence: =>
-    @_lastMessageSequence or {}
-
-  _open: =>
-    super()
-    for channel, opts of @config.channels
-      if @_lastMessageSequence
-        opts.last_sequence = @_lastMessageSequence[channel]
-
-      unless opts.last_sequence
-        opts.last_sequence = 0
-
-      @subscribe channel, opts
-
-  _message: (event) =>
-    frame = @config.parse event.data
-    @_restartKeepAlive()
-    unless isPong frame
-      try
-        @_lastMessageSequence ||= {}
-        @_lastMessageSequence[frame.channel] = frame.last_sequence
-        @config.message frame
-      catch e
-
-sendPing = (socket) ->
-  socket.send JSON.stringify ping: 'PING'
-
-isPong = (o) ->
-  o.pong is 'PONG'

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

@@ -1,2 +0,0 @@
-#= require firehose/core
-#= require firehose/version

data/lib/firehose/assets.rb

@@ -1,56 +0,0 @@
-require 'sprockets'
-
-module Firehose
-  # Deal with bundling Sprocket assets into environments (like Rails or Sprockets)
-  module Assets
-    def self.path(*segs)
-      File.join File.expand_path('../../assets', __FILE__), segs
-    end
-
-    # Integrate Firehose ./lib/assets files into a sprocket-enabled environment.
-    module Sprockets
-      # Entry-point Javascript for Sprockets project.
-      JAVASCRIPT = "firehose.js"
-
-      # Drop flash and javascript paths to Firehose assets into a sprockets environment.
-      def self.configure(env)
-        env.append_path Firehose::Assets.path('javascripts')
-        env
-      end
-
-      # The "main" javascript that folks should compile and use in their
-      # web applications.
-      def self.javascript
-        Firehose::Assets::Sprockets.environment[JAVASCRIPT].source
-      end
-
-      # Return a new sprockets environment configured with Firehose.
-      def self.environment
-        configure ::Sprockets::Environment.new
-      end
-
-      # Quick and dirty way for folks to compile the Firehose assets to a path
-      # from the CLI and use. These are usualy non-ruby (or non-sprockets) folks
-      # who want to run the firehose process and use the JS in a web app.
-      def self.manifest(directory)
-        ::Sprockets::Manifest.new(environment, directory)
-      end
-
-      # Try to automatically configure Sprockets if it's detected in the project.
-      def self.auto_detect
-        if defined? ::Sprockets and ::Sprockets.respond_to? :append_path
-          Firehose::Assets::Sprockets.configure ::Sprockets
-        end
-      end
-
-      def self.manifest_paths
-        paths = []
-        paths << File.basename(Firehose::Assets.path('/javascripts/firehose/firehose.js.coffee'), '.coffee')
-        paths
-      end
-    end
-  end
-end
-
-# Detect if Sprockets is loaded. If it is, lets configure Firehose to use it!
-Firehose::Assets::Sprockets.auto_detect

data/lib/firehose/cli.rb

@@ -1,79 +0,0 @@
-require 'thor'
-require 'eventmachine'
-require 'uri'
-
-# Enable native async-io libs
-EM.kqueue if EM.kqueue?
-EM.epoll  if EM.epoll?
-
-module Firehose
-  class CLI < Thor
-    def initialize(*args)
-      super
-      # Disable buffering to $stdio for Firehose.logger
-      $stdout.sync = true
-    end
-
-    desc "javascript", "Compile the Firehose JavaScript."
-    def javascript
-      $stderr.puts "DEPRECATION WARNING: Firehose JS assets have been moved to https://github.com/firehoseio/js_client"
-      $stdout.puts Firehose::Assets::Sprockets.javascript
-    end
-
-    desc "version", "Display the current version."
-    def version
-      puts %[Firehose #{Firehose::VERSION} "#{Firehose::CODENAME}"]
-    end
-
-    desc "server", "Start an instance of a server."
-    method_option :port,   :type => :numeric, :default => ENV['PORT'] || Firehose::URI.port, :required => false, :aliases => '-p'
-    method_option :host,   :type => :string,  :default => ENV['HOST'] || Firehose::URI.host, :required => false, :aliases => '-h'
-    method_option :server, :type => :string,  :default => ENV['SERVER'] ||'rainbows', :required => false, :aliases => '-s'
-    def server
-      begin
-        Firehose::Server::App.new(options).start
-      rescue => e
-        Firehose.logger.error "#{e.message}: #{e.backtrace}"
-        raise e
-      end
-    end
-
-    desc "consume URI", "Consume messages from a resource."
-    method_option :concurrency, :type => :numeric, :default => 1, :aliases => '-c'
-    def consume(uri)
-      EM.run do
-        options[:concurrency].times { Firehose::Client::Consumer.parse(uri).request }
-      end
-    end
-
-    desc "publish URI [PAYLOAD]", "Publish messages to a resource."
-    method_option :ttl, :type => :numeric, :aliases => '-t'
-    method_option :times, :type => :numeric, :aliases => '-n', :default => 1
-    method_option :interval, :type => :numeric, :aliases => '-i'
-    def publish(uri, payload=nil)
-      payload     ||= $stdin.read
-      client      = Firehose::Client::Producer::Http.new(uri)
-      path        = ::URI.parse(uri).path
-      times       = options[:times]
-      ttl         = options[:ttl]
-
-      EM.run do
-        # TODO I think this can be cleaned up so the top-level if/else can be ditched.
-        if interval = options[:interval]
-          # Publish messages at a forced interval.
-          EM.add_periodic_timer interval do
-            client.publish(payload).to(path, :ttl => ttl)
-            EM.stop if times && (times-=1).zero?
-          end
-        else
-          # Publish messages as soon as the last message was published.
-          worker = Proc.new do
-            client.publish(payload).to(path, :ttl => ttl)
-            times && (times-=1).zero? ? EM.stop : worker.call
-          end
-          worker.call
-        end
-      end
-    end
-  end
-end