rails_den 2.0.0

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

@@ -0,0 +1,193 @@
+require "digest"
+
+module RailsDen
+  module Presence
+    class Broadcaster
+      COMMUNITY_STREAM =
+        "rails_den:presence:community:v1"
+
+      COMMUNITY_FINGERPRINT_KEY =
+        "rails_den:presence:v1:broadcast:community:fingerprint"
+
+      COMMUNITY_CHECK_KEY =
+        "rails_den:presence:v1:broadcast:community:check"
+
+      COMMUNITY_CHECK_INTERVAL =
+        5
+
+      class << self
+        def community_stream
+          COMMUNITY_STREAM
+        end
+
+        def broadcast_change!(
+          now: Time.current,
+          force: false
+        )
+          return unless force || community_check_due?
+
+          fingerprint =
+            community_fingerprint(
+              now: now
+            )
+
+          return unless community_changed?(
+            fingerprint
+          )
+
+          ActionCable.server.broadcast(
+            COMMUNITY_STREAM,
+            {
+              type: "presence_changed"
+            }
+          )
+        rescue Redis::BaseError,
+               RailsDen::Presence::ConfigurationError
+          nil
+        end
+
+        private
+
+        def community_check_due?
+          RailsDen::Presence.redis.set(
+            COMMUNITY_CHECK_KEY,
+            Time.current.to_f,
+            nx: true,
+            ex: COMMUNITY_CHECK_INTERVAL
+          ).present?
+        end
+
+        def community_fingerprint(now:)
+          snapshots =
+            RailsDen::Presence::Registry
+              .new
+              .community_snapshots(
+                now: now
+              )
+
+          grouped =
+            snapshots.group_by do |snapshot|
+              [
+                snapshot.identity_type.to_s,
+                snapshot.identity_id.to_s
+              ]
+            end
+
+          privacy =
+            privacy_by_identity_key(
+              grouped.keys
+            )
+
+          rows =
+            grouped.map do |key, member_snapshots|
+              latest_activity =
+                member_snapshots
+                  .filter_map(
+                    &:last_activity_at
+                  )
+                  .max
+
+              status =
+                if latest_activity &&
+                   latest_activity >=
+                     now -
+                     RailsDen::Presence.away_after
+                  :online
+                else
+                  :away
+                end
+
+              latest_board_snapshot =
+                member_snapshots
+                  .select {
+                    |snapshot|
+                    snapshot.board_id.present?
+                  }
+                  .max_by do |snapshot|
+                    [
+                      snapshot.last_activity_at&.to_f || 0,
+                      snapshot.connected_at&.to_f || 0,
+                      snapshot.session_id.to_s
+                    ]
+                  end
+
+              show_presence,
+              show_current_board =
+                privacy.fetch(
+                  key,
+                  [
+                    true,
+                    true
+                  ]
+                )
+
+              [
+                key.first,
+                key.last,
+                status.to_s,
+                latest_board_snapshot&.board_id.to_s,
+                show_presence,
+                show_current_board
+              ]
+            end
+
+          Digest::SHA256.hexdigest(
+            [
+              RailsDen.config.presence_visibility.to_s,
+              rows.sort
+            ].inspect
+          )
+        end
+
+        def privacy_by_identity_key(keys)
+          result = {}
+
+          keys
+            .group_by(&:first)
+            .each do |type, typed_keys|
+              ids =
+                typed_keys.map(&:last)
+
+              RailsDen::MemberProfile
+                .where(
+                  profile_owner_type: type,
+                  profile_owner_id: ids
+                )
+                .each do |profile|
+                  result[
+                    [
+                      profile.profile_owner_type.to_s,
+                      profile.profile_owner_id.to_s
+                    ]
+                  ] = [
+                    profile.show_presence?,
+                    profile.show_current_board?
+                  ]
+                end
+            end
+
+          result
+        end
+
+        def community_changed?(fingerprint)
+          redis =
+            RailsDen::Presence.redis
+
+          previous =
+            redis.get(
+              COMMUNITY_FINGERPRINT_KEY
+            )
+
+          return false if previous == fingerprint
+
+          redis.set(
+            COMMUNITY_FINGERPRINT_KEY,
+            fingerprint
+          )
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+module RailsDen
+  module Presence
+    class ChatRoomRegistry
+      KEY_PREFIX =
+        "rails_den:presence:v1:chat_room"
+
+      RoomSnapshot =
+        Struct.new(
+          :session_id,
+          :identity_type,
+          :identity_id,
+          :chat_channel_id,
+          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(
+        identity:,
+        session_id:,
+        chat_channel:
+      )
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        redis.multi do |transaction|
+          transaction.hset(
+            session_key(id),
+            {
+              "identity_type" =>
+                descriptor.fetch(:type),
+              "identity_id" =>
+                descriptor.fetch(:id),
+              "chat_channel_id" =>
+                chat_channel.id.to_s
+            }
+          )
+
+          transaction.expire(
+            session_key(id),
+            metadata_retention
+          )
+        end
+
+        true
+      end
+
+      def leave(
+        identity:,
+        session_id:,
+        chat_channel:
+      )
+        id =
+          normalize_session_id(
+            session_id
+          )
+
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        payload =
+          redis.hgetall(
+            session_key(id)
+          )
+
+        return false if payload.empty?
+
+        return false unless
+          payload["identity_type"] ==
+            descriptor.fetch(:type)
+
+        return false unless
+          payload["identity_id"] ==
+            descriptor.fetch(:id)
+
+        return false unless
+          payload["chat_channel_id"] ==
+            chat_channel.id.to_s
+
+        redis.del(
+          session_key(id)
+        )
+
+        true
+      end
+
+      def remove_identity_from_channel(
+        identity:,
+        chat_channel:,
+        now: Time.current
+      )
+        descriptor =
+          identity_descriptor(
+            identity
+          )
+
+        matching =
+          community_room_snapshots(
+            now: now
+          ).select do |snapshot|
+            snapshot.identity_type.to_s ==
+              descriptor.fetch(:type) &&
+              snapshot.identity_id.to_s ==
+                descriptor.fetch(:id) &&
+              snapshot.chat_channel_id ==
+                chat_channel.id
+          end
+
+        return false if matching.empty?
+
+        redis.del(
+          *matching.map do |snapshot|
+            session_key(
+              snapshot.session_id
+            )
+          end
+        )
+
+        true
+      end
+
+      def community_room_snapshots(
+        now: Time.current
+      )
+        live_snapshots =
+          RailsDen::Presence::Registry
+            .new(
+              redis: redis
+            )
+            .community_snapshots(
+              now: now
+            )
+
+        return [] if live_snapshots.empty?
+
+        payloads =
+          redis.pipelined do |pipeline|
+            live_snapshots.each do |snapshot|
+              pipeline.hgetall(
+                session_key(
+                  snapshot.session_id
+                )
+              )
+            end
+          end
+
+        live_snapshots
+          .zip(payloads)
+          .filter_map do |snapshot, payload|
+            room_snapshot_for(
+              snapshot,
+              payload
+            )
+          end
+      end
+
+      private
+
+      attr_reader :redis
+
+      def room_snapshot_for(
+        live_snapshot,
+        payload
+      )
+        return if payload.empty?
+
+        return unless
+          payload["identity_type"] ==
+            live_snapshot
+              .identity_type
+              .to_s
+
+        return unless
+          payload["identity_id"] ==
+            live_snapshot
+              .identity_id
+              .to_s
+
+        chat_channel_id =
+          payload[
+            "chat_channel_id"
+          ].presence
+
+        return unless chat_channel_id
+
+        RoomSnapshot.new(
+          session_id:
+            live_snapshot.session_id,
+          identity_type:
+            live_snapshot.identity_type,
+          identity_id:
+            live_snapshot.identity_id,
+          chat_channel_id:
+            chat_channel_id.to_i
+        )
+      end
+
+      def session_key(session_id)
+        "#{KEY_PREFIX}:session:#{session_id}"
+      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 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 metadata_retention
+        [
+          RailsDen::Presence
+            .recently_active_window,
+          RailsDen::Presence.expiration * 4
+        ].max
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+module RailsDen
+  module Presence
+    class CommunitySummary
+      Summary =
+        Struct.new(
+          :visible,
+          :online_count,
+          :away_count,
+          keyword_init: true
+        ) do
+          def visible?
+            !!visible
+          end
+
+          def active_count
+            online_count + away_count
+          end
+        end
+
+      class << self
+        def call(
+          viewer:,
+          now: Time.current
+        )
+          new(
+            viewer: viewer,
+            now: now
+          ).call
+        end
+      end
+
+      def initialize(
+        viewer:,
+        now:
+      )
+        @viewer = viewer
+        @now = now
+      end
+
+      def call
+        return hidden_summary unless RailsDen::Presence.enabled?
+
+        unless RailsDen::Presence::Visibility
+          .presence_surface_visible_to?(
+            viewer
+          )
+          return hidden_summary
+        end
+
+        snapshots =
+          RailsDen::Presence::Registry
+            .new
+            .community_snapshots(
+              now: now
+            )
+
+        snapshots_by_identity =
+          snapshots.group_by do |snapshot|
+            [
+              snapshot.identity_type.to_s,
+              snapshot.identity_id.to_s
+            ]
+          end
+
+        profiles =
+          profiles_by_identity_key(
+            snapshots_by_identity.keys
+          )
+
+        online_count = 0
+        away_count = 0
+
+        snapshots_by_identity.each do |identity_key, identity_snapshots|
+          profile =
+            profiles[
+              identity_key
+            ]
+
+          next unless RailsDen::Presence::Visibility
+            .profile_allows_presence?(
+              profile
+            )
+
+          case status_from_snapshots(
+            identity_snapshots
+          )
+          when :online
+            online_count += 1
+          when :away
+            away_count += 1
+          end
+        end
+
+        Summary.new(
+          visible: true,
+          online_count: online_count,
+          away_count: away_count
+        )
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        hidden_summary
+      end
+
+      private
+
+      attr_reader :viewer,
+                  :now
+
+      def profiles_by_identity_key(identity_keys)
+        return {} if identity_keys.empty?
+
+        types =
+          identity_keys
+            .map(&:first)
+            .uniq
+
+        ids =
+          identity_keys
+            .map(&:last)
+            .uniq
+
+        RailsDen::MemberProfile
+          .where(
+            profile_owner_type: types,
+            profile_owner_id: ids
+          )
+          .to_a
+          .index_by do |profile|
+            [
+              profile.profile_owner_type.to_s,
+              profile.profile_owner_id.to_s
+            ]
+          end
+      end
+
+      def status_from_snapshots(snapshots)
+        last_activity_at =
+          snapshots
+            .filter_map(
+              &:last_activity_at
+            )
+            .max
+
+        return :away unless last_activity_at
+
+        cutoff =
+          now -
+            RailsDen::Presence.away_after
+
+        if last_activity_at >= cutoff
+          :online
+        else
+          :away
+        end
+      end
+
+      def hidden_summary
+        Summary.new(
+          visible: false,
+          online_count: 0,
+          away_count: 0
+        )
+      end
+    end
+  end
+end