RpcLoadBalancer.LoadBalancer.SelectionAlgorithm behaviour (rpc_load_balancer v0.2.2)

Copy Markdown View Source

Behaviour for load balancer node selection.

Summary

Types

load_balancer_name()

@type load_balancer_name() :: atom() | module()

Callbacks

caches()

(optional)
@callback caches() :: [module()]

child_specs(load_balancer_name, opts)

(optional)
@callback child_specs(load_balancer_name(), opts :: keyword()) :: [
  Supervisor.child_spec()
]

choose_from_nodes(load_balancer_name, list, opts)

@callback choose_from_nodes(load_balancer_name(), [node()], opts :: keyword()) :: node()

choose_nodes(load_balancer_name, list, pos_integer, opts)

(optional)
@callback choose_nodes(load_balancer_name(), [node()], pos_integer(), opts :: keyword()) ::
  [node()]

init(load_balancer_name, opts)

(optional)
@callback init(load_balancer_name(), opts :: keyword()) :: :ok

local?()

(optional)
@callback local?() :: boolean()

on_node_change(load_balancer_name, {})

(optional)
@callback on_node_change(
  load_balancer_name(),
  {:joined | :left, [node()]}
) :: :ok

release_node(load_balancer_name, node)

(optional)
@callback release_node(load_balancer_name(), node()) :: :ok

Functions

all_caches(algorithms)

@spec all_caches([module()]) :: [module()]

Returns the union of caches required by every algorithm passed in.

Used by RpcLoadBalancer.Application to start exactly the cache agents the configured algorithms need — no more, no less.

caches(algorithm)

@spec caches(module()) :: [module()]

Returns the cache modules an algorithm needs.

Algorithms that don't require any caches can omit the caches/0 callback entirely; we treat that as [].

child_specs(algorithm, load_balancer_name, opts)

@spec child_specs(module(), load_balancer_name(), keyword()) :: [
  Supervisor.child_spec()
]

choose_from_nodes(algorithm, load_balancer_name, node_list, opts \\ [])

@spec choose_from_nodes(module(), load_balancer_name(), [node()], keyword()) :: node()

choose_nodes(algorithm, load_balancer_name, node_list, count, opts \\ [])

@spec choose_nodes(module(), load_balancer_name(), [node()], pos_integer(), keyword()) ::
  [node()]

get_algorithm(load_balancer_name)

@spec get_algorithm(load_balancer_name()) ::
  {:ok, module() | nil} | {:error, ErrorMessage.t()}

init(algorithm, load_balancer_name, opts)

@spec init(module(), load_balancer_name(), keyword()) :: :ok

local?(algorithm)

@spec local?(module()) :: boolean()

on_node_change(algorithm, load_balancer_name, change)

@spec on_node_change(module(), load_balancer_name(), {:joined | :left, [node()]}) ::
  :ok

put_algorithm(load_balancer_name, algorithm_module)

@spec put_algorithm(load_balancer_name(), module()) ::
  :ok | {:error, ErrorMessage.t()}

release_node(algorithm, load_balancer_name, node)

@spec release_node(module(), load_balancer_name(), node()) :: :ok