cable_room 0.7.0.beta3 → 0.8.0.beta1

data/lib/cable_room/room/base.rb

@@ -10,48 +10,61 @@ module CableRoom
       class << self
         # Start this room in the current process if nobody else is running it. Takes the room's
         # Redlock first, so exactly one process wins; returns false when the lock is held.
-        #
-        # Only a process that hosts rooms can do this: every process in :inline, and only
-        # `cable_room server` in :remote. Anywhere else `Host.instance` raises Host::NotHosting
-        # rather than letting a room start where it doesn't belong.
         def ensure(key = nil)
-          Host.instance.ensure_room(self, key)
+          lock_key = room_port_key(key)
+          # One attempt: a held lock means the room is already running, and retrying (Redlock's
+          # default is 3 retries, 200-250 ms apart) would park the caller's ActionCable worker for
+          # ~0.7 s on every `create: true` member's ping.
+          lock_info = CableRoom.lock_manager.lock(lock_key, self::LOCK_DURATION.in_milliseconds, retry_count: 0)
+          return false unless lock_info
+
+          Host.instance.start_room(
+            self,
+            key,
+            lock_info,
+            watchdog_interval: self::WATCH_DOG_INTERVAL,
+            lock_duration: self::LOCK_DURATION,
+          )
+
+          true
+        rescue => e
+          CableRoom.lock_manager.unlock(lock_info) if lock_info
+          raise e
         end
 
         # The stream name for a room, or for one of its ports: "RoomClass:key" or
-        # "RoomClass:key:port". Members and rooms both use this, so it has to be stable.
+        # "RoomClass:key:port". Members and rooms both use this, so it has to stay stable. These
+        # are the names rooms had as ActionCable channels (`broadcasting_for`), so a rolling deploy
+        # and the browser side see no change. It's also the room's Redlock key.
         def room_port_key(room_key, port = nil)
-          parts = [name, room_key]
-          parts << port if port
-          parts.map { |part| serialize_key_part(part) }.join(":")
+          full_key = [room_key]
+          full_key << port if port
+          stream_namer.broadcasting_for(full_key)
         end
 
-        # The Bus channel members publish on to reach a room's inbound port `port`, and the one
-        # the room's Host subscribes to for it. `room_port_key(room_key)` ("RoomClass:key") is the
-        # room's cluster-wide identity — it's already the Redlock key — so the main port lands on
-        # the design's `cr:{room_key}:in` and a custom port on `cr:{room_key}:in:{port}`.
-        def inbound_channel(room_key, port = ROOM_IN_CHANNEL)
-          port = port.to_s == ROOM_IN_CHANNEL.to_s ? nil : serialize_key_part(port)
-          Bus.inbound_channel(room_port_key(room_key), port)
-        end
-
-        # Send a message to a room from anywhere in the app: same Bus channel a member uses
         def send_message(room_key, data, port: ROOM_IN_CHANNEL)
-          CableRoom.bus.publish(inbound_channel(room_key, port), data)
+          ActionCable.server.broadcast(room_port_key(room_key, port), data)
         end
 
-        # Every instance of this room class running in this process. Empty when the process
-        # hosts no rooms at all (a web process in :remote).
         def locally_running_instances
-          Room.locally_open_rooms.select { |room| room.class == self }
+          Host.instance.runners.select do |runner|
+            runner.room_class == self
+          end.map(&:room)
         end
 
         private
 
-        # Same rule ActionCable uses to name broadcasts: records go by their GlobalID, anything
-        # else by `to_param`
-        def serialize_key_part(part)
-          part.respond_to?(:to_gid_param) ? part.to_gid_param : part.to_param
+        # Names this room's streams the way it did when it was an ActionCable channel: through
+        # that channel class's `broadcasting_for`, so an app's override of it still applies.
+        # PandaPal's puts the Apartment tenant first, which keeps two tenants' rooms with the
+        # same key (and their Redlocks) apart. Never instantiated; it only answers `channel_name`.
+        def stream_namer
+          @stream_namer ||= begin
+            room_class = self
+            Class.new(ActionCable::Channel::Base) do
+              define_singleton_method(:channel_name) { room_class.name }
+            end
+          end
         end
       end
 
@@ -62,7 +75,6 @@ module CableRoom
       include HostAdapter
 
       include Lifecycle
-      include Snapshotting
       include Reaping
       include InputHandling
 
@@ -73,7 +85,7 @@ module CableRoom
 
       attr_reader :key
 
-      delegate :logger, :tenant, to: :@runner
+      delegate :logger, to: :@runner
 
       def initialize(runner, key = nil)
         super()
@@ -85,13 +97,6 @@ module CableRoom
         port_transmit(ROOM_OUT_CHANNEL, data)
       end
 
-      # The room's sending side of Ports: room→member messages go out on the stream named by
-      # `room_port_key(port)` through the configured CableRoom::Broadcaster. (The listening side
-      # is in Room::HostAdapter.) Public because `ports[:x] << msg` reaches it through a PortProxy.
-      def port_transmit(port, data)
-        broadcaster.broadcast(room_port_key(port), data)
-      end
-
       protected
 
       def room_class
@@ -101,10 +106,6 @@ module CableRoom
       def room_port_key(sub_channel = nil)
         self.class.room_port_key(key, sub_channel)
       end
-
-      def broadcaster
-        Broadcaster.current
-      end
     end
   end
 end

data/lib/cable_room/room/callbacks.rb

@@ -7,7 +7,6 @@ module CableRoom
       included do
         define_callbacks :startup
         define_callbacks :shutdown
-        define_callbacks :work
       end
 
       class_methods do
@@ -28,27 +27,6 @@ module CableRoom
           set_callback(:shutdown, :after, *methods, &block)
         end
         alias_method :on_shutdown, :after_shutdown
-
-        # Wraps every piece of Room code that runs on a Host thread: startup/restore, message and
-        # timer handlers, snapshot_state, and shutdown alike (see Host::Runner#with_room_context,
-        # the one thing that ever triggers the :work callback chain). This is the seam for
-        # anything that has to be true before a Room's own code runs on a given thread -- Apartment
-        # switching first among them (see README's Multi-tenancy section).
-        #
-        # Define it once on your own shared base Room class (or reopen CableRoom::Room::Base
-        # itself) to cover every Room; define it again on a specific Room subclass for one that
-        # needs something different -- ordinary callback inheritance, nothing cable_room-specific.
-        def before_work(*methods, &block)
-          set_callback(:work, :before, *methods, &block)
-        end
-
-        def after_work(*methods, &block)
-          set_callback(:work, :after, *methods, &block)
-        end
-
-        def around_work(*methods, &block)
-          set_callback(:work, :around, *methods, &block)
-        end
       end
     end
   end

data/lib/cable_room/room/host_adapter.rb

@@ -23,27 +23,22 @@ module CableRoom
         end
       end
 
-      # The room's listening side of Ports: subscribe, through the Host, to the Bus channel
-      # members publish on for `port` (see Room::Base.inbound_channel). `on_live` runs once the
-      # subscription is confirmed, the same as it does for members.
+      # The room side of Ports#stream_port: listen on this room's inbound stream for `port`.
+      # `on_live` runs once the subscription is confirmed.
       def stream_port(port, auto_close: true, on_live: nil, &blk)
-        @runner.subscribe(inbound_channel(port), on_live: on_live, &blk)
+        @runner.subscribe(room_port_key(port), coder: ActiveSupport::JSON, on_live: on_live, &blk)
         _streamed_ports << port if auto_close
       end
 
       def close_streamed_ports!
         _streamed_ports.each do |port|
-          @runner.unsubscribe(inbound_channel(port))
+          @runner.unsubscribe(room_port_key(port))
         end
         _streamed_ports.clear
       end
 
       protected
 
-      def inbound_channel(port)
-        self.class.inbound_channel(key, port)
-      end
-
       def start_periodic_timer(callback, every:)
         @runner.start_periodic_timer(-> { instance_exec(&callback) }, every: every)
       end

data/lib/cable_room/room/lifecycle.rb

@@ -5,10 +5,8 @@ module CableRoom
 
       included do
         after_startup do
-          logger.info restored? ? "Restored" : "Started"
-          # A restored room's members were attached the whole time; telling them the room opened
-          # would make every one of them re-announce for nothing.
-          self << { type: 'room_opened' } unless restored?
+          logger.info "Started"
+          self << { type: 'room_opened' }
         end
 
         before_shutdown do
@@ -27,8 +25,7 @@ module CableRoom
         @runner.state
       end
 
-      # Requests that the Room shut down gracefully, processing any pending messages. A frozen
-      # room (mid-migration) shuts down the same way; that's the "no peer took it" path.
+      # Requests that the Room shut down gracefully, processing any pending messages
       def shutdown!(reason = "Room requested shutdown")
         @shutdown_reason = reason
         logger.info "Shutdown requested: #{reason}"
@@ -42,24 +39,10 @@ module CableRoom
 
       private
 
-      # What `room_closed` will say. The runner sets it when the host, not the room, decides to
-      # close (a server shutting down, a migration nobody adopted).
-      def _shutdown_reason=(reason)
-        @shutdown_reason = reason
-      end
-
-      # The startup chain. A restore (see Snapshotting#_restore) runs the same callbacks — they
-      # are what subscribe the inbound port and start the reapers — but swaps `startup` for
-      # `restore_state(app_state)` when the room defines it.
-      def _startup(restoring: false, app_state: nil)
-        event = restoring ? "room_restored.cable_room" : "room_opened.cable_room"
-        ActiveSupport::Notifications.instrument(event, { room: self }) do
+      def _startup
+        ActiveSupport::Notifications.instrument("room_opened.cable_room", { room: self }) do
           run_callbacks :startup do
-            if restoring && respond_to?(:restore_state, true)
-              restore_state(app_state)
-            else
-              startup if respond_to?(:startup)
-            end
+            startup if respond_to?(:startup)
           end
         end
       end

data/lib/cable_room/room/port_management.rb

@@ -158,29 +158,6 @@ module CableRoom
         end
       end
 
-      # -- Snapshot and restore (see CableRoom::Snapshot) ----------------------------------------
-
-      def _snapshot_port_clients
-        @_port_clients.values.map(&:to_snapshot)
-      end
-
-      # Re-create every port exactly as it was, without running port_connected callbacks: the
-      # members are still there and were already acknowledged. A port whose user can't be found
-      # any more (its record was deleted) is dropped rather than failing the whole room; that
-      # member will be re-acknowledged when it next pings.
-      def _restore_port_clients(entries)
-        Array(entries).each do |entry|
-          client = PortClient.new(self, entry["token"])
-          begin
-            client.restore!(entry)
-          rescue ::ActiveJob::DeserializationError => e
-            logger.warn "Dropping port #{entry['token']} from the snapshot: #{e.message}"
-            next
-          end
-          @_port_clients[client.token] = client
-        end
-      end
-
       def check_port_inactivity
         return unless @_port_clients
 
@@ -238,33 +215,6 @@ module CableRoom
         def tag!(*tags)
           self[:tags].merge(tags.flatten.map(&:to_sym))
         end
-
-        SNAPSHOT_OWN_KEYS = %w[tags as last_seen_at].freeze
-
-        # This port as one `port_clients` entry of a CableRoom::Snapshot. `as` goes through the
-        # same serializer the member used to send it (a GlobalID for a record). Everything else on
-        # the port — what the member's `extra:` merged in, plus anything the room stored with
-        # `message_origin[:x] = ...` — travels under `metadata`, the same way, so records survive.
-        def to_snapshot
-          metadata = @metadata.to_h.except(*SNAPSHOT_OWN_KEYS)
-          {
-            token: token,
-            tags: self[:tags].map(&:to_s),
-            as: Snapshot.serialize_argument(self[:as]),
-            last_seen_at: Snapshot.encode_time(self[:last_seen_at]),
-            metadata: Snapshot.serialize_argument(metadata),
-          }
-        end
-
-        # The inverse of `to_snapshot`. `last_seen_at` is kept, not reset: the port is exactly as
-        # old as it was, and its member's next ping refreshes it as usual.
-        def restore!(entry)
-          merge!(Snapshot.deserialize_argument(entry["metadata"]))
-          tag!(entry["tags"])
-          self[:as] = Snapshot.deserialize_argument(entry["as"])
-          self[:last_seen_at] = Snapshot.decode_time(entry["last_seen_at"]) || self[:last_seen_at]
-          self
-        end
       end
     end
   end

data/lib/cable_room/room/reaping.rb

@@ -74,39 +74,6 @@ module CableRoom
         ping_watchdog
       end
 
-      # -- Snapshot and restore (see CableRoom::Snapshot) ----------------------------------------
-
-      # One entry per `reap_when`, in declaration order. `last_keep_at` is the wall-clock moment
-      # the reaper's grace period started counting from (nil until it has run once), so the
-      # deadline — `last_keep_at + grace` — is the same on whichever host restores it.
-      def _snapshot_reaper_state
-        self.class.reaper_checkers.each_with_index.map do |cfg, index|
-          state = _reaper_states[cfg] || {}
-          { key: cfg[:key]&.to_s, index: index, last_keep_at: Snapshot.encode_time(state[:last_keep_at]) }
-        end
-      end
-
-      # Runs before the startup callbacks, which add the timer to each state and leave the rest
-      # alone. A named reaper matches by name and an anonymous one by position, so a Room whose
-      # reapers changed between the two hosts' code versions keeps what still lines up and drops
-      # the rest.
-      def _restore_reaper_state(entries)
-        checkers = self.class.reaper_checkers
-        Array(entries).each do |entry|
-          cfg =
-            if entry["key"].present?
-              checkers.find { |c| c[:key].to_s == entry["key"] }
-            else
-              candidate = checkers[entry["index"].to_i]
-              candidate if candidate && candidate[:key].nil?
-            end
-          next unless cfg
-
-          last_keep_at = Snapshot.decode_time(entry["last_keep_at"])
-          (_reaper_states[cfg] ||= {})[:last_keep_at] = last_keep_at if last_keep_at
-        end
-      end
-
       private
 
       def _reaper_states

data/lib/cable_room/room/user_management.rb

@@ -98,33 +98,6 @@ module CableRoom
         tags
       end
 
-      # -- Snapshot and restore (see CableRoom::Snapshot) ----------------------------------------
-
-      # The user map is carried on its own rather than rebuilt from the ports: a port whose join
-      # the tag policy refused has no user entry, and a rebuild would invent one.
-      def _snapshot_user_state
-        @_user_map_mutex.synchronize do
-          @_user_state_map.map do |user, usm|
-            { user: Snapshot.serialize_argument(user), port_tokens: usm[:port_tokens].to_a }
-          end
-        end
-      end
-
-      # No user_joined callbacks here: these users joined long ago, on the previous host.
-      def _restore_user_state(entries)
-        @_user_map_mutex.synchronize do
-          Array(entries).each do |entry|
-            begin
-              user = Snapshot.deserialize_argument(entry["user"])
-            rescue ::ActiveJob::DeserializationError => e
-              logger.warn "Dropping a user from the snapshot: #{e.message}"
-              next
-            end
-            @_user_state_map[user] = { port_tokens: Set.new(entry["port_tokens"]) }
-          end
-        end
-      end
-
       def _apply_port_scope(user: nil, tag: nil, **kwargs)
         if user && tag
           user_tags = all_user_tags(user) || []

data/lib/cable_room/room.rb

@@ -10,7 +10,6 @@ module CableRoom
       autoload :HostAdapter
 
       autoload :Lifecycle
-      autoload :Snapshotting
       autoload :Reaping
       autoload :InputHandling
 
@@ -21,10 +20,8 @@ module CableRoom
       autoload :Broadcasting
     end
 
-    # Every room running in this process. Asking never creates a Host, so a process that hosts
-    # no rooms (a web process in :remote) just gets an empty list.
     def self.locally_open_rooms
-      Host.current&.rooms || []
+      Host.instance.rooms
     end
   end
 end