anycable-rails 0.5.5 → 0.6.0.rc1

data/lib/action_cable/subscription_adapter/any_cable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "anycable-rails"
+
+module ActionCable
+  module SubscriptionAdapter
+    # AnyCable subscription adapter delegates broadcasts
+    # to AnyCable
+    class AnyCable < Base
+      def initialize(*); end
+
+      def broadcast(channel, payload)
+        ::AnyCable.broadcast(channel, payload)
+      end
+
+      def shutdown
+        # nothing to do
+        # we only need this method for development,
+        # 'cause code reloading triggers `server.restart` -> `pubsub.shutdown`
+      end
+    end
+  end
+end

data/lib/anycable/rails.rb

@@ -4,17 +4,17 @@ require "anycable"
 require "anycable/rails/version"
 require "anycable/rails/config"
 
-module Anycable
+module AnyCable
   # Rails handler for AnyCable
   module Rails
     require "anycable/rails/railtie"
-    require "anycable/rails/actioncable/server"
-    require "anycable/rails/actioncable/connection"
+    # Load Action Cable patches only when running RPC server
+    require "anycable/rails/actioncable/connection" if defined?(::AnyCable::CLI)
   end
 end
 
 # Warn if application has been already initialized.
-# Anycable should be loaded before initialization in order to work correctly.
+# AnyCable should be loaded before initialization in order to work correctly.
 if defined?(::Rails) && ::Rails.application && ::Rails.application.initialized?
   puts("\n**************************************************")
   puts(

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

@@ -13,11 +13,15 @@ module ActionCable
         # noop
       end
 
-      def stream_from(broadcasting, callback = nil, coder: nil)
-        if callback.present? || coder.present? || block_given?
-          raise ArgumentError, 'Custom stream callbacks are not supported in AnyCable!'
-        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
 

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

@@ -6,9 +6,13 @@ require "anycable/rails/actioncable/channel"
 
 module ActionCable
   module Connection
-    # rubocop:disable Metrics/ClassLength
+    # rubocop: disable Metrics/ClassLength
     class Base # :nodoc:
-      using Anycable::Refinements::Subscriptions
+      # We store logger tags in identifiers to be able
+      # to re-use them in the subsequent calls
+      LOG_TAGS_IDENTIFIER = "__ltags__"
+
+      using AnyCable::Refinements::Subscriptions
 
       attr_reader :socket
 
@@ -27,9 +31,11 @@ module ActionCable
         end
       end
 
-      def initialize(socket, identifiers: '{}', subscriptions: [])
+      def initialize(socket, identifiers: "{}", subscriptions: [])
         @ids = ActiveSupport::JSON.decode(identifiers)
 
+        @ltags = ids.delete(LOG_TAGS_IDENTIFIER)
+
         @cached_ids = {}
         @env = socket.env
         @coder = ActiveSupport::JSON
@@ -43,11 +49,12 @@ module ActionCable
       def handle_open
         logger.info started_request_message if access_logs?
 
+        verify_origin!
+
         connect if respond_to?(:connect)
         send_welcome_message
       rescue ActionCable::Connection::Authorization::UnauthorizedError
-        logger.info finished_request_message('Rejected') if access_logs?
-        close
+        reject_request
       end
 
       def handle_close
@@ -88,12 +95,14 @@ module ActionCable
       # Generate identifiers info.
       # Converts GlobalID compatible vars to corresponding global IDs params.
       def identifiers_hash
-        identifiers.each_with_object({}) do |id, acc|
+        obj = { LOG_TAGS_IDENTIFIER => fetch_ltags }
+
+        identifiers.each_with_object(obj) do |id, acc|
           obj = instance_variable_get("@#{id}")
           next unless obj
 
           acc[id] = obj.try(:to_gid_param) || obj
-        end
+        end.compact
       end
 
       def identifiers_json
@@ -103,7 +112,7 @@ module ActionCable
       # Fetch identifier and deserialize if neccessary
       def fetch_identifier(name)
         @cached_ids[name] ||= @cached_ids.fetch(name) do
-          val = @ids[name.to_s]
+          val = ids[name.to_s]
           next val unless val.is_a?(String)
 
           GlobalID::Locator.locate(val) || val
@@ -111,32 +120,57 @@ module ActionCable
       end
 
       def logger
-        Anycable.logger
+        @logger ||= TaggedLoggerProxy.new(AnyCable.logger, tags: ltags || [])
       end
 
       private
 
+      attr_reader :ids, :ltags
+
       def started_request_message
-        'Started "%s"%s for %s at %s' % [
-          request.filtered_path,
-          " [Anycable]",
-          request.ip,
-          Time.now.to_s
-        ]
+        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")
-        'Finished "%s"%s for %s at %s (%s)' % [
-          request.filtered_path,
-          " [Anycable]",
-          request.ip,
-          Time.now.to_s,
-          reason
-        ]
+        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
+        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 unless socket.env.key?("HTTP_ORIGIN")
+
+        return if allow_request_origin?
+
+        raise(
+          ActionCable::Connection::Authorization::UnauthorizedError,
+          "Origin is not allowed"
+        )
+      end
+
+      def reject_request
+        logger.info finished_request_message("Rejected") if access_logs?
+        close
       end
     end
     # rubocop:enable Metrics/ClassLength

data/lib/anycable/rails/compatibility.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AnyCable
+  class CompatibilityError < StandardError; end
+
+  module Compatibility # :nodoc:
+    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
+
+      %w[subscribe_to_channel 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
+
+        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)
+
+    ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
+      def disconnect
+        raise AnyCable::CompatibilityError,
+              "Disconnecting remote clients is not supported by AnyCable yet"
+      end
+    end)
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "pathname"
+
+require_relative "rubocop/cops/anycable/stream_from"
+require_relative "rubocop/cops/anycable/remote_disconnect"
+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/rubocop/config/default.yml

@@ -0,0 +1,12 @@
+AnyCable/InstanceVars:
+  Include:
+    - "**/channels/**/*.rb"
+
+AnyCable/StreamFrom:
+  Include:
+    - "**/channels/**/*.rb"
+
+AnyCable/PeriodicalTimers:
+  Include:
+    - "**/channels/**/*.rb"
+    

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"
+
+        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.begin_type? || child.block_type? || child.def_type?
+              find_nested_ivars(child, &block)
+            elsif child.ivasgn_type? || child.ivar_type?
+              yield(child)
+            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/remote_disconnect.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module AnyCable
+      # Checks for remote disconnect usage.
+      #
+      # @example
+      #   # bad
+      #   class MyServive
+      #     def call(user)
+      #       ActionCable.server.remote_connections.where(current_user: user).disconnect
+      #     end
+      #   end
+      #
+      class RemoteDisconnect < RuboCop::Cop::Cop
+        MSG = "Disconnecting remote clients is not supported in AnyCable"
+
+        def_node_matcher :has_remote_disconnect?, <<-PATTERN
+          (send (send (send _ :remote_connections) ...) :disconnect)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if has_remote_disconnect?(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_from("all") {}
+      #     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 ...) ...)
+        PATTERN
+
+        def_node_matcher :stream_from_with_callback?, <<-PATTERN
+          (send _ :stream_from str_type? (block (send nil? :lambda) ...))
+        PATTERN
+
+        def_node_matcher :args_of_stream_from, <<-PATTERN
+          (send _ :stream_from str_type? $...)
+        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