anycable-rails-core 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae33f5aaf1057a1aa63e16280048477ed7f6be5ff403e7a45bd4198aed3ef226
-  data.tar.gz: dfedd48dbeddaf2e722093bec52f459c576c59a3c549e26afe00753ee770496b
+  metadata.gz: 6ceb26b8e5c09c7bd5500007a29a79a2933cc38848a63da16af272a4a5d11771
+  data.tar.gz: 6db49c5ceca2e5b020fb7b225ebe2e1db63df8beb9858224502883ff35392529
 SHA512:
-  metadata.gz: 3e84c51f6fb7b2c7e7a1b1535b2f99b4db0d83ee3235b45104aad07e353924bf2ce91269b4dbb9b992f356a622594f3c2e44941edf60b47be899196ee8adfd83
-  data.tar.gz: 6b9b15397056c29d3cbf01b566ea4282e41dc2065f8af827bb73f102c47e78d429aecbfd11d687660eb4c820225fa3411d9bd7bd4fb39a75155568a0e4e24e05
+  metadata.gz: d78c540124cec98c20e2004f49324580300a9be00eea194fa09200a8b30090b3448e3411dcba1a4002efa857997e0ed66da44a808efd17ceede3ce45fd97b751
+  data.tar.gz: 4e7916ccc0f8c18ed305eab329575c1bc840be9eeeb1534d4d3c661067a5f9a96ac761af3e8f2f9871a0f3bcbc7d30816e09a3e9998d7bffdf3555d36a88f515

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master
 
+## 1.5.4 (2024-10-08)
+
+- Add [actioncable-next](https://github.com/anycable/actioncable-next) support. ([@palkan][])
+
+- Generate `anycable.toml` in `anycable:setup` generator. ([@palkan][])
+
 ## 1.5.3 (2024-09-12)
 
 - Set upper limit on supported Rails versions. ([@palkan][])

data/README.md

@@ -8,8 +8,6 @@ AnyCable allows you to use any WebSocket server (written in any language) as a r
 
 With AnyCable you can use channels, client-side JS, broadcasting - (almost) all that you can do with Action Cable.
 
-You can even use Action Cable in development and not be afraid of [compatibility issues](#compatibility).
-
 💾 [Example Application](https://github.com/anycable/anycable_rails_demo)
 
 📑 [Documentation](https://docs.anycable.io/rails/getting_started).
@@ -21,9 +19,10 @@ You can even use Action Cable in development and not be afraid of [compatibility
 
 ## Requirements
 
-- Ruby >= 2.6
-- Rails >= 6.0 (Rails 5.1 could work but we're no longer enforce compatibility on CI)
-- Redis (see [other options](https://github.com/anycable/anycable/issues/2) for broadcasting)
+- Ruby >= 3.1
+- Rails >= 6.0\*
+
+\* Recent `anycable-rails` versions only work with Rails 8+; older versions compatible with Rails 6 and Rails 7 still receive fixes and minor updates (patch releases).
 
 ## Usage
 
@@ -31,9 +30,6 @@ Add `anycable-rails` gem to your Gemfile:
 
 ```ruby
 gem "anycable-rails"
-
-# when using Redis broadcast adapter
-gem "redis", ">= 4.0"
 ```
 
 ### Interactive set up

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

@@ -57,3 +57,23 @@ ActionCable::Channel::Base.prepend(Module.new do
     connection.instance_variable_defined?(:@anycable_socket)
   end
 end)
+
+# Handle $pubsub channel in Subscriptions
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  # The contents are mostly copied from the original,
+  # there is no good way to configure channels mapping due to #safe_constantize
+  # and the layers of JSON
+  # https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/connection/subscriptions.rb
+  def add(data)
+    id_key = data["identifier"]
+    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+
+    return if subscriptions.key?(id_key)
+
+    return super unless id_options[:channel] == "$pubsub"
+
+    subscription = AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
+    subscriptions[id_key] = subscription
+    subscription.subscribe_to_channel
+  end
+end)

data/lib/anycable/rails/action_cable_ext/remote_connections.rb

@@ -3,20 +3,10 @@
 require "action_cable/remote_connections"
 
 ActionCable::RemoteConnections::RemoteConnection.include(AnyCable::Rails::Connections::SerializableIdentification)
-
 ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
-  # Rails <7.1 has no `reconnect` argument
-  if ActionCable::RemoteConnections::RemoteConnection.instance_method(:disconnect).arity == 0
-    def disconnect(reconnect: true)
-      # Legacy Action Cable functionality if case we're not fully migrated yet
-      super() unless AnyCable::Rails.enabled?
-      ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
-    end
-  else
-    def disconnect(reconnect: true)
-      # Legacy Action Cable functionality if case we're not fully migrated yet
-      super unless AnyCable::Rails.enabled?
-      ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
-    end
+  def disconnect(reconnect: true)
+    # Legacy Action Cable functionality if case we're not fully migrated yet
+    super unless AnyCable::Rails.enabled?
+    ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
   end
 end)

data/lib/anycable/rails/compatibility.rb

@@ -8,6 +8,7 @@ module AnyCable
       @active_periodic_timers
       @_streams
       @parameter_filter
+      @whisper_stream
     ]
 
     ActionCable::Channel::Base.prepend(Module.new do

data/lib/anycable/rails/connection_factory.rb

@@ -1,6 +1,25 @@
 # frozen_string_literal: true
 
-require "anycable/rails/connection"
+require "action_cable"
+
+begin
+  ActionCable::Server::Socket
+rescue
+end
+
+if defined?(ActionCable::Server::Socket)
+  require "anycable/rails/next/connection"
+  require "anycable/rails/next/action_cable_ext/connection"
+  require "anycable/rails/next/action_cable_ext/channel"
+else
+  require "anycable/rails/connection"
+
+  require "anycable/rails/action_cable_ext/connection"
+  require "anycable/rails/action_cable_ext/channel"
+end
+
+require "anycable/rails/action_cable_ext/remote_connections"
+require "anycable/rails/action_cable_ext/broadcast_options"
 
 module AnyCable
   module Rails

data/lib/anycable/rails/connections/persistent_session.rb

@@ -2,6 +2,11 @@
 
 require "anycable/rails/connections/session_proxy"
 
+if defined?(ActionCable::Server::Socket)
+  require "anycable/rails/next/connection/persistent_session"
+  return
+end
+
 module AnyCable
   module Rails
     module Connections

data/lib/anycable/rails/connections/serializable_identification.rb

@@ -32,6 +32,11 @@ module AnyCable
           identifiers_hash.to_json
         end
 
+        def identifiers_json=(val)
+          @cached_ids = {}
+          @serialized_ids = val ? ActiveSupport::JSON.decode(val) : {}
+        end
+
         # Fetch identifier and deserialize if neccessary
         def fetch_identifier(name)
           return unless @cached_ids

data/lib/anycable/rails/connections/session_proxy.rb

@@ -46,9 +46,9 @@ module AnyCable
           rack_session.respond_to?(name, include_private) || super
         end
 
-        def method_missing(method, *args, &block)
+        def method_missing(method, ...)
           if rack_session.respond_to?(method, true)
-            rack_session.send(method, *args, &block)
+            rack_session.send(method, ...)
           else
             super
           end

data/lib/anycable/rails/ext/jwt.rb

@@ -10,7 +10,7 @@ module AnyCable
           super
         rescue AnyCable::JWT::ExpiredSignature
           logger.error "An expired JWT token was rejected"
-          close(reason: "token_expired", reconnect: false) if websocket&.alive?
+          close(reason: "token_expired", reconnect: false)
         end
 
         def anycable_jwt_present?

data/lib/anycable/rails/ext/signed_streams.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Connection::Base.include(Module.new do
+  # This method is assumed to be overriden in the connection class to enable public
+  # streams
+  def allow_public_streams?
+    false
+  end
+end)
+
+# Handle $pubsub channel in Subscriptions
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  def subscription_from_identifier(id_key)
+    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+    return super unless id_options[:channel] == "$pubsub"
+
+    AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
+  end
+end)

data/lib/anycable/rails/ext/whisper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  attr_accessor :whisper_stream
+
+  def stream_from(broadcasting, _callback = nil, **opts)
+    whispering = opts.delete(:whisper)
+    whispers_to(broadcasting) if whispering
+    super
+  end
+
+  def whispers_to(broadcasting)
+    logger.debug "#{self.class.name} whispers to #{broadcasting}"
+    self.whisper_stream = broadcasting
+  end
+end)
+
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  def execute_command(data)
+    return whisper(data) if data["command"] == "whisper"
+
+    super
+  end
+
+  def whisper(data)
+    subscription = find(data)
+    stream = subscription.whisper_stream
+    raise "Whispering stream is not set" unless stream
+
+    ::ActionCable.server.broadcast stream, data["data"]
+  end
+end)

data/lib/anycable/rails/ext.rb

@@ -4,7 +4,10 @@ module AnyCable
   module Rails
     module Ext
       autoload :JWT, "anycable/rails/ext/jwt"
-      autoload :SignedStreams, "anycable/rails/ext/signed_streams"
+
+      # These features are included by default
+      require "anycable/rails/ext/signed_streams"
+      require "anycable/rails/ext/whisper"
     end
   end
 end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  # Whispering support
+  def whispers_to(broadcasting)
+    return super unless anycabled?
+
+    connection.anycable_socket.whisper identifier, broadcasting
+  end
+
+  # Unsubscribing relies on the channel state (which is not persistent in AnyCable).
+  # Thus, we pretend that the stream is registered to make Action Cable do its unsubscribing job.
+  def stop_stream_from(broadcasting)
+    streams[broadcasting] = true if anycabled?
+    super
+  end
+
+  # For AnyCable, unsubscribing from all streams is a separate operation,
+  # so we use a special constant to indicate it.
+  def stop_all_streams
+    if anycabled?
+      streams.clear
+      streams[AnyCable::Rails::Server::PubSub::ALL_STREAMS] = true
+    end
+    super
+  end
+
+  # Make rejected status accessible from outside
+  def rejected? = subscription_rejected?
+
+  private
+
+  def anycabled? = connection.anycabled?
+end)

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"
 

data/lib/anycable/rails/socket_id_tracking.rb

@@ -11,8 +11,8 @@ module AnyCable
 
       private
 
-      def anycable_tracking_socket_id(&block)
-        Rails.with_socket_id(request.headers[AnyCable.config.socket_id_header], &block)
+      def anycable_tracking_socket_id(&)
+        Rails.with_socket_id(request.headers[AnyCable.config.socket_id_header], &)
       end
     end
 

data/lib/anycable/rails/version.rb

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

data/lib/generators/anycable/setup/setup_generator.rb

@@ -70,6 +70,8 @@ module AnyCableRailsGenerators
         template "anycable.yml"
       end
 
+      template "anycable.toml"
+
       update_cable_yml
     end
 
@@ -168,6 +170,7 @@ module AnyCableRailsGenerators
               ANYCABLE_BROADCAST_ADAPTER: http
               ANYCABLE_RPC_HOST: anycable:50051
               ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+              ANYCABLE_SECRET: "anycable-local-secret"
 
           anycable:
             <<: *rails
@@ -208,6 +211,7 @@ module AnyCableRailsGenerators
               ANYCABLE_BROADCAST_ADAPTER: http
               ANYCABLE_RPC_HOST: http://rails:3000/_anycable
               ANYCABLE_DEBUG: ${ANYCABLE_DEBUG:-true}
+              ANYCABLE_SECRET: "anycable-local-secret"
           ─────────────────────────────────────────
         YML
       end
@@ -266,18 +270,11 @@ module AnyCableRailsGenerators
           end
         end
         unless contents.match?(/^ws:\s/)
-          append_file file_name, "ws: bin/anycable-go #{anycable_go_options}", force: true
+          append_file file_name, "ws: bin/anycable-go", force: true
         end
       end
     end
 
-    def anycable_go_options
-      opts = ["--port=8080"]
-      opts << "--broadcast_adapter=http" unless redis?
-      opts << "--rpc_host=http://localhost:3000/_anycable" if http_rpc?
-      opts.join(" ")
-    end
-
     def file_exists?(name)
       in_root do
         return File.file?(name)

data/lib/generators/anycable/setup/templates/Procfile.dev.tt

@@ -2,4 +2,4 @@ web: bin/rails s
 <%- unless http_rpc? -%>
 anycable: bundle exec anycable
 <%- end -%>
-ws: bin/anycable-go <%= anycable_go_options %>
+ws: bin/anycable-go

data/lib/generators/anycable/setup/templates/anycable.toml.tt

@@ -0,0 +1,83 @@
+# AnyCable server configuration (development).
+#
+# Read more at https://docs.anycable.io/anycable-go/configuration
+
+# Public mode disables connection authentication, pub/sub streams and broadcasts verification
+# public = false
+
+# The application secret key
+secret = "anycable-local-secret"
+
+# Broadcasting adapters for app-to-clients messages
+<%- if redis? -%>
+broadcast_adapters = ["http", "redisx"]
+<%- elsif nats? -%>
+broadcast_adapters = ["http", "nats"]
+<%- else -%>
+broadcast_adapters = ["http"]
+<%- end -%>
+
+# Pub/sub adapter for inter-node communication
+<%- if redis? -%>
+pubsub_adapter = "redis"
+<%- elsif nats? -%>
+pubsub_adapter = "nats"
+<%- else -%>
+# pubsub_adapter = "redis" # or "nats"
+<%- end -%>
+
+[server]
+host = "localhost"
+port = 8080
+
+[logging]
+debug = true
+
+# Read more about broker: https://docs.anycable.io/anycable-go/reliable_streams
+[broker]
+adapter = "memory"
+history_ttl = 300
+history_limit = 100
+sessions_ttl = 300
+
+[rpc]
+<%- if http_rpc? -%>
+host = "http://localhost:3000/_anycable"
+<%- else -%>
+host = "localhost:50051"
+<%- end -%>
+# Specify HTTP headers that must be proxied to the RPC service
+proxy_headers = ["cookie"]
+# RPC concurrency (max number of concurrent RPC requests)
+concurrency = 28
+
+# Read more about AnyCable JWT: https://docs.anycable.io/anycable-go/jwt_identification
+[jwt]
+# param = "jid"
+# force = true
+
+# Read more about AnyCable signed streams: https://docs.anycable.io/anycable-go/signed_streams
+[streams]
+# Enable public (unsigned) streams
+# public = true
+# Enable whispering support for pub/sub streams
+# whisper = true
+pubsub_channel = "$pubsub"
+# turbo = true
+# cable_ready = true
+
+[redis]
+<%- if redis? -%>
+url = "redis://localhost:6379"
+<%- else -%>
+# url = "redis://localhost:6379"
+<%- end -%>
+
+<%- if nats? -%>
+[nats]
+servers = "nats://127.0.0.1:4222"
+<%- end -%>
+
+[http_broadcast]
+port = 8090
+path = "/_broadcast"

data/lib/generators/anycable/setup/templates/config/anycable.yml.tt

@@ -15,14 +15,15 @@ default: &default
   # Whether to enable gRPC level logging or not
   log_grpc: false
   <%- if redis? -%>
-  # Use Redis to broadcast messages to AnyCable server
-  broadcast_adapter: redis
+  # Use Redis Streams to broadcast messages to AnyCable server
+  broadcast_adapter: redisx
   <%- elsif nats? -%>
   # Use NATS to broadcast messages to AnyCable server
   broadcast_adapter: nats
   <%- else -%>
   # Use HTTP broadcaster
   broadcast_adapter: http
+  http_broadcast_url: "http://localhost:8090/_anycable"
   <%- end -%>
   <%- if redis? -%>
   # You can use REDIS_URL env var to configure Redis URL.
@@ -37,6 +38,8 @@ default: &default
   # Read more about AnyCable RPC:  <%= DOCS_ROOT %>/anycable-go/rpc
   http_rpc_mount_path: "/_anycable"
   <%- end -%>
+  # Must be the same as in your AnyCable server config
+  secret: "anycable-local-secret"
 
 development:
   <<: *default
@@ -51,3 +54,4 @@ test:
 production:
   <<: *default
   websocket_url: ~
+  secret: ~

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anycable-rails-core
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.4
 platform: ruby
 authors:
 - palkan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2024-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: globalid
   requirement: !ruby/object:Gem::Requirement
@@ -77,7 +77,6 @@ files:
 - lib/anycable/rails/action_cable_ext/channel.rb
 - lib/anycable/rails/action_cable_ext/connection.rb
 - lib/anycable/rails/action_cable_ext/remote_connections.rb
-- lib/anycable/rails/action_cable_ext/signed_streams.rb
 - lib/anycable/rails/channel_state.rb
 - lib/anycable/rails/compatibility.rb
 - lib/anycable/rails/compatibility/rubocop.rb
@@ -93,9 +92,15 @@ files:
 - lib/anycable/rails/connections/session_proxy.rb
 - lib/anycable/rails/ext.rb
 - lib/anycable/rails/ext/jwt.rb
+- lib/anycable/rails/ext/signed_streams.rb
+- lib/anycable/rails/ext/whisper.rb
 - lib/anycable/rails/helper.rb
 - lib/anycable/rails/middlewares/executor.rb
 - lib/anycable/rails/middlewares/log_tagging.rb
+- lib/anycable/rails/next/action_cable_ext/channel.rb
+- lib/anycable/rails/next/action_cable_ext/connection.rb
+- lib/anycable/rails/next/connection.rb
+- lib/anycable/rails/next/connection/persistent_session.rb
 - lib/anycable/rails/object_serializer.rb
 - lib/anycable/rails/pubsub_channel.rb
 - lib/anycable/rails/rack.rb
@@ -110,6 +115,7 @@ files:
 - lib/generators/anycable/setup/USAGE
 - lib/generators/anycable/setup/setup_generator.rb
 - lib/generators/anycable/setup/templates/Procfile.dev.tt
+- lib/generators/anycable/setup/templates/anycable.toml.tt
 - lib/generators/anycable/setup/templates/bin/anycable-go.tt
 - lib/generators/anycable/setup/templates/config/anycable.yml.tt
 - lib/generators/anycable/setup/templates/config/cable.yml.tt

data/lib/anycable/rails/action_cable_ext/signed_streams.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "action_cable"
-
-ActionCable::Connection::Base.include(Module.new do
-  # This method is assumed to be overriden in the connection class to enable public
-  # streams
-  def allow_public_streams?
-    false
-  end
-end)
-
-# Handle $pubsub channel in Subscriptions
-ActionCable::Connection::Subscriptions.prepend(Module.new do
-  # The contents are mostly copied from the original,
-  # there is no good way to configure channels mapping due to #safe_constantize
-  # and the layers of JSON
-  # https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/connection/subscriptions.rb
-  def add(data)
-    id_key = data["identifier"]
-    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
-
-    return if subscriptions.key?(id_key)
-
-    return super unless id_options[:channel] == "$pubsub"
-
-    subscription = AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
-    subscriptions[id_key] = subscription
-    subscription.subscribe_to_channel
-  end
-end)