A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
%% SPDX-License-Identifier: AGPL-3.0-or-later
-module(guild_thread_dispatch).
-typing([eqwalizer]).
-include_lib("kernel/include/logger.hrl").
-export([
handles/1,
handle/4,
dispatch_counts/0,
count_masked/2,
init_counters/0
]).
-define(RECENT_CREATE_CAP, 256).
-define(PRIVATE_THREAD, 12).
-define(COUNTS_KEY, {?MODULE, variant_counts}).
-define(EVENTS, [
thread_create,
thread_update,
thread_delete,
thread_member_update,
thread_members_update,
thread_list_sync,
thread_member_list_update,
forum_unreads
]).
-define(MASKED_EVENTS, [
message_create,
message_update,
channel_create,
channel_update,
channel_update_bulk,
guild_role_create,
guild_role_update,
guild_role_update_bulk
]).
-type guild_state() :: map().
-type session_pair() :: {binary(), map()}.
-type delivery() :: {atom(), pid(), map()}.
-spec handles(atom()) -> boolean().
handles(thread_create) -> true;
handles(thread_update) -> true;
handles(thread_delete) -> true;
handles(thread_member_update) -> true;
handles(thread_members_update) -> true;
handles(thread_list_sync) -> true;
handles(thread_member_list_update) -> true;
handles(forum_unreads) -> true;
handles(_) -> false.
-spec handle(atom(), map(), full | state_only, map()) -> {noreply, map()}.
handle(Event, EventData, Mode, #{id := GuildId} = State) when is_integer(GuildId) ->
Data = EventData#{<<"guild_id">> => integer_to_binary(GuildId)},
try
State1 =
case guild_thread_load:loading(State) of
true -> guild_thread_load:queue_event(Event, Data, State);
false -> State
end,
{noreply, handle_mode(Mode, Event, Data, GuildId, State1)}
catch
Class:Reason:Stack ->
?LOG_WARNING(
"guild_thread_dispatch_failed: event=~p guild_id=~p class=~p reason=~p stack=~p",
[
Event, GuildId, Class, Reason, Stack
]
),
{noreply, State}
end;
handle(_Event, _EventData, _Mode, State) ->
{noreply, State}.
-spec handle_mode(full | state_only, atom(), map(), integer(), guild_state()) -> guild_state().
handle_mode(state_only, Event, Data, _GuildId, State) ->
guild_state_threads:apply_event(Event, Data, State);
handle_mode(full, Event, Data, GuildId, State) ->
{Deliveries, State1} = handle_event(Event, Data, State),
ok = deliver(Deliveries, GuildId),
after_delivery(Event, Data, State1).
-spec after_delivery(atom(), map(), guild_state()) -> guild_state().
after_delivery(thread_members_update, Data, State) ->
case snowflake_id:parse_maybe(maps:get(<<"id">>, Data, undefined)) of
ThreadId when is_integer(ThreadId) ->
guild_thread_subscriptions:member_lists_changed(ThreadId, State);
_ ->
State
end;
after_delivery(_Event, _Data, State) ->
State.
-spec handle_event(atom(), map(), guild_state()) -> {[delivery()], guild_state()}.
handle_event(thread_create, Data, State) ->
thread_create(Data, State);
handle_event(thread_update, Data, State) ->
thread_update(Data, State);
handle_event(thread_delete, Data, State) ->
thread_delete(Data, State);
handle_event(thread_member_update, Data, State) ->
thread_member_update(Data, State);
handle_event(thread_members_update, Data, State) ->
thread_members_update(Data, State);
handle_event(_Event, _Data, State) ->
{[], State}.
-spec thread_create(map(), guild_state()) -> {[delivery()], guild_state()}.
thread_create(Data, State0) ->
ThreadId = snowflake_id:parse(maps:get(<<"id">>, Data)),
State = guild_state_threads:apply_event(thread_create, Data, State0),
Thread = thread_or_context(ThreadId, Data, State),
Initial = [
UserId
|| M <- list_field(<<"_fluxer_members">>, Data),
UserId <- [snowflake_id:parse_maybe(maps:get(<<"user_id">>, M, undefined))],
is_integer(UserId)
],
InitialSet = maps:from_keys(Initial, true),
Base = public_payload(Data),
{Recipients, _Memo} = recipients(
Thread,
viewer_sessions(State),
State,
fun(Session, Passive) ->
is_map_key(maps:get(user_id, Session, undefined), InitialSet) orelse
(not Passive andalso interested(Session, ThreadId, State))
end,
#{}
),
Deliveries = [
{thread_create, Pid, with_member(Base, ThreadId, UserId, State)}
|| {_Sid, #{pid := Pid, user_id := UserId}} <- Recipients
],
count(thread_create, length(Deliveries)),
{Deliveries, remember_create(ThreadId, Initial, State)}.
-spec thread_update(map(), guild_state()) -> {[delivery()], guild_state()}.
thread_update(Data, State0) ->
ThreadId = snowflake_id:parse(maps:get(<<"id">>, Data)),
WasActive = guild_thread_gate:thread(ThreadId, State0) =/= undefined,
Viewers = viewer_sessions(State0),
Before = thread_or_context(ThreadId, Data, State0),
{BeforeRecipients, Memo} = recipients(
Before, Viewers, State0, joined_or_interested(ThreadId, State0), #{}
),
State = guild_state_threads:apply_event(thread_update, Data, State0),
After = thread_or_context(ThreadId, Data, State),
{AfterRecipients, AfterMemo} = recipients(
After,
Viewers,
State,
joined_or_interested(ThreadId, State),
shared_memo(Before, After, Memo)
),
Payload = public_payload(Data),
Deliveries = [
{thread_update, Pid, Payload}
|| {_Sid, #{pid := Pid}} <- union(BeforeRecipients, AfterRecipients)
],
count(thread_update, length(Deliveries)),
MemberDeliveries =
case {WasActive, guild_thread_gate:thread(ThreadId, State)} of
{false, Restored} when is_map(Restored) ->
unarchive_member_updates(ThreadId, Restored, Viewers, State, AfterMemo);
_ ->
[]
end,
count(thread_member_update, length(MemberDeliveries)),
{Deliveries ++ MemberDeliveries, State}.
-spec shared_memo(map() | undefined, map() | undefined, map()) -> map().
shared_memo(Before, After, Memo) when is_map(Before), is_map(After) ->
ParentId = guild_thread_permissions:parent_id(Before),
case
guild_thread_permissions:parent_id(After) =:= ParentId andalso
maps:get(<<"type">>, Before, undefined) =/= ?PRIVATE_THREAD andalso
maps:get(<<"type">>, After, undefined) =/= ?PRIVATE_THREAD
of
true -> Memo;
false -> #{}
end;
shared_memo(_Before, _After, _Memo) ->
#{}.
-spec unarchive_member_updates(integer(), map(), [session_pair()], guild_state(), map()) ->
[delivery()].
unarchive_member_updates(ThreadId, Thread, Viewers, #{id := GuildId} = State, Memo) ->
Wants = fun(Session, _Passive) -> is_member(Session, ThreadId, State) end,
case guild_thread_gate:store(State) of
undefined ->
[];
Tab ->
{Targets, _Memo} = recipients(
Thread,
Viewers,
State,
Wants,
Memo
),
[
{thread_member_update, Pid, Member#{
<<"guild_id">> => integer_to_binary(GuildId)
}}
|| {_Sid, #{pid := Pid, user_id := UserId}} <- Targets,
Member <- [guild_thread_store:get_member(Tab, ThreadId, UserId)],
is_map(Member)
]
end.
-spec thread_delete(map(), guild_state()) -> {[delivery()], guild_state()}.
thread_delete(Data, State0) ->
ThreadId = snowflake_id:parse(maps:get(<<"id">>, Data)),
Thread = thread_or_context(ThreadId, Data, State0),
Joined = joined_or_interested(ThreadId, State0),
Listed = maps:from_keys(
snowflake_id:parse_list(maps:get(<<"_fluxer_member_ids">>, Data, [])), true
),
Wants = fun(Session, Passive) ->
Joined(Session, Passive) orelse
is_map_key(maps:get(user_id, Session, undefined), Listed)
end,
{Recipients, _Memo} = recipients(Thread, viewer_sessions(State0), State0, Wants, #{}),
Payload = maps:with([<<"id">>, <<"guild_id">>, <<"parent_id">>, <<"type">>], Data),
State = guild_state_threads:apply_event(thread_delete, Data, State0),
Deliveries = [{thread_delete, Pid, Payload} || {_Sid, #{pid := Pid}} <- Recipients],
count(thread_delete, length(Deliveries)),
{Deliveries, State}.
-spec thread_member_update(map(), guild_state()) -> {[delivery()], guild_state()}.
thread_member_update(Data, State0) ->
State = guild_state_threads:apply_event(thread_member_update, Data, State0),
ThreadId = snowflake_id:parse_maybe(maps:get(<<"id">>, Data, undefined)),
TargetId = snowflake_id:parse_maybe(maps:get(<<"user_id">>, Data, undefined)),
Thread = member_update_thread(ThreadId, TargetId, Data, State),
Payload = guild_thread_payload:strip_internal(Data),
Deliveries = [
{thread_member_update, Pid, Payload}
|| Thread =/= undefined,
{_Sid, #{pid := Pid, user_id := UserId} = Session} <- viewer_sessions(State),
UserId =:= TargetId,
can_view(Session, Thread, State)
],
count(thread_member_update, length(Deliveries)),
{Deliveries, State}.
-spec member_update_thread(term(), term(), map(), guild_state()) -> map() | undefined.
member_update_thread(ThreadId, TargetId, Data, State) when
is_integer(ThreadId), is_integer(TargetId)
->
case thread_or_context(ThreadId, Data, State) of
undefined -> parent_context(ThreadId, TargetId, Data);
Thread -> Thread
end;
member_update_thread(_ThreadId, _TargetId, _Data, _State) ->
undefined.
-spec parent_context(integer(), integer(), map()) -> map() | undefined.
parent_context(ThreadId, TargetId, #{<<"_fluxer_parent_id">> := ParentId}) ->
#{
<<"id">> => ThreadId,
<<"parent_id">> => ParentId,
<<"_fluxer_member_ids">> => [integer_to_binary(TargetId)]
};
parent_context(_ThreadId, _TargetId, _Data) ->
undefined.
-spec thread_members_update(map(), guild_state()) -> {[delivery()], guild_state()}.
thread_members_update(Data, State0) ->
ThreadId = snowflake_id:parse(maps:get(<<"id">>, Data)),
State = guild_state_threads:apply_event(thread_members_update, Data, State0),
Thread = thread_or_context(ThreadId, Data, State),
Added = maps:from_keys(
[
UserId
|| M <- list_field(<<"added_members">>, Data),
UserId <- [snowflake_id:parse_maybe(maps:get(<<"user_id">>, M, undefined))],
is_integer(UserId)
],
true
),
Removed = maps:from_keys(
[
UserId
|| Raw <- list_value(maps:get(<<"removed_member_ids">>, Data, [])),
UserId <- [snowflake_id:parse_maybe(Raw)],
is_integer(UserId)
],
true
),
{Suppressed, State1} = take_recent_create(ThreadId, State),
Viewers = viewer_sessions(State1),
{Synthesized, Memo} = synthesized_creates(
Thread, ThreadId, maps:without(Suppressed, Added), Viewers, State1
),
Payload = members_update_payload(Data, State1),
Affected = [
Pair
|| {_Sid, #{user_id := UserId}} = Pair <- Viewers,
is_map_key(UserId, Added) orelse is_map_key(UserId, Removed)
],
{Interested, _Memo} = recipients(
Thread,
Viewers,
State1,
fun(Session, Passive) ->
not Passive andalso interested(Session, ThreadId, State1)
end,
Memo
),
Deliveries = [
{thread_members_update, Pid, Payload}
|| {_Sid, #{pid := Pid}} <- union(Affected, Interested)
],
count(thread_members_update, length(Deliveries)),
{Synthesized ++ Deliveries, State1}.
-spec synthesized_creates(
map() | undefined, integer(), #{integer() => true}, [session_pair()], guild_state()
) ->
{[delivery()], map()}.
synthesized_creates(undefined, _ThreadId, _Users, _Viewers, _State) ->
{[], #{}};
synthesized_creates(_Thread, _ThreadId, Users, _Viewers, _State) when map_size(Users) =:= 0 ->
{[], #{}};
synthesized_creates(Thread, ThreadId, Users, Viewers, State) ->
Base = guild_thread_view:thread_payload(Thread),
{Targets, Memo} = recipients(
Thread,
Viewers,
State,
fun(Session, _Passive) -> is_map_key(maps:get(user_id, Session, undefined), Users) end,
#{}
),
Deliveries = [
{thread_create, Pid, with_member(Base, ThreadId, UserId, State)}
|| {_Sid, #{pid := Pid, user_id := UserId}} <- Targets
],
count(thread_create, length(Deliveries)),
{Deliveries, Memo}.
-spec members_update_payload(map(), guild_state()) -> map().
members_update_payload(Data, State) ->
Base = guild_thread_payload:strip_internal(Data),
case maps:get(<<"added_members">>, Base, undefined) of
Added when is_list(Added) ->
Ctx = guild_member_list_connected:presence_context(State),
Base#{
<<"added_members">> => [decorate_added(M, Ctx, State) || M <- Added, is_map(M)]
};
_ ->
Base
end.
-spec decorate_added(map(), map(), guild_state()) -> map().
decorate_added(Member, PresenceCtx, State) ->
Stripped = maps:without([<<"muted">>, <<"mute_config">>], Member),
case snowflake_id:parse_maybe(maps:get(<<"user_id">>, Member, undefined)) of
UserId when is_integer(UserId) ->
GuildMember = guild_permissions_check:find_member_by_user_id(UserId, State),
Stripped#{
<<"member">> => null_if_undefined(GuildMember),
<<"presence">> => presence(UserId, PresenceCtx)
};
_ ->
Stripped#{<<"member">> => null, <<"presence">> => null}
end.
-spec presence(integer(), map()) -> map() | null.
presence(UserId, Ctx) ->
#{<<"presence">> := Presence} = guild_member_list_connected:add_presence_to_member(
#{}, UserId, Ctx
),
case maps:get(<<"status">>, Presence, <<"offline">>) of
<<"offline">> -> null;
_ -> Presence#{<<"user">> => #{<<"id">> => integer_to_binary(UserId)}}
end.
-spec null_if_undefined(map() | undefined) -> map() | null.
null_if_undefined(undefined) -> null;
null_if_undefined(Value) -> Value.
-spec recipients(
map() | undefined,
[session_pair()],
guild_state(),
fun((map(), boolean()) -> boolean()),
map()
) -> {[session_pair()], map()}.
recipients(undefined, _Viewers, _State, _Wants, Memo) ->
{[], Memo};
recipients(Thread, Viewers, State, Wants, Memo0) ->
GuildId = maps:get(id, State),
Small = session_passive:is_small_guild(State),
{Pairs, Memo} = lists:foldl(
fun({_Sid, Session} = Pair, {Acc, Memo1}) ->
Passive = (not Small) andalso session_passive:is_passive(GuildId, Session),
Candidate = Wants(Session, Passive) andalso Session,
{Ok, Memo2} = guild_thread_gate:thread_view_access(Candidate, Thread, State, Memo1),
{[Pair || Ok] ++ Acc, Memo2}
end,
{[], Memo0},
Viewers
),
{lists:reverse(Pairs), Memo}.
-spec joined_or_interested(integer(), guild_state()) -> fun((map(), boolean()) -> boolean()).
joined_or_interested(ThreadId, State) ->
fun(Session, Passive) ->
is_member(Session, ThreadId, State) orelse
(not Passive andalso interested(Session, ThreadId, State))
end.
-spec interested(map(), integer(), guild_state()) -> boolean().
interested(Session, ThreadId, State) ->
type_conv:is_true(maps:get(bot, Session, false)) orelse
is_member(Session, ThreadId, State) orelse
type_conv:is_true(maps:get(thread_subscribed, Session, false)).
-spec is_member(map(), integer(), guild_state()) -> boolean().
is_member(#{user_id := UserId}, ThreadId, State) ->
case guild_thread_gate:store(State) of
undefined -> false;
Tab -> guild_thread_store:is_member(Tab, ThreadId, UserId)
end;
is_member(_Session, _ThreadId, _State) ->
false.
-spec can_view(map(), map(), guild_state()) -> boolean().
can_view(#{user_id := UserId}, Thread, State) when is_integer(UserId) ->
Member = guild_permissions_check:find_member_by_user_id(UserId, State),
Member =/= undefined andalso guild_thread_view:can_view(UserId, Thread, Member, State);
can_view(_Session, _Thread, _State) ->
false.
-spec viewer_sessions(guild_state()) -> [session_pair()].
viewer_sessions(State) ->
[
{Sid, Session}
|| {Sid, Session} <- maps:to_list(maps:get(sessions, State)),
is_map(Session),
guild_thread_gate:session_viewer(Session),
not type_conv:is_true(maps:get(pending_connect, Session, false)),
is_pid(maps:get(pid, Session, undefined))
].
-spec union([session_pair()], [session_pair()]) -> [session_pair()].
union(A, B) ->
maps:to_list(maps:merge(maps:from_list(A), maps:from_list(B))).
-spec thread_or_context(integer(), map(), guild_state()) -> map() | undefined.
thread_or_context(ThreadId, Data, State) ->
maybe
undefined ?= guild_thread_gate:thread(ThreadId, State),
undefined ?= guild_state_threads:thread_context(ThreadId, Data),
fallback_context(ThreadId, Data)
else
Thread ->
Thread
end.
-spec fallback_context(integer(), map()) -> map() | undefined.
fallback_context(ThreadId, #{<<"parent_id">> := _, <<"type">> := _} = Data) ->
(maps:with([<<"parent_id">>, <<"type">>, <<"_fluxer_member_ids">>], Data))#{
<<"id">> => ThreadId
};
fallback_context(_ThreadId, _Data) ->
undefined.
-spec public_payload(map()) -> map().
public_payload(Data) ->
maps:without(
[<<"member">>, <<"member_ids_preview">>], guild_thread_payload:strip_internal(Data)
).
-spec with_member(map(), integer(), term(), guild_state()) -> map().
with_member(Base, ThreadId, UserId, State) when is_integer(UserId) ->
Member =
case guild_thread_gate:store(State) of
undefined -> undefined;
Tab -> guild_thread_store:get_member(Tab, ThreadId, UserId)
end,
case Member of
undefined -> Base;
_ -> Base#{<<"member">> => Member}
end;
with_member(Base, _ThreadId, _UserId, _State) ->
Base.
-spec remember_create(integer(), [integer()], guild_state()) -> guild_state().
remember_create(_ThreadId, [], State) ->
State;
remember_create(ThreadId, Initial, State) ->
Recent0 = maps:get(thread_recent_create, State, #{}),
Recent =
case map_size(Recent0) >= ?RECENT_CREATE_CAP of
true -> #{};
false -> Recent0
end,
State#{thread_recent_create => Recent#{ThreadId => Initial}}.
-spec take_recent_create(integer(), guild_state()) -> {[integer()], guild_state()}.
take_recent_create(ThreadId, State) ->
case maps:get(thread_recent_create, State, #{}) of
#{ThreadId := Initial} = Recent ->
{Initial, State#{thread_recent_create => maps:remove(ThreadId, Recent)}};
_ ->
{[], State}
end.
-spec deliver([delivery()], integer()) -> ok.
deliver(Deliveries, GuildId) ->
Grouped = lists:foldl(
fun({Event, Pid, Payload}, Acc) ->
Key = {Event, Payload},
Acc#{Key => [Pid | maps:get(Key, Acc, [])]}
end,
#{},
Deliveries
),
Ordered = lists:sort(
fun({{EventA, _}, _}, {{EventB, _}, _}) -> order(EventA) =< order(EventB) end,
maps:to_list(Grouped)
),
lists:foreach(
fun({{Event, Payload}, Pids}) ->
Encoded =
{pre_encoded,
iolist_to_binary(
json:encode(guild_data_wire:payload(Payload), fun json:encode_value/2)
)},
gateway_dispatch_relay:dispatch_many(lists:reverse(Pids), Event, Encoded, GuildId)
end,
Ordered
).
-spec order(atom()) -> non_neg_integer().
order(thread_create) -> 0;
order(thread_update) -> 1;
order(thread_delete) -> 1;
order(thread_member_update) -> 2;
order(thread_members_update) -> 3;
order(_) -> 4.
-spec list_field(binary(), map()) -> [map()].
list_field(Key, Map) ->
[M || M <- list_value(maps:get(Key, Map, [])), is_map(M)].
-spec list_value(term()) -> list().
list_value(List) when is_list(List) -> List;
list_value(_) -> [].
-spec count(atom(), non_neg_integer()) -> ok.
count(Event, N) ->
count_key({Event, viewer}, N).
-spec count_masked(atom(), non_neg_integer()) -> ok.
count_masked(Event, N) ->
count_key({Event, masked}, N).
-spec count_keys() -> [{atom(), viewer | masked}].
count_keys() ->
[{E, viewer} || E <- ?EVENTS] ++ [{E, masked} || E <- ?MASKED_EVENTS].
-spec count_key({atom(), viewer | masked}, non_neg_integer()) -> ok.
count_key(_Key, 0) ->
ok;
count_key(Key, N) ->
case key_index(Key, count_keys(), 1) of
undefined ->
ok;
Index ->
guild_thread_store:add_counter(?COUNTS_KEY, Index, N)
end.
-spec init_counters() -> ok.
init_counters() ->
guild_thread_store:ensure_counter(?COUNTS_KEY, length(count_keys())).
-spec key_index(term(), [term()], pos_integer()) -> pos_integer() | undefined.
key_index(Key, [Key | _], Index) -> Index;
key_index(Key, [_ | Rest], Index) -> key_index(Key, Rest, Index + 1);
key_index(_Key, [], _Index) -> undefined.
-spec dispatch_counts() -> #{{atom(), viewer | masked} => non_neg_integer()}.
dispatch_counts() ->
Keys = count_keys(),
case persistent_term:get(?COUNTS_KEY, undefined) of
undefined ->
maps:from_list([{K, 0} || K <- Keys]);
Counters ->
maps:from_list([
{K, counters:get(Counters, I)}
|| {K, I} <- lists:zip(Keys, lists:seq(1, length(Keys)))
])
end.