cable_room 0.7.0.beta2 → 0.8.0.beta1

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