omg-actioncable 8.0.0.alpha2

data/lib/action_cable/engine.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_cable"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionCable
+  class Engine < Rails::Engine # :nodoc:
+    config.action_cable = ActiveSupport::OrderedOptions.new
+    config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
+    config.action_cable.precompile_assets = true
+
+    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
+        include ActionCable::Helpers::ActionCableHelper
+      end
+    end
+
+    initializer "action_cable.logger" do
+      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
+          app.config.assets.precompile += %w( actioncable.js actioncable.esm.js )
+        end
+      end
+    end
+
+    initializer "action_cable.set_configs" do |app|
+      options = app.config.action_cable
+      options.allowed_request_origins ||= /https?:\/\/localhost:\d+/ if ::Rails.env.development?
+
+      app.paths.add "config/cable", with: "config/cable.yml"
+
+      ActiveSupport.on_load(:action_cable) do
+        if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
+          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
+    end
+
+    initializer "action_cable.routes" do
+      config.after_initialize do |app|
+        config = app.config
+        unless config.action_cable.mount_path.nil?
+          app.routes.prepend do
+            mount ActionCable.server => config.action_cable.mount_path, internal: true, anchor: true
+          end
+        end
+      end
+    end
+
+    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(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.
+            unless stopping?
+              inner.call
+            end
+          end
+        end
+
+        wrap = lambda do |_, 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
+
+        app.reloader.before_class_unload do
+          ActionCable.server.restart
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/gem_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  # 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 = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha2"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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-turbo-track' => 'reload' %>
+      #     </head>
+      #
+      # This is then used by Action Cable to determine the URL of your WebSocket
+      # server. Your JavaScript can then connect to the server without needing to
+      # specify the URL directly:
+      #
+      #     import Cable from "@rails/actioncable"
+      #     window.Cable = Cable
+      #     window.App = {}
+      #     App.cable = Cable.createConsumer()
+      #
+      # Make sure to specify the correct server location in each of your environment
+      # config files:
+      #
+      #     config.action_cable.mount_path = "/cable123"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="/cable123" />
+      #
+      #     config.action_cable.url = "ws://actioncable.com"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="ws://actioncable.com" />
+      #
+      def action_cable_meta_tag
+        tag "meta", name: "action-cable-url", content: (
+          ActionCable.server.config.url ||
+          ActionCable.server.config.mount_path ||
+          raise("No Action Cable URL configured -- please configure this at config.action_cable.url")
+        )
+      end
+    end
+  end
+end

data/lib/action_cable/remote_connections.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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:
+  #
+  #     module ApplicationCable
+  #       class Connection < ActionCable::Connection::Base
+  #         identified_by :current_user
+  #         ....
+  #       end
+  #     end
+  #
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #
+  # This 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 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
+
+    def initialize(server)
+      @server = server
+    end
+
+    def where(identifier)
+      RemoteConnection.new(server, identifier)
+    end
+
+    # # Action Cable Remote Connection
+    #
+    # Represents a single remote connection found via
+    # `ActionCable.server.remote_connections.where(*)`. Exists 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(reconnect: true)
+        server.broadcast internal_channel, { type: "disconnect", reconnect: reconnect }
+      end
+
+      # Returns all the identifiers that were applied to this connection.
+      redefine_method :identifiers do
+        server.connection_identifiers
+      end
+
+      protected
+        attr_reader :server
+
+      private
+        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/base.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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.
+    #
+    # Also, this is the server instance used for broadcasting. See Broadcasting for
+    # more information.
+    class Base
+      include ActionCable::Server::Broadcasting
+      include ActionCable::Server::Connections
+
+      cattr_accessor :config, instance_accessor: false, default: ActionCable::Server::Configuration.new
+
+      attr_reader :config
+
+      def self.logger; config.logger; end
+      delegate :logger, to: :config
+
+      attr_reader :mutex
+
+      def initialize(config: self.class.config)
+        @config = config
+        @mutex = Monitor.new
+        @remote_connections = @event_loop = @worker_pool = @pubsub = nil
+      end
+
+      # 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
+
+      # Disconnect all the connections identified by `identifiers` on this server or
+      # any others via RemoteConnections.
+      def disconnect(identifiers)
+        remote_connections.where(identifiers).disconnect
+      end
+
+      def restart
+        connections.each do |connection|
+          connection.close(reason: ActionCable::INTERNAL[:disconnect_reasons][:server_restart])
+        end
+
+        @mutex.synchronize do
+          # Shutdown the worker pool
+          @worker_pool.halt if @worker_pool
+          @worker_pool = nil
+
+          # Shutdown the pub/sub adapter
+          @pubsub.shutdown if @pubsub
+          @pubsub = nil
+        end
+      end
+
+      # Gateway to RemoteConnections. See that class for details.
+      def remote_connections
+        @remote_connections || @mutex.synchronize { @remote_connections ||= RemoteConnections.new(self) }
+      end
+
+      def event_loop
+        @event_loop || @mutex.synchronize { @event_loop ||= ActionCable::Connection::StreamEventLoop.new }
+      end
+
+      # The worker pool is where we run connection callbacks and channel actions. We
+      # do as little as possible on the server's main thread. The worker pool is an
+      # executor service that's backed by a pool of threads working from a task queue.
+      # The thread pool size maxes out at 4 worker threads by default. Tune the size
+      # yourself with `config.action_cable.worker_pool_size`.
+      #
+      # Using Active Record, Redis, etc within your channel actions means you'll get a
+      # separate connection from each thread in the worker pool. Plan your deployment
+      # accordingly: 5 servers each running 5 Puma workers each running an 8-thread
+      # worker pool means at least 200 database connections.
+      #
+      # Also, ensure that your database connection pool size is as least as large as
+      # your worker pool size. Otherwise, workers may oversubscribe the database
+      # connection pool and block while they wait for other workers to release their
+      # connections. Use a smaller worker pool or a larger database connection pool
+      # instead.
+      def worker_pool
+        @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
+      end
+
+      # Adapter used for all streams/broadcasting.
+      def pubsub
+        @pubsub || @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) }
+      end
+
+      # All of the identifiers applied to the connection class associated with this
+      # server.
+      def connection_identifiers
+        config.connection_class.call.identifiers
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:action_cable, Base.config)
+  end
+end

data/lib/action_cable/server/broadcasting.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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:
+    #
+    #     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 that's fit for print" }
+    #
+    #     # Client-side CoffeeScript, 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 `broadcasting`. This will later be JSON
+      # encoded.
+      def broadcast(broadcasting, message, coder: ActiveSupport::JSON)
+        broadcaster_for(broadcasting, coder: coder).broadcast(message)
+      end
+
+      # Returns a broadcaster for a named `broadcasting` that can be reused. Useful
+      # when you have an object that may need multiple spots to transmit to a specific
+      # broadcasting over and over.
+      def broadcaster_for(broadcasting, coder: ActiveSupport::JSON)
+        Broadcaster.new(self, String(broadcasting), coder: coder)
+      end
+
+      private
+        class Broadcaster
+          attr_reader :server, :broadcasting, :coder
+
+          def initialize(server, broadcasting, coder:)
+            @server, @broadcasting, @coder = server, broadcasting, coder
+          end
+
+          def broadcast(message)
+            server.logger.debug { "[ActionCable] Broadcasting to #{broadcasting}: #{message.inspect.truncate(300)}" }
+
+            payload = { broadcasting: broadcasting, message: message, coder: coder }
+            ActiveSupport::Notifications.instrument("broadcast.action_cable", payload) do
+              encoded = coder ? coder.encode(message) : message
+              server.pubsub.broadcast broadcasting, encoded
+            end
+          end
+        end
+    end
+  end
+end

data/lib/action_cable/server/configuration.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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.
+    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, :filter_parameters
+      attr_accessor :cable, :url, :mount_path
+      attr_accessor :precompile_assets
+      attr_accessor :health_check_path, :health_check_application
+
+      def initialize
+        @log_tags = []
+
+        @connection_class = -> { ActionCable::Connection::Base }
+        @worker_pool_size = 4
+
+        @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.
+      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.
+        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.
+          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.
+            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.
+          else
+            raise e.class, "Error loading the '#{adapter}' Action Cable pubsub adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+          end
+        end
+
+        adapter = adapter.camelize
+        adapter = "PostgreSQL" if adapter == "Postgresql"
+        "ActionCable::SubscriptionAdapter::#{adapter}".constantize
+      end
+    end
+  end
+end

data/lib/action_cable/server/connections.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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:
+      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 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.each(&:beat) }
+        end
+      end
+
+      def open_connections_statistics
+        connections.map(&:statistics)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Server
+    class Worker
+      module ActiveRecordConnectionManagement
+        extend ActiveSupport::Concern
+
+        included do
+          if defined?(ActiveRecord::Base)
+            set_callback :work, :around, :with_database_connections
+          end
+        end
+
+        def with_database_connections(&block)
+          connection.logger.tag(ActiveRecord::Base.logger, &block)
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/server/worker.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/callbacks"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "concurrent"
+
+module ActionCable
+  module Server
+    # Worker used by Server.send_async to do connection work in threads.
+    class Worker # :nodoc:
+      include ActiveSupport::Callbacks
+
+      thread_mattr_accessor :connection
+      define_callbacks :work
+      include ActiveRecordConnectionManagement
+
+      attr_reader :executor
+
+      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
+      def halt
+        @executor.shutdown
+      end
+
+      def stopping?
+        @executor.shuttingdown?
+      end
+
+      def work(connection, &block)
+        self.connection = connection
+
+        run_callbacks :work, &block
+      ensure
+        self.connection = nil
+      end
+
+      def async_exec(receiver, *args, connection:, &block)
+        async_invoke receiver, :instance_exec, *args, connection: connection, &block
+      end
+
+      def async_invoke(receiver, method, *args, connection: receiver, &block)
+        @executor.post do
+          invoke(receiver, method, *args, connection: connection, &block)
+        end
+      end
+
+      def invoke(receiver, method, *args, connection:, &block)
+        work(connection) do
+          receiver.send method, *args, &block
+        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
+      end
+
+      private
+        def logger
+          ActionCable.server.logger
+        end
+    end
+  end
+end

data/lib/action_cable/subscription_adapter/async.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module SubscriptionAdapter
+    class Async < Inline # :nodoc:
+      private
+        def new_subscriber_map
+          AsyncSubscriberMap.new(server.event_loop)
+        end
+
+        class AsyncSubscriberMap < SubscriberMap
+          def initialize(event_loop)
+            @event_loop = event_loop
+            super()
+          end
+
+          def add_subscriber(*)
+            @event_loop.post { super }
+          end
+
+          def invoke_callback(*)
+            @event_loop.post { super }
+          end
+        end
+    end
+  end
+end