actioncable 0.0.0 → 5.0.0.beta1

data/lib/action_cable/server/broadcasting.rb

@@ -0,0 +1,54 @@
+require 'redis'
+
+module ActionCable
+  module Server
+    # Broadcasting is how other parts of your application can send messages to the channel subscribers. As explained in Channel, most of the time, these
+    # broadcastings are streamed directly to the clients subscribed to the named broadcasting. Let's explain with a full-stack example:
+    #
+    #   class WebNotificationsChannel < ApplicationCable::Channel
+    #      def subscribed
+    #        stream_from "web_notifications_#{current_user.id}"
+    #      end
+    #    end
+    #
+    #    # Somewhere in your app this is called, perhaps from a NewCommentJob
+    #    ActionCable.server.broadcast \
+    #      "web_notifications_1", { title: 'New things!', body: 'All shit fit for print' }
+    #
+    #    # Client-side coffescript, which assumes you've already requested the right to send web notifications
+    #    App.cable.subscriptions.create "WebNotificationsChannel",
+    #      received: (data) ->
+    #        new Notification data['title'], body: data['body']
+    module Broadcasting
+      # Broadcast a hash directly to a named <tt>broadcasting</tt>. It'll automatically be JSON encoded.
+      def broadcast(broadcasting, message)
+        broadcaster_for(broadcasting).broadcast(message)
+      end
+
+      # Returns a broadcaster for a named <tt>broadcasting</tt> that can be reused. Useful when you have a object that
+      # may need multiple spots to transmit to a specific broadcasting over and over.
+      def broadcaster_for(broadcasting)
+        Broadcaster.new(self, broadcasting)
+      end
+
+      # The redis instance used for broadcasting. Not intended for direct user use.
+      def broadcasting_redis
+        @broadcasting_redis ||= Redis.new(config.redis)
+      end
+
+      private
+        class Broadcaster
+          attr_reader :server, :broadcasting
+
+          def initialize(server, broadcasting)
+            @server, @broadcasting = server, broadcasting
+          end
+
+          def broadcast(message)
+            server.logger.info "[ActionCable] Broadcasting to #{broadcasting}: #{message}"
+            server.broadcasting_redis.publish broadcasting, ActiveSupport::JSON.encode(message)
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/server/configuration.rb

@@ -0,0 +1,35 @@
+module ActionCable
+  module Server
+    # An instance of this configuration object is available via ActionCable.server.config, which allows you to tweak the configuration points
+    # in a Rails config initializer.
+    class Configuration
+      attr_accessor :logger, :log_tags
+      attr_accessor :connection_class, :worker_pool_size
+      attr_accessor :redis, :channels_path
+      attr_accessor :disable_request_forgery_protection, :allowed_request_origins
+      attr_accessor :url
+
+      def initialize
+        @log_tags = []
+
+        @connection_class  = ApplicationCable::Connection
+        @worker_pool_size  = 100
+
+        @channels_path = Rails.root.join('app/channels')
+
+        @disable_request_forgery_protection = false
+      end
+
+      def channel_paths
+        @channels ||= Dir["#{channels_path}/**/*_channel.rb"]
+      end
+
+      def channel_class_names
+        @channel_class_names ||= channel_paths.collect do |channel_path|
+          Pathname.new(channel_path).basename.to_s.split('.').first.camelize
+        end
+      end
+    end
+  end
+end
+

data/lib/action_cable/server/connections.rb

@@ -0,0 +1,37 @@
+module ActionCable
+  module Server
+    # Collection class for all the connections that's been established on this specific server. Remember, usually you'll run many cable servers, so
+    # you can't use this collection as an full list of all the connections established against your application. Use RemoteConnections for that.
+    # As such, this is primarily for internal use.
+    module Connections
+      BEAT_INTERVAL = 3
+
+      def connections
+        @connections ||= []
+      end
+
+      def add_connection(connection)
+        connections << connection
+      end
+
+      def remove_connection(connection)
+        connections.delete connection
+      end
+
+      # WebSocket connection implementations differ on when they'll mark a connection as stale. We basically never want a connection to go stale, as you
+      # then can't rely on being able to receive and send to it. So there's a 3 second heartbeat running on all connections. If the beat fails, we automatically
+      # disconnect.
+      def setup_heartbeat_timer
+        EM.next_tick do
+          @heartbeat_timer ||= EventMachine.add_periodic_timer(BEAT_INTERVAL) do
+            EM.next_tick { connections.map(&:beat) }
+          end
+        end
+      end
+
+      def open_connections_statistics
+        connections.map(&:statistics)
+      end
+    end
+  end
+end

data/lib/action_cable/server/worker.rb

@@ -0,0 +1,42 @@
+require 'celluloid'
+require 'active_support/callbacks'
+
+module ActionCable
+  module Server
+    # Worker used by Server.send_async to do connection work in threads. Only for internal use.
+    class Worker
+      include ActiveSupport::Callbacks
+      include Celluloid
+
+      attr_reader :connection
+      define_callbacks :work
+      include ActiveRecordConnectionManagement
+
+      def invoke(receiver, method, *args)
+        @connection = receiver
+
+        run_callbacks :work do
+          receiver.send method, *args
+        end
+      rescue Exception => e
+        logger.error "There was an exception - #{e.class}(#{e.message})"
+        logger.error e.backtrace.join("\n")
+
+        receiver.handle_exception if receiver.respond_to?(:handle_exception)
+      end
+
+      def run_periodic_timer(channel, callback)
+        @connection = channel.connection
+
+        run_callbacks :work do
+          callback.respond_to?(:call) ? channel.instance_exec(&callback) : channel.send(callback)
+        end
+      end
+
+      private
+        def logger
+          ActionCable.server.logger
+        end
+    end
+  end
+end

data/lib/action_cable/server/worker/active_record_connection_management.rb

@@ -0,0 +1,22 @@
+module ActionCable
+  module Server
+    class Worker
+      # Clear active connections between units of work so the long-running channel or connection processes do not hoard connections.
+      module ActiveRecordConnectionManagement
+        extend ActiveSupport::Concern
+
+        included do
+          if defined?(ActiveRecord::Base)
+            set_callback :work, :around, :with_database_connections
+          end
+        end
+
+        def with_database_connections
+          connection.logger.tag(ActiveRecord::Base.logger) { yield }
+        ensure
+          ActiveRecord::Base.clear_active_connections!
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/version.rb

@@ -1,3 +1,8 @@
+require_relative 'gem_version'
+
 module ActionCable
-  VERSION = "0.0.0"
+  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>
+  def self.version
+    gem_version
+  end
 end

data/lib/assets/javascripts/action_cable.coffee.erb

@@ -0,0 +1,23 @@
+#= require_self
+#= require action_cable/consumer
+
+@ActionCable =
+  INTERNAL: <%= ActionCable::INTERNAL.to_json %>
+
+  createConsumer: (url = @getConfig("url")) ->
+    new ActionCable.Consumer @createWebSocketURL(url)
+
+  getConfig: (name) ->
+    element = document.head.querySelector("meta[name='action-cable-#{name}']")
+    element?.getAttribute("content")
+
+  createWebSocketURL: (url) ->
+    if url and not /^wss?:/i.test(url)
+      a = document.createElement("a")
+      a.href = url
+      # Fix populating Location properties in IE. Otherwise, protocol will be blank.
+      a.href = a.href
+      a.protocol = a.protocol.replace("http", "ws")
+      a.href
+    else
+      url

data/lib/assets/javascripts/action_cable/connection.coffee

@@ -0,0 +1,84 @@
+# Encapsulate the cable connection held by the consumer. This is an internal class not intended for direct user manipulation.
+
+{message_types} = ActionCable.INTERNAL
+
+class ActionCable.Connection
+  @reopenDelay: 500
+
+  constructor: (@consumer) ->
+    @open()
+
+  send: (data) ->
+    if @isOpen()
+      @webSocket.send(JSON.stringify(data))
+      true
+    else
+      false
+
+  open: =>
+    if @webSocket and not @isState("closed")
+      throw new Error("Existing connection must be closed before opening")
+    else
+      @webSocket = new WebSocket(@consumer.url)
+      @installEventHandlers()
+      true
+
+  close: ->
+    @webSocket?.close()
+
+  reopen: ->
+    if @isState("closed")
+      @open()
+    else
+      try
+        @close()
+      finally
+        setTimeout(@open, @constructor.reopenDelay)
+
+  isOpen: ->
+    @isState("open")
+
+  # Private
+
+  isState: (states...) ->
+    @getState() in states
+
+  getState: ->
+    return state.toLowerCase() for state, value of WebSocket when value is @webSocket?.readyState
+    null
+
+  installEventHandlers: ->
+    for eventName of @events
+      handler = @events[eventName].bind(this)
+      @webSocket["on#{eventName}"] = handler
+    return
+
+  events:
+    message: (event) ->
+      {identifier, message, type} = JSON.parse(event.data)
+
+      switch type
+        when message_types.confirmation
+          @consumer.subscriptions.notify(identifier, "connected")
+        when message_types.rejection
+          @consumer.subscriptions.reject(identifier)
+        else
+          @consumer.subscriptions.notify(identifier, "received", message)
+
+    open: ->
+      @disconnected = false
+      @consumer.subscriptions.reload()
+
+    close: ->
+      @disconnect()
+
+    error: ->
+      @disconnect()
+
+  disconnect: ->
+    return if @disconnected
+    @disconnected = true
+    @consumer.subscriptions.notifyAll("disconnected")
+
+  toJSON: ->
+    state: @getState()

data/lib/assets/javascripts/action_cable/connection_monitor.coffee

@@ -0,0 +1,84 @@
+# Responsible for ensuring the cable connection is in good health by validating the heartbeat pings sent from the server, and attempting
+# revival reconnections if things go astray. Internal class, not intended for direct user manipulation.
+class ActionCable.ConnectionMonitor
+  @pollInterval:
+    min: 3
+    max: 30
+
+  @staleThreshold: 6 # Server::Connections::BEAT_INTERVAL * 2 (missed two pings)
+
+  identifier: ActionCable.INTERNAL.identifiers.ping
+
+  constructor: (@consumer) ->
+    @consumer.subscriptions.add(this)
+    @start()
+
+  connected: ->
+    @reset()
+    @pingedAt = now()
+    delete @disconnectedAt
+
+  disconnected: ->
+    @disconnectedAt = now()
+
+  received: ->
+    @pingedAt = now()
+
+  reset: ->
+    @reconnectAttempts = 0
+
+  start: ->
+    @reset()
+    delete @stoppedAt
+    @startedAt = now()
+    @poll()
+    document.addEventListener("visibilitychange", @visibilityDidChange)
+
+  stop: ->
+    @stoppedAt = now()
+    document.removeEventListener("visibilitychange", @visibilityDidChange)
+
+  poll: ->
+    setTimeout =>
+      unless @stoppedAt
+        @reconnectIfStale()
+        @poll()
+    , @getInterval()
+
+  getInterval: ->
+    {min, max} = @constructor.pollInterval
+    interval = 5 * Math.log(@reconnectAttempts + 1)
+    clamp(interval, min, max) * 1000
+
+  reconnectIfStale: ->
+    if @connectionIsStale()
+      @reconnectAttempts++
+      unless @disconnectedRecently()
+        @consumer.connection.reopen()
+
+  connectionIsStale: ->
+    secondsSince(@pingedAt ? @startedAt) > @constructor.staleThreshold
+
+  disconnectedRecently: ->
+    @disconnectedAt and secondsSince(@disconnectedAt) < @constructor.staleThreshold
+
+  visibilityDidChange: =>
+    if document.visibilityState is "visible"
+      setTimeout =>
+        if @connectionIsStale() or not @consumer.connection.isOpen()
+          @consumer.connection.reopen()
+      , 200
+
+  toJSON: ->
+    interval = @getInterval()
+    connectionIsStale = @connectionIsStale()
+    {@startedAt, @stoppedAt, @pingedAt, @reconnectAttempts, connectionIsStale, interval}
+
+  now = ->
+    new Date().getTime()
+
+  secondsSince = (time) ->
+    (now() - time) / 1000
+
+  clamp = (number, min, max) ->
+    Math.max(min, Math.min(max, number))

data/lib/assets/javascripts/action_cable/consumer.coffee

@@ -0,0 +1,31 @@
+#= require action_cable/connection
+#= require action_cable/connection_monitor
+#= require action_cable/subscriptions
+#= require action_cable/subscription
+
+# The ActionCable.Consumer establishes the connection to a server-side Ruby Connection object. Once established,
+# the ActionCable.ConnectionMonitor will ensure that its properly maintained through heartbeats and checking for stale updates.
+# The Consumer instance is also the gateway to establishing subscriptions to desired channels through the #createSubscription
+# method.
+#
+# The following example shows how this can be setup:
+#
+#   @App = {}
+#   App.cable = ActionCable.createConsumer "ws://example.com/accounts/1"
+#   App.appearance = App.cable.subscriptions.create "AppearanceChannel"
+#
+# For more details on how you'd configure an actual channel subscription, see ActionCable.Subscription.
+class ActionCable.Consumer
+  constructor: (@url) ->
+    @subscriptions = new ActionCable.Subscriptions this
+    @connection = new ActionCable.Connection this
+    @connectionMonitor = new ActionCable.ConnectionMonitor this
+
+  send: (data) ->
+    @connection.send(data)
+
+  inspect: ->
+    JSON.stringify(this, null, 2)
+
+  toJSON: ->
+    {@url, @subscriptions, @connection, @connectionMonitor}

data/lib/assets/javascripts/action_cable/subscription.coffee

@@ -0,0 +1,68 @@
+# A new subscription is created through the ActionCable.Subscriptions instance available on the consumer. 
+# It provides a number of callbacks and a method for calling remote procedure calls on the corresponding 
+# Channel instance on the server side.
+#
+# An example demonstrates the basic functionality:
+#
+#   App.appearance = App.cable.subscriptions.create "AppearanceChannel",
+#     connected: ->
+#       # Called once the subscription has been successfully completed
+#   
+#     appear: ->
+#       @perform 'appear', appearing_on: @appearingOn()
+#   
+#     away: ->
+#       @perform 'away'
+#   
+#     appearingOn: ->
+#       $('main').data 'appearing-on'
+#
+# The methods #appear and #away forward their intent to the remote AppearanceChannel instance on the server
+# by calling the `@perform` method with the first parameter being the action (which maps to AppearanceChannel#appear/away).
+# The second parameter is a hash that'll get JSON encoded and made available on the server in the data parameter.
+#
+# This is how the server component would look:
+#
+#   class AppearanceChannel < ApplicationActionCable::Channel
+#     def subscribed
+#       current_user.appear
+#     end
+#   
+#     def unsubscribed
+#       current_user.disappear
+#     end
+#   
+#     def appear(data)
+#       current_user.appear on: data['appearing_on']
+#     end
+#   
+#     def away
+#       current_user.away
+#     end
+#   end
+#
+# The "AppearanceChannel" name is automatically mapped between the client-side subscription creation and the server-side Ruby class name.
+# The AppearanceChannel#appear/away public methods are exposed automatically to client-side invocation through the @perform method.
+class ActionCable.Subscription
+  constructor: (@subscriptions, params = {}, mixin) ->
+    @identifier = JSON.stringify(params)
+    extend(this, mixin)
+    @subscriptions.add(this)
+    @consumer = @subscriptions.consumer
+
+  # Perform a channel action with the optional data passed as an attribute
+  perform: (action, data = {}) ->
+    data.action = action
+    @send(data)
+
+  send: (data) ->
+    @consumer.send(command: "message", identifier: @identifier, data: JSON.stringify(data))
+
+  unsubscribe: ->
+    @subscriptions.remove(this)
+
+  extend = (object, properties) ->
+    if properties?
+      for key, value of properties
+        object[key] = value
+    object