A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(gateway): track dm partner presence in mutual guilds (#2658)
Hampus53399ffb445b
diff --git a/fluxer_gateway/src/guild/guild.erl b/fluxer_gateway/src/guild/guild.erlindex b44133945..3bf87e5a0 100644--- a/fluxer_gateway/src/guild/guild.erl+++ b/fluxer_gateway/src/guild/guild.erl@@ -172,10 +172,11 @@ route_cast(Tag, Msg, State) ->case cast_handler(Tag) ofvoice -> guild_voice_handler:handle_cast(Msg, State);subscription -> guild_subscription_handler:handle_cast(Msg, State);+ dm_partners -> guild_dm_partners:handle_cast(Msg, State);undefined -> {noreply, State}end.--spec cast_handler(atom()) -> voice | subscription | undefined.+-spec cast_handler(atom()) -> voice | subscription | dm_partners | undefined.cast_handler(relay_voice_state_update) -> voice;cast_handler(relay_voice_server_update) -> voice;cast_handler(store_pending_connection) -> voice;@@ -183,6 +184,7 @@ cast_handler(add_virtual_channel_access) -> voice;cast_handler(remove_virtual_channel_access) -> voice;cast_handler(cleanup_virtual_access_for_user) -> voice;cast_handler(update_member_subscriptions) -> subscription;+cast_handler(update_dm_partners) -> dm_partners;cast_handler(_) -> undefined.-spec handle_info(term(), guild_state()) -> info_reply().@@ -545,7 +547,7 @@ dispatch_event(Event, EventData, State) ->Event, NewState),ok = maybe_refresh_permission_cache(Event, ParsedEventData, State, StateAfterPrune),- StateAfterPrune.+ guild_dm_partners:maybe_reevaluate(Event, ParsedEventData, State, StateAfterPrune).-spec parse_event_data(term()) -> map().parse_event_data(D) when is_binary(D) -> require_map(json:decode(D));diff --git a/fluxer_gateway/src/guild/guild_dm_partners.erl b/fluxer_gateway/src/guild/guild_dm_partners.erlnew file mode 100644index 000000000..ef8e9b349--- /dev/null+++ b/fluxer_gateway/src/guild/guild_dm_partners.erl@@ -0,0 +1,259 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_dm_partners).+-typing([eqwalizer]).++-export([handle_cast/2, maybe_reevaluate/4]).++-type guild_state() :: map().+-type session_id() :: binary().+-type user_id() :: integer().+-type registration() :: #{+ user_id := user_id(),+ pid := pid(),+ partners := #{user_id() => true},+ eligible := #{user_id() => true}+}.+-type registrations() :: #{session_id() => registration()}.+-type scope() :: none | all | {user, user_id()}.++-export_type([guild_state/0]).++-define(MAX_PARTNERS, 1000).+-define(PRUNE_SLACK, 64).++-spec handle_cast(term(), guild_state()) -> {noreply, guild_state()}.+handle_cast({update_dm_partners, SessionId, PartnerIds}, State) when+ is_binary(SessionId), is_list(PartnerIds)+->+ {noreply, update(SessionId, PartnerIds, State)};+handle_cast(_Msg, State) ->+ {noreply, State}.++-spec maybe_reevaluate(term(), term(), guild_state(), guild_state()) -> guild_state().+maybe_reevaluate(Event, Data, PreviousState, State) ->+ Registrations = registrations(State),+ case map_size(Registrations) of+ 0 ->+ State;+ _ ->+ reevaluate(+ effective_scope(scope(Event, Data), PreviousState, State), Registrations, State+ )+ end.++-spec effective_scope(scope(), guild_state(), guild_state()) -> scope().+effective_scope(all, PreviousState, State) ->+ case visibility_inputs(PreviousState) =:= visibility_inputs(State) of+ true -> none;+ false -> all+ end;+effective_scope(Scope, _PreviousState, _State) ->+ Scope.++-spec visibility_inputs(guild_state()) -> term().+visibility_inputs(State) ->+ Data = map_utils:ensure_map(maps:get(data, State, #{})),+ Guild = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),+ {+ maps:get(<<"owner_id">>, Guild, undefined),+ role_inputs(guild_data_index:role_index(Data)),+ channel_inputs(guild_data_index:channel_index(Data)),+ maps:get(virtual_channel_access, State, #{})+ }.++-spec role_inputs(term()) -> term().+role_inputs(Roles) when is_map(Roles) ->+ lists:sort([+ {Id, maps:get(<<"permissions">>, Role, undefined)}+ || {Id, Role} <- maps:to_list(Roles), is_map(Role)+ ]);+role_inputs(Roles) ->+ Roles.++-spec channel_inputs(term()) -> term().+channel_inputs(Channels) when is_map(Channels) ->+ lists:sort([+ {+ Id,+ maps:get(<<"type">>, Channel, undefined),+ maps:get(<<"parent_id">>, Channel, undefined),+ maps:get(<<"permission_overwrites">>, Channel, [])+ }+ || {Id, Channel} <- maps:to_list(Channels), is_map(Channel)+ ]);+channel_inputs(Channels) ->+ Channels.++-spec update(session_id(), [term()], guild_state()) -> guild_state().+update(SessionId, PartnerIds, State) ->+ Registrations = registrations(State),+ Next =+ case session_owner(SessionId, State) of+ {ok, UserId, Pid} ->+ update_owned(SessionId, UserId, Pid, PartnerIds, Registrations, State);+ error ->+ maps:remove(SessionId, Registrations)+ end,+ State#{dm_partners => maybe_prune(Next, State)}.++-spec update_owned(session_id(), user_id(), pid(), [term()], registrations(), guild_state()) ->+ registrations().+update_owned(SessionId, UserId, Pid, PartnerIds, Registrations, State) ->+ case presence_targets:dm_partner_presence_enabled(UserId) of+ false ->+ maps:remove(SessionId, Registrations);+ true ->+ Entry = #{+ user_id => UserId,+ pid => Pid,+ partners => partner_set(PartnerIds, UserId),+ eligible => previous_eligible(+ maps:get(SessionId, Registrations, undefined), Pid+ )+ },+ put_all(evaluate(#{SessionId => Entry}, State), Registrations)+ end.++-spec reevaluate(scope(), registrations(), guild_state()) -> guild_state().+reevaluate(none, _Registrations, State) ->+ State;+reevaluate(all, Registrations, State) ->+ State#{dm_partners => evaluate(live_registrations(Registrations, State), State)};+reevaluate({user, UserId}, Registrations, State) ->+ Affected = maps:fold(+ fun(SessionId, Entry, Acc) ->+ case involves_user(UserId, Entry) of+ true -> Acc#{SessionId => Entry};+ false -> Acc+ end+ end,+ #{},+ Registrations+ ),+ case map_size(Affected) of+ 0 ->+ State;+ _ ->+ Live = live_registrations(Affected, State),+ Kept = maps:without(+ maps:keys(maps:without(maps:keys(Live), Affected)), Registrations+ ),+ State#{dm_partners => maybe_prune(put_all(evaluate(Live, State), Kept), State)}+ end.++-spec put_all(registrations(), registrations()) -> registrations().+put_all(Entries, Registrations) ->+ maps:fold(+ fun(SessionId, Entry, Acc) -> Acc#{SessionId => Entry} end, Registrations, Entries+ ).++-spec maybe_prune(registrations(), guild_state()) -> registrations().+maybe_prune(Registrations, State) ->+ Sessions = maps:get(sessions, State, #{}),+ case map_size(Registrations) > map_size(Sessions) + ?PRUNE_SLACK of+ true ->+ maps:filter(+ fun(SessionId, _Entry) -> maps:is_key(SessionId, Sessions) end, Registrations+ );+ false ->+ Registrations+ end.++-spec evaluate(registrations(), guild_state()) -> registrations().+evaluate(Entries, _State) when map_size(Entries) =:= 0 ->+ Entries;+evaluate(Entries, State) ->+ Requests = [+ {SessionId, UserId, maps:keys(Partners)}+ || {SessionId, #{user_id := UserId, partners := Partners}} <- maps:to_list(Entries)+ ],+ Results = guild_subscription_mutual_channels:filter_session_member_ids(Requests, State),+ GuildId = maps:get(id, State),+ maps:map(+ fun(SessionId, Entry) ->+ apply_result(GuildId, maps:get(SessionId, Results, []), Entry)+ end,+ Entries+ ).++-spec apply_result(integer(), [user_id()], registration()) -> registration().+apply_result(GuildId, EligibleIds, #{pid := Pid, eligible := Previous} = Entry) ->+ Eligible = presence_targets:map_from_ids(EligibleIds),+ ok = notify_if_changed(Pid, GuildId, Previous, Eligible),+ Entry#{eligible := Eligible}.++-spec notify_if_changed(pid(), integer(), #{user_id() => true}, #{user_id() => true}) -> ok.+notify_if_changed(_Pid, _GuildId, Same, Same) ->+ ok;+notify_if_changed(Pid, GuildId, _Previous, Eligible) ->+ Pid ! {dm_partner_mutual, GuildId, maps:keys(Eligible)},+ ok.++-spec live_registrations(registrations(), guild_state()) -> registrations().+live_registrations(Registrations, State) ->+ Sessions = maps:get(sessions, State, #{}),+ maps:filter(+ fun(SessionId, #{user_id := UserId}) ->+ maps:is_key(SessionId, Sessions) andalso+ presence_targets:dm_partner_presence_enabled(UserId)+ end,+ Registrations+ ).++-spec involves_user(user_id(), registration()) -> boolean().+involves_user(UserId, #{user_id := UserId}) ->+ true;+involves_user(UserId, #{partners := Partners}) ->+ maps:is_key(UserId, Partners).++-spec scope(term(), term()) -> scope().+scope(guild_member_add, Data) -> member_scope(Data);+scope(guild_member_remove, Data) -> member_scope(Data);+scope(guild_member_update, Data) -> member_scope(Data);+scope(guild_update, _Data) -> all;+scope(guild_role_update, _Data) -> all;+scope(guild_role_update_bulk, _Data) -> all;+scope(guild_role_delete, _Data) -> all;+scope(channel_create, _Data) -> all;+scope(channel_update, _Data) -> all;+scope(channel_update_bulk, _Data) -> all;+scope(channel_delete, _Data) -> all;+scope(_Event, _Data) -> none.++-spec member_scope(term()) -> scope().+member_scope(#{<<"user">> := #{<<"id">> := RawUserId}}) ->+ case snowflake_id:parse_maybe(RawUserId) of+ UserId when is_integer(UserId) -> {user, UserId};+ _ -> all+ end;+member_scope(_Data) ->+ all.++-spec session_owner(session_id(), guild_state()) -> {ok, user_id(), pid()} | error.+session_owner(SessionId, State) ->+ case maps:get(SessionId, maps:get(sessions, State, #{}), undefined) of+ #{user_id := UserId, pid := Pid} when is_integer(UserId), is_pid(Pid) ->+ {ok, UserId, Pid};+ _ ->+ error+ end.++-spec previous_eligible(registration() | undefined, pid()) -> #{user_id() => true}.+previous_eligible(#{pid := Pid, eligible := Eligible}, Pid) ->+ Eligible;+previous_eligible(_Previous, _Pid) ->+ #{}.++-spec partner_set([term()], user_id()) -> #{user_id() => true}.+partner_set(PartnerIds, UserId) ->+ presence_targets:map_from_ids(+ lists:sublist([Id || Id <- PartnerIds, is_integer(Id), Id =/= UserId], ?MAX_PARTNERS)+ ).++-spec registrations(guild_state()) -> registrations().+registrations(State) ->+ case maps:get(dm_partners, State, #{}) of+ Registrations when is_map(Registrations) -> Registrations;+ _ -> #{}+ end.diff --git a/fluxer_gateway/src/guild/guild_subscription_mutual_channels.erl b/fluxer_gateway/src/guild/guild_subscription_mutual_channels.erlindex 404bdf93f..ef20577fb 100644--- a/fluxer_gateway/src/guild/guild_subscription_mutual_channels.erl+++ b/fluxer_gateway/src/guild/guild_subscription_mutual_channels.erl@@ -3,7 +3,7 @@-module(guild_subscription_mutual_channels).-typing([eqwalizer]).--export([filter_member_ids/3]).+-export([filter_member_ids/3, filter_session_member_ids/2]).-ifdef(TEST).-include_lib("eunit/include/eunit.hrl").@@ -28,6 +28,82 @@ filter_member_ids(SessionUserId, MemberIds, State) ->),lists:reverse(Kept).+-spec filter_session_member_ids([{term(), user_id(), [term()]}], guild_state()) ->+ #{term() => [user_id()]}.+filter_session_member_ids([], _State) ->+ #{};+filter_session_member_ids(Requests, State) ->+ Exceptions = exceptions(State),+ Sessions = maps:get(sessions, State, #{}),+ {Results, _Cache} = lists:foldl(+ fun({SessionId, SessionUserId, MemberIds}, {Acc, Cache}) ->+ SessionMap = request_session_map(SessionId, SessionUserId, Sessions, State),+ {Kept, Cache1} = keep_session_members(+ MemberIds, SessionUserId, SessionMap, Exceptions, State, Cache+ ),+ {Acc#{SessionId => Kept}, Cache1}+ end,+ {#{}, #{}},+ Requests+ ),+ Results.++-spec request_session_map(term(), user_id(), map(), guild_state()) -> map().+request_session_map(SessionId, SessionUserId, Sessions, State) ->+ case maps:get(SessionId, Sessions, undefined) of+ #{user_id := SessionUserId, viewable_channels := Map} = SessionData when is_map(Map) ->+ case maps:get(pending_connect, SessionData, false) of+ true -> session_channel_map(SessionUserId, State);+ _ -> Map+ end;+ _ ->+ session_channel_map(SessionUserId, State)+ end.++-spec keep_session_members(+ [term()], user_id(), map(), sets:set(user_id()), guild_state(), #{term() => [integer()]}+) -> {[user_id()], #{term() => [integer()]}}.+keep_session_members(MemberIds, SessionUserId, SessionMap, Exceptions, State, Cache) ->+ {Kept, _Seen, Cache1} = lists:foldl(+ fun+ (MemberId, Acc) when MemberId =:= SessionUserId; not is_integer(MemberId) ->+ Acc;+ (MemberId, {KeptAcc, Seen, CacheAcc}) ->+ {Key, CacheAcc1} = member_channel_key(MemberId, Exceptions, State, CacheAcc),+ case maps:find(Key, Seen) of+ {ok, true} ->+ {[MemberId | KeptAcc], Seen, CacheAcc1};+ {ok, false} ->+ {KeptAcc, Seen, CacheAcc1};+ error ->+ Shared = has_shared_channel(maps:get(Key, CacheAcc1), SessionMap),+ {kept_if(Shared, MemberId, KeptAcc), Seen#{Key => Shared}, CacheAcc1}+ end+ end,+ {[], #{}, Cache},+ MemberIds+ ),+ {lists:reverse(Kept), Cache1}.++-spec kept_if(boolean(), user_id(), [user_id()]) -> [user_id()].+kept_if(true, MemberId, Kept) -> [MemberId | Kept];+kept_if(false, _MemberId, Kept) -> Kept.++-spec member_channel_key(user_id(), sets:set(user_id()), guild_state(), #{term() => [integer()]}) ->+ {term(), #{term() => [integer()]}}.+member_channel_key(MemberId, Exceptions, State, Cache) ->+ Key =+ case memo_key(MemberId, Exceptions, State) of+ bypass -> {user, MemberId};+ {ok, RawRoles} -> {roles, RawRoles}+ end,+ case maps:is_key(Key, Cache) of+ true ->+ {Key, Cache};+ false ->+ {Key, Cache#{Key => guild_visibility:get_user_viewable_channels(MemberId, State)}}+ end.+-spec session_channel_map(user_id(), guild_state()) -> map().session_channel_map(SessionUserId, State) ->case guild_visibility_channels:get_cached_viewable_channel_map(SessionUserId, State) of@@ -284,4 +360,23 @@ non_member_candidate_is_dropped_test() ->?assertEqual([], filter_member_ids(10, [777], State)),?assertEqual([], reference_filter_member_ids(10, [777], State)).+filter_session_member_ids_matches_filter_member_ids_test() ->+ State = test_state(),+ Ids = candidate_ids(),+ Viewers = [10, 30, 7, 99],+ Requests = [{Viewer, Viewer, Ids} || Viewer <- Viewers],+ ?assertEqual(+ maps:from_list([{Viewer, filter_member_ids(Viewer, Ids, State)} || Viewer <- Viewers]),+ filter_session_member_ids(Requests, State)+ ).++filter_session_member_ids_reads_the_session_viewable_map_test() ->+ State = (test_state())#{+ sessions => #{<<"s10">> => #{user_id => 10, viewable_channels => #{600 => true}}}+ },+ ?assertEqual(+ #{<<"s10">> => [30, 31, 7, 99, 4242]},+ filter_session_member_ids([{<<"s10">>, 10, [20, 30, 31, 7, 99, 4242]}], State)+ ).+-endif.diff --git a/fluxer_gateway/src/presence/presence_targets.erl b/fluxer_gateway/src/presence/presence_targets.erlindex aa718ec79..e2747618c 100644--- a/fluxer_gateway/src/presence/presence_targets.erl+++ b/fluxer_gateway/src/presence/presence_targets.erl@@ -9,6 +9,8 @@group_dm_channel_recipient_ids/2,dm_recipients_from_state/1,dm_channel_recipient_ids/2,+ direct_dm_partner_ids/1,+ dm_partner_presence_enabled/1,map_from_ids/1]).@@ -32,10 +34,11 @@ accumulate_friend_id(_UserId, _Type, Acc) ->-spec group_dm_recipients_from_state(state()) -> #{channel_id() => #{user_id() => true}}.group_dm_recipients_from_state(State) ->UserId = maps:get(user_id, State, undefined),+ Eligible = eligible_dm_partner_ids(State),Channels = maps:get(channels, State, #{}),maps:fold(fun(ChannelId, Channel, Acc) ->- accumulate_dm_channel(ChannelId, Channel, UserId, Acc)+ accumulate_dm_channel(ChannelId, Channel, UserId, Eligible, Acc)end,#{},Channels@@ -45,20 +48,83 @@ group_dm_recipients_from_state(State) ->dm_recipients_from_state(State) ->group_dm_recipients_from_state(State).--spec accumulate_dm_channel(term(), term(), user_id() | undefined, map()) -> map().-accumulate_dm_channel(ChannelId, Channel, UserId, Acc) when+-spec accumulate_dm_channel(+ term(), term(), user_id() | undefined, #{user_id() => true}, map()+) -> map().+accumulate_dm_channel(ChannelId, Channel, UserId, Eligible, Acc) whenis_integer(ChannelId), is_map(Channel)->- case is_group_dm_channel_type(maps:get(<<"type">>, Channel, 0)) of- true ->- RecipientIds = extract_recipient_ids(Channel),- Acc#{ChannelId => map_from_ids([Rid || Rid <- RecipientIds, Rid =/= UserId])};- false ->+ case maps:get(<<"type">>, Channel, 0) of+ 3 ->+ Acc#{ChannelId => map_from_ids(other_recipient_ids(Channel, UserId))};+ 1 ->+ accumulate_direct_dm(+ ChannelId, other_recipient_ids(Channel, UserId), Eligible, Acc+ );+ _ ->Accend;-accumulate_dm_channel(_ChannelId, _Channel, _UserId, Acc) ->+accumulate_dm_channel(_ChannelId, _Channel, _UserId, _Eligible, Acc) ->Acc.+-spec accumulate_direct_dm(channel_id(), [user_id()], #{user_id() => true}, map()) -> map().+accumulate_direct_dm(ChannelId, RecipientIds, Eligible, Acc) ->+ case [Rid || Rid <- RecipientIds, maps:is_key(Rid, Eligible)] of+ [] -> Acc;+ EligibleIds -> Acc#{ChannelId => map_from_ids(EligibleIds)}+ end.++-spec other_recipient_ids(map(), user_id() | undefined) -> [user_id()].+other_recipient_ids(Channel, UserId) ->+ [Rid || Rid <- extract_recipient_ids(Channel), Rid =/= UserId].++-spec eligible_dm_partner_ids(state()) -> #{user_id() => true}.+eligible_dm_partner_ids(State) ->+ case dm_partner_presence_enabled(maps:get(user_id, State, undefined)) of+ true -> connected_guild_dm_partners(State);+ false -> #{}+ end.++-spec connected_guild_dm_partners(state()) -> #{user_id() => true}.+connected_guild_dm_partners(State) ->+ Guilds = maps:get(guilds, State, #{}),+ maps:fold(+ fun(GuildId, PartnerIds, Acc) ->+ case maps:get(GuildId, Guilds, undefined) of+ {Pid, _Ref} when is_pid(Pid), is_map(PartnerIds) -> maps:merge(Acc, PartnerIds);+ _ -> Acc+ end+ end,+ #{},+ maps:get(dm_mutual_by_guild, State, #{})+ ).++-spec direct_dm_partner_ids(state()) -> [user_id()].+direct_dm_partner_ids(State) ->+ UserId = maps:get(user_id, State, undefined),+ PartnerIds = maps:fold(+ fun(_ChannelId, Channel, Acc) -> accumulate_direct_partner(Channel, UserId, Acc) end,+ [],+ maps:get(channels, State, #{})+ ),+ lists:usort(PartnerIds).++-spec accumulate_direct_partner(term(), user_id() | undefined, [user_id()]) -> [user_id()].+accumulate_direct_partner(#{<<"type">> := 1} = Channel, UserId, Acc) ->+ other_recipient_ids(Channel, UserId) ++ Acc;+accumulate_direct_partner(_Channel, _UserId, Acc) ->+ Acc.++-spec dm_partner_presence_enabled(term()) -> boolean().+dm_partner_presence_enabled(UserId) when is_integer(UserId) ->+ case application:get_env(fluxer_gateway, dm_presence_mutual_context, true) of+ true -> true;+ {users, UserIds} when is_list(UserIds) -> lists:member(UserId, UserIds);+ _ -> false+ end;+dm_partner_presence_enabled(_UserId) ->+ false.+-spec is_group_dm_channel_type(term()) -> boolean().is_group_dm_channel_type(3) -> true;is_group_dm_channel_type(_) -> false.diff --git a/fluxer_gateway/src/session/session.erl b/fluxer_gateway/src/session/session.erlindex 0f7617242..84ed0c3d1 100644--- a/fluxer_gateway/src/session/session.erl+++ b/fluxer_gateway/src/session/session.erl@@ -238,6 +238,10 @@ handle_info({call_reconnect, ChannelId, Attempt}, State) whensession_connection:handle_call_reconnect(ChannelId, Attempt, State);handle_info({gateway_timing_update, Timings}, State) ->{noreply, gateway_timings:merge_state(Timings, State)};+handle_info({dm_partner_mutual, GuildId, PartnerIds}, State) when+ is_integer(GuildId), is_list(PartnerIds)+->+ session_dm_partners:handle_mutual(GuildId, PartnerIds, State);handle_info(Msg, State) ->handle_info_lifecycle(Msg, State).diff --git a/fluxer_gateway/src/session/session_connection_guild.erl b/fluxer_gateway/src/session/session_connection_guild.erlindex 56bc270b3..450eac104 100644--- a/fluxer_gateway/src/session/session_connection_guild.erl+++ b/fluxer_gateway/src/session/session_connection_guild.erl@@ -460,7 +460,8 @@ finalize_guild_monitor(GuildId, GuildPid, Guilds0, State, ReadyFun) ->apply_ready_fun(GuildId, GuildPid, ReadyFun, State) ->case ReadyFun(State) of{noreply, ReadyState} ->- {noreply, maybe_replay_guild_subscriptions(GuildId, GuildPid, ReadyState)};+ ReplayedState = maybe_replay_guild_subscriptions(GuildId, GuildPid, ReadyState),+ {noreply, session_dm_partners:register_guild(GuildId, GuildPid, ReplayedState)};{stop, normal, ReadyState} ->{stop, normal, ReadyState}end.diff --git a/fluxer_gateway/src/session/session_dispatch_presence.erl b/fluxer_gateway/src/session/session_dispatch_presence.erlindex ba28dc8c7..7bf6eadc3 100644--- a/fluxer_gateway/src/session/session_dispatch_presence.erl+++ b/fluxer_gateway/src/session/session_dispatch_presence.erl@@ -105,14 +105,33 @@ maybe_flush_pending_presences(relationship_add, Data, State) ->maybe_flush_pending_presences(relationship_update, Data, State) ->maybe_flush_relationship_pending_presences(Data, State);maybe_flush_pending_presences(channel_create, Data, State) ->- flush_dm_channel_pending_presences(Data, State);+ flush_dm_channel_pending_presences(Data, maybe_register_dm_partners(Data, State));maybe_flush_pending_presences(channel_update, Data, State) ->- flush_dm_channel_pending_presences(Data, State);+ flush_dm_channel_pending_presences(Data, maybe_register_dm_partners(Data, State));+maybe_flush_pending_presences(channel_delete, Data, State) ->+ {maybe_register_dm_partners(Data, State), []};+maybe_flush_pending_presences(guild_delete, Data, State) ->+ {forget_deleted_guild(Data, State), []};maybe_flush_pending_presences(channel_recipient_add, Data, State) ->flush_added_recipient_pending_presences(Data, State);maybe_flush_pending_presences(_, _, State) ->{State, []}.+-spec maybe_register_dm_partners(term(), session_state()) -> session_state().+maybe_register_dm_partners(#{<<"type">> := 1}, State) ->+ session_dm_partners:register_all(State);+maybe_register_dm_partners(_Data, State) ->+ State.++-spec forget_deleted_guild(term(), session_state()) -> session_state().+forget_deleted_guild(#{<<"id">> := RawGuildId}, State) ->+ case snowflake_id:parse_maybe(RawGuildId) of+ GuildId when is_integer(GuildId) -> session_dm_partners:forget_guild(GuildId, State);+ _ -> State+ end;+forget_deleted_guild(_Data, State) ->+ State.+-spec flush_dm_channel_pending_presences(map(), session_state()) ->{session_state(), [user_id()]}.flush_dm_channel_pending_presences(Data, State) ->@@ -229,6 +248,7 @@ event_changes_presence_targets(channel_update) -> true;event_changes_presence_targets(channel_delete) -> true;event_changes_presence_targets(channel_recipient_add) -> true;event_changes_presence_targets(channel_recipient_remove) -> true;+event_changes_presence_targets(guild_delete) -> true;event_changes_presence_targets(_) -> false.-spec sync_presence_targets([user_id()], session_state()) -> session_state().diff --git a/fluxer_gateway/src/session/session_dm_partners.erl b/fluxer_gateway/src/session/session_dm_partners.erlnew file mode 100644index 000000000..265379972--- /dev/null+++ b/fluxer_gateway/src/session/session_dm_partners.erl@@ -0,0 +1,80 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(session_dm_partners).+-typing([eqwalizer]).++-export([register_all/1, register_guild/3, handle_mutual/3, forget_guild/2]).++-type session_state() :: map().+-type guild_id() :: integer().+-type user_id() :: integer().++-define(MAX_PARTNERS, 1000).++-spec register_all(session_state()) -> session_state().+register_all(State) ->+ case enabled(State) of+ true ->+ Partners = partner_ids(State),+ maps:foreach(+ fun(_GuildId, GuildRef) -> cast_partners(GuildRef, Partners, State) end,+ maps:get(guilds, State, #{})+ ),+ State;+ false ->+ State+ end.++-spec register_guild(guild_id(), pid(), session_state()) -> session_state().+register_guild(_GuildId, GuildPid, State) ->+ case enabled(State) of+ true ->+ cast_partners({GuildPid, undefined}, partner_ids(State), State),+ State;+ false ->+ State+ end.++-spec handle_mutual(guild_id(), [user_id()], session_state()) -> {noreply, session_state()}.+handle_mutual(GuildId, PartnerIds, State) ->+ case maps:get(GuildId, maps:get(guilds, State, #{}), undefined) of+ {Pid, _Ref} when is_pid(Pid) ->+ {noreply, put_guild_partners(GuildId, PartnerIds, State)};+ _ ->+ {noreply, State}+ end.++-spec forget_guild(guild_id(), session_state()) -> session_state().+forget_guild(GuildId, State) ->+ Current = maps:get(dm_mutual_by_guild, State, #{}),+ State#{dm_mutual_by_guild => maps:remove(GuildId, Current)}.++-spec put_guild_partners(guild_id(), [user_id()], session_state()) -> session_state().+put_guild_partners(GuildId, PartnerIds, State) ->+ Current = maps:get(dm_mutual_by_guild, State, #{}),+ Next =+ case presence_targets:map_from_ids(PartnerIds) of+ Empty when map_size(Empty) =:= 0 -> maps:remove(GuildId, Current);+ Ids -> Current#{GuildId => Ids}+ end,+ case Next =:= Current of+ true ->+ State;+ false ->+ session_dispatch_presence:sync_presence_targets(State#{dm_mutual_by_guild => Next})+ end.++-spec cast_partners(term(), [user_id()], session_state()) -> ok.+cast_partners({Pid, _Ref}, Partners, State) when is_pid(Pid) ->+ gen_server:cast(Pid, {update_dm_partners, maps:get(id, State), Partners});+cast_partners(_GuildRef, _Partners, _State) ->+ ok.++-spec partner_ids(session_state()) -> [user_id()].+partner_ids(State) ->+ lists:sublist(presence_targets:direct_dm_partner_ids(State), ?MAX_PARTNERS).++-spec enabled(session_state()) -> boolean().+enabled(State) ->+ maps:get(bot, State, false) =/= true andalso+ presence_targets:dm_partner_presence_enabled(maps:get(user_id, State, undefined)).diff --git a/fluxer_gateway/test/guild_dm_partners_tests.erl b/fluxer_gateway/test/guild_dm_partners_tests.erlnew file mode 100644index 000000000..92caf4a4d--- /dev/null+++ b/fluxer_gateway/test/guild_dm_partners_tests.erl@@ -0,0 +1,196 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_dm_partners_tests).+-typing([eqwalizer]).++-include_lib("eunit/include/eunit.hrl").++-define(GUILD_ID, 42).+-define(VIEWER_ROLE, 1000).+-define(OTHER_ROLE, 2000).+-define(SESSION, <<"session-10">>).+-define(FLAG, dm_presence_mutual_context).++registration_notifies_mutual_partners_test() ->+ with_flag(true, fun() ->+ State = register_partners(state(), [20, 30, 777]),+ ?assertEqual({dm_partner_mutual, ?GUILD_ID, [20]}, receive_mutual()),+ ?assert(maps:is_key(?SESSION, maps:get(dm_partners, State)))+ end).++unknown_session_is_not_registered_test() ->+ with_flag(true, fun() ->+ {noreply, State} = guild_dm_partners:handle_cast(+ {update_dm_partners, <<"missing">>, [20]}, state()+ ),+ ?assertEqual(#{}, maps:get(dm_partners, State, #{})),+ ?assertEqual(none, receive_mutual())+ end).++disabled_flag_does_not_register_test() ->+ with_flag(false, fun() ->+ State = register_partners(state(), [20]),+ ?assertEqual(#{}, maps:get(dm_partners, State, #{})),+ ?assertEqual(none, receive_mutual())+ end).++unchanged_eligibility_is_not_sent_again_test() ->+ with_flag(true, fun() ->+ State = register_partners(state(), [20]),+ {dm_partner_mutual, _, [20]} = receive_mutual(),+ _ = register_partners(State, [20, 777]),+ ?assertEqual(none, receive_mutual())+ end).++partner_leaving_the_guild_withdraws_the_partner_test() ->+ with_flag(true, fun() ->+ Before = register_partners(state(), [20]),+ {dm_partner_mutual, _, [20]} = receive_mutual(),+ After = without_member(20, Before),+ _ = guild_dm_partners:maybe_reevaluate(+ guild_member_remove, #{<<"user">> => #{<<"id">> => <<"20">>}}, Before, After+ ),+ ?assertEqual({dm_partner_mutual, ?GUILD_ID, []}, receive_mutual())+ end).++guild_wide_event_without_visibility_change_does_nothing_test() ->+ with_flag(true, fun() ->+ Before = register_partners(state(), [20]),+ {dm_partner_mutual, _, [20]} = receive_mutual(),+ Renamed = with_channels(+ [+ (channel(500, viewer_overwrites()))#{<<"name">> => <<"renamed">>},+ channel(600, other_overwrites())+ ],+ Before+ ),+ _ = guild_dm_partners:maybe_reevaluate(channel_update, #{}, Before, Renamed),+ ?assertEqual(none, receive_mutual())+ end).++guild_wide_visibility_change_reevaluates_test() ->+ with_flag(true, fun() ->+ Before = register_partners(state(), [30]),+ ?assertEqual(none, receive_mutual()),+ Opened = with_channels(+ [+ channel(500, viewer_overwrites() ++ [overwrite(?OTHER_ROLE, 0)]),+ channel(600, other_overwrites())+ ],+ Before+ ),+ _ = guild_dm_partners:maybe_reevaluate(channel_update, #{}, Before, Opened),+ ?assertEqual({dm_partner_mutual, ?GUILD_ID, [30]}, receive_mutual())+ end).++disconnected_sessions_are_dropped_on_reevaluation_test() ->+ with_flag(true, fun() ->+ Before = register_partners(state(), [20]),+ {dm_partner_mutual, _, [20]} = receive_mutual(),+ Gone = Before#{sessions => #{}},+ After = guild_dm_partners:maybe_reevaluate(guild_role_delete, #{}, Before, Gone#{+ virtual_channel_access => #{1 => sets:new()}+ }),+ ?assertEqual(#{}, maps:get(dm_partners, After))+ end).++register_partners(State, PartnerIds) ->+ {noreply, NewState} = guild_dm_partners:handle_cast(+ {update_dm_partners, ?SESSION, PartnerIds}, State+ ),+ NewState.++state() ->+ Base = #{+ id => ?GUILD_ID,+ virtual_channel_access => #{},+ data => data(+ [channel(500, viewer_overwrites()), channel(600, other_overwrites())], members()+ )+ },+ Viewable = guild_sessions:build_viewable_channel_map(+ guild_visibility:get_user_viewable_channels(10, Base)+ ),+ Base#{+ sessions => #{+ ?SESSION => #{user_id => 10, pid => self(), viewable_channels => Viewable}+ }+ }.++data(Channels, Members) ->+ #{+ <<"guild">> => #{<<"owner_id">> => <<"7">>},+ <<"roles">> => [role(?GUILD_ID), role(?VIEWER_ROLE), role(?OTHER_ROLE)],+ <<"members">> => Members,+ <<"channels">> => Channels,+ <<"channel_index">> => guild_data_index:build_id_index(Channels)+ }.++members() ->+ maps:from_list(+ [{7, member(7, [])}] +++ [{Id, member(Id, [?VIEWER_ROLE])} || Id <- [10, 20]] +++ [{30, member(30, [?OTHER_ROLE])}]+ ).++without_member(UserId, #{data := Data} = State) ->+ State#{data => Data#{<<"members">> => maps:remove(UserId, maps:get(<<"members">>, Data))}}.++with_channels(Channels, #{data := Data} = State) ->+ State#{+ data => Data#{+ <<"channels">> => Channels,+ <<"channel_index">> => guild_data_index:build_id_index(Channels)+ }+ }.++role(RoleId) ->+ #{<<"id">> => integer_to_binary(RoleId), <<"permissions">> => <<"0">>}.++member(UserId, RoleIds) ->+ #{+ <<"user">> => #{<<"id">> => integer_to_binary(UserId)},+ <<"roles">> => [integer_to_binary(RoleId) || RoleId <- RoleIds]+ }.++viewer_overwrites() ->+ [overwrite(?VIEWER_ROLE, 0)].++other_overwrites() ->+ [overwrite(?OTHER_ROLE, 0)].++overwrite(TargetId, Type) ->+ #{+ <<"id">> => integer_to_binary(TargetId),+ <<"type">> => Type,+ <<"allow">> => integer_to_binary(constants:view_channel_permission()),+ <<"deny">> => <<"0">>+ }.++channel(ChannelId, Overwrites) ->+ #{+ <<"id">> => integer_to_binary(ChannelId),+ <<"type">> => 0,+ <<"permission_overwrites">> => Overwrites+ }.++receive_mutual() ->+ receive+ {dm_partner_mutual, _, _} = Msg -> Msg+ after 100 ->+ none+ end.++with_flag(Value, Fun) ->+ Previous = application:get_env(fluxer_gateway, ?FLAG),+ application:set_env(fluxer_gateway, ?FLAG, Value),+ try+ Fun()+ after+ restore_flag(Previous)+ end.++restore_flag(undefined) ->+ application:unset_env(fluxer_gateway, ?FLAG);+restore_flag({ok, Value}) ->+ application:set_env(fluxer_gateway, ?FLAG, Value).diff --git a/fluxer_gateway/test/presence_targets_dm_partner_tests.erl b/fluxer_gateway/test/presence_targets_dm_partner_tests.erlnew file mode 100644index 000000000..aa6ecefd0--- /dev/null+++ b/fluxer_gateway/test/presence_targets_dm_partner_tests.erl@@ -0,0 +1,93 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(presence_targets_dm_partner_tests).+-typing([eqwalizer]).++-include_lib("eunit/include/eunit.hrl").++-define(SELF, 1).+-define(GUILD, 900).+-define(FLAG, dm_presence_mutual_context).++eligible_direct_dm_is_a_presence_target_test() ->+ with_flag(true, fun() ->+ State = state(#{?GUILD => #{2 => true}}, connected()),+ ?assertEqual(+ #{100 => #{2 => true}, 300 => #{5 => true, 6 => true}},+ presence_targets:group_dm_recipients_from_state(State)+ )+ end).++direct_dm_without_mutual_context_is_not_a_target_test() ->+ with_flag(true, fun() ->+ State = state(#{}, connected()),+ ?assertEqual(+ #{300 => #{5 => true, 6 => true}},+ presence_targets:group_dm_recipients_from_state(State)+ )+ end).++mutual_context_from_a_disconnected_guild_is_ignored_test() ->+ with_flag(true, fun() ->+ State = state(#{?GUILD => #{2 => true}}, #{?GUILD => undefined}),+ ?assertEqual(+ #{300 => #{5 => true, 6 => true}},+ presence_targets:group_dm_recipients_from_state(State)+ )+ end).++disabled_flag_keeps_direct_dms_out_test() ->+ with_flag(false, fun() ->+ State = state(#{?GUILD => #{2 => true, 3 => true}}, connected()),+ ?assertEqual(+ #{300 => #{5 => true, 6 => true}},+ presence_targets:group_dm_recipients_from_state(State)+ )+ end).++user_allowlist_gates_direct_dms_test() ->+ State = state(#{?GUILD => #{2 => true}}, connected()),+ with_flag({users, [?SELF]}, fun() ->+ ?assert(maps:is_key(100, presence_targets:group_dm_recipients_from_state(State)))+ end),+ with_flag({users, [42]}, fun() ->+ ?assertNot(maps:is_key(100, presence_targets:group_dm_recipients_from_state(State)))+ end).++direct_dm_partner_ids_lists_one_to_one_partners_only_test() ->+ ?assertEqual([2, 3], presence_targets:direct_dm_partner_ids(state(#{}, connected()))).++state(MutualByGuild, Guilds) ->+ #{+ user_id => ?SELF,+ guilds => Guilds,+ dm_mutual_by_guild => MutualByGuild,+ channels => #{+ 100 => channel(1, [?SELF, 2]),+ 200 => channel(1, [?SELF, 3]),+ 300 => channel(3, [?SELF, 5, 6])+ }+ }.++channel(Type, RecipientIds) ->+ #{+ <<"type">> => Type,+ <<"recipients">> => [#{<<"id">> => integer_to_binary(Id)} || Id <- RecipientIds]+ }.++connected() ->+ #{?GUILD => {self(), make_ref()}}.++with_flag(Value, Fun) ->+ Previous = application:get_env(fluxer_gateway, ?FLAG),+ application:set_env(fluxer_gateway, ?FLAG, Value),+ try+ Fun()+ after+ restore_flag(Previous)+ end.++restore_flag(undefined) ->+ application:unset_env(fluxer_gateway, ?FLAG);+restore_flag({ok, Value}) ->+ application:set_env(fluxer_gateway, ?FLAG, Value).diff --git a/fluxer_gateway/test/session_dm_partners_tests.erl b/fluxer_gateway/test/session_dm_partners_tests.erlnew file mode 100644index 000000000..121963c49--- /dev/null+++ b/fluxer_gateway/test/session_dm_partners_tests.erl@@ -0,0 +1,97 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(session_dm_partners_tests).+-typing([eqwalizer]).++-include_lib("eunit/include/eunit.hrl").++-define(SELF, 1).+-define(GUILD, 900).+-define(SESSION_ID, <<"session-1">>).+-define(FLAG, dm_presence_mutual_context).++handle_mutual_stores_partners_for_a_connected_guild_test() ->+ {noreply, State} = session_dm_partners:handle_mutual(?GUILD, [2], state(connected())),+ ?assertEqual(#{?GUILD => #{2 => true}}, maps:get(dm_mutual_by_guild, State)).++handle_mutual_ignores_a_guild_that_is_not_connected_test() ->+ Initial = state(#{}),+ ?assertEqual({noreply, Initial}, session_dm_partners:handle_mutual(?GUILD, [2], Initial)).++handle_mutual_drops_the_guild_when_nothing_is_mutual_test() ->+ {noreply, With} = session_dm_partners:handle_mutual(?GUILD, [2], state(connected())),+ {noreply, Without} = session_dm_partners:handle_mutual(?GUILD, [], With),+ ?assertEqual(#{}, maps:get(dm_mutual_by_guild, Without)).++forget_guild_drops_its_partners_test() ->+ {noreply, With} = session_dm_partners:handle_mutual(?GUILD, [2], state(connected())),+ ?assertEqual(+ #{}, maps:get(dm_mutual_by_guild, session_dm_partners:forget_guild(?GUILD, With))+ ).++register_all_sends_direct_partners_to_every_connected_guild_test() ->+ with_flag(true, fun() ->+ _ = session_dm_partners:register_all(state(connected())),+ ?assertEqual({update_dm_partners, ?SESSION_ID, [2, 3]}, receive_cast())+ end).++register_guild_sends_direct_partners_to_that_guild_test() ->+ with_flag(true, fun() ->+ _ = session_dm_partners:register_guild(?GUILD, self(), state(#{})),+ ?assertEqual({update_dm_partners, ?SESSION_ID, [2, 3]}, receive_cast())+ end).++register_all_is_inert_when_disabled_test() ->+ with_flag(false, fun() ->+ _ = session_dm_partners:register_all(state(connected())),+ ?assertEqual(none, receive_cast())+ end).++bots_never_register_test() ->+ with_flag(true, fun() ->+ _ = session_dm_partners:register_all((state(connected()))#{bot => true}),+ ?assertEqual(none, receive_cast())+ end).++state(Guilds) ->+ #{+ id => ?SESSION_ID,+ user_id => ?SELF,+ presence_pid => undefined,+ guilds => Guilds,+ channels => #{+ 100 => channel(1, [?SELF, 2]),+ 200 => channel(1, [?SELF, 3]),+ 300 => channel(3, [?SELF, 5, 6])+ }+ }.++channel(Type, RecipientIds) ->+ #{+ <<"type">> => Type,+ <<"recipients">> => [#{<<"id">> => integer_to_binary(Id)} || Id <- RecipientIds]+ }.++connected() ->+ #{?GUILD => {self(), make_ref()}}.++receive_cast() ->+ receive+ {'$gen_cast', Msg} -> Msg+ after 100 ->+ none+ end.++with_flag(Value, Fun) ->+ Previous = application:get_env(fluxer_gateway, ?FLAG),+ application:set_env(fluxer_gateway, ?FLAG, Value),+ try+ Fun()+ after+ restore_flag(Previous)+ end.++restore_flag(undefined) ->+ application:unset_env(fluxer_gateway, ?FLAG);+restore_flag({ok, Value}) ->+ application:set_env(fluxer_gateway, ?FLAG, Value).