actioncable 7.0.4 → 7.1.5.1

data/lib/action_cable/channel/streams.rb

@@ -2,6 +2,8 @@
 
 module ActionCable
   module Channel
+    # = Action Cable \Channel \Streams
+    #
     # Streams allow channels to route broadcastings to the subscriber. A broadcasting is, as discussed elsewhere, a pubsub queue where any data
     # placed into it is automatically sent to the clients that are connected at that time. It's purely an online queue, though. If you're not
     # streaming a broadcasting at the very moment it sends out an update, you will not get that update, even if you connect after it has been sent.

data/lib/action_cable/channel/test_case.rb

@@ -15,6 +15,8 @@ module ActionCable
       end
     end
 
+    # = Action Cable \Channel Stub
+    #
     # Stub +stream_from+ to track streams for the channel.
     # Add public aliases for +subscription_confirmation_sent?+ and
     # +subscription_rejected?+.
@@ -45,9 +47,12 @@ module ActionCable
     end
 
     class ConnectionStub
-      attr_reader :transmissions, :identifiers, :subscriptions, :logger
+      attr_reader :server, :transmissions, :identifiers, :subscriptions, :logger
+
+      delegate :pubsub, :config, to: :server
 
       def initialize(identifiers = {})
+        @server = ActionCable.server
         @transmissions = []
 
         identifiers.each do |identifier, val|
@@ -135,11 +140,11 @@ module ActionCable
     # ActionCable::Channel::TestCase will also automatically provide the following instance
     # methods for use in the tests:
     #
-    # <b>connection</b>::
+    # connection::
     #      An ActionCable::Channel::ConnectionStub, representing the current HTTP connection.
-    # <b>subscription</b>::
+    # subscription::
     #      An instance of the current channel, created when you call +subscribe+.
-    # <b>transmissions</b>::
+    # transmissions::
     #      A list of all messages that have been transmitted into the channel.
     #
     #

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.

data/lib/action_cable/connection/callbacks.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+
+module ActionCable
+  module Connection
+    # = Action Cable \Connection \Callbacks
+    #
+    # The {before_command}[rdoc-ref:ClassMethods#before_command],
+    # {after_command}[rdoc-ref:ClassMethods#after_command], and
+    # {around_command}[rdoc-ref:ClassMethods#around_command] callbacks are
+    # invoked when sending commands to the client, such as when subscribing,
+    # unsubscribing, or performing an action.
+    #
+    # ==== Example
+    #
+    #    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  = 4
-    PRE   = nil
+    MINOR = 1
+    TINY  = 5
+    PRE   = "1"
 
     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"
@@ -46,7 +44,7 @@ module ActionCable
 
       private
         def listener
-          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
+          @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, config_options, @server.event_loop) }
         end
 
         def redis_connection_for_broadcasts
@@ -56,11 +54,15 @@ module ActionCable
         end
 
         def redis_connection
-          self.class.redis_connector.call(@server.config.cable.symbolize_keys.merge(id: identifier))
+          self.class.redis_connector.call(config_options)
+        end
+
+        def config_options
+          @config_options ||= @server.config.cable.deep_symbolize_keys.merge(id: identifier)
         end
 
         class Listener < SubscriberMap
-          def initialize(adapter, event_loop)
+          def initialize(adapter, config_options, event_loop)
             super()
 
             @adapter = adapter
@@ -69,6 +71,11 @@ module ActionCable
             @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
             @subscription_lock = Mutex.new
 
+            @reconnect_attempt = 0
+            # Use the same config as used by Redis conn
+            @reconnect_attempts = config_options.fetch(:reconnect_attempts, 1)
+            @reconnect_attempts = Array.new(@reconnect_attempts, 0) if @reconnect_attempts.is_a?(Integer)
+
             @subscribed_client = nil
 
             @when_connected = []
@@ -84,6 +91,7 @@ module ActionCable
                 on.subscribe do |chan, count|
                   @subscription_lock.synchronize do
                     if count == 1
+                      @reconnect_attempt = 0
                       @subscribed_client = original_client
 
                       until @when_connected.empty?
@@ -150,8 +158,16 @@ module ActionCable
               @thread ||= Thread.new do
                 Thread.current.abort_on_exception = true
 
-                conn = @adapter.redis_connection_for_subscriptions
-                listen conn
+                begin
+                  conn = @adapter.redis_connection_for_subscriptions
+                  listen conn
+                rescue ConnectionError
+                  reset
+                  if retry_connecting?
+                    when_connected { resubscribe }
+                    retry
+                  end
+                end
               end
             end
 
@@ -163,7 +179,36 @@ module ActionCable
               end
             end
 
+            def retry_connecting?
+              @reconnect_attempt += 1
+
+              return false if @reconnect_attempt > @reconnect_attempts.size
+
+              sleep_t = @reconnect_attempts[@reconnect_attempt - 1]
+
+              sleep(sleep_t) if sleep_t > 0
+
+              true
+            end
+
+            def resubscribe
+              channels = @sync.synchronize do
+                @subscribers.keys
+              end
+              @subscribed_client.subscribe(*channels) unless channels.empty?
+            end
+
+            def reset
+              @subscription_lock.synchronize do
+                @subscribed_client = nil
+                @subscribe_callbacks.clear
+                @when_connected.clear
+              end
+            end
+
             if ::Redis::VERSION < "5"
+              ConnectionError = ::Redis::BaseConnectionError
+
               class SubscribedClient
                 def initialize(raw_client)
                   @raw_client = raw_client
@@ -193,10 +238,11 @@ 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
+
               def extract_subscribed_client(conn)
                 conn
               end