cable_room 0.7.0.beta3 → 0.8.0.beta2

data/lib/cable_room/room_member.rb

@@ -1,8 +1,4 @@
 module CableRoom
-  # Raised at subscribe time when `join_room` asks for something AnyCable can't deliver
-  # (see RoomMember#refuse_unsupported_under_anycable!).
-  class AnyCableUnsupported < ArgumentError; end
-
   module RoomMember
     extend ActiveSupport::Concern
 
@@ -13,19 +9,18 @@ module CableRoom
     # ~30% of all room messages at 10 s with no skipping.
     PING_INTERVAL = 15.seconds
 
+    # A dropped announcement is invisible to the port. The room hears members on the Bus, and its
+    # subscription is live once the room has started, but the room may not have started yet, may
+    # live in another process, or the Bus may be reconnecting; Redis pub/sub doesn't queue, so a
+    # port_connected sent before the room is listening is discarded with no error. Re-announce on
+    # a doubling backoff from here until the room acknowledges, rather than waiting out a whole
+    # PING_INTERVAL. port_connected is idempotent on the room side (the port is merged,
+    # user_joined fires only once), so a redundant re-announcement costs one message.
+    REANNOUNCE_INITIAL_DELAY = 0.1.seconds
+
     included do
       periodically :ping_room_memberships, every: PING_INTERVAL
 
-      # Where MembershipStore::AnyCable keeps the memberships between anycable-rails' per-call
-      # channel instances. `state_attr_accessor` only exists once anycable-rails is loaded; without
-      # it the channel lives for the socket and the in-memory store is all there is. Private
-      # because every public method of a channel is an action a client can perform, and a client
-      # that could write this could claim another member's token.
-      if respond_to?(:state_attr_accessor)
-        state_attr_accessor MembershipStore::AnyCable::STATE_ATTRIBUTE
-        private MembershipStore::AnyCable::STATE_ATTRIBUTE, :"#{MembershipStore::AnyCable::STATE_ATTRIBUTE}="
-      end
-
       after_unsubscribe do
         to_close = _room_memberships.to_a
         _room_memberships.clear
@@ -33,51 +28,13 @@ module CableRoom
       end
     end
 
-    # The channel's memberships (a MembershipStore). RoomMembership registers itself here, so this
-    # has to stay public; treat it as internal and read `room_memberships` instead.
     def _room_memberships
-      @_room_memberships ||= MembershipStore.for(self)
-    end
-
-    # True when anycable-rails is handling this channel: the connection carries an AnyCable socket,
-    # this instance exists for one RPC call only, its streams are held by anycable-go, and its
-    # timers never run. `anycabled?` is what anycable-rails itself checks; it only exists once the
-    # gem is loaded. (Public methods are actions; performing this one is harmless.)
-    def anycable_channel?
-      connection.respond_to?(:anycabled?) && !!connection.anycabled?
-    end
-
-    # The `hello` channel action. The browser performs it once ActionCable has confirmed the
-    # subscription (`connected()` in the JS client), which is the first moment every stream this
-    # channel opened is guaranteed live. Each membership announces itself to its room in response;
-    # nothing is announced before then. A channel with no memberships ignores it.
-    #
-    # Public methods on a channel are its actions, so every RoomMember channel accepts
-    # `perform("hello")` without further wiring.
-    def hello(_data = nil)
-      hello_room_memberships
-    end
-
-    # The `ping` channel action. Under ActionCable the channel's own timer pings, so a client that
-    # performs this is doing harmless extra work. Under AnyCable channel timers never run (there is
-    # no long-lived channel object to run them on), so the browser performs this every
-    # PING_INTERVAL and each membership turns it into port_ping. See README "Using AnyCable".
-    def ping(_data = nil)
-      ping_room_memberships
+      @_room_memberships ||= Set.new
     end
 
     protected
 
-    # The memberships `join_room` created on this channel. Under AnyCable the instance variable
-    # `subscribed` assigned is gone by the next call; this still has them, rebuilt from the
-    # channel state.
-    def room_memberships
-      _room_memberships
-    end
-
     def join_room(room_class, room_key = nil, as: :not_given, forward: false, **kwargs, &blk)
-      refuse_unsupported_under_anycable!(forward: forward, callbacks: kwargs, block: blk)
-
       if forward
         # raise ArgumentError, "Cannot specify both `forward: true` and `on_message:`" if kwargs[:on_message]
         original_on_message = kwargs[:on_message]
@@ -101,33 +58,13 @@ module CableRoom
       _room_memberships.each(&:ping!)
     end
 
-    # Under AnyCable, room→member broadcasts go anycable-go → socket and never pass through this
-    # process, and the channel object is rebuilt per call, so nothing here can run a proc when a
-    # message arrives. That rules out `forward: false` (nothing would deliver messages to the app),
-    # every `on_*:` callback, and a preconfigure block (custom stream handlers). Failing at
-    # subscribe time beats a join that silently never fires anything. RoomProxyChannel's own
-    # `forward` wrapper is added after this check, so it is exempt. Plain ActionCable: no-op.
-    UNSUPPORTED_UNDER_ANYCABLE_CALLBACKS = %i[on_joined on_message on_room_opened on_room_closed on_left].freeze
-
-    def refuse_unsupported_under_anycable!(forward:, callbacks:, block:)
-      return unless anycable_channel?
-
-      unsupported = []
-      unsupported << "forward: false" unless forward
-      unsupported.concat(UNSUPPORTED_UNDER_ANYCABLE_CALLBACKS.select { |cb| callbacks[cb] }.map { |cb| "#{cb}:" })
-      unsupported << "a preconfigure block" if block
-      return if unsupported.empty?
-
-      raise AnyCableUnsupported,
-        "join_room used #{unsupported.join(', ')} on an AnyCable-backed channel (#{self.class.name}). " \
-        "Under AnyCable room messages never pass through this process, so these can't work; " \
-        "use forward: true without callbacks (see README, \"Using AnyCable\")."
-    end
-
-    # Server-side entry point for the hello signal, for channels that learn the client is ready
-    # some other way than the `hello` action (a custom handshake message, for instance).
-    def hello_room_memberships
-      _room_memberships.each(&:hello!)
+    def transmit_subscription_confirmation(...)
+      super
+      memberships = _room_memberships.to_a
+      memberships.each(&:streams_live!)
+      connection.worker_pool.async_exec(self, connection: connection) do
+        memberships.each(&:transmit_port_connected)
+      end
     end
   end
 
@@ -148,28 +85,21 @@ module CableRoom
       on_left: nil,
       tags: [],
       extra: nil,
-      tenant: nil,
       &preconfigure
     )
       @mutex = Monitor.new
 
       @has_left = false
       @has_established = false
-      @hello_received = false
+      @streams_live = false
+      @reannounce_delay = nil
+      @reannounce_job = nil
 
       @cable_channel = cable_channel
       @room_class = room_class
       @room_key = room_key
       @allow_create = create
 
-      # Defaults to the ambient tenant right here, at join_room's own call site -- the member's
-      # own request thread, the last point before this room's work moves to a Host thread with no
-      # request of its own to derive one from (see Runner#initialize). An app only needs to pass
-      # `tenant:` explicitly to ask for something other than "whatever tenant this join is
-      # happening under", which is the common case. nil isn't a real tenant either way, so it
-      # doubles as "not given".
-      @tenant = tenant || (Apartment::Tenant.current if defined?(Apartment))
-
       @on_room_opened = on_room_opened
       @on_joined = on_joined
       @on_message = on_message
@@ -197,95 +127,11 @@ module CableRoom
       @mutex.synchronize { @has_left }
     end
 
-    def hello_received?
-      @hello_received
-    end
-
-    # Whether room→member traffic reaches this object. Under ActionCable the streams opened in
-    # initiate_connection dispatch into handle_received_message. Under AnyCable anycable-go holds
-    # the streams and delivers them straight to the socket, so this process never sees a room
-    # message: acknowledgements, room_opened, and room_closed are invisible here, and none of the
-    # on_* callbacks can fire.
-    def hears_room?
-      !@cable_channel.anycable_channel?
-    end
-
-    # Whether the room has acknowledged this port, as far as this process can tell. Under
-    # ActionCable that is the acknowledgement itself. Under AnyCable the acknowledgement went to
-    # the socket, so the most this process knows is that hello went out; the browser, which does
-    # see port_acknowledged, owns the retry (README "Using AnyCable").
-    def presumed_established?
-      hears_room? ? @has_established : @hello_received
-    end
-
-    # Whether client input can be handed to the room. Under ActionCable input waits for the
-    # acknowledgement, because until then the room has no port to attribute it to. Under AnyCable
-    # it goes as soon as hello has: hello's port_connected and the input travel the same Bus
-    # channel from the same process, so the room sees them in that order, and a room that doesn't
-    # exist yet drops both the way ActionCable would have dropped the input.
-    def accepts_input?
-      !left? && presumed_established?
-    end
-
-    # What MembershipStore::AnyCable writes into the channel state: enough to rebuild this
-    # membership on a later RPC call (see .restore). Callbacks are procs and can't go; `extra`
-    # travels in the ActiveJob-serialized form the room deserializes, which needs no lookup here.
-    def persisted_identity
-      {
-        "token" => @token,
-        "room_class" => room_class.name,
-        "room_key" => @room_key,
-        "tags" => @tags,
-        "extra" => serialized_extra,
-        "create" => @allow_create,
-        "hello_received" => @hello_received,
-        "tenant" => @tenant,
-      }
-    end
-
-    # The inverse of #persisted_identity, for a channel instance anycable-rails built for one RPC
-    # call. The result can hello!, ping!, leave!, and forward input with the token the subscribe
-    # call created. It does not open streams (anycable-go still holds the ones subscribe opened)
-    # and does not announce itself (only hello! does); it carries no callbacks.
-    def self.restore(cable_channel, record)
-      membership = allocate
-      membership.send(:restore_from, cable_channel, record)
-      membership
-    end
-
-    # The client has said hello: its subscription is confirmed, so every stream this membership
-    # opened is live and the room's acknowledgement has somewhere to land. This is the only thing
-    # that lets port_connected go out — a membership that never hears hello never announces.
-    #
-    # Hello is remembered for the life of the membership, across rejoin!: the browser says it
-    # once per subscription, and a rejoin happens server-side without the browser knowing.
-    def hello!
-      return if left?
-
-      ActiveSupport::Notifications.instrument(
-        "hello_received.cable_room",
-        { membership: self, room_class: room_class, room_key: @room_key, channel: @cable_channel }
-      ) do
-        @hello_received = true
-        # Under AnyCable the next call starts from a fresh channel; it has to know hello happened.
-        @cable_channel._room_memberships.persist!
-        # A repeated hello re-announces, which is harmless: port_connected is idempotent room-side.
-        transmit_port_connected
-      end
-    end
-
     def ping!
       return if left?
-      if presumed_established?
-        # The room already heard from us if we sent anything since the last interval; the next
-        # ping lands within 2 x PING_INTERVAL of that, well inside PORT_TIMEOUT.
+      if @has_established
         port_transmit(room_class::ROOM_IN_CHANNEL, { type: 'port_ping' }, secure_context: true) unless recently_transmitted?
-      elsif @hello_received
-        # Announced but never acknowledged: 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 RoomProxyChannel#receive), so re-announce instead of
-        # pinging: port_connected is idempotent on the room side (the port is merged, user_joined
-        # fires only once). Before hello there is nothing to heal — the client isn't ready.
+      else
         transmit_port_connected
       end
       @mutex.synchronize do
@@ -297,6 +143,7 @@ module CableRoom
       @mutex.synchronize do
         return if left?
 
+        stop_reannouncing
         close_streamed_ports!
         @cable_channel._room_memberships.delete(self)
         port_transmit(room_class::ROOM_IN_CHANNEL, { type: 'port_disconnected' }, secure_context: true)
@@ -316,6 +163,22 @@ module CableRoom
 
     def key; @room_key; end
 
+    # @internal
+    def streams_live!
+      @streams_live = true
+    end
+
+    # @internal
+    def transmit_port_connected
+      msg = {
+        type: 'port_connected',
+        tags: @tags,
+      }
+      msg[:extra] = ::ActiveJob::Arguments.serialize([@extra]) if @extra
+      port_transmit(room_class::ROOM_IN_CHANNEL, msg, secure_context: true)
+      schedule_reannounce
+    end
+
     # -- The member side of Ports ---------------------------------------------------------------
 
     # Everything a member sends goes to its room, so it's published on the room's Bus channel for
@@ -337,13 +200,8 @@ module CableRoom
       @last_transmit_at = monotonic_now unless type == :port_ping
     end
 
-    # Room→member traffic arrives on ActionCable streams (the broadcaster publishes to them), so
+    # Room→member traffic arrives on ActionCable streams (the room broadcasts to them), so
     # listening on a port is a plain stream_from on the member's channel.
-    #
-    # Subscribing is asynchronous: anything published to the port before the pubsub adapter
-    # confirms the subscription can be lost. ActionCable confirms the channel subscription to the
-    # client only after every stream is live, which is why members wait for the client's `hello`
-    # (see #hello!) rather than announcing themselves from here.
     def stream_port(port, auto_close: true, &blk)
       @cable_channel.stream_from(room_port_key(port), coder: ActiveSupport::JSON, &blk)
       _streamed_ports << port if auto_close
@@ -358,6 +216,48 @@ module CableRoom
 
     protected
 
+    # Re-announce until the room acknowledges the port, doubling the wait each time. Handing off
+    # to ping! at PING_INTERVAL keeps a stuck membership from holding a timer open forever.
+    #
+    # The timer is a plain Concurrent::ScheduledTask, not the Host's scheduler: in :remote a web
+    # process has no Host, and the member side must never need one.
+    def schedule_reannounce
+      @mutex.synchronize do
+        cancel_reannounce
+        return if @has_established || @has_left
+        return if Host.current&.shutdown?
+
+        next_delay = @reannounce_delay ? @reannounce_delay * 2 : RoomMember::REANNOUNCE_INITIAL_DELAY
+        return if next_delay > RoomMember::PING_INTERVAL
+
+        @reannounce_delay = next_delay
+
+        # async_exec runs the block with `instance_exec` against the channel, so hold onto the
+        # membership rather than relying on `self`.
+        membership = self
+        channel = @cable_channel
+        @reannounce_job = Concurrent::ScheduledTask.execute(@reannounce_delay.to_f) do
+          channel.connection.worker_pool.async_exec(channel, connection: channel.connection) do
+            membership.transmit_port_connected unless membership.connected? || membership.left?
+          end
+        end
+      end
+    end
+
+    def cancel_reannounce
+      @mutex.synchronize do
+        @reannounce_job&.cancel
+        @reannounce_job = nil
+      end
+    end
+
+    def stop_reannouncing
+      @mutex.synchronize do
+        cancel_reannounce
+        @reannounce_delay = nil
+      end
+    end
+
     def recently_transmitted?
       @last_transmit_at && (monotonic_now - @last_transmit_at) < RoomMember::PING_INTERVAL
     end
@@ -378,12 +278,13 @@ module CableRoom
         # A re-announced port (see ping!) is re-acknowledged; only the first one is a join.
         first_acknowledgement = !@has_established
         @has_established = true
+        stop_reannouncing
         @on_joined&.call(self) if first_acknowledgement
       when 'room_opened'
-        # The room we were waiting for just came up. Announce again if the client is ready;
-        # before hello the announcement waits for hello itself, and a premature one would be
-        # acknowledged into a stream the client isn't listening on yet.
-        transmit_port_connected if @hello_received
+        # Only safe once our own streams are confirmed; otherwise the room may acknowledge on the
+        # private port before anyone is listening. If we are not live yet, the subscription
+        # confirmation hook will announce for us.
+        transmit_port_connected if @streams_live
         @on_room_opened&.call(self)
       when 'room_closed'
         leave!
@@ -403,14 +304,9 @@ module CableRoom
 
         @token = SecureRandom.hex(16)
         @has_established = false
+        stop_reannouncing
         @cable_channel._room_memberships << self
 
-        # Subscribing is asynchronous, and the room acknowledges on the private @token stream. We
-        # never announce here: port_connected waits for the client's hello (see hello!), which
-        # only arrives after ActionCable has confirmed the subscription — that is, after every one
-        # of these streams is live. A rejoin! is the exception: hello already happened for this
-        # socket, so announce now and let ping! repeat it if the room misses it.
-
         # Listen to public/broadcast channel
         stream_port(room_class::ROOM_OUT_CHANNEL) do |message|
           handle_received_message(message)
@@ -436,81 +332,49 @@ module CableRoom
 
         @preconfigure&.call(self)
 
-        transmit_port_connected if @hello_received
+        # Announcing here races the async stream subscriptions: the room can acknowledge on the
+        # private port before it is live and the ack is lost. transmit_subscription_confirmation
+        # announces instead, once every stream is confirmed.
 
         maybe_provision_room
       end
     end
 
-    def restore_from(cable_channel, record)
-      @mutex = Monitor.new
-      @has_left = false
-      # Never learned here (see #hears_room?); the browser sees the acknowledgement instead.
-      @has_established = false
-
-      @cable_channel = cable_channel
-      @room_class = record.fetch("room_class").constantize
-      @room_key = record.fetch("room_key")
-      @token = record.fetch("token")
-      @tags = Array(record["tags"]).map(&:to_sym)
-      @serialized_extra = record["extra"]
-      @allow_create = record["create"] == true
-      @hello_received = record["hello_received"] == true
-      @tenant = record["tenant"]
-    end
-
-    def transmit_port_connected
-      msg = {
-        type: 'port_connected',
-        tags: @tags,
-      }
-      msg[:extra] = serialized_extra if serialized_extra
-      port_transmit(room_class::ROOM_IN_CHANNEL, msg, secure_context: true)
-    end
-
-    # `extra` as the room receives it. Serialized once: a restored membership only ever has this
-    # form (see #persisted_identity), a fresh one builds it from what join_room was given.
-    def serialized_extra
-      return @serialized_extra if defined?(@serialized_extra)
-
-      @serialized_extra = @extra ? ::ActiveJob::Arguments.serialize([@extra]) : nil
-    end
-
-    # Ask the rooms hosts to start our room if `create: true` asked for it and nobody has
-    # acknowledged us yet. This never starts a room in the member's process: it publishes a
-    # `provision` request on the Bus, and every Host (the web process's own in :inline, the
-    # `cable_room server` fleet in :remote) hears it and races for the room's lock, the least
-    # loaded one first (see CableRoom::Placement). One code path, both modes.
-    #
-    # Called at join and again on every ping until the room acknowledges the port, so a lost
-    # request costs at most one ping interval, and a room whose host died comes back on the next
-    # ping from any member. Once acknowledged the room plainly exists, so we stop asking.
+    # Start the room if `create: true` asked for it and nobody runs it yet. Called at join and
+    # again on every ping, so a room whose host died comes back.
     def maybe_provision_room
       return if left?
       return unless @allow_create
-      return if @has_established
+      return request_remote_room if CableRoom.remote?
+      return if Host.current&.shutdown?
 
-      if CableRoom.config.inline?
-        # In :inline this process hosts rooms itself, so make sure its Host is up and listening
-        # before asking; otherwise the very first request in a fresh process would go unheard.
-        return if Host.instance.shutdown?
-      end
+      @room_class.ensure(@room_key)
+    end
 
+    # In :remote this process never hosts rooms, so `create: true` asks the rooms Hosts to start
+    # it: a provision request on the Bus, which every rooms Host's Placement hears and races for,
+    # the least-loaded first (see Host::Placement). Called at join and on every ping, even once the
+    # room has acknowledged the port, the same as `ensure` on every ping in :inline: a rooms
+    # process that dies sends no room_closed, and this is what brings its rooms back within one
+    # ping. While the room runs it costs one publish per member per ping, and a single-attempt lock
+    # try on each rooms Host that isn't running it (the one that is skips the request).
+    #
+    # The request names our tenant, since a rooms process has no request tenant of its own: the
+    # Host that claims the room starts it there, so its lock, inbound channel, and stream names
+    # match the ones this member uses.
+    def request_remote_room
       request = {
-        type: "provision",
+        type: Host::Placement::REQUEST_TYPE,
         room_class: room_class.name,
         # Keys travel the way `extra` does, so a record key arrives on the host as the record
         room_key: ::ActiveJob::Arguments.serialize([@room_key]),
+        tenant: CableRoom.current_tenant,
         requested_at: Time.current,
-        # Whatever `join_room` was given for `tenant:` (nil for a single-tenant app). The Host has
-        # no request of its own to derive this from, so a multi-tenant app has to hand it over
-        # explicitly here rather than have the Runner guess at ambient state (see Runner#initialize).
-        tenant: @tenant,
       }
 
       ActiveSupport::Notifications.instrument(
         "provision_requested.cable_room",
-        { membership: self, room_class: room_class, room_key: @room_key, channel: @cable_channel, request: request }
+        { membership: self, room_class: room_class, room_key: @room_key, tenant: request[:tenant], request: request }
       ) do
         CableRoom.bus.publish(Bus.provision_channel, request)
       end

data/lib/cable_room/room_proxy_channel.rb

@@ -13,17 +13,12 @@ module CableRoom
       @room_membership = subscribe_to_room
     end
 
-    # The channel's actions are `hello` and `ping` (inherited from RoomMember: the client performs
-    # hello once its subscription is confirmed, and the membership announces itself to the room)
-    # and `receive`, which pipes everything else the client sends into the room. Until the room
-    # has acknowledged the membership (or, under AnyCable, until hello has gone out — see
-    # RoomMembership#accepts_input?) there is nowhere for input to go, so it is dropped.
     def receive(data)
-      room_membership << data if room_membership&.accepts_input?
+      @room_membership << data if @room_membership&.connected?
     end
 
     def unsubscribed
-      room_membership&.leave!
+      @room_membership&.leave!
     end
 
     protected
@@ -32,12 +27,6 @@ module CableRoom
       raise NotImplementedError
     end
 
-    # The membership `subscribed` created. Under AnyCable this channel instance may not be the one
-    # that ran `subscribed`, so fall back to the memberships rebuilt from the channel state.
-    def room_membership
-      @room_membership ||= room_memberships.first
-    end
-
     def join_room(*args, **kwargs, &blk)
       kwargs[:forward] = true
       super

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.7.0.beta3".freeze
+  VERSION = "0.8.0.beta2".freeze
 end