anycable-rails-core 1.5.3 → 1.6.2

data/lib/anycable/rails/next/action_cable_ext/connection.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "action_cable"
+require "anycable/rails/connections/serializable_identification"
+
+ActionCable::Connection::Base.include(AnyCable::Rails::Connections::SerializableIdentification)
+ActionCable::Connection::Base.prepend(Module.new do
+  def anycabled?
+    anycable_socket
+  end
+
+  # Allow overriding #subscriptions to use a custom implementation
+  attr_writer :subscriptions
+
+  # Alias for the #socket which is only set within AnyCable RPC context
+  attr_accessor :anycable_socket
+
+  # Enhance #send_welcome_message to include sid if present
+  def send_welcome_message
+    transmit({
+      type: ActionCable::INTERNAL[:message_types][:welcome],
+      sid: env["anycable.sid"]
+    }.compact)
+  end
+
+  def subscribe_to_internal_channel
+    super unless anycabled?
+  end
+end)

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

@@ -0,0 +1,39 @@
+# 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 request
+          @request ||= super.tap do |req|
+            next unless socket.session
+            req.env[::Rack::RACK_SESSION] =
+              SessionProxy.new(req.env[::Rack::RACK_SESSION], socket.session)
+          end
+        end
+
+        private
+
+        def commit_session!
+          return unless defined?(@request) && 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/next/connection.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+module AnyCable
+  module Rails
+    class Current < ActiveSupport::CurrentAttributes
+      attribute :identifier
+    end
+
+    # Wrap ActionCable.server to provide a custom executor
+    # and a pubsub adapter
+    class Server < SimpleDelegator
+      # Implements an executor inteface
+      class Executor
+        class NoopTimer
+          def shutdown = nil
+        end
+
+        NOOP_TIMER = NoopTimer.new.freeze
+
+        def post(...)
+          raise NonImplementedError, "Executor#post is not implemented in AnyCable context"
+        end
+
+        def timer(...) = NOOP_TIMER
+      end
+
+      # A signleton executor for all connections
+      EXECUTOR = Executor.new.freeze
+
+      # PubSub adapter to manage streams configuration
+      # for the underlying socket
+      class PubSub
+        private attr_reader :socket
+
+        ALL_STREAMS = Data.define(:to_str).new("all")
+
+        def initialize(socket) = @socket = socket
+
+        def subscribe(channel, _message_callback, success_callback = nil)
+          socket.subscribe identifier, channel
+          success_callback&.call
+        end
+
+        def unsubscribe(channel, _message_callback)
+          if channel == ALL_STREAMS
+            socket.unsubscribe_from_all identifier
+          else
+            socket.unsubscribe identifier, channel
+          end
+        end
+
+        private
+
+        def identifier = Current.identifier
+      end
+
+      attr_accessor :pubsub, :executor
+
+      def self.for(server, socket)
+        new(server).tap do |srv|
+          srv.executor = EXECUTOR
+          srv.pubsub = PubSub.new(socket)
+        end
+      end
+    end
+
+    class Connection
+      class Subscriptions < ::ActionCable::Connection::Subscriptions
+        # Wrap the original #execute_command to pre-initialize the channel for unsubscribe/message and
+        # return true/false to indicate successful/unsuccessful subscription.
+        def execute_command(data)
+          cmd = data["command"]
+
+          # We need the current channel identifier in pub/sub
+          Current.identifier = data["identifier"]
+
+          load(data["identifier"]) unless cmd == "subscribe"
+
+          super
+
+          return true unless cmd == "subscribe"
+
+          subscription = subscriptions[data["identifier"]]
+          !(subscription.nil? || subscription.rejected?)
+        end
+
+        # Restore channels from the list of identifiers and the state
+        def restore(subscriptions, istate)
+          subscriptions.each do |id|
+            channel = load(id)
+            channel.__istate__ = ActiveSupport::JSON.decode(istate[id]) if istate[id]
+          end
+        end
+
+        # Find or create a channel for a given identifier
+        def load(identifier)
+          return subscriptions[identifier] if subscriptions[identifier]
+
+          subscription = subscription_from_identifier(identifier)
+          raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}" unless subscription
+
+          subscriptions[identifier] = subscription
+        end
+      end
+
+      # We store logger tags in the connection state to be able
+      # to re-use them in the subsequent calls
+      LOG_TAGS_IDENTIFIER = "__ltags__"
+
+      attr_reader :socket, :server
+
+      delegate :identifiers_json, to: :conn
+      delegate :cstate, :istate, to: :socket
+
+      def initialize(connection_class, socket, identifiers: nil, subscriptions: nil, server: ::ActionCable.server)
+        server = Server.for(server, socket)
+
+        @socket = socket
+        @server = server
+        # TODO: Move protocol to socket.env as "anycable.protocol"
+        @protocol = "actioncable-v1-json"
+
+        logger_tags = fetch_logger_tags_from_state
+        @logger = ActionCable::Server::TaggedLoggerProxy.new(AnyCable.logger, tags: logger_tags)
+
+        @conn = connection_class.new(server, self)
+        conn.subscriptions = Subscriptions.new(conn)
+        conn.identifiers_json = identifiers
+        conn.anycable_socket = socket
+        conn.subscriptions.restore(subscriptions, socket.istate) if subscriptions
+      end
+
+      # == AnyCable RPC interface [BEGIN] ==
+      def handle_open
+        logger.info started_request_message if access_logs?
+
+        return close unless allow_request_origin?
+
+        conn.handle_open
+
+        # Commit log tags to the connection state
+        socket.cstate.write(LOG_TAGS_IDENTIFIER, logger.tags.to_json) unless logger.tags.empty?
+
+        socket.closed?
+      end
+
+      def handle_close
+        conn.handle_close
+        close
+        true
+      end
+
+      def handle_channel_command(identifier, command, data)
+        conn.handle_incoming({"command" => command, "identifier" => identifier, "data" => data})
+      end
+      # == AnyCable RPC interface [END] ==
+
+      # == Action Cable socket interface [BEGIN]
+      attr_reader :protocol, :logger
+
+      def request
+        @request ||= begin
+          env = socket.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
+      end
+
+      delegate :env, to: :request
+
+      def transmit(data)
+        socket.transmit ActiveSupport::JSON.encode(data)
+      end
+
+      def close(...)
+        return if socket.closed?
+        logger.info finished_request_message if access_logs?
+        socket.close(...)
+      end
+
+      def perform_work(receiver, method_name, *args)
+        raise ArgumentError, "Performing work is not supported within AnyCable"
+      end
+      # == Action Cable socket interface [END]
+
+      private
+
+      attr_reader :conn
+
+      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
+        format(
+          'Finished "%s"%s for %s at %s',
+          request.filtered_path, " [AnyCable]", request.ip, Time.now.to_s
+        )
+      end
+
+      def allow_request_origin?
+        return true unless socket.env.key?("HTTP_ORIGIN")
+
+        server.allow_request_origin?(socket.env)
+      end
+
+      def access_logs?
+        AnyCable.config.access_logs_disabled == false
+      end
+    end
+  end
+end

data/lib/anycable/rails/railtie.rb

@@ -1,11 +1,5 @@
 # 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/action_cable_ext/broadcast_options"
-require "anycable/rails/action_cable_ext/signed_streams"
-
 require "anycable/rails/channel_state"
 require "anycable/rails/connection_factory"
 
@@ -119,6 +113,7 @@ module AnyCable
       initializer "anycable.routes" do
         config.after_initialize do |app|
           config = AnyCable.config
+          config.http_rpc_mount_path ||= "/_anycable" if config.http_rpc?
           unless config.http_rpc_mount_path.nil?
             app.routes.prepend do
               mount AnyCable::HTTRPC::Server.new => config.http_rpc_mount_path, :internal => true
@@ -129,11 +124,12 @@ module AnyCable
 
       initializer "anycable.verify_pool_sizes" do
         next if AnyCable.config.disable_rpc_pool_size_warning?
-        # Skip if non-gRPC server is used
-        next unless AnyCable.config.respond_to?(:rpc_pool_size)
 
         # Log current db vs. gRPC pool sizes
         AnyCable.configure_server do
+          # Skip if non-gRPC server is used
+          next unless AnyCable.config.respond_to?(:rpc_pool_size)
+
           ActiveSupport.on_load(:active_record) do
             db_pool_size = ::ActiveRecord::Base.connection_pool.size
             rpc_pool_size = AnyCable.config.rpc_pool_size

data/lib/anycable/rails/{compatibility/rubocop → rubocop}/cops/anycable/instance_vars.rb

@@ -24,7 +24,7 @@ module RuboCop
       #     end
       #   end
       #
-      class InstanceVars < RuboCop::Cop::Cop
+      class InstanceVars < RuboCop::Cop::Base
         MSG = "Channel instance variables are not supported in AnyCable. Use `state_attr_accessor` instead"
 
         def on_class(node)

data/lib/anycable/rails/{compatibility/rubocop → rubocop}/cops/anycable/periodical_timers.rb

@@ -13,16 +13,11 @@ module RuboCop
       #     periodically(:do_something, every: 2.seconds)
       #   end
       #
-      class PeriodicalTimers < RuboCop::Cop::Cop
+      class PeriodicalTimers < RuboCop::Cop::Base
         MSG = "Periodical Timers are not supported in AnyCable"
+        RESTRICT_ON_SEND = %i[periodically].freeze
 
-        def_node_matcher :calls_periodically?, <<-PATTERN
-          (send _ :periodically ...)
-        PATTERN
-
-        def on_send(node)
-          add_offense(node) if calls_periodically?(node)
-        end
+        alias_method :on_send, :add_offense
       end
     end
   end

data/lib/anycable/rails/{compatibility/rubocop → rubocop}/cops/anycable/stream_from.rb

@@ -34,7 +34,7 @@ module RuboCop
       #     end
       #   end
       #
-      class StreamFrom < RuboCop::Cop::Cop
+      class StreamFrom < RuboCop::Cop::Base
         def_node_matcher :stream_from_with_block?, <<-PATTERN
           (block {(send _ :stream_from ...) (send _ :stream_for ...)} ...)
         PATTERN
@@ -81,16 +81,14 @@ module RuboCop
 
         def add_callback_offense(node)
           add_offense(
-            node,
-            location: :expression,
+            node.loc.expression,
             message: "Custom stream callbacks are not supported in AnyCable"
           )
         end
 
         def add_custom_coder_offense(node)
           add_offense(
-            node,
-            location: :expression,
+            node.loc.expression,
             message: "Custom coders are not supported in AnyCable"
           )
         end

data/lib/anycable/rails/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/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rails
-    VERSION = "1.5.3"
+    VERSION = "1.6.2"
   end
 end

data/lib/anycable/rails.rb

@@ -9,6 +9,7 @@ require "globalid"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
 require "anycable/rails/ext"
+require "anycable/rails/channel"
 
 module AnyCable
   # Rails handler for AnyCable
@@ -84,7 +85,7 @@ end
 
 # Warn if application has been already initialized.
 # AnyCable should be loaded before initialization in order to work correctly.
-if defined?(::Rails) && ::Rails.application && ::Rails.application.initialized?
+if defined?(::Rails) && ::Rails.application&.initialized?
   puts("\n**************************************************")
   puts(
     "⛔️  WARNING: AnyCable loaded after application initialization. Might not work correctly.\n" \

data/lib/generators/anycable/bin/templates/bin/anycable-go.tt

@@ -10,6 +10,11 @@ if [ ! -f ./bin/dist/anycable-go ]; then
   ./bin/rails g anycable:download --version=$version --bin-path=./bin/dist
 fi
 
+if [ -x ./bin/dist/anycable-go ]; then
+  echo "Setting execution permission for AnyCable server"
+  chmod +x ./bin/dist/anycable-go
+fi
+
 curVersion=$(./bin/dist/anycable-go -v)
 
 if [[ "$version" != "latest" ]]; then

data/lib/generators/anycable/download/download_generator.rb

@@ -37,24 +37,35 @@ module AnyCableRailsGenerators
       return latest_release_url(version) if version == "latest"
 
       if Gem::Version.new(version).segments.first >= 1
-        new_release_url("v#{version}")
+        new_release_url(version)
       else
-        legacy_release_url("v#{version}")
+        legacy_release_url(version)
+      end
+    end
+
+    def repository_name(version)
+      return "anycable/anycable" if version == "latest"
+
+      major, minor, = Gem::Version.new(version).segments
+      if (major >= 1 && minor >= 6) || (major > 1)
+        "anycable/anycable"
+      else
+        "anycable/anycable-go"
       end
     end
 
     def legacy_release_url(version)
-      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+      "https://github.com/#{repository_name(version)}/releases/download/v#{version}/" \
         "anycable-go-v#{version}-#{os_name}-#{cpu_name}"
     end
 
     def new_release_url(version)
-      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+      "https://github.com/#{repository_name(version)}/releases/download/v#{version}/" \
         "anycable-go-#{os_name}-#{cpu_name}"
     end
 
     def latest_release_url(version)
-      "https://github.com/anycable/anycable-go/releases/latest/download/" \
+      "https://github.com/#{repository_name(version)}/releases/latest/download/" \
         "anycable-go-#{os_name}-#{cpu_name}"
     end