A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
refactor(gateway): split voice server lookup, drop inline tests
Hampus7c15d6b2f851
diff --git a/fluxer_gateway/src/guild/voice/guild_voice_server.erl b/fluxer_gateway/src/guild/voice/guild_voice_server.erlindex 34124abec..aaf8afed9 100644--- a/fluxer_gateway/src/guild/voice/guild_voice_server.erl+++ b/fluxer_gateway/src/guild/voice/guild_voice_server.erl@@ -23,9 +23,6 @@-define(REGISTRY_TABLE, guild_voice_registry).-define(SWEEP_INTERVAL_MS, 10000).-define(MAX_PENDING_CONNECTIONS, 1000).--define(MAX_RECENT_DISCONNECTS, 500).--define(MAX_E2EE_KEYS, 1000).--define(RECENT_DISCONNECT_TTL_MS, 120000).-define(SEEDED_SESSION_CHECK_DELAY_MS, 60000).-define(SESSION_LOOKUP_TIMEOUT_MS, 5000).@@ -58,7 +55,7 @@ lookup(GuildId) ->[{_, Pid}] when is_pid(Pid) ->handle_registered_lookup(GuildId, Pid);_ ->- recover_from_guild(GuildId)+ guild_voice_server_lookup:recover(GuildId)end.-spec handle_registered_lookup(integer(), pid()) -> {ok, pid()} | {error, not_found}.@@ -68,16 +65,12 @@ handle_registered_lookup(GuildId, Pid) ->{ok, Pid};false ->ets:delete(?REGISTRY_TABLE, GuildId),- recover_from_guild(GuildId)+ guild_voice_server_lookup:recover(GuildId)end.-spec lookup_registered(integer()) -> {ok, pid()} | {error, not_found}.lookup_registered(GuildId) ->- Result = safe_lookup(fun() -> ets:lookup(?REGISTRY_TABLE, GuildId) end),- case Result of- [{_, Pid}] when is_pid(Pid) -> live_pid_result(Pid);- _ -> {error, not_found}- end.+ guild_voice_server_lookup:registered(GuildId).-spec resolve(integer() | undefined, pid()) -> pid().resolve(undefined, FallbackPid) ->@@ -96,14 +89,7 @@ resolve_result(GuildId, FallbackPid) ->{ok, VoicePid} ->{ok, VoicePid};{error, not_found} ->- resolve_after_lookup_miss(GuildId, FallbackPid)- end.---spec resolve_after_lookup_miss(integer(), pid()) -> {ok, pid()} | {error, not_found}.-resolve_after_lookup_miss(GuildId, FallbackPid) ->- case resolve_from_owner(GuildId) of- {ok, VoicePid} -> {ok, VoicePid};- {error, not_found} -> resolve_from_guild_pid(FallbackPid)+ guild_voice_server_lookup:after_miss(GuildId, FallbackPid)end.-spec is_voice_server_pid(pid()) -> boolean().@@ -186,7 +172,9 @@ voice_request_handler(_) ->-spec handle_call_local(term(), server_state()) -> {reply, term(), server_state()}.handle_call_local({store_pending_connection, ConnectionId, Metadata}, State) ->Pending = maps:get(pending_voice_connections, State, #{}),- NewPending = bounded_put(ConnectionId, Metadata, Pending, ?MAX_PENDING_CONNECTIONS),+ NewPending = guild_voice_server_caps:bounded_put(+ ConnectionId, Metadata, Pending, ?MAX_PENDING_CONNECTIONS+ ),{reply, ok, State#{pending_voice_connections => NewPending}};handle_call_local({get_voice_states_for_channel, ChIdBin}, State) ->{reply, channel_query(voice_states, ChIdBin, State), State};@@ -207,7 +195,9 @@ channel_query(voice_states, ChIdBin, State) ->-spec handle_cast(term(), server_state()) -> {noreply, server_state()}.handle_cast({store_pending_connection, ConnId, Meta}, State) ->Pending = maps:get(pending_voice_connections, State, #{}),- NewPending = bounded_put(ConnId, Meta, Pending, ?MAX_PENDING_CONNECTIONS),+ NewPending = guild_voice_server_caps:bounded_put(+ ConnId, Meta, Pending, ?MAX_PENDING_CONNECTIONS+ ),{noreply, State#{pending_voice_connections => NewPending}};handle_cast({disconnect_voice_user, Request}, State) when is_map(Request) ->{noreply,@@ -232,17 +222,16 @@ handle_cast(_, State) ->{noreply, server_state()} | {stop, normal, server_state()}.handle_info(sweep_pending_joins, State) ->erlang:send_after(?SWEEP_INTERVAL_MS, self(), sweep_pending_joins),- State1 = sweep_recently_disconnected(State),- State2 = sweep_e2ee_room_keys(State1),- case maps:size(maps:get(pending_voice_connections, State2, #{})) of+ Swept = guild_voice_server_caps:sweep(State),+ case maps:size(maps:get(pending_voice_connections, Swept, #{})) of0 ->- {noreply, State2};+ {noreply, Swept};_ ->- GuildState = guild_voice_server_state:build_guild_state(State2),+ GuildState = guild_voice_server_state:build_guild_state(Swept),NewGuildState = guild_voice_connection_pending:sweep_expired_pending_joins(GuildState),- {noreply, guild_voice_server_state:apply_guild_state(NewGuildState, State2)}+ {noreply, guild_voice_server_state:apply_guild_state(NewGuildState, Swept)}end;handle_info(check_p2p_sessions, State) ->erlang:send_after(?SEEDED_SESSION_CHECK_DELAY_MS, self(), check_p2p_sessions),@@ -251,13 +240,14 @@ handle_info(check_p2p_sessions, State) ->),{noreply, State};handle_info({check_seeded_sessions, Round, ConnectionIds}, State) ->- ok = spawn_seeded_session_check(Round, seeded_sessions(ConnectionIds, State), State),+ Sessions = seeded_sessions(eqwalizer:dynamic_cast(ConnectionIds), State),+ ok = spawn_seeded_session_check(eqwalizer:dynamic_cast(Round), Sessions, State),{noreply, State};handle_info({seeded_sessions_gone, first, Gone}, State) ->- ok = schedule_seeded_session_check(second, maps:keys(Gone)),+ ok = schedule_seeded_session_check(second, maps:keys(eqwalizer:dynamic_cast(Gone))),{noreply, State};handle_info({seeded_sessions_gone, second, Gone}, State) ->- {noreply, remove_gone_seeded_connections(Gone, State)};+ {noreply, remove_gone_seeded_connections(eqwalizer:dynamic_cast(Gone), State)};handle_info({'EXIT', Pid, Reason}, #{guild_pid := GuildPid} = State) when Pid =:= GuildPid ->logger:info("Voice server shutting down because guild process exited",@@ -286,20 +276,6 @@ code_change(_OldVsn, State, _Extra) ->erlang:garbage_collect(),{ok, State}.--spec safe_lookup(fun(() -> term())) -> term().-safe_lookup(Fun) ->- try- Fun()- catch- throw:_ -> {error, not_found};- error:_ -> {error, not_found};- exit:_ -> {error, not_found}- end.---spec safe_lookup_match(term()) -> {ok, pid()} | {error, not_found}.-safe_lookup_match({ok, Pid}) when is_pid(Pid) -> {ok, Pid};-safe_lookup_match(_) -> {error, not_found}.--spec schedule_seeded_session_check(first | second, [binary()]) -> ok.schedule_seeded_session_check(_Round, []) ->ok;@@ -344,19 +320,19 @@ spawn_seeded_session_check(_Round, Seeded, _State) when map_size(Seeded) =:= 0 -spawn_seeded_session_check(Round, Seeded, State) ->Self = self(),IsGone = session_gone_fun(State),- _ = spawn(fun() ->- SessionIds = lists:usort([SessionId || {_UserId, SessionId} <- maps:values(Seeded)]),- GoneSessions = [SessionId || SessionId <- SessionIds, IsGone(SessionId)],- Gone = maps:filter(- fun(_ConnectionId, {_UserId, SessionId}) ->- lists:member(SessionId, GoneSessions)- end,- Seeded- ),- Self ! {seeded_sessions_gone, Round, Gone}- end),+ _ = spawn(fun() -> Self ! {seeded_sessions_gone, Round, gone_seeded(Seeded, IsGone)} end),ok.+-spec gone_seeded(#{binary() => {integer(), binary()}}, fun((binary()) -> boolean())) ->+ #{binary() => {integer(), binary()}}.+gone_seeded(Seeded, IsGone) ->+ SessionIds = lists:usort([SessionId || {_UserId, SessionId} <- maps:values(Seeded)]),+ GoneSessions = [SessionId || SessionId <- SessionIds, IsGone(SessionId)],+ maps:filter(+ fun(_ConnectionId, {_UserId, SessionId}) -> lists:member(SessionId, GoneSessions) end,+ Seeded+ ).+-spec session_gone_fun(server_state()) -> fun((binary()) -> boolean()).session_gone_fun(State) ->case maps:get(test_session_gone_fun, State, undefined) of@@ -420,383 +396,3 @@ delegate_voice_call(Fun, Request, State) ->GS = guild_voice_server_state:build_guild_state(State),{reply, Reply, NewGS} = Fun(Request, GS),{reply, Reply, guild_voice_server_state:apply_guild_state(NewGS, State)}.---spec resolve_from_owner(integer()) -> {ok, pid()} | {error, not_found}.-resolve_from_owner(GuildId) ->- Result = safe_lookup(fun() -> gateway_node_router:owner_node_result(GuildId, guilds) end),- case Result of- {ok, Owner} when is_atom(Owner), Owner =/= node() ->- lookup_on_owner(Owner, GuildId);- _ ->- {error, not_found}- end.---spec lookup_on_owner(atom(), integer()) -> {ok, pid()} | {error, not_found}.-lookup_on_owner(Owner, GuildId) ->- Result = safe_lookup(fun() -> rpc:call(Owner, ?MODULE, lookup, [GuildId], 1000) end),- safe_lookup_match(Result).---spec resolve_from_guild_pid(pid()) -> {ok, pid()} | {error, not_found}.-resolve_from_guild_pid(FallbackPid) ->- Result = safe_lookup(fun() -> gen_server:call(FallbackPid, get_voice_server_pid, 500) end),- case Result of- {ok, VoicePid} when is_pid(VoicePid) -> live_pid_result(VoicePid);- _ -> {error, not_found}- end.---spec recover_from_guild(integer()) -> {ok, pid()} | {error, not_found}.-recover_from_guild(GuildId) ->- Result = safe_lookup(fun() -> ets:lookup(guild_pid_cache, GuildId) end),- case Result of- [{_, GuildPid}] when is_pid(GuildPid) ->- ask_live_guild_for_voice_pid(GuildId, GuildPid);- _ ->- {error, not_found}- end.---spec ask_live_guild_for_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.-ask_live_guild_for_voice_pid(GuildId, GuildPid) ->- case process_liveness:is_alive(GuildPid) of- true -> ask_guild_for_voice_pid(GuildId, GuildPid);- false -> {error, not_found}- end.---spec ask_guild_for_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.-ask_guild_for_voice_pid(GuildId, GuildPid) ->- Result = safe_lookup(fun() -> gen_server:call(GuildPid, get_voice_server_pid, 500) end),- case Result of- {ok, VSP} when is_pid(VSP) ->- cache_live_voice_pid(GuildId, VSP);- _ ->- {error, not_found}- end.---spec live_pid_result(pid()) -> {ok, pid()} | {error, not_found}.-live_pid_result(Pid) ->- case process_liveness:is_alive(Pid) of- true -> {ok, Pid};- false -> {error, not_found}- end.---spec cache_live_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.-cache_live_voice_pid(GuildId, VoicePid) ->- case live_pid_result(VoicePid) of- {ok, VoicePid} ->- ets:insert(?REGISTRY_TABLE, {GuildId, VoicePid}),- {ok, VoicePid};- {error, not_found} ->- {error, not_found}- end.---spec bounded_put(term(), term(), map(), pos_integer()) -> map().-bounded_put(Key, Value, Map, MaxSize) ->- case maps:is_key(Key, Map) of- true ->- Map#{Key => Value};- false ->- bounded_put_new(Key, Value, Map, MaxSize)- end.---spec bounded_put_new(term(), term(), map(), pos_integer()) -> map().-bounded_put_new(Key, Value, Map, MaxSize) ->- case maps:size(Map) >= MaxSize of- true ->- logger:warning("Voice server bounded map at capacity", #{max_size => MaxSize}),- Map;- false ->- Map#{Key => Value}- end.---spec sweep_recently_disconnected(map()) -> map().-sweep_recently_disconnected(State) ->- Cache = maps:get(recently_disconnected_voice_states, State, #{}),- case maps:size(Cache) of- 0 ->- State;- _ ->- Capped = evict_stale_disconnects(Cache),- State#{recently_disconnected_voice_states => Capped}- end.---spec evict_stale_disconnects(map()) -> map().-evict_stale_disconnects(Cache) ->- Now = erlang:system_time(millisecond),- IsAlive = fun- (_ConnId, #{disconnected_at := At}) -> (Now - At) < ?RECENT_DISCONNECT_TTL_MS;- (_ConnId, _) -> false- end,- enforce_map_cap(maps:filter(IsAlive, Cache), ?MAX_RECENT_DISCONNECTS).---spec sweep_e2ee_room_keys(server_state()) -> server_state().-sweep_e2ee_room_keys(State) ->- Keys = maps:get(e2ee_room_keys, State, #{}),- case maps:size(Keys) of- 0 ->- State;- Size when Size =< ?MAX_E2EE_KEYS ->- State;- _ ->- State#{e2ee_room_keys => enforce_map_cap(Keys, ?MAX_E2EE_KEYS)}- end.---spec enforce_map_cap(map(), pos_integer()) -> map().-enforce_map_cap(Map, MaxSize) ->- case maps:size(Map) =< MaxSize of- true ->- Map;- false ->- {Keep, _} = lists:split(MaxSize, maps:to_list(Map)),- maps:from_list(Keep)- end.---ifdef(TEST).--include_lib("eunit/include/eunit.hrl").--seeded_sessions_only_tracks_states_with_a_session_test() ->- State = #{- voice_states => #{- <<"a">> => #{<<"user_id">> => <<"5">>, <<"session_id">> => <<"sess-a">>},- <<"b">> => #{<<"user_id">> => <<"6">>},- <<"c">> => #{<<"user_id">> => <<"7">>, <<"session_id">> => null}- }- },- ?assertEqual(- #{<<"a">> => {5, <<"sess-a">>}},- seeded_sessions([<<"a">>, <<"b">>, <<"c">>, <<"missing">>], State)- ).--seeded_session_check_reports_only_gone_sessions_test() ->- State = #{- voice_states => #{- <<"a">> => #{<<"user_id">> => <<"5">>, <<"session_id">> => <<"dead">>},- <<"b">> => #{<<"user_id">> => <<"6">>, <<"session_id">> => <<"alive">>}- },- test_session_gone_fun => fun(SessionId) -> SessionId =:= <<"dead">> end- },- ok = spawn_seeded_session_check(first, seeded_sessions([<<"a">>, <<"b">>], State), State),- receive- {seeded_sessions_gone, first, Gone} ->- ?assertEqual(#{<<"a">> => {5, <<"dead">>}}, Gone)- after 1000 -> ?assert(false)- end.--p2p_session_check_reports_only_gone_p2p_sessions_test() ->- State0 = seeded_test_state(self()),- #{<<"ghost">> := Ghost, <<"live">> := Live} = VoiceStates = maps:get(voice_states, State0),- State = State0#{- voice_states => VoiceStates#{- <<"ghost">> => Ghost#{<<"p2p">> => true},- <<"live">> => Live#{<<"p2p">> => true},- <<"sfu-ghost">> => Ghost#{<<"connection_id">> => <<"sfu-ghost">>}- },- test_session_gone_fun => fun(SessionId) -> SessionId =:= <<"dead">> end- },- {noreply, State} = handle_info(check_p2p_sessions, State),- receive- {seeded_sessions_gone, first, Gone} ->- ?assertEqual(#{<<"ghost">> => {5, <<"dead">>}}, Gone)- after 1000 -> ?assert(false)- end.--gone_seeded_connection_is_removed_test() ->- TestFun = fun(_, _, _, _) -> {ok, #{success => true}} end,- GuildPid = spawn(fun() -> guild_state_reply_loop(TestFun) end),- State = seeded_test_state(GuildPid),- try- {noreply, NewState} = handle_info(- {seeded_sessions_gone, second, #{<<"ghost">> => {5, <<"dead">>}}}, State- ),- ?assertEqual([<<"live">>], maps:keys(maps:get(voice_states, NewState)))- after- exit(GuildPid, kill)- end.--seeded_connection_that_changed_session_is_kept_test() ->- TestFun = fun(_, _, _, _) -> {ok, #{success => true}} end,- GuildPid = spawn(fun() -> guild_state_reply_loop(TestFun) end),- State = seeded_test_state(GuildPid),- try- {noreply, NewState} = handle_info(- {seeded_sessions_gone, second, #{<<"ghost">> => {5, <<"an-older-session">>}}}, State- ),- ?assertEqual(- lists:sort([<<"ghost">>, <<"live">>]),- lists:sort(maps:keys(maps:get(voice_states, NewState)))- )- after- exit(GuildPid, kill)- end.--seeded_test_state(GuildPid) ->- #{- guild_id => 42,- guild_pid => GuildPid,- voice_states => #{- <<"ghost">> => #{- <<"user_id">> => <<"5">>,- <<"guild_id">> => <<"42">>,- <<"channel_id">> => <<"20">>,- <<"connection_id">> => <<"ghost">>,- <<"session_id">> => <<"dead">>- },- <<"live">> => #{- <<"user_id">> => <<"6">>,- <<"guild_id">> => <<"42">>,- <<"channel_id">> => <<"20">>,- <<"connection_id">> => <<"live">>,- <<"session_id">> => <<"alive">>- }- },- pending_voice_connections => #{},- recently_disconnected_voice_states => #{},- e2ee_room_keys => #{}- }.--disconnect_voice_user_cast_removes_the_voice_state_test() ->- Self = self(),- TestFun = fun(GId, ChId, UId, ConnId) ->- Self ! {force_disconnect, GId, ChId, UId, ConnId},- {ok, #{success => true}}- end,- GuildPid = spawn(fun() -> guild_state_reply_loop(TestFun) end),- State = #{- guild_id => 42,- guild_pid => GuildPid,- voice_states => #{- <<"conn">> => #{- <<"user_id">> => <<"5">>,- <<"guild_id">> => <<"42">>,- <<"channel_id">> => <<"20">>,- <<"connection_id">> => <<"conn">>- }- },- pending_voice_connections => #{},- recently_disconnected_voice_states => #{},- e2ee_room_keys => #{}- },- try- {noreply, NewState} = handle_cast(- {disconnect_voice_user, #{user_id => 5, connection_id => null}}, State- ),- ?assertEqual(#{}, maps:get(voice_states, NewState)),- receive- {force_disconnect, 42, 20, 5, <<"conn">>} -> ok- after 200 -> ?assert(false)- end- after- exit(GuildPid, kill)- end.--guild_state_reply_loop(TestFun) ->- GuildState = #{- id => 42,- data => #{<<"guild">> => #{<<"owner_id">> => <<"999">>}},- sessions => #{},- test_force_disconnect_fun => TestFun- },- receive- {'$gen_call', From, {get_voice_guild_state}} ->- gen_server:reply(From, GuildState),- guild_state_reply_loop(TestFun);- _ ->- guild_state_reply_loop(TestFun)- end.--apply_guild_state_preserves_e2ee_test() ->- State = #{- guild_id => 1,- guild_pid => self(),- voice_states => #{},- pending_voice_connections => #{},- recently_disconnected_voice_states => #{},- e2ee_room_keys => #{10 => <<"old-key">>}- },- GuildState = State#{e2ee_room_keys => #{10 => <<"new-key">>}},- NewState = guild_voice_server_state:merge_guild_state(GuildState, State),- ?assertEqual(#{10 => <<"new-key">>}, maps:get(e2ee_room_keys, NewState)).--resolve_asks_fallback_test() ->- GuildId = 987654321,- VoicePid = spawn(fun voice_pid_loop/0),- GuildPid = spawn(fun() -> voice_pid_reply_loop(VoicePid) end),- try- ?assertEqual(VoicePid, resolve(GuildId, GuildPid))- after- VoicePid ! stop,- exit(GuildPid, kill)- end.--resolve_rejects_dead_voice_pid_test() ->- GuildId = 987654323,- DeadVoicePid = spawn(fun() -> ok end),- MonitorRef = erlang:monitor(process, DeadVoicePid),- receive- {'DOWN', MonitorRef, process, DeadVoicePid, _} -> ok- after 1000 -> error(timeout)- end,- GuildPid = spawn(fun() ->- voice_pid_reply_loop(DeadVoicePid)- end),- try- ?assertEqual({error, not_found}, resolve_result(GuildId, GuildPid)),- ?assertEqual(GuildPid, resolve(GuildId, GuildPid))- after- exit(GuildPid, kill)- end.--bounded_put_under_limit_test() ->- Map = #{a => 1, b => 2},- Result = bounded_put(c, 3, Map, 5),- ?assertEqual(#{a => 1, b => 2, c => 3}, Result).--bounded_put_at_limit_drops_test() ->- Map = #{a => 1, b => 2},- Result = bounded_put(c, 3, Map, 2),- ?assertEqual(#{a => 1, b => 2}, Result).--bounded_put_existing_key_updates_test() ->- Map = #{a => 1, b => 2},- Result = bounded_put(a, 99, Map, 2),- ?assertEqual(#{a => 99, b => 2}, Result).--enforce_map_cap_under_test() ->- Map = #{a => 1, b => 2},- ?assertEqual(Map, enforce_map_cap(Map, 5)).--enforce_map_cap_over_test() ->- Map = #{a => 1, b => 2, c => 3},- Result = enforce_map_cap(Map, 2),- ?assertEqual(2, maps:size(Result)).--sweep_recently_disconnected_empty_test() ->- State = #{recently_disconnected_voice_states => #{}},- ?assertEqual(State, sweep_recently_disconnected(State)).--sweep_recently_disconnected_evicts_old_test() ->- Now = erlang:system_time(millisecond),- Old = Now - ?RECENT_DISCONNECT_TTL_MS - 1000,- Cache = #{- <<"old-conn">> => #{disconnected_at => Old, voice_state => #{}},- <<"new-conn">> => #{disconnected_at => Now, voice_state => #{}}- },- State = #{recently_disconnected_voice_states => Cache},- Result = sweep_recently_disconnected(State),- RD = maps:get(recently_disconnected_voice_states, Result),- ?assertNot(maps:is_key(<<"old-conn">>, RD)),- ?assert(maps:is_key(<<"new-conn">>, RD)).--voice_pid_loop() ->- receive- stop -> ok- after 5000 ->- ok- end.--voice_pid_reply_loop(VoicePid) ->- receive- {'$gen_call', {From, Tag}, get_voice_server_pid} -> From ! {Tag, {ok, VoicePid}}- after 5000 ->- ok- end.---endif.diff --git a/fluxer_gateway/src/guild/voice/guild_voice_server_caps.erl b/fluxer_gateway/src/guild/voice/guild_voice_server_caps.erlnew file mode 100644index 000000000..5a52a4570--- /dev/null+++ b/fluxer_gateway/src/guild/voice/guild_voice_server_caps.erl@@ -0,0 +1,75 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_voice_server_caps).+-typing([eqwalizer]).++-export([bounded_put/4, sweep/1]).++-define(MAX_RECENT_DISCONNECTS, 500).+-define(MAX_E2EE_KEYS, 1000).+-define(RECENT_DISCONNECT_TTL_MS, 120000).++-spec bounded_put(term(), term(), map(), pos_integer()) -> map().+bounded_put(Key, Value, Map, MaxSize) ->+ case maps:is_key(Key, Map) of+ true ->+ Map#{Key => Value};+ false ->+ bounded_put_new(Key, Value, Map, MaxSize)+ end.++-spec bounded_put_new(term(), term(), map(), pos_integer()) -> map().+bounded_put_new(Key, Value, Map, MaxSize) ->+ case maps:size(Map) >= MaxSize of+ true ->+ logger:warning("Voice server bounded map at capacity", #{max_size => MaxSize}),+ Map;+ false ->+ Map#{Key => Value}+ end.++-spec sweep(map()) -> map().+sweep(State) ->+ sweep_e2ee_room_keys(sweep_recently_disconnected(State)).++-spec sweep_recently_disconnected(map()) -> map().+sweep_recently_disconnected(State) ->+ Cache = maps:get(recently_disconnected_voice_states, State, #{}),+ case maps:size(Cache) of+ 0 ->+ State;+ _ ->+ Capped = evict_stale_disconnects(Cache),+ State#{recently_disconnected_voice_states => Capped}+ end.++-spec evict_stale_disconnects(map()) -> map().+evict_stale_disconnects(Cache) ->+ Now = erlang:system_time(millisecond),+ IsAlive = fun+ (_ConnId, #{disconnected_at := At}) -> (Now - At) < ?RECENT_DISCONNECT_TTL_MS;+ (_ConnId, _) -> false+ end,+ enforce_map_cap(maps:filter(IsAlive, Cache), ?MAX_RECENT_DISCONNECTS).++-spec sweep_e2ee_room_keys(map()) -> map().+sweep_e2ee_room_keys(State) ->+ Keys = maps:get(e2ee_room_keys, State, #{}),+ case maps:size(Keys) of+ 0 ->+ State;+ Size when Size =< ?MAX_E2EE_KEYS ->+ State;+ _ ->+ State#{e2ee_room_keys => enforce_map_cap(Keys, ?MAX_E2EE_KEYS)}+ end.++-spec enforce_map_cap(map(), pos_integer()) -> map().+enforce_map_cap(Map, MaxSize) ->+ case maps:size(Map) =< MaxSize of+ true ->+ Map;+ false ->+ {Keep, _} = lists:split(MaxSize, maps:to_list(Map)),+ maps:from_list(Keep)+ end.diff --git a/fluxer_gateway/src/guild/voice/guild_voice_server_lookup.erl b/fluxer_gateway/src/guild/voice/guild_voice_server_lookup.erlnew file mode 100644index 000000000..2be96ebcf--- /dev/null+++ b/fluxer_gateway/src/guild/voice/guild_voice_server_lookup.erl@@ -0,0 +1,106 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_voice_server_lookup).+-typing([eqwalizer]).++-export([registered/1, recover/1, after_miss/2]).++-define(REGISTRY_TABLE, guild_voice_registry).++-spec registered(integer()) -> {ok, pid()} | {error, not_found}.+registered(GuildId) ->+ Result = safe_lookup(fun() -> ets:lookup(?REGISTRY_TABLE, GuildId) end),+ case Result of+ [{_, Pid}] when is_pid(Pid) -> live_pid_result(Pid);+ _ -> {error, not_found}+ end.++-spec after_miss(integer(), pid()) -> {ok, pid()} | {error, not_found}.+after_miss(GuildId, FallbackPid) ->+ case resolve_from_owner(GuildId) of+ {ok, VoicePid} -> {ok, VoicePid};+ {error, not_found} -> resolve_from_guild_pid(FallbackPid)+ end.++-spec safe_lookup(fun(() -> term())) -> term().+safe_lookup(Fun) ->+ try+ Fun()+ catch+ throw:_ -> {error, not_found};+ error:_ -> {error, not_found};+ exit:_ -> {error, not_found}+ end.++-spec safe_lookup_match(term()) -> {ok, pid()} | {error, not_found}.+safe_lookup_match({ok, Pid}) when is_pid(Pid) -> {ok, Pid};+safe_lookup_match(_) -> {error, not_found}.++-spec resolve_from_owner(integer()) -> {ok, pid()} | {error, not_found}.+resolve_from_owner(GuildId) ->+ Result = safe_lookup(fun() -> gateway_node_router:owner_node_result(GuildId, guilds) end),+ case Result of+ {ok, Owner} when is_atom(Owner), Owner =/= node() ->+ lookup_on_owner(Owner, GuildId);+ _ ->+ {error, not_found}+ end.++-spec lookup_on_owner(atom(), integer()) -> {ok, pid()} | {error, not_found}.+lookup_on_owner(Owner, GuildId) ->+ Result = safe_lookup(fun() ->+ rpc:call(Owner, guild_voice_server, lookup, [GuildId], 1000)+ end),+ safe_lookup_match(Result).++-spec resolve_from_guild_pid(pid()) -> {ok, pid()} | {error, not_found}.+resolve_from_guild_pid(FallbackPid) ->+ Result = safe_lookup(fun() -> gen_server:call(FallbackPid, get_voice_server_pid, 500) end),+ case Result of+ {ok, VoicePid} when is_pid(VoicePid) -> live_pid_result(VoicePid);+ _ -> {error, not_found}+ end.++-spec recover(integer()) -> {ok, pid()} | {error, not_found}.+recover(GuildId) ->+ Result = safe_lookup(fun() -> ets:lookup(guild_pid_cache, GuildId) end),+ case Result of+ [{_, GuildPid}] when is_pid(GuildPid) ->+ ask_live_guild_for_voice_pid(GuildId, GuildPid);+ _ ->+ {error, not_found}+ end.++-spec ask_live_guild_for_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.+ask_live_guild_for_voice_pid(GuildId, GuildPid) ->+ case process_liveness:is_alive(GuildPid) of+ true -> ask_guild_for_voice_pid(GuildId, GuildPid);+ false -> {error, not_found}+ end.++-spec ask_guild_for_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.+ask_guild_for_voice_pid(GuildId, GuildPid) ->+ Result = safe_lookup(fun() -> gen_server:call(GuildPid, get_voice_server_pid, 500) end),+ case Result of+ {ok, VSP} when is_pid(VSP) ->+ cache_live_voice_pid(GuildId, VSP);+ _ ->+ {error, not_found}+ end.++-spec live_pid_result(pid()) -> {ok, pid()} | {error, not_found}.+live_pid_result(Pid) ->+ case process_liveness:is_alive(Pid) of+ true -> {ok, Pid};+ false -> {error, not_found}+ end.++-spec cache_live_voice_pid(integer(), pid()) -> {ok, pid()} | {error, not_found}.+cache_live_voice_pid(GuildId, VoicePid) ->+ case live_pid_result(VoicePid) of+ {ok, VoicePid} ->+ ets:insert(?REGISTRY_TABLE, {GuildId, VoicePid}),+ {ok, VoicePid};+ {error, not_found} ->+ {error, not_found}+ end.