cable_room 0.7.0.beta3 → 0.8.0.beta2

data/cable_room.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.summary       = "Build live Rooms on top of ActionCable"
   spec.homepage      = "https://instructure.com"
 
-  spec.files = Dir["{app,config,db,exe,lib}/**/*", "README.md", "CHANGELOG.md", "*.gemspec"]
+  spec.files = Dir["{app,config,db,exe,lib}/**/*", "README.md", "*.gemspec"]
   spec.bindir = "exe"
   spec.executables = ["cable_room"]
   spec.require_paths = ['lib']
@@ -27,8 +27,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rufus-scheduler", "~> 3.6"
   spec.add_dependency "redlock", "~> 2.0"
   spec.add_dependency "rediconn", "~> 0.1.2"
-  # rediconn builds pools of redis-rb clients but doesn't declare the gem; the Bus needs it too
-  spec.add_dependency "redis", ">= 5.0"
+  # Workaround approved October 2, 2026: rediconn requires "redis" at load time but only declares
+  # it as a development dependency, so cable_room declares it instead. Drop this once rediconn
+  # does. The Bus needs >= 5: redis-rb 4 holds its client lock for the whole SUBSCRIBE loop, so
+  # another thread can't add a channel to a live session. The ceiling matches ActionCable 8.1's
+  # Redis adapter (7.2's is "< 6"), so apps on that adapter still resolve.
+  spec.add_dependency "redis", ">= 5", "< 7"
 
   spec.add_development_dependency 'rspec', '~> 3'
 end

data/lib/cable_room/bus.rb

@@ -1,13 +1,13 @@
 require 'set'
+require 'redis'
 require 'active_support/json'
 
 module CableRoom
-  # The Redis bus that carries member-to-room traffic in every mode: `to_room` messages,
-  # provision requests, and the handoff data a room leaves behind when it migrates to another
-  # host. It's a thin layer over the `CABLEROOM_*` Redis connection (see `CableRoom.redis_pool`)
-  # that adds three things:
+  # The Redis pub/sub bus for member-to-room traffic. It's a thin layer over the `CABLEROOM_*`
+  # Redis connection (see `CableRoom.redis_pool`) that adds three things:
   #
-  #   * One place that knows the channel and key names (`cr:{room_key}:in` and friends).
+  #   * One place that knows the channel names (`cr:{room_port_key}:in` and friends, and
+  #     `cr:provision`).
   #   * JSON encoding on the way in and decoding on the way out, using the same coder the room
   #     ports already use for ActionCable streams, so a bad payload fails at the publisher.
   #   * A single subscriber thread that owns a dedicated pub/sub connection and hands each
@@ -18,6 +18,12 @@ module CableRoom
   # blocks until Redis confirms the subscription, so anything published after it returns is
   # delivered.
   #
+  # Reconnects: when the pub/sub connection drops, the subscriber thread reports the error and
+  # opens a new session for every channel it still has a handler for, backing off from 0.1 s up
+  # to 5 s between attempts. Redis pub/sub doesn't queue, so anything published while the
+  # session is down is lost. Callers that can't afford that need their own recovery (members
+  # re-announce on their ping, for example).
+  #
   # Handlers run on the subscriber thread. Keep them short (hand the work to a queue) and never
   # block in them waiting on the bus itself. A handler is allowed to call `subscribe` and
   # `unsubscribe`; those calls return without waiting when made from the subscriber thread,
@@ -32,42 +38,32 @@ module CableRoom
     KEY_PREFIX = "cr".freeze
     DEFAULT_TIMEOUT = 5
 
+    INITIAL_BACKOFF = 0.1
+    MAX_BACKOFF = 5
+
     class << self
       # Pub/sub channel that a room's host listens on for member-to-room messages. A room's main
-      # inbound port has no suffix (`cr:{room_key}:in`); a custom inbound port gets one
-      # (`cr:{room_key}:in:{port}`), so every channel a room listens on shares one prefix.
-      # `Room::Base.inbound_channel` is what turns a room class, key, and port into these.
-      def inbound_channel(room_key, port = nil)
-        channel = room_channel(room_key, "in")
+      # inbound port has no suffix (`cr:{room_port_key}:in`); a custom inbound port gets one
+      # (`cr:{room_port_key}:in:{port}`), so every channel a room listens on shares one prefix.
+      # The room part is the room's own stream name, so an app's `broadcasting_for` override
+      # (PandaPal's tenant prefix) keeps two tenants' rooms apart here too.
+      def inbound_channel(room_class, room_key, port = nil)
+        channel = room_channel(room_class.room_port_key(room_key), "in")
         port.nil? ? channel : "#{channel}:#{port}"
       end
 
-      # Pub/sub channel every host listens on for "someone wants room X to exist" requests.
+      # The one process-wide channel `create: true` members ask for rooms on, and every rooms
+      # Host's Placement listens to (see Host::Placement). It isn't per tenant: the tenant rides in
+      # the request, and the Host that claims the room switches into it.
       def provision_channel
         "#{KEY_PREFIX}:provision"
       end
 
-      # Redis list where a migrating room's old host parks inbound messages until the new host
-      # has adopted the room.
-      def handoff_list(room_key)
-        room_channel(room_key, "handoff")
-      end
-
-      # Redis string (with a TTL) holding the frozen room's snapshot during a migration.
-      def snapshot_key(room_key)
-        room_channel(room_key, "snapshot")
-      end
-
-      # Pub/sub channel the adopting host publishes on once it has taken over the room.
-      def adopted_channel(room_key)
-        room_channel(room_key, "adopted")
-      end
-
       private
 
-      def room_channel(room_key, suffix)
-        key = room_key.to_s
-        raise ArgumentError, "room_key can't be blank" if key.empty?
+      def room_channel(port_key, suffix)
+        key = port_key.to_s
+        raise ArgumentError, "room_port_key can't be blank" if key.empty?
         "#{KEY_PREFIX}:#{key}:#{suffix}"
       end
     end
@@ -87,7 +83,7 @@ module CableRoom
       @subscriber_redis = nil
     end
 
-    # ---- Publisher and plain key operations --------------------------------------------------
+    # ---- Publisher --------------------------------------------------------------------------
 
     # Publish a JSON-encodable payload. Returns the number of subscribers that received it.
     def publish(channel, payload)
@@ -95,45 +91,6 @@ module CableRoom
       redis { |r| r.publish(channel, encoded) }
     end
 
-    # Append one or more payloads to the end of a list. Returns the list's new length. With `ttl`
-    # (seconds or a Duration) the list's expiry is reset in the same round trip, so a list nobody
-    # deletes (a host that died mid-handoff) still goes away on its own.
-    def rpush(key, *payloads, ttl: nil)
-      encoded = payloads.map { |payload| encode(payload) }
-      return redis { |r| r.rpush(key, encoded) } unless ttl
-
-      seconds = ttl.to_i
-      raise ArgumentError, "ttl must be a positive number of seconds" unless seconds.positive?
-      length, = redis { |r| r.pipelined { |p| p.rpush(key, encoded); p.expire(key, seconds) } }
-      length
-    end
-
-    # The whole list, oldest first, decoded.
-    def lrange(key)
-      redis { |r| r.lrange(key, 0, -1) }.map { |raw| decode(raw) }
-    end
-
-    # Delete keys. Returns how many existed.
-    def del(*keys)
-      redis { |r| r.del(*keys) }
-    end
-
-    # Store a payload under a key that expires after `ttl` (seconds or an
-    # ActiveSupport::Duration). Migration uses this for snapshots so a dead handoff cleans
-    # itself up.
-    def set(key, payload, ttl:)
-      seconds = ttl.to_i
-      raise ArgumentError, "ttl must be a positive number of seconds" unless seconds.positive?
-      encoded = encode(payload)
-      redis { |r| r.set(key, encoded, ex: seconds) }
-    end
-
-    # The decoded payload stored under a key, or nil when there isn't one.
-    def get(key)
-      raw = redis { |r| r.get(key) }
-      raw.nil? ? nil : decode(raw)
-    end
-
     # ---- Subscriber -------------------------------------------------------------------------
 
     # Register `handler` for `channel` and block until Redis confirms the subscription. The
@@ -169,11 +126,13 @@ module CableRoom
 
     # Drop the handler for `channel` and block until Redis confirms the unsubscribe. When no
     # channels are left the subscriber thread exits, and this also waits for that. Returns
-    # false if the channel wasn't subscribed.
-    def unsubscribe(channel, timeout: DEFAULT_TIMEOUT)
+    # false if the channel wasn't subscribed. With `handler:`, only unsubscribes while that
+    # handler is still the one registered (a later `subscribe` may have replaced it).
+    def unsubscribe(channel, handler: nil, timeout: DEFAULT_TIMEOUT)
       channel = channel.to_s
 
       @mutex.synchronize do
+        return false if handler && !@handlers[channel].equal?(handler)
         return false unless @handlers.delete(channel)
         reconcile
 
@@ -253,7 +212,7 @@ module CableRoom
     # channel; a session ends when the last channel is unsubscribed (normal) or the connection
     # fails (reported, then retried with backoff). The loop exits once nothing is wanted.
     def subscriber_loop
-      backoff = 0.1
+      backoff = INITIAL_BACKOFF
       loop do
         channels = @mutex.synchronize do
           if @handlers.empty?
@@ -266,11 +225,11 @@ module CableRoom
 
         begin
           run_session(channels)
-          backoff = 0.1
+          backoff = INITIAL_BACKOFF
         rescue StandardError => e
           CableRoom.report_error(e, bus: self, channels: channels)
           sleep backoff
-          backoff = [backoff * 2, 5].min
+          backoff = [backoff * 2, MAX_BACKOFF].min
         end
       end
     end
@@ -330,6 +289,10 @@ module CableRoom
     # Bring the server-side subscription set in line with the handlers we hold. Only possible
     # while a session is live; before that, the thread's first confirmation calls this to pick
     # up anything added or removed while it was connecting. Caller must hold @mutex.
+    #
+    # The writes below happen under @mutex, which is safe because they only queue a command on
+    # the socket: nothing here waits on a reply, and the subscriber thread never needs anything
+    # but @mutex to make progress.
     def reconcile
       return unless @session_live
 
@@ -342,6 +305,13 @@ module CableRoom
         @requested.delete(channel)
         @subscriber_redis.unsubscribe(channel)
       end
+    rescue Redis::BaseConnectionError, RedisClient::ConnectionError
+      # The socket died under us. Stop writing to it and let the subscriber thread notice, report
+      # it, and open a new session for every channel still wanted. A caller waiting in
+      # `subscribe` rides on that session's confirmation (or times out) rather than seeing the
+      # connection error for a subscription the bus is about to retry anyway.
+      @session_live = false
+      @subscriber_redis = nil
     end
 
     # Decode and hand one message to its handler. A handler that raises is reported and the

data/lib/cable_room/cli.rb

@@ -6,38 +6,61 @@ require "logger"
 require_relative "version"
 
 module CableRoom
-  # The `cable_room` command. Its one command, `server`, is the "rooms host" role from the
-  # distributed-rooms design: boot the Rails app, become a rooms host, run until SIGTERM or SIGINT,
-  # then shut every room down cleanly.
+  # The `cable_room` command. Its one command, `server`, is the rooms process for
+  # `room_host = :remote`: boot the Rails app, become this process's rooms Host, run until SIGTERM
+  # or SIGINT, then shut every room down (members get room_closed). Rooms aren't migrated
+  # anywhere on the way out.
   #
-  # It only makes sense with `room_host = :remote` and refuses to run otherwise: in :inline the
-  # web processes host rooms themselves, so a server here would only race them for locks.
+  # It refuses to run in :inline, where the web processes host rooms themselves and a server here
+  # would only race them for locks.
   #
-  # Boot works the way sidekiq and good_job do it: `require` the app's `config/environment.rb`
-  # from the current directory, or from `--require PATH` (an app directory or a boot file).
-  # Bundler is already set up because the command runs under `bundle exec`. Nothing from the gem
-  # beyond this file and `version` is loaded before the app boots, so the app's Gemfile decides
-  # when the Railtie loads, the same as in a web process.
+  # What the rooms process needs from the app:
   #
-  # `--workers N` picks the process model. With N = 1 this process hosts rooms itself. With
-  # N > 1 (the default is the machine's core count) the app is booted once, here, and then
-  # `Host::Supervisor` forks N children that each host rooms; this parent only watches them,
-  # replaces one that dies, and relays SIGTERM and SIGINT. The parent never builds a Host, a Bus
-  # subscriber, or a Redis connection of its own: those belong to the children, which build them
-  # after the fork so no process ever shares a socket or a thread with another.
+  #   * The app's own config/cable.yml with a Redis adapter. Rooms still talk to members with
+  #     `ActionCable.server.broadcast`, which reaches web processes only through a shared
+  #     pubsub; the async and inline adapters keep broadcasts inside this process.
+  #   * The same CABLEROOM_* Redis settings as the web processes. Members publish to rooms on
+  #     the Bus there, and room locks live there.
+  #   * A tenant for every room it starts, in a multi-tenant app. Provision requests carry the
+  #     member's tenant; a room started here by hand needs `MyRoom.ensure(key, tenant: ...)`.
   #
-  # Everything is instance state and `run` returns an exit status, so specs can drive the parsing
-  # and the refusals in-process; only the exe calls `exit`.
+  # Rooms start here through provisioning: a `create: true` join on the web side publishes a
+  # provision request on the Bus, and each rooms Host's Placement (started by `Host.start!`)
+  # waits in proportion to its load, then races for the room's lock (see Host::Placement).
+  #
+  # Boot works the way sidekiq and good_job do it: `require` the app's config/environment.rb from
+  # the current directory, or from `--require PATH` (an app directory or a boot file). Bundler is
+  # already set up because the command runs under `bundle exec`. Nothing from the gem beyond this
+  # file and `version` loads before the app boots, so the app's Gemfile decides when the Railtie
+  # loads, the same as in a web process. Nothing subscribes to Redis or starts a thread until
+  # the app has booted and been eager-loaded, so a supervisor can fork after that point.
+  #
+  # `--workers N` picks the process model. With N = 1 this process hosts rooms itself, as a
+  # single rooms process always has; the container's restart policy is its supervisor. With
+  # N > 1 (the default is the machine's processor count) the app is booted once, here, and then
+  # `Host::Supervisor` forks N children that each host rooms with their own Bus connection;
+  # this parent only watches them, replaces one that dies, and relays SIGTERM and SIGINT. The
+  # parent never builds a Host, subscribes the Bus, or keeps a Redis or database connection:
+  # the children build their own after the fork, so no two processes ever share a socket or a
+  # thread.
+  #
+  # `run` returns an exit status rather than exiting, so specs can drive it in-process.
   class CLI
     STOP_SIGNALS = %w[TERM INT].freeze
 
+    # How long a room's startup waits for Redis to confirm each Bus subscription here. A healthy
+    # Redis confirms in milliseconds; this only bounds a sick one, and failing sooner frees the
+    # room's lock sooner. The web-side default (Bus::DEFAULT_TIMEOUT, 5 s) is sized for a member
+    # join that can afford to wait.
+    SUBSCRIBE_TIMEOUT = 2
+
     attr_reader :options, :command
 
     def initialize(argv, stdout: $stdout, stderr: $stderr)
       @argv = argv.dup
       @stdout = stdout
       @stderr = stderr
-      @options = { workers: nil, require: Dir.pwd }
+      @options = { require: Dir.pwd, workers: nil }
     end
 
     # Parse and run. Returns the process exit status.
@@ -59,7 +82,7 @@ module CableRoom
       1
     end
 
-    # How many worker processes `server` runs: `--workers`, or one per core.
+    # How many worker processes `server` runs: `--workers`, or one per processor
     def workers
       options[:workers] || Etc.nprocessors
     end
@@ -70,14 +93,15 @@ module CableRoom
       @parser ||= OptionParser.new do |o|
         o.banner = "Usage: cable_room server [options]"
         o.separator ""
-        o.separator "Runs a CableRoom rooms host: boots the Rails app in the current directory and"
-        o.separator "hosts rooms until SIGTERM or SIGINT. Needs CableRoom.config.room_host = :remote."
+        o.separator "Hosts CableRoom rooms for a Rails app with room_host = :remote: boots the app in"
+        o.separator "the current directory and runs until SIGTERM or SIGINT. Needs the app's"
+        o.separator "config/cable.yml (a Redis adapter) and the same CABLEROOM_* Redis as the web."
         o.separator ""
         o.on("-r", "--require PATH", "App directory (with config/environment.rb) or a boot file to require") do |path|
           @options[:require] = path
         end
         o.on("-w", "--workers N", Integer,
-             "Worker processes to fork (default: one per core, #{Etc.nprocessors} here). 1 runs in this process.") do |n|
+             "Worker processes to fork (default: one per processor, #{Etc.nprocessors} here). 1 runs in this process.") do |n|
           @options[:workers] = n
         end
         o.on("-v", "--version", "Print the version and exit") do
@@ -106,31 +130,49 @@ module CableRoom
 
       boot_app!
 
-      unless CableRoom.config.remote?
-        @stderr.puts "cable_room server: CableRoom.config.room_host is #{CableRoom.config.room_host.inspect}, but a " \
-                     "rooms host only makes sense with :remote (in :inline the web processes host rooms " \
-                     "themselves). Set CABLE_ROOM_HOST=remote or `c.room_host = :remote` and try again."
+      unless CableRoom.remote?
+        @stderr.puts "cable_room server: CableRoom.room_host is #{CableRoom.room_host.inspect}, but a rooms " \
+                     "process only makes sense with :remote (in :inline the web processes host rooms " \
+                     "themselves). Set CABLE_ROOM_HOST=remote or `CableRoom.room_host = :remote` and try again."
         return 1
       end
 
+      warn_about_local_cable_adapter
       return run_host if workers == 1
 
       supervise_workers
     end
 
-    # Load the app: a directory means its config/environment.rb, anything else is required as-is
+    # Load the app: a directory means its config/environment.rb, anything else is required as-is.
+    # Then eager-load it, as production does anyway, so every room class is loaded before any
+    # room starts (and before a supervisor forks).
     def boot_app!
       path = File.expand_path(options[:require])
       path = File.join(path, "config", "environment.rb") if File.directory?(path)
       require path
+
+      Rails.application.eager_load! if defined?(Rails) && Rails.application && !Rails.application.config.eager_load
+    end
+
+    def warn_about_local_cable_adapter
+      cable = ActionCable.server.config.cable || {}
+      adapter = (cable[:adapter] || cable["adapter"]).to_s
+      return unless %w[async inline test].include?(adapter)
+
+      @stderr.puts "cable_room server: warning: ActionCable's adapter is #{adapter.inspect}, so room broadcasts " \
+                   "never leave this process and members won't hear their rooms. Use the app's Redis cable.yml."
     end
 
     # Fork `workers` children that each run `run_host`, and watch them until a stop signal has
     # come and gone. This parent hosts nothing itself (see the class comment for why).
     def supervise_workers
       Process.setproctitle("cable_room server: supervisor (#{workers} workers)")
-      say "supervising #{workers} workers (pid #{Process.pid}, room_host=#{CableRoom.config.room_host}, " \
-          "broadcaster=#{CableRoom.config.broadcaster})"
+      # Fail now, once, if the CABLEROOM_* Redis is unreachable, rather than in N workers that
+      # would each die and come back with backoff. Then let go of what the ping (or the app's
+      # boot) opened, so the children inherit no Redis or database sockets.
+      CableRoom.redis(&:ping)
+      release_connections_before_fork
+      say "supervising #{workers} workers (pid #{Process.pid}, room_host=#{CableRoom.room_host})"
 
       supervisor = CableRoom::Host::Supervisor.new(count: workers, logger: supervisor_logger) do |index|
         run_host(worker: index)
@@ -140,6 +182,15 @@ module CableRoom
       status
     end
 
+    # Close the parent's idle pooled Redis connections and its ActiveRecord connections. The
+    # children would drop their copies anyway (see `CableRoom.after_fork!`); closing them here
+    # means there are no copies to drop, and the parent, which only waits on children from now
+    # on, holds nothing it won't use. Both pools reconnect lazily if anything asks again.
+    def release_connections_before_fork
+      CableRoom.redis_pool.reload(&:close)
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all) if defined?(ActiveRecord::Base)
+    end
+
     # Logs from the supervisor go to the same place as the CLI's own messages, in the same style.
     # Unbuffered, so a "forked worker" line shows up when it happens, not when the process exits.
     def supervisor_logger
@@ -153,8 +204,8 @@ module CableRoom
     # life of a single-process server and of each forked worker (`worker` is the worker's index,
     # nil when there's no supervisor). Returns the exit status.
     def run_host(worker: nil)
-      # Trap before starting the Host, so a signal that lands while rooms are still coming up
-      # (the supervisor relaying a SIGTERM that arrived mid-boot, say) is kept, not fatal
+      # Trap before anything slow, so a signal that lands while rooms are still coming up (the
+      # supervisor relaying a SIGTERM that arrived mid-boot, say) is kept, not fatal
       signals = trap_stop_signals
 
       if worker
@@ -162,41 +213,29 @@ module CableRoom
         tag_logger("cable_room worker #{worker}")
       end
 
-      host = CableRoom::Host.start!
-      say "hosting rooms (pid #{Process.pid}, room_host=#{CableRoom.config.room_host}, " \
-          "broadcaster=#{CableRoom.config.broadcaster})", worker: worker
+      # Fail now, not at the first room, if the CABLEROOM_* Redis is unreachable
+      CableRoom.redis(&:ping)
+
+      host = CableRoom::Host.start!(subscribe_timeout: SUBSCRIBE_TIMEOUT)
+      say "hosting rooms (pid #{Process.pid}, room_host=#{CableRoom.room_host})", worker: worker
 
-      signal = wait_for_stop_signal(signals)
-      stop_host(host, signal, worker: worker)
+      signal = signals.pop
+      say "got SIG#{signal}, shutting down #{host.open_rooms_count} room(s)", worker: worker
+      # A second signal from here on gets the previous handler (the default one kills at once)
+      restore_signal_handlers
+      host.shutdown!
+      CableRoom.bus.shutdown
       say "shut down", worker: worker
       0
     ensure
-      restore_traps
-    end
-
-    # A stop signal with rooms open is a planned shutdown: hand the rooms to peer hosts before
-    # leaving (`Host#drain!`, bounded by `drain_timeout`; a room nobody adopts closes with
-    # `room_closed`). With nothing open there is nothing to move, so just shut down. Both are
-    # idempotent, so the one SIGTERM a supervisor relays and a later `at_exit` don't collide.
-    def stop_host(host, signal, worker: nil)
-      rooms = host.rooms.size
-      if rooms.zero?
-        say "got SIG#{signal}, shutting down 0 room(s)", worker: worker
-        host.shutdown!
-        return
-      end
-
-      say "got SIG#{signal}, migrating #{rooms} room(s) to peer hosts", worker: worker
-      result = host.drain!(reason: "SIG#{signal}")
-      say "drained: #{result.migrated.size} room(s) migrated, #{result.closed.size} closed, " \
-          "in #{result.duration.round(1)}s", worker: worker
+      restore_signal_handlers
     end
 
     # Every room on this Host logs through `ActionCable.server.logger` (Host#logger); give that
     # logger a tag naming the worker, so lines from the N workers sharing one stdout can be told
     # apart. `tagged` without a block returns a logger whose tags apply on every thread, which is
     # what we need: rooms log from the worker pool, not from this thread. A logger without tags
-    # (a plain Logger, or Rails' BroadcastLogger fanning out to several) is left as it is.
+    # (a plain Logger, say) is left as it is.
     def tag_logger(tag)
       logger = ActionCable.server.logger
       return unless logger.respond_to?(:tagged)
@@ -205,33 +244,23 @@ module CableRoom
       ActionCable.server.config.logger = tagged if tagged.respond_to?(:info)
     end
 
-    def say(message, worker: nil)
-      prefix = worker ? "cable_room server (worker #{worker})" : "cable_room server"
-      @stdout.puts "#{prefix}: #{message}"
-      @stdout.flush
-    end
-
     # Signal handlers may only do trivial work, so each one just drops the signal's name on a
-    # queue for the main thread to pick up. Returns the queue.
+    # queue for the main thread to pick up
     def trap_stop_signals
       signals = Queue.new
-      @previous_traps = STOP_SIGNALS.to_h { |sig| [sig, trap(sig) { signals << sig }] }
+      @previous_handlers = STOP_SIGNALS.to_h { |sig| [sig, trap(sig) { signals << sig }] }
       signals
     end
 
-    # Block the main thread until SIGTERM or SIGINT; returns the signal's name. A timed pop, not
-    # a plain one: if this were the only thread left (a worker whose rooms have all gone quiet,
-    # say), a blocking pop would trip Ruby's deadlock detector, because a trap isn't a thread.
-    def wait_for_stop_signal(signals)
-      loop do
-        signal = signals.pop(timeout: 1)
-        return signal if signal
-      end
+    def restore_signal_handlers
+      @previous_handlers&.each { |sig, handler| trap(sig, handler) }
+      @previous_handlers = nil
     end
 
-    def restore_traps
-      @previous_traps&.each { |sig, handler| trap(sig, handler) }
-      @previous_traps = nil
+    def say(message, worker: nil)
+      prefix = worker ? "cable_room server (worker #{worker})" : "cable_room server"
+      @stdout.puts "#{prefix}: #{message}"
+      @stdout.flush
     end
   end
 end