Skip to content

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

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

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

-export([
    normalize_guild_ids/1,
    replay_buffer_bytes/1,
    normalize_seq/1,
    normalize_active_guilds/1,
    build_ignored_events_map/1,
    load_relationships/1,
    build_state/1,
    schedule_timers/1
]).

-export_type([guild_id/0, session_state/0]).

-type guild_id() :: session:guild_id().
-type session_state() :: session:session_state().
-type seq() :: session:seq().
-type core_inputs() :: #{
    bot := boolean(),
    is_staff := boolean(),
    ready := map() | undefined,
    buffer := [map()],
    seq := seq(),
    ack_seq := seq(),
    socket_pid := pid(),
    guild_ids := [guild_id()]
}.

-spec normalize_guild_ids(term()) -> [guild_id()].
normalize_guild_ids(Value) when is_list(Value) ->
    lists:filtermap(
        fun
            (GuildId) when is_integer(GuildId), GuildId > 0 ->
                {true, GuildId};
            (_) ->
                false
        end,
        Value
    );
normalize_guild_ids(Value) when is_map(Value) -> normalize_guild_ids(maps:keys(Value));
normalize_guild_ids(_) ->
    [].

-spec normalize_active_guilds(term()) -> sets:set(guild_id()).
normalize_active_guilds(Value) ->
    sets:from_list(normalize_guild_ids(active_guild_source(Value))).

-spec active_guild_source(term()) -> term().
active_guild_source(Value) ->
    try sets:to_list(eqwalizer:dynamic_cast(Value)) of
        List when is_list(List) -> List
    catch
        _:_ -> active_guild_source_fallback(Value)
    end.

-spec active_guild_source_fallback(term()) -> term().
active_guild_source_fallback(Value) when is_map(Value) ->
    maps:keys(Value);
active_guild_source_fallback(Value) ->
    Value.

-spec normalize_seq(term()) -> session:seq().
normalize_seq(Value) when is_integer(Value), Value >= 0 -> Value;
normalize_seq(_) -> 0.

-spec normalize_buffer(term()) -> [map()].
normalize_buffer(Buffer) when is_list(Buffer) ->
    lists:filtermap(fun normalize_buffer_event/1, Buffer);
normalize_buffer(Buffer) when is_map(Buffer) ->
    lists:filtermap(fun normalize_buffer_event/1, deque_to_list(Buffer));
normalize_buffer(_) ->
    [].

-spec deque_to_list(map()) -> [term()].
deque_to_list(Buffer) ->
    try limited_deque:to_list(eqwalizer:dynamic_cast(Buffer)) of
        List -> List
    catch
        error:_Reason -> [];
        exit:_Reason -> []
    end.

-spec normalize_buffer_event(term()) -> {true, map()} | false.
normalize_buffer_event(Event) when is_map(Event) ->
    case maps:get(seq, Event, -1) of
        Seq when is_integer(Seq), Seq >= 0 -> {true, Event};
        _ -> false
    end;
normalize_buffer_event(_) ->
    false.

-spec init_buffer_bytes(term(), [map()]) -> non_neg_integer().
init_buffer_bytes(_Raw, []) ->
    0;
init_buffer_bytes(Raw, Buffer) when is_map(Raw) ->
    restored_deque_bytes(Raw, Buffer);
init_buffer_bytes(_Raw, Buffer) ->
    replay_buffer_bytes(Buffer).

-spec restored_deque_bytes(map(), [map()]) -> non_neg_integer().
restored_deque_bytes(Raw, Buffer) ->
    try limited_deque:bytes(eqwalizer:dynamic_cast(Raw)) of
        Bytes when is_integer(Bytes), Bytes >= 0 -> Bytes;
        _ -> replay_buffer_bytes(Buffer)
    catch
        error:_Reason -> replay_buffer_bytes(Buffer);
        exit:_Reason -> replay_buffer_bytes(Buffer)
    end.

-spec replay_buffer_bytes([map()]) -> non_neg_integer().
replay_buffer_bytes(Buffer) ->
    WordSize = erlang:system_info(wordsize),
    lists:foldl(
        fun(Event, Acc) -> trunc(Acc + erts_debug:flat_size(Event) * WordSize) end,
        0,
        Buffer
    ).

-spec replay_payload_bytes([map()]) -> non_neg_integer().
replay_payload_bytes(Buffer) ->
    lists:foldl(
        fun(Event, Acc) -> trunc(Acc + session_replay_buffer:entry_payload_bytes(Event)) end,
        0,
        Buffer
    ).

-spec build_ignored_events_map(term()) -> #{binary() => true}.
build_ignored_events_map(Events) when is_list(Events) ->
    maps:from_list([{Event, true} || Event <- Events, is_binary(Event)]);
build_ignored_events_map(_) ->
    #{}.

-spec load_private_channels(map() | undefined) -> #{session:channel_id() => map()}.
load_private_channels(Ready) when is_map(Ready) ->
    maps:from_list([
        {ChannelId, C}
     || C <- maps:get(<<"private_channels">>, Ready, []),
        ChannelId <- [type_conv:extract_id(C, <<"id">>)],
        ChannelId =/= undefined
    ]);
load_private_channels(_) ->
    #{}.

-spec load_relationships(map() | undefined) -> #{session:user_id() => integer()}.
load_relationships(Ready) when is_map(Ready) ->
    maps:from_list([
        {UserId, Type}
     || R <- maps:get(<<"relationships">>, Ready, []),
        UserId <- [type_conv:extract_id(R, <<"id">>)],
        Type <- [maps:get(<<"type">>, R, undefined)],
        UserId =/= undefined,
        is_integer(Type)
    ]);
load_relationships(_) ->
    #{}.

-spec build_state(map()) -> session_state().
build_state(SessionData) ->
    BuildStartedAt = gateway_timings:start(),
    GwTimings0 = maps:get(gw_timings, SessionData, gateway_timings:new()),
    BaseState0 = extract_fields(SessionData),
    VoiceQueueState = session_voice:init_voice_queue(),
    BaseState = maps:merge(BaseState0, VoiceQueueState),
    GwTimings = gateway_timings:record_function(
        session_init_build_state,
        <<"session_init:build_state/1">>,
        BuildStartedAt,
        GwTimings0
    ),
    gateway_timings:put_state(GwTimings, BaseState).

-spec extract_fields(map()) -> session_state().
extract_fields(#{socket_pid := SocketPid} = D) ->
    Bot = maps:get(bot, D, false),
    Ready = init_ready(Bot, maps:get(ready, D)),
    Buffer = normalize_buffer(maps:get(buffer, D, [])),
    Seq = normalize_seq(maps:get(seq, D, 0)),
    AckSeq = init_ack_seq(normalize_seq(maps:get(ack_seq, D, 0)), Seq),
    GuildIds = normalize_guild_ids(maps:get(guilds, D, [])),
    IsStaff = extract_is_staff(maps:get(user_data, D, #{})),
    Core = extract_core_fields(D, #{
        bot => Bot,
        is_staff => IsStaff,
        ready => Ready,
        buffer => Buffer,
        seq => Seq,
        ack_seq => AckSeq,
        socket_pid => SocketPid,
        guild_ids => GuildIds
    }),
    Extra = extract_extra_fields(D, Ready),
    maps:merge(maps:merge(Core, Extra), session_visits:init_fields(D)).

-spec extract_core_fields(map(), core_inputs()) -> session_state().
extract_core_fields(
    #{
        id := Id,
        user_id := UserId,
        user_data := UserData,
        version := Version,
        token_hash := TokenHash,
        auth_session_id_hash := AuthSessionIdHash,
        properties := Properties,
        status := Status
    } = D,
    #{
        bot := Bot,
        is_staff := IsStaff,
        ready := Ready,
        buffer := Buffer,
        seq := Seq,
        ack_seq := AckSeq,
        socket_pid := SocketPid,
        guild_ids := GuildIds
    }
) ->
    #{
        id => Id,
        user_id => UserId,
        user_data => UserData,
        custom_status => maps:get(custom_status, D, null),
        settings_invisible => maps:get(settings_invisible, D, false),
        version => Version,
        token_hash => TokenHash,
        auth_session_id_hash => AuthSessionIdHash,
        buffer => Buffer,
        buffer_bytes => init_buffer_bytes(maps:get(buffer, D, []), Buffer),
        replay_payload_bytes => replay_payload_bytes(Buffer),
        seq => Seq,
        ack_seq => AckSeq,
        replay_floor => init_replay_floor(normalize_seq(maps:get(replay_floor, D, 0)), Seq),
        properties => Properties,
        status => Status,
        resume_status => maps:get(resume_status, D, Status),
        afk => maps:get(afk, D, false),
        mobile => maps:get(mobile, D, false),
        presence_pid => undefined,
        presence_mref => undefined,
        socket_pid => SocketPid,
        socket_mref => monitor(process, SocketPid),
        resume_timer => undefined,
        offline_timer => undefined,
        guilds => maps:from_list([{Gid, undefined} || Gid <- GuildIds]),
        calls => #{},
        channels => maps:get(channels, D, load_private_channels(Ready)),
        ready => Ready,
        gw_timings => maps:get(gw_timings, D, gateway_timings:new()),
        bot => Bot,
        shard => maps:get(shard, D, undefined),
        is_staff => IsStaff,
        e2ee_capable => maps:get(e2ee_capable, D, false),
        geoip_country_code => maps:get(geoip_country_code, D, undefined)
    }.

-spec extract_extra_fields(map(), map() | undefined) -> map().
extract_extra_fields(D, Ready) ->
    #{
        ignored_events => build_ignored_events_map(maps:get(ignored_events, D, [])),
        initial_guild_id => maps:get(initial_guild_id, D, undefined),
        active_guilds => initial_active_guilds(D),
        collected_guild_states => maps:get(collected_guild_states, D, []),
        collected_sessions => maps:get(collected_sessions, D, []),
        collected_presences => maps:get(collected_presences, D, []),
        guild_subscription_state => maps:get(guild_subscription_state, D, #{}),
        guild_health => maps:get(guild_health, D, #{}),
        relationships => maps:get(relationships, D, load_relationships(Ready)),
        suppress_presence_updates => true,
        pending_presences => [],
        guild_connect_inflight => #{},
        guild_connect_workers => #{},
        guild_connect_timers => #{},
        debounce_reactions => maps:get(debounce_reactions, D, false),
        thread_channels_capable => maps:get(thread_channels_capable, D, false),
        reaction_buffer => [],
        reaction_buffer_timer => undefined
    }.

-spec initial_active_guilds(map()) -> sets:set(guild_id()).
initial_active_guilds(D) ->
    Explicit = normalize_active_guilds(maps:get(active_guilds, D, [])),
    FromSubscriptions = active_guilds_from_subscription_state(
        maps:get(guild_subscription_state, D, #{})
    ),
    sets:union(Explicit, FromSubscriptions).

-spec active_guilds_from_subscription_state(term()) -> sets:set(guild_id()).
active_guilds_from_subscription_state(Subscriptions) when is_map(Subscriptions) ->
    maps:fold(fun active_guild_from_subscription/3, sets:new(), Subscriptions);
active_guilds_from_subscription_state(_) ->
    sets:new().

-spec active_guild_from_subscription(term(), term(), sets:set(guild_id())) ->
    sets:set(guild_id()).
active_guild_from_subscription(GuildId, #{<<"active">> := true}, Acc) ->
    case snowflake_id:parse_optional(GuildId) of
        Id when is_integer(Id), Id > 0 -> sets:add_element(Id, Acc);
        _ -> Acc
    end;
active_guild_from_subscription(_GuildId, _GuildSubData, Acc) ->
    Acc.

-spec extract_is_staff(map()) -> boolean().
extract_is_staff(UserData) when is_map(UserData) ->
    guild_availability_check:is_user_staff_from_user_data(UserData);
extract_is_staff(_) ->
    false.

-spec init_ready(boolean(), map() | undefined) -> map() | undefined.
init_ready(true, Ready) when is_map(Ready) -> Ready;
init_ready(true, _Ready) -> undefined;
init_ready(false, Ready) -> Ready.

-spec init_ack_seq(seq(), seq()) -> seq().
init_ack_seq(AckSeq, Seq) when AckSeq =< Seq -> AckSeq;
init_ack_seq(_AckSeq, Seq) -> Seq.

-spec init_replay_floor(seq(), seq()) -> seq().
init_replay_floor(Floor, Seq) when Floor =< Seq -> Floor;
init_replay_floor(_Floor, Seq) -> Seq.

-spec schedule_timers(session_state()) -> ok.
schedule_timers(#{bot := Bot, guilds := GuildsMap}) ->
    GuildIds = maps:keys(GuildsMap),
    self() ! {presence_connect, 0},
    init_bot_ready_signal(Bot),
    init_prewarm_guilds(Bot, GuildIds),
    lists:foreach(fun(Gid) -> self() ! {guild_connect, Gid, 0} end, GuildIds),
    erlang:send_after(5000, self(), premature_readiness),
    erlang:send_after(10000, self(), enable_presence_updates),
    erlang:send_after(60000, self(), check_ack_lag),
    ok.

-spec init_bot_ready_signal(boolean()) -> ok.
init_bot_ready_signal(true) ->
    self() ! bot_initial_ready,
    ok;
init_bot_ready_signal(false) ->
    ok.

-spec init_prewarm_guilds(boolean(), [guild_id()]) -> ok.
init_prewarm_guilds(true, GuildIds) ->
    spawn(fun() -> safe_prewarm_guild_pid_cache(GuildIds) end),
    ok;
init_prewarm_guilds(false, GuildIds) ->
    prewarm_guild_pid_cache(GuildIds).

-spec safe_prewarm_guild_pid_cache([guild_id()]) -> ok.
safe_prewarm_guild_pid_cache(GuildIds) ->
    try
        prewarm_guild_pid_cache(GuildIds)
    catch
        error:_Reason -> ok;
        exit:_Reason -> ok
    end.

-spec prewarm_guild_pid_cache([guild_id()]) -> ok.
prewarm_guild_pid_cache(GuildIds) ->
    ByNode = group_guilds_by_node(GuildIds),
    maps:foreach(fun prewarm_node_guilds/2, ByNode),
    ok.

-spec prewarm_node_guilds(atom(), [guild_id()]) -> ok.
prewarm_node_guilds(Node, Ids) ->
    try
        rpc:call(Node, gateway_rpc_guild, batch_lookup_guild_pids, [Ids], 3000)
    catch
        error:_Reason -> ok;
        exit:_Reason -> ok
    end,
    ok.

-spec group_guilds_by_node([guild_id()]) -> #{atom() => [guild_id()]}.
group_guilds_by_node(GuildIds) ->
    lists:foldl(fun group_guild_by_node/2, #{}, GuildIds).

-spec group_guild_by_node(guild_id(), #{atom() => [guild_id()]}) -> #{atom() => [guild_id()]}.
group_guild_by_node(GuildId, Acc) ->
    case resolve_guild_node(GuildId) of
        {ok, Node} -> add_guild_to_node(Node, GuildId, Acc);
        error -> Acc
    end.

-spec add_guild_to_node(atom(), guild_id(), #{atom() => [guild_id()]}) ->
    #{atom() => [guild_id()]}.
add_guild_to_node(Node, GuildId, Acc) ->
    Existing = maps:get(Node, Acc, []),
    Acc#{Node => [GuildId | Existing]}.

-spec resolve_guild_node(guild_id()) -> {ok, atom()} | error.
resolve_guild_node(GuildId) ->
    try gateway_node_router:owner_node_result(GuildId, guilds) of
        {ok, Node} when is_atom(Node) -> {ok, Node};
        _ -> error
    catch
        error:_Reason -> error;
        exit:_Reason -> error
    end.