rage-rb 1.28.2 → 1.29.0

data/lib/rage/cable/protocols/raw_web_socket_json.rb

@@ -44,7 +44,7 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
   DEFAULT_PARAMS = {}.freeze
   private_constant :DEFAULT_PARAMS
 
-  def self.init(router)
+  def self.init
     super
 
     @ping_connections = Set.new
@@ -61,8 +61,10 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
   end
 
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
-  def self.on_open(connection)
-    accepted = @router.process_connection(connection)
+  # @param env [Hash] the Rack environment
+  # @param router [Rage::Cable::Router] the Cable router
+  def self.on_open(connection, env, router)
+    accepted = router.process_connection(connection, env)
 
     unless accepted
       connection.write(MESSAGES::UNAUTHORIZED)
@@ -70,7 +72,7 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
       return
     end
 
-    channel_id = connection.env["PATH_INFO"].split("/")[-1]
+    channel_id = env["PATH_INFO"].split("/")[-1]
 
     channel_name = if channel_id.end_with?("Channel")
       channel_id
@@ -86,10 +88,10 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
       "#{channel_id}Channel"
     end
 
-    query_string = connection.env["QUERY_STRING"]
+    query_string = env["QUERY_STRING"]
     params = query_string == "" ? DEFAULT_PARAMS : Iodine::Rack::Utils.parse_nested_query(query_string)
 
-    status = @router.process_subscription(connection, IDENTIFIER, channel_name, params)
+    status = router.process_subscription(connection, env, IDENTIFIER, channel_name, params)
 
     if status == :rejected
       connection.write(MESSAGES::REJECTED)
@@ -101,8 +103,10 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
   end
 
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param env [Hash] the Rack environment
   # @param raw_data [String] the message body
-  def self.on_message(connection, raw_data)
+  # @param router [Rage::Cable::Router] the Cable router
+  def self.on_message(connection, env, raw_data, router)
     if raw_data == "ping"
       @ping_connections << connection
       return
@@ -110,15 +114,17 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
 
     data = JSON.parse(raw_data)
 
-    message_status = @router.process_message(connection, IDENTIFIER, :receive, data)
+    message_status = router.process_message(connection, env, IDENTIFIER, :receive, data)
     unless message_status == :processed
       connection.write(MESSAGES::UNKNOWN)
     end
   end
 
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
-  def self.on_close(connection)
-    @router.process_disconnection(connection)
+  # @param env [Hash] the Rack environment
+  # @param router [Rage::Cable::Router] the Cable router
+  def self.on_close(connection, env, router)
+    router.process_disconnection(connection, env)
   end
 
   # @param data [Object] the object to serialize
@@ -131,6 +137,12 @@ class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
     false
   end
 
+  # A unique identifier of the protocol used in multi-server setups by {Rage::PubSub}.
+  # @return [String]
+  def self.protocol_id
+    "rawjson"
+  end
+
   # @private
   # The base implementation groups connection subscriptions by `params`;
   # however, with `RawWebSocketJson`, params are not part of the payload (see {serialize})

data/lib/rage/cable/remote_disconnect.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Include this module in your connection class to enable server-initiated disconnections.
+#
+# This allows you to disconnect WebSocket connections from anywhere in your application
+# using {Rage::Cable::Connection.disconnect Rage::Cable::Connection.disconnect}. A common
+# use case is forcing a logout when a user's session is invalidated or their account is suspended.
+#
+# @example
+#   class RageCable::Connection < Rage::Cable::Connection
+#     include Rage::Cable::RemoteDisconnect
+#
+#     identified_by :current_user
+#
+#     def connect
+#       self.current_user = find_verified_user
+#     end
+#   end
+#
+#   # Later, elsewhere in your application:
+#   RageCable::Connection.disconnect(current_user: user)
+#
+module Rage::Cable::RemoteDisconnect
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Disconnect all connections matching the specified identifier.
+    # @example Disconnect all connections for a user
+    #   RageCable::Connection.disconnect(current_user: User.find(1))
+    def disconnect(protocol_options: nil, **identified_by)
+      raise ArgumentError, "An identifier must be provided" if identified_by.empty?
+      raise ArgumentError, "Only one identifier can be provided" if identified_by.size > 1
+
+      id_pair = identified_by.first
+      unless __identifiers&.include?(id_pair[0])
+        raise ArgumentError, "Unknown identifier: #{id_pair[0]}"
+      end
+
+      message = if protocol_options
+        raise ArgumentError, "protocol_options must be a Hash" unless protocol_options.is_a?(Hash)
+        protocol_options.to_json
+      else
+        ""
+      end
+
+      Rage::PubSub.publish(message, topic: ["rage", name, id_pair])
+    end
+  end
+
+  private
+
+  def __remote_disconnect_setup(connection, protocol)
+    __identified_by_map.each do |identified_by|
+      Rage::PubSub.subscribe(topic: ["rage", self.class.name, identified_by], subscription_id: connection) do |message|
+        protocol_options = JSON.parse(message, symbolize_names: true) unless message.empty?
+        protocol.on_remote_disconnect(connection, protocol_options)
+        connection.close
+      end
+    end
+  end
+
+  def __remote_disconnect_cleanup(connection)
+    __identified_by_map&.each do |identified_by|
+      Rage::PubSub.unsubscribe(topic: ["rage", self.class.name, identified_by], subscription_id: connection)
+    end
+  end
+end

data/lib/rage/cable/router.rb

@@ -2,24 +2,25 @@
 
 class Rage::Cable::Router
   # @private
-  def initialize
+  # @param protocol [Rage::Cable::Protocols::Base]
+  # @param namespace [Module]
+  def initialize(protocol, namespace)
     # Hash<String(channel name) => Proc(new channel instance)>
     @channels_map = {}
+    @protocol = protocol
+    @namespace = namespace
     init_connection_class
   end
 
   # Calls the `connect` method on the `Connection` class to handle authentication.
   #
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param env [Hash] the Rack environment
   # @return [true] if the connection was accepted
   # @return [false] if the connection was rejected
-  def process_connection(connection)
-    env = connection.env
-
+  def process_connection(connection, env)
     cable_connection = @connection_class.new(env)
-    Rage::Telemetry.tracer.span_cable_connection_process(connection: cable_connection, action: :connect, env:) do
-      cable_connection.connect
-    end
+    cable_connection.__connect(connection, @protocol)
 
     if cable_connection.rejected?
       Rage.logger.debug { "An unauthorized connection attempt was rejected" }
@@ -34,6 +35,7 @@ class Rage::Cable::Router
   # Calls the `subscribed` method on the specified channel.
   #
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param env [Hash] the Rack environment
   # @param identifier [String] the identifier of the subscription
   # @param channel_name [String] the name of the channel class
   # @param params [Hash] the params hash associated with the subscription
@@ -41,10 +43,10 @@ class Rage::Cable::Router
   # @return [:invalid] if the subscription class does not exist
   # @return [:rejected] if the subscription was rejected
   # @return [:subscribed] if the subscription was accepted
-  def process_subscription(connection, identifier, channel_name, params)
+  def process_subscription(connection, env, identifier, channel_name, params)
     channel_class = @channels_map[channel_name] || begin
       begin
-        klass = Object.const_get(channel_name)
+        klass = @namespace.const_get(channel_name, false) unless channel_name.start_with?("::")
       rescue NameError
         nil
       end
@@ -54,18 +56,18 @@ class Rage::Cable::Router
         return :invalid
       end
 
-      klass.__register_actions.tap do |available_actions|
-        Rage.logger.debug { "Compiled #{channel_name}. Available remote actions: #{available_actions}." }
+      klass.__register_actions(@protocol).tap do |available_actions|
+        Rage.logger.debug { "Compiled #{klass.name}. Available remote actions: #{available_actions}." }
       end
 
       @channels_map[channel_name] = klass
     end
 
-    channel = channel_class.new(connection, params, connection.env["rage.identified_by"])
+    channel = channel_class.new(connection, params, env["rage.identified_by"])
     channel.__run_action(:subscribed)
 
     if channel.subscription_rejected?
-      Rage.logger.debug { "#{channel_name} is transmitting the subscription rejection" }
+      Rage.logger.debug { "#{channel_class} is transmitting the subscription rejection" }
       # if the subscription is rejected in the `subscribed` method, ActionCable will additionally run
       # the `unsubscribed` method; this makes little sense to me as the client was never subscribed in
       # the first place; additionally, I don't think this behaviour is documented anywhere;
@@ -73,15 +75,15 @@ class Rage::Cable::Router
       # channel.__run_action(:unsubscribed)
       :rejected
     else
-      Rage.logger.debug { "#{channel_name} is transmitting the subscription confirmation" }
-      connection.env["rage.cable"][identifier] = channel
+      Rage.logger.debug { "#{channel_class} is transmitting the subscription confirmation" }
+      env["rage.cable"][identifier] = channel
       :subscribed
     end
   end
 
   # Calls the handler method on the specified channel.
   #
-  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param env [Hash] the Rack environment
   # @param identifier [String] the identifier of the subscription
   # @param action_name [Symbol] the name of the handler method
   # @param data [Object] the data sent by the client
@@ -89,8 +91,8 @@ class Rage::Cable::Router
   # @return [:no_subscription] if the client is not subscribed to the specified channel
   # @return [:unknown_action] if the action does not exist on the specified channel
   # @return [:processed] if the message has been successfully processed
-  def process_message(connection, identifier, action_name, data)
-    channel = connection.env["rage.cable"][identifier]
+  def process_message(_, env, identifier, action_name, data)
+    channel = env["rage.cable"][identifier]
     unless channel
       Rage.logger.debug { "Unable to find the subscription" }
       return :no_subscription
@@ -105,25 +107,36 @@ class Rage::Cable::Router
     end
   end
 
+  # Runs the `unsubscribed` method on a specific channel without closing the connection.
+  #
+  # @param env [Hash] the Rack environment
+  # @param identifier [String] the identifier of the subscription
+  def process_unsubscription(_, env, identifier)
+    channel = env["rage.cable"].delete(identifier)
+    unless channel
+      Rage.logger.debug { "Unable to find the subscription" }
+      return
+    end
+
+    channel.__run_action(:unsubscribed)
+  end
+
   # Runs the `unsubscribed` methods on all the channels the client is subscribed to.
   #
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
-  def process_disconnection(connection)
-    env = connection.env
-
+  # @param env [Hash] the Rack environment
+  def process_disconnection(connection, env)
     env["rage.cable"]&.each do |_, channel|
       channel.__run_action(:unsubscribed)
     end
 
     cable_connection = @connection_class.new(env, env["rage.identified_by"])
-
-    Rage::Telemetry.tracer.span_cable_connection_process(connection: cable_connection, action: :disconnect, env:) do
-      cable_connection.disconnect
-    end
+    cable_connection.__disconnect(connection)
   end
 
   # @private
   def reset
+    @namespace = Object.const_get(@namespace.name) if @namespace.name
     @channels_map.clear
     init_connection_class
   end
@@ -131,10 +144,10 @@ class Rage::Cable::Router
   private
 
   def init_connection_class
-    @connection_class = if Object.const_defined?("RageCable::Connection")
-      RageCable::Connection
-    elsif Object.const_defined?("ApplicationCable::Connection")
-      ApplicationCable::Connection
+    @connection_class = if @namespace.const_defined?("RageCable::Connection", false)
+      @namespace.const_get("RageCable::Connection", false)
+    elsif @namespace.const_defined?("ApplicationCable::Connection", false)
+      @namespace.const_get("ApplicationCable::Connection", false)
     else
       puts "WARNING: Could not find the RageCable connection class! All connections will be accepted by default."
       Rage::Cable::Connection

data/lib/rage/code_loader.rb

@@ -85,7 +85,7 @@ class Rage::CodeLoader
 
   def reload_components
     unless Rage.autoload?(:Cable) # the `Cable` component is loaded
-      Rage::Cable.__router.reset
+      ObjectSpace.each_object(Rage::Cable::Router).each(&:reset)
     end
 
     unless Rage.autoload?(:OpenAPI) # the `OpenAPI` component is loaded

data/lib/rage/configuration.rb

@@ -757,30 +757,31 @@ class Rage::Configuration
     #     config.cable.protocol = :raw_websocket_json
     #   end
     def protocol=(protocol)
-      @protocol = case protocol
-      when Class
-        protocol
-      when :actioncable_v1_json
-        Rage::Cable::Protocols::ActioncableV1Json
-      when :raw_websocket_json
-        Rage::Cable::Protocols::RawWebSocketJson
-      else
-        raise ArgumentError, "Unknown protocol. Supported values are `:actioncable_v1_json` and `:raw_websocket_json`."
-      end
+      @protocol = Rage::Cable.__protocol_for(protocol)
     end
 
     # @private
-    def middlewares
-      @middlewares ||= begin
-        origin_middleware = if @disable_request_forgery_protection
-          []
-        else
-          [[Rage::OriginValidator, Array(@allowed_request_origins), nil]]
-        end
+    # Returns the list of middleware to be used with Cable applications.
+    #
+    # When `include_http_middleware` is `true`, the returned list includes both Cable-specific
+    # middleware and the application's HTTP middleware (excluding {Rage::FiberWrapper}).
+    # When `include_http_middleware` is `false`, only Cable-specific middleware is returned.
+    #
+    # @param include_http_middleware [Boolean] whether to include the application's HTTP middleware.
+    # @return [Array<Array>] an array of middleware definitions, where each definition is an array containing `[middleware_class, args, block]`
+    def middlewares(include_http_middleware: true)
+      cable_middlewares = if @disable_request_forgery_protection
+        []
+      else
+        [[Rage::OriginValidator, Array(@allowed_request_origins), nil]]
+      end
 
-        origin_middleware + Rage.config.middleware.middlewares.reject do |middleware, _, _|
-          middleware == Rage::FiberWrapper
+      if include_http_middleware
+        cable_middlewares + Rage.config.middleware.middlewares.reject do |m, _, _|
+          m == Rage::FiberWrapper
         end
+      else
+        cable_middlewares
       end
     end
   end

data/lib/rage/cookies.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
-require "base64"
 require "time"
 
+begin
+  require "base64"
+rescue LoadError
+  fail <<~ERR
+
+    Rage depends on `base64` to encode cookies. Ensure the following line is added to your Gemfile:
+    gem "base64"
+
+  ERR
+end
+
 if !defined?(DomainName)
   fail <<~ERR
 

data/lib/rage/daemon.rb

@@ -159,11 +159,7 @@ class Rage::Daemon
     private
 
     def __execute
-      Iodine.on_state(:start_shutdown) do
-        @__stopping = true
-      end
-
-      Fiber.schedule do
+      f = Fiber.schedule do
         backoff = INITIAL_BACKOFF
 
         Rage.logger.with_context(daemon: name) do
@@ -193,6 +189,11 @@ class Rage::Daemon
           end
         end
       end
+
+      Iodine.on_state(:start_shutdown) do
+        @__stopping = true
+        f.kill
+      end
     end # class << self
 
     def __cleanup(instance)