cable_room 0.7.0.beta3 → 0.8.0.beta1

data/lib/cable_room/host/worker_pool.rb

@@ -1,50 +1,37 @@
-require 'concurrent'
-
 module CableRoom
   class Host
-    # The thread pool every room's work runs on. Deliberately *not* an ActionCable::Server::Worker
-    # subclass: that would put Room work on the same shared `:work` callback chain as ordinary
-    # ActionCable connections, and that chain is leaky by construction -- `ActiveSupport::Callbacks`
-    # re-injects a callback added to the base class into every existing descendant regardless of
-    # load order, so an app's own tenant-switching hook (PandaPal's, say, registered from a Rails
-    # initializer well after this class is defined) ends up wrapping Room work too, whether we want
-    # it to or not. Owning a distinct namespace here avoids that category of problem entirely:
-    # nothing outside cable_room can attach to Room work by surprise. The one seam an app gets is
-    # a Room's own `before_work`/`after_work`/`around_work` (see Room::Callbacks and
-    # Host::Runner#with_room_context).
-    class WorkerPool
-      attr_reader :executor
-
-      def initialize(max_size: 5)
-        @executor = Concurrent::ThreadPoolExecutor.new(
-          name: "CableRoom",
-          min_threads: 1,
-          max_threads: max_size,
-          max_queue: 0,
-        )
+    # The thread pool every room's work runs on. It's an ActionCable Worker so the `:work`
+    # callbacks Rails installs (the executor wrap, ActiveRecord log tagging) still apply to room
+    # work exactly as they did when rooms were channels.
+    #
+    # The "connection" passed around here is the room's Host::Runner. ActionCable's Worker was
+    # written for connections; rooms don't have one, but the runner fills the same role: it's
+    # the thing with a logger and an error reporter.
+    class WorkerPool < ActionCable::Server::Worker
+      set_callback :work, :around do |_, blk|
+        pconn = ActionCable::Server::Worker.connection
+        ActionCable::Server::Worker.connection = connection
+        blk.call
+      ensure
+        ActionCable::Server::Worker.connection = pconn
       end
 
-      # Reduces every exception to a proper report instead of ActionCable's Worker#invoke, which
-      # logs a line and calls a no-argument `handle_exception`, discarding the error itself. Rooms
-      # run all of their work through here, so report it properly. `connection:` is always a
-      # Host::Runner in practice (see Runner#post_work); the else branch is a defensive fallback.
+      # ActionCable's Worker#invoke reduces every exception to a log line and a no-argument
+      # `handle_exception` call, which discards the error itself. Rooms run all of their work
+      # through here, so report it properly instead.
       def invoke(receiver, method, *args, connection:, &block)
-        receiver.send method, *args, &block
-      rescue Exception => e
-        if connection.respond_to?(:report_work_error)
-          connection.report_work_error(e)
-        else
-          logger.error "There was an exception - #{e.class}(#{e.message})"
-          logger.error Array(e.backtrace).join("\n")
-          CableRoom.report_error(e, connection: connection)
+        work(connection) do
+          receiver.send method, *args, &block
+        rescue Exception => e
+          if connection.respond_to?(:report_work_error)
+            connection.report_work_error(e)
+          else
+            logger.error "There was an exception - #{e.class}(#{e.message})"
+            logger.error Array(e.backtrace).join("\n")
+            CableRoom.report_error(e, connection: connection)
+          end
         end
       end
-
-      private
-
-      def logger
-        ActionCable.server.logger
-      end
     end
   end
 end

data/lib/cable_room/host.rb

@@ -1,8 +1,6 @@
-require 'socket'
 require_relative 'host/worker_pool'
-require_relative 'host/bus_inbound'
+require_relative 'host/action_cable_inbound'
 require_relative 'host/runner'
-require_relative 'host/supervisor'
 
 module CableRoom
   # One Host per process. It owns every Room running here: the worker pool their work runs on,
@@ -15,112 +13,26 @@ module CableRoom
   class Host
     BEAT_INTERVAL = 5.seconds
 
-    # Raised when a process that doesn't host rooms asks for its Host. With `room_host = :remote`
-    # only `cable_room server` hosts rooms; a web process must never start one.
-    class NotHosting < StandardError; end
-
-    NOT_HOSTING_MESSAGE =
-      "This process doesn't host rooms: CableRoom.config.room_host is :remote, so rooms run " \
-      "under `cable_room server`. Start rooms there (or call CableRoom::Host.start! first if this " \
-      "process really should host them).".freeze
-
-    @start_mutex = Mutex.new
-
     class << self
-      # The Host this process runs, or nil when it runs none (a web process in :remote, or an
-      # :inline process that hasn't started a room yet). Use this for introspection and cleanup,
-      # where "no rooms here" is a normal answer.
-      def current
-        @current
-      end
-
-      # The Host this process runs. In :inline every process hosts rooms, so the first caller
-      # builds it. In :remote only a process that declared itself a rooms host with `start!`
-      # (`cable_room server`) has one; anyone else gets NotHosting, so a room can never quietly
-      # start in the web tier because some code path reached for the Host.
       def instance
-        current || (CableRoom.config.inline? ? start! : raise(NotHosting, NOT_HOSTING_MESSAGE))
-      end
-
-      # Make this process a rooms host. Builds the Host once and starts its provisioning listener,
-      # so this process hears `create: true` requests from then on; later calls return the same
-      # Host. `cable_room server` calls this explicitly; in :inline `instance` calls it for you.
-      def start!
-        @start_mutex.synchronize { @current ||= new.tap(&:start_placement) }
-      end
-
-      # Swap this process's Host for `host` (nil allowed) and return the previous one. Only specs
-      # that play two process roles in one Ruby process should need this (see RoomHostHarness):
-      # the "web" side has to see no Host while another Host runs the rooms.
-      def replace_current(host)
-        @start_mutex.synchronize { @current.tap { @current = host } }
-      end
-    end
-
-    # How many rooms `drain!` hands off at once before `drain_timeout`. Each handoff costs the
-    # adopting peer a full room restore (its startup chain, often database reads), so a host with
-    # hundreds of rooms must not offer them all in the same second; and each one holds a thread
-    # here for up to `handoff_timeout`. Four keeps a big host draining in well under the default
-    # ten minutes (a handoff normally takes well under a second) without swamping the fleet.
-    DRAIN_CONCURRENCY = 4
-
-    # What `drain!` returns: how the rooms ended up, and how long it took. `migrated` and
-    # `closed` are Migration objects (see their `state` and `room`).
-    DrainResult = Struct.new(:reason, :migrated, :closed, :duration, keyword_init: true) do
-      def rooms
-        migrated.size + closed.size
+        @instance ||= new
       end
     end
 
-    attr_reader :scheduler, :inbound, :placement
-
-    # True once this host has started shutting down for good and is handing its rooms off (see
-    # `drain!`). A draining host never claims a provision request, so it can't take on a room it
-    # would only have to hand off again.
-    attr_writer :draining
+    attr_reader :scheduler, :inbound
 
     delegate :logger, to: :cable_server
 
-    class << self
-      # Register a block to run when a `drain!` finishes, with the Host and its DrainResult. An
-      # app that scales in through an ASG termination lifecycle hook completes the hook here
-      # (`complete-lifecycle-action`), once every room has moved or closed. Blocks run on the
-      # draining thread before `drain!` returns; one that raises is reported and doesn't stop
-      # the others.
-      def after_drain(&blk)
-        raise ArgumentError, "after_drain needs a block" unless blk
-        after_drain_callbacks << blk
-        blk
-      end
-
-      def after_drain_callbacks
-        @after_drain_callbacks ||= []
-      end
-    end
-
-    # `inbound` is how rooms receive messages: by default the process-wide Bus, so a room hears
-    # its members the same way whether it runs inside the web process or on a remote host.
-    def initialize(inbound: BusInbound.new)
+    # `inbound` is how rooms receive messages. Anything with ActionCableInbound's two methods works.
+    def initialize(inbound: ActionCableInbound.new)
       @runners = Set.new
       @monitor = Monitor.new
       @inbound = inbound
-      @draining = false
-      @drain_result = nil
-      @drain_thread = nil
-      @migrations = []
       @scheduler = Rufus::Scheduler.new
 
-      # A rooms host that leaves with rooms still open (a crash on the main thread, say; on a
-      # SIGTERM `cable_room server` has already drained by now, so this is a no-op) gives them
-      # the same chance to move as a planned shutdown would. In :inline there is no fleet of
-      # peers by design (see `drain!`), so exit closes rooms the way it always has.
       at_exit do
         logger.info "Shutting down CableRoom"
-        if CableRoom.config.remote? && !shutdown? && runners.any?
-          drain!(reason: "process exit")
-        else
-          shutdown!
-        end
+        shutdown!
       end
 
       # Every few seconds each room renews its Redlock and checks its watchdog
@@ -130,118 +42,20 @@ module CableRoom
     end
 
     def worker_pool
+      # TODO Pin Rooms to a specific thread so that they never have to worry about thread safety?
       @worker_pool || @monitor.synchronize do
         @worker_pool ||= WorkerPool.new(max_size: cable_server.config.worker_pool_size)
       end
     end
 
-    # Start `room_class`'s room for `key` on this Host if nobody else is running it. Takes the
-    # room's Redlock first, so exactly one process cluster-wide wins; returns false when the lock
-    # is already held. This is the host-side way to bring a room up: `Room::Base.ensure` calls it
-    # on the process Host, Placement calls it for a provision request, and `cable_room server`
-    # (or a spec harness) can call it on a Host it owns without any member asking.
-    #
-    # If a snapshot of the room is on offer (another host is handing it off, see
-    # CableRoom::Migration), winning the lock means adopting it: the room comes back here with
-    # its members and state rather than starting fresh underneath the old host. The check is
-    # made after the lock is won, so it can't be raced. `handoff_only: true` (a handoff request)
-    # starts nothing when there is no snapshot to adopt — it has expired, or the old host took
-    # the room back — and lets the lock go.
-    def ensure_room(room_class, key = nil, handoff_only: false, tenant: nil)
-      lock_key = room_class.room_port_key(key)
-      lock_info = CableRoom.lock_manager.lock(lock_key, room_class::LOCK_DURATION.in_milliseconds)
-      return false unless lock_info
-
-      snapshot = bus.get(Bus.snapshot_key(lock_key))
-      return Migration.adopt(self, room_class, key, lock_info: lock_info, snapshot: snapshot) if snapshot
-
-      if handoff_only
-        logger.info "No snapshot to adopt for #{lock_key}; letting the lock go"
-        CableRoom.lock_manager.unlock(lock_info)
-        return false
-      end
-
-      start_room(
-        room_class,
-        key,
-        lock_info,
-        watchdog_interval: room_class::WATCH_DOG_INTERVAL,
-        lock_duration: room_class::LOCK_DURATION,
-        tenant: tenant,
-      )
-
-      true
-    rescue => e
-      CableRoom.lock_manager.unlock(lock_info) if lock_info
-      raise e
-    end
-
-    # Start running a room here. The caller (`ensure_room`) has already taken the room's Redlock;
-    # the runner renews it from now on and releases it when the room dies. `tenant:` comes from the
-    # member's provision request (see RoomMembership#initialize / #maybe_provision_room and
-    # Placement#claim), already defaulted there to the ambient tenant if the app didn't pass one
-    # explicitly -- nil past that point just means no Apartment multi-tenancy is in play.
-    def start_room(room_class, key, lock_info, watchdog_interval:, lock_duration:, tenant: nil)
-      runner = Runner.new(self, room_class, key, lock_info, watchdog_interval:, lock_duration:, tenant:)
+    # Start running a room here. The caller (Room::Base.ensure) has already taken the room's
+    # Redlock; the runner renews it from now on and releases it when the room dies.
+    def start_room(room_class, key, lock_info, watchdog_interval:, lock_duration:)
+      runner = Runner.new(self, room_class, key, lock_info, watchdog_interval:, lock_duration:)
       runner.start!
       runner
     end
 
-    # Bring a room back from a CableRoom::Snapshot on this Host, the way a migration's adopter
-    # does. With no `lock_info`, takes the room's Redlock first and returns false if someone else
-    # holds it — the same rule as `ensure_room`. With one, the caller has already claimed the lock.
-    # Raises Snapshot::UnknownVersion or Snapshot::UnknownRoomClass before anything is built if
-    # the snapshot can't be used here. `hold_inbound: true` brings the room up frozen, holding
-    # its inbound until `Runner#thaw!` (see Runner#restore!).
-    #
-    # If the room fails to come up, the lock is released either way — the caller's too. A room
-    # that can't start here must not keep its key locked: the migration that handed it over
-    # takes the lock back and restarts it as soon as the lock is free.
-    def restore_room(snapshot, lock_info = nil, hold_inbound: false)
-      snapshot = Snapshot.validate!(snapshot)
-      room_class = Snapshot.room_class_for(snapshot)
-      key = Snapshot.key_for(snapshot)
-      lock_key = room_class.room_port_key(key)
-
-      if lock_info
-        unless lock_info[:resource] == lock_key
-          raise ArgumentError, "lock_info is for #{lock_info[:resource].inspect}, but the snapshot is #{lock_key}"
-        end
-      else
-        lock_info = CableRoom.lock_manager.lock(lock_key, room_class::LOCK_DURATION.in_milliseconds)
-        return false unless lock_info
-      end
-
-      runner = Runner.new(
-        self,
-        room_class,
-        key,
-        lock_info,
-        watchdog_interval: room_class::WATCH_DOG_INTERVAL,
-        lock_duration: room_class::LOCK_DURATION,
-        tenant: snapshot["tenant"],
-      )
-      runner.restore!(snapshot, hold_inbound: hold_inbound)
-      runner
-    rescue => e
-      # `restore!` releases the lock itself when the room fails to come up; this covers a failure
-      # before the runner exists
-      CableRoom.lock_manager.unlock(lock_info) if lock_info && runner.nil?
-      raise e
-    end
-
-    # A name for this host in migration traffic and instrumentation (`from_host`, `to_host`):
-    # machine, pid, and a few random characters, so two hosts in one process (a spec) differ too.
-    def id
-      @id ||= "#{Socket.gethostname}:#{Process.pid}:#{SecureRandom.hex(3)}"
-    end
-
-    # The Bus this host's rooms listen on, for the migration's list and key operations. Falls
-    # back to the process-wide Bus when `inbound` isn't Bus-backed.
-    def bus
-      inbound.respond_to?(:bus) ? inbound.bus : CableRoom.bus
-    end
-
     def track(runner)
       @monitor.synchronize do
         raise "Cannot add Room after shutdown" if @shutdown
@@ -262,132 +76,25 @@ module CableRoom
       runners.map(&:room)
     end
 
-    # How many member ports are attached to rooms on this Host right now. This is the load
-    # number the design scales the rooms pool on, so an app can publish it as a gauge. It reads
-    # each room's port table from outside the room's thread; a count that's a moment stale is
-    # fine for a metric.
-    def open_ports
-      rooms.sum(&:open_port_count)
-    end
-
-    # How many rooms this Host runs right now. This is the load number provisioning weights its
-    # delay by: a host with more rooms waits longer before racing for a new one.
-    def open_rooms_count
-      @monitor.synchronize { @runners.size }
-    end
-
     def each_runner(&blk)
       runners.each(&blk)
     end
 
-    def draining?
-      @draining
-    end
-
-    # True once `drain!` has finished (every room moved or closed, and the host is shut down).
-    def drained?
-      !@drain_result.nil?
-    end
-
-    # The result of the drain, or nil until `drain!` has finished.
-    def drain_result
-      @drain_result
-    end
-
-    # Every CableRoom::Migration this host's drain has started, oldest room first. Each one's
-    # `state` says where it is; the list is complete once `drained?`.
-    def migrations
-      @monitor.synchronize { @migrations.dup }
+    # How many rooms this Host runs right now. Cheap enough to publish as a gauge.
+    def open_rooms_count
+      @monitor.synchronize { @runners.size }
     end
 
-    # Planned shutdown: move every room here to a peer host, then shut down. This is what SIGTERM
-    # means to `cable_room server` (see CableRoom::Migration for the per-room protocol):
-    #
-    #   1. Mark the host draining, so its Placement claims nothing more (a room it took now would
-    #      only have to move again), and instrument `host_draining.cable_room`.
-    #   2. Hand rooms off oldest first, DRAIN_CONCURRENCY at a time. A room nobody adopts within
-    #      `handoff_timeout` closes with `room_closed`; so does one that can't be snapshotted.
-    #   3. When `drain_timeout` passes with rooms still waiting their turn, offer all of them at
-    #      once — the same path, just no longer throttled — so the drain ends within about one
-    #      more `handoff_timeout` whatever the fleet does.
-    #   4. `shutdown!`, run the `Host.after_drain` callbacks, and return a DrainResult.
-    #
-    # Blocks until done. Runs once: a second call (from another thread, or `at_exit` after
-    # `cable_room server` has already drained) waits for the first and returns its result.
-    # `drain_timeout` and `handoff_timeout` default to the config's; specs pass short ones.
-    #
-    # In :inline the peers are the other web processes hosting rooms, if any. The design gives
-    # :inline no fleet of its own, so the gem doesn't drain there on exit (see `at_exit`); an app
-    # running several inline processes may still call this from its own signal handling.
-    def drain!(reason:, drain_timeout: nil, handoff_timeout: nil, concurrency: DRAIN_CONCURRENCY)
-      other = @monitor.synchronize do
-        return @drain_result if @drain_result
-        @drain_thread.tap { @drain_thread ||= Thread.current }
-      end
-      if other
-        other.join unless other == Thread.current
-        return @drain_result
-      end
-
-      drain_timeout ||= CableRoom.config.drain_timeout
-      handoff_timeout ||= CableRoom.config.handoff_timeout
-      started = monotonic_now
-      self.draining = true
-
-      queued = runners.sort_by(&:started_at)
-      migrations = queued.map { |runner| Migration.new(self, runner, reason: reason, handoff_timeout: handoff_timeout) }
-      @monitor.synchronize { @migrations = migrations }
-      logger.info "Draining #{migrations.size} room(s): #{reason}"
-
-      payload = { host: self, rooms: queued.map(&:room), reason: reason }
-      ActiveSupport::Notifications.instrument("host_draining.cable_room", payload) do |event|
-        run_migrations(migrations, concurrency: concurrency, deadline: started + drain_timeout.to_f)
-        event[:migrated] = migrations.count(&:migrated?)
-        event[:closed] = migrations.count { |m| !m.migrated? }
-      end
-
-      shutdown!
-
-      result = DrainResult.new(
-        reason: reason,
-        migrated: migrations.select(&:migrated?),
-        closed: migrations.reject(&:migrated?),
-        duration: monotonic_now - started,
-      )
-      logger.info "Drained: #{result.migrated.size} room(s) migrated, #{result.closed.size} closed, in #{result.duration.round(2)}s"
-      @monitor.synchronize { @drain_result = result }
-
-      self.class.after_drain_callbacks.each do |callback|
-        callback.call(self, result)
-      rescue => e
-        CableRoom.report_error(e, host: self, drain_result: result)
-      end
-
-      result
+    # How many member ports are attached across every room here. It reads each room's port table
+    # from outside the room's thread; a count that's a moment stale is fine for a metric.
+    def open_ports
+      rooms.sum(&:open_port_count)
     end
 
     def shutdown?
       @shutdown
     end
 
-    # Start listening for provision requests (see CableRoom::Placement). `Host.start!` does this
-    # for the process Host; a Host built with `new` (a spec harness) calls it itself. Pass a
-    # Placement to use one with non-default settings; calling it again re-arms the current one.
-    def start_placement(placement = nil)
-      previous = @monitor.synchronize do
-        raise "Cannot start placement after shutdown" if @shutdown
-        @placement.tap { @placement = placement || @placement || Placement.new(self) }
-      end
-      previous.stop if previous && previous != @placement
-      @placement.start
-      @placement
-    end
-
-    # Stop listening and drop any claim still waiting. Nothing starts a room here after this.
-    def stop_placement
-      @placement&.stop
-    end
-
     # Stop everything: the beat, every room (gracefully, with a bounded wait), then the pool.
     # Runs once; later calls do nothing.
     def shutdown!
@@ -396,8 +103,6 @@ module CableRoom
         @shutdown = true
       end
 
-      # Stop claiming first: a room started after this point would only be shut down again
-      stop_placement
       scheduler.shutdown
       shutdown_rooms!
       worker_pool.executor.shutdown
@@ -424,57 +129,6 @@ module CableRoom
 
     private
 
-    # Run the migrations `concurrency` at a time until `deadline`, then everything still waiting
-    # at once. Each runs on a thread of its own rather than the worker pool: a handoff blocks for
-    # up to `handoff_timeout` waiting on a peer, and the rooms still need the pool to run.
-    def run_migrations(migrations, concurrency:, deadline:)
-      queue = Queue.new
-      migrations.each { |migration| queue << migration }
-      next_migration = -> { queue.pop(true) rescue nil } # non-blocking: nil once the queue is empty
-
-      workers = Array.new([concurrency, migrations.size].min) do |i|
-        migration_thread("cable_room-drain-#{i}") do
-          while (migration = next_migration.call)
-            migration.run
-          end
-        end
-      end
-
-      workers.each do |thread|
-        remaining = deadline - monotonic_now
-        break if remaining <= 0
-        thread.join(remaining)
-      end
-
-      forced = []
-      while (migration = next_migration.call)
-        forced << migration
-      end
-      if forced.any?
-        logger.warn "drain_timeout passed with #{forced.size} room(s) still waiting; handing them all off now"
-      end
-      forced_threads = forced.map { |migration| migration_thread("cable_room-drain-forced") { migration.run } }
-
-      (workers + forced_threads).each(&:join)
-    end
-
-    def migration_thread(name)
-      thread = Thread.new do
-        yield
-      rescue => e
-        # Migration#run handles its own failures; this is for a bug in the loop itself, which
-        # must not take the whole drain down with it
-        CableRoom.report_error(e, host: self)
-      end
-      thread.name = name
-      thread.report_on_exception = false
-      thread
-    end
-
-    def monotonic_now
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-
     def cable_server
       ActionCable.server
     end

data/lib/cable_room/ports.rb

@@ -1,17 +1,4 @@
 module CableRoom
-  # The `ports[...]` DSL shared by a Room and by a member's RoomMembership. A port is a named
-  # lane between a room and its members; `ports[:x] << msg` sends on it and `ports[:x].stream`
-  # listens on it. Which transport that touches depends on which side you're on, and each side
-  # implements the three methods below:
-  #
-  #   * Member side (RoomMembership): sending publishes on the Bus channel for the room's port
-  #     (member→room), listening is an ActionCable stream (room→member, fed by the broadcaster).
-  #   * Room side (Room::Base and Room::HostAdapter): sending goes through the configured
-  #     CableRoom::Broadcaster, listening subscribes on the Bus through the room's Host.
-  #
-  # So a member's `ports[:custom] << msg` and a room's `ports[:custom].stream` meet on the Bus,
-  # and a room's `ports[:custom] << msg` and a member's `ports[:custom].stream` meet on the
-  # broadcaster's streams. Neither side needs to know that.
   module Ports
     extend ActiveSupport::Concern
 
@@ -19,19 +6,22 @@ module CableRoom
       @ports_proxy ||= PortsProxy.new(self)
     end
 
-    # Listen on `port`, handing each decoded message to the block. Ports streamed with
-    # `auto_close: true` are stopped by `close_streamed_ports!`.
+    # The member side, streaming through its ActionCable channel. Rooms override this (and
+    # close_streamed_ports!) in Room::HostAdapter to listen through their Host::Runner instead.
     def stream_port(port, auto_close: true, &blk)
-      raise NotImplementedError, "#{self.class} must implement stream_port"
+      @cable_channel.stream_from(room_port_key(port), coder: ActiveSupport::JSON, &blk)
+      _streamed_ports << port if auto_close
     end
 
     def close_streamed_ports!
-      raise NotImplementedError, "#{self.class} must implement close_streamed_ports!"
+      _streamed_ports.each do |port|
+        @cable_channel.stop_stream_from(room_port_key(port))
+      end
+      _streamed_ports.clear
     end
 
-    # Send `data` on `port`.
     def port_transmit(port, data)
-      raise NotImplementedError, "#{self.class} must implement port_transmit"
+      ActionCable.server.broadcast(room_port_key(port), data)
     end
 
     protected

data/lib/cable_room/railtie.rb

@@ -5,12 +5,20 @@ require "active_model/railtie"
 
 module CableRoom
   class Railtie < Rails::Railtie # :nodoc:
+    rake_tasks do
+    end
+
+    console do |app|
+    end
+
+    runner do
+    end
+
     initializer "cable_room.hook_action_cable_restart" do
       module ActionCableServerExtensions
-        # ActionCable restarts when the app reloads; stop every room with it. A process that
-        # hosts no rooms (a web process in :remote) has nothing to stop.
+        # ActionCable restarts when the app reloads; stop every room with it
         def restart
-          CableRoom::Host.current&.stop_all_rooms!
+          CableRoom::Host.instance.stop_all_rooms!
           super
         end
       end