cable_room 0.6.1 → 0.6.2.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 652ffcb10ea146215a77d64543cce7c60d1e67d45db773eaaae6487d50fb5340
-  data.tar.gz: 5be41bc8fb4fbfa16575f5693c939d3b7877fd520f0daac373e4e44b505aeefa
+  metadata.gz: 34ff8028043d9407e2f5f9487c472873b8ad56c1cda136ad50038ca28be578ff
+  data.tar.gz: 401c6500ac0d1c065967a4901a4a2e3d0ed75b1a8ffc3101260e820b5fff5bc4
 SHA512:
-  metadata.gz: be5a1a35fa28418a373b219c25b9f994291feea230840078584d9bd447b5d334ef31b205c542032570cd0148bb9ab42ced9543bd21eee2f50ea131f519ef3b94
-  data.tar.gz: 65fd75d2bda566796cc84b495c7ff32c7a3de15331c8ec891f33c36a549acfa14289f3817ee84eb086694891bf970c4ba6b99337b68aafb5e5acc0e5dea3fc69
+  metadata.gz: 83df8225dca28fd3c4fa70434698fea93bfd05ab495c5cac8d8718cb5acfe7a8c5800548a2332d2200247efc1dd29cd900d161e1914a75b3f34c908c972c4d24
+  data.tar.gz: 25e0451d688da7390793a0cca348e488b618c89dc8e98b510b775e7babdaf4df912c583b1bb1b0d04b8567c899646075c5abb27062e9e71de13f2fd458eb7169

data/lib/cable_room/ports.rb

@@ -6,8 +6,18 @@ module CableRoom
       @ports_proxy ||= PortsProxy.new(self)
     end
 
-    def stream_port(port, auto_close: true, &blk)
-      @cable_channel.stream_from(room_port_key(port), coder: ActiveSupport::JSON, &blk)
+    # Subscribe the channel to `port`, delivering each decoded message to the block.
+    #
+    # `on_live`, when given, runs once the pubsub adapter has confirmed the subscription — the
+    # first moment a message published to the port is guaranteed to reach the block. Subscribing
+    # is asynchronous, so anything published before then can be lost.
+    def stream_port(port, auto_close: true, on_live: nil, &blk)
+      broadcasting = room_port_key(port)
+      if on_live
+        _stream_from_observing_liveness(broadcasting, on_live, &blk)
+      else
+        @cable_channel.stream_from(broadcasting, coder: ActiveSupport::JSON, &blk)
+      end
       _streamed_ports << port if auto_close
     end
 
@@ -32,6 +42,34 @@ module CableRoom
       @_streamed_ports ||= Set.new
     end
 
+    # ActionCable::Channel::Streams#stream_from confirms the channel subscription once every one of
+    # its streams is live, but offers no per-stream hook. This is its body — unchanged from Rails
+    # 6.1 through 8.1 — with `on_live` added to the adapter's success callback.
+    #
+    # When the channel has replaced `stream_from` (ActionCable's channel test stubs, recorders,
+    # `StubRoomChannel`) there is no subscription to observe: defer to it and report live at once.
+    def _stream_from_observing_liveness(broadcasting, on_live, &blk)
+      chan = @cable_channel
+      unless chan.method(:stream_from).owner == ActionCable::Channel::Streams
+        chan.stream_from(broadcasting, coder: ActiveSupport::JSON, &blk)
+        on_live.call
+        return
+      end
+      return if chan.respond_to?(:unsubscribed?, true) && chan.send(:unsubscribed?)
+
+      chan.send(:defer_subscription_confirmation!)
+      handler = chan.send(:worker_pool_stream_handler, broadcasting, blk, coder: ActiveSupport::JSON)
+      chan.send(:streams)[broadcasting] = handler
+
+      chan.connection.server.event_loop.post do
+        chan.send(:pubsub).subscribe(broadcasting, handler, lambda do
+          chan.send(:ensure_confirmation_sent)
+          chan.logger.info "#{chan.class.name} is streaming from #{broadcasting}"
+          on_live.call
+        end)
+      end
+    end
+
     class PortsProxy
       def initialize(ports_concern)
         @ports_concern = ports_concern

data/lib/cable_room/room/input_handling.rb

@@ -56,7 +56,7 @@ module CableRoom
         class_attribute :_system_message_types, instance_writer: false, default: Set.new
 
         set_callback(:receive_message, :before) do
-          logger.debug "Received message: #{message.inspect}"
+          logger.debug { "Received message: #{message.inspect}" }
         end
 
         set_callback(:receive_message, :before) do

data/lib/cable_room/room_member.rb

@@ -103,13 +103,13 @@ module CableRoom
       return if left?
       if @has_established
         port_transmit(room_class::ROOM_IN_CHANNEL, { type: 'port_ping' }, secure_context: true)
-      else
-        # The port_connected sent by initiate_connection can be lost: stream subscriptions are
-        # asynchronous, so a room on another server can acknowledge before our private stream is
-        # live — and an unestablished membership silently drops everything the client sends
-        # (see #<<). Until acknowledged, keep re-announcing instead of pinging: port_connected is
-        # idempotent on the room side (the port is merged, user_joined fires only once), and the
-        # re-acknowledgement lands once our subscription is up.
+      elsif @streams_live
+        # Announced but never acknowledged. Our streams were already live when we announced (see
+        # initiate_connection), so this is not the subscribe race — the announcement or the
+        # acknowledgement was lost in transit, or the room did not exist yet. An unestablished
+        # membership silently drops everything the client sends (see #<<), so re-announce instead
+        # of pinging: port_connected is idempotent on the room side (the port is merged,
+        # user_joined fires only once).
         transmit_port_connected
       end
       @mutex.synchronize do
@@ -140,6 +140,23 @@ module CableRoom
 
     def key; @room_key; end
 
+    # Every stream this membership opens reports back once it is live; the last one to come up
+    # sends port_connected (see initiate_connection).
+    #
+    # The adapter runs the liveness callback on its own terms — the async and inline adapters call
+    # it while holding their subscriber-map lock, the Redis adapter on the event loop — so nothing
+    # may happen inside it except a hop to a worker thread: taking @mutex there deadlocks against
+    # an initiate_connection that is mid-broadcast, and broadcasting from it re-enters the lock.
+    def stream_port(port, on_live: nil, **kwargs, &blk)
+      generation = @stream_generation
+      @streams_pending += 1
+      connection = @cable_channel.connection
+      super(port, **kwargs, on_live: lambda do
+        connection.worker_pool.async_invoke(self, :_stream_became_live, generation, connection: connection)
+        on_live&.call
+      end, &blk)
+    end
+
     protected
 
     def port_transmit(port, data, secure_context: false)
@@ -170,7 +187,9 @@ module CableRoom
         @has_established = true
         @on_joined&.call(self) if first_acknowledgement
       when 'room_opened'
-        transmit_port_connected
+        # If our streams are not all live yet, the pending announcement covers this (and an early
+        # one would be acknowledged into a stream nobody is listening to yet).
+        transmit_port_connected if @streams_live
         @on_room_opened&.call(self)
       when 'room_closed'
         leave!
@@ -192,6 +211,18 @@ module CableRoom
         @has_established = false
         @cable_channel._room_memberships << self
 
+        # port_connected must not go out until every stream below is live on the pubsub adapter.
+        # Subscribing is asynchronous and the room acknowledges on the private @token stream, so
+        # announcing first lets a fast room — in practice one on another server — reply into a
+        # stream nobody is listening to yet; the acknowledgement is lost and the membership never
+        # establishes. stream_port (overridden above) counts the streams it opens and the last one
+        # to come up announces (_stream_became_live). The generation discards confirmations from
+        # a previous connection that land after a rejoin!.
+        @stream_generation = (@stream_generation || 0) + 1
+        @streams_pending = 0
+        @streams_armed = false
+        @streams_live = false
+
         # Listen to public/broadcast channel
         stream_port(room_class::ROOM_OUT_CHANNEL) do |message|
           handle_received_message(message)
@@ -217,12 +248,33 @@ module CableRoom
 
         @preconfigure&.call(self)
 
-        transmit_port_connected
+        # Streams whose adapter confirmed synchronously are already counted down; announce now if
+        # that was all of them, otherwise the last confirmation will.
+        @streams_armed = true
+        _announce_if_streams_live
 
         maybe_provision_room
       end
     end
 
+    def _stream_became_live(generation)
+      @mutex.synchronize do
+        return unless generation == @stream_generation
+
+        @streams_pending -= 1
+        _announce_if_streams_live
+      end
+    end
+
+    # Under @mutex. Sends port_connected once per connection, when every stream opened by
+    # initiate_connection has been confirmed live.
+    def _announce_if_streams_live
+      return if @streams_live || !@streams_armed || @streams_pending > 0 || left?
+
+      @streams_live = true
+      transmit_port_connected
+    end
+
     def transmit_port_connected
       msg = {
         type: 'port_connected',

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.6.1".freeze
+  VERSION = "0.6.2.beta1".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cable_room
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2.beta1
 platform: ruby
 authors:
 - Ethan Knapp