anycable-rails 1.4.0 → 1.4.2

data/lib/anycable/rails/compatibility.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  class CompatibilityError < StandardError; end
-
-  module Compatibility # :nodoc:
-    IGNORE_INSTANCE_VARS = %i[
-      @active_periodic_timers
-      @_streams
-      @parameter_filter
-    ]
-
-    ActionCable::Channel::Base.prepend(Module.new do
-      def stream_from(broadcasting, callback = nil, coder: nil)
-        if coder.present? && coder != ActiveSupport::JSON
-          raise AnyCable::CompatibilityError, "Custom coders are not supported by AnyCable"
-        end
-
-        if callback.present? || block_given?
-          raise AnyCable::CompatibilityError,
-            "Custom stream callbacks are not supported by AnyCable"
-        end
-
-        super
-      end
-
-      # Do not prepend `subscribe_to_channel` 'cause we make it no-op
-      # when AnyCable is running (see anycable/rails/actioncable/channel.rb)
-      %w[run_callbacks perform_action].each do |mid|
-        module_eval <<~CODE, __FILE__, __LINE__ + 1
-          def #{mid}(*)
-            __anycable_check_ivars__ { super }
-          end
-        CODE
-      end
-
-      def __anycable_check_ivars__
-        was_ivars = instance_variables
-        res = yield
-        diff = instance_variables - was_ivars - IGNORE_INSTANCE_VARS
-
-        if self.class.respond_to?(:channel_state_attributes)
-          diff.delete(:@__istate__)
-          diff.delete_if { |ivar| self.class.channel_state_attributes.include?(:"#{ivar.to_s.sub(/^@/, "")}") }
-        end
-
-        unless diff.empty?
-          raise AnyCable::CompatibilityError,
-            "Channel instance variables are not supported by AnyCable, " \
-            "but were set: #{diff.join(", ")}"
-        end
-
-        res
-      end
-    end)
-
-    ActionCable::Channel::Base.singleton_class.prepend(Module.new do
-      def periodically(*)
-        raise AnyCable::CompatibilityError, "Periodical timers are not supported by AnyCable"
-      end
-    end)
-  end
-end

data/lib/anycable/rails/config.rb

@@ -1,19 +0,0 @@
-# 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
-# - `http_rpc_mount_path` (default to nil) — path to mount HTTP RPC server
-AnyCable::Config.attr_config(
-  access_logs_disabled: true,
-  persistent_session_enabled: false,
-  embedded: false,
-  http_rpc_mount_path: nil
-)
-AnyCable::Config.ignore_options :access_logs_disabled, :persistent_session_enabled

data/lib/anycable/rails/connection.rb

@@ -1,211 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,81 +0,0 @@
-# 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/middlewares/executor.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module Rails
-    module Middlewares
-      # Executor runs Rails executor for each call
-      # See https://guides.rubyonrails.org/v5.2.0/threading_and_code_execution.html#framework-behavior
-      class Executor < AnyCable::Middleware
-        attr_reader :executor
-
-        def initialize(executor)
-          @executor = executor
-        end
-
-        def call(method, message, metadata)
-          if ::Rails.respond_to?(:error)
-            executor.wrap do
-              sid = metadata["sid"]
-
-              ::Rails.error.record(context: {method: method, payload: message.to_h, sid: sid}) do
-                yield
-              end
-            end
-          else
-            executor.wrap { yield }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/anycable/rails/middlewares/log_tagging.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module AnyCable
-  module Rails
-    module Middlewares
-      # Middleware to add `sid` (session ID) tag to logs.
-      #
-      # Session ID could be provided through gRPC metadata `sid` key.
-      #
-      # See https://github.com/grpc/grpc-go/blob/master/Documentation/grpc-metadata.md
-      class LogTagging < AnyCable::Middleware
-        def call(_method, _request, metadata)
-          sid = metadata["sid"]
-          return yield unless sid
-
-          AnyCable.logger.tagged("AnyCable sid=#{sid}") { yield }
-        end
-      end
-    end
-  end
-end

data/lib/anycable/rails/rack.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/configuration"
-require "action_dispatch/middleware/stack"
-
-module AnyCable
-  module Rails
-    # Rack middleware stack to modify the HTTP request object.
-    #
-    # AnyCable Websocket server does not use Rack middleware processing mechanism (which Rails uses
-    # when Action Cable is mounted into the main app).
-    #
-    # Some middlewares could enhance request env with useful information.
-    #
-    # For instance, consider the Rails session middleware: it's responsible for restoring the
-    # session data from cookies.
-    #
-    # AnyCable adds session middelware by default to its own stack.
-    #
-    # You can also use any Rack/Rails middleware you want. For example, to enable Devise/Warden
-    # you can add the following code to an initializer or any other configuration file:
-    #
-    #   AnyCable::Rails::Rack.middleware.use Warden::Manager do |config|
-    #     Devise.warden_config = config
-    #   end
-    module Rack
-      def self.app_build_lock
-        @app_build_lock
-      end
-
-      @app_build_lock = Mutex.new
-
-      def self.middleware
-        @middleware ||= ::Rails::Configuration::MiddlewareStackProxy.new
-      end
-
-      def self.default_middleware_stack
-        config = ::Rails.application.config
-
-        ActionDispatch::MiddlewareStack.new do |middleware|
-          middleware.use(config.session_store, config.session_options) if config.session_store
-        end
-      end
-
-      def self.app
-        @rack_app || app_build_lock.synchronize do
-          @rack_app ||= default_middleware_stack.yield_self do |stack|
-                          middleware.merge_into(stack)
-                        end.yield_self do |stack|
-            stack.build { [-1, {}, []] }
-          end
-        end
-      end
-    end
-  end
-end