A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
refactor(gateway): move viewable channels cache, drop tests
Hampus087bc19342f5
diff --git a/fluxer_gateway/src/guild/guild_sessions.erl b/fluxer_gateway/src/guild/guild_sessions.erlindex 546a89def..e6413155a 100644--- a/fluxer_gateway/src/guild/guild_sessions.erl+++ b/fluxer_gateway/src/guild/guild_sessions.erl@@ -45,7 +45,7 @@{noreply, guild_state()} | {stop, normal, guild_state()}.handle_session_down(Ref, State) ->case guild_sessions_connect:find_session_by_ref(Ref, State) of- {SessionId, #{pending_connect := true} = Session} = Found ->+ {SessionId, #{pending_connect := true} = Session} = Found when is_binary(SessionId) ->handle_pending_ref_down(SessionId, Session, Ref, Found, State);Found ->guild_sessions_connect:handle_session_down(Ref, Found, State)@@ -91,15 +91,22 @@ set_session_push_hold(SessionId, Hold, State) ->Stateend.--spec released_push_holds([session_id()], guild_state()) -> [session_id()].+-spec released_push_holds([Id], guild_state()) -> [Id] when Id :: term().released_push_holds(SessionIds, State) ->Sessions = maps:get(sessions, State, #{}),[SessionId|| SessionId <- SessionIds,- maps:get(push_hold, maps:get(SessionId, Sessions, #{}), undefined) =:= false+ push_hold_released(maps:get(SessionId, Sessions, #{}))].+-spec push_hold_released(map()) -> boolean().+push_hold_released(SessionData) ->+ case maps:get(push_hold, SessionData, undefined) of+ false -> true;+ _ -> false+ end.+-spec filter_sessions_for_channel(sessions_map(), channel_id(), session_id() | undefined, guild_state()) -> [session_pair()].@@ -331,7 +338,7 @@ maybe_refresh_user_session_cache(UserId, UserRoles, ViewableChannels, SessionDat-spec refresh_all_viewable_channels(guild_state()) -> guild_state().refresh_all_viewable_channels(State) ->- guild_sessions_connect:invalidate_viewable_channels_cache(State),+ guild_viewable_channels_cache:invalidate(State),Sessions = maps:get(sessions, State, #{}),maps:fold(fun refresh_session_viewable/3,@@ -373,11 +380,10 @@ memo_session_can_view_channel(true, SessionData, ChannelId, State, Memo) ->memo_session_can_view_channel_by_permissions(SessionData, ChannelId, State, Memo) ->UserId = maps:get(user_id, SessionData, undefined),case {UserId, maps:get(viewable_channels, SessionData, undefined)} of- {Uid, ViewableChannels} when is_integer(Uid), is_map(ViewableChannels) ->- case maps:is_key(ChannelId, ViewableChannels) of- true -> {true, Memo};- false -> memo_member_channel_access(Uid, ChannelId, State, Memo)- end;+ {Uid, ViewableChannels} when+ is_integer(Uid), is_map(ViewableChannels), is_map_key(ChannelId, ViewableChannels)+ ->+ {true, Memo};{Uid, _} when is_integer(Uid) ->memo_member_channel_access(Uid, ChannelId, State, Memo);_ ->@@ -410,272 +416,3 @@ build_viewable_channel_map(ChannelIds) ->#{},ChannelIds).---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--filter_active_sessions_test() ->- S1 = #{user_id => 1, pending_connect => false},- S2 = #{user_id => 2, pending_connect => true},- S3 = #{user_id => 3},- Sessions = #{<<"a">> => S1, <<"b">> => S2, <<"c">> => S3},- Result = filter_active_sessions(Sessions, <<"a">>, fun(_S, _Sid) -> true end),- ResultSids = lists:sort([Sid || {Sid, _} <- Result]),- ?assertEqual([<<"c">>], ResultSids).--filter_active_sessions_with_predicate_test() ->- S1 = #{user_id => 1},- S2 = #{user_id => 2},- Sessions = #{<<"a">> => S1, <<"b">> => S2},- Result = filter_active_sessions(Sessions, undefined, fun(S, _Sid) ->- maps:get(user_id, S) =:= 2- end),- ?assertEqual(1, length(Result)),- [{<<"b">>, _}] = Result.--store_memo_bound_test() ->- Full = maps:from_list([{I, 0} || I <- lists:seq(1, ?MAX_MEMO_ENTRIES)]),- ?assertEqual(Full, store_memo(0, 1, Full)),- ?assertEqual(?MAX_MEMO_ENTRIES, map_size(store_memo(0, 1, Full))).---spec reference_session_can_access_message(map(), channel_id(), binary(), guild_state()) ->- boolean().-reference_session_can_access_message(SessionData, ChannelId, MessageId, State) ->- case maps:get(user_id, SessionData, undefined) of- UserId when is_integer(UserId) ->- Perms = guild_permissions:get_member_permissions(UserId, ChannelId, State),- guild_permissions_check:can_access_message_by_permissions(Perms, MessageId, State);- _ ->- false- end.---spec reference_session_can_view_channel(session_data(), channel_id(), guild_state()) ->- boolean().-reference_session_can_view_channel(SessionData, ChannelId, State) ->- guild_thread_gate:channel_visible(SessionData, ChannelId, State) andalso- reference_session_can_view_channel_by_permissions(SessionData, ChannelId, State).---spec reference_session_can_view_channel_by_permissions(- session_data(), channel_id(), guild_state()-) ->- boolean().-reference_session_can_view_channel_by_permissions(SessionData, ChannelId, State) ->- UserId = maps:get(user_id, SessionData, undefined),- case {UserId, maps:get(viewable_channels, SessionData, undefined)} of- {Uid, ViewableChannels} when is_integer(Uid), is_map(ViewableChannels) ->- maps:is_key(ChannelId, ViewableChannels) orelse- check_member_channel_access(Uid, ChannelId, State);- {Uid, _} when is_integer(Uid) ->- check_member_channel_access(Uid, ChannelId, State);- _ ->- false- end.---spec reference_filter_channel_direct(- sessions_map(), channel_id(), session_id() | undefined, guild_state()-) -> [session_pair()].-reference_filter_channel_direct(Sessions, ChannelId, SessionIdOpt, State) ->- filter_active_sessions(Sessions, SessionIdOpt, fun(S, _Sid) ->- reference_session_can_view_channel(S, ChannelId, State)- end).---spec reference_filter_message_direct(- sessions_map(), channel_id(), binary(), session_id() | undefined, guild_state()-) -> [session_pair()].-reference_filter_message_direct(Sessions, ChannelId, MessageId, SessionIdOpt, State) ->- filter_active_sessions(Sessions, SessionIdOpt, fun(S, _Sid) ->- reference_session_can_view_channel(S, ChannelId, State) andalso- reference_session_can_access_message(S, ChannelId, MessageId, State)- end).--memo_session_can_view_channel_listed_skips_memo_test() ->- Session = #{user_id => 1001, viewable_channels => #{10 => true}},- ?assertEqual({true, #{}}, memo_session_can_view_channel(false, Session, 10, #{}, #{})).--memo_session_can_view_channel_without_user_test() ->- Session = #{viewable_channels => #{10 => true}},- ?assertEqual({false, #{}}, memo_session_can_view_channel(false, Session, 10, #{}, #{})).--channel_filters_match_per_session_reference_test() ->- State = visibility_fixture_state(),- Sessions = maps:get(sessions, State),- Excludes = [undefined | lists:sublist(lists:sort(maps:keys(Sessions)), 3)],- Results = [- assert_filters_match_reference(Sessions, ChannelId, Exclude, State)- || ChannelId <- visibility_fixture_channels(), Exclude <- Excludes- ],- Visible = lists:append([Sids || {Sids, _} <- Results]),- ?assert(lists:member(<<"u1002-stale">>, Visible)),- ?assert(lists:member(<<"u1005-nomap">>, Visible)),- ?assert(lists:member(<<"u1007-empty">>, Visible)),- ?assertNot(lists:member(<<"nouser">>, Visible)),- ?assert(lists:any(fun({Sids, _}) -> Sids =/= [] end, Results)),- ?assert(lists:any(fun({Sids, Msg}) -> length(Msg) < length(Sids) end, Results)).--assert_filters_match_reference(Sessions, ChannelId, Exclude, State) ->- Channel = filter_sessions_for_channel(Sessions, ChannelId, Exclude, State),- ?assertEqual(reference_filter_channel_direct(Sessions, ChannelId, Exclude, State), Channel),- MessageId = <<"1430000000000000000">>,- Message = filter_sessions_for_message(Sessions, ChannelId, MessageId, Exclude, State),- ?assertEqual(- reference_filter_message_direct(Sessions, ChannelId, MessageId, Exclude, State), Message- ),- {[Sid || {Sid, _} <- Channel], [Sid || {Sid, _} <- Message]}.--visibility_fixture_channels() ->- [10, 20, 30, 40, 50, 60, 61, 70].--visibility_fixture_state() ->- View = constants:view_channel_permission(),- History = constants:read_message_history_permission(),- Deny = fun(Id, Type, Bits) ->- #{- <<"id">> => Id,- <<"type">> => Type,- <<"allow">> => <<"0">>,- <<"deny">> => integer_to_binary(Bits)- }- end,- Allow = fun(Id, Type, Bits) ->- #{- <<"id">> => Id,- <<"type">> => Type,- <<"allow">> => integer_to_binary(Bits),- <<"deny">> => <<"0">>- }- end,- Channel = fun(Id, Type, Parent, Overwrites) ->- #{- <<"id">> => integer_to_binary(Id),- <<"type">> => Type,- <<"parent_id">> => Parent,- <<"permission_overwrites">> => Overwrites- }- end,- Member = fun(UserId, Roles) ->- #{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}, <<"roles">> => Roles}- end,- Data = #{- <<"guild">> => #{- <<"id">> => <<"1">>, <<"owner_id">> => <<"999">>, <<"features">> => []- },- <<"roles">> => [- #{<<"id">> => <<"1">>, <<"permissions">> => integer_to_binary(View bor History)},- #{<<"id">> => <<"200">>, <<"permissions">> => <<"0">>},- #{<<"id">> => <<"300">>, <<"permissions">> => <<"0">>}- ],- <<"members">> => [- Member(999, []),- Member(1001, []),- Member(1002, [<<"300">>]),- Member(1003, [<<"200">>]),- Member(1004, [<<"200">>, <<"300">>]),- Member(1005, []),- Member(1006, [<<"300">>]),- Member(1007, [])- ],- <<"channels">> => [- Channel(10, 0, null, []),- Channel(20, 0, null, [Deny(<<"1">>, 0, View), Allow(<<"300">>, 0, View)]),- Channel(30, 0, null, [Deny(<<"1">>, 0, View), Allow(<<"1005">>, 1, View)]),- Channel(40, 0, null, [Deny(<<"200">>, 0, View)]),- Channel(50, 0, null, [Deny(<<"1">>, 0, History), Allow(<<"300">>, 0, History)]),- Channel(60, 4, null, [Deny(<<"1">>, 0, View)]),- Channel(61, 0, <<"60">>, [Allow(<<"300">>, 0, View)])- ]- },- Sessions = #{- <<"owner">> => #{user_id => 999, viewable_channels => #{}},- <<"u1001-a">> => #{user_id => 1001, viewable_channels => #{10 => true, 40 => true}},- <<"u1001-b">> => #{user_id => 1001},- <<"u1001-pending">> => #{user_id => 1001, pending_connect => true},- <<"u1002-stale">> => #{user_id => 1002, viewable_channels => #{}},- <<"u1002-full">> => #{user_id => 1002, viewable_channels => #{10 => true, 20 => true}},- <<"u1003-a">> => #{user_id => 1003, viewable_channels => #{10 => true, 40 => true}},- <<"u1003-b">> => #{user_id => 1003, viewable_channels => #{}},- <<"u1004">> => #{user_id => 1004, viewable_channels => #{20 => true}},- <<"u1005-nomap">> => #{user_id => 1005},- <<"u1005-map">> => #{user_id => 1005, viewable_channels => #{10 => true}},- <<"u1006">> => #{user_id => 1006, viewable_channels => #{61 => true}},- <<"u1007-empty">> => #{user_id => 1007, viewable_channels => #{}},- <<"u1008-nonmember">> => #{user_id => 1008, viewable_channels => #{}},- <<"u1008-listed">> => #{user_id => 1008, viewable_channels => #{50 => true}},- <<"nouser">> => #{viewable_channels => #{10 => true}}- },- #{- id => 1,- sessions => Sessions,- data => Data,- virtual_channel_access => #{1007 => sets:from_list([20])}- }.--filter_message_memo_matches_direct_test() ->- State = #{data => #{<<"guild">> => #{<<"owner_id">> => <<"1">>}}},- Owner1 = #{user_id => 1, viewable_channels => #{5 => true}},- Owner2 = #{user_id => 1, viewable_channels => #{5 => true}},- Other = #{user_id => 2, viewable_channels => #{5 => true}},- Sessions = #{<<"a">> => Owner1, <<"b">> => Owner2, <<"c">> => Other},- Direct = reference_filter_message_direct(Sessions, 5, <<"1">>, undefined, State),- Memoized = filter_message_memo(Sessions, 5, <<"1">>, undefined, State),- ?assertEqual(Direct, Memoized),- ?assertEqual([<<"a">>, <<"b">>], lists:sort([Sid || {Sid, _} <- Memoized])).--filter_message_memo_collects_visible_sessions_test() ->- State = #{data => #{<<"guild">> => #{<<"owner_id">> => <<"1">>}}},- Owner1 = #{user_id => 1, viewable_channels => #{5 => true}},- Owner2 = #{user_id => 1, viewable_channels => #{5 => true}},- Other = #{user_id => 2, viewable_channels => #{5 => true}},- Sessions = #{<<"a">> => Owner1, <<"b">> => Owner2, <<"c">> => Other},- Memoized = filter_message_memo(Sessions, 5, <<"1">>, undefined, State),- ?assertEqual([<<"a">>, <<"b">>], lists:sort([Sid || {Sid, _} <- Memoized])).--filter_message_memo_skips_excluded_test() ->- State = #{data => #{<<"guild">> => #{<<"owner_id">> => <<"1">>}}},- S1 = #{user_id => 1, viewable_channels => #{5 => true}},- S2 = #{user_id => 1, viewable_channels => #{5 => true}, pending_connect => true},- Sessions = #{<<"a">> => S1, <<"b">> => S2},- ?assertEqual([], filter_message_memo(Sessions, 5, <<"1">>, <<"a">>, State)).--filter_sessions_for_message_test() ->- State = #{data => #{<<"guild">> => #{<<"owner_id">> => <<"1">>}}},- Sessions = #{<<"a">> => #{user_id => 1, viewable_channels => #{5 => true}}},- ?assertEqual(- [{<<"a">>, maps:get(<<"a">>, Sessions)}],- filter_sessions_for_message(Sessions, 5, <<"1">>, undefined, State)- ).--handle_pending_session_down_keeps_tracking_test() ->- Ref = make_ref(),- Pending = #{session_id => <<"a">>, user_id => 1, mref => Ref, pending_connect => true},- Active = #{session_id => <<"b">>, user_id => 1, mref => make_ref()},- Sessions = #{<<"a">> => Pending, <<"b">> => Active},- State = #{- sessions => Sessions,- guild_session_refs => #{Ref => <<"a">>},- session_connect_pending => #{<<"a">> => #{}},- user_session_counts => #{1 => 1},- connected_user_ids => sets:from_list([1])- },- {noreply, NewState} = handle_pending_session_down(<<"a">>, Ref, Sessions, State),- ?assertEqual(#{<<"b">> => Active}, maps:get(sessions, NewState)),- ?assertEqual(#{}, maps:get(guild_session_refs, NewState)),- ?assertEqual(#{}, maps:get(session_connect_pending, NewState)),- ?assertEqual(#{1 => 1}, maps:get(user_session_counts, NewState)),- ?assertEqual([1], sets:to_list(maps:get(connected_user_ids, NewState))),- ?assertEqual(false, maps:is_key(auto_stop_pending, NewState)).--handle_pending_session_down_last_session_test() ->- Ref = make_ref(),- Pending = #{session_id => <<"a">>, user_id => 1, mref => Ref, pending_connect => true},- Sessions = #{<<"a">> => Pending},- State = #{- sessions => Sessions,- guild_session_refs => #{Ref => <<"a">>},- disable_auto_stop_on_empty => true- },- {noreply, NewState} = handle_pending_session_down(<<"a">>, Ref, Sessions, State),- ?assertEqual(#{}, maps:get(sessions, NewState)),- ?assertEqual(#{}, maps:get(guild_session_refs, NewState)),- ?assertEqual(false, maps:is_key(auto_stop_pending, NewState)).---endif.diff --git a/fluxer_gateway/src/guild/guild_sessions_connect.erl b/fluxer_gateway/src/guild/guild_sessions_connect.erlindex c8cf93106..fc6cc3244 100644--- a/fluxer_gateway/src/guild/guild_sessions_connect.erl+++ b/fluxer_gateway/src/guild/guild_sessions_connect.erl@@ -7,18 +7,22 @@handle_session_connect/3,resection_connected_user/4,build_initial_last_message_ids/1,- build_initial_channel_versions/1,handle_session_down/3,find_session_by_ref/2,put_session_ref/3,remove_session_ref/2,build_session_ref_index/1,remove_session/2,- counts_as_connected/1,- invalidate_viewable_channels_cache/1+ counts_as_connected/1]).--type guild_state() :: #{viewable_channels_cache => ets:tid(), term() => term()}.+-type guild_state() :: #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+}.-type session_id() :: binary().-type user_id() :: integer().-type guild_id() :: integer().@@ -30,12 +34,21 @@| {error, too_many_sessions}| {error, not_member}.--export_type([guild_state/0, session_id/0, user_id/0, connect_reply/0]).--define(MAX_SESSIONS_PER_USER_PER_GUILD, 100).--spec handle_session_connect(map(), pid(), guild_state()) ->- {reply, connect_reply(), guild_state()}.+-spec handle_session_connect(map(), pid(), #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+}) ->+ {reply,+ {ok, map()}+ | {ok, unavailable, map()}+ | {error, too_many_sessions}+ | {error, not_member},+ #{viewable_channels_cache => ets:tid(), term() => term()}}.handle_session_connect(Request, Pid, State) ->#{session_id := SessionId, user_id := UserId} = Request,Sessions = maps:get(sessions, State, #{}),@@ -167,7 +180,7 @@ build_session_data(Request, Pid, UserId, SessionId, State) ->user_roles => UserRoles,bot => maps:get(bot, Request, false),is_staff => maps:get(is_staff, Request, false),- viewable_channels => get_viewable_channels_cached(UserId, UserRoles, State),+ viewable_channels => guild_viewable_channels_cache:get(UserId, UserRoles, State),thread_capable => Capable,thread_viewer => Viewer}.@@ -253,9 +266,21 @@ add_channel_version(_, Acc) ->Acc.-spec handle_session_down(- reference(), {session_id() | undefined, session_data() | undefined}, guild_state()+ reference(), {binary() | undefined, map() | undefined}, #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }) ->- {noreply, guild_state()}.+ {noreply, #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }}.handle_session_down(Ref, {DisconnectingSessionId, DisconnectingSession}, State) ->Sessions = maps:get(sessions, State, #{}),DisconnectUserId = disconnect_user_id(DisconnectingSession),@@ -293,7 +318,20 @@ maybe_resection_on_disconnect(#{user_id := UserIdDown}, OldState, NewState) whenmaybe_resection_on_disconnect(_, _OldState, NewState) ->NewState.--spec remove_session(session_id(), guild_state()) -> guild_state().+-spec remove_session(binary(), #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+}) ->+ #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }.remove_session(SessionId, State) ->Sessions = maps:get(sessions, State, #{}),case maps:get(SessionId, Sessions, undefined) of@@ -325,9 +363,11 @@ cleanup_removed_session(Session, State) ->cleanup_session_subscriptions(Session, State)end.--spec counts_as_connected(session_data()) -> boolean().-counts_as_connected(#{pending_connect := true} = Session) ->- maps:get(owns_connected_tracking, Session, false) =:= true;+-spec counts_as_connected(map()) -> boolean().+counts_as_connected(#{pending_connect := true, owns_connected_tracking := true}) ->+ true;+counts_as_connected(#{pending_connect := true}) ->+ false;counts_as_connected(_Session) ->true.@@ -342,8 +382,14 @@ maybe_demonitor_session(Session) ->okend.--spec find_session_by_ref(reference(), guild_state()) ->- {session_id() | undefined, session_data() | undefined}.+-spec find_session_by_ref(reference(), #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+}) ->+ {binary() | undefined, map() | undefined}.find_session_by_ref(Ref, State) ->Sessions = maps:get(sessions, State, #{}),SessionId = maps:get(Ref, maps:get(guild_session_refs, State, #{}), undefined),@@ -372,7 +418,20 @@ remove_session_id(SessionId, Sessions) when is_binary(SessionId) ->remove_session_id(undefined, Sessions) ->Sessions.--spec put_session_ref(session_id(), term(), guild_state()) -> guild_state().+-spec put_session_ref(binary(), term(), #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+}) ->+ #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }.put_session_ref(SessionId, Ref, State) when is_reference(Ref) ->ok = guild_health:put_session(SessionId, State),Refs = maps:get(guild_session_refs, State, #{}),@@ -380,7 +439,7 @@ put_session_ref(SessionId, Ref, State) when is_reference(Ref) ->put_session_ref(_SessionId, _Ref, State) ->State.--spec remove_session_ref(term(), guild_state()) -> guild_state().+-spec remove_session_ref(term(), map()) -> map().remove_session_ref(Ref, State) when is_reference(Ref) ->Refs = maps:get(guild_session_refs, State, #{}),ok = guild_health:remove_session(maps:get(Ref, Refs, undefined), State),@@ -388,7 +447,7 @@ remove_session_ref(Ref, State) when is_reference(Ref) ->remove_session_ref(_Ref, State) ->State.--spec build_session_ref_index(sessions_map()) -> #{reference() => session_id()}.+-spec build_session_ref_index(#{binary() => map()}) -> #{reference() => binary()}.build_session_ref_index(Sessions) ->maps:fold(fun@@ -435,21 +494,41 @@ cleanup_session_subscriptions(Session, State) ->) -> guild_state().maybe_resection_disconnected_user(UserId, OldState, NewState) ->case became_disconnected(UserId, OldState, NewState) of- true -> resection_user_after_connection_change(UserId, OldState, NewState);+ true -> resection_user_after_connection_change(UserId, NewState);false -> NewStateend.-spec resection_connected_user(- user_id() | undefined, map() | undefined, guild_state(), guild_state()-) -> guild_state().+ integer() | undefined,+ map() | undefined,+ #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ },+ #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }+) ->+ #{+ sessions => #{binary() => map()},+ guild_session_refs => #{reference() => binary()},+ connected_user_ids => sets:set(integer()),+ viewable_channels_cache => ets:tid(),+ term() => term()+ }.resection_connected_user(UserId, PresenceBefore, OldState, NewState) whenis_integer(UserId), UserId > 0->case became_connected(UserId, OldState, NewState) oftrue ->- ResectionedState = resection_after_connect(- UserId, PresenceBefore, OldState, NewState- ),+ ResectionedState = resection_after_connect(UserId, PresenceBefore, NewState),_ = guild_presence_reconcile:maybe_schedule_user_repair(UserId, ResectionedState),ResectionedState;false ->@@ -458,13 +537,11 @@ resection_connected_user(UserId, PresenceBefore, OldState, NewState) whenresection_connected_user(_UserId, _PresenceBefore, _OldState, NewState) ->NewState.--spec resection_after_connect(- user_id(), map() | undefined, guild_state(), guild_state()-) -> guild_state().-resection_after_connect(UserId, PresenceBefore, OldState, NewState) ->+-spec resection_after_connect(user_id(), map() | undefined, guild_state()) -> guild_state().+resection_after_connect(UserId, PresenceBefore, NewState) ->case presence_resynced_lists(UserId, PresenceBefore, NewState) oftrue -> resection_user_already_synced(UserId, NewState);- false -> resection_user_after_connection_change(UserId, OldState, NewState)+ false -> resection_user_after_connection_change(UserId, NewState)end.-spec presence_resynced_lists(user_id(), map() | undefined, guild_state()) -> boolean().@@ -491,10 +568,8 @@ became_disconnected(UserId, OldState, NewState) ->user_connected(UserId, State) ->sets:is_element(UserId, guild_member_list_connected:connected_session_user_ids(State)).--spec resection_user_after_connection_change(- user_id(), guild_state(), guild_state()-) -> guild_state().-resection_user_after_connection_change(UserId, _OldState, NewState) ->+-spec resection_user_after_connection_change(user_id(), guild_state()) -> guild_state().+resection_user_after_connection_change(UserId, NewState) ->_ = guild_presence:sync_online_status(UserId, NewState),guild_member_list_write:broadcast_channel_engine_connection_change(UserId, NewState).@@ -502,7 +577,11 @@ resection_user_after_connection_change(UserId, _OldState, NewState) ->session_id(), guild_id(), guild_id() | undefined, guild_state()) -> guild_state().maybe_auto_sync_initial_guild(SessionId, GuildId, GuildId, State) ->- Sessions = require_map(maps:get(sessions, State, #{})),+ Sessions =+ case maps:get(sessions, State, #{}) of+ SessionMap when is_map(SessionMap) -> SessionMap;+ _ -> #{}+ end,case maps:get(SessionId, Sessions, undefined) ofundefined ->State;@@ -523,7 +602,11 @@ track_connected_user(UserId, _Delta, State) when->State;track_connected_user(UserId, Delta, State) ->- Counts = require_map(maps:get(user_session_counts, State, #{})),+ Counts =+ case maps:get(user_session_counts, State, #{}) of+ CountMap when is_map(CountMap) -> CountMap;+ _ -> #{}+ end,Connected = maps:get(connected_user_ids, State, sets:new()),OldCount = require_non_neg(maps:get(UserId, Counts, 0)),NewCount = max(0, OldCount + Delta),@@ -540,55 +623,6 @@ apply_count_change(UserId, 0, Counts, Connected) ->apply_count_change(UserId, NewCount, Counts, Connected) ->{Counts#{UserId => NewCount}, sets:add_element(UserId, Connected)}.--spec get_viewable_channels_cached(- user_id(), [integer()], guild_state()-) -> map().-get_viewable_channels_cached(UserId, UserRoles, State) ->- RoleKey = list_to_tuple(lists:sort(UserRoles)),- CacheTab = viewable_channels_cache_table(State),- lookup_or_compute_viewable(UserId, RoleKey, CacheTab, State).---spec lookup_or_compute_viewable(- user_id(), tuple(), ets:tid() | undefined, guild_state()-) -> map().-lookup_or_compute_viewable(UserId, _RoleKey, undefined, State) ->- compute_viewable_channel_map(UserId, State);-lookup_or_compute_viewable(UserId, RoleKey, CacheTab, State) ->- case ets:lookup(CacheTab, RoleKey) of- [{_, Map}] ->- Map;- [] ->- Map = compute_viewable_channel_map(UserId, State),- ets:insert(CacheTab, {RoleKey, Map}),- Map- end.---spec compute_viewable_channel_map(user_id(), guild_state()) -> map().-compute_viewable_channel_map(UserId, State) ->- guild_sessions:build_viewable_channel_map(- guild_visibility_channels:get_user_viewable_channels(UserId, State)- ).---spec invalidate_viewable_channels_cache(guild_state()) -> ok.-invalidate_viewable_channels_cache(State) ->- case viewable_channels_cache_table(State) of- CacheTab when is_reference(CacheTab) ->- ets:delete_all_objects(CacheTab),- ok;- undefined ->- ok- end.---spec viewable_channels_cache_table(guild_state()) -> ets:tid() | undefined.-viewable_channels_cache_table(#{viewable_channels_cache := CacheTab}) ->- CacheTab;-viewable_channels_cache_table(_) ->- undefined.---spec require_map(term()) -> #{term() => term()}.-require_map(M) when is_map(M) -> M;-require_map(_) -> #{}.--spec require_guild_id(term()) -> guild_id().require_guild_id(Id) when is_integer(Id), Id > 0 -> Id;require_guild_id(_) -> error(badarg).@@ -607,14 +641,3 @@ snowflake_binary(FieldName, Value) ->{ok, Id} -> integer_to_binary(Id);{error, _, _} -> undefinedend.---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--presence_resynced_lists_needs_a_list_visible_change_test() ->- State = #{member_presence => #{42 => #{<<"status">> => <<"online">>}}},- ?assertNot(presence_resynced_lists(42, undefined, State)),- ?assert(presence_resynced_lists(42, #{}, State)),- ?assertNot(presence_resynced_lists(42, #{<<"status">> => <<"online">>}, State)).---endif.diff --git a/fluxer_gateway/src/guild/guild_viewable_channels_cache.erl b/fluxer_gateway/src/guild/guild_viewable_channels_cache.erlnew file mode 100644index 000000000..22fc4d725--- /dev/null+++ b/fluxer_gateway/src/guild/guild_viewable_channels_cache.erl@@ -0,0 +1,56 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_viewable_channels_cache).+-typing([eqwalizer]).++-export([get/3, invalidate/1]).++-type guild_state() :: #{viewable_channels_cache => ets:tid(), term() => term()}.+-type user_id() :: integer().++-spec get(+ integer(), [integer()], #{viewable_channels_cache => ets:tid(), term() => term()}+) -> map().+get(UserId, UserRoles, State) ->+ CacheKey = {UserId, list_to_tuple(lists:sort(UserRoles))},+ CacheTab = viewable_channels_cache_table(State),+ lookup_or_compute_viewable(UserId, CacheKey, CacheTab, State).++-spec lookup_or_compute_viewable(+ user_id(), tuple(), ets:tid() | undefined, guild_state()+) -> map().+lookup_or_compute_viewable(UserId, _CacheKey, undefined, State) ->+ compute_viewable_channel_map(UserId, State);+lookup_or_compute_viewable(UserId, CacheKey, CacheTab, State) ->+ case ets:lookup(CacheTab, CacheKey) of+ [{_, Map}] ->+ Map;+ [] ->+ Map = compute_viewable_channel_map(UserId, State),+ ets:insert(CacheTab, {CacheKey, Map}),+ Map+ end.++-spec compute_viewable_channel_map(user_id(), guild_state()) -> map().+compute_viewable_channel_map(UserId, State) ->+ guild_sessions:build_viewable_channel_map(+ guild_visibility_channels:get_user_viewable_channels(UserId, State)+ ).++-spec invalidate(#{+ viewable_channels_cache => ets:tid(), term() => term()+}) -> ok.+invalidate(State) ->+ case viewable_channels_cache_table(State) of+ CacheTab when is_reference(CacheTab) ->+ ets:delete_all_objects(CacheTab),+ ok;+ undefined ->+ ok+ end.++-spec viewable_channels_cache_table(guild_state()) -> ets:tid() | undefined.+viewable_channels_cache_table(#{viewable_channels_cache := CacheTab}) ->+ CacheTab;+viewable_channels_cache_table(_) ->+ undefined.