rails_den 2.0.0

data/app/services/rails_den/chat/spatial_registry.rb

@@ -0,0 +1,682 @@
+module RailsDen
+  module Chat
+    class SpatialRegistry
+      KEY_PREFIX =
+        "rails_den:chat:spatial:v1"
+
+      SESSION_ID_PATTERN =
+        /\A[a-zA-Z0-9_-]{8,128}\z/
+
+      class StaleSequenceError < StandardError
+      end
+
+      Snapshot =
+        Struct.new(
+          :session_id,
+          :identity_type,
+          :identity_id,
+          :room_key,
+          :room_slug,
+          :chat_channel_id,
+          :x,
+          :y,
+          :z,
+          :yaw,
+          :pitch,
+          :grounded,
+          :moving,
+          :sequence,
+          :connected_at,
+          :updated_at,
+          keyword_init: true
+        )
+
+      def initialize(redis: RailsDen::Presence.redis)
+        unless RailsDen::Presence.enabled?
+          raise RailsDen::Presence::ConfigurationError,
+                "RailsDen Presence is disabled."
+        end
+
+        @redis = redis
+      end
+
+      def enter(
+        room: nil,
+        channel: nil,
+        identity:,
+        session_id:,
+        state:,
+        at: Time.current
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        reconcile_expired!(
+          room: room,
+          at: at
+        )
+
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        existing =
+          session_payload(
+            room.key,
+            id
+          )
+
+        verify_existing_identity!(
+          existing,
+          descriptor,
+          room
+        )
+
+        connected_at =
+          if existing.empty?
+            at
+          else
+            time_from_payload(
+              existing["connected_at"]
+            ) || at
+          end
+
+        write_session(
+          room: room,
+          session_id: id,
+          descriptor: descriptor,
+          state: state,
+          connected_at: connected_at,
+          updated_at: at
+        )
+
+        snapshot(
+          room: room,
+          session_id: id
+        )
+      end
+
+      def update(
+        room: nil,
+        channel: nil,
+        identity:,
+        session_id:,
+        state:,
+        at: Time.current
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        reconcile_expired!(
+          room: room,
+          at: at
+        )
+
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        existing =
+          session_payload(
+            room.key,
+            id
+          )
+
+        if existing.empty?
+          raise ArgumentError,
+                "Spatial session is not registered."
+        end
+
+        verify_existing_identity!(
+          existing,
+          descriptor,
+          room
+        )
+
+        current_sequence =
+          existing
+            .fetch(
+              "sequence",
+              "0"
+            )
+            .to_i
+
+        next_sequence =
+          state.fetch(
+            :sequence
+          )
+
+        if next_sequence <= current_sequence
+          raise StaleSequenceError,
+                "Spatial sequence is stale."
+        end
+
+        connected_at =
+          time_from_payload(
+            existing["connected_at"]
+          ) || at
+
+        write_session(
+          room: room,
+          session_id: id,
+          descriptor: descriptor,
+          state: state,
+          connected_at: connected_at,
+          updated_at: at
+        )
+
+        snapshot(
+          room: room,
+          session_id: id
+        )
+      end
+
+      def refresh(
+        room: nil,
+        channel: nil,
+        identity:,
+        session_id:,
+        at: Time.current
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        existing =
+          session_payload(
+            room.key,
+            id
+          )
+
+        return false if existing.empty?
+
+        verify_existing_identity!(
+          existing,
+          descriptor,
+          room
+        )
+
+        state = {
+          x: existing.fetch("x").to_f,
+          y: existing.fetch("y").to_f,
+          z: existing.fetch("z").to_f,
+          yaw: existing.fetch("yaw").to_f,
+          pitch: optional_float(existing["pitch"]),
+          grounded: boolean_from_payload(existing["grounded"]),
+          moving: boolean_from_payload(existing["moving"]),
+          sequence:
+            existing
+              .fetch(
+                "sequence",
+                "0"
+              )
+              .to_i
+        }
+
+        write_session(
+          room: room,
+          session_id: id,
+          descriptor: descriptor,
+          state: state,
+          connected_at:
+            time_from_payload(
+              existing["connected_at"]
+            ) || at,
+          updated_at: at
+        )
+
+        true
+      end
+
+      def leave(
+        room: nil,
+        channel: nil,
+        identity:,
+        session_id:
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        payload =
+          session_payload(
+            room.key,
+            id
+          )
+
+        return false if payload.empty?
+
+        verify_existing_identity!(
+          payload,
+          descriptor,
+          room
+        )
+
+        redis.multi do |transaction|
+          transaction.del(
+            session_key(
+              room.key,
+              id
+            )
+          )
+
+          transaction.zrem(
+            room_index_key(
+              room.key
+            ),
+            id
+          )
+        end
+
+        true
+      end
+
+      def room_snapshots(
+        room: nil,
+        channel: nil,
+        now: Time.current
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        reconcile_expired!(
+          room: room,
+          at: now
+        )
+
+        session_ids =
+          redis.zrangebyscore(
+            room_index_key(
+              room.key
+            ),
+            "(#{now.to_f}",
+            "+inf"
+          )
+
+        return [] if session_ids.empty?
+
+        payloads =
+          redis.pipelined do |pipeline|
+            session_ids.each do |session_id|
+              pipeline.hgetall(
+                session_key(
+                  room.key,
+                  session_id
+                )
+              )
+            end
+          end
+
+        snapshots = []
+        missing_ids = []
+
+        session_ids
+          .zip(payloads)
+          .each do |session_id, payload|
+            if payload.empty?
+              missing_ids << session_id
+              next
+            end
+
+            parsed =
+              snapshot_from_payload(
+                session_id,
+                payload
+              )
+
+            if parsed
+              snapshots << parsed
+            else
+              missing_ids << session_id
+            end
+          end
+
+        if missing_ids.any?
+          redis.zrem(
+            room_index_key(
+              room.key
+            ),
+            missing_ids
+          )
+        end
+
+        snapshots
+      end
+
+      def snapshot(
+        room: nil,
+        channel: nil,
+        session_id:
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        payload =
+          session_payload(
+            room.key,
+            id
+          )
+
+        return if payload.empty?
+
+        snapshot_from_payload(
+          id,
+          payload
+        )
+      end
+
+      def reconcile_expired!(
+        room: nil,
+        channel: nil,
+        at: Time.current
+      )
+        room = spatial_room(room: room, channel: channel)
+
+        index_key =
+          room_index_key(
+            room.key
+          )
+
+        session_ids =
+          redis.zrangebyscore(
+            index_key,
+            "-inf",
+            at.to_f
+          )
+
+        return 0 if session_ids.empty?
+
+        redis.multi do |transaction|
+          transaction.zrem(
+            index_key,
+            session_ids
+          )
+
+          session_ids.each do |session_id|
+            transaction.del(
+              session_key(
+                room.key,
+                session_id
+              )
+            )
+          end
+        end
+
+        session_ids.length
+      end
+
+      private
+
+      attr_reader :redis
+
+      def spatial_room(room:, channel:)
+        RailsDen::Chat::SpatialRoom.coerce(
+          room: room,
+          channel: channel
+        )
+      end
+
+      def write_session(
+        room:,
+        session_id:,
+        descriptor:,
+        state:,
+        connected_at:,
+        updated_at:
+      )
+        expires_at =
+          updated_at.to_f +
+            spatial_ttl
+
+        payload = {
+          "identity_type" => descriptor.fetch(:type),
+          "identity_id" => descriptor.fetch(:id),
+          "room_key" => room.key,
+          "room_slug" => room.slug,
+          "chat_channel_id" => room.chat_channel_id.to_s,
+          "x" => state.fetch(:x).to_f,
+          "y" => state.fetch(:y).to_f,
+          "z" => state.fetch(:z).to_f,
+          "yaw" => state.fetch(:yaw).to_f,
+          "pitch" =>
+            state[:pitch].nil? ?
+              "" :
+              state[:pitch].to_f,
+          "grounded" =>
+            state.fetch(:grounded) ?
+              "1" :
+              "0",
+          "moving" =>
+            state.fetch(:moving) ?
+              "1" :
+              "0",
+          "sequence" => state.fetch(:sequence).to_i,
+          "connected_at" => connected_at.to_f,
+          "updated_at" => updated_at.to_f
+        }
+
+        index_key =
+          room_index_key(
+            room.key
+          )
+
+        redis.multi do |transaction|
+          transaction.hset(
+            session_key(
+              room.key,
+              session_id
+            ),
+            payload
+          )
+
+          transaction.expire(
+            session_key(
+              room.key,
+              session_id
+            ),
+            metadata_retention
+          )
+
+          transaction.zadd(
+            index_key,
+            expires_at,
+            session_id
+          )
+
+          transaction.expire(
+            index_key,
+            metadata_retention
+          )
+        end
+      end
+
+      def verify_existing_identity!(
+        payload,
+        descriptor,
+        room
+      )
+        return if payload.empty?
+
+        same_type =
+          payload["identity_type"] ==
+            descriptor.fetch(:type)
+
+        same_id =
+          payload["identity_id"] ==
+            descriptor.fetch(:id)
+
+        same_room =
+          payload["room_key"] ==
+            room.key
+
+        return if same_type && same_id && same_room
+
+        raise ArgumentError,
+              "Spatial session belongs to a different identity or room."
+      end
+
+      def snapshot_from_payload(
+        session_id,
+        payload
+      )
+        channel_id =
+          payload["chat_channel_id"].presence
+
+        Snapshot.new(
+          session_id: session_id,
+          identity_type: payload.fetch("identity_type"),
+          identity_id: payload.fetch("identity_id"),
+          room_key: payload.fetch("room_key"),
+          room_slug: payload.fetch("room_slug"),
+          chat_channel_id:
+            channel_id ?
+              channel_id.to_i :
+              nil,
+          x: payload.fetch("x").to_f,
+          y: payload.fetch("y").to_f,
+          z: payload.fetch("z").to_f,
+          yaw: payload.fetch("yaw").to_f,
+          pitch: optional_float(payload["pitch"]),
+          grounded: boolean_from_payload(payload["grounded"]),
+          moving: boolean_from_payload(payload["moving"]),
+          sequence:
+            payload
+              .fetch(
+                "sequence",
+                "0"
+              )
+              .to_i,
+          connected_at:
+            time_from_payload(
+              payload["connected_at"]
+            ),
+          updated_at:
+            time_from_payload(
+              payload["updated_at"]
+            )
+        )
+      rescue KeyError,
+             ArgumentError,
+             TypeError
+        nil
+      end
+
+      def session_payload(
+        room_key,
+        session_id
+      )
+        redis.hgetall(
+          session_key(
+            room_key,
+            session_id
+          )
+        )
+      end
+
+      def session_key(
+        room_key,
+        session_id
+      )
+        "#{KEY_PREFIX}:room:#{room_key}:session:#{session_id}"
+      end
+
+      def room_index_key(room_key)
+        "#{KEY_PREFIX}:room:#{room_key}:sessions"
+      end
+
+      def normalize_session_id(value)
+        session_id =
+          value
+            .to_s
+            .strip
+
+        unless session_id.match?(
+          SESSION_ID_PATTERN
+        )
+          raise ArgumentError,
+                "Spatial session_id is invalid."
+        end
+
+        session_id
+      end
+
+      def identity_descriptor(identity)
+        unless identity&.respond_to?(:id) &&
+               identity.id.present?
+          raise ArgumentError,
+                "Spatial identity must be a persisted record."
+        end
+
+        {
+          type:
+            identity
+              .class
+              .polymorphic_name
+              .to_s,
+          id: identity.id.to_s
+        }
+      end
+
+      def spatial_ttl
+        [
+          RailsDen::Presence.expiration,
+          120
+        ].max
+      end
+
+      def metadata_retention
+        [
+          spatial_ttl * 2,
+          RailsDen::Presence.recently_active_window
+        ].max
+      end
+
+      def optional_float(value)
+        return if value.blank?
+
+        value.to_f
+      end
+
+      def boolean_from_payload(value)
+        value.to_s == "1"
+      end
+
+      def time_from_payload(value)
+        return if value.blank?
+
+        Time.at(
+          value.to_f
+        )
+      end
+    end
+  end
+end