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_counts_cache_query).
-typing([eqwalizer]).
-include_lib("fluxer_gateway/include/timeout_config.hrl").
-export([
safe_owner_call/3,
safe_local_call/2,
safe_bulk_get/1,
ensure_started/0,
resolve_owner_node/1,
resolve_owner_node_safe/1,
resolve_owner_node_safe/2,
group_guild_ids_by_owner/1,
normalize_guild_ids/1,
split_local_remote_groups/1,
update_local/4,
delete_local/2,
get_local/2,
bulk_get_local/2,
bulk_get_local_groups/2,
handle_bulk_get_call/3,
local_snapshot/1
]).
-type guild_id() :: integer().
-type counts() :: {non_neg_integer(), non_neg_integer()}.
-export_type([guild_id/0, counts/0]).
-spec safe_local_call(term(), term()) -> term().
safe_local_call(Request, Fallback) ->
case ensure_started() of
ok -> do_safe_local_call(Request, Fallback);
error -> Fallback
end.
-spec do_safe_local_call(term(), term()) -> term().
do_safe_local_call(Request, Fallback) ->
try
gen_server:call(guild_counts_cache, Request, ?DEFAULT_GEN_SERVER_TIMEOUT)
catch
exit:_ -> Fallback
end.
-spec safe_owner_call(guild_id(), term(), term()) -> term().
safe_owner_call(GuildId, Request, Fallback) ->
OwnerNode = resolve_owner_node(GuildId),
dispatch_owner_call(OwnerNode, Request, Fallback).
-spec dispatch_owner_call(node() | unavailable, term(), term()) -> term().
dispatch_owner_call(unavailable, _Request, Fallback) ->
Fallback;
dispatch_owner_call(OwnerNode, Request, Fallback) ->
case OwnerNode =:= node() of
true ->
local_call_if_enabled(Request, Fallback);
false ->
guild_counts_cache_remote:safe_remote_call(
OwnerNode, Request, Fallback, ?DEFAULT_GEN_SERVER_TIMEOUT
)
end.
-spec local_call_if_enabled(term(), term()) -> term().
local_call_if_enabled(Request, Fallback) ->
case fluxer_gateway_sup:role_enabled(guilds) of
true -> safe_local_call(Request, Fallback);
false -> Fallback
end.
-spec safe_bulk_get([guild_id()]) -> #{guild_id() => counts()}.
safe_bulk_get(GuildIds) ->
Groups = group_guild_ids_by_owner(GuildIds),
lists:foldl(
fun({OwnerNode, OwnerGuildIds}, AccMap) ->
Reply = fetch_bulk_group(OwnerNode, OwnerGuildIds),
merge_reply(Reply, AccMap)
end,
#{},
Groups
).
-spec fetch_bulk_group(node(), [guild_id()]) -> term().
fetch_bulk_group(OwnerNode, OwnerGuildIds) ->
Request = {bulk_get_local, OwnerGuildIds},
case OwnerNode =:= node() of
true ->
fetch_bulk_local(Request);
false ->
guild_counts_cache_remote:safe_remote_call(
OwnerNode, Request, #{}
)
end.
-spec fetch_bulk_local(term()) -> term().
fetch_bulk_local(Request) ->
case fluxer_gateway_sup:role_enabled(guilds) of
true -> safe_local_call(Request, #{});
false -> #{}
end.
-spec merge_reply(term(), #{guild_id() => counts()}) -> #{guild_id() => counts()}.
merge_reply(ReplyMap, AccMap) when is_map(ReplyMap) ->
maps:merge(AccMap, eqwalizer:dynamic_cast(ReplyMap));
merge_reply(_, AccMap) ->
AccMap.
-spec ensure_started() -> ok | error.
ensure_started() ->
case fluxer_gateway_sup:role_enabled(guilds) of
true -> ensure_started_with_role();
false -> error
end.
-spec ensure_started_with_role() -> ok | error.
ensure_started_with_role() ->
case whereis(guild_counts_cache) of
Pid when is_pid(Pid) -> ok;
undefined -> try_start_cache()
end.
-spec try_start_cache() -> ok | error.
try_start_cache() ->
case guild_counts_cache:start_link() of
{ok, _Pid} -> ok;
{error, _Reason} -> error
end.
-spec resolve_owner_node(guild_id()) -> node() | unavailable.
resolve_owner_node(GuildId) ->
clustered_ets_cache:resolve_owner_node(GuildId, guilds).
-spec resolve_owner_node_safe(guild_id()) -> node() | unavailable.
resolve_owner_node_safe(GuildId) ->
resolve_owner_node_safe(GuildId, fun resolve_owner_node/1).
-spec resolve_owner_node_safe(guild_id(), fun((guild_id()) -> term())) -> node() | unavailable.
resolve_owner_node_safe(GuildId, ResolveOwnerNodeFun) ->
try ResolveOwnerNodeFun(GuildId) of
unavailable -> unavailable;
OwnerNode when is_atom(OwnerNode) -> OwnerNode;
_ -> unavailable
catch
_:_ -> unavailable
end.
-spec group_guild_ids_by_owner([guild_id()]) -> [{node(), [guild_id()]}].
group_guild_ids_by_owner(GuildIds) ->
normalize_owner_groups(
clustered_ets_cache:group_keys_by_owner(normalize_guild_ids(GuildIds), guilds)
).
-spec normalize_owner_groups([{node(), [term()]}]) -> [{node(), [guild_id()]}].
normalize_owner_groups(Groups) ->
[
{OwnerNode, normalize_guild_ids(OwnerGuildIds)}
|| {OwnerNode, OwnerGuildIds} <- Groups
].
-spec normalize_guild_ids([term()]) -> [guild_id()].
normalize_guild_ids(GuildIds) ->
lists:usort([GuildId || GuildId <- GuildIds, is_integer(GuildId), GuildId > 0]).
-spec split_local_remote_groups([{node(), [guild_id()]}]) ->
{[{node(), [guild_id()]}], [{node(), [guild_id()]}]}.
split_local_remote_groups(OwnerGroups) ->
lists:partition(
fun({OwnerNode, _OwnerGuildIds}) -> OwnerNode =:= node() end,
OwnerGroups
).
-spec update_local(guild_id(), non_neg_integer(), non_neg_integer(), map()) -> {ok, map()}.
update_local(GuildId, MemberCount, OnlineCount, State) ->
{_Reply, NewState} = guild_counts_cache_shard_mgmt:forward_call(
GuildId, {update, GuildId, MemberCount, OnlineCount}, State
),
{ok, NewState}.
-spec delete_local(guild_id(), map()) -> {ok, map()}.
delete_local(GuildId, State) ->
{_Reply, NewState} = guild_counts_cache_shard_mgmt:forward_call(
GuildId, {delete, GuildId}, State
),
{ok, NewState}.
-spec get_local(guild_id(), map()) ->
{{ok, non_neg_integer(), non_neg_integer()} | miss, map()}.
get_local(GuildId, State) ->
{Reply, NewState} = guild_counts_cache_shard_mgmt:forward_call(
GuildId, {get, GuildId}, State
),
{guild_counts_cache_remote:normalize_get_reply(Reply), NewState}.
-spec handle_bulk_get_call([guild_id()], gen_server:from(), map()) ->
{reply, #{guild_id() => counts()}, map()} | {noreply, map()}.
handle_bulk_get_call(GuildIds, From, State) ->
OwnerGroups = group_guild_ids_by_owner(GuildIds),
{LocalGroups, RemoteGroups} = split_local_remote_groups(OwnerGroups),
{LocalMap, State1} = bulk_get_local_groups(LocalGroups, State),
case RemoteGroups of
[] ->
{reply, LocalMap, State1};
_ ->
guild_counts_cache_remote:start_remote_bulk_get_reply(From, LocalMap, RemoteGroups),
{noreply, State1}
end.
-spec bulk_get_local_groups([{node(), [guild_id()]}], map()) ->
{#{guild_id() => counts()}, map()}.
bulk_get_local_groups(LocalGroups, State) ->
lists:foldl(
fun({_OwnerNode, OwnerGuildIds}, {AccMap, AccState}) ->
{LocalMap, State1} = bulk_get_local(OwnerGuildIds, AccState),
{maps:merge(AccMap, LocalMap), State1}
end,
{#{}, State},
LocalGroups
).
-spec bulk_get_local([guild_id()], map()) -> {#{guild_id() => counts()}, map()}.
bulk_get_local(GuildIds, State) ->
Count = maps:get(shard_count, State),
UniqueGuildIds = normalize_guild_ids(GuildIds),
Groups = rendezvous_router:group_keys(UniqueGuildIds, Count),
lists:foldl(
fun({Index, Ids}, {AccMap, AccState}) ->
{SafeIdx, State1} = guild_counts_cache_shard_mgmt:ensure_shard_for_index(
Index, AccState
),
{Reply, State2} = guild_counts_cache_shard_mgmt:call_shard(
SafeIdx, {bulk_get, Ids}, State1
),
merge_bulk_reply(Reply, AccMap, State2)
end,
{#{}, State},
Groups
).
-spec merge_bulk_reply(term(), #{guild_id() => counts()}, map()) ->
{#{guild_id() => counts()}, map()}.
merge_bulk_reply(ReplyMap, AccMap, State) when is_map(ReplyMap) ->
{maps:merge(AccMap, eqwalizer:dynamic_cast(ReplyMap)), State};
merge_bulk_reply(_, AccMap, State) ->
{AccMap, State}.
-spec local_snapshot(map()) -> #{guild_id() => counts()}.
local_snapshot(State) ->
Count = maps:get(shard_count, State),
{SnapshotMap, _FinalState} = lists:foldl(
fun(Index, {AccMap, AccState}) ->
{SafeIdx, State1} = guild_counts_cache_shard_mgmt:ensure_shard_for_index(
Index, AccState
),
{Reply, State2} = guild_counts_cache_shard_mgmt:call_shard(
SafeIdx, snapshot, State1
),
merge_bulk_reply(Reply, AccMap, State2)
end,
{#{}, State},
lists:seq(0, Count - 1)
),
SnapshotMap.