actioncable 0.0.0 → 5.0.0.beta1

data/lib/action_cable/connection/message_buffer.rb

@@ -0,0 +1,54 @@
+module ActionCable
+  module Connection
+    # Allows us to buffer messages received from the WebSocket before the Connection has been fully initialized and is ready to receive them.
+    # Entirely internal operation and should not be used directly by the user.
+    class MessageBuffer
+      def initialize(connection)
+        @connection = connection
+        @buffered_messages = []
+      end
+
+      def append(message)
+        if valid? message
+          if processing?
+            receive message
+          else
+            buffer message
+          end
+        else
+          connection.logger.error "Couldn't handle non-string message: #{message.class}"
+        end
+      end
+
+      def processing?
+        @processing
+      end
+
+      def process!
+        @processing = true
+        receive_buffered_messages
+      end
+
+      protected
+        attr_reader :connection
+        attr_accessor :buffered_messages
+
+      private
+        def valid?(message)
+          message.is_a?(String)
+        end
+
+        def receive(message)
+          connection.send_async :receive, message
+        end
+
+        def buffer(message)
+          buffered_messages << message
+        end
+
+        def receive_buffered_messages
+          receive buffered_messages.shift until buffered_messages.empty?
+        end
+    end
+  end
+end

data/lib/action_cable/connection/subscriptions.rb

@@ -0,0 +1,76 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActionCable
+  module Connection
+    # Collection class for all the channel subscriptions established on a given connection. Responsible for routing incoming commands that arrive on
+    # the connection to the proper channel. Should not be used directly by the user.
+    class Subscriptions
+      def initialize(connection)
+        @connection = connection
+        @subscriptions = {}
+      end
+
+      def execute_command(data)
+        case data['command']
+        when 'subscribe'   then add data
+        when 'unsubscribe' then remove data
+        when 'message'     then perform_action data
+        else
+          logger.error "Received unrecognized command in #{data.inspect}"
+        end
+      rescue Exception => e
+        logger.error "Could not execute command from #{data.inspect}) [#{e.class} - #{e.message}]: #{e.backtrace.first(5).join(" | ")}"
+      end
+
+      def add(data)
+        id_key = data['identifier']
+        id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+
+        subscription_klass = connection.server.channel_classes[id_options[:channel]]
+
+        if subscription_klass
+          subscriptions[id_key] ||= subscription_klass.new(connection, id_key, id_options)
+        else
+          logger.error "Subscription class not found (#{data.inspect})"
+        end
+      end
+
+      def remove(data)
+        logger.info "Unsubscribing from channel: #{data['identifier']}"
+        remove_subscription subscriptions[data['identifier']]
+      end
+
+      def remove_subscription(subscription)
+        subscription.unsubscribe_from_channel
+        subscriptions.delete(subscription.identifier)
+      end
+
+      def perform_action(data)
+        find(data).perform_action ActiveSupport::JSON.decode(data['data'])
+      end
+
+
+      def identifiers
+        subscriptions.keys
+      end
+
+      def unsubscribe_from_all
+        subscriptions.each { |id, channel| channel.unsubscribe_from_channel }
+      end
+
+      protected
+        attr_reader :connection, :subscriptions
+
+      private
+        delegate :logger, to: :connection
+
+        def find(data)
+          if subscription = subscriptions[data['identifier']]
+            subscription
+          else
+            raise "Unable to find subscription with identifier: #{data['identifier']}"
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/connection/tagged_logger_proxy.rb

@@ -0,0 +1,40 @@
+module ActionCable
+  module Connection
+    # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
+    # <tt>ActiveSupport::TaggedLogging</tt> enhanced Rails.logger, as that logger will reset the tags between requests.
+    # The connection is long-lived, so it needs its own set of tags for its independent duration.
+    class TaggedLoggerProxy
+      attr_reader :tags
+
+      def initialize(logger, tags:)
+        @logger = logger
+        @tags = tags.flatten
+      end
+
+      def add_tags(*tags)
+        @tags += tags.flatten
+        @tags = @tags.uniq
+      end
+
+      def tag(logger)
+        if logger.respond_to?(:tagged)
+          current_tags = tags - logger.formatter.current_tags
+          logger.tagged(*current_tags) { yield }
+        else
+          yield
+        end
+      end
+
+      %i( debug info warn error fatal unknown ).each do |severity|
+        define_method(severity) do |message|
+          log severity, message
+        end
+      end
+
+      protected
+        def log(type, message)
+          tag(@logger) { @logger.send type, message }
+        end
+    end
+  end
+end

data/lib/action_cable/connection/web_socket.rb

@@ -0,0 +1,29 @@
+require 'faye/websocket'
+
+module ActionCable
+  module Connection
+    # Decorate the Faye::WebSocket with helpers we need.
+    class WebSocket
+      delegate :rack_response, :close, :on, to: :websocket
+
+      def initialize(env)
+        @websocket = Faye::WebSocket.websocket?(env) ? Faye::WebSocket.new(env) : nil
+      end
+
+      def possible?
+        websocket
+      end
+
+      def alive?
+        websocket && websocket.ready_state == Faye::WebSocket::API::OPEN
+      end
+
+      def transmit(data)
+        websocket.send data
+      end
+
+      protected
+        attr_reader :websocket
+    end
+  end
+end

data/lib/action_cable/engine.rb

@@ -0,0 +1,38 @@
+require "rails"
+require "action_cable"
+require "action_cable/helpers/action_cable_helper"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionCable
+  class Railtie < Rails::Engine # :nodoc:
+    config.action_cable = ActiveSupport::OrderedOptions.new
+    config.action_cable.url = '/cable'
+
+    config.eager_load_namespaces << ActionCable
+
+    initializer "action_cable.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ActionCable::Helpers::ActionCableHelper
+      end
+    end
+
+    initializer "action_cable.logger" do
+      ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "action_cable.set_configs" do |app|
+      options = app.config.action_cable
+      options.allowed_request_origins ||= "http://localhost:3000" if ::Rails.env.development?
+
+      app.paths.add "config/redis/cable", with: "config/redis/cable.yml"
+
+      ActiveSupport.on_load(:action_cable) do
+        if (redis_cable_path = Pathname.new(app.config.paths["config/redis/cable"].first)).exist?
+          self.redis = Rails.application.config_for(redis_cable_path).with_indifferent_access
+        end
+
+        options.each { |k,v| send("#{k}=", v) }
+      end
+    end
+  end
+end

data/lib/action_cable/gem_version.rb

@@ -0,0 +1,15 @@
+module ActionCable
+  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 0
+    PRE   = "beta1"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -0,0 +1,29 @@
+module ActionCable
+  module Helpers
+    module ActionCableHelper
+      # Returns an "action-cable-url" meta tag with the value of the url specified in your
+      # configuration. Ensure this is above your javascript tag:
+      #
+      #   <head>
+      #     <%= action_cable_meta_tag %>
+      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+      #   </head>
+      #
+      # This is then used by ActionCable to determine the url of your websocket server.
+      # Your CoffeeScript can then connect to the server without needing to specify the
+      # url directly:
+      #
+      #   #= require cable
+      #   @App = {}
+      #   App.cable = Cable.createConsumer()
+      #
+      # Make sure to specify the correct server location in each of your environments
+      # config file:
+      #
+      #   config.action_cable.url = "ws://example.com:28080"
+      def action_cable_meta_tag
+        tag "meta", name: "action-cable-url", content: Rails.application.config.action_cable.url
+      end
+    end
+  end
+end

data/lib/action_cable/process/logging.rb

@@ -0,0 +1,10 @@
+require 'action_cable/server'
+require 'eventmachine'
+require 'celluloid'
+
+EM.error_handler do |e|
+  puts "Error raised inside the event loop: #{e.message}"
+  puts e.backtrace.join("\n")
+end
+
+Celluloid.logger = ActionCable.server.logger

data/lib/action_cable/remote_connections.rb

@@ -0,0 +1,64 @@
+module ActionCable
+  # If you need to disconnect a given connection, you go through the RemoteConnections. You find the connections you're looking for by
+  # searching the identifier declared on the connection. Example:
+  #
+  #   module ApplicationCable
+  #     class Connection < ActionCable::Connection::Base
+  #       identified_by :current_user
+  #       ....
+  #     end
+  #   end
+  #
+  #   ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #
+  # That will disconnect all the connections established for User.find(1) across all servers running on all machines (because it uses
+  # the internal channel that all these servers are subscribed to).
+  class RemoteConnections
+    attr_reader :server
+
+    def initialize(server)
+      @server = server
+    end
+
+    def where(identifier)
+      RemoteConnection.new(server, identifier)
+    end
+
+    private
+      # Represents a single remote connection found via ActionCable.server.remote_connections.where(*).
+      # Exists for the solely for the purpose of calling #disconnect on that connection.
+      class RemoteConnection
+        class InvalidIdentifiersError < StandardError; end
+
+        include Connection::Identification, Connection::InternalChannel
+
+        def initialize(server, ids)
+          @server = server
+          set_identifier_instance_vars(ids)
+        end
+
+        # Uses the internal channel to disconnect the connection.
+        def disconnect
+          server.broadcast internal_redis_channel, type: 'disconnect'
+        end
+
+        # Returns all the identifiers that were applied to this connection.
+        def identifiers
+          server.connection_identifiers
+        end
+
+        private
+          attr_reader :server
+
+          def set_identifier_instance_vars(ids)
+            raise InvalidIdentifiersError unless valid_identifiers?(ids)
+            ids.each { |k,v| instance_variable_set("@#{k}", v) }
+          end
+
+          def valid_identifiers?(ids)
+            keys = ids.keys
+            identifiers.all? { |id| keys.include?(id) }
+          end
+      end
+  end
+end

data/lib/action_cable/server.rb

@@ -0,0 +1,19 @@
+require 'eventmachine'
+EventMachine.epoll  if EventMachine.epoll?
+EventMachine.kqueue if EventMachine.kqueue?
+
+module ActionCable
+  module Server
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Base
+      autoload :Broadcasting
+      autoload :Connections
+      autoload :Configuration
+
+      autoload :Worker
+      autoload :ActiveRecordConnectionManagement, 'action_cable/server/worker/active_record_connection_management'
+    end
+  end
+end

data/lib/action_cable/server/base.rb

@@ -0,0 +1,77 @@
+# FIXME: Cargo culted fix from https://github.com/celluloid/celluloid-pool/issues/10
+require 'celluloid/current'
+
+require 'em-hiredis'
+
+module ActionCable
+  module Server
+    # A singleton ActionCable::Server instance is available via ActionCable.server. It's used by the rack process that starts the cable server, but
+    # also by the user to reach the RemoteConnections instead for finding and disconnecting connections across all servers.
+    #
+    # Also, this is the server instance used for broadcasting. See Broadcasting for details.
+    class Base
+      include ActionCable::Server::Broadcasting
+      include ActionCable::Server::Connections
+
+      cattr_accessor(:config, instance_accessor: true) { ActionCable::Server::Configuration.new }
+
+      def self.logger; config.logger; end
+      delegate :logger, to: :config
+
+      def initialize
+      end
+
+      # Called by rack to setup the server.
+      def call(env)
+        setup_heartbeat_timer
+        config.connection_class.new(self, env).process
+      end
+
+      # Disconnect all the connections identified by `identifiers` on this server or any others via RemoteConnections.
+      def disconnect(identifiers)
+        remote_connections.where(identifiers).disconnect
+      end
+
+      # Gateway to RemoteConnections. See that class for details.
+      def remote_connections
+        @remote_connections ||= RemoteConnections.new(self)
+      end
+
+      # The thread worker pool for handling all the connection work on this server. Default size is set by config.worker_pool_size.
+      def worker_pool
+        @worker_pool ||= ActionCable::Server::Worker.pool(size: config.worker_pool_size)
+      end
+
+      # Requires and returns a hash of all the channel class constants keyed by name.
+      def channel_classes
+        @channel_classes ||= begin
+          config.channel_paths.each { |channel_path| require channel_path }
+          config.channel_class_names.each_with_object({}) { |name, hash| hash[name] = name.constantize }
+        end
+      end
+
+      # The redis pubsub adapter used for all streams/broadcasting.
+      def pubsub
+        @pubsub ||= redis.pubsub
+      end
+
+      # The EventMachine Redis instance used by the pubsub adapter.
+      def redis
+        @redis ||= EM::Hiredis.connect(config.redis[:url]).tap do |redis|
+          redis.on(:reconnect_failed) do
+            logger.info "[ActionCable] Redis reconnect failed."
+            # logger.info "[ActionCable] Redis reconnected. Closing all the open connections."
+            # @connections.map &:close
+          end
+        end
+      end
+
+      # All the identifiers applied to the connection class associated with this server.
+      def connection_identifiers
+        config.connection_class.identifiers
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:action_cable, Base.config)
+  end
+end