Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

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.erl
index 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) ->
State
end.
--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.erl
index 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) when
maybe_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) ->
ok
end.
--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 -> NewState
end.
-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) when
is_integer(UserId), UserId > 0
->
case became_connected(UserId, OldState, NewState) of
true ->
- 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) when
resection_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) of
true -> 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) of
undefined ->
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, _, _} -> undefined
end.
-
--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.erl
new file mode 100644
index 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.