Skip to content

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

TypeScript fluxerfluxerapp
21.2 KB
Raw Blame
%% SPDX-License-Identifier: AGPL-3.0-or-later

-module(guild_thread_subscriptions).
-typing([eqwalizer]).

-export([
    update/3,
    handle_tick/2,
    handle_drain/1,
    clear_on_passive/1,
    access_gained/4,
    member_lists_changed/2,
    resync_after_load/1,
    presence_changed/2,
    member_changed/2,
    handle_list_flush/1,
    refresh_presence_users/1,
    export_handoff/1,
    restore_handoff/1,
    list_sync_counts/0,
    init_counters/0
]).

-define(MAX_MEMBER_LISTS, 10).
-define(MAX_LIST_MEMBERS, 1000).
-define(MAX_PRESENCE_USERS, 1000).
-define(SYNC_JITTER_MS, 5000).
-define(SYNC_RATE, 20).
-define(LIST_FLUSH_MS, 250).
-define(COUNTS_KEY, {?MODULE, list_sync}).

-type guild_state() :: map().

-export_type([guild_state/0]).

-spec update(binary(), map(), guild_state()) -> guild_state().
update(SessionId, Subscriptions, State) ->
    Sessions = maps:get(sessions, State, #{}),
    case maps:get(SessionId, Sessions, undefined) of
        Session when is_map(Session) ->
            update_viewer(
                guild_thread_gate:session_viewer(Session),
                SessionId,
                Session,
                Subscriptions,
                State
            );
        _ ->
            State
    end.

-spec update_viewer(boolean(), binary(), map(), map(), guild_state()) -> guild_state().
update_viewer(true, SessionId, Session, Subscriptions, State) ->
    apply_update(SessionId, Session, Subscriptions, State);
update_viewer(false, _SessionId, _Session, _Subscriptions, State) ->
    State.

-spec apply_update(binary(), map(), map(), guild_state()) -> guild_state().
apply_update(SessionId, Session0, Subscriptions, State) ->
    {Session1, SyncNeeded} = apply_threads_flag(
        maps:get(threads, Subscriptions, undefined), Session0
    ),
    {Session2, NewLists} = apply_member_lists(
        maps:get(member_lists, Subscriptions, undefined), Session1, State
    ),
    Sessions = maps:get(sessions, State, #{}),
    State1 = refresh_presence_users(
        maps:get(thread_member_lists, Session0, []) =/=
            maps:get(thread_member_lists, Session2, []),
        State#{sessions => Sessions#{SessionId => Session2}}
    ),
    lists:foreach(fun(ThreadId) -> send_member_list(Session2, ThreadId, State1) end, NewLists),
    maybe_schedule_sync(SyncNeeded, SessionId, State1).

-spec apply_threads_flag(term(), map()) -> {map(), boolean()}.
apply_threads_flag(true, Session) ->
    {Session#{thread_subscribed => true}, not thread_subscribed(Session)};
apply_threads_flag(false, Session) ->
    {maps:remove(thread_subscribed, Session), false};
apply_threads_flag(_Other, Session) ->
    {Session, false}.

-spec thread_subscribed(map()) -> boolean().
thread_subscribed(#{thread_subscribed := true}) -> true;
thread_subscribed(_Session) -> false.

-spec apply_member_lists(term(), map(), guild_state()) -> {map(), [integer()]}.
apply_member_lists(Ids, Session, State) when is_list(Ids) ->
    Viewable = lists:sublist(
        [Id || Id <- lists:usort(Ids), is_integer(Id), viewable_thread(Session, Id, State)],
        ?MAX_MEMBER_LISTS
    ),
    Updated =
        case Viewable of
            [] -> maps:remove(thread_member_lists, Session);
            _ -> Session#{thread_member_lists => Viewable}
        end,
    {Updated, Viewable};
apply_member_lists(_Other, Session, _State) ->
    {Session, []}.

-spec viewable_thread(map(), integer(), guild_state()) -> boolean().
viewable_thread(Session, ThreadId, State) ->
    case guild_thread_gate:thread(ThreadId, State) of
        undefined -> false;
        Thread -> session_can_view(Session, Thread, State)
    end.

-spec session_can_view(map(), map(), guild_state()) -> boolean().
session_can_view(#{user_id := UserId}, Thread, State) when is_integer(UserId) ->
    case guild_permissions_check:find_member_by_user_id(UserId, State) of
        undefined -> false;
        Member -> guild_thread_view:can_view(UserId, Thread, Member, State)
    end;
session_can_view(_Session, _Thread, _State) ->
    false.

-spec schedule_sync(binary(), guild_state()) -> guild_state().
schedule_sync(SessionId, State) ->
    Pending = maps:get(thread_sync_pending, State, #{}),
    case maps:is_key(SessionId, Pending) of
        true ->
            State;
        false ->
            _ = erlang:send_after(
                rand:uniform(?SYNC_JITTER_MS) - 1, self(), {thread_list_sync_tick, SessionId}
            ),
            State#{thread_sync_pending => Pending#{SessionId => scheduled}}
    end.

-spec maybe_schedule_sync(boolean(), binary(), guild_state()) -> guild_state().
maybe_schedule_sync(true, SessionId, State) -> schedule_sync(SessionId, State);
maybe_schedule_sync(false, _SessionId, State) -> State.

-spec export_handoff(guild_state()) -> map().
export_handoff(State) ->
    maps:merge(
        case State of
            #{thread_sync_pending := Pending} -> #{thread_handoff_syncs => maps:keys(Pending)};
            _ -> #{}
        end,
        case State of
            #{thread_list_dirty := Dirty} -> #{thread_handoff_lists => maps:keys(Dirty)};
            _ -> #{}
        end
    ).

-spec restore_handoff(guild_state()) -> guild_state().
restore_handoff(State0) ->
    State = maps:without([thread_handoff_syncs, thread_handoff_lists], State0),
    State1 =
        case State0 of
            #{thread_handoff_syncs := SessionIds} when is_list(SessionIds) ->
                lists:foldl(
                    fun schedule_sync/2, State, [Sid || Sid <- SessionIds, is_binary(Sid)]
                );
            _ ->
                State
        end,
    case [Id || Id <- maps:get(thread_handoff_lists, State0, []), is_integer(Id)] of
        [] -> State1;
        ThreadIds -> mark_dirty(ThreadIds, State1#{thread_list_refresh => true})
    end.

-spec handle_tick(term(), guild_state()) -> guild_state().
handle_tick(SessionId, State) when is_binary(SessionId) ->
    Pending = maps:get(thread_sync_pending, State, #{}),
    case maps:get(SessionId, Pending, undefined) of
        queued ->
            drain(State);
        _ ->
            Queue = maps:get(thread_sync_queue, State, queue:new()),
            drain(State#{
                thread_sync_pending => Pending#{SessionId => queued},
                thread_sync_queue => queue:in(SessionId, Queue)
            })
    end;
handle_tick(_SessionId, State) ->
    State.

-spec handle_drain(guild_state()) -> guild_state().
handle_drain(State) ->
    drain(maps:remove(thread_sync_timer, State)).

-spec drain(guild_state()) -> guild_state().
drain(State) ->
    Queue = maps:get(thread_sync_queue, State, queue:new()),
    case queue:out(Queue) of
        {empty, _} ->
            maps:remove(thread_sync_queue, State);
        {{value, SessionId}, Rest} ->
            drain_session(SessionId, Rest, State)
    end.

-spec drain_session(binary(), queue:queue(), guild_state()) -> guild_state().
drain_session(SessionId, Rest, State) ->
    Now = erlang:monotonic_time(millisecond),
    case take_token(Now, maps:get(thread_sync_bucket, State, {?SYNC_RATE, Now})) of
        {ok, Bucket} ->
            send_full_sync(SessionId, State),
            Pending = maps:remove(SessionId, maps:get(thread_sync_pending, State, #{})),
            drain(
                put_pending(Pending, State#{
                    thread_sync_bucket => Bucket, thread_sync_queue => Rest
                })
            );
        {wait, {Tokens, _} = Bucket} ->
            arm_drain(ceil((1 - Tokens) * 1000 / ?SYNC_RATE), State#{
                thread_sync_bucket => Bucket
            })
    end.

-spec put_pending(map(), guild_state()) -> guild_state().
put_pending(Pending, State) when map_size(Pending) =:= 0 ->
    maps:remove(thread_sync_pending, State);
put_pending(Pending, State) ->
    State#{thread_sync_pending => Pending}.

-spec arm_drain(integer(), guild_state()) -> guild_state().
arm_drain(_DelayMs, #{thread_sync_timer := true} = State) ->
    State;
arm_drain(DelayMs, State) ->
    _ = erlang:send_after(max(1, DelayMs), self(), thread_list_sync_drain),
    State#{thread_sync_timer => true}.

-spec take_token(integer(), {number(), integer()}) ->
    {ok, {number(), integer()}} | {wait, {number(), integer()}}.
take_token(Now, {Tokens0, Last}) ->
    Tokens = min(?SYNC_RATE, Tokens0 + (Now - Last) * ?SYNC_RATE / 1000),
    case Tokens >= 1 of
        true -> {ok, {Tokens - 1, Now}};
        false -> {wait, {Tokens, Now}}
    end.

-spec send_full_sync(binary(), guild_state()) -> ok.
send_full_sync(SessionId, State) ->
    case maps:get(SessionId, maps:get(sessions, State, #{}), undefined) of
        #{thread_viewer := true, pid := Pid, user_id := UserId} = Session when
            is_pid(Pid)
        ->
            send_available_sync(Pid, UserId, Session, State);
        _ ->
            ok
    end.

-spec send_available_sync(pid(), integer(), map(), guild_state()) -> ok.
send_available_sync(Pid, UserId, Session, State) ->
    case guild_availability:is_guild_unavailable_for_user(UserId, State) of
        true ->
            ok;
        false ->
            send_list_sync(Pid, UserId, sync_scope(Session), State),
            count(full)
    end.

-spec sync_scope(map()) -> all | joined.
sync_scope(#{thread_subscribed := true}) -> all;
sync_scope(#{bot := true}) -> all;
sync_scope(_Session) -> joined.

-spec resync_after_load(guild_state()) -> guild_state().
resync_after_load(State) ->
    Tab = guild_thread_gate:store(State),
    State1 = refresh_presence_users(State),
    maps:fold(
        fun(SessionId, Session, Acc) ->
            maybe_schedule_sync(needs_resync(Session, Tab), SessionId, Acc)
        end,
        mark_dirty(maps:keys(maps:get(thread_list_sessions, State1, #{})), State1),
        maps:get(sessions, State, #{})
    ).

-spec needs_resync(term(), ets:table() | undefined) -> boolean().
needs_resync(_Session, undefined) ->
    false;
needs_resync(#{thread_viewer := true, pending_connect := true}, _Tab) ->
    false;
needs_resync(#{thread_viewer := true, user_id := UserId} = Session, Tab) ->
    sync_scope(Session) =:= all orelse
        guild_thread_store:user_thread_ids(Tab, eqwalizer:dynamic_cast(UserId)) =/= [];
needs_resync(_Session, _Tab) ->
    false.

-spec send_list_sync(pid(), integer(), [integer()] | all | joined, guild_state()) -> ok.
send_list_sync(Pid, UserId, Parents, #{id := GuildId} = State) ->
    Member = guild_permissions_check:find_member_by_user_id(UserId, State),
    Payload = guild_thread_view:list_sync(GuildId, UserId, Parents, Member, State),
    gateway_dispatch_relay:dispatch(Pid, thread_list_sync, Payload, GuildId).

-spec clear_on_passive(map()) -> map().
clear_on_passive(Session) ->
    maps:remove(thread_subscribed, Session).

-spec access_gained(map(), [integer()], guild_state(), integer()) -> ok.
access_gained(Session, AddedChannelIds, State, _GuildId) ->
    case guild_thread_gate:session_viewer(Session) andalso guild_thread_gate:store(State) of
        false ->
            ok;
        undefined ->
            ok;
        Tab ->
            Parents = [
                P
             || P <- AddedChannelIds, guild_thread_store:parent_thread_ids(Tab, P) =/= []
            ],
            send_access_sync(Parents, Session, State)
    end.

-spec send_access_sync([integer()], map(), guild_state()) -> ok.
send_access_sync([], _Session, _State) ->
    ok;
send_access_sync(Parents, #{pid := Pid, user_id := UserId}, State) when is_pid(Pid) ->
    count(access),
    send_list_sync(Pid, UserId, Parents, State);
send_access_sync(_Parents, _Session, _State) ->
    ok.

-spec member_lists_changed(integer(), guild_state()) -> guild_state().
member_lists_changed(ThreadId, #{thread_list_sessions := Index} = State) when
    is_map_key(ThreadId, Index)
->
    mark_dirty([ThreadId], State#{thread_list_refresh => true});
member_lists_changed(_ThreadId, State) ->
    State.

-spec presence_changed(integer(), guild_state()) -> guild_state().
presence_changed(UserId, #{thread_presence_users := Users} = State) ->
    mark_dirty(maps:get(UserId, Users, []), State);
presence_changed(_UserId, State) ->
    State.

-spec member_changed(integer(), guild_state()) -> guild_state().
member_changed(UserId, State) ->
    presence_changed(UserId, State).

-spec mark_dirty([integer()], guild_state()) -> guild_state().
mark_dirty([], State) ->
    State;
mark_dirty(ThreadIds, State) ->
    Dirty = maps:get(thread_list_dirty, State, #{}),
    arm_list_flush(State#{
        thread_list_dirty => maps:merge(Dirty, maps:from_keys(ThreadIds, true))
    }).

-spec arm_list_flush(guild_state()) -> guild_state().
arm_list_flush(#{thread_list_flush := true} = State) ->
    State;
arm_list_flush(State) ->
    _ = erlang:send_after(?LIST_FLUSH_MS, self(), thread_member_list_flush),
    State#{thread_list_flush => true}.

-spec handle_list_flush(guild_state()) -> guild_state().
handle_list_flush(State0) ->
    case guild_thread_load:loading(State0) of
        true -> maps:remove(thread_list_flush, State0);
        false -> flush_member_lists(State0)
    end.

-spec flush_member_lists(guild_state()) -> guild_state().
flush_member_lists(State0) ->
    Dirty = maps:keys(maps:get(thread_list_dirty, State0, #{})),
    State = refresh_presence_users(
        maps:is_key(thread_list_refresh, State0) orelse stale_list_sessions(Dirty, State0),
        maps:without([thread_list_dirty, thread_list_flush, thread_list_refresh], State0)
    ),
    ok = send_member_lists(Dirty, State),
    State.

-spec stale_list_sessions([integer()], guild_state()) -> boolean().
stale_list_sessions(ThreadIds, State) ->
    Index = maps:get(thread_list_sessions, State, #{}),
    Sessions = maps:get(sessions, State, #{}),
    lists:any(
        fun(ThreadId) -> stale_thread_sessions(ThreadId, Index, Sessions) end,
        ThreadIds
    ).

-spec stale_thread_sessions(integer(), #{integer() => [binary()]}, map()) -> boolean().
stale_thread_sessions(ThreadId, Index, Sessions) ->
    lists:any(
        fun(Sid) -> not lists_thread(ThreadId, maps:get(Sid, Sessions, undefined)) end,
        maps:get(ThreadId, Index, [])
    ).

-spec lists_thread(integer(), term()) -> boolean().
lists_thread(ThreadId, #{thread_member_lists := Lists}) ->
    lists:member(ThreadId, eqwalizer:dynamic_cast(Lists));
lists_thread(_ThreadId, _Session) ->
    false.

-spec refresh_presence_users(guild_state()) -> guild_state().
refresh_presence_users(State) ->
    refresh_presence_users(true, State).

-spec refresh_presence_users(boolean(), guild_state()) -> guild_state().
refresh_presence_users(false, State) ->
    State;
refresh_presence_users(true, State) ->
    ThreadIds = lists:usort(
        lists:append([
            Lists
         || #{thread_member_lists := Lists} <- maps:values(maps:get(sessions, State, #{}))
        ])
    ),
    case {ThreadIds, guild_thread_gate:store(State)} of
        {[_ | _], Tab} when Tab =/= undefined ->
            State#{
                thread_presence_users => presence_users(ThreadIds, Tab),
                thread_list_sessions => list_sessions(maps:get(sessions, State, #{}))
            };
        _ ->
            maps:without([thread_presence_users, thread_list_sessions], State)
    end.

-spec list_sessions(map()) -> #{integer() => [binary()]}.
list_sessions(Sessions) ->
    maps:fold(
        fun
            (SessionId, #{thread_member_lists := Lists}, Acc) ->
                index_session(SessionId, Lists, Acc);
            (_SessionId, _Session, Acc) ->
                Acc
        end,
        #{},
        Sessions
    ).

-spec index_session(binary(), [integer()], #{integer() => [binary()]}) ->
    #{integer() => [binary()]}.
index_session(SessionId, Lists, Index) ->
    lists:foldl(
        fun(ThreadId, Acc) -> Acc#{ThreadId => [SessionId | maps:get(ThreadId, Acc, [])]} end,
        Index,
        Lists
    ).

-spec presence_users([integer()], ets:table()) -> #{integer() => [integer()]}.
presence_users(ThreadIds, Tab) ->
    lists:foldl(
        fun(ThreadId, Acc) -> add_thread_presence(ThreadId, Tab, Acc) end, #{}, ThreadIds
    ).

-spec add_thread_presence(integer(), ets:table(), #{integer() => [integer()]}) ->
    #{integer() => [integer()]}.
add_thread_presence(ThreadId, Tab, Users) ->
    lists:foldl(
        fun(UserId, Acc) -> add_presence_user(ThreadId, UserId, Acc) end,
        Users,
        lists:sublist(guild_thread_store:member_ids(Tab, ThreadId), ?MAX_LIST_MEMBERS)
    ).

-spec add_presence_user(integer(), integer(), #{integer() => [integer()]}) ->
    #{integer() => [integer()]}.
add_presence_user(ThreadId, UserId, Users) ->
    case maps:find(UserId, Users) of
        {ok, Threads} ->
            Users#{UserId => [ThreadId | Threads]};
        error when map_size(Users) < ?MAX_PRESENCE_USERS ->
            Users#{UserId => [ThreadId]};
        error ->
            Users
    end.

-spec send_member_lists([integer()], guild_state()) -> ok.
send_member_lists([], _State) ->
    ok;
send_member_lists(ThreadIds, #{id := GuildId} = State) ->
    Index = maps:get(thread_list_sessions, State, #{}),
    Sessions = maps:get(sessions, State, #{}),
    Ctx = guild_member_list_connected:presence_context(State),
    lists:foreach(
        fun(ThreadId) ->
            Pids = list_pids(ThreadId, maps:get(ThreadId, Index, []), Sessions, State),
            send_thread_member_list(Pids, GuildId, ThreadId, Ctx, State)
        end,
        ThreadIds
    );
send_member_lists(_ThreadIds, _State) ->
    ok.

-spec send_thread_member_list([pid()], integer(), integer(), map(), guild_state()) -> ok.
send_thread_member_list([], _GuildId, _ThreadId, _Ctx, _State) ->
    ok;
send_thread_member_list(Pids, GuildId, ThreadId, Ctx, State) ->
    gateway_dispatch_relay:dispatch_many(
        Pids,
        thread_member_list_update,
        member_list_payload(GuildId, ThreadId, Ctx, State),
        GuildId
    ).

-spec list_pids(integer(), [binary()], map(), guild_state()) -> [pid()].
list_pids(ThreadId, SessionIds, Sessions, State) ->
    case guild_thread_gate:thread(ThreadId, State) of
        undefined ->
            [];
        Thread ->
            viewer_pids(ThreadId, Thread, SessionIds, Sessions, State)
    end.

-spec viewer_pids(integer(), map(), [binary()], map(), guild_state()) -> [pid()].
viewer_pids(ThreadId, Thread, SessionIds, Sessions, State) ->
    {Pids, _Memo} = lists:foldl(
        fun(Sid, {Acc, Memo}) ->
            list_pid(ThreadId, Thread, maps:get(Sid, Sessions, undefined), State, Acc, Memo)
        end,
        {[], #{}},
        SessionIds
    ),
    Pids.

-spec list_pid(integer(), map(), term(), guild_state(), [pid()], map()) -> {[pid()], map()}.
list_pid(
    ThreadId,
    Thread,
    #{pid := Pid, thread_viewer := true, thread_member_lists := Lists} = Session,
    State,
    Acc,
    Memo
) when is_pid(Pid) ->
    case lists:member(ThreadId, eqwalizer:dynamic_cast(Lists)) of
        true -> add_viewer_pid(Pid, Session, Thread, State, Acc, Memo);
        false -> {Acc, Memo}
    end;
list_pid(_ThreadId, _Thread, _Session, _State, Acc, Memo) ->
    {Acc, Memo}.

-spec add_viewer_pid(pid(), map(), map(), guild_state(), [pid()], map()) -> {[pid()], map()}.
add_viewer_pid(Pid, Session, Thread, State, Acc, Memo) ->
    case guild_thread_gate:thread_view_access(Session, Thread, State, Memo) of
        {true, Memo1} -> {[Pid | Acc], Memo1};
        {false, Memo1} -> {Acc, Memo1}
    end.

-spec send_member_list(map(), integer(), guild_state()) -> ok.
send_member_list(#{pid := Pid, thread_viewer := true}, ThreadId, #{id := GuildId} = State) when
    is_pid(Pid)
->
    Ctx = guild_member_list_connected:presence_context(State),
    gateway_dispatch_relay:dispatch(
        Pid,
        thread_member_list_update,
        member_list_payload(GuildId, ThreadId, Ctx, State),
        GuildId
    );
send_member_list(_Session, _ThreadId, _State) ->
    ok.

-spec member_list_payload(integer(), integer(), map(), guild_state()) -> map().
member_list_payload(GuildId, ThreadId, Ctx, State) ->
    Members =
        case guild_thread_gate:store(State) of
            undefined -> [];
            Tab -> lists:sublist(guild_thread_store:members(Tab, ThreadId), ?MAX_LIST_MEMBERS)
        end,
    #{
        <<"guild_id">> => integer_to_binary(GuildId),
        <<"thread_id">> => integer_to_binary(ThreadId),
        <<"members">> => [list_member(UserId, M, Ctx, State) || {UserId, M} <- Members]
    }.

-spec list_member(integer(), map(), map(), guild_state()) -> map().
list_member(UserId, ThreadMember, Ctx, State) ->
    #{<<"presence">> := Presence} = guild_member_list_connected:add_presence_to_member(
        #{}, UserId, Ctx
    ),
    GuildMember =
        case guild_permissions_check:find_member_by_user_id(UserId, State) of
            undefined -> null;
            M -> M
        end,
    #{
        <<"user_id">> => integer_to_binary(UserId),
        <<"join_timestamp">> => maps:get(<<"join_timestamp">>, ThreadMember, null),
        <<"flags">> => maps:get(<<"flags">>, ThreadMember, 0),
        <<"member">> => GuildMember,
        <<"presence">> => Presence
    }.

-spec count(full | access) -> ok.
count(Reason) ->
    guild_thread_store:add_counter(?COUNTS_KEY, reason_index(Reason), 1).

-spec init_counters() -> ok.
init_counters() ->
    guild_thread_store:ensure_counter(?COUNTS_KEY, 2).

-spec reason_index(full | access) -> 1 | 2.
reason_index(full) -> 1;
reason_index(access) -> 2.

-spec list_sync_counts() -> #{full | access => non_neg_integer()}.
list_sync_counts() ->
    case persistent_term:get(?COUNTS_KEY, undefined) of
        undefined -> #{};
        Counters -> #{R => counters:get(Counters, reason_index(R)) || R <- [full, access]}
    end.