cable_room 0.6.2.beta1 → 0.7.0.beta2

data/lib/cable_room.rb

@@ -8,10 +8,18 @@ require 'redlock'
 require 'rufus-scheduler'
 
 require_relative 'cable_room/railtie'
+require_relative 'cable_room/config'
+require_relative 'cable_room/broadcaster'
 
-require_relative 'cable_room/channel_base'
-require_relative 'cable_room/channel_tracker'
+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/'
@@ -36,6 +44,27 @@ 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!
+    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!
+    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
+    end
+
     def redis_pool
       require 'rediconn'
       @redis_pool ||= RediConn::RedisConnection.create(env_prefix: "CABLEROOM")
@@ -50,5 +79,31 @@ module CableRoom
         CableRoom.redis,
       ])
     end
+
+    # The process-wide Redis bus (see CableRoom::Bus). Built on first use.
+    def bus
+      @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).
+    #
+    # 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 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.
+    def after_fork!
+      @bus = nil
+      @lock_manager = nil
+      @redis_pool = nil
+      Host.replace_current(nil)
+    end
   end
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: cable_room
 version: !ruby/object:Gem::Version
-  version: 0.6.2.beta1
+  version: 0.7.0.beta2
 platform: ruby
 authors:
 - Ethan Knapp
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -77,14 +77,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '5.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -101,32 +101,49 @@ dependencies:
         version: '3'
 email:
 - eknapp@instructure.com
-executables: []
+executables:
+- cable_room
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - README.md
 - cable_room.gemspec
+- exe/cable_room
 - lib/cable_room.rb
-- lib/cable_room/channel_base.rb
-- lib/cable_room/channel_tracker.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/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
 - lib/cable_room/room/base.rb
 - lib/cable_room/room/broadcasting.rb
 - lib/cable_room/room/callbacks.rb
-- lib/cable_room/room/channel_adapter.rb
+- lib/cable_room/room/host_adapter.rb
 - lib/cable_room/room/input_handling.rb
 - lib/cable_room/room/lifecycle.rb
 - lib/cable_room/room/port_management.rb
 - 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/lib/cable_room/channel_base.rb

@@ -1,247 +0,0 @@
-module CableRoom
-  class ChannelBase < ActionCable::Channel::Base
-    attr_reader :room, :tenant
-    attr_reader :server, :logger
-    delegate :event_loop, :worker_pool, :pubsub, to: :server
-
-    def initialize(lock_info, room_class, key, config)
-      # We don't really have a "connection" in the ActionCable sense, so
-      #   stuff in something that half looks like one
-      super(DummyConnection.new(self), "Room[]", {})
-
-      # Used mainly for logs and being able to follow a specific Room instance
-      @uuid = SecureRandom.hex(6)
-
-      @mutex = Monitor.new
-      @lock_info = lock_info
-      @current_state = :initializing
-
-      @tenant = Apartment::Tenant.current if defined?(Apartment)
-
-      @server = ChannelTracker.instance
-      @logger = ActionCable::Connection::TaggedLoggerProxy.new(
-        @server.logger,
-        tags: ["#{room_class.name} #{@uuid}"]
-      )
-
-      logger.info "Initializing new #{room_class.name}"
-      logger.info "  UUID: #{@uuid}"
-      logger.info "  Key: #{room_class.room_port_key(key)}"
-
-      @watchdog_interval = config[:watchdog_interval]
-      @lock_duration = config[:lock_duration]
-
-      @processing_work = false
-      @work_queue = []
-
-      @room = room_class.new(self, key)
-      @server.track_room_channel self
-      ping_watchdog
-    end
-
-    def self.channel_name
-      module_parent.name
-    end
-
-    def stream_from(...)
-      raise ArgumentError, "Block required" unless block_given?
-      super
-    end
-
-    def state
-      @current_state
-    end
-
-    after_subscribe do
-      begin
-        @current_state = :starting
-        @room.send(:_startup)
-        @current_state = :started
-      rescue => e
-        terminate!
-        raise e
-      end
-    end
-
-    after_unsubscribe do
-      @mutex.synchronize do
-        @current_state = :shutting_down
-        stop_all_streams
-        begin
-          @room.send(:_shutdown)
-        ensure
-          terminate!
-        end
-      end
-    end
-
-    def ping_watchdog
-      return if state == :dead
-
-      logger.debug "Ping watchdog"
-      @last_watchdog_ping_at = Time.current
-    end
-
-    def check_room_watchdog
-      @mutex.synchronize do
-        return if state == :dead || state == :shutting_down
-      end
-
-      relock = CableRoom.lock_manager.lock(@lock_info[:resource], @lock_duration.in_milliseconds, extend: @lock_info)
-      unless relock
-        logger.warn "Lost lock, shutting down"
-        unsubscribe_from_channel
-        return
-      end
-
-      unless @last_watchdog_ping_at && @last_watchdog_ping_at > @watchdog_interval.ago
-        logger.warn "Watchdog timeout for room #{@room.class.name}[#{@room.key}], shutting down"
-        initiate_shutdown("Watchdog timeout")
-        return
-      end
-    end
-
-    def initiate_shutdown(reason)
-      @mutex.synchronize do
-        return if @current_state == :dead || @current_state == :shutting_down
-
-        logger.info "Initiating shutdown: #{reason}"
-
-        # Stop streams immediately to prevent further messages from being added
-        stop_all_streams
-
-        # Append the final unsubscribe to the work queue so we can process remaining messages first
-        post_work(async: false) do
-          unsubscribe_from_channel
-        end
-
-        @current_state = :shutting_down
-      end
-    end
-
-    def terminate!
-      @mutex.synchronize do
-        stop_all_streams
-        @current_state = :dead
-        CableRoom.lock_manager.unlock(@lock_info) if @lock_info
-        server.untrack_room_channel self
-      end
-    end
-
-    def _post_wrapped_work(async: false, silent: false, &blk)
-      if async
-        # Async stuff is mostly untracked - we just post it to the worker pool and forget about it
-        worker_pool.executor.post(&blk)
-      else
-        @mutex.synchronize do
-          if @current_state == :dead || @current_state == :shutting_down
-            raise "Attempt to post work to dead or shutting down room" unless silent
-            return
-          end
-          @work_queue << blk
-        end
-        schedule_work
-      end
-    end
-
-    def post_work(**kwargs, &blk)
-      _post_wrapped_work(**kwargs) do
-        worker_pool.invoke(self, :instance_exec, connection: self, &blk)
-      rescue => e
-        report_work_error(e)
-      end
-    end
-
-    # Work errors are swallowed so one bad message can't take the Room down with it. Log the
-    # backtrace and hand the error to the application so the failure is still discoverable.
-    def report_work_error(error)
-      logger.error "Error during work execution: #{error.class.name}: #{error.message}"
-      Array(error.backtrace).first(20).each { |line| logger.error "  #{line}" }
-
-      CableRoom.report_error(
-        error,
-        room: room,
-        room_class: room&.class,
-        room_key: room&.key,
-        channel: self
-      )
-    end
-
-    def beat
-      post_work(async: true) do
-        check_room_watchdog
-      end
-    end
-
-    def transmit(*args)
-      logger.info("Channel.transmit called, ignoring: #{args.inspect}")
-    end
-
-    protected
-
-    def start_periodic_timer(callback, every:)
-      raise "Attempt to start periodic timer on a dead room" if state == :dead || state == :shutting_down
-
-      job = connection.server.scheduler.schedule_every(every) do
-        post_work(async: false, silent: true) do
-          instance_exec(&callback)
-        end
-      end
-
-      PeriodicTimer.new(job)
-    end
-
-    def schedule_work
-      @mutex.synchronize do
-        return if @processing_work
-
-        work = @work_queue.shift
-        return unless work
-
-        @processing_work = true
-
-        worker_pool.executor.post do
-          begin
-            work.call
-          ensure
-            @mutex.synchronize do
-              @processing_work = false
-            end
-            schedule_work
-          end
-        end
-      end
-    end
-  end
-
-  # ActionCable's `stop_periodic_timers` calls #shutdown on whatever #start_periodic_timer
-  # returned, but Rufus jobs are cancelled with #unschedule. Adapt the one to the other here
-  # rather than aliasing #shutdown onto Rufus::Scheduler::Job for the whole process.
-  class PeriodicTimer
-    attr_reader :job
-
-    delegate :unschedule, :scheduled?, :next_time, to: :job
-
-    def initialize(job)
-      @job = job
-    end
-
-    def shutdown
-      job.unschedule
-    end
-  end
-
-  class DummyConnection
-    attr_reader :channel
-    delegate :server, :logger, :tenant, :transmit, :post_work, :_post_wrapped_work,
-             :report_work_error, to: :channel
-    delegate :event_loop, :pubsub, :worker_pool, to: :server
-
-    attr_reader :identifiers
-
-    def initialize(channel)
-      @channel = channel
-      @identifiers = []
-    end
-  end
-end

data/lib/cable_room/channel_tracker.rb

@@ -1,130 +0,0 @@
-module CableRoom
-  class ChannelTracker
-    def self.instance
-      @instance ||= new
-    end
-
-    BEAT_INTERVAL = 5.seconds
-
-    delegate :logger, :pubsub, :event_loop, :config, to: :cable_server
-
-    attr_reader :room_channels, :scheduler
-
-    def initialize
-      @room_channels = Set.new
-      @monitor = Monitor.new
-
-      @scheduler = Rufus::Scheduler.new
-
-      at_exit do
-        logger.info "Shutting down CableRoom"
-        shutdown!
-      end
-
-      scheduler.every(BEAT_INTERVAL) do
-        each_room_channel do |chan|
-          chan.beat
-        end
-      end
-    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 { @worker_pool ||= ThreadPool.new(max_size: config.worker_pool_size) }
-    end
-
-    def track_room_channel(chan)
-      raise "Cannot add Room after shutdown" if @shutdown
-      @room_channels << chan
-    end
-
-    def untrack_room_channel(chan)
-      @room_channels.delete(chan)
-    end
-
-    def shutdown?
-      @shutdown
-    end
-
-    def shutdown!
-      @monitor.synchronize do
-        @shutdown = true
-
-        scheduler.shutdown
-
-        shutdown_rooms!
-
-        worker_pool.executor.shutdown
-        worker_pool.executor.wait_for_termination(5)
-        worker_pool.executor.kill
-      end
-    end
-
-    def shutdown_rooms!
-      @monitor.synchronize do
-        each_room_channel do |chan|
-          chan.initiate_shutdown("Server shutting down")
-        end
-      end
-
-      count = 0
-      loop do
-        break if @room_channels.empty? || count >= 15
-        sleep 1
-        count += 1
-      end
-    end
-
-    def each_room_channel(&blk)
-      @room_channels.dup.each(&blk)
-    end
-
-    private
-
-    def cable_server
-      ActionCable.server
-    end
-
-    class ThreadPool < 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
-
-      # 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)
-        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
-
-      def async_invoke(receiver, method, *args, connection: receiver, &block)
-        # Instead of posting directly to the global pool, post to a dedicated queue for the room/"connection".
-        #   This makes each rooms so that they can be processed by at-most-one thread at a time, while still
-        #   allowing multiple rooms to be processed by the same thread-pool.
-
-        # TODO Implement more of a round-robin approach so that no room can starve out others?
-
-        # "connection" here really references the Channel, since "Connections" in this context don't really exist
-
-        connection._post_wrapped_work(async: false) do
-          invoke(receiver, method, *args, connection: connection, &block)
-        end
-      end
-    end
-
-  end
-end

data/lib/cable_room/room/channel_adapter.rb

@@ -1,18 +0,0 @@
-module CableRoom
-  module Room
-    module ChannelAdapter
-      extend ActiveSupport::Concern
-
-      Channel = CableRoom::ChannelBase
-
-      class_methods do
-        def inherited(subclass)
-          # Descend from *this* class's Channel, so periodic timers and other channel-level
-          # configuration survive multiple levels of subclassing
-          subclass.const_set(:Channel, Class.new(self::Channel))
-          super
-        end
-      end
-    end
-  end
-end