A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
refactor(gateway): move viewable memo out, drop inline tests
Hampus19bb24c0bf41
diff --git a/fluxer_gateway/src/guild/guild_data_channels.erl b/fluxer_gateway/src/guild/guild_data_channels.erlindex f42a5e5b8..1cc81a671 100644--- a/fluxer_gateway/src/guild/guild_data_channels.erl+++ b/fluxer_gateway/src/guild/guild_data_channels.erl@@ -104,7 +104,7 @@ member_view_cache(State) ->_ ->#{inputs => Inputs,- exceptions => guild_maintenance:viewable_exceptions(State),+ exceptions => guild_viewable_memo:exceptions(State),views => #{}}end.@@ -221,15 +221,28 @@ select_first_viewable(Channel, GuildId, BasePerms) ->-spec check_viewable(integer() | undefined, integer() | undefined, map(), integer(), integer()) ->integer() | null.check_viewable(ChannelType, ChannelId, Channel, GuildId, BasePerms) when- is_integer(ChannelId), ChannelType =:= 0 orelse ChannelType =:= 2 orelse ChannelType =:= 5+ is_integer(ChannelId)->- case bitset:has(BasePerms, constants:administrator_permission()) of- true -> ChannelId;- false -> check_view_permission(ChannelId, Channel, GuildId, BasePerms)+ case is_landing_channel_type(ChannelType) of+ true -> check_admin_or_view(ChannelId, Channel, GuildId, BasePerms);+ false -> nullend;check_viewable(_, _, _, _, _) ->null.+-spec is_landing_channel_type(integer() | undefined) -> boolean().+is_landing_channel_type(0) -> true;+is_landing_channel_type(2) -> true;+is_landing_channel_type(5) -> true;+is_landing_channel_type(_) -> false.++-spec check_admin_or_view(integer(), map(), integer(), integer()) -> integer() | null.+check_admin_or_view(ChannelId, Channel, GuildId, BasePerms) ->+ case bitset:has(BasePerms, constants:administrator_permission()) of+ true -> ChannelId;+ false -> check_view_permission(ChannelId, Channel, GuildId, BasePerms)+ end.+-spec check_view_permission(integer(), map(), integer(), integer()) -> integer() | null.check_view_permission(ChannelId, Channel, GuildId, BasePerms) ->FinalPerms = guild_permissions_overwrites:apply_channel_overwrites(diff --git a/fluxer_gateway/src/guild/guild_maintenance.erl b/fluxer_gateway/src/guild/guild_maintenance.erlindex 907f7e049..9ca70cb41 100644--- a/fluxer_gateway/src/guild/guild_maintenance.erl+++ b/fluxer_gateway/src/guild/guild_maintenance.erl@@ -12,12 +12,9 @@schedule_count_cache_refresh/1,maybe_prune_invalid_member_subscriptions/2,cleanup_removed_member_subscriptions/3,- apply_everyone_perm_bit/2,- viewable_exceptions/1,- new_viewable_memo/1,- memoised_member_viewable_channel_map/3+ apply_everyone_perm_bit/2]).--export_type([guild_state/0, viewable_memo/0]).+-export_type([guild_state/0]).-define(COUNT_CACHE_REFRESH_INTERVAL, 30000).@@ -25,8 +22,9 @@-type session_id() :: binary().-type subscription_state() :: guild_subscriptions:subscription_state().-type guild_state() :: map().--type viewable_memo() :: #{exceptions := sets:set(user_id()), cache := #{term() => map()}}.--type prune_acc() :: {subscription_state(), #{user_id() => non_neg_integer()}, viewable_memo()}.+-type prune_acc() :: {+ subscription_state(), #{user_id() => non_neg_integer()}, guild_viewable_memo:memo()+}.-spec update_counts(guild_state()) -> guild_state().update_counts(State) ->@@ -166,7 +164,7 @@ member_subscriptions(State) ->-spec require_subscription_state(term()) -> subscription_state().require_subscription_state(MemberSubs) when is_map(MemberSubs) ->- maps:merge(guild_subscriptions:init_state(), MemberSubs).+ maps:merge(guild_subscriptions:init_state(), eqwalizer:dynamic_cast(MemberSubs)).-spec prune_member_subscription_map(subscription_state(), map(), guild_state()) ->{subscription_state(), #{user_id() => non_neg_integer()}}.@@ -177,7 +175,7 @@ prune_member_subscription_map(MemberSubs, Sessions, State) ->fun(MemberId, Subscribers, Acc) ->prune_member_subscribers(MemberId, Subscribers, Sessions, State, Acc)end,- {MemberSubs, #{}, new_viewable_memo(State)},+ {MemberSubs, #{}, guild_viewable_memo:new(State)},MemberSubs),{NewMemberSubs, Counts}.@@ -192,7 +190,7 @@ prune_member_subscription_map(MemberSubs, Sessions, State) ->prune_member_subscribers(MemberId, Subscribers, Sessions, State, {Subs, Counts, Memo}) whenis_integer(MemberId)->- {MemberViewable, Memo1} = memoised_member_viewable_channel_map(MemberId, State, Memo),+ {MemberViewable, Memo1} = guild_viewable_memo:memoised_channel_map(MemberId, State, Memo),{KeptSubscribers, RemovedCount} = prune_subscriber_set(Subscribers, Sessions, MemberViewable, State),@@ -214,118 +212,6 @@ session_viewable_channels(SessionData, SessionUserId, State) ->)end.--spec member_viewable_channel_map(user_id(), guild_state()) -> map().-member_viewable_channel_map(MemberId, State) ->- guild_sessions:build_viewable_channel_map(- guild_visibility_channels:get_user_viewable_channels(MemberId, State)- ).--%% One pass reads a fixed state, and get_user_viewable_channels/2 reads nothing from a-%% member except its raw roles term, so two members holding the same term see the same-%% channels. The user-specific inputs are the guild owner, virtual channel access and-%% user-type permission overwrites, and every user named by one of those bypasses the-%% memo. A term is still computed the first time the pass meets it, so a term whose-%% computation raises raises on the same member it does without the memo.--spec new_viewable_memo(guild_state()) -> viewable_memo().-new_viewable_memo(State) ->- #{exceptions => viewable_exceptions(State), cache => #{}}.---spec memoised_member_viewable_channel_map(user_id(), guild_state(), viewable_memo()) ->- {map(), viewable_memo()}.-memoised_member_viewable_channel_map(MemberId, State, Memo) ->- #{exceptions := Exceptions, cache := Cache} = Memo,- case memo_key(MemberId, Exceptions, State) of- bypass ->- {member_viewable_channel_map(MemberId, State), Memo};- {ok, RawRoles} ->- cached_member_viewable_channel_map(MemberId, RawRoles, State, Cache, Memo)- end.---spec cached_member_viewable_channel_map(- user_id(), term(), guild_state(), #{term() => map()}, viewable_memo()-) -> {map(), viewable_memo()}.-cached_member_viewable_channel_map(MemberId, RawRoles, State, Cache, Memo) ->- case maps:find(RawRoles, Cache) of- {ok, Viewable} ->- {Viewable, Memo};- error ->- Viewable = member_viewable_channel_map(MemberId, State),- {Viewable, Memo#{cache := Cache#{RawRoles => Viewable}}}- end.---spec memo_key(user_id(), sets:set(user_id()), guild_state()) -> {ok, term()} | bypass.-memo_key(MemberId, Exceptions, State) ->- case sets:is_element(MemberId, Exceptions) of- true ->- bypass;- false ->- member_roles_key(guild_permissions_check:find_member_by_user_id(MemberId, State))- end.---spec member_roles_key(map() | undefined) -> {ok, term()} | bypass.-member_roles_key(Member) when is_map(Member) ->- {ok, maps:get(<<"roles">>, Member, [])};-member_roles_key(_Member) ->- bypass.---spec viewable_exceptions(guild_state()) -> sets:set(user_id()).-viewable_exceptions(State) ->- Data = map_utils:ensure_map(map_utils:get_safe(State, data, #{})),- Guild = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),- Owner = owner_ids(maps:get(<<"owner_id">>, Guild, undefined)),- Virtual = maps:keys(map_utils:ensure_map(maps:get(virtual_channel_access, State, #{}))),- sets:from_list(Owner ++ Virtual ++ overwrite_target_ids(Data)).--%% parse_maybe/1, not parse_optional/1: an id this rejects makes the permission check-%% itself raise before it can match a user, so leaving it out keeps the memo exact.--spec owner_ids(term()) -> [user_id()].-owner_ids(OwnerIdRaw) ->- case snowflake_id:parse_maybe(OwnerIdRaw) of- OwnerId when is_integer(OwnerId) -> [OwnerId];- _ -> []- end.--%% Both places a permission check can take overwrites from, and role targets alongside-%% user targets. Role ids can never collide with user ids, so the superset only costs a-%% few members their memo entry.--spec overwrite_target_ids(map()) -> [user_id()].-overwrite_target_ids(Data) ->- Cached = maps:fold(- fun(_ChannelId, Entries, Acc) -> cached_target_ids(Entries, Acc) end,- [],- map_utils:ensure_map(maps:get(overwrite_perms_cache, Data, #{}))- ),- maps:fold(- fun(_ChannelId, Channel, Acc) -> channel_target_ids(Channel, Acc) end,- Cached,- guild_data_index_channels:channel_index(Data)- ).---spec cached_target_ids(term(), [user_id()]) -> [user_id()].-cached_target_ids(Entries, Acc) when is_list(Entries) ->- [Id || {Id, _Type, _Allow, _Deny} <- Entries, is_integer(Id)] ++ Acc;-cached_target_ids(_Entries, Acc) ->- Acc.---spec channel_target_ids(term(), [user_id()]) -> [user_id()].-channel_target_ids(Channel, Acc) when is_map(Channel) ->- lists:foldl(- fun overwrite_target_id/2,- Acc,- map_utils:ensure_list(maps:get(<<"permission_overwrites">>, Channel, []))- );-channel_target_ids(_Channel, Acc) ->- Acc.---spec overwrite_target_id(term(), [user_id()]) -> [user_id()].-overwrite_target_id(Overwrite, Acc) when is_map(Overwrite) ->- case snowflake_id:parse_maybe(maps:get(<<"id">>, Overwrite, undefined)) of- Id when is_integer(Id) -> [Id | Acc];- _ -> Acc- end;-overwrite_target_id(_Overwrite, Acc) ->- Acc.-%% update_pruned_member_subscription/4 drops the whole result when nothing was removed,%% so the kept set is only ever built when Removed is non-empty, and then by the same%% fold over the same subscribers as before.@@ -390,24 +276,6 @@ session_shares_member_channels(SessionData, MemberViewable, State) ->falseend.--spec maps_share_any_key(map(), map()) -> boolean().-maps_share_any_key(MapA, MapB) ->- {Smaller, Larger} =- case map_size(MapA) =< map_size(MapB) of- true -> {MapA, MapB};- false -> {MapB, MapA}- end,- maps_share_any_key_iter(maps:iterator(Smaller), Larger).---spec maps_share_any_key_iter(maps:iterator(), map()) -> boolean().-maps_share_any_key_iter(Iterator, LargerMap) ->- case maps:next(Iterator) of- none ->- false;- {Key, _, Next} ->- maps:is_key(Key, LargerMap) orelse maps_share_any_key_iter(Next, LargerMap)- end.--spec update_pruned_member_subscription(user_id(),sets:set(session_id()),@@ -498,280 +366,3 @@ update_everyone_role_permissions(Role, Current, Bit, Acc, ChangedAcc) ->-spec role_permissions_int(map()) -> integer().role_permissions_int(Role) ->bitset:parse(maps:get(<<"permissions">>, Role, undefined)).---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--prune_invalid_member_subscriptions_batches_by_member_test() ->- State = prune_test_state(),- Result = maybe_prune_invalid_member_subscriptions(guild_role_update, State),- MemberSubs = maps:get(member_subscriptions, Result),- ?assertEqual([<<"s1">>], guild_subscriptions:get_subscribed_sessions(20, MemberSubs)),- ?assertEqual([], guild_subscriptions:get_subscribed_sessions(30, MemberSubs)),- ?assertEqual(#{20 => 1, 30 => 1}, maps:get(presence_subscriptions, Result)).--prune_test_state() ->- GuildId = 42,- ViewerRole = 1000,- OtherRole = 2000,- ChannelA = 500,- ChannelB = 600,- MemberSubs0 = guild_subscriptions:init_state(),- MemberSubs1 = guild_subscriptions:subscribe(<<"s1">>, 20, MemberSubs0),- MemberSubs2 = guild_subscriptions:subscribe(<<"s1">>, 30, MemberSubs1),- MemberSubs3 = guild_subscriptions:subscribe(<<"missing">>, 30, MemberSubs2),- #{- id => GuildId,- sessions => #{- <<"s1">> => #{- session_id => <<"s1">>,- user_id => 10,- pid => self(),- viewable_channels => #{ChannelA => true}- }- },- member_subscriptions => MemberSubs3,- presence_subscriptions => #{20 => 1, 30 => 3},- data => #{- <<"guild">> => #{<<"owner_id">> => <<"999">>},- <<"roles">> => [- prune_role(GuildId, 0),- prune_role(ViewerRole, 0),- prune_role(OtherRole, 0)- ],- <<"members">> => #{- 10 => prune_member(10, [ViewerRole]),- 20 => prune_member(20, [ViewerRole]),- 30 => prune_member(30, [OtherRole])- },- <<"channels">> => [- prune_channel(ChannelA, [prune_overwrite(ViewerRole, 0)]),- prune_channel(ChannelB, [prune_overwrite(OtherRole, 0)])- ]- }- }.--prune_role(RoleId, Permissions) ->- #{- <<"id">> => integer_to_binary(RoleId),- <<"permissions">> => integer_to_binary(Permissions)- }.--prune_member(UserId, RoleIds) ->- #{- <<"user">> => #{<<"id">> => integer_to_binary(UserId)},- <<"roles">> => [integer_to_binary(RoleId) || RoleId <- RoleIds]- }.--update_counts_repairs_missing_members_table_test() ->- ok = application:set_env(fluxer_gateway, guild_members_table_self_heal, true),- try- Result = update_counts(repair_counts_state()),- Tab = maps:get(members_ets, maps:get(data, Result)),- ?assert(is_reference(Tab)),- ?assertNot(maps:is_key(members_ets_repair, Result)),- ?assertEqual([1, 2], lists:sort([Id || {Id, _} <- ets:tab2list(Tab)])),- ?assertEqual(2, maps:get(member_count, Result)),- ets:delete(Tab)- after- application:unset_env(fluxer_gateway, guild_members_table_self_heal)- end.--repair_counts_state() ->- MemberMap = #{- 1 => #{<<"user">> => #{<<"id">> => 1}},- 2 => #{<<"user">> => #{<<"id">> => 2}}- },- #{- id => 42,- disable_guild_count_cache_updates => true,- data => #{- <<"channels">> => [],- <<"members">> => MemberMap,- members_normalized => MemberMap- }- }.--prune_channel(ChannelId, Overwrites) ->- #{- <<"id">> => integer_to_binary(ChannelId),- <<"permission_overwrites">> => Overwrites- }.--prune_overwrite(TargetId, Type) ->- #{- <<"id">> => integer_to_binary(TargetId),- <<"type">> => Type,- <<"allow">> => integer_to_binary(constants:view_channel_permission()),- <<"deny">> => <<"0">>- }.--%% Members 30, 31, 99 and 4242 all have the same roles term and reach only channel 600-%% through it, but 99 holds virtual access to channel 500 and 4242 is a user-overwrite-%% target on 500, so neither may be answered from that term. Member 7 owns the guild,-%% 777 is subscribed without being a member, and session s3 has no cached viewable map.-memo_prune_state() ->- GuildId = 42,- ViewerRole = 1000,- OtherRole = 2000,- Members = maps:from_list(- [{7, prune_member(7, [])}] ++- [{Id, prune_member(Id, [ViewerRole])} || Id <- [10, 20, 21]] ++- [{Id, prune_member(Id, [OtherRole])} || Id <- [30, 31, 99, 4242]]- ),- #{- id => GuildId,- virtual_channel_access => #{99 => sets:from_list([500])},- sessions => #{- <<"s1">> => #{user_id => 10, viewable_channels => #{500 => true}},- <<"s2">> => #{user_id => 30, viewable_channels => #{600 => true}},- <<"s3">> => #{user_id => 10}- },- member_subscriptions => memo_prune_subscriptions(),- presence_subscriptions => maps:from_list(- [{Id, 3} || Id <- [7, 20, 21, 30, 31, 99, 4242, 777]]- ),- data => #{- <<"guild">> => #{<<"owner_id">> => <<"7">>},- <<"roles">> => [- prune_role(GuildId, 0),- prune_role(ViewerRole, 0),- prune_role(OtherRole, 0)- ],- <<"members">> => Members,- <<"channels">> => [- prune_channel(500, [prune_overwrite(ViewerRole, 0), prune_overwrite(4242, 1)]),- prune_channel(600, [prune_overwrite(OtherRole, 0)])- ]- }- }.--memo_prune_subscriptions() ->- lists:foldl(- fun({SessionId, MemberIds}, Acc) ->- guild_subscriptions:update_subscriptions(SessionId, MemberIds, Acc)- end,- guild_subscriptions:init_state(),- [- {<<"s1">>, [20, 21, 30, 31, 7, 99, 4242, 777]},- {<<"s2">>, [20, 30]},- {<<"s3">>, [20, 30]},- {<<"missing">>, [31]}- ]- ).--%% prune_member_subscription_map/3 as it read before the memo: every subscribed member-%% materialises its own viewable channel map and every subscriber set is rebuilt.-prune_keeps_exception_members_a_session_can_still_see_test() ->- Result = maybe_prune_invalid_member_subscriptions(guild_role_update, memo_prune_state()),- MemberSubs = maps:get(member_subscriptions, Result),- Presence = #{7 => 3, 20 => 2, 21 => 3, 30 => 1, 31 => 1, 99 => 3, 4242 => 3, 777 => 2},- ?assertEqual(- [[<<"s1">>], [<<"s1">>], [<<"s1">>], [], []],- [- lists:sort(guild_subscriptions:get_subscribed_sessions(Id, MemberSubs))- || Id <- [7, 99, 4242, 31, 777]- ]- ),- ?assertEqual(Presence, maps:get(presence_subscriptions, Result)).--memo_never_answers_owner_virtual_or_overwrite_targets_from_the_cache_test() ->- State = memo_prune_state(),- {_, Memo} = memoised_member_viewable_channel_map(30, State, new_viewable_memo(State)),- Answers = [memoised_member_viewable_channel_map(Id, State, Memo) || Id <- [7, 99, 4242]],- ?assertEqual(- [member_viewable_channel_map(Id, State) || Id <- [7, 99, 4242]],- [Viewable || {Viewable, _} <- Answers]- ),- ?assertEqual([Memo, Memo, Memo], [M || {_, M} <- Answers]).--prune_subscriber_set_returns_the_original_set_when_nothing_is_removed_test() ->- State = memo_prune_state(),- Subscribers = sets:from_list([<<"s1">>, <<"s3">>]),- Viewable = member_viewable_channel_map(20, State),- ?assertEqual(- {Subscribers, 0},- prune_subscriber_set(Subscribers, maps:get(sessions, State), Viewable, State)- ).-permission_cache_skips_nick_only_member_update_test() ->- UserId = 4242,- OldState = permission_cache_state(- 7710001, permission_cache_member(UserId, [10], <<"old">>)- ),- EventData = permission_cache_member(UserId, [10], <<"new">>),- NewState = permission_cache_apply(EventData, OldState),- ?assertNotEqual(- guild_data_index_members:get_member(UserId, maps:get(data, OldState)),- guild_data_index_members:get_member(UserId, maps:get(data, NewState))- ),- ?assertEqual(- {error, not_found},- permission_cache_refresh(guild_member_update, EventData, OldState, NewState)- ).--permission_cache_rebuilds_on_member_role_change_test() ->- UserId = 4242,- OldState = permission_cache_state(- 7710002, permission_cache_member(UserId, [10], <<"old">>)- ),- EventData = permission_cache_member(UserId, [10, 11], <<"old">>),- NewState = permission_cache_apply(EventData, OldState),- {ok, Snapshot} = permission_cache_refresh(- guild_member_update, EventData, OldState, NewState- ),- #{<<"roles">> := Roles} = guild_permissions_check:find_member_by_user_id(UserId, Snapshot),- ?assertEqual([10, 11], Roles).--permission_cache_rebuilds_on_member_timeout_change_test() ->- UserId = 4242,- Until = <<"2026-09-01T00:00:00.000Z">>,- OldState = permission_cache_state(- 7710003, permission_cache_member(UserId, [10], <<"old">>)- ),- EventData = (permission_cache_member(UserId, [10], <<"old">>))#{- <<"communication_disabled_until">> => Until- },- NewState = permission_cache_apply(EventData, OldState),- {ok, Snapshot} = permission_cache_refresh(- guild_member_update, EventData, OldState, NewState- ),- #{<<"communication_disabled_until">> := MemberUntil} =- guild_permissions_check:find_member_by_user_id(UserId, Snapshot),- ?assertEqual(Until, MemberUntil).--permission_cache_rebuilds_for_other_mutating_events_test() ->- State = permission_cache_state(7710004, permission_cache_member(4242, [10], <<"old">>)),- ?assertMatch({ok, _}, permission_cache_refresh(guild_role_update, #{}, State, State)).--permission_cache_rebuilds_without_member_update_user_id_test() ->- State = permission_cache_state(7710005, permission_cache_member(4242, [10], <<"old">>)),- ?assertMatch({ok, _}, permission_cache_refresh(guild_member_update, #{}, State, State)).--permission_cache_refresh(Event, EventData, OldState, NewState) ->- GuildId = maps:get(id, NewState),- ok = guild_permission_cache:delete(GuildId),- try- ok = maybe_put_permission_cache(Event, EventData, OldState, NewState),- guild_permission_cache:get_snapshot(GuildId)- after- ok = guild_permission_cache:delete(GuildId)- end.--permission_cache_state(GuildId, Member) ->- #{- id => GuildId,- data => guild_data_index:normalize_map(#{- <<"guild">> => #{<<"owner_id">> => <<"999">>},- <<"roles">> => [prune_role(10, 0), prune_role(11, 0)],- <<"members">> => [Member],- <<"channels">> => []- })- }.--permission_cache_member(UserId, RoleIds, Nick) ->- (prune_member(UserId, RoleIds))#{<<"nick">> => Nick}.--permission_cache_apply(EventData, State) ->- State#{data => guild_state_member:handle_member_update(EventData, maps:get(data, State))}.---endif.diff --git a/fluxer_gateway/src/guild/guild_viewable_memo.erl b/fluxer_gateway/src/guild/guild_viewable_memo.erlnew file mode 100644index 000000000..7e2c6c10a--- /dev/null+++ b/fluxer_gateway/src/guild/guild_viewable_memo.erl@@ -0,0 +1,123 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_viewable_memo).+-typing([eqwalizer]).++-export([new/1, memoised_channel_map/3, channel_map/2, exceptions/1]).+-export_type([memo/0, user_id/0, guild_state/0]).++-type user_id() :: integer().+-type guild_state() :: map().+-type memo() :: #{exceptions := sets:set(user_id()), cache := #{term() => map()}}.++-spec channel_map(user_id(), guild_state()) -> map().+channel_map(MemberId, State) ->+ guild_sessions:build_viewable_channel_map(+ guild_visibility_channels:get_user_viewable_channels(MemberId, State)+ ).++%% One pass reads a fixed state, and get_user_viewable_channels/2 reads nothing from a+%% member except its raw roles term, so two members holding the same term see the same+%% channels. The user-specific inputs are the guild owner, virtual channel access and+%% user-type permission overwrites, and every user named by one of those bypasses the+%% memo. A term is still computed the first time the pass meets it, so a term whose+%% computation raises raises on the same member it does without the memo.+-spec new(guild_state()) -> memo().+new(State) ->+ #{exceptions => exceptions(State), cache => #{}}.++-spec memoised_channel_map(user_id(), guild_state(), memo()) ->+ {map(), memo()}.+memoised_channel_map(MemberId, State, Memo) ->+ #{exceptions := Exceptions, cache := Cache} = Memo,+ case memo_key(MemberId, Exceptions, State) of+ bypass ->+ {channel_map(MemberId, State), Memo};+ {ok, RawRoles} ->+ cached_channel_map(MemberId, RawRoles, State, Cache, Memo)+ end.++-spec cached_channel_map(+ user_id(), term(), guild_state(), #{term() => map()}, memo()+) -> {map(), memo()}.+cached_channel_map(MemberId, RawRoles, State, Cache, Memo) ->+ case maps:find(RawRoles, Cache) of+ {ok, Viewable} ->+ {Viewable, Memo};+ error ->+ Viewable = channel_map(MemberId, State),+ {Viewable, Memo#{cache := Cache#{RawRoles => Viewable}}}+ end.++-spec memo_key(user_id(), sets:set(user_id()), guild_state()) -> {ok, term()} | bypass.+memo_key(MemberId, Exceptions, State) ->+ case sets:is_element(MemberId, Exceptions) of+ true ->+ bypass;+ false ->+ member_roles_key(guild_permissions_check:find_member_by_user_id(MemberId, State))+ end.++-spec member_roles_key(map() | undefined) -> {ok, term()} | bypass.+member_roles_key(Member) when is_map(Member) ->+ {ok, maps:get(<<"roles">>, Member, [])};+member_roles_key(_Member) ->+ bypass.++-spec exceptions(guild_state()) -> sets:set(user_id()).+exceptions(State) ->+ Data = map_utils:ensure_map(map_utils:get_safe(State, data, #{})),+ Guild = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),+ Owner = owner_ids(maps:get(<<"owner_id">>, Guild, undefined)),+ Virtual = maps:keys(map_utils:ensure_map(maps:get(virtual_channel_access, State, #{}))),+ sets:from_list(Owner ++ Virtual ++ overwrite_target_ids(Data)).++%% parse_maybe/1, not parse_optional/1: an id this rejects makes the permission check+%% itself raise before it can match a user, so leaving it out keeps the memo exact.+-spec owner_ids(term()) -> [user_id()].+owner_ids(OwnerIdRaw) ->+ case snowflake_id:parse_maybe(OwnerIdRaw) of+ OwnerId when is_integer(OwnerId) -> [OwnerId];+ _ -> []+ end.++%% Both places a permission check can take overwrites from, and role targets alongside+%% user targets. Role ids can never collide with user ids, so the superset only costs a+%% few members their memo entry.+-spec overwrite_target_ids(map()) -> [user_id()].+overwrite_target_ids(Data) ->+ Cached = maps:fold(+ fun(_ChannelId, Entries, Acc) -> cached_target_ids(Entries, Acc) end,+ [],+ map_utils:ensure_map(maps:get(overwrite_perms_cache, Data, #{}))+ ),+ maps:fold(+ fun(_ChannelId, Channel, Acc) -> channel_target_ids(Channel, Acc) end,+ Cached,+ guild_data_index_channels:channel_index(Data)+ ).++-spec cached_target_ids(term(), [user_id()]) -> [user_id()].+cached_target_ids(Entries, Acc) when is_list(Entries) ->+ [Id || {Id, _Type, _Allow, _Deny} <- Entries, is_integer(Id)] ++ Acc;+cached_target_ids(_Entries, Acc) ->+ Acc.++-spec channel_target_ids(term(), [user_id()]) -> [user_id()].+channel_target_ids(Channel, Acc) when is_map(Channel) ->+ lists:foldl(+ fun overwrite_target_id/2,+ Acc,+ map_utils:ensure_list(maps:get(<<"permission_overwrites">>, Channel, []))+ );+channel_target_ids(_Channel, Acc) ->+ Acc.++-spec overwrite_target_id(term(), [user_id()]) -> [user_id()].+overwrite_target_id(Overwrite, Acc) when is_map(Overwrite) ->+ case snowflake_id:parse_maybe(maps:get(<<"id">>, Overwrite, undefined)) of+ Id when is_integer(Id) -> [Id | Acc];+ _ -> Acc+ end;+overwrite_target_id(_Overwrite, Acc) ->+ Acc.diff --git a/fluxer_gateway/src/guild/guild_visibility_memo.erl b/fluxer_gateway/src/guild/guild_visibility_memo.erlindex 356133da8..ab9299cd2 100644--- a/fluxer_gateway/src/guild/guild_visibility_memo.erl+++ b/fluxer_gateway/src/guild/guild_visibility_memo.erl@@ -5,7 +5,7 @@-export([new/3, pairs/5]).--export_type([memo/0, pairs/0]).+-export_type([memo/0, pairs/0, guild_state/0, channel_id/0]).-type guild_state() :: map().-type user_id() :: integer().@@ -13,20 +13,19 @@-type visibility() :: #{channel_id() => {boolean(), boolean()}}.-type settled() :: {#{channel_id() => true}, [channel_id()]} | unsettled.-type pairs() :: {visibility(), settled()}.--type memo() ::- disabled- | #{- exceptions := sets:set(user_id()),- unchanged := #{channel_id() => true},- pairs := #{term() => pairs()}- }.+-type active_memo() :: #{+ exceptions := sets:set(user_id()),+ unchanged := #{channel_id() => true},+ pairs := #{term() => pairs()}+}.+-type memo() :: disabled | active_memo().-spec new([channel_id()], guild_state(), guild_state()) -> memo().new(ChannelIds, OldState, NewState) ->#{exceptions => sets:union(- guild_maintenance:viewable_exceptions(OldState),- guild_maintenance:viewable_exceptions(NewState)+ guild_viewable_memo:exceptions(OldState),+ guild_viewable_memo:exceptions(NewState)),unchanged => maps:from_keys([@@ -44,28 +43,36 @@ new(ChannelIds, OldState, NewState) ->{pairs() | none, memo()}.pairs(_ChannelIds, _OldState, _NewState, _ChangeContext, disabled) ->{none, disabled};-pairs(ChannelIds, OldState, NewState, ChangeContext, Memo) ->+pairs(ChannelIds, OldState, NewState, ChangeContext, #{} = Memo) ->#{user_id := UserId, old_member := OldMember, new_member := NewMember} = ChangeContext,- #{exceptions := Exceptions, unchanged := Unchanged, pairs := Cache} = Memo,+ #{exceptions := Exceptions} = Memo,case {sets:is_element(UserId, Exceptions), OldMember, NewMember} of{false, #{}, #{}} ->Key = {maps:get(<<"roles">>, OldMember, []), maps:get(<<"roles">>, NewMember, [])},- case maps:find(Key, Cache) of- {ok, Found} ->- {Found, Memo};- error ->- Reusable =- case Key of- {Same, Same} -> Unchanged;- _ -> #{}- end,- Computed = compute(ChannelIds, OldState, NewState, Reusable, ChangeContext),- {Computed, Memo#{pairs := Cache#{Key => Computed}}}- end;+ cached_pairs(Key, ChannelIds, {OldState, NewState}, ChangeContext, Memo);_ ->{none, Memo}end.+-spec cached_pairs(+ {term(), term()}, [channel_id()], {guild_state(), guild_state()}, map(), active_memo()+) ->+ {pairs(), active_memo()}.+cached_pairs(Key, ChannelIds, {OldState, NewState}, ChangeContext, Memo) ->+ #{unchanged := Unchanged, pairs := Cache} = Memo,+ case maps:find(Key, Cache) of+ {ok, Found} ->+ {Found, Memo};+ error ->+ Reusable = reusable_channels(Key, Unchanged),+ Computed = compute(ChannelIds, OldState, NewState, Reusable, ChangeContext),+ {Computed, Memo#{pairs := Cache#{Key => Computed}}}+ end.++-spec reusable_channels({term(), term()}, #{channel_id() => true}) -> #{channel_id() => true}.+reusable_channels({Same, Same}, Unchanged) -> Unchanged;+reusable_channels(_Key, _Unchanged) -> #{}.+-spec compute([channel_id()], guild_state(), guild_state(), #{channel_id() => true}, map()) ->pairs().compute(ChannelIds, OldState, NewState, Reusable, ChangeContext) ->@@ -94,7 +101,7 @@ visibility(ChannelId, OldState, NewState, Reusable, ChangeContext) ->-spec settle(visibility()) -> settled().settle(Visibility) ->- case lists:all(fun({Old, New}) -> Old =:= New end, maps:values(Visibility)) of+ case all_unchanged(Visibility) oftrue ->{maps:from_keys([Id || {Id, {_, true}} <- maps:to_list(Visibility)], true),@@ -103,3 +110,7 @@ settle(Visibility) ->false ->unsettledend.++-spec all_unchanged(visibility()) -> boolean().+all_unchanged(Visibility) ->+ lists:all(fun({Old, New}) -> Old =:= New end, maps:values(Visibility)).