anycable-rails 1.0.7 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 474cfd55dac8443341c7717845af042cd80889e3d865cdef3a6e41d089f02348
-  data.tar.gz: e744ee509ebc1ee82cb112150f346970fe52b55dfb134745b927f94c5670198e
+  metadata.gz: 6200d2863868ed23ac3bcc19478e4310bc4097bfff5884eb5c427ef9c41ec6be
+  data.tar.gz: a33f42cd90e362301dc90f5957b77787cec29e28c3aeee9782d3d81c582301f4
 SHA512:
-  metadata.gz: 4092bd45059bbb6062df44dc78b4ba2ff1bf8a2f3ef65448f7baf3886c35b91b4e0feb315e86e92cf746735f945b007d7550bd01c5bdd1a0dc6b32178d1a1c68
-  data.tar.gz: e63aa37233adf6f31eff249c2b9f1beeb1ea41d7f50152061cb8b3769cefc9be863c380df710dcf6715c4b2070fda26a569f3a2b7d8bca63cecc5fc8c3b0c97f
+  metadata.gz: 2f89b8b32dca31e58df2ad57f926b6ef7f2619dd5286d630e393cd7e306fd247cba46e4aa1ce76304bb75486ba52127b0d819dae10093e0a835a5e11c9b02ece
+  data.tar.gz: 5fc0c51cb4eb86c5c8bbbbae0c896af8440ec765370ff0c4a69aaa146e3d2465f1b28993f8f213cd7f8d956d684251aecb7eeda8951db14b0dbbc4c035b45507

data/CHANGELOG.md

@@ -2,6 +2,88 @@
 
 ## master
 
+## 1.3.4 (2022-06-28)
+
+- Add support and backport for Connection command callbacks. ([@palkan][])
+
+## 1.3.3 (2022-04-20)
+
+- Added `sid` (unique connection identifier) field to the `welcome` message if present. ([@palkan][])
+
+- Fixed handling Ruby Logger incompatible loggers. ([@palkan][])
+
+## 1.3.2 (2022-03-04)
+
+- Allow Ruby 2.6.
+
+## 1.3.1 (2022-02-28)
+
+- Fix Action Cable Channel patch to not change methods signatures. ([@palkan][])
+
+Otherwise it could lead to conflicts with other patches.
+
+## 1.3.0 (2022-02-21)
+
+- Introduce `AnyCable::Rails.extend_adapter!` to make any pubsub adapter AnyCable-compatible. ([@palkan][])
+
+- Refactored Action Cable patching to preserve original functionality and avoid monkey-patching collisions. ([@palkan][])
+
+## 1.2.1 (2022-01-31)
+
+- Add a temporary fix to be compatible with `sentry-rails`. ([@palkan][])
+
+See [#165](https://github.com/anycable/anycable-rails/issues/165).
+
+- Run embedded RPC server only if `any_cable` adapter is used for Action Cable. ([@palkan][])
+
+## 1.2.0 (2021-12-21) 🎄
+
+- Drop Rails 5 support.
+
+- Drop Ruby 2.6 support.
+
+## 1.1.4 (2021-11-11)
+
+- Added `Connection#state_attr_accessor`. ([@palkan][])
+
+## 1.1.3 (2021-10-11)
+
+- Relax Action Cable dependency. ([@palkan][])
+
+Action Cable 5.1 is allowed (though not recommended).
+
+## 1.1.2 (2021-06-23)
+
+- Bring back dependency on `anycable` (instead of `anycable-core`). ([@palkan][])
+
+Make it easier to get started by adding just a single gem.
+
+## 1.1.1 (2021-06-08)
+
+- Updated documentation links in the generator. ([@palkan][])
+
+## 1.1.0 🚸 (2021-06-01)
+
+- No changes since 1.1.0.rc1.1.
+
+## 1.1.0.rc1.1 (2021-05-12)
+
+- Fixed config loading regression introduced in 1.1.0.rc1.
+
+## 1.1.0.rc1 (2021-05-12)
+
+- Adding `anycable` or `grpc` gem as an explicit dependency is required.
+
+Now, `anycable-rails` depends on `anycable-core`, which doesn't include gRPC server implementation.
+You should either add `anycable` or `grpc` (>= 1.37) gem as an explicit dependency.
+
+- Add option to embed AnyCable RPC into a Rails server process. ([@palkan][])
+
+Set `embedded: true` in the configuration to launch RPC along with `rails s` (only for Rails 6.1+).
+
+- **Ruby >= 2.6** is required.
+- **Rails >= 6.0** is required.
+
 ## 1.0.7 (2021-03-05)
 
 - Ruby 3 compatibility. ([@palkan][])

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2017-2021 palkan
+Copyright 2017-2022 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,7 +1,6 @@
 [![Gem Version](https://badge.fury.io/rb/anycable-rails.svg)](https://rubygems.org/gems/anycable-rails)
 [![Build](https://github.com/anycable/anycable-rails/workflows/Build/badge.svg)](https://github.com/anycable/anycable-rails/actions)
-[![Gitter](https://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/anycable/Lobby)
-[![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://docs.anycable.io/#/rails/getting_started)
+[![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://docs.anycable.io/rails/getting_started)
 
 # AnyCable Rails
 
@@ -11,19 +10,19 @@ With AnyCable you can use channels, client-side JS, broadcasting - (almost) all
 
 You can even use Action Cable in development and not be afraid of [compatibility issues](#compatibility).
 
-**Important** This is a readme for the upcoming v1.0 release. For v0.6.x see the readme from the [0-6-stable](https://github.com/anycable/anycable-rails/tree/0-6-stable) branch.
-
 💾 [Example Application](https://github.com/anycable/anycable_rails_demo)
 
-📑 [Documentation](https://docs.anycable.io/#/rails/getting_started).
+📑 [Documentation](https://docs.anycable.io/rails/getting_started).
+
+> [AnyCable Pro](https://docs.anycable.io/pro) has been launched 🚀
 
 <a href="https://evilmartians.com/">
 <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
 
 ## Requirements
 
-- Ruby >= 2.5
-- Rails >= 5.2
+- Ruby >= 2.6
+- Rails >= 6.0 (Rails 5.1 could work but we're no longer enforce compatibility on CI)
 - Redis (see [other options](https://github.com/anycable/anycable/issues/2) for broadcasting)
 
 ## Usage
@@ -64,7 +63,7 @@ and specify AnyCable WebSocket server URL:
 # For development it's likely the localhost
 
 # config/environments/development.rb
-config.action_cable.url = "ws://localhost:3334/cable"
+config.action_cable.url = "ws://localhost:8080/cable"
 
 # For production it's likely to have a sub-domain and secure connection
 
@@ -82,17 +81,17 @@ $ bundle exec anycable
 $ RAILS_ENV=production bundle exec anycable
 ```
 
-And, finally, run AnyCable WebSocket server, e.g. [anycable-go](https://docs.anycable.io/#/v1/anycable-go/getting_started):
+And, finally, run AnyCable WebSocket server, e.g. [anycable-go](https://docs.anycable.io/anycable-go/getting_started):
 
 ```sh
-anycable-go --host=localhost --port=3334
+anycable-go --host=localhost --port=8080
 ```
 
-See [documentation](https://docs.anycable.io/#/rails/getting_started) for more information on AnyCable + Rails usage.
+See [documentation](https://docs.anycable.io/rails/getting_started) for more information on AnyCable + Rails usage.
 
 ## Action Cable Compatibility
 
-See [documentation](https://docs.anycable.io/#/rails/compatibility).
+See [documentation](https://docs.anycable.io/rails/compatibility).
 
 ## Contributing
 

data/lib/anycable/rails/action_cable_ext/channel.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  def subscribe_to_channel
+    super unless anycabled? && !@__anycable_subscribing__
+  end
+
+  def handle_subscribe
+    @__anycable_subscribing__ = true
+    subscribe_to_channel
+  ensure
+    @__anycable_subscribing__ = false
+  end
+
+  def start_periodic_timers
+    super unless anycabled?
+  end
+
+  def stop_periodic_timers
+    super unless anycabled?
+  end
+
+  def stream_from(broadcasting, _callback = nil, **)
+    return super unless anycabled?
+
+    connection.anycable_socket.subscribe identifier, broadcasting
+  end
+
+  def stop_stream_from(broadcasting)
+    return super unless anycabled?
+
+    connection.anycable_socket.unsubscribe identifier, broadcasting
+  end
+
+  def stop_all_streams
+    return super unless anycabled?
+
+    connection.anycable_socket.unsubscribe_from_all identifier
+  end
+
+  private
+
+  def anycabled?
+    # Use instance variable check here for testing compatibility
+    connection.instance_variable_defined?(:@anycable_socket)
+  end
+end)

data/lib/anycable/rails/action_cable_ext/connection.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "action_cable"
+require "anycable/rails/connections/serializable_identification"
+
+ActionCable::Connection::Base.include(AnyCable::Rails::Connections::SerializableIdentification)
+ActionCable::Connection::Base.prepend(Module.new do
+  attr_reader :anycable_socket
+  attr_accessor :anycable_request_builder
+
+  # In AnyCable, we lazily populate env by passing it through the middleware chain,
+  # so we access it via #request
+  def env
+    return super unless anycabled?
+
+    request.env
+  end
+
+  def anycabled?
+    @anycable_socket
+  end
+
+  private
+
+  def request
+    return super unless anycabled?
+
+    @request ||= anycable_request_builder.build_rack_request(@env)
+  end
+end)
+
+# Backport command callbacks: https://github.com/rails/rails/pull/44696
+unless ActionCable::Connection::Base.respond_to?(:before_command)
+  ActionCable::Connection::Base.include ActiveSupport::Callbacks
+  ActionCable::Connection::Base.define_callbacks :command
+  ActionCable::Connection::Base.extend(Module.new do
+    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)
+
+  ActionCable::Connection::Base.prepend(Module.new do
+    def dispatch_websocket_message(websocket_message)
+      return super unless websocket.alive?
+
+      handle_channel_command(decode(websocket_message))
+    end
+
+    def handle_channel_command(payload)
+      run_callbacks :command do
+        subscriptions.execute_command payload
+      end
+    end
+  end)
+end
+
+# Trigger autoload
+test_case_defined = false
+
+begin
+  ActionCable::Connection::TestCase # rubocop:disable Lint/Void
+  test_case_defined = true
+rescue NameError
+end
+
+# Backport: https://github.com/rails/rails/pull/45445
+if test_case_defined && !ActionCable::Connection::TestConnection.method_defined?(:transmissions)
+  ActionCable::Connection::TestConnection.prepend(Module.new do
+    attr_reader :transmissions
+
+    def initialize(*)
+      super
+
+      @transmissions = []
+      @subscriptions = ActionCable::Connection::Subscriptions.new(self)
+    end
+
+    def transmit(cable_message)
+      transmissions << cable_message.with_indifferent_access
+    end
+  end)
+end

data/lib/anycable/rails/{actioncable → action_cable_ext}/remote_connections.rb

@@ -2,10 +2,12 @@
 
 require "action_cable/remote_connections"
 
-ActionCable::RemoteConnections::RemoteConnection.include(ActionCable::Connection::SerializableIdentification)
+ActionCable::RemoteConnections::RemoteConnection.include(AnyCable::Rails::Connections::SerializableIdentification)
 
 ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
   def disconnect(reconnect: true)
+    # Legacy Action Cable functionality if case we're not fully migrated yet
+    super() unless AnyCable::Rails.enabled?
     ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
   end
 end)

data/lib/anycable/rails/channel_state.rb

@@ -10,11 +10,11 @@ module AnyCable
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{name}
                 return @#{name} if instance_variable_defined?(:@#{name})
-                @#{name} = AnyCable::Rails.deserialize(__istate__["#{name}"], json: true) if connection.anycable_socket
+                @#{name} = AnyCable::Rails.deserialize(__istate__["#{name}"], json: true) if anycabled?
               end
 
               def #{name}=(val)
-                __istate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if connection.anycable_socket
+                __istate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
                 instance_variable_set(:@#{name}, val)
               end
             RUBY
@@ -41,13 +41,68 @@ module AnyCable
       attr_writer :__istate__
 
       def __istate__
-        @__istate__ ||= connection.socket.istate
+        @__istate__ ||= connection.anycable_socket.istate
+      end
+    end
+
+    module ConnectionState
+      module ClassMethods
+        def state_attr_accessor(*names)
+          names.each do |name|
+            connection_state_attributes << name
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                return @#{name} if instance_variable_defined?(:@#{name})
+                @#{name} = AnyCable::Rails.deserialize(__cstate__["#{name}"], json: true) if anycabled?
+              end
+
+              def #{name}=(val)
+                __cstate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
+                instance_variable_set(:@#{name}, val)
+              end
+            RUBY
+          end
+        end
+
+        def connection_state_attributes
+          return @connection_state_attributes if instance_variable_defined?(:@connection_state_attributes)
+
+          @connection_state_attributes =
+            if superclass.respond_to?(:connection_state_attributes)
+              superclass.connection_state_attributes.dup
+            else
+              []
+            end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Make it possible to provide istate explicitly for a connection instance
+      attr_writer :__cstate__
+
+      def __cstate__
+        @__cstate__ ||= anycable_socket.cstate
       end
     end
   end
 end
 
-ActiveSupport.on_load(:action_cable) do
+if ActiveSupport::VERSION::MAJOR < 6
+  # `state_attr_accessor` must be available in Action Cable
+  ActiveSupport.on_load(:action_cable) do
+    ::ActionCable::Connection::Base.include(AnyCable::Rails::ConnectionState)
+    ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+  end
+else
   # `state_attr_accessor` must be available in Action Cable
-  ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+  ActiveSupport.on_load(:action_cable_connection) do
+    ::ActionCable::Connection::Base.include(AnyCable::Rails::ConnectionState)
+  end
+
+  ActiveSupport.on_load(:action_cable_channel) do
+    ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+  end
 end

data/lib/anycable/rails/config.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require "anycable/config"
+# Make sure Rails extensions for Anyway Config are loaded
+# See https://github.com/anycable/anycable-rails/issues/63
+require "anyway/rails"
 
 # Extend AnyCable configuration with:
 # - `access_logs_disabled` (defaults to true) — whether to print Started/Finished logs
 # - `persistent_session_enabled` (defaults to false) — whether to store session changes in the connection state
+# - `embedded` (defaults to false) — whether to run RPC server inside a Rails server process
 AnyCable::Config.attr_config(
   access_logs_disabled: true,
-  persistent_session_enabled: false
+  persistent_session_enabled: false,
+  embedded: false
 )
 AnyCable::Config.ignore_options :access_logs_disabled, :persistent_session_enabled

data/lib/anycable/rails/connection.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+module AnyCable
+  module Rails
+    # Enhance Action Cable connection
+    using(Module.new do
+      refine ActionCable::Connection::Base do
+        attr_writer :env, :websocket, :logger, :coder,
+          :subscriptions, :serialized_ids, :cached_ids, :server,
+          :anycable_socket
+
+        # Using public :send_welcome_message causes stack level too deep 🤷🏻‍♂️
+        def send_welcome_message
+          transmit({
+            type: ActionCable::INTERNAL[:message_types][:welcome],
+            sid: env["anycable.sid"]
+          }.compact)
+        end
+
+        def public_request
+          request
+        end
+      end
+
+      refine ActionCable::Channel::Base do
+        def rejected?
+          subscription_rejected?
+        end
+      end
+
+      refine ActionCable::Connection::Subscriptions do
+        # Find or add a subscription to the list
+        def fetch(identifier)
+          add("identifier" => identifier) unless subscriptions[identifier]
+
+          unless subscriptions[identifier]
+            raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}"
+          end
+
+          subscriptions[identifier]
+        end
+      end
+    end)
+
+    class Connection
+      # We store logger tags in the connection state to be able
+      # to re-use them in the subsequent calls
+      LOG_TAGS_IDENTIFIER = "__ltags__"
+
+      delegate :identifiers_json, to: :conn
+
+      attr_reader :socket, :logger
+
+      def initialize(connection_class, socket, identifiers: nil, subscriptions: nil)
+        @socket = socket
+
+        logger_tags = fetch_logger_tags_from_state
+        @logger = ActionCable::Connection::TaggedLoggerProxy.new(AnyCable.logger, tags: logger_tags)
+
+        # Instead of calling #initialize,
+        # we allocate an instance and setup all the required components manually
+        @conn = connection_class.allocate
+        # Required to access config (for access origin checks)
+        conn.server = ActionCable.server
+        conn.logger = logger
+        conn.anycable_socket = conn.websocket = socket
+        conn.env = socket.env
+        conn.coder = ActiveSupport::JSON
+        conn.subscriptions = ActionCable::Connection::Subscriptions.new(conn)
+        conn.serialized_ids = {}
+        conn.serialized_ids = ActiveSupport::JSON.decode(identifiers) if identifiers
+        conn.cached_ids = {}
+        conn.anycable_request_builder = self
+
+        return unless subscriptions
+
+        # Pre-initialize channels (for disconnect)
+        subscriptions.each do |id|
+          channel = conn.subscriptions.fetch(id)
+          next unless socket.istate[id]
+
+          channel.__istate__ = ActiveSupport::JSON.decode(socket.istate[id])
+        end
+      end
+
+      def handle_open
+        logger.info started_request_message if access_logs?
+
+        verify_origin! || return
+
+        conn.connect if conn.respond_to?(:connect)
+
+        socket.cstate.write(LOG_TAGS_IDENTIFIER, logger.tags.to_json) unless logger.tags.empty?
+
+        conn.send_welcome_message
+      rescue ::ActionCable::Connection::Authorization::UnauthorizedError
+        reject_request(
+          ActionCable::INTERNAL[:disconnect_reasons]&.[](:unauthorized) || "unauthorized"
+        )
+      end
+
+      def handle_close
+        logger.info finished_request_message if access_logs?
+
+        conn.subscriptions.unsubscribe_from_all
+        conn.disconnect if conn.respond_to?(:disconnect)
+        true
+      end
+
+      def handle_channel_command(identifier, command, data)
+        conn.run_callbacks :command do
+          # We cannot use subscriptions#execute_command here,
+          # since we MUST return true of false, depending on the status
+          # of execution
+          channel = conn.subscriptions.fetch(identifier)
+          case command
+          when "subscribe"
+            channel.handle_subscribe
+            !channel.rejected?
+          when "unsubscribe"
+            conn.subscriptions.remove_subscription(channel)
+            true
+          when "message"
+            channel.perform_action ActiveSupport::JSON.decode(data)
+            true
+          else
+            false
+          end
+        end
+      # Support rescue_from
+      # https://github.com/rails/rails/commit/d2571e560c62116f60429c933d0c41a0e249b58b
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        rescue_with_handler(e) || raise
+        false
+      end
+
+      def build_rack_request(env)
+        environment = ::Rails.application.env_config.merge(env) if defined?(::Rails.application) && ::Rails.application
+        AnyCable::Rails::Rack.app.call(environment) if environment
+
+        ActionDispatch::Request.new(environment || env)
+      end
+
+      def action_cable_connection
+        conn
+      end
+
+      private
+
+      attr_reader :conn
+
+      def reject_request(reason, reconnect = false)
+        logger.info finished_request_message("Rejected") if access_logs?
+        conn.close(
+          reason: reason,
+          reconnect: reconnect
+        )
+      end
+
+      def fetch_logger_tags_from_state
+        socket.cstate.read(LOG_TAGS_IDENTIFIER).yield_self do |raw_tags|
+          next [] unless raw_tags
+          ActiveSupport::JSON.decode(raw_tags)
+        end
+      end
+
+      def started_request_message
+        format(
+          'Started "%s"%s for %s at %s',
+          request.filtered_path, " [AnyCable]", request.ip, Time.now.to_s
+        )
+      end
+
+      def finished_request_message(reason = "Closed")
+        format(
+          'Finished "%s"%s for %s at %s (%s)',
+          request.filtered_path, " [AnyCable]", request.ip, Time.now.to_s, reason
+        )
+      end
+
+      def verify_origin!
+        return true unless socket.env.key?("HTTP_ORIGIN")
+
+        return true if conn.send(:allow_request_origin?)
+
+        reject_request(
+          ActionCable::INTERNAL[:disconnect_reasons]&.[](:invalid_request) || "invalid_request"
+        )
+        false
+      end
+
+      def access_logs?
+        AnyCable.config.access_logs_disabled == false
+      end
+
+      def request
+        conn.public_request
+      end
+
+      def request_loaded?
+        conn.instance_variable_defined?(:@request)
+      end
+
+      def rescue_with_handler(e)
+        conn.rescue_with_handler(e) if conn.respond_to?(:rescue_with_handler)
+      end
+    end
+  end
+end

data/lib/anycable/rails/connection_factory.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "anycable/rails/connection"
+
+module AnyCable
+  module Rails
+    class ConnectionFactory
+      def initialize(&block)
+        @mappings = []
+        @use_router = false
+        instance_eval(&block) if block
+      end
+
+      def call(socket, **options)
+        connection_class = use_router? ? resolve_connection_class(socket.env) :
+                                         ActionCable.server.config.connection_class.call
+
+        AnyCable::Rails::Connection.new(connection_class, socket, **options)
+      end
+
+      def map(route, &block)
+        raise ArgumentError, "Block is required" unless block
+
+        @use_router = true
+        mappings << [route, block]
+      end
+
+      private
+
+      attr_reader :mappings, :use_router
+      alias_method :use_router?, :use_router
+
+      def resolve_connection_class(env)
+        path = env["PATH_INFO"]
+
+        mappings.each do |(prefix, resolver)|
+          return resolver.call if path.starts_with?(prefix)
+        end
+
+        raise "No connection class found matching #{path}"
+      end
+    end
+  end
+end