actioncable 6.1.7.9 → 7.2.2.1

data/lib/action_cable/server/configuration.rb

@@ -1,14 +1,23 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
+require "rack"
+
 module ActionCable
   module Server
-    # 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.
+    # # 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.
     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 = []
@@ -18,30 +27,35 @@ 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.
-      # If the adapter cannot be found, this will default to the Redis adapter.
-      # Also makes sure proper dependencies are required.
+      # Returns constant of subscription adapter specified in config/cable.yml. If the
+      # adapter cannot be found, this will default to the Redis adapter. Also makes
+      # sure proper dependencies are required.
       def pubsub_adapter
         adapter = (cable.fetch("adapter") { "redis" })
 
         # Require the adapter itself and give useful feedback about
-        #   1. Missing adapter gems and
-        #   2. Adapter gems' missing dependencies.
+        #     1. Missing adapter gems and
+        #     2. Adapter gems' missing dependencies.
         path_to_adapter = "action_cable/subscription_adapter/#{adapter}"
         begin
           require path_to_adapter
         rescue LoadError => e
-          # We couldn't require the adapter itself. Raise an exception that
-          # points out config typos and missing gems.
+          # We couldn't require the adapter itself. Raise an exception that points out
+          # config typos and missing gems.
           if e.path == path_to_adapter
-            # We can assume that a non-builtin adapter was specified, so it's
-            # either misspelled or missing from Gemfile.
+            # We can assume that a non-builtin adapter was specified, so it's either
+            # misspelled or missing from Gemfile.
             raise e.class, "Could not load the '#{adapter}' Action Cable pubsub adapter. Ensure that the adapter is spelled correctly in config/cable.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
 
-          # Bubbled up from the adapter require. Prefix the exception message
-          # with some guidance about how to address it and reraise.
+          # Bubbled up from the adapter require. Prefix the exception message with some
+          # guidance about how to address it and reraise.
           else
             raise e.class, "Error loading the '#{adapter}' Action Cable pubsub adapter. Missing a gem it depends on? #{e.message}", e.backtrace
           end

data/lib/action_cable/server/connections.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module Server
-    # 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.
+    # # 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:
       BEAT_INTERVAL = 3
 
@@ -19,12 +25,14 @@ module ActionCable
         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 communicate with the connection. To solve this, a 3 second heartbeat runs on all connections. If the beat fails, we automatically
+      # 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 communicate with the connection. To solve this, a 3
+      # second heartbeat runs on all connections. If the beat fails, we automatically
       # 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/active_record_connection_management.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module Server
     class Worker
@@ -12,8 +14,8 @@ module ActionCable
           end
         end
 
-        def with_database_connections
-          connection.logger.tag(ActiveRecord::Base.logger) { yield }
+        def with_database_connections(&block)
+          connection.logger.tag(ActiveRecord::Base.logger, &block)
         end
       end
     end

data/lib/action_cable/server/worker.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 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
@@ -19,14 +20,15 @@ module ActionCable
 
       def initialize(max_size: 5)
         @executor = Concurrent::ThreadPoolExecutor.new(
+          name: "ActionCable",
           min_threads: 1,
           max_threads: max_size,
           max_queue: 0,
         )
       end
 
-      # Stop processing work: any work that has not already started
-      # running will be discarded from the queue
+      # Stop processing work: any work that has not already started running will be
+      # discarded from the queue
       def halt
         @executor.shutdown
       end
@@ -35,12 +37,10 @@ module ActionCable
         @executor.shuttingdown?
       end
 
-      def work(connection)
+      def work(connection, &block)
         self.connection = connection
 
-        run_callbacks :work do
-          yield
-        end
+        run_callbacks :work, &block
       ensure
         self.connection = nil
       end

data/lib/action_cable/subscription_adapter/async.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "action_cable/subscription_adapter/inline"
+# :markup: markdown
 
 module ActionCable
   module SubscriptionAdapter

data/lib/action_cable/subscription_adapter/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class Base

data/lib/action_cable/subscription_adapter/channel_prefix.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     module ChannelPrefix # :nodoc:

data/lib/action_cable/subscription_adapter/inline.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class Inline < Base # :nodoc:

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 gem "pg", "~> 1.1"
 require "pg"
-require "thread"
-require "digest/sha1"
+require "openssl"
 
 module ActionCable
   module SubscriptionAdapter
@@ -35,8 +36,8 @@ module ActionCable
 
       def with_subscriptions_connection(&block) # :nodoc:
         ar_conn = ActiveRecord::Base.connection_pool.checkout.tap do |conn|
-          # Action Cable is taking ownership over this database connection, and
-          # will perform the necessary cleanup tasks
+          # Action Cable is taking ownership over this database connection, and will
+          # perform the necessary cleanup tasks
           ActiveRecord::Base.connection_pool.remove(conn)
         end
         pg_conn = ar_conn.raw_connection
@@ -58,7 +59,7 @@ module ActionCable
 
       private
         def channel_identifier(channel)
-          channel.size > 63 ? Digest::SHA1.hexdigest(channel) : channel
+          channel.size > 63 ? OpenSSL::Digest::SHA1.hexdigest(channel) : channel
         end
 
         def listener

data/lib/action_cable/subscription_adapter/redis.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "thread"
+# :markup: markdown
 
-gem "redis", ">= 3", "< 5"
+gem "redis", ">= 4", "< 6"
 require "redis"
 
 require "active_support/core_ext/hash/except"
@@ -12,8 +12,9 @@ module ActionCable
     class Redis < Base # :nodoc:
       prepend ChannelPrefix
 
-      # Overwrite this factory method for Redis connections if you want to use a different Redis library than the redis gem.
-      # This is needed, for example, when using Makara proxies for distributed Redis.
+      # Overwrite this factory method for Redis connections if you want to use a
+      # different Redis library than the redis gem. This is needed, for example, when
+      # using Makara proxies for distributed Redis.
       cattr_accessor :redis_connector, default: ->(config) do
         ::Redis.new(config.except(:adapter, :channel_prefix))
       end
@@ -46,7 +47,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 +57,15 @@ module ActionCable
         end
 
         def redis_connection
-          self.class.redis_connector.call(@server.config.cable.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,7 +74,12 @@ module ActionCable
             @subscribe_callbacks = Hash.new { |h, k| h[k] = [] }
             @subscription_lock = Mutex.new
 
-            @raw_client = nil
+            @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 = []
 
@@ -78,13 +88,14 @@ module ActionCable
 
           def listen(conn)
             conn.without_reconnect do
-              original_client = conn.respond_to?(:_client) ? conn._client : conn.client
+              original_client = extract_subscribed_client(conn)
 
               conn.subscribe("_action_cable_internal") do |on|
                 on.subscribe do |chan, count|
                   @subscription_lock.synchronize do
                     if count == 1
-                      @raw_client = original_client
+                      @reconnect_attempt = 0
+                      @subscribed_client = original_client
 
                       until @when_connected.empty?
                         @when_connected.shift.call
@@ -106,7 +117,7 @@ module ActionCable
                 on.unsubscribe do |chan, count|
                   if count == 0
                     @subscription_lock.synchronize do
-                      @raw_client = nil
+                      @subscribed_client = nil
                     end
                   end
                 end
@@ -119,8 +130,8 @@ module ActionCable
               return if @thread.nil?
 
               when_connected do
-                send_command("unsubscribe")
-                @raw_client = nil
+                @subscribed_client.unsubscribe
+                @subscribed_client = nil
               end
             end
 
@@ -131,13 +142,13 @@ module ActionCable
             @subscription_lock.synchronize do
               ensure_listener_running
               @subscribe_callbacks[channel] << on_success
-              when_connected { send_command("subscribe", channel) }
+              when_connected { @subscribed_client.subscribe(channel) }
             end
           end
 
           def remove_channel(channel)
             @subscription_lock.synchronize do
-              when_connected { send_command("unsubscribe", channel) }
+              when_connected { @subscribed_client.unsubscribe(channel) }
             end
           end
 
@@ -150,28 +161,93 @@ 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
 
             def when_connected(&block)
-              if @raw_client
+              if @subscribed_client
                 block.call
               else
                 @when_connected << block
               end
             end
 
-            def send_command(*command)
-              @raw_client.write(command)
+            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
+                end
+
+                def subscribe(*channel)
+                  send_command("subscribe", *channel)
+                end
+
+                def unsubscribe(*channel)
+                  send_command("unsubscribe", *channel)
+                end
 
-              very_raw_connection =
-                @raw_client.connection.instance_variable_defined?(:@connection) &&
-                @raw_client.connection.instance_variable_get(:@connection)
+                private
+                  def send_command(*command)
+                    @raw_client.write(command)
+
+                    very_raw_connection =
+                      @raw_client.connection.instance_variable_defined?(:@connection) &&
+                      @raw_client.connection.instance_variable_get(:@connection)
+
+                    if very_raw_connection && very_raw_connection.respond_to?(:flush)
+                      very_raw_connection.flush
+                    end
+                    nil
+                  end
+              end
+
+              def extract_subscribed_client(conn)
+                SubscribedClient.new(conn._client)
+              end
+            else
+              ConnectionError = RedisClient::ConnectionError
 
-              if very_raw_connection && very_raw_connection.respond_to?(:flush)
-                very_raw_connection.flush
+              def extract_subscribed_client(conn)
+                conn
               end
             end
         end

data/lib/action_cable/subscription_adapter/subscriber_map.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module SubscriptionAdapter
     class SubscriberMap

data/lib/action_cable/subscription_adapter/test.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "async"
+# :markup: markdown
 
 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
-    # <tt>ActionCable::TestHelper</tt> 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.
+    # 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,
-    # so it could be used in system tests too.
+    # 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)
         broadcasts(channel) << payload

data/lib/action_cable/test_case.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/test_case"
 
 module ActionCable