actioncable 7.0.8.7 → 7.1.0.beta1

data/lib/action_cable/connection/authorization.rb

@@ -5,7 +5,7 @@ module ActionCable
     module Authorization
       class UnauthorizedError < StandardError; end
 
-      # Closes the WebSocket connection if it is open and returns a 404 "File not Found" response.
+      # Closes the WebSocket connection if it is open and returns an "unauthorized" reason.
       def reject_unauthorized_connection
         logger.error "An unauthorized connection attempt was rejected"
         raise UnauthorizedError

data/lib/action_cable/connection/base.rb

@@ -5,6 +5,8 @@ require "active_support/rescuable"
 
 module ActionCable
   module Connection
+    # = Action Cable \Connection \Base
+    #
     # For every WebSocket connection the Action Cable server accepts, a Connection object will be instantiated. This instance becomes the parent
     # of all of the channel subscriptions that are created from there on. Incoming messages are then routed to these channel subscriptions
     # based on an identifier sent by the Action Cable consumer. The Connection itself does not deal with any specific application logic beyond
@@ -47,10 +49,11 @@ module ActionCable
       include Identification
       include InternalChannel
       include Authorization
+      include Callbacks
       include ActiveSupport::Rescuable
 
       attr_reader :server, :env, :subscriptions, :logger, :worker_pool, :protocol
-      delegate :event_loop, :pubsub, to: :server
+      delegate :event_loop, :pubsub, :config, to: :server
 
       def initialize(server, env, coder: ActiveSupport::JSON)
         @server, @env, @coder = server, env, coder
@@ -86,12 +89,18 @@ module ActionCable
 
       def dispatch_websocket_message(websocket_message) # :nodoc:
         if websocket.alive?
-          subscriptions.execute_command decode(websocket_message)
+          handle_channel_command decode(websocket_message)
         else
           logger.error "Ignoring message processed after the WebSocket was closed: #{websocket_message.inspect})"
         end
       end
 
+      def handle_channel_command(payload)
+        run_callbacks :command do
+          subscriptions.execute_command payload
+        end
+      end
+
       def transmit(cable_message) # :nodoc:
         websocket.transmit encode(cable_message)
       end
@@ -143,6 +152,10 @@ module ActionCable
         send_async :handle_close
       end
 
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+      end
+
       private
         attr_reader :websocket
         attr_reader :message_buffer
@@ -222,7 +235,7 @@ module ActionCable
 
           logger.error invalid_request_message
           logger.info finished_request_message
-          [ 404, { "Content-Type" => "text/plain" }, [ "Page not found" ] ]
+          [ 404, { Rack::CONTENT_TYPE => "text/plain; charset=utf-8" }, [ "Page not found" ] ]
         end
 
         # Tags are declared in the server but computed in the connection. This allows us per-connection tailored tags.
@@ -237,7 +250,7 @@ module ActionCable
             request.filtered_path,
             websocket.possible? ? " [WebSocket]" : "[non-WebSocket]",
             request.ip,
-            Time.now.to_default_s ]
+            Time.now.to_s ]
         end
 
         def finished_request_message
@@ -245,7 +258,7 @@ module ActionCable
             request.filtered_path,
             websocket.possible? ? " [WebSocket]" : "[non-WebSocket]",
             request.ip,
-            Time.now.to_default_s ]
+            Time.now.to_s ]
         end
 
         def invalid_request_message

data/lib/action_cable/connection/callbacks.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+
+module ActionCable
+  module Connection
+    # = Action Cable \Connection \Callbacks
+    #
+    # There are <tt>before_command</tt>, <tt>after_command</tt>, and <tt>around_command</tt> callbacks
+    # available to be invoked before, after or around every command received by a client respectively.
+    # The term "command" here refers to any interaction received by a client (subscribing, unsubscribing or performing actions):
+    #
+    #    module ApplicationCable
+    #      class Connection < ActionCable::Connection::Base
+    #        identified_by :user
+    #
+    #        around_command :set_current_account
+    #
+    #        private
+    #
+    #        def set_current_account
+    #          # Now all channels could use Current.account
+    #          Current.set(account: user.account) { yield }
+    #        end
+    #      end
+    #    end
+    #
+    module Callbacks
+      extend  ActiveSupport::Concern
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :command
+      end
+
+      module ClassMethods
+        def before_command(*methods, &block)
+          set_callback(:command, :before, *methods, &block)
+        end
+
+        def after_command(*methods, &block)
+          set_callback(:command, :after, *methods, &block)
+        end
+
+        def around_command(*methods, &block)
+          set_callback(:command, :around, *methods, &block)
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/connection/internal_channel.rb

@@ -2,6 +2,8 @@
 
 module ActionCable
   module Connection
+    # = Action Cable \InternalChannel
+    #
     # Makes it possible for the RemoteConnection to disconnect a specific connection.
     module InternalChannel
       extend ActiveSupport::Concern
@@ -32,7 +34,7 @@ module ActionCable
           case message["type"]
           when "disconnect"
             logger.info "Removing connection (#{connection_identifier})"
-            websocket.close
+            close(reason: ActionCable::INTERNAL[:disconnect_reasons][:remote], reconnect: message.fetch("reconnect", true))
           end
         rescue Exception => e
           logger.error "There was an exception - #{e.class}(#{e.message})"

data/lib/action_cable/connection/stream.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
-
 module ActionCable
   module Connection
     #--
@@ -100,7 +98,7 @@ module ActionCable
 
         # This should return the underlying io according to the SPEC:
         @rack_hijack_io = @socket_object.env["rack.hijack"].call
-        # Retain existing behaviour if required:
+        # Retain existing behavior if required:
         @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
 
         @event_loop.attach(@rack_hijack_io, self)

data/lib/action_cable/connection/stream_event_loop.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "nio"
-require "thread"
 
 module ActionCable
   module Connection

data/lib/action_cable/connection/subscriptions.rb

@@ -4,6 +4,8 @@ require "active_support/core_ext/hash/indifferent_access"
 
 module ActionCable
   module Connection
+    # = Action Cable \Connection \Subscriptions
+    #
     # 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.
     class Subscriptions # :nodoc:

data/lib/action_cable/connection/tagged_logger_proxy.rb

@@ -2,6 +2,8 @@
 
 module ActionCable
   module Connection
+    # = Action Cable \Connection \TaggedLoggerProxy
+    #
     # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
     # ActiveSupport::TaggedLogging 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.
@@ -28,14 +30,14 @@ module ActionCable
       end
 
       %i( debug info warn error fatal unknown ).each do |severity|
-        define_method(severity) do |message|
-          log severity, message
+        define_method(severity) do |message = nil, &block|
+          log severity, message, &block
         end
       end
 
       private
-        def log(type, message) # :doc:
-          tag(@logger) { @logger.send type, message }
+        def log(type, message, &block) # :doc:
+          tag(@logger) { @logger.send type, message, &block }
         end
     end
   end

data/lib/action_cable/connection/test_case.rb

@@ -56,6 +56,8 @@ module ActionCable
       end
     end
 
+    # = Action Cable \Connection \TestCase
+    #
     # Unit test Action Cable connections.
     #
     # Useful to check whether a connection's +identified_by+ gets assigned properly
@@ -116,7 +118,7 @@ module ActionCable
     #     assert_equal "1", connection.user_id
     #   end
     #
-    # == Connection is automatically inferred
+    # == \Connection is automatically inferred
     #
     # ActionCable::Connection::TestCase will automatically infer the connection under test
     # from the test class name. If the channel cannot be inferred from the test

data/lib/action_cable/connection/web_socket.rb

@@ -4,6 +4,8 @@ require "websocket/driver"
 
 module ActionCable
   module Connection
+    # = Action Cable \Connection \WebSocket
+    #
     # Wrap the real socket to minimize the externally-presented API
     class WebSocket # :nodoc:
       def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])

data/lib/action_cable/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionCable
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_cable/engine.rb

@@ -2,7 +2,6 @@
 
 require "rails"
 require "action_cable"
-require "action_cable/helpers/action_cable_helper"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActionCable
@@ -11,7 +10,9 @@ module ActionCable
     config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
     config.action_cable.precompile_assets = true
 
-    config.eager_load_namespaces << ActionCable
+    initializer "action_cable.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_cable] = ActionCable.deprecator
+    end
 
     initializer "action_cable.helpers" do
       ActiveSupport.on_load(:action_view) do
@@ -23,6 +24,12 @@ module ActionCable
       ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
     end
 
+    initializer "action_cable.health_check_application" do
+      ActiveSupport.on_load(:action_cable) {
+        self.health_check_application = ->(env) { Rails::HealthController.action(:show).call(env) }
+      }
+    end
+
     initializer "action_cable.asset" do
       config.after_initialize do |app|
         if app.config.respond_to?(:assets) && app.config.action_cable.precompile_assets
@@ -39,11 +46,12 @@ module ActionCable
 
       ActiveSupport.on_load(:action_cable) do
         if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
-          self.cable = Rails.application.config_for(config_path).to_h.with_indifferent_access
+          self.cable = app.config_for(config_path).to_h.with_indifferent_access
         end
 
         previous_connection_class = connection_class
         self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
+        self.filter_parameters += app.config.filter_parameters
 
         options.each { |k, v| send("#{k}=", v) }
       end
@@ -63,7 +71,7 @@ module ActionCable
     initializer "action_cable.set_work_hooks" do |app|
       ActiveSupport.on_load(:action_cable) do
         ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
-          app.executor.wrap do
+          app.executor.wrap(source: "application.action_cable") do
             # If we took a while to get the lock, we may have been halted
             # in the meantime. As we haven't started doing any real work
             # yet, we should pretend that we never made it off the queue.
@@ -74,7 +82,7 @@ module ActionCable
         end
 
         wrap = lambda do |_, inner|
-          app.executor.wrap(&inner)
+          app.executor.wrap(source: "application.action_cable", &inner)
         end
         ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
         ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap

data/lib/action_cable/gem_version.rb

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

data/lib/action_cable/remote_connections.rb

@@ -3,6 +3,8 @@
 require "active_support/core_ext/module/redefine_method"
 
 module ActionCable
+  # = Action Cable Remote Connections
+  #
   # If you need to disconnect a given connection, you can go through the
   # RemoteConnections. You can find the connections you're looking for by
   # searching for the identifier declared on the connection. For example:
@@ -19,6 +21,11 @@ module ActionCable
   # This will disconnect all the connections established for
   # <tt>User.find(1)</tt>, across all servers running on all machines, because
   # it uses the internal channel that all of these servers are subscribed to.
+  #
+  # By default, server sends a "disconnect" message with "reconnect" flag set to true.
+  # You can override it by specifying the +reconnect+ option:
+  #
+  #   ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect(reconnect: false)
   class RemoteConnections
     attr_reader :server
 
@@ -31,6 +38,8 @@ module ActionCable
     end
 
     private
+      # = Action Cable Remote \Connection
+      #
       # Represents a single remote connection found via <tt>ActionCable.server.remote_connections.where(*)</tt>.
       # Exists solely for the purpose of calling #disconnect on that connection.
       class RemoteConnection
@@ -44,8 +53,8 @@ module ActionCable
         end
 
         # Uses the internal channel to disconnect the connection.
-        def disconnect
-          server.broadcast internal_channel, { type: "disconnect" }
+        def disconnect(reconnect: true)
+          server.broadcast internal_channel, { type: "disconnect", reconnect: reconnect }
         end
 
         # Returns all the identifiers that were applied to this connection.

data/lib/action_cable/server/base.rb

@@ -4,6 +4,8 @@ require "monitor"
 
 module ActionCable
   module Server
+    # = Action Cable \Server \Base
+    #
     # A singleton ActionCable::Server instance is available via ActionCable.server. It's used by the Rack process that starts the Action Cable server, but
     # is also used by the user to reach the RemoteConnections object, which is used for finding and disconnecting connections across all servers.
     #
@@ -29,6 +31,7 @@ module ActionCable
 
       # Called by Rack to set up the server.
       def call(env)
+        return config.health_check_application.call(env) if env["PATH_INFO"] == config.health_check_path
         setup_heartbeat_timer
         config.connection_class.call.new(self, env).process
       end

data/lib/action_cable/server/broadcasting.rb

@@ -2,6 +2,8 @@
 
 module ActionCable
   module Server
+    # = Action Cable \Server \Broadcasting
+    #
     # Broadcasting is how other parts of your application can send messages to a channel's 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:
     #

data/lib/action_cable/server/configuration.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
+require "rack"
+
 module ActionCable
   module Server
+    # = Action Cable \Server \Configuration
+    #
     # An instance of this configuration object is available via ActionCable.server.config, which allows you to tweak Action Cable configuration
-    # in a Rails config initializer.
+    # in a \Rails config initializer.
     class Configuration
       attr_accessor :logger, :log_tags
       attr_accessor :connection_class, :worker_pool_size
-      attr_accessor :disable_request_forgery_protection, :allowed_request_origins, :allow_same_origin_as_host
+      attr_accessor :disable_request_forgery_protection, :allowed_request_origins, :allow_same_origin_as_host, :filter_parameters
       attr_accessor :cable, :url, :mount_path
       attr_accessor :precompile_assets
+      attr_accessor :health_check_path, :health_check_application
 
       def initialize
         @log_tags = []
@@ -19,6 +24,11 @@ module ActionCable
 
         @disable_request_forgery_protection = false
         @allow_same_origin_as_host = true
+        @filter_parameters = []
+
+        @health_check_application = ->(env) {
+          [200, { Rack::CONTENT_TYPE => "text/html", "date" => Time.now.httpdate }, []]
+        }
       end
 
       # Returns constant of subscription adapter specified in config/cable.yml.

data/lib/action_cable/server/connections.rb

@@ -2,6 +2,8 @@
 
 module ActionCable
   module Server
+    # = Action Cable \Server \Connections
+    #
     # Collection class for all the connections that have been established on this specific server. Remember, usually you'll run many Action Cable servers, so
     # you can't use this collection as a full list of all of the connections established against your application. Instead, use RemoteConnections for that.
     module Connections # :nodoc:
@@ -24,7 +26,7 @@ module ActionCable
       # disconnect.
       def setup_heartbeat_timer
         @heartbeat_timer ||= event_loop.timer(BEAT_INTERVAL) do
-          event_loop.post { connections.map(&:beat) }
+          event_loop.post { connections.each(&:beat) }
         end
       end
 

data/lib/action_cable/server/worker.rb

@@ -2,7 +2,6 @@
 
 require "active_support/callbacks"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
-require "action_cable/server/worker/active_record_connection_management"
 require "concurrent"
 
 module ActionCable

data/lib/action_cable/subscription_adapter/async.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "action_cable/subscription_adapter/inline"
-
 module ActionCable
   module SubscriptionAdapter
     class Async < Inline # :nodoc:

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -2,7 +2,6 @@
 
 gem "pg", "~> 1.1"
 require "pg"
-require "thread"
 require "openssl"
 
 module ActionCable

data/lib/action_cable/subscription_adapter/redis.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "thread"
-
-gem "redis", ">= 3", "< 6"
+gem "redis", ">= 4", "< 6"
 require "redis"
 
 require "active_support/core_ext/hash/except"
@@ -209,7 +207,7 @@ module ActionCable
             end
 
             if ::Redis::VERSION < "5"
-              ConnectionError = ::Redis::ConnectionError
+              ConnectionError = ::Redis::BaseConnectionError
 
               class SubscribedClient
                 def initialize(raw_client)
@@ -240,8 +238,7 @@ module ActionCable
               end
 
               def extract_subscribed_client(conn)
-                raw_client = conn.respond_to?(:_client) ? conn._client : conn.client
-                SubscribedClient.new(raw_client)
+                SubscribedClient.new(conn._client)
               end
             else
               ConnectionError = RedisClient::ConnectionError

data/lib/action_cable/subscription_adapter/test.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "async"
-
 module ActionCable
   module SubscriptionAdapter
-    # == Test adapter for Action Cable
+    # == \Test adapter for Action Cable
     #
     # The test adapter should be used only in testing. Along with
-    # ActionCable::TestHelper it makes a great tool to test your Rails application.
+    # ActionCable::TestHelper it makes a great tool to test your \Rails application.
     #
     # To use the test adapter set +adapter+ value to +test+ in your +config/cable.yml+ file.
     #
-    # NOTE: Test adapter extends the <tt>ActionCable::SubscriptionsAdapter::Async</tt> adapter,
+    # NOTE: +Test+ adapter extends the +ActionCable::SubscriptionAdapter::Async+ adapter,
     # so it could be used in system tests too.
     class Test < Async
       def broadcast(channel, payload)

data/lib/action_cable/test_helper.rb

@@ -29,30 +29,33 @@ module ActionCable
     #   end
     #
     # If a block is passed, that block should cause the specified number of
-    # messages to be broadcasted.
+    # messages to be broadcasted. It returns the messages that were broadcasted.
     #
     #   def test_broadcasts_again
-    #     assert_broadcasts('messages', 1) do
+    #     message = assert_broadcasts('messages', 1) do
     #       ActionCable.server.broadcast 'messages', { text: 'hello' }
     #     end
+    #     assert_equal({ text: 'hello' }, message)
     #
-    #     assert_broadcasts('messages', 2) do
+    #     messages = assert_broadcasts('messages', 2) do
     #       ActionCable.server.broadcast 'messages', { text: 'hi' }
     #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
     #     end
+    #     assert_equal 2, messages.length
+    #     assert_equal({ text: 'hi' }, messages.first)
+    #     assert_equal({ text: 'how are you?' }, messages.last)
     #   end
     #
     def assert_broadcasts(stream, number, &block)
       if block_given?
-        original_count = broadcasts_size(stream)
-        _assert_nothing_raised_or_warn("assert_broadcasts", &block)
-        new_count = broadcasts_size(stream)
-        actual_count = new_count - original_count
+        new_messages = new_broadcasts_from(broadcasts(stream), stream, "assert_broadcasts", &block)
+
+        actual_count = new_messages.size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
       else
-        actual_count = broadcasts_size(stream)
+        actual_count = broadcasts(stream).size
+        assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
       end
-
-      assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
     end
 
     # Asserts that no messages have been sent to the stream.
@@ -79,6 +82,22 @@ module ActionCable
       assert_broadcasts stream, 0, &block
     end
 
+    # Returns the messages that are broadcasted in the block.
+    #
+    #   def test_broadcasts
+    #     messages = capture_broadcasts('messages') do
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #     end
+    #     assert_equal 2, messages.length
+    #     assert_equal({ text: 'hi' }, messages.first)
+    #     assert_equal({ text: 'how are you?' }, messages.last)
+    #   end
+    #
+    def capture_broadcasts(stream, &block)
+      new_broadcasts_from(broadcasts(stream), stream, "capture_broadcasts", &block).map { |m| ActiveSupport::JSON.decode(m) }
+    end
+
     # Asserts that the specified message has been sent to the stream.
     #
     #   def test_assert_transmitted_message
@@ -103,20 +122,22 @@ module ActionCable
 
       new_messages = broadcasts(stream)
       if block_given?
-        old_messages = new_messages
-        clear_messages(stream)
-
-        _assert_nothing_raised_or_warn("assert_broadcast_on", &block)
-        new_messages = broadcasts(stream)
-        clear_messages(stream)
-
-        # Restore all sent messages
-        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+        new_messages = new_broadcasts_from(new_messages, stream, "assert_broadcast_on", &block)
       end
 
       message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
 
-      assert message, "No messages sent with #{data} to #{stream}"
+      error_message = "No messages sent with #{data} to #{stream}"
+
+      if new_messages.any?
+        error_message = new_messages.inject("#{error_message}\nMessage(s) found:\n") do |error_message, new_message|
+          error_message + "#{ActiveSupport::JSON.decode(new_message)}\n"
+        end
+      else
+        error_message = "#{error_message}\nNo message found for #{stream}"
+      end
+
+      assert message, error_message
     end
 
     def pubsub_adapter # :nodoc:
@@ -126,8 +147,18 @@ module ActionCable
     delegate :broadcasts, :clear_messages, to: :pubsub_adapter
 
     private
-      def broadcasts_size(channel)
-        broadcasts(channel).size
+      def new_broadcasts_from(current_messages, stream, assertion, &block)
+        old_messages = current_messages
+        clear_messages(stream)
+
+        _assert_nothing_raised_or_warn(assertion, &block)
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+
+        new_messages
       end
   end
 end