rails_den 2.0.0

data/app/services/rails_den/presence/registry.rb

@@ -0,0 +1,805 @@
+require "digest"
+
+module RailsDen
+  module Presence
+    class Registry
+      KEY_PREFIX = "rails_den:presence:v1"
+
+      Snapshot =
+        Struct.new(
+          :session_id,
+          :identity_type,
+          :identity_id,
+          :connected_at,
+          :last_heartbeat_at,
+          :last_activity_at,
+          :board_id,
+          keyword_init: true
+        )
+
+      State =
+        Struct.new(
+          :status,
+          :session_count,
+          :last_activity_at,
+          :board_ids,
+          keyword_init: true
+        ) do
+          def online?
+            status == :online
+          end
+
+          def away?
+            status == :away
+          end
+
+          def offline?
+            status == :offline
+          end
+        end
+
+      def initialize(redis: RailsDen::Presence.redis)
+        unless RailsDen::Presence.enabled?
+          raise RailsDen::Presence::ConfigurationError,
+                "RailsDen Presence is disabled."
+        end
+
+        @redis = redis
+      end
+
+      def register(
+        identity:,
+        session_id:,
+        board: nil,
+        at: Time.current
+      )
+        reconcile_expired!(
+          at: at
+        )
+
+        id = normalize_session_id(session_id)
+        descriptor = identity_descriptor(identity)
+        existing = session_payload(id)
+
+        verify_existing_identity!(
+          existing,
+          descriptor
+        )
+
+        old_board_id =
+          existing["board_id"].presence
+
+        write_session(
+          session_id: id,
+          descriptor: descriptor,
+          connected_at:
+            existing["connected_at"].presence ||
+              at.to_f,
+          heartbeat_at: at,
+          activity_at: at,
+          board_id: board&.id,
+          old_board_id: old_board_id
+        )
+
+        id
+      end
+
+      def heartbeat(
+        identity:,
+        session_id:,
+        at: Time.current
+      )
+        reconcile_expired!(
+          at: at
+        )
+
+        id = normalize_session_id(session_id)
+        descriptor = identity_descriptor(identity)
+        existing = session_payload(id)
+
+        if existing.empty?
+          return register(
+            identity: identity,
+            session_id: id,
+            at: at
+          )
+        end
+
+        verify_existing_identity!(
+          existing,
+          descriptor
+        )
+
+        write_session(
+          session_id: id,
+          descriptor: descriptor,
+          connected_at: existing.fetch("connected_at"),
+          heartbeat_at: at,
+          activity_at:
+            existing.fetch(
+              "last_activity_at",
+              at.to_f
+            ),
+          board_id:
+            existing["board_id"].presence,
+          old_board_id:
+            existing["board_id"].presence
+        )
+
+        id
+      end
+
+      def mark_active(
+        identity:,
+        session_id:,
+        board: :unchanged,
+        at: Time.current
+      )
+        reconcile_expired!(
+          at: at
+        )
+
+        id = normalize_session_id(session_id)
+        descriptor = identity_descriptor(identity)
+        existing = session_payload(id)
+
+        if existing.empty?
+          return register(
+            identity: identity,
+            session_id: id,
+            board:
+              board == :unchanged ? nil : board,
+            at: at
+          )
+        end
+
+        verify_existing_identity!(
+          existing,
+          descriptor
+        )
+
+        old_board_id =
+          existing["board_id"].presence
+
+        board_id =
+          if board == :unchanged
+            old_board_id
+          else
+            board&.id
+          end
+
+        write_session(
+          session_id: id,
+          descriptor: descriptor,
+          connected_at: existing.fetch("connected_at"),
+          heartbeat_at: at,
+          activity_at: at,
+          board_id: board_id,
+          old_board_id: old_board_id
+        )
+
+        id
+      end
+
+      def disconnect(
+        identity:,
+        session_id:,
+        at: Time.current
+      )
+        reconcile_expired!(
+          at: at
+        )
+
+        id = normalize_session_id(session_id)
+        descriptor = identity_descriptor(identity)
+        existing = session_payload(id)
+
+        if existing.empty?
+          prune_member_index!(
+            descriptor,
+            at: at
+          )
+
+          result =
+            state_without_reconciliation(
+              identity: identity,
+              now: at
+            )
+
+          record_last_seen_if_offline!(
+            identity,
+            result,
+            at
+          )
+
+          return result
+        end
+
+        verify_existing_identity!(
+          existing,
+          descriptor
+        )
+
+        remove_session!(
+          session_id: id,
+          descriptor: descriptor,
+          board_id:
+            existing["board_id"].presence
+        )
+
+        result =
+          state_without_reconciliation(
+            identity: identity,
+            now: at
+          )
+
+        record_last_seen_if_offline!(
+          identity,
+          result,
+          at
+        )
+
+        result
+      end
+
+      def state(
+        identity:,
+        now: Time.current
+      )
+        reconcile_expired!(
+          at: now
+        )
+
+        state_without_reconciliation(
+          identity: identity,
+          now: now
+        )
+      end
+
+      def member_snapshots(
+        identity:,
+        now: Time.current
+      )
+        reconcile_expired!(
+          at: now
+        )
+
+        descriptor =
+          identity_descriptor(identity)
+
+        snapshots_from_index(
+          member_index_key(descriptor),
+          now: now
+        )
+      end
+
+      def community_snapshots(
+        now: Time.current
+      )
+        reconcile_expired!(
+          at: now
+        )
+
+        snapshots_from_index(
+          community_index_key,
+          now: now
+        )
+      end
+
+      def board_snapshots(
+        board:,
+        now: Time.current
+      )
+        reconcile_expired!(
+          at: now
+        )
+
+        snapshots_from_index(
+          board_index_key(board.id),
+          now: now
+        )
+      end
+
+      def reconcile_expired!(
+        at: Time.current
+      )
+        cutoff =
+          at.to_f
+
+        session_ids =
+          redis.zrangebyscore(
+            community_index_key,
+            "-inf",
+            cutoff
+          )
+
+        session_ids.each do |session_id|
+          reconcile_expired_session!(
+            session_id,
+            at: at
+          )
+        end
+
+        session_ids.length
+      end
+
+      private
+
+      attr_reader :redis
+
+      def state_without_reconciliation(
+        identity:,
+        now:
+      )
+        descriptor =
+          identity_descriptor(identity)
+
+        snapshots =
+          snapshots_from_index(
+            member_index_key(descriptor),
+            now: now
+          )
+
+        if snapshots.empty?
+          return State.new(
+            status: :offline,
+            session_count: 0,
+            last_activity_at: nil,
+            board_ids: []
+          )
+        end
+
+        last_activity_at =
+          snapshots
+            .map(&:last_activity_at)
+            .compact
+            .max
+
+        away_cutoff =
+          now.to_f -
+            RailsDen::Presence.away_after
+
+        status =
+          if last_activity_at &&
+             last_activity_at.to_f >= away_cutoff
+            :online
+          else
+            :away
+          end
+
+        State.new(
+          status: status,
+          session_count: snapshots.length,
+          last_activity_at: last_activity_at,
+          board_ids:
+            snapshots
+              .filter_map(&:board_id)
+              .uniq
+        )
+      end
+
+      def write_session(
+        session_id:,
+        descriptor:,
+        connected_at:,
+        heartbeat_at:,
+        activity_at:,
+        board_id:,
+        old_board_id:
+      )
+        expiration =
+          RailsDen::Presence.expiration
+
+        expires_at =
+          heartbeat_at.to_f +
+            expiration
+
+        payload = {
+          "identity_type" =>
+            descriptor.fetch(:type),
+          "identity_id" =>
+            descriptor.fetch(:id),
+          "connected_at" =>
+            connected_at.to_f,
+          "last_heartbeat_at" =>
+            heartbeat_at.to_f,
+          "last_activity_at" =>
+            activity_at.to_f,
+          "board_id" =>
+            board_id.to_s
+        }
+
+        redis.multi do |transaction|
+          transaction.hset(
+            session_key(session_id),
+            payload
+          )
+
+          transaction.expire(
+            session_key(session_id),
+            metadata_retention
+          )
+
+          transaction.zadd(
+            community_index_key,
+            expires_at,
+            session_id
+          )
+
+          member_key =
+            member_index_key(descriptor)
+
+          transaction.zadd(
+            member_key,
+            expires_at,
+            session_id
+          )
+
+          transaction.expire(
+            member_key,
+            metadata_retention
+          )
+
+          if old_board_id &&
+             old_board_id.to_s != board_id.to_s
+            transaction.zrem(
+              board_index_key(old_board_id),
+              session_id
+            )
+          end
+
+          if board_id.present?
+            board_key =
+              board_index_key(board_id)
+
+            transaction.zadd(
+              board_key,
+              expires_at,
+              session_id
+            )
+
+            transaction.expire(
+              board_key,
+              metadata_retention
+            )
+          end
+        end
+      end
+
+      def reconcile_expired_session!(
+        session_id,
+        at:
+      )
+        score =
+          redis.zscore(
+            community_index_key,
+            session_id
+          )
+
+        return unless score
+        return if score.to_f > at.to_f
+
+        payload =
+          session_payload(
+            session_id
+          )
+
+        if payload.empty?
+          redis.zrem(
+            community_index_key,
+            session_id
+          )
+
+          return
+        end
+
+        descriptor = {
+          type:
+            payload.fetch(
+              "identity_type"
+            ),
+          id:
+            payload.fetch(
+              "identity_id"
+            )
+        }
+
+        board_id =
+          payload["board_id"].presence
+
+        expired_at =
+          Time.at(
+            score.to_f
+          )
+
+        remove_session!(
+          session_id: session_id,
+          descriptor: descriptor,
+          board_id: board_id
+        )
+
+        return if member_has_live_sessions?(
+          descriptor,
+          at: at
+        )
+
+        identity =
+          locate_identity(
+            descriptor
+          )
+
+        return unless identity
+
+        RailsDen::Presence::LastSeen.record!(
+          identity: identity,
+          at: expired_at
+        )
+      end
+
+      def remove_session!(
+        session_id:,
+        descriptor:,
+        board_id:
+      )
+        redis.multi do |transaction|
+          transaction.del(
+            session_key(session_id)
+          )
+
+          transaction.zrem(
+            community_index_key,
+            session_id
+          )
+
+          transaction.zrem(
+            member_index_key(descriptor),
+            session_id
+          )
+
+          if board_id.present?
+            transaction.zrem(
+              board_index_key(board_id),
+              session_id
+            )
+          end
+        end
+      end
+
+      def member_has_live_sessions?(
+        descriptor,
+        at:
+      )
+        redis.zcount(
+          member_index_key(descriptor),
+          "(#{at.to_f}",
+          "+inf"
+        ).positive?
+      end
+
+      def locate_identity(descriptor)
+        identity_class =
+          descriptor
+            .fetch(:type)
+            .constantize
+
+        identity_class.find_by(
+          id: descriptor.fetch(:id)
+        )
+      rescue NameError
+        nil
+      end
+
+      def snapshots_from_index(
+        index_key,
+        now:
+      )
+        session_ids =
+          redis.zrangebyscore(
+            index_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(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
+
+            snapshots <<
+              snapshot_from_payload(
+                session_id,
+                payload
+              )
+          end
+
+        if missing_ids.any?
+          redis.zrem(
+            index_key,
+            missing_ids
+          )
+        end
+
+        snapshots
+      end
+
+      def snapshot_from_payload(
+        session_id,
+        payload
+      )
+        Snapshot.new(
+          session_id: session_id,
+          identity_type:
+            payload.fetch(
+              "identity_type"
+            ),
+          identity_id:
+            payload.fetch(
+              "identity_id"
+            ),
+          connected_at:
+            time_from_payload(
+              payload["connected_at"]
+            ),
+          last_heartbeat_at:
+            time_from_payload(
+              payload["last_heartbeat_at"]
+            ),
+          last_activity_at:
+            time_from_payload(
+              payload["last_activity_at"]
+            ),
+          board_id:
+            integer_or_nil(
+              payload["board_id"]
+            )
+        )
+      end
+
+      def session_payload(session_id)
+        redis.hgetall(
+          session_key(session_id)
+        )
+      end
+
+      def verify_existing_identity!(
+        payload,
+        descriptor
+      )
+        return if payload.empty?
+
+        same_type =
+          payload["identity_type"] ==
+            descriptor.fetch(:type)
+
+        same_id =
+          payload["identity_id"] ==
+            descriptor.fetch(:id)
+
+        return if same_type && same_id
+
+        raise ArgumentError,
+              "Presence session belongs to a different identity."
+      end
+
+      def identity_descriptor(identity)
+        unless identity&.respond_to?(:id) &&
+               identity.id.present?
+          raise ArgumentError,
+                "Presence identity must be a persisted record."
+        end
+
+        {
+          type:
+            identity
+              .class
+              .polymorphic_name
+              .to_s,
+          id:
+            identity.id.to_s
+        }
+      end
+
+      def member_index_key(descriptor)
+        digest =
+          Digest::SHA256.hexdigest(
+            [
+              descriptor.fetch(:type),
+              descriptor.fetch(:id)
+            ].join("\0")
+          )
+
+        "#{KEY_PREFIX}:member:#{digest}:sessions"
+      end
+
+      def session_key(session_id)
+        "#{KEY_PREFIX}:session:#{session_id}"
+      end
+
+      def community_index_key
+        "#{KEY_PREFIX}:community:sessions"
+      end
+
+      def board_index_key(board_id)
+        "#{KEY_PREFIX}:board:#{board_id}:sessions"
+      end
+
+      def normalize_session_id(value)
+        session_id =
+          value
+            .to_s
+            .strip
+
+        unless session_id.match?(
+          /\A[a-zA-Z0-9_-]{8,128}\z/
+        )
+          raise ArgumentError,
+                "Presence session_id is invalid."
+        end
+
+        session_id
+      end
+
+      def prune_member_index!(
+        descriptor,
+        at:
+      )
+        redis.zremrangebyscore(
+          member_index_key(descriptor),
+          "-inf",
+          at.to_f
+        )
+      end
+
+      def record_last_seen_if_offline!(
+        identity,
+        state,
+        at
+      )
+        return unless state.offline?
+
+        RailsDen::Presence::LastSeen.record!(
+          identity: identity,
+          at: at
+        )
+      end
+
+      def metadata_retention
+        [
+          RailsDen::Presence.recently_active_window,
+          RailsDen::Presence.expiration * 4
+        ].max
+      end
+
+      def time_from_payload(value)
+        return if value.blank?
+
+        Time.at(
+          value.to_f
+        )
+      end
+
+      def integer_or_nil(value)
+        return if value.blank?
+
+        value.to_i
+      end
+    end
+  end
+end