rage-rb 1.28.2 → 1.29.0

data/lib/rage/fiber_scheduler.rb

@@ -3,12 +3,20 @@
 require "resolv"
 
 class Rage::FiberScheduler
+  # @private
   MAX_READ = 65536
 
+  # @private
+  VERSION = defined?(IO::Buffer::VERSION) && IO::Buffer::VERSION >= 3 ? 4 : 3
+
+  # @private
+  attr_reader :root_fiber
+
   # Initialize the scheduler, storing the root fiber and an empty DNS cache.
   def initialize
     @root_fiber = Fiber.current
     @dns_cache = {}
+    @blocked = {}
   end
 
   # Wait for I/O events on a file descriptor, yielding the fiber until ready or timeout.
@@ -29,43 +37,50 @@ class Rage::FiberScheduler
   end
 
   # Read data from an I/O object into a buffer, pausing the fiber between reads.
-  def io_read(io, buffer, length, offset = 0)
-    length_to_read = if length == 0
-      buffer.size > MAX_READ ? MAX_READ : buffer.size
-    else
-      length
+  if VERSION == 4
+    def io_read(io, buffer, offset, length)
+      ::Iodine::Scheduler.read(io.fileno, buffer, length, offset)
     end
-
-    while true
-      string = ::Iodine::Scheduler.read(io.fileno, length_to_read, offset)
-
-      if string.nil?
-        return offset
+  else
+    def io_read(io, buffer, length, offset = 0)
+      length_to_read = if length == 0
+        buffer.size > MAX_READ ? MAX_READ : buffer.size
+      else
+        length
       end
 
-      if string.empty?
-        return -Errno::EAGAIN::Errno
-      end
+      while true
+        result = ::Iodine::Scheduler.read(io.fileno, buffer, length_to_read, offset)
 
-      buffer.set_string(string, offset)
+        if result == 0
+          return offset
+        elsif result < 0
+          next if result == -Errno::EINTR::Errno
+          return result
+        end
 
-      size = string.bytesize
-      offset += size
-      return offset if size < length_to_read || size >= buffer.size
+        offset += result
+        return offset if result < length_to_read || result >= buffer.size
 
-      Fiber.pause
+        length_to_read = length_to_read.clamp(nil, buffer.size - offset)
+        Fiber.pause
+      end
     end
   end
 
   unless ENV["RAGE_DISABLE_IO_WRITE"]
     # Write data from a buffer to an I/O object.
-    def io_write(io, buffer, length, offset = 0)
-      bytes_to_write = length
-      bytes_to_write = buffer.size if length == 0
-
-      ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
+    if VERSION == 4
+      def io_write(io, buffer, offset, length)
+        ::Iodine::Scheduler.write(io.fileno, buffer, length, offset)
+      end
+    else
+      def io_write(io, buffer, length, offset = 0)
+        bytes_to_write = length
+        bytes_to_write = buffer.size if length == 0
 
-      bytes_to_write - offset
+        ::Iodine::Scheduler.write_async(io.fileno, buffer, bytes_to_write, offset)
+      end
     end
   end
 
@@ -106,28 +121,27 @@ class Rage::FiberScheduler
 
   # Block the current fiber until unblocked or timeout.
   def block(_blocker, timeout = nil)
-    f, fulfilled = Fiber.current, false
-
+    f = Fiber.current
     gen = (f.__wait_generation += 1)
-    channel = f.__block_channel = "block:#{f.object_id}:#{gen}"
+    @blocked[f] = gen
 
-    resume_fiber_block = proc do
-      unless fulfilled
-        fulfilled = true
-        ::Iodine.defer { ::Iodine.unsubscribe(channel) }
-        f.resume if f.alive? && gen == f.__wait_generation
-      end
+    if timeout
+      ::Iodine.run_after((timeout * 1000).to_i) { unblock(nil, f) if gen == f.__wait_generation }
     end
 
-    ::Iodine.subscribe(channel) { resume_fiber_block.call }
-    ::Iodine.run_after((timeout * 1000).to_i) { resume_fiber_block.call } if timeout
-
     Fiber.yield
+  ensure
+    @blocked.delete(f)
   end
 
-  # Unblock a fiber by publishing to its block channel.
+  # Unblock a fiber previously blocked by `#block`.
   def unblock(_blocker, fiber)
-    ::Iodine.publish(fiber.__block_channel, "", Iodine::PubSub::PROCESS) if fiber.__block_channel
+    gen = @blocked.delete(fiber)
+    return unless gen
+
+    ::Iodine.defer do
+      fiber.resume if fiber.alive? && gen == fiber.__wait_generation
+    end
   end
 
   # Interrupt a fiber by incrementing its generation and raising an exception.

data/lib/rage/internal.rb

@@ -56,6 +56,10 @@ class Rage::Internal
           "#{streamable.class.name}:#{streamable.id}"
         elsif streamable.is_a?(String) || streamable.is_a?(Symbol) || streamable.is_a?(Numeric)
           streamable
+        elsif streamable.is_a?(Array)
+          stream_name_for(streamable)
+        elsif streamable.is_a?(Hash)
+          stream_name_for(streamable.sort)
         else
           raise ArgumentError, "Unable to generate stream name. Expected an object that responds to `id`, got: #{streamable.class}"
         end

data/lib/rage/middleware/origin_validator.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class Rage::OriginValidator
-  def initialize(app, *allowed_origins)
+  def initialize(app, *allowed_origins, allow_same_origin_as_host: true)
     @app = app
-    @validator = build_validator(allowed_origins)
+    @validator = build_validator(allowed_origins, allow_same_origin_as_host)
   end
 
   def call(env)
@@ -17,20 +17,43 @@ class Rage::OriginValidator
 
   private
 
-  def build_validator(allowed_origins)
-    if allowed_origins.empty?
+  def build_validator(allowed_origins, allow_same_origin_as_host)
+    if allowed_origins.empty? && !allow_same_origin_as_host
       ->(env) { false }
     else
-      origins_eval = allowed_origins.map { |origin|
-        origin.is_a?(Regexp) ?
-          "origin =~ /#{origin.source}/.freeze" :
-          "origin == '#{origin}'.freeze"
-      }.join(" || ")
+      origins_eval = []
+
+      same_origin_eval = if allow_same_origin_as_host
+        origins_eval << "is_same_origin"
+
+        <<~RUBY
+          host = env["HTTP_HOST"]
+
+          is_same_origin = if host.nil?
+            false
+          elsif origin.start_with?("https://")
+            origin.size == host.size + 8 && origin.end_with?(host)
+          elsif origin.start_with?("http://")
+            origin.size == host.size + 7 && origin.end_with?(host)
+          end
+        RUBY
+      end
+
+      origins_eval += allowed_origins.map do |configured_origin|
+        configured_origin.is_a?(Regexp) ?
+          "origin =~ /#{configured_origin.source}/" :
+          "origin == '#{configured_origin}'"
+      end
+
+      eval <<~RUBY
+        # frozen_string_literal: true
 
-      eval <<-RUBY
         ->(env) do
-          origin = env["HTTP_ORIGIN".freeze]
-          #{origins_eval}
+          origin = env["HTTP_ORIGIN"]
+          return false unless origin
+
+          #{same_origin_eval}
+          #{origins_eval.join(" || ")}
         end
       RUBY
     end

data/lib/rage/pubsub/pubsub.rb

@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
 ##
-# The module provides the support for multi-server setups for `Rage::Cable` and `Rage::SSE`. It allows for broadcasting messages across multiple servers or from different runtimes, e.g. Sidekiq.
+# The module enables communication between Rage instances across worker processes and nodes.
+#
+# It provides the infrastructure for multi-server setups for `Rage::Cable` and `Rage::SSE`, allowing broadcasting
+# messages across multiple servers or from different runtimes, e.g. Sidekiq. It also exposes a low-level API via
+# the {subscribe}, {unsubscribe}, and {publish} methods for direct inter-process communication.
+#
+# @note The low-level API is primarily intended for integrations and gems. Most applications should use
+#   higher-level abstractions like {Rage::Cable Rage::Cable} or {Rage::SSE Rage::SSE} instead.
+#
+# ## Configuration
 #
 # To use the module, add the `redis-client` gem to your Gemfile and create the environment-specific configuration in `config/pubsub.yml`:
 #
@@ -19,7 +30,141 @@
 # The rest of the options are passed directly to `redis-client`.
 #
 module Rage::PubSub
+  BROADCASTER_ID = "pubsub"
+  private_constant :BROADCASTER_ID
+
+  module Relay
+    def self.broadcast(channel, data)
+      Iodine.publish(channel, data)
+    end
+  end
+  private_constant :Relay
+
+  class << self
+    # @private
+    def __initialize
+      if (adapter = Rage.config.pubsub.adapter)
+        adapter.add_broadcaster(BROADCASTER_ID, Relay)
+        @__adapter = adapter
+      end
+    end
+
+    # Subscribe to messages on a topic.
+    #
+    # @param topic [String, Array, #id] The channel name to subscribe to. Can be a string, an array,
+    #   an Active Record model, or any object responding to `id`.
+    # @param subscription_id [Object] A unique identifier for this subscription within the topic.
+    #   Used to manage multiple subscriptions to the same topic and for cleanup via {unsubscribe}.
+    # @yieldparam message [String] The raw message string.
+    # @raise [ArgumentError] If a subscription with the same `topic` and `subscription_id` already exists.
+    #
+    # @example Subscribe to order updates
+    #   Rage::PubSub.subscribe(topic: "orders", subscription_id: :order_listener) do |message|
+    #     data = JSON.parse(message)
+    #     puts "Received order update: #{data}"
+    #   end
+    def subscribe(topic:, subscription_id:, &block)
+      serialized_topic = Rage::Internal.stream_name_for(topic)
+      topic_subscriptions = (subscriptions[serialized_topic] ||= {})
+
+      if topic_subscriptions.has_key?(subscription_id)
+        raise ArgumentError, "A subscription with topic #{topic.inspect} and subscription_id #{subscription_id.inspect} already exists"
+      end
+
+      topic_subscriptions[subscription_id] = block
+      subscribe_to_topic(serialized_topic) if topic_subscriptions.size == 1
+
+      true
+    end
+
+    # Remove a subscription from a topic.
+    #
+    # @param topic [String, Array, #id] The channel name to unsubscribe from. Must match the value
+    #   used when calling {subscribe}.
+    # @param subscription_id [Object, nil] The identifier of the subscription to remove. Omit the identifier to remove all subscriptions for the topic.
+    #
+    # @example Unsubscribe from order updates
+    #   Rage::PubSub.unsubscribe(topic: "orders", subscription_id: :order_listener)
+    def unsubscribe(topic:, subscription_id: nil)
+      serialized_topic = Rage::Internal.stream_name_for(topic)
+      topic_subscriptions = subscriptions[serialized_topic]
+
+      return false if topic_subscriptions.nil? || (subscription_id && !topic_subscriptions.has_key?(subscription_id))
+
+      if subscription_id
+        topic_subscriptions.delete(subscription_id)
+        unsubscribe_from_topic(serialized_topic) if topic_subscriptions.empty?
+      else
+        unsubscribe_from_topic(serialized_topic)
+      end
+
+      true
+    end
+
+    # Publish a message to all subscribers of a topic.
+    #
+    # Messages are delivered to all subscribers across worker processes and nodes (when a PubSub
+    # adapter is configured).
+    #
+    # @param message [String] The message to publish.
+    # @param topic [String, Array, #id] The channel name to publish to. Can be a string, an array,
+    #   an Active Record model, or any object responding to `id`.
+    # @raise [ArgumentError] If message is not a String.
+    #
+    # @example Publish an order update
+    #   Rage::PubSub.publish(JSON.generate({ id: 123, status: "shipped" }), topic: "orders")
+    #
+    # @example Publish to a model-based topic
+    #   Rage::PubSub.publish("refresh", topic: current_user)
+    def publish(message, topic:)
+      raise ArgumentError, "Message must be a String, got #{message.class}" unless message.is_a?(String)
+
+      serialized_topic = Rage::Internal.stream_name_for(topic)
+      channel = "pubsub:#{serialized_topic}"
+
+      Iodine.publish(channel, message) if Iodine.running?
+      @__adapter&.publish(BROADCASTER_ID, channel, message)
+
+      true
+    end
+
+    private
+
+    def subscriptions
+      @subscriptions ||= {}
+    end
+
+    def subscribe_to_topic(serialized_topic)
+      Iodine.subscribe("pubsub:#{serialized_topic}") do |_, message|
+        topic_subscriptions = subscriptions[serialized_topic]
+
+        topic_subscriptions&.each do |subscription_id, callback|
+          callback.call(message)
+        rescue => e
+          Rage.logger.error(
+            "PubSub callback failed with exception: #{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}",
+            subscription_id:
+          )
+        end
+      end
+    end
+
+    def unsubscribe_from_topic(serialized_topic)
+      subscriptions.delete(serialized_topic)
+
+      Iodine.defer do
+        Iodine.unsubscribe("pubsub:#{serialized_topic}") unless subscriptions.has_key?(serialized_topic)
+      end
+    end
+  end # class << self
+
   module Adapters
     autoload :Redis, "rage/pubsub/adapters/redis"
   end
 end
+
+if Rage.config.internal.initialized?
+  Rage::PubSub.__initialize
+else
+  Rage.config.after_initialize { Rage::PubSub.__initialize }
+end

data/lib/rage/router/dsl.rb

@@ -11,7 +11,10 @@ class Rage::Router::DSL
   end
 
   def draw(&block)
-    Handler.new(@router).instance_eval(&block)
+    handler = Handler.new(@router)
+    Rage::Extension.__routes.each { |block| handler.instance_eval(&block) }
+    handler.instance_eval(&block)
+
     # propagate route definitions to Rails for `rails routes` to work
     Rails.application.routes.draw(&block) if Rage.config.internal.rails_mode
   end

data/lib/rage/rspec.rb

@@ -256,11 +256,10 @@ module RageCableHelpers
   end
 
   def subscribe(params = {})
-    __stub_cable_protocol!
     __stub_iodine_defer!
 
     channel_class = __channel_class
-    channel_class.__register_actions
+    channel_class.__register_actions(__cable_test_protocol)
 
     params = (params || {}).each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
     params[:channel] = channel_class.name
@@ -355,10 +354,6 @@ module RageCableHelpers
     URI.parse("http://#{default_host}/")
   end
 
-  def __stub_cable_protocol!
-    allow(Rage.cable).to receive(:__protocol).and_return(__cable_test_protocol)
-  end
-
   def __stub_iodine_defer!
     allow(Iodine).to receive(:defer) do |&block|
       block&.call

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "1.28.2"
+  VERSION = "1.29.0"
 end

data/lib/rage-rb.rb

@@ -8,7 +8,12 @@ require "pathname"
 module Rage
   # Builds the Rage application with the configured middlewares.
   def self.application
-    with_middlewares(Application.new(__router), config.middleware.middlewares)
+    middleware = config.middleware.middlewares
+    if Fiber.scheduler && Fiber.current != Fiber.scheduler.root_fiber
+      middleware = middleware.reject { |m, _, _| m == Rage::FiberWrapper }
+    end
+
+    with_middlewares(Application.new(__router), middleware)
   end
 
   # Builds the Rage application which delegates Rails requests to `Rails.application`.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.28.2
+  version: 1.29.0
 platform: ruby
 authors:
 - Roman Samoilov
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '6.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '6.3'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +150,7 @@ files:
 - lib/rage/cable/protocols/actioncable_v1_json.rb
 - lib/rage/cable/protocols/base.rb
 - lib/rage/cable/protocols/raw_web_socket_json.rb
+- lib/rage/cable/remote_disconnect.rb
 - lib/rage/cable/router.rb
 - lib/rage/cli.rb
 - lib/rage/cli/base.rb
@@ -166,6 +167,8 @@ files:
 - lib/rage/deferred/backends/disk.rb
 - lib/rage/deferred/backends/nil.rb
 - lib/rage/deferred/context.rb
+- lib/rage/deferred/dead_task.rb
+- lib/rage/deferred/dead_tasks.rb
 - lib/rage/deferred/deferred.rb
 - lib/rage/deferred/metadata.rb
 - lib/rage/deferred/middleware_chain.rb