Skip to content

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

TypeScript fluxerfluxerapp

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.erl
index 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, #{})) of
0 ->
- {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.erl
new file mode 100644
index 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.erl
new file mode 100644
index 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.