cable_room 0.8.0.beta1 → 0.8.0.beta2

data/lib/cable_room/room_member.rb

@@ -9,8 +9,9 @@ module CableRoom
     # ~30% of all room messages at 10 s with no skipping.
     PING_INTERVAL = 15.seconds
 
-    # A dropped announcement is invisible to the port. The room's inbound subscription is
-    # registered asynchronously — and the room may live in another process entirely — so a
+    # A dropped announcement is invisible to the port. The room hears members on the Bus, and its
+    # subscription is live once the room has started, but the room may not have started yet, may
+    # live in another process, or the Bus may be reconnecting; Redis pub/sub doesn't queue, so a
     # port_connected sent before the room is listening is discarded with no error. Re-announce on
     # a doubling backoff from here until the room acknowledges, rather than waiting out a whole
     # PING_INTERVAL. port_connected is idempotent on the room side (the port is merged,
@@ -178,8 +179,11 @@ module CableRoom
       schedule_reannounce
     end
 
-    protected
+    # -- The member side of Ports ---------------------------------------------------------------
 
+    # Everything a member sends goes to its room, so it's published on the room's Bus channel for
+    # `port` (see Room::Base.inbound_channel). The room's Host is subscribed there and queues the
+    # message on the room. Public because `ports[:x] << msg` reaches it through a PortProxy.
     def port_transmit(port, data, secure_context: false)
       data[:mtok] = @token
 
@@ -191,18 +195,37 @@ module CableRoom
         end
       end
 
-      super(port, data)
+      CableRoom.bus.publish(room_class.inbound_channel(@room_key, port), data)
       # Pings don't count: a ping must never be the reason the next ping is skipped.
       @last_transmit_at = monotonic_now unless type == :port_ping
     end
 
+    # Room→member traffic arrives on ActionCable streams (the room broadcasts to them), so
+    # listening on a port is a plain stream_from on the member's channel.
+    def stream_port(port, auto_close: true, &blk)
+      @cable_channel.stream_from(room_port_key(port), coder: ActiveSupport::JSON, &blk)
+      _streamed_ports << port if auto_close
+    end
+
+    def close_streamed_ports!
+      _streamed_ports.each do |port|
+        @cable_channel.stop_stream_from(room_port_key(port))
+      end
+      _streamed_ports.clear
+    end
+
+    protected
+
     # Re-announce until the room acknowledges the port, doubling the wait each time. Handing off
     # to ping! at PING_INTERVAL keeps a stuck membership from holding a timer open forever.
+    #
+    # The timer is a plain Concurrent::ScheduledTask, not the Host's scheduler: in :remote a web
+    # process has no Host, and the member side must never need one.
     def schedule_reannounce
       @mutex.synchronize do
         cancel_reannounce
         return if @has_established || @has_left
-        return if Host.instance.shutdown?
+        return if Host.current&.shutdown?
 
         next_delay = @reannounce_delay ? @reannounce_delay * 2 : RoomMember::REANNOUNCE_INITIAL_DELAY
         return if next_delay > RoomMember::PING_INTERVAL
@@ -213,7 +236,7 @@ module CableRoom
         # membership rather than relying on `self`.
         membership = self
         channel = @cable_channel
-        @reannounce_job = Host.instance.scheduler.schedule_in(@reannounce_delay.to_f) do
+        @reannounce_job = Concurrent::ScheduledTask.execute(@reannounce_delay.to_f) do
           channel.connection.worker_pool.async_exec(channel, connection: channel.connection) do
             membership.transmit_port_connected unless membership.connected? || membership.left?
           end
@@ -223,7 +246,7 @@ module CableRoom
 
     def cancel_reannounce
       @mutex.synchronize do
-        @reannounce_job&.unschedule
+        @reannounce_job&.cancel
         @reannounce_job = nil
       end
     end
@@ -317,12 +340,44 @@ module CableRoom
       end
     end
 
+    # Start the room if `create: true` asked for it and nobody runs it yet. Called at join and
+    # again on every ping, so a room whose host died comes back.
     def maybe_provision_room
       return if left?
       return unless @allow_create
-      return if Host.instance.shutdown?
+      return request_remote_room if CableRoom.remote?
+      return if Host.current&.shutdown?
 
       @room_class.ensure(@room_key)
     end
+
+    # In :remote this process never hosts rooms, so `create: true` asks the rooms Hosts to start
+    # it: a provision request on the Bus, which every rooms Host's Placement hears and races for,
+    # the least-loaded first (see Host::Placement). Called at join and on every ping, even once the
+    # room has acknowledged the port, the same as `ensure` on every ping in :inline: a rooms
+    # process that dies sends no room_closed, and this is what brings its rooms back within one
+    # ping. While the room runs it costs one publish per member per ping, and a single-attempt lock
+    # try on each rooms Host that isn't running it (the one that is skips the request).
+    #
+    # The request names our tenant, since a rooms process has no request tenant of its own: the
+    # Host that claims the room starts it there, so its lock, inbound channel, and stream names
+    # match the ones this member uses.
+    def request_remote_room
+      request = {
+        type: Host::Placement::REQUEST_TYPE,
+        room_class: room_class.name,
+        # Keys travel the way `extra` does, so a record key arrives on the host as the record
+        room_key: ::ActiveJob::Arguments.serialize([@room_key]),
+        tenant: CableRoom.current_tenant,
+        requested_at: Time.current,
+      }
+
+      ActiveSupport::Notifications.instrument(
+        "provision_requested.cable_room",
+        { membership: self, room_class: room_class, room_key: @room_key, tenant: request[:tenant], request: request }
+      ) do
+        CableRoom.bus.publish(Bus.provision_channel, request)
+      end
+    end
   end
 end

data/lib/cable_room/version.rb

@@ -1,3 +1,3 @@
 module CableRoom
-  VERSION = "0.8.0.beta1".freeze
+  VERSION = "0.8.0.beta2".freeze
 end

data/lib/cable_room.rb

@@ -4,11 +4,15 @@ require 'active_support/time'
 require 'active_support/core_ext/module'
 
 require 'action_cable'
+require 'concurrent'
 require 'redlock'
 require 'rufus-scheduler'
 
+require_relative 'cable_room/config'
 require_relative 'cable_room/railtie'
 
+require_relative 'cable_room/bus'
+
 require_relative 'cable_room/periodic_timer'
 require_relative 'cable_room/host'
 require_relative 'cable_room/ports'
@@ -18,6 +22,9 @@ require_relative 'cable_room/room/'
 require_relative 'cable_room/version'
 
 module CableRoom
+  BUS_LOCK = Mutex.new
+  private_constant :BUS_LOCK
+
   class << self
     # Called as `handler.call(error, context)` whenever work inside a Room raises. Rooms swallow
     # exceptions so that one bad message can't kill the Room, which makes this the only way to
@@ -36,6 +43,31 @@ module CableRoom
       warn "CableRoom.error_handler raised #{handler_error.class}: #{handler_error.message}"
     end
 
+    # The Apartment tenant the calling thread is in, or nil in an app without Apartment
+    def current_tenant
+      Apartment::Tenant.current if defined?(Apartment)
+    end
+
+    # Run the block switched into `tenant`. Does nothing extra when there's no tenant, no
+    # Apartment, or the thread is already in it, so an :inline join (which starts its room in its
+    # own tenant) never switches at all.
+    def with_tenant(tenant, &blk)
+      return yield if tenant.nil? || !defined?(Apartment) || Apartment::Tenant.current == tenant
+
+      Apartment::Tenant.switch(tenant, &blk)
+    end
+
+    # Run the block inside the Rails app's executor (database connections, reloading, and so on),
+    # the way ActionCable wraps channel callbacks. Nesting is fine: the executor yields straight
+    # through when it's already active on this thread. Without Rails it just yields.
+    def with_app_executor(&blk)
+      if defined?(Rails) && Rails.application
+        Rails.application.executor.wrap(&blk)
+      else
+        yield
+      end
+    end
+
     def redis_pool
       require 'rediconn'
       @redis_pool ||= RediConn::RedisConnection.create(env_prefix: "CABLEROOM")
@@ -50,5 +82,41 @@ module CableRoom
         CableRoom.redis,
       ])
     end
+
+    # The process-wide Redis bus (see CableRoom::Bus). Built on first use. Guarded so two threads
+    # racing to it can't each build one: a handler registered on the loser would be stranded.
+    def bus
+      @bus || BUS_LOCK.synchronize { @bus ||= Bus.new }
+    end
+
+    # Call this in a child process right after `fork`, before it touches Redis or hosts a room.
+    # `cable_room server --workers N` does it in every worker (see Host::Supervisor); an app that
+    # forks for its own reasons (Puma's `on_worker_boot` with `preload_app!`, a job runner) should
+    # call it there too.
+    #
+    # A forked child starts with copies of the parent's objects but only the forking thread, so
+    # anything that owns a thread or a socket is broken in the child: the Bus subscriber thread
+    # doesn't exist, a mutex may be held by a thread that's gone, and a Redis socket is shared
+    # with the parent, so both processes would read each other's replies. This drops the memos,
+    # so the next caller builds fresh ones:
+    #
+    #   * the Bus. The copy is only dropped, not shut down: its pub/sub socket is still the
+    #     parent's, and anything sent on it (even a TLS close_notify) would land in the parent's
+    #     session. GC closes the child's copy of the descriptor quietly.
+    #   * the Redlock client, whose monitor may be held by a parent thread.
+    #   * the Host, whose rooms, locks, and threads are the parent's. It's abandoned (see
+    #     Host#abandon!) so its `at_exit` hook can't close the parent's rooms when the child exits.
+    #
+    # Pooled connections need nothing from us. `redis_pool` is RediConn's shared pool for the
+    # URL (the same object comes back if we rebuild it), and connection_pool drops the connections
+    # it inherited on its own (it hooks `Process._fork`); redis-client also reconnects any client
+    # it finds in a new pid. Rails does the same for ActiveRecord (`PoolConfig.discard_pools!`
+    # runs after every fork), and its pools reconnect lazily on first use.
+    def after_fork!
+      BUS_LOCK.synchronize { @bus = nil }
+      @lock_manager = nil
+      Host.replace_current(nil)&.abandon!
+      nil
+    end
   end
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: cable_room
 version: !ruby/object:Gem::Version
-  version: 0.8.0.beta1
+  version: 0.8.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,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -101,16 +107,23 @@ dependencies:
         version: '3'
 email:
 - eknapp@instructure.com
-executables: []
+executables:
+- cable_room
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
 - cable_room.gemspec
+- exe/cable_room
 - lib/cable_room.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/action_cable_inbound.rb
+- lib/cable_room/host/bus_inbound.rb
+- lib/cable_room/host/placement.rb
 - lib/cable_room/host/runner.rb
+- lib/cable_room/host/supervisor.rb
 - lib/cable_room/host/worker_pool.rb
 - lib/cable_room/periodic_timer.rb
 - lib/cable_room/ports.rb

data/lib/cable_room/host/action_cable_inbound.rb

@@ -1,35 +0,0 @@
-module CableRoom
-  class Host
-    # How rooms receive messages: straight off ActionCable's pubsub adapter, on the same stream
-    # names members publish to (Room::Base.room_port_key). This is the only place the room side
-    # touches ActionCable for inbound traffic; anything with the same two methods can be handed to
-    # `Host.new(inbound:)`.
-    #
-    # `subscribe` returns a handle that `unsubscribe` needs back. Handlers receive the payload
-    # exactly as published (a JSON string, for ActionCable) on the adapter's own thread, so they
-    # must be quick and hand the real work off. Host::Runner does that by queueing it on the room.
-    # `on_live` runs on that same thread once the adapter confirms the subscription.
-    class ActionCableInbound
-      # Subscribes from the calling thread. ActionCable's own stream_from posts the subscribe to
-      # the event loop first, but the adapter registers asynchronously either way, so that extra
-      # hop only widens the window in which the room can't hear anything.
-      #
-      # The adapter calls `on_live` while holding its own subscriber-map lock, so it must never
-      # wait on anything that might be waiting on the adapter (a room's mutex, say).
-      def subscribe(stream, on_live: nil, &on_message)
-        server.pubsub.subscribe(stream, on_message, on_live)
-        on_message
-      end
-
-      def unsubscribe(stream, handle)
-        server.pubsub.unsubscribe(stream, handle)
-      end
-
-      private
-
-      def server
-        ActionCable.server
-      end
-    end
-  end
-end