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 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.erl
index 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 -> null
end;
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.erl
index 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}) when
is_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) ->
false
end.
--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.erl
new file mode 100644
index 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.erl
index 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) of
true ->
{
maps:from_keys([Id || {Id, {_, true}} <- maps:to_list(Visibility)], true),
@@ -103,3 +110,7 @@ settle(Visibility) ->
false ->
unsettled
end.
+
+-spec all_unchanged(visibility()) -> boolean().
+all_unchanged(Visibility) ->
+ lists:all(fun({Old, New}) -> Old =:= New end, maps:values(Visibility)).