anycable-rails 1.0.7 → 1.3.4

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

@@ -1,222 +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
-    # rubocop: disable Metrics/ClassLength
-    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
-
-      # rubocop:disable Metrics/MethodLength
-      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 # rubocop:disable Lint/Void
-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: {})
-  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