anycable-rails-core 1.4.0

data/lib/anycable/rails/compatibility/rubocop/cops/anycable/instance_vars.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module AnyCable
+      # Checks for instance variable usage inside subscriptions.
+      #
+      # @example
+      #   # bad
+      #   class MyChannel < ApplicationCable::Channel
+      #     def subscribed
+      #       @post = Post.find(params[:id])
+      #       stream_from @post
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyChannel < ApplicationCable::Channel
+      #     def subscribed
+      #       post = Post.find(params[:id])
+      #       stream_from post
+      #     end
+      #   end
+      #
+      class InstanceVars < RuboCop::Cop::Cop
+        MSG = "Channel instance variables are not supported in AnyCable. Use `state_attr_accessor` instead"
+
+        def on_class(node)
+          find_nested_ivars(node) do |nested_ivar|
+            add_offense(nested_ivar)
+          end
+        end
+
+        private
+
+        def find_nested_ivars(node, &block)
+          node.each_child_node do |child|
+            if child.ivasgn_type? || child.ivar_type?
+              yield(child)
+            elsif child.children.any?
+              find_nested_ivars(child, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/compatibility/rubocop/cops/anycable/periodical_timers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module AnyCable
+      # Checks for periodical timers usage.
+      #
+      # @example
+      #   # bad
+      #   class MyChannel < ApplicationCable::Channel
+      #     periodically(:do_something, every: 2.seconds)
+      #   end
+      #
+      class PeriodicalTimers < RuboCop::Cop::Cop
+        MSG = "Periodical Timers are not supported in AnyCable"
+
+        def_node_matcher :calls_periodically?, <<-PATTERN
+          (send _ :periodically ...)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if calls_periodically?(node)
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/compatibility/rubocop/cops/anycable/stream_from.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module AnyCable
+      # Checks for #stream_from calls with custom callbacks or coders.
+      #
+      # @example
+      #   # bad
+      #   class MyChannel < ApplicationCable::Channel
+      #     def follow
+      #       stream_for(room) {}
+      #     end
+      #   end
+      #
+      #   class MyChannel < ApplicationCable::Channel
+      #     def follow
+      #       stream_from("all", -> {})
+      #     end
+      #   end
+      #
+      #   class MyChannel < ApplicationCable::Channel
+      #     def follow
+      #       stream_from("all", coder: SomeCoder)
+      #     end
+      #   end
+      #
+      #  # good
+      #   class MyChannel < ApplicationCable::Channel
+      #     def follow
+      #       stream_from "all"
+      #     end
+      #   end
+      #
+      class StreamFrom < RuboCop::Cop::Cop
+        def_node_matcher :stream_from_with_block?, <<-PATTERN
+          (block {(send _ :stream_from ...) (send _ :stream_for ...)} ...)
+        PATTERN
+
+        def_node_matcher :stream_from_with_callback?, <<-PATTERN
+          {(send _ :stream_from str_type? (block (send nil? :lambda) ...)) (send _ :stream_for ... (block (send nil? :lambda) ...))}
+        PATTERN
+
+        def_node_matcher :args_of_stream_from, <<-PATTERN
+          {(send _ :stream_from str_type? $...)  (send _ :stream_for $...)}
+        PATTERN
+
+        def_node_matcher :coder_symbol?, "(pair (sym :coder) ...)"
+
+        def_node_matcher :active_support_json?, <<-PATTERN
+          (pair _ (const (const nil? :ActiveSupport) :JSON))
+        PATTERN
+
+        def on_block(node)
+          add_callback_offense(node) if stream_from_with_block?(node)
+        end
+
+        def on_send(node)
+          if stream_from_with_callback?(node)
+            add_callback_offense(node)
+            return
+          end
+
+          args = args_of_stream_from(node)
+          find_coders(args) { |coder| add_custom_coder_offense(coder) }
+        end
+
+        private
+
+        def find_coders(args)
+          return if args.nil?
+
+          args.select(&:hash_type?).each do |arg|
+            arg.each_child_node do |pair|
+              yield(pair) if coder_symbol?(pair) && !active_support_json?(pair)
+            end
+          end
+        end
+
+        def add_callback_offense(node)
+          add_offense(
+            node,
+            location: :expression,
+            message: "Custom stream callbacks are not supported in AnyCable"
+          )
+        end
+
+        def add_custom_coder_offense(node)
+          add_offense(
+            node,
+            location: :expression,
+            message: "Custom coders are not supported in AnyCable"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/compatibility/rubocop.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "pathname"
+
+require_relative "rubocop/cops/anycable/stream_from"
+require_relative "rubocop/cops/anycable/periodical_timers"
+require_relative "rubocop/cops/anycable/instance_vars"
+
+module RuboCop
+  module AnyCable # :nodoc:
+    CONFIG_DEFAULT = Pathname.new(__dir__).join("rubocop", "config", "default.yml").freeze
+
+    # Merge anycable config into default configuration
+    # See https://github.com/backus/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+    def self.inject!
+      path = CONFIG_DEFAULT.to_s
+      puts "configuration from #{path}" if ConfigLoader.debug?
+      hash = ConfigLoader.send(:load_yaml_configuration, path)
+      config = Config.new(hash, path)
+      config = ConfigLoader.merge_with_default(config, path)
+      ConfigLoader.instance_variable_set(:@default_configuration, config)
+    end
+  end
+end
+
+RuboCop::AnyCable.inject!

data/lib/anycable/rails/compatibility.rb

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

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

@@ -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

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