anycable-rails 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d21ee870a0caaeed44d71d571303e0e9ab835457360ee1b205279f38379716e2
-  data.tar.gz: 0e1f4c986782474601d40228ae272ab795bd038ad837420b9a689f74c91edfcf
+  metadata.gz: 37be6474db2d3efc3493ec6fdf5b3826fbdfd84f9c4bc5f4574f1e0497457ec1
+  data.tar.gz: bafe87b642e1aaf15c5b09650ed271081d0ba53738507077ed1075b2de5e0ef2
 SHA512:
-  metadata.gz: 7cd248fd53e2f09632a9fec2e3439c788f70b96b40270480b0b519ac70738740df783afc7bf7d107bf718dfe08cf31e8880796beace87cc87b20b5aa69cf90e2
-  data.tar.gz: 6c8e6cedcdd61b58e0dcfd82dfa72a4f3f1e0591bb90e27ef7b8b5c10bbe51a37163f83b12daba720f64f9519cbeadb9fbcb24e9d9af5ec84e988faa1cc54ad0
+  metadata.gz: b656f5a17009a19aacef7c1aac587299b5bdca24079e3e6a1ce2c9e652e26a7d65f08e34f0022e1ed4a9e42d8783af9d7d9e85a9059577ec224a523b7c12378e
+  data.tar.gz: 383c128d5404a7ed42bba43a426cb68bd10be23607557bce7a8ef46cd1ea1cf2777c918e44a4c71f307a0f973ff863aef36f547290ce821d65251e7f9a62a3fd

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 1.3.0 (2021-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 (2021-01-31)
 
 - Add a temporary fix to be compatible with `sentry-rails`. ([@palkan][])

data/README.md

@@ -1,6 +1,5 @@
 [![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)
 
 # AnyCable Rails

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "action_cable/channel"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  def subscribe_to_channel(force: false)
+    return if anycabled? && !force
+    super()
+  end
+
+  def handle_subscribe
+    subscribe_to_channel(force: true)
+  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,30 @@
+# frozen_string_literal: true
+
+require "action_cable/connection"
+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)

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,7 +41,7 @@ module AnyCable
       attr_writer :__istate__
 
       def __istate__
-        @__istate__ ||= connection.socket.istate
+        @__istate__ ||= connection.anycable_socket.istate
       end
     end
 
@@ -53,11 +53,11 @@ module AnyCable
             class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def #{name}
                 return @#{name} if instance_variable_defined?(:@#{name})
-                @#{name} = AnyCable::Rails.deserialize(__cstate__["#{name}"], json: true) if anycable_socket
+                @#{name} = AnyCable::Rails.deserialize(__cstate__["#{name}"], json: true) if anycabled?
               end
 
               def #{name}=(val)
-                __cstate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycable_socket
+                __cstate__["#{name}"] = AnyCable::Rails.serialize(val, json: true) if anycabled?
                 instance_variable_set(:@#{name}, val)
               end
             RUBY
@@ -84,7 +84,7 @@ module AnyCable
       attr_writer :__cstate__
 
       def __cstate__
-        @__cstate__ ||= socket.cstate
+        @__cstate__ ||= anycable_socket.cstate
       end
     end
   end

data/lib/anycable/rails/connection.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "action_cable/connection"
+require "action_cable/channel"
+
+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 public_send_welcome_message
+          send_welcome_message
+        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.public_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)
+        # 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
+      # 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

data/lib/anycable/rails/connections/persistent_session.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "anycable/rails/connections/session_proxy"
+
+module AnyCable
+  module Rails
+    module Connections
+      module PersistentSession
+        def handle_open
+          super.tap { commit_session! }
+        end
+
+        def handle_channel_command(*)
+          super.tap { commit_session! }
+        end
+
+        def build_rack_request(env)
+          return super unless socket.session
+
+          super.tap do |req|
+            req.env[::Rack::RACK_SESSION] =
+              SessionProxy.new(req.env[::Rack::RACK_SESSION], socket.session)
+          end
+        end
+
+        private
+
+        def commit_session!
+          return unless request_loaded? && request.session.respond_to?(:loaded?) && request.session.loaded?
+
+          socket.session = request.session.to_json
+        end
+      end
+    end
+  end
+end
+
+AnyCable::Rails::Connection.prepend(
+  AnyCable::Rails::Connections::PersistentSession
+)

data/lib/anycable/rails/connections/serializable_identification.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Connections
+      module SerializableIdentification
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def identified_by(*identifiers)
+            super
+            Array(identifiers).each do |identifier|
+              define_method(identifier) do
+                instance_variable_get(:"@#{identifier}") || fetch_identifier(identifier)
+              end
+            end
+          end
+        end
+
+        # Generate identifiers info.
+        # Converts GlobalID compatible vars to corresponding global IDs params.
+        def identifiers_hash
+          identifiers.each_with_object({}) do |id, acc|
+            obj = instance_variable_get("@#{id}")
+            next unless obj
+
+            acc[id] = AnyCable::Rails.serialize(obj)
+          end.compact
+        end
+
+        def identifiers_json
+          identifiers_hash.to_json
+        end
+
+        # Fetch identifier and deserialize if neccessary
+        def fetch_identifier(name)
+          return unless @cached_ids
+
+          @cached_ids[name] ||= @cached_ids.fetch(name) do
+            AnyCable::Rails.deserialize(@serialized_ids[name.to_s])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/connections/session_proxy.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Connections
+      # Wrap `request.session` to lazily load values provided
+      # in the RPC call (set by the previous calls)
+      class SessionProxy
+        attr_reader :rack_session, :socket_session
+
+        def initialize(rack_session, socket_session)
+          @rack_session = rack_session
+          @socket_session = JSON.parse(socket_session).with_indifferent_access
+        end
+
+        %i[has_key? [] []= fetch delete dig].each do |mid|
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def #{mid}(*args, **kwargs, &block)
+              restore_key! args.first
+              rack_session.#{mid}(*args, **kwargs, &block)
+            end
+          CODE
+        end
+
+        alias_method :include?, :has_key?
+        alias_method :key?, :has_key?
+
+        %i[update merge! to_hash].each do |mid|
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def #{mid}(*args, **kwargs, &block)
+              restore!
+              rack_session.#{mid}(*args, **kwargs, &block)
+            end
+          CODE
+        end
+
+        alias_method :to_h, :to_hash
+
+        def keys
+          rack_session.keys + socket_session.keys
+        end
+
+        # Delegate both publuc and private methods to rack_session
+        def respond_to_missing?(name, include_private = false)
+          return false if name == :marshal_dump || name == :_dump
+          rack_session.respond_to?(name, include_private) || super
+        end
+
+        def method_missing(method, *args, &block)
+          if rack_session.respond_to?(method, true)
+            rack_session.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        # This method is used by StimulusReflex to obtain `@by`
+        def instance_variable_get(name)
+          super || rack_session.instance_variable_get(name)
+        end
+
+        private
+
+        def restore!
+          socket_session.keys.each(&method(:restore_key!))
+        end
+
+        def restore_key!(key)
+          return unless socket_session.key?(key)
+          val = socket_session.delete(key)
+          rack_session[key] =
+            if val.is_a?(String)
+              GlobalID::Locator.locate(val) || val
+            else
+              val
+            end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/railtie.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
+require "anycable/rails/action_cable_ext/connection"
+require "anycable/rails/action_cable_ext/channel"
+require "anycable/rails/action_cable_ext/remote_connections"
+
 require "anycable/rails/channel_state"
+require "anycable/rails/connection_factory"
 
 module AnyCable
   module Rails
@@ -43,30 +48,16 @@ module AnyCable
 
       initializer "anycable.connection_factory", after: "action_cable.set_configs" do |app|
         ActiveSupport.on_load(:action_cable) do
-          # Add AnyCable patch method stub (we use it in ChannelState to distinguish between Action Cable and AnyCable)
-          # NOTE: Method could be already defined if patch was loaded manually
-          ActionCable::Connection::Base.attr_reader(:anycable_socket) unless ActionCable::Connection::Base.method_defined?(:anycable_socket)
-
           app.config.to_prepare do
-            AnyCable.connection_factory = ActionCable.server.config.connection_class.call
+            AnyCable.connection_factory = AnyCable::Rails::ConnectionFactory.new
           end
 
-          if AnyCable::Rails.enabled?
-            require "anycable/rails/actioncable/connection"
-            if AnyCable.config.persistent_session_enabled
-              require "anycable/rails/actioncable/connection/persistent_session"
-            end
+          if AnyCable.config.persistent_session_enabled?
+            require "anycable/rails/connections/persistent_session"
           end
         end
       end
 
-      # Temp hack to fix Sentry vs AnyCable incompatibility
-      # See https://github.com/anycable/anycable-rails/issues/165
-      initializer "anycable.sentry_hack", after: :"sentry.extend_action_cable" do
-        next unless defined?(::Sentry::Rails::ActionCableExtensions::Connection)
-        Sentry::Rails::ActionCableExtensions::Connection.send :public, :handle_open, :handle_close
-      end
-
       # Since Rails 6.1
       if respond_to?(:server)
         server do

data/lib/anycable/rails/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rails
-    VERSION = "1.2.1"
+    VERSION = "1.3.0"
   end
 end

data/lib/anycable/rails.rb

@@ -48,6 +48,17 @@ module AnyCable
           val
         end
       end
+
+      module Extension
+        def broadcast(channel, payload)
+          super
+          ::AnyCable.broadcast(channel, payload)
+        end
+      end
+
+      def extend_adapter!(adapter)
+        adapter.extend(Extension)
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anycable-rails
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - palkan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-31 00:00:00.000000000 Z
+date: 2022-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable
@@ -150,12 +150,9 @@ files:
 - lib/action_cable/subscription_adapter/anycable.rb
 - lib/anycable-rails.rb
 - lib/anycable/rails.rb
-- lib/anycable/rails/actioncable/channel.rb
-- lib/anycable/rails/actioncable/connection.rb
-- lib/anycable/rails/actioncable/connection/persistent_session.rb
-- lib/anycable/rails/actioncable/connection/serializable_identification.rb
-- lib/anycable/rails/actioncable/remote_connections.rb
-- lib/anycable/rails/actioncable/testing.rb
+- lib/anycable/rails/action_cable_ext/channel.rb
+- lib/anycable/rails/action_cable_ext/connection.rb
+- lib/anycable/rails/action_cable_ext/remote_connections.rb
 - lib/anycable/rails/channel_state.rb
 - lib/anycable/rails/compatibility.rb
 - lib/anycable/rails/compatibility/rubocop.rb
@@ -164,12 +161,15 @@ files:
 - lib/anycable/rails/compatibility/rubocop/cops/anycable/periodical_timers.rb
 - lib/anycable/rails/compatibility/rubocop/cops/anycable/stream_from.rb
 - lib/anycable/rails/config.rb
+- lib/anycable/rails/connection.rb
+- lib/anycable/rails/connection_factory.rb
+- lib/anycable/rails/connections/persistent_session.rb
+- lib/anycable/rails/connections/serializable_identification.rb
+- lib/anycable/rails/connections/session_proxy.rb
 - lib/anycable/rails/middlewares/executor.rb
 - lib/anycable/rails/middlewares/log_tagging.rb
 - lib/anycable/rails/rack.rb
 - lib/anycable/rails/railtie.rb
-- lib/anycable/rails/refinements/subscriptions.rb
-- lib/anycable/rails/session_proxy.rb
 - lib/anycable/rails/version.rb
 - lib/generators/anycable/download/USAGE
 - lib/generators/anycable/download/download_generator.rb

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "action_cable/channel"
-
-module ActionCable
-  module Channel
-    class Base # :nodoc:
-      alias_method :handle_subscribe, :subscribe_to_channel
-
-      public :handle_subscribe, :subscription_rejected?
-
-      # Action Cable calls this method from inside the Subscriptions#add
-      # method, which we use to initialize the channel instance.
-      # We don't want to invoke `subscribed` callbacks every time we do that.
-      def subscribe_to_channel
-        # noop
-      end
-
-      def start_periodic_timers
-        # noop
-      end
-
-      def stop_periodic_timers
-        # noop
-      end
-
-      def stream_from(broadcasting, _callback = nil, _options = {})
-        connection.socket.subscribe identifier, broadcasting
-      end
-
-      def stop_stream_from(broadcasting)
-        connection.socket.unsubscribe identifier, broadcasting
-      end
-
-      def stop_all_streams
-        connection.socket.unsubscribe_from_all identifier
-      end
-    end
-  end
-end

data/lib/anycable/rails/actioncable/connection/persistent_session.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActionCable
-  module Connection
-    module PersistentSession
-      def handle_open
-        super.tap { commit_session! }
-      end
-
-      def handle_channel_command(*)
-        super.tap { commit_session! }
-      end
-
-      def build_rack_request
-        return super unless socket.session
-
-        super.tap do |req|
-          req.env[::Rack::RACK_SESSION] =
-            AnyCable::Rails::SessionProxy.new(req.env[::Rack::RACK_SESSION], socket.session)
-        end
-      end
-
-      def commit_session!
-        return unless request_loaded? && request.session.respond_to?(:loaded?) && request.session.loaded?
-
-        socket.session = request.session.to_json
-      end
-    end
-  end
-end
-
-::ActionCable::Connection::Base.prepend(
-  ::ActionCable::Connection::PersistentSession
-)

data/lib/anycable/rails/actioncable/connection/serializable_identification.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module ActionCable
-  module Connection
-    module SerializableIdentification
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def identified_by(*identifiers)
-          super
-          Array(identifiers).each do |identifier|
-            define_method(identifier) do
-              instance_variable_get(:"@#{identifier}") || fetch_identifier(identifier)
-            end
-          end
-        end
-      end
-
-      # Generate identifiers info.
-      # Converts GlobalID compatible vars to corresponding global IDs params.
-      def identifiers_hash
-        identifiers.each_with_object({}) do |id, acc|
-          obj = instance_variable_get("@#{id}")
-          next unless obj
-
-          acc[id] = AnyCable::Rails.serialize(obj)
-        end.compact
-      end
-
-      def identifiers_json
-        identifiers_hash.to_json
-      end
-
-      # Fetch identifier and deserialize if neccessary
-      def fetch_identifier(name)
-        @cached_ids[name] ||= @cached_ids.fetch(name) do
-          AnyCable::Rails.deserialize(ids[name.to_s])
-        end
-      end
-    end
-  end
-end

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

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require "action_cable/connection"
-require "anycable/rails/actioncable/connection/serializable_identification"
-require "anycable/rails/refinements/subscriptions"
-require "anycable/rails/actioncable/channel"
-require "anycable/rails/actioncable/remote_connections"
-require "anycable/rails/session_proxy"
-
-module ActionCable
-  module Connection
-    class Base # :nodoc:
-      # We store logger tags in the connection state to be able
-      # to re-use them in the subsequent calls
-      LOG_TAGS_IDENTIFIER = "__ltags__"
-
-      using AnyCable::Refinements::Subscriptions
-
-      include SerializableIdentification
-
-      attr_reader :socket
-
-      alias_method :anycable_socket, :socket
-
-      delegate :env, :session, to: :request
-
-      class << self
-        def call(socket, **options)
-          new(socket, nil, **options)
-        end
-      end
-
-      def initialize(socket, env, identifiers: "{}", subscriptions: nil)
-        if env
-          # If env is set, then somehow we're in the context of Action Cable
-          # Return and print a warning in #process
-          @request = ActionDispatch::Request.new(env)
-          return
-        end
-
-        @ids = ActiveSupport::JSON.decode(identifiers)
-
-        @ltags = socket.cstate.read(LOG_TAGS_IDENTIFIER).yield_self do |raw_tags|
-          next unless raw_tags
-          ActiveSupport::JSON.decode(raw_tags)
-        end
-
-        @cached_ids = {}
-        @coder = ActiveSupport::JSON
-        @socket = socket
-        @subscriptions = ActionCable::Connection::Subscriptions.new(self)
-
-        return unless subscriptions
-
-        # Initialize channels (for disconnect)
-        subscriptions.each do |id|
-          channel = @subscriptions.fetch(id)
-          next unless socket.istate[id]
-
-          channel.__istate__ = ActiveSupport::JSON.decode(socket.istate[id])
-        end
-      end
-
-      def process
-        # Use Rails logger here to print to stdout in development
-        logger.error invalid_request_message
-        logger.info finished_request_message
-        [404, {"Content-Type" => "text/plain"}, ["Page not found"]]
-      end
-
-      def invalid_request_message
-        "You're trying to connect to Action Cable server while using AnyCable. " \
-        "See https://docs.anycable.io/troubleshooting?id=server-raises-an-argumenterror-exception-when-client-tries-to-connect"
-      end
-
-      def handle_open
-        logger.info started_request_message if access_logs?
-
-        verify_origin! || return
-
-        connect if respond_to?(:connect)
-
-        socket.cstate.write(LOG_TAGS_IDENTIFIER, fetch_ltags.to_json)
-
-        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?
-
-        subscriptions.unsubscribe_from_all
-        disconnect if respond_to?(:disconnect)
-        true
-      end
-
-      def handle_channel_command(identifier, command, data)
-        channel = subscriptions.fetch(identifier)
-        case command
-        when "subscribe"
-          channel.handle_subscribe
-          !channel.subscription_rejected?
-        when "unsubscribe"
-          subscriptions.remove_subscription(channel)
-          true
-        when "message"
-          channel.perform_action ActiveSupport::JSON.decode(data)
-          true
-        else
-          false
-        end
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def close(reason: nil, reconnect: nil)
-        transmit(
-          type: ActionCable::INTERNAL[:message_types].fetch(:disconnect, "disconnect"),
-          reason: reason,
-          reconnect: reconnect
-        )
-        socket.close
-      end
-
-      def transmit(cable_message)
-        socket.transmit encode(cable_message)
-      end
-
-      def logger
-        @logger ||= TaggedLoggerProxy.new(AnyCable.logger, tags: ltags || [])
-      end
-
-      def request
-        @request ||= build_rack_request
-      end
-
-      private
-
-      attr_reader :ids, :ltags
-
-      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 access_logs?
-        AnyCable.config.access_logs_disabled == false
-      end
-
-      def fetch_ltags
-        if instance_variable_defined?(:@logger)
-          logger.tags
-        else
-          ltags
-        end
-      end
-
-      def server
-        ActionCable.server
-      end
-
-      def verify_origin!
-        return true unless socket.env.key?("HTTP_ORIGIN")
-
-        return true if allow_request_origin?
-
-        reject_request(
-          ActionCable::INTERNAL[:disconnect_reasons]&.[](:invalid_request) || "invalid_request"
-        )
-        false
-      end
-
-      def reject_request(reason, reconnect = false)
-        logger.info finished_request_message("Rejected") if access_logs?
-        close(
-          reason: reason,
-          reconnect: reconnect
-        )
-      end
-
-      def build_rack_request
-        environment = Rails.application.env_config.merge(socket.env)
-        AnyCable::Rails::Rack.app.call(environment)
-
-        ActionDispatch::Request.new(environment)
-      end
-
-      def request_loaded?
-        instance_variable_defined?(:@request)
-      end
-    end
-    # rubocop:enable Metrics/ClassLength
-  end
-end
-
-# Support rescue_from
-# https://github.com/rails/rails/commit/d2571e560c62116f60429c933d0c41a0e249b58b
-if ActionCable::Connection::Base.respond_to?(:rescue_from)
-  ActionCable::Connection::Base.prepend(Module.new do
-    def handle_channel_command(*)
-      super
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      rescue_with_handler(e) || raise
-      false
-    end
-  end)
-end
-
-require "anycable/rails/actioncable/testing" if ::Rails.env.test?

data/lib/anycable/rails/actioncable/testing.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-# This file contains patches to Action Cable testing modules
-
-# Trigger autoload (if constant is defined)
-begin
-  ActionCable::Channel::TestCase # rubocop:disable Lint/Void
-  ActionCable::Connection::TestCase
-rescue NameError
-  return
-end
-
-ActionCable::Channel::ChannelStub.prepend(Module.new do
-  def subscribe_to_channel
-    handle_subscribe
-  end
-end)
-
-ActionCable::Channel::ConnectionStub.prepend(Module.new do
-  def socket
-    @socket ||= AnyCable::Socket.new(env: AnyCable::Env.new(url: "http://test.host", headers: {}))
-  end
-
-  alias_method :anycable_socket, :socket
-end)
-
-ActionCable::Connection::TestConnection.prepend(Module.new do
-  def initialize(request)
-    @request = request
-    @cached_ids = {}
-    super
-  end
-end)

data/lib/anycable/rails/refinements/subscriptions.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module Refinements
-    module Subscriptions # :nodoc:
-      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
-  end
-end

data/lib/anycable/rails/session_proxy.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module Rails
-    # Wrap `request.session` to lazily load values provided
-    # in the RPC call (set by the previous calls)
-    class SessionProxy
-      attr_reader :rack_session, :socket_session
-
-      def initialize(rack_session, socket_session)
-        @rack_session = rack_session
-        @socket_session = JSON.parse(socket_session).with_indifferent_access
-      end
-
-      %i[has_key? [] []= fetch delete dig].each do |mid|
-        class_eval <<~CODE, __FILE__, __LINE__ + 1
-          def #{mid}(*args, **kwargs, &block)
-            restore_key! args.first
-            rack_session.#{mid}(*args, **kwargs, &block)
-          end
-        CODE
-      end
-
-      alias_method :include?, :has_key?
-      alias_method :key?, :has_key?
-
-      %i[update merge! to_hash].each do |mid|
-        class_eval <<~CODE, __FILE__, __LINE__ + 1
-          def #{mid}(*args, **kwargs, &block)
-            restore!
-            rack_session.#{mid}(*args, **kwargs, &block)
-          end
-        CODE
-      end
-
-      alias_method :to_h, :to_hash
-
-      def keys
-        rack_session.keys + socket_session.keys
-      end
-
-      # Delegate both publuc and private methods to rack_session
-      def respond_to_missing?(name, include_private = false)
-        return false if name == :marshal_dump || name == :_dump
-        rack_session.respond_to?(name, include_private) || super
-      end
-
-      def method_missing(method, *args, &block)
-        if rack_session.respond_to?(method, true)
-          rack_session.send(method, *args, &block)
-        else
-          super
-        end
-      end
-
-      # This method is used by StimulusReflex to obtain `@by`
-      def instance_variable_get(name)
-        super || rack_session.instance_variable_get(name)
-      end
-
-      private
-
-      def restore!
-        socket_session.keys.each(&method(:restore_key!))
-      end
-
-      def restore_key!(key)
-        return unless socket_session.key?(key)
-        val = socket_session.delete(key)
-        rack_session[key] =
-          if val.is_a?(String)
-            GlobalID::Locator.locate(val) || val
-          else
-            val
-          end
-      end
-    end
-  end
-end