Skip to content

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

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

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

-export([
    determine_shard_count/1,
    determine_shard_count/2,
    default_shard_count/0,
    select_shard/2,
    resolve_owner_node/2,
    resolve_owner_nodes/3,
    group_keys_by_owner/2
]).
-export_type([shard_source/0]).

-type shard_source() :: atom() | auto.

-define(OWNER_HASH_LIMIT, 16#FFFFFFFF).

-spec determine_shard_count([atom()]) -> {pos_integer(), shard_source()}.
determine_shard_count(ConfigKeys) when is_list(ConfigKeys) ->
    determine_shard_count(ConfigKeys, fun fluxer_gateway_env:get/1).

-spec determine_shard_count([atom()], fun((atom()) -> term())) ->
    {pos_integer(), shard_source()}.
determine_shard_count([], _GetConfigValue) ->
    {default_shard_count(), auto};
determine_shard_count([ConfigKey | Rest], GetConfigValue) ->
    case validate_shard_count(safe_config_value(ConfigKey, GetConfigValue)) of
        {ok, Count} ->
            {Count, ConfigKey};
        error ->
            determine_shard_count(Rest, GetConfigValue)
    end.

-spec safe_config_value(atom(), fun((atom()) -> term())) -> term().
safe_config_value(ConfigKey, GetConfigValue) ->
    try GetConfigValue(ConfigKey) of
        Value -> Value
    catch
        error:_Reason -> undefined;
        exit:_Reason -> undefined
    end.

-spec default_shard_count() -> pos_integer().
default_shard_count() ->
    erlang:system_info(schedulers_online).

-spec select_shard(term(), pos_integer()) -> non_neg_integer().
select_shard(Key, Count) when Count > 0 ->
    rendezvous_router:select(Key, Count).

-spec resolve_owner_node(term(), atom()) -> node() | unavailable.
resolve_owner_node(Key, Role) when is_atom(Role) ->
    owner_node_from_result(safe_owner_node_result(Key, Role)).

-spec owner_node_from_result({ok, node()} | unavailable) -> node() | unavailable.
owner_node_from_result({ok, OwnerNode}) ->
    OwnerNode;
owner_node_from_result(unavailable) ->
    unavailable.

-spec safe_owner_node_result(term(), atom() | fun((term()) -> term())) ->
    {ok, node()} | unavailable.
safe_owner_node_result(Key, Role) when is_atom(Role) ->
    safe_owner_node_result(
        Key,
        fun(OwnerKey) -> gateway_node_router:owner_node_result(OwnerKey, Role) end
    );
safe_owner_node_result(Key, OwnerResolver) ->
    try OwnerResolver(Key) of
        {ok, OwnerNode} when is_atom(OwnerNode) ->
            normalize_owner_node(OwnerNode);
        OwnerNode when is_atom(OwnerNode) ->
            normalize_owner_node(OwnerNode);
        {error, _Reason} ->
            unavailable;
        _ ->
            unavailable
    catch
        error:_Reason -> unavailable;
        exit:_Reason -> unavailable;
        throw:_Reason -> unavailable
    end.

-spec normalize_owner_node(atom()) -> {ok, node()} | unavailable.
normalize_owner_node(OwnerNode) when is_atom(OwnerNode) ->
    case lists:member($@, atom_to_list(OwnerNode)) of
        true -> {ok, OwnerNode};
        false -> unavailable
    end.

-spec resolve_owner_nodes(term(), pos_integer(), atom()) -> [node()].
resolve_owner_nodes(Key, ReplicaCount, Role) when is_integer(ReplicaCount), ReplicaCount > 0 ->
    case resolve_owner_node(Key, Role) of
        unavailable ->
            [];
        PrimaryNode when is_atom(PrimaryNode) ->
            CandidateNodes = resolve_candidate_nodes(PrimaryNode, Role),
            select_owner_nodes(Key, CandidateNodes, ReplicaCount)
    end.

-spec group_keys_by_owner([term()], atom() | fun((term()) -> term())) -> [{node(), [term()]}].
group_keys_by_owner(Keys, Role) when is_atom(Role) ->
    group_keys_by_owner(Keys, owner_node_result_resolver(Role));
group_keys_by_owner(Keys, OwnerResolver) ->
    UniqueKeys = lists:usort(Keys),
    GroupedMap = lists:foldl(
        fun(Key, Acc) ->
            add_owner_key(Key, OwnerResolver, Acc)
        end,
        #{},
        UniqueKeys
    ),
    lists:sort(
        maps:fold(
            fun(OwnerNode, OwnerKeys, Acc) ->
                [{OwnerNode, lists:reverse(OwnerKeys)} | Acc]
            end,
            [],
            GroupedMap
        )
    ).

-spec owner_node_result_resolver(atom()) -> fun((term()) -> term()).
owner_node_result_resolver(Role) ->
    fun(OwnerKey) -> gateway_node_router:owner_node_result(OwnerKey, Role) end.

-spec add_owner_key(term(), fun((term()) -> term()), #{node() => [term()]}) ->
    #{node() => [term()]}.
add_owner_key(Key, OwnerResolver, Acc) ->
    case safe_owner_node_result(Key, OwnerResolver) of
        {ok, OwnerNode} ->
            OwnerKeys = maps:get(OwnerNode, Acc, []),
            Acc#{OwnerNode => [Key | OwnerKeys]};
        unavailable ->
            Acc
    end.

-spec resolve_candidate_nodes(node(), atom() | undefined) -> [node()].
resolve_candidate_nodes(PrimaryNode, Role) ->
    ActiveNodes = [Node || Node <- safe_active_nodes_for_role(Role), is_atom(Node)],
    lists:usort([PrimaryNode | ActiveNodes]).

-spec safe_active_nodes_for_role(atom() | undefined) -> [node()].
safe_active_nodes_for_role(Role) ->
    try active_nodes_for_role(Role) of
        Nodes -> Nodes
    catch
        error:_Reason -> [];
        exit:_Reason -> []
    end.

-spec active_nodes_for_role(atom() | undefined) -> [node()].
active_nodes_for_role(undefined) ->
    gateway_node_router:active_nodes();
active_nodes_for_role(Role) ->
    gateway_node_router:active_nodes(Role).

-spec select_owner_nodes(term(), [node(), ...], pos_integer()) -> [node()].
select_owner_nodes(Key, CandidateNodes, ReplicaCount) ->
    case lists:usort(CandidateNodes) of
        [SingleNode] ->
            [SingleNode];
        UniqueNodes when ReplicaCount =:= 1 ->
            [select_top_owner_node(Key, UniqueNodes)];
        UniqueNodes ->
            select_sorted_owner_nodes(Key, UniqueNodes, ReplicaCount)
    end.

-spec select_top_owner_node(term(), [node(), ...]) -> node().
select_top_owner_node(Key, [FirstNode | RestNodes]) ->
    {TopNode, _TopWeight} = lists:foldl(
        fun(Node, Best) -> select_higher_owner(Key, Node, Best) end,
        {FirstNode, owner_node_weight(Key, FirstNode)},
        RestNodes
    ),
    TopNode.

-spec select_higher_owner(term(), node(), {node(), non_neg_integer()}) ->
    {node(), non_neg_integer()}.
select_higher_owner(Key, Node, {BestNode, BestWeight} = Best) ->
    Weight = owner_node_weight(Key, Node),
    case higher_priority(Weight, Node, BestWeight, BestNode) of
        true -> {Node, Weight};
        false -> Best
    end.

-spec higher_priority(non_neg_integer(), node(), non_neg_integer(), node()) -> boolean().
higher_priority(WeightA, NodeA, WeightB, NodeB) ->
    (WeightA > WeightB) orelse (WeightA =:= WeightB andalso NodeA < NodeB).

-spec select_sorted_owner_nodes(term(), [node()], pos_integer()) -> [node()].
select_sorted_owner_nodes(Key, UniqueNodes, ReplicaCount) ->
    WeightedNodes = [{Node, owner_node_weight(Key, Node)} || Node <- UniqueNodes],
    SortedNodes = lists:sort(
        fun({NodeA, WeightA}, {NodeB, WeightB}) ->
            higher_priority(WeightA, NodeA, WeightB, NodeB)
        end,
        WeightedNodes
    ),
    LimitedNodes = lists:sublist(SortedNodes, erlang:min(ReplicaCount, length(SortedNodes))),
    [Node || {Node, _Weight} <- LimitedNodes].

-spec owner_node_weight(term(), node()) -> non_neg_integer().
owner_node_weight(Key, Node) ->
    erlang:phash2({Key, Node}, ?OWNER_HASH_LIMIT).

-spec validate_shard_count(term()) -> {ok, pos_integer()} | error.
validate_shard_count(Value) when is_integer(Value), Value > 0 ->
    {ok, Value};
validate_shard_count(_) ->
    error.