cable_room 0.7.0.beta3 → 0.8.0.beta2

data/lib/cable_room.rb

@@ -4,28 +4,27 @@ require 'active_support/time'
 require 'active_support/core_ext/module'
 
 require 'action_cable'
+require 'concurrent'
 require 'redlock'
 require 'rufus-scheduler'
 
-require_relative 'cable_room/railtie'
 require_relative 'cable_room/config'
-require_relative 'cable_room/broadcaster'
+require_relative 'cable_room/railtie'
 
 require_relative 'cable_room/bus'
 
 require_relative 'cable_room/periodic_timer'
-require_relative 'cable_room/snapshot'
 require_relative 'cable_room/host'
-require_relative 'cable_room/placement'
-require_relative 'cable_room/migration'
 require_relative 'cable_room/ports'
-require_relative 'cable_room/membership_store'
 require_relative 'cable_room/room_member'
 require_relative 'cable_room/room_proxy_channel'
 require_relative 'cable_room/room/'
 require_relative 'cable_room/version'
 
 module CableRoom
+  BUS_LOCK = Mutex.new
+  private_constant :BUS_LOCK
+
   class << self
     # Called as `handler.call(error, context)` whenever work inside a Room raises. Rooms swallow
     # exceptions so that one bad message can't kill the Room, which makes this the only way to
@@ -44,25 +43,29 @@ module CableRoom
       warn "CableRoom.error_handler raised #{handler_error.class}: #{handler_error.message}"
     end
 
-    # The active CableRoom::Config. Built on first use with the defaults plus any env
-    # overrides, so an app that never calls `configure` still gets a valid config.
-    def config
-      @config ||= Config.new.apply_env_overrides.validate!
+    # The Apartment tenant the calling thread is in, or nil in an app without Apartment
+    def current_tenant
+      Apartment::Tenant.current if defined?(Apartment)
     end
 
-    # Yields the config so an app can set the knobs, then re-applies the env overrides
-    # (CABLE_ROOM_HOST, CABLE_ROOM_BROADCASTER) and checks every value. Bad values raise
-    # here, at boot, instead of somewhere deep in a room later.
-    def configure
-      cfg = @config || Config.new
-      yield cfg if block_given?
-      @config = cfg.apply_env_overrides.validate!
+    # Run the block switched into `tenant`. Does nothing extra when there's no tenant, no
+    # Apartment, or the thread is already in it, so an :inline join (which starts its room in its
+    # own tenant) never switches at all.
+    def with_tenant(tenant, &blk)
+      return yield if tenant.nil? || !defined?(Apartment) || Apartment::Tenant.current == tenant
+
+      Apartment::Tenant.switch(tenant, &blk)
     end
 
-    # Drops the current config so the next `config` call rebuilds it, which also makes
-    # `Broadcaster.current` rebuild (and forget any `Broadcaster.current=` override). Meant for specs.
-    def reset_config!
-      @config = nil
+    # Run the block inside the Rails app's executor (database connections, reloading, and so on),
+    # the way ActionCable wraps channel callbacks. Nesting is fine: the executor yields straight
+    # through when it's already active on this thread. Without Rails it just yields.
+    def with_app_executor(&blk)
+      if defined?(Rails) && Rails.application
+        Rails.application.executor.wrap(&blk)
+      else
+        yield
+      end
     end
 
     def redis_pool
@@ -80,30 +83,40 @@ module CableRoom
       ])
     end
 
-    # The process-wide Redis bus (see CableRoom::Bus). Built on first use.
+    # The process-wide Redis bus (see CableRoom::Bus). Built on first use. Guarded so two threads
+    # racing to it can't each build one: a handler registered on the loser would be stranded.
     def bus
-      @bus ||= Bus.new
+      @bus || BUS_LOCK.synchronize { @bus ||= Bus.new }
     end
 
     # Call this in a child process right after `fork`, before it touches Redis or hosts a room.
-    # `cable_room server --workers N` does it for every worker (see Host::Supervisor).
+    # `cable_room server --workers N` does it in every worker (see Host::Supervisor); an app that
+    # forks for its own reasons (Puma's `on_worker_boot` with `preload_app!`, a job runner) should
+    # call it there too.
+    #
+    # A forked child starts with copies of the parent's objects but only the forking thread, so
+    # anything that owns a thread or a socket is broken in the child: the Bus subscriber thread
+    # doesn't exist, a mutex may be held by a thread that's gone, and a Redis socket is shared
+    # with the parent, so both processes would read each other's replies. This drops the memos,
+    # so the next caller builds fresh ones:
     #
-    # A forked child starts with copies of the parent's objects but only one thread, so anything
-    # that owns a socket or a thread is broken in the child: the Bus subscriber thread doesn't
-    # exist, its mutex may be held by nobody, and a Redis socket is shared with the parent, so
-    # both processes would read each other's replies. Dropping the memos means the next caller
-    # builds fresh ones. The connection pool and redis-client also notice the fork on their own
-    # (both hook `Process._fork` and drop inherited sockets), and Rails does the same for
-    # ActiveRecord, so those need nothing from us; this keeps the gem's rule simple: nothing
-    # Redis-backed survives a fork.
+    #   * the Bus. The copy is only dropped, not shut down: its pub/sub socket is still the
+    #     parent's, and anything sent on it (even a TLS close_notify) would land in the parent's
+    #     session. GC closes the child's copy of the descriptor quietly.
+    #   * the Redlock client, whose monitor may be held by a parent thread.
+    #   * the Host, whose rooms, locks, and threads are the parent's. It's abandoned (see
+    #     Host#abandon!) so its `at_exit` hook can't close the parent's rooms when the child exits.
     #
-    # The Host goes too. A parent that forks workers must never host rooms itself, and a Host
-    # copied from a parent would have no worker threads and no scheduler thread behind it.
+    # Pooled connections need nothing from us. `redis_pool` is RediConn's shared pool for the
+    # URL (the same object comes back if we rebuild it), and connection_pool drops the connections
+    # it inherited on its own (it hooks `Process._fork`); redis-client also reconnects any client
+    # it finds in a new pid. Rails does the same for ActiveRecord (`PoolConfig.discard_pools!`
+    # runs after every fork), and its pools reconnect lazily on first use.
     def after_fork!
-      @bus = nil
+      BUS_LOCK.synchronize { @bus = nil }
       @lock_manager = nil
-      @redis_pool = nil
-      Host.replace_current(nil)
+      Host.replace_current(nil)&.abandon!
+      nil
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cable_room
 version: !ruby/object:Gem::Version
-  version: 0.7.0.beta3
+  version: 0.8.0.beta2
 platform: ruby
 authors:
 - Ethan Knapp
@@ -77,14 +77,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -106,24 +112,20 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - README.md
 - cable_room.gemspec
 - exe/cable_room
 - lib/cable_room.rb
-- lib/cable_room/broadcaster.rb
 - lib/cable_room/bus.rb
 - lib/cable_room/cli.rb
 - lib/cable_room/config.rb
 - lib/cable_room/host.rb
 - lib/cable_room/host/bus_inbound.rb
+- lib/cable_room/host/placement.rb
 - lib/cable_room/host/runner.rb
 - lib/cable_room/host/supervisor.rb
 - lib/cable_room/host/worker_pool.rb
-- lib/cable_room/membership_store.rb
-- lib/cable_room/migration.rb
 - lib/cable_room/periodic_timer.rb
-- lib/cable_room/placement.rb
 - lib/cable_room/ports.rb
 - lib/cable_room/railtie.rb
 - lib/cable_room/room.rb
@@ -137,13 +139,10 @@ files:
 - lib/cable_room/room/port_policies.rb
 - lib/cable_room/room/port_scoping.rb
 - lib/cable_room/room/reaping.rb
-- lib/cable_room/room/snapshotting.rb
 - lib/cable_room/room/threading.rb
 - lib/cable_room/room/user_management.rb
-- lib/cable_room/room_harness.rb
 - lib/cable_room/room_member.rb
 - lib/cable_room/room_proxy_channel.rb
-- lib/cable_room/snapshot.rb
 - lib/cable_room/version.rb
 homepage: https://instructure.com
 licenses: []

data/CHANGELOG.md

@@ -1,122 +0,0 @@
-# Changelog.
-
-## 1.0.0
-
-Rooms can now run in their own process pool, and browsers can be served by anycable-go. Every
-Room definition from 0.6 works unchanged. The channel and deployment contracts do change; the
-README's "Upgrading from 0.6 to 1.0" section is the checklist.
-
-### Breaking.
-
-- **Clients must send `hello`.** A membership no longer announces itself to the Room when the
-  channel subscribes. The browser performs `hello` once ActionCable confirms the subscription
-  (`connected()` in the JS client), and only then does `port_connected` go out. There is no
-  fallback: a client that never says `hello` receives broadcasts on the shared stream, but the
-  Room never sees it and everything it sends is dropped. Browser tabs open across the deploy
-  speak the old handshake and stay deaf until reloaded.
-- **`ChannelBase`, `ChannelTracker`, and `DummyConnection` are gone.** Rooms no longer run inside
-  a synthetic ActionCable channel. `CableRoom::Host` (one per process) and `Host::Runner` (one
-  per Room) own the work queue, worker pool, scheduler, Redlock renewal, watchdog, and shutdown.
-  Internal names apps may have reached for moved with them:
-  - inside a Room, `@cable_channel` is now `@runner` (a `Host::Runner`);
-  - the `CableRoom.error_handler` context key `channel:` is now `runner:` (with `room:`,
-    `room_class:`, and `room_key:` alongside it);
-  - `Room#params` is gone (it delegated to the synthetic channel, which had none);
-  - `ChannelTracker::BEAT_INTERVAL` is `Host::BEAT_INTERVAL`;
-  - `Room::ChannelAdapter` is `Room::HostAdapter`, and the `MyRoom::Channel` constant no longer
-    exists;
-  - `CableRoom::Room.locally_open_rooms` and `MyRoom.locally_running_instances` read from the
-    Host and return `[]` in a process that hosts no Rooms.
-- **Provisioning happens over the bus.** `join_room(..., create: true)` never starts a Room in
-  the member's process. It publishes a `provision` request (at join and on every ping until the
-  Room acknowledges the port), and one of the hosts starts the Room after a load-weighted
-  delay. `Room::Base.ensure` still starts a Room directly, but only in a process that hosts
-  Rooms: in a `room_host = :remote` web process it raises `CableRoom::Host::NotHosting`.
-- **Member→room traffic rides cable_room's own Redis.** Everything a member sends (`to_room`,
-  `port_connected`, `port_ping`, `port_disconnected`, custom ports) and `Room::Base.send_message`
-  publish on `CableRoom::Bus`, over the `CABLEROOM_*` connection. The Room side no longer
-  touches ActionCable pubsub for inbound. That connection must be reachable from every web
-  process and every rooms host.
-- **`redis` is a runtime dependency** (`>= 5.0`). It was a development dependency; rediconn
-  needed it all along, and the bus uses it directly.
-- **`PortManagement::PORT_TIMEOUT` is 45 seconds**, up from 30. A member that stops pinging
-  keeps its port 15 seconds longer.
-- **`room_closed` always carries a reason.** In 0.6 a close the host decided (process exit,
-  watchdog timeout, lost lock) sent `reason: nil`; only `shutdown!` from inside the Room set one.
-  Now the runner sets it too: `"Server shutting down"`, `"Watchdog timeout"`, the signal name on
-  a `cable_room server` drain, and the failure on a migration that closed instead of moving.
-- **Instrumentation payloads.** `error.cable_room` and the error handler get the new context
-  keys above. Every 0.6 event still fires with the same name.
-
-### Added.
-
-- `CableRoom.configure` / `CableRoom.config` (`CableRoom::Config`) with five knobs:
-  `room_host` (`:inline` | `:remote`), `broadcaster` (`:action_cable` | `:anycable`),
-  `provision_delay_ms` (20), `drain_timeout` (10 minutes), and `handoff_timeout` (10 seconds).
-  `CABLE_ROOM_HOST` and `CABLE_ROOM_BROADCASTER` override the first two, even when the block sets
-  them. Unknown values raise at boot and name the valid options. Defaults reproduce 0.6.
-- `CableRoom::Broadcaster`: room→member traffic goes through `ActionCableBroadcaster`
-  (`ActionCable.server.broadcast`, the default) or `AnyCableBroadcaster` (`AnyCable.broadcast`).
-  Stream names are identical in both. `anycable-rails` is optional; selecting `:anycable`
-  without it raises `Broadcaster::MissingDependency` naming the gem.
-- `CableRoom::Bus`: Redis pub/sub and the handoff storage on the `CABLEROOM_*` connection.
-  Channel names: `cr:{RoomClass:key}:in` (and `:in:{port}` for custom ports), `cr:provision`,
-  `cr:{RoomClass:key}:handoff`, `cr:{RoomClass:key}:snapshot`, `cr:{RoomClass:key}:adopted`.
-  `Room::Base.inbound_channel(key, port)` names a Room's inbound channel.
-- `CableRoom::Host`: `Host.current` (nil when the process hosts nothing), `Host.instance`,
-  `Host.start!`, `Host#open_ports` (the load gauge to scale on), `Host#open_rooms_count`,
-  `Host#drain!`, `Host.after_drain`, `Host::NotHosting`.
-- `cable_room server` (`exe/cable_room`, `CableRoom::CLI`): boots the Rails app in the current
-  directory (or `--require PATH`), refuses to run unless `room_host` is `:remote`, hosts Rooms
-  until SIGTERM or SIGINT, and migrates open Rooms to peers on the way out. `--workers N`
-  (default: core count) preloads the app and forks N single-GVL workers through
-  `Host::Supervisor`, which replaces a worker that dies (with a growing delay for one that dies
-  at boot), relays SIGTERM and SIGINT, and waits for every worker. `--version` prints the
-  version. `CableRoom.after_fork!` resets the bus, lock manager, Redis pool, and Host in a
-  forked child.
-- Load-weighted provisioning (`CableRoom::Placement`): every host hears each `provision`
-  request, waits `provision_delay_ms × (open_rooms + jitter)`, then races for the Redlock.
-  Exactly one wins. A draining host never claims.
-- Snapshot and restore: optional `snapshot_state` / `restore_state` hooks on a Room,
-  `restored?`, `CableRoom::Snapshot` (version 1, gem-owned ports, users, reaper deadlines, and
-  `app_state`), `Snapshot::NotSerializable` raised at snapshot time for non-JSON state, and
-  `Host#restore_room`. A restored Room runs `restore_state` instead of `startup` when it defines
-  it, and never broadcasts `room_opened`.
-- Live migration on planned shutdown (`CableRoom::Migration`): freeze → snapshot → offer (Redis,
-  60 second TTL) → peer adopts → relay and replay with per-stream markers → let go. Members keep
-  their streams and lose nothing. A Room nobody adopts within `handoff_timeout` closes with
-  `room_closed`; `drain_timeout` forces whatever is still waiting through. New lifecycle states
-  `:freezing` and `:frozen`.
-- Channel actions `hello` and `ping` on every `RoomMember` channel (and so on
-  `RoomProxyChannel`), plus the server-side `hello_room_memberships`, `RoomMembership#hello!`,
-  `#hello_received?`, `#accepts_input?`, and the protected `room_memberships` reader.
-- AnyCable channel state: `CableRoom::MembershipStore` keeps each membership's identity in
-  anycable-rails' `state_attr_accessor`, so `hello`, `receive`, `ping`, and `unsubscribed` work
-  across anycable-rails' per-call channel instances. Under plain ActionCable nothing changes.
-- New `ActiveSupport::Notifications` events: `hello_received.cable_room`,
-  `provision_requested.cable_room`, `provision_claimed.cable_room`, `room_snapshotted.cable_room`,
-  `room_restored.cable_room`, `host_draining.cable_room`, and `room_migrated.cable_room`.
-- CI: an `e2e-anycable` job runs `spec/e2e` against a real `anycable/anycable-go:1.6` under both
-  Appraisals. Locally it runs only with `CABLE_ROOM_E2E=1`.
-- `CHANGELOG.md` and `exe/` ship in the gem.
-
-### Changed.
-
-- `Room::Base.room_port_key` builds the stream name itself (`"RoomClass:key:port"`, records by
-  GlobalID). The format is the same one ActionCable produced in 0.6.
-- The ActionCable `restart` hook (development code reload) stops Rooms through the Host.
-- `RoomMembership#stream_port` takes `auto_close:`; the room-side `stream_port` takes `on_live:`.
-- The `Railtie` no longer declares empty `rake_tasks`, `console`, and `runner` blocks.
-- The README describes the 1.0 architecture: configuration, deployment modes, `cable_room
-  server`, provisioning, the hello handshake, AnyCable's browser contract, migration, every
-  instrumentation event, and the 0.6 → 1.0 upgrade guide.
-
-### Fixed.
-
-- The gemspec declares `redis`, which rediconn loads but never listed. An app that didn't have
-  `redis` in its own Gemfile could fail to boot with 0.6.
-
-## 0.6.2.beta1
-
-The last release before distributed rooms. Rooms ran inside a synthetic ActionCable channel in
-every process that joined them.

data/lib/cable_room/broadcaster.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module CableRoom
-  # How a Room pushes messages out to its members. Every room→member message (`from_room`, tag,
-  # user, and `mtok` streams, plus `Room::Base.send_message`) goes through one of these, so
-  # swapping the transport is a config change, not a code change.
-  #
-  # `CableRoom.config.broadcaster` picks the implementation:
-  #
-  #   :action_cable  -> ActionCableBroadcaster (the default; today's behavior)
-  #   :anycable      -> AnyCableBroadcaster (needs the optional `anycable-rails` gem)
-  #
-  # Every broadcaster answers `broadcast(stream, payload)`. Specs can swap in a recording fake
-  # with `Broadcaster.current = fake`; `CableRoom.reset_config!` drops it again.
-  module Broadcaster
-    # Raised when the config asks for a broadcaster whose gem isn't in the bundle.
-    class MissingDependency < LoadError; end
-
-    class << self
-      # The broadcaster the current config selects. Built once per config object and reused,
-      # so `CableRoom.reset_config!` or `CableRoom.configure` picks up a fresh one on the next
-      # call without anyone having to remember to clear a cache.
-      def current
-        config = CableRoom.config
-        return @current if @current && @current_config.equal?(config)
-
-        @current_config = config
-        @current = build(config.broadcaster)
-      end
-
-      # Replace the broadcaster for the life of the current config object. Meant for specs that
-      # need a fake without rspec-mocks; `CableRoom.reset_config!` builds a new config, which
-      # makes `current` rebuild from it and forget this one.
-      def current=(broadcaster)
-        @current_config = CableRoom.config
-        @current = broadcaster
-      end
-
-      # Builds the broadcaster named by `name`. Config already rejects unknown names, so the
-      # `else` branch only fires if someone bypasses config.
-      def build(name)
-        case name&.to_sym
-        when :action_cable
-          ActionCableBroadcaster.new
-        when :anycable
-          AnyCableBroadcaster.new
-        else
-          raise ArgumentError,
-                "CableRoom broadcaster must be one of #{Config::BROADCASTERS.map(&:inspect).join(', ')} " \
-                "(got #{name.inspect})"
-        end
-      end
-    end
-
-    # Publishes through the ActionCable server, which hands the message to whatever pubsub
-    # adapter the app configured (Redis, async, ...).
-    class ActionCableBroadcaster
-      def broadcast(stream, payload)
-        ActionCable.server.broadcast(stream, payload)
-      end
-    end
-
-    # Publishes through `AnyCable.broadcast`, so anycable-go fans the message out to sockets.
-    # Stream names are the same ones ActionCableBroadcaster uses, so a member subscribed through
-    # anycable-go sees the same traffic it would through ActionCable.
-    #
-    # `anycable-rails` is optional at runtime: it's only loaded when this broadcaster is built, and
-    # a missing gem raises MissingDependency naming what to add.
-    #
-    # Payload encoding: `ActionCable.server.broadcast` runs every message through its coder
-    # (ActiveSupport::JSON by default) and hands the pubsub adapter a JSON string; anycable-rails's
-    # own ActionCable adapter forwards that string to `AnyCable.broadcast` untouched, and
-    # anycable-go expects the `data` field to be a pre-encoded string. So we encode here with the
-    # same coder, and a member decodes the message exactly as it would from ActionCable.
-    class AnyCableBroadcaster
-      CODER = ActiveSupport::JSON
-      GEM_NAME = "anycable-rails"
-
-      class << self
-        # Loads AnyCable on first use. `anycable` (a dependency of anycable-rails) is what defines
-        # `AnyCable.broadcast`; requiring it rather than `anycable-rails` avoids re-running the
-        # Rails integration in a process that already booted without it.
-        def ensure_loaded!
-          return if defined?(::AnyCable) && ::AnyCable.respond_to?(:broadcast)
-
-          begin
-            require "anycable"
-          rescue LoadError
-            raise MissingDependency,
-                  "CableRoom broadcaster :anycable needs the #{GEM_NAME} gem. " \
-                  "Add `gem \"#{GEM_NAME}\"` to your Gemfile, or set broadcaster to :action_cable."
-          end
-        end
-      end
-
-      def initialize
-        self.class.ensure_loaded!
-      end
-
-      def broadcast(stream, payload)
-        publish(stream, encode(payload))
-      end
-
-      protected
-
-      # The one call that leaves the process. Fakes override this to record instead of publish.
-      def publish(stream, encoded_payload)
-        ::AnyCable.broadcast(stream, encoded_payload)
-      end
-
-      def encode(payload)
-        CODER.encode(payload)
-      end
-    end
-  end
-end

data/lib/cable_room/membership_store.rb

@@ -1,105 +0,0 @@
-module CableRoom
-  # Where a channel keeps its RoomMemberships between calls. `RoomMember#_room_memberships` is one
-  # of these, and RoomMembership adds and removes itself from it.
-  #
-  # Under ActionCable the channel object lives as long as the socket, so an in-memory set is the
-  # whole story: this base class. Under anycable-rails every RPC call (subscribe, message,
-  # unsubscribe, disconnect) builds a fresh channel instance and never re-runs `subscribed`, so an
-  # in-memory set is empty by the time `hello` or `receive` arrive. The AnyCable subclass writes
-  # each membership's identity into the channel's AnyCable state, which anycable-go hands back on
-  # every call, and rebuilds the memberships from it on first use.
-  class MembershipStore
-    include Enumerable
-
-    def self.for(channel)
-      channel.anycable_channel? ? AnyCable.new(channel) : new(channel)
-    end
-
-    def initialize(channel)
-      @channel = channel
-      @memberships = Set.new
-    end
-
-    def <<(membership)
-      memberships << membership
-      persist!
-      self
-    end
-
-    def delete(membership)
-      memberships.delete(membership)
-      persist!
-    end
-
-    def clear
-      memberships.clear
-      persist!
-    end
-
-    def each(&blk)
-      memberships.each(&blk)
-    end
-
-    def to_a
-      memberships.to_a
-    end
-
-    def empty?
-      memberships.empty?
-    end
-
-    def size
-      memberships.size
-    end
-
-    # Write the memberships back to wherever they live. Call it after changing something about a
-    # membership that has to survive the call (RoomMembership#hello! does). In memory there is
-    # nothing to do.
-    def persist!; end
-
-    protected
-
-    def memberships
-      @memberships
-    end
-
-    # The anycable-rails flavor: the memberships also live in the channel's AnyCable state
-    # (`state_attr_accessor`), as one JSON string of RoomMembership#persisted_identity records.
-    #
-    # One string rather than an array of hashes because anycable-rails runs every value in the
-    # state through its own serializer, which locates any GlobalID-looking string through the
-    # database. The `extra` a member joined with is ActiveJob-serialized and may well contain one,
-    # and the room is the only party that should deserialize it. Encoding the records ourselves
-    # keeps that serializer out of them.
-    class AnyCable < MembershipStore
-      STATE_ATTRIBUTE = :_cable_room_memberships
-
-      def persist!
-        # The accessor is private on the channel (see RoomMember) so it can't be performed as a
-        # channel action; `send` is deliberate.
-        @channel.send(:"#{STATE_ATTRIBUTE}=", ActiveSupport::JSON.encode(memberships.map(&:persisted_identity)))
-      end
-
-      protected
-
-      # Rebuild on first use, whatever the use is. The subscribe call that creates the first
-      # membership finds nothing to rebuild; every later call finds what subscribe (and hello)
-      # wrote. Restored memberships are added straight to the set: they exist already as far as
-      # anycable-go is concerned, so there is nothing to persist and no stream to open.
-      def memberships
-        restore! unless @restored
-        super
-      end
-
-      def restore!
-        @restored = true
-        raw = @channel.send(STATE_ATTRIBUTE)
-        return if raw.blank?
-
-        ActiveSupport::JSON.decode(raw).each do |record|
-          @memberships << RoomMembership.restore(@channel, record)
-        end
-      end
-    end
-  end
-end