cable_room 0.7.0.beta2 → 0.8.0.beta1

data/lib/cable_room/cli.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require "optparse"
-require "etc"
-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.
-  #
-  # 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.
-  #
-  # 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.
-  #
-  # `--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.
-  #
-  # 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`.
-  class CLI
-    STOP_SIGNALS = %w[TERM INT].freeze
-
-    attr_reader :options, :command
-
-    def initialize(argv, stdout: $stdout, stderr: $stderr)
-      @argv = argv.dup
-      @stdout = stdout
-      @stderr = stderr
-      @options = { workers: nil, require: Dir.pwd }
-    end
-
-    # Parse and run. Returns the process exit status.
-    def run
-      parse!
-      return 0 if @help_shown
-
-      case command
-      when "server" then server
-      when nil
-        @stderr.puts parser
-        1
-      else
-        @stderr.puts "Unknown command #{command.inspect}.", parser
-        1
-      end
-    rescue OptionParser::ParseError => e
-      @stderr.puts e.message, parser
-      1
-    end
-
-    # How many worker processes `server` runs: `--workers`, or one per core.
-    def workers
-      options[:workers] || Etc.nprocessors
-    end
-
-    private
-
-    def parser
-      @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 ""
-        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|
-          @options[:workers] = n
-        end
-        o.on("-v", "--version", "Print the version and exit") do
-          @stdout.puts CableRoom::VERSION
-          @help_shown = true
-        end
-        o.on("-h", "--help", "Show this help") do
-          @stdout.puts o
-          @help_shown = true
-        end
-      end
-    end
-
-    def parse!
-      rest = parser.parse(@argv)
-      @command = rest.shift
-      raise OptionParser::ParseError, "Unexpected arguments: #{rest.join(' ')}" if rest.any?
-    end
-
-    def server
-      # Check the cheap things before booting Rails, so a bad flag fails in milliseconds
-      unless workers >= 1
-        @stderr.puts "cable_room server: --workers must be at least 1 (got #{workers})."
-        return 1
-      end
-
-      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."
-        return 1
-      end
-
-      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
-    def boot_app!
-      path = File.expand_path(options[:require])
-      path = File.join(path, "config", "environment.rb") if File.directory?(path)
-      require path
-    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})"
-
-      supervisor = CableRoom::Host::Supervisor.new(count: workers, logger: supervisor_logger) do |index|
-        run_host(worker: index)
-      end
-      status = supervisor.run
-      say "shut down"
-      status
-    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
-      @stdout.sync = true if @stdout.respond_to?(:sync=)
-      Logger.new(@stdout).tap do |logger|
-        logger.formatter = ->(_severity, _time, _progname, message) { "cable_room server: #{message}\n" }
-      end
-    end
-
-    # Host rooms in this process until SIGTERM or SIGINT, then shut them down. This is the whole
-    # 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
-      signals = trap_stop_signals
-
-      if worker
-        Process.setproctitle("cable_room server: worker #{worker}")
-        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
-
-      signal = wait_for_stop_signal(signals)
-      stop_host(host, signal, worker: worker)
-      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
-    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.
-    def tag_logger(tag)
-      logger = ActionCable.server.logger
-      return unless logger.respond_to?(:tagged)
-
-      tagged = logger.tagged(tag)
-      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.
-    def trap_stop_signals
-      signals = Queue.new
-      @previous_traps = 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
-    end
-
-    def restore_traps
-      @previous_traps&.each { |sig, handler| trap(sig, handler) }
-      @previous_traps = nil
-    end
-  end
-end

data/lib/cable_room/config.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module CableRoom
-  # Holds the app-wide settings for CableRoom. Get the current one with `CableRoom.config`
-  # and change it with `CableRoom.configure`:
-  #
-  #   CableRoom.configure do |c|
-  #     c.room_host   = :remote       # :inline | :remote
-  #     c.broadcaster = :anycable     # :action_cable | :anycable
-  #     c.provision_delay_ms = 20
-  #     c.drain_timeout   = 10.minutes
-  #     c.handoff_timeout = 10.seconds
-  #   end
-  #
-  # The env vars CABLE_ROOM_HOST and CABLE_ROOM_BROADCASTER override `room_host` and
-  # `broadcaster`, even when the configure block sets them. That lets one build run in
-  # both modes without a code change. With no configuration at all, every default keeps
-  # today's behavior: rooms run inline and broadcast through ActionCable.
-  class Config
-    class InvalidOption < ArgumentError; end
-
-    ROOM_HOSTS = %i[inline remote].freeze
-    BROADCASTERS = %i[action_cable anycable].freeze
-
-    ENV_OVERRIDES = {
-      room_host: "CABLE_ROOM_HOST",
-      broadcaster: "CABLE_ROOM_BROADCASTER",
-    }.freeze
-
-    DEFAULTS = {
-      room_host: :inline,
-      broadcaster: :action_cable,
-      provision_delay_ms: 20,
-      drain_timeout: 10.minutes,
-      handoff_timeout: 10.seconds,
-    }.freeze
-
-    attr_reader :room_host, :broadcaster
-    attr_accessor :provision_delay_ms, :drain_timeout, :handoff_timeout
-
-    def initialize
-      DEFAULTS.each { |name, value| instance_variable_set("@#{name}", value) }
-    end
-
-    # Where rooms run. `:inline` keeps them in the web process; `:remote` moves them to a
-    # dedicated host pool. Accepts a Symbol or String; unknown values raise right away.
-    def room_host=(value)
-      @room_host = validate_choice!(:room_host, value, ROOM_HOSTS)
-    end
-
-    # How a room pushes messages to members. Accepts a Symbol or String; unknown values raise.
-    def broadcaster=(value)
-      @broadcaster = validate_choice!(:broadcaster, value, BROADCASTERS)
-    end
-
-    # Rooms run inside every process that joins them (the web process in a Rails app).
-    def inline?
-      room_host == :inline
-    end
-
-    # Rooms run only in `cable_room server` processes; a web process never hosts one.
-    def remote?
-      room_host == :remote
-    end
-
-    # Copies CABLE_ROOM_HOST and CABLE_ROOM_BROADCASTER onto this config. Blank or missing
-    # variables leave the current value alone. `env` is injectable for specs.
-    def apply_env_overrides(env = ENV)
-      ENV_OVERRIDES.each do |name, var|
-        value = env[var]
-        next if value.nil? || value.strip.empty?
-
-        public_send("#{name}=", value)
-      end
-      self
-    end
-
-    # Checks every knob at once. The choice knobs are already checked by their setters, so
-    # this mostly guards the timing knobs, which are plain accessors.
-    def validate!
-      validate_choice!(:room_host, room_host, ROOM_HOSTS)
-      validate_choice!(:broadcaster, broadcaster, BROADCASTERS)
-      validate_number!(:provision_delay_ms, provision_delay_ms, min: 0)
-      validate_number!(:drain_timeout, drain_timeout, min: 0, exclusive: true)
-      validate_number!(:handoff_timeout, handoff_timeout, min: 0, exclusive: true)
-      self
-    end
-
-    def to_h
-      DEFAULTS.keys.to_h { |name| [name, public_send(name)] }
-    end
-
-    private
-
-    def validate_choice!(name, value, allowed)
-      symbol = value.to_s.to_sym unless value.nil?
-      return symbol if allowed.include?(symbol)
-
-      raise InvalidOption,
-            "CableRoom config: #{name} must be one of #{allowed.map(&:inspect).join(', ')} " \
-            "(got #{value.inspect})"
-    end
-
-    def validate_number!(name, value, min:, exclusive: false)
-      ok = value.is_a?(Numeric) && (exclusive ? value > min : value >= min)
-      return value if ok
-
-      bound = exclusive ? "greater than #{min}" : "at least #{min}"
-      raise InvalidOption, "CableRoom config: #{name} must be a number #{bound} (got #{value.inspect})"
-    end
-  end
-end

data/lib/cable_room/host/bus_inbound.rb

@@ -1,36 +0,0 @@
-module CableRoom
-  class Host
-    # How rooms receive messages: off the process-wide CableRoom::Bus (see `CableRoom.bus`), on
-    # the channels `Room::Base.inbound_channel` names. This is the only room-side code that
-    # touches the inbound transport, and it's the same in `:inline` and `:remote` mode — the only
-    # difference is which process the Host lives in. Anything with these two methods can be handed
-    # to `Host.new(inbound:)`.
-    #
-    # `subscribe` returns a handle that `unsubscribe` needs back. Handlers get the decoded message
-    # on the Bus's single subscriber thread, in publish order, so they must be quick and hand the
-    # real work off; Host::Runner does that by queueing it on the room. `subscribe` blocks until
-    # Redis confirms the subscription, so `on_live` runs on the caller's thread right before it
-    # returns, and anything published after that is delivered.
-    class BusInbound
-      # `bus` defaults to `CableRoom.bus` (looked up lazily so specs can swap it)
-      def initialize(bus: nil)
-        @bus = bus
-      end
-
-      def subscribe(channel, on_live: nil, &on_message)
-        bus.subscribe(channel) { |message, _channel| on_message.call(message) }
-        on_live&.call
-        on_message
-      end
-
-      def unsubscribe(channel, _handle)
-        bus.unsubscribe(channel)
-      end
-
-      # The Bus behind this transport (the process-wide one unless a spec handed us another)
-      def bus
-        @bus || CableRoom.bus
-      end
-    end
-  end
-end

data/lib/cable_room/host/supervisor.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-module CableRoom
-  class Host
-    # The parent process behind `cable_room server --workers N`. It forks N children, runs one
-    # block in each, replaces a child that dies, and passes SIGTERM and SIGINT on to every child
-    # before exiting itself. It never hosts a room, never opens Redis, and never starts a Bus:
-    # each child builds its own after the fork (`CableRoom.after_fork!`), so nothing with a
-    # socket or a thread behind it is ever shared between processes.
-    #
-    #   Supervisor.new(count: 2, logger: logger) { |index| run_a_host(index) }.run
-    #
-    # The block is the whole child: it runs right after the fork and its return value (an Integer,
-    # or nil for 0) is the child's exit status. The child leaves with `exit!`, so `at_exit` hooks
-    # the parent registered before forking don't run a second time in every child (Resque does
-    # the same for its forked workers). A block that raises is logged and exits 1, which makes
-    # the supervisor replace it.
-    #
-    # Restarts: a child that dies is replaced. One that ran for at least `stable_after` seconds
-    # comes back at once; one that died sooner is treated as failing to boot and comes back
-    # after a delay that doubles from `first_backoff` up to `max_backoff`, so a broken app forks
-    # a few times a minute rather than thousands of times a second.
-    #
-    # Signals: SIGTERM and SIGINT to the parent are relayed to every live child and the parent
-    # then waits, with no time limit of its own, until they've all exited (a child migrating rooms
-    # may take a while; the container's `timeout -k` is the outer bound). A signal sent to one
-    # child touches only that child: it exits, and the parent replaces it. The handlers do
-    # nothing but write a byte to a pipe; the main loop reads the pipe, so no real work runs in
-    # signal context. SIGCHLD writes the same pipe to wake the loop when a child exits, and the
-    # loop also polls every `POLL_INTERVAL` seconds in case a wake-up is ever missed.
-    #
-    # If the parent itself dies without relaying anything (SIGKILL, a crash), each child notices
-    # through a second pipe (`watch_parent`) and stops as if it had been sent SIGTERM, so a dead
-    # supervisor never leaves orphaned workers hosting rooms.
-    class Supervisor
-      STOP_SIGNALS = %w[TERM INT].freeze
-      POLL_INTERVAL = 1
-
-      Worker = Struct.new(:index, :pid, :started_at)
-
-      attr_reader :count, :logger
-
-      def initialize(count:, logger:, stable_after: 5, first_backoff: 1, max_backoff: 30, &body)
-        raise ArgumentError, "count must be at least 1 (got #{count.inspect})" unless count.is_a?(Integer) && count >= 1
-        raise ArgumentError, "Supervisor needs a block to run in each worker" unless body
-
-        @count = count
-        @logger = logger
-        @stable_after = stable_after
-        @first_backoff = first_backoff
-        @max_backoff = max_backoff
-        @body = body
-
-        @workers = {}      # index => Worker, for every live child
-        @restart_at = {}   # index => monotonic time to fork a replacement
-        @backoff = {}      # index => the delay used for that slot's last boot failure
-        @stopping = false
-      end
-
-      # Fork the workers and supervise them until a stop signal has arrived and every child has
-      # exited. Blocks. Returns the process exit status (0).
-      def run
-        @signal_reader, @signal_writer = IO.pipe
-        @lifeline_reader, @lifeline_writer = IO.pipe
-        previous_traps = install_traps
-
-        count.times { |index| start_worker(index) }
-
-        loop do
-          wait_for_wakeup
-          reap_exited_workers
-          break if @stopping && @workers.empty?
-          start_due_restarts unless @stopping
-        end
-
-        logger.info "all workers exited"
-        0
-      ensure
-        # If we're leaving for any reason other than "every child is gone" (a bug, say), don't
-        # orphan the children: tell them to stop too. Then hand the signals back.
-        relay("TERM") if @workers.any?
-        previous_traps&.each { |sig, handler| trap(sig, handler) }
-        [@signal_reader, @signal_writer, @lifeline_reader, @lifeline_writer].each { |io| io&.close }
-      end
-
-      # Ask the supervisor to shut down as if `signal` had arrived: relay it to every worker and
-      # exit once they're gone. Safe from any thread and from a trap handler; the work happens on
-      # the thread running `run`.
-      def stop!(signal = "TERM")
-        wake(signal)
-      end
-
-      def stopping?
-        @stopping
-      end
-
-      # Pids of the children alive right now.
-      def worker_pids
-        @workers.values.map(&:pid)
-      end
-
-      private
-
-      # ---- The parent ----------------------------------------------------------------------
-
-      def install_traps
-        (STOP_SIGNALS + %w[CHLD]).to_h do |sig|
-          [sig, trap(sig) { wake(sig) }]
-        end
-      end
-
-      # Runs in signal context, so it does the one thing that's safe there: a non-blocking write
-      # to the pipe. A full pipe means plenty of wake-ups are already queued, so dropping is fine.
-      def wake(signal)
-        @signal_writer&.write_nonblock("#{signal}\n")
-      rescue IO::WaitWritable, IOError, Errno::EPIPE
-        nil
-      end
-
-      # Sleep until a signal or child exit wakes us, a restart is due, or the poll interval
-      # passes. Any stop signal on the pipe starts the shutdown.
-      def wait_for_wakeup
-        timeout = [POLL_INTERVAL, seconds_until_next_restart].compact.min
-        ready, = IO.select([@signal_reader], nil, nil, timeout)
-        return unless ready
-
-        pending = begin
-          @signal_reader.read_nonblock(4096)
-        rescue IO::WaitReadable, EOFError
-          ""
-        end
-        pending.split("\n").each { |signal| begin_stopping(signal) if STOP_SIGNALS.include?(signal) }
-      end
-
-      def begin_stopping(signal)
-        if @stopping
-          # A second Ctrl-C or TERM: pass it along again, in case a child missed the first
-          relay(signal)
-          return
-        end
-
-        @stopping = true
-        @restart_at.clear
-        logger.info "got SIG#{signal}, relaying to #{@workers.size} worker(s) and waiting for them"
-        relay(signal)
-      end
-
-      def relay(signal)
-        @workers.each_value do |worker|
-          Process.kill(signal, worker.pid)
-        rescue Errno::ESRCH
-          nil # already gone; the next reap logs it
-        end
-      end
-
-      def reap_exited_workers
-        @workers.values.each do |worker|
-          status = begin
-            _, status = Process.wait2(worker.pid, Process::WNOHANG)
-            status
-          rescue Errno::ECHILD
-            :unknown # someone else reaped it; treat it as gone
-          end
-          next if status.nil?
-
-          @workers.delete(worker.index)
-          uptime = now - worker.started_at
-          reason = describe_exit(status)
-
-          if @stopping
-            logger.info "worker #{worker.index} (pid #{worker.pid}) #{reason} after #{uptime.round}s"
-          else
-            delay = restart_delay(worker.index, uptime)
-            @restart_at[worker.index] = now + delay
-            logger.warn "worker #{worker.index} (pid #{worker.pid}) #{reason} after #{uptime.round}s; " \
-                        "restarting #{delay.zero? ? 'now' : "in #{delay}s"}"
-          end
-        end
-      end
-
-      def describe_exit(status)
-        return "exited (status unknown)" if status == :unknown
-        return "killed by SIG#{Signal.signame(status.termsig)}" if status.signaled?
-
-        "exited with status #{status.exitstatus}"
-      end
-
-      # A worker that lived a while and then died gets replaced right away. One that died
-      # almost immediately most likely can't boot, so wait, and wait longer each time it happens.
-      def restart_delay(index, uptime)
-        if uptime >= @stable_after
-          @backoff.delete(index)
-          0
-        else
-          @backoff[index] = @backoff[index] ? [@backoff[index] * 2, @max_backoff].min : @first_backoff
-        end
-      end
-
-      def start_due_restarts
-        due = @restart_at.select { |_, at| at <= now }.keys
-        due.each do |index|
-          @restart_at.delete(index)
-          start_worker(index)
-        end
-      end
-
-      def seconds_until_next_restart
-        next_at = @restart_at.values.min
-        next_at && [next_at - now, 0].max
-      end
-
-      def start_worker(index)
-        pid = fork_worker(index)
-        @workers[index] = Worker.new(index, pid, now)
-        logger.info "forked worker #{index} (pid #{pid})"
-      end
-
-      def now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      # ---- The child -----------------------------------------------------------------------
-
-      def fork_worker(index)
-        Process.fork do
-          status = 1
-          begin
-            # The child inherits the parent's traps and both ends of its wake-up pipe. Neither
-            # belongs here: a relayed SIGTERM must reach the body's own handler (or kill the
-            # child by default) instead of writing to a pipe nobody in this process reads.
-            (STOP_SIGNALS + %w[CHLD]).each { |sig| trap(sig, "DEFAULT") }
-            @signal_reader.close
-            @signal_writer.close
-            @workers = {}
-
-            # Give up our copy of the lifeline's write end first, so a sibling can never keep the
-            # pipe open after the parent is gone; then watch the read end for the parent's death
-            @lifeline_writer.close
-            watch_parent(@lifeline_reader)
-
-            CableRoom.after_fork!
-
-            result = @body.call(index)
-            status = result.is_a?(Integer) ? result : 0
-          rescue SystemExit => e
-            status = e.status
-          rescue SignalException
-            raise # let Ruby end the process with the signal, so the parent sees which one
-          rescue Exception => e # rubocop:disable Lint/RescueException -- the child must not outlive a broken body
-            logger.error "worker #{index} (pid #{Process.pid}) crashed: #{e.class}: #{e.message}\n  #{e.backtrace&.first(10)&.join("\n  ")}"
-            status = 1
-          end
-
-          $stdout.flush
-          $stderr.flush
-          exit!(status)
-        end
-      end
-
-      # Once every child has closed its copy, the parent holds the only write end of the lifeline
-      # pipe, so a read here returns EOF exactly when the parent is gone: crashed, or SIGKILLed by
-      # the container's `timeout -k`. A worker must not carry on hosting rooms with nobody
-      # supervising it, so it stops itself the same way a relayed SIGTERM would stop it.
-      def watch_parent(reader)
-        thread = Thread.new do
-          reader.read(1)
-          Process.kill("TERM", Process.pid)
-        end
-        thread.name = "cable_room-supervisor-lifeline"
-        thread.report_on_exception = false
-        thread
-      end
-    end
-  end
-end