@spec add_chain(atom(), list(), non_neg_integer()) :: {:ok, atom()} | {:error, any()}

Add a chain to the supervisor. Chain's options follow docs in Chain module.

@spec add_chain_worker(
  atom(),
  atom(),
  {module(), atom(), list()} | fun() | module() | {module(), list()},
  list(),
  non_neg_integer()
) :: {:ok, atom()} | {:error, any()}

Add a worker to the chain in supervisor.

@spec add_group(atom(), list(), non_neg_integer()) :: {:ok, atom()} | {:error, any()}

Add a group to the supervisor. Group's options follow docs in Group module.

@spec add_group_worker(
  atom(),
  atom(),
  {module(), atom(), list()} | fun() | module() | {module(), list()},
  list(),
  non_neg_integer()
) :: {:ok, atom()} | {:error, any()}

Add a worker to a group in the supervisor. Function's options follow Worker module. Support worker is function (mfa, anonymous function) or GenServer

@spec add_standalone_worker(
  atom(),
  {module(), atom(), list()} | fun() | module() | {module(), list()},
  list(),
  non_neg_integer()
) :: {:ok, atom()} | {:error, any()}

Add a standalone worker process to the supervisor. function for start worker can be a function or a {module, function, arguments} or a GenServer. Standalone worker is run independently from other workers follow :one_to_one strategy. If worker crashes, it will check the restart strategy of worker then act accordingly.

@spec broadcast_to_group(atom(), atom(), any(), non_neg_integer()) ::
  :ok | {:error, any()}

Send data to all workers in a group.

@spec broadcast_to_my_group(any()) :: :ok | {:error, any()}

Send data to all workers in current group of worker. Using for communite between workers in the same group.

Returns a specification to start this module under a supervisor.

See Supervisor.

@spec count_workers_in_chain(atom(), any(), non_neg_integer()) ::
  {:ok, pos_integer()} | {:error, any()}

count workers in chain

@spec count_workers_in_group(atom(), any(), non_neg_integer()) ::
  {:ok, non_neg_integer()} | {:error, term()}

count workers in group

@spec get_my_group() :: atom() | nil

get current group id of worker.

@spec get_my_supervisor() :: atom() | nil

Get supervisor id in current process (not support for GenServer worker).

@spec get_pid_chain_worker(atom(), any(), any(), non_neg_integer()) ::
  {:ok, any()} | {:error, any()}

get pid of chain worker

@spec get_pid_group_worker(atom(), any(), any(), non_neg_integer()) ::
  pid() | {:error, any()}

get pid of group worker.

@spec get_pid_standalone_worker(atom(), any(), non_neg_integer()) ::
  {:ok, pid()} | {:error, term()}

get pid of standalone worker

@spec group_exists?(atom(), any(), non_neg_integer()) :: boolean() | {:error, any()}

group is existed

@spec list_chains(atom(), non_neg_integer()) ::
  {:ok,
   [
     %{
       id: atom(),
       restart_strategy: atom(),
       send_type: atom(),
       queue_length: pos_integer(),
       worker_ids: [term()]
     }
   ]}
  | {:error, term()}

Lists the chains of a supervisor with their configuration and worker ids.

Examples

Sup.add_chain(:sup1, id: :chain1)
{:ok,
 [
   %{
     id: :chain1,
     restart_strategy: :one_for_one,
     send_type: :random,
     queue_length: 50,
     worker_ids: []
   }
 ]} = Sup.list_chains(:sup1)

@spec list_groups(atom(), non_neg_integer()) ::
  {:ok, [%{id: atom(), restart_strategy: atom(), worker_ids: [term()]}]}
  | {:error, term()}

Lists the groups of a supervisor with their restart strategies and worker ids.

Examples

Sup.add_group(:sup1, id: :group1, restart_strategy: :one_for_all)
{:ok,
 [
   %{id: :group1, restart_strategy: :one_for_all, worker_ids: []}
 ]} = Sup.list_groups(:sup1)

@spec list_standalone_workers(atom(), non_neg_integer()) ::
  {:ok, [%{id: term(), name: atom() | nil, restart_strategy: atom()}]}
  | {:error, term()}

Lists the standalone workers of a supervisor.

Examples

Sup.add_standalone_worker(:sup1, {MyGenServer, []}, id: :sa1)
{:ok, [%{id: :sa1, name: nil, restart_strategy: :transient}]} =
  Sup.list_standalone_workers(:sup1)

@spec remove_chain(atom(), any(), non_neg_integer()) :: :ok | {:error, term()}

remove chain.

@spec remove_chain_worker(atom(), any(), any(), non_neg_integer()) ::
  :ok | {:error, term()}

remove a worker from chain.

@spec remove_group(atom(), any(), non_neg_integer()) :: :ok | {:error, any()}

remove group

@spec remove_group_worker(atom(), any(), any(), non_neg_integer()) ::
  :ok | {:error, any()}

remove a worker out of group

@spec remove_standalone_worker(atom(), any(), non_neg_integer()) ::
  :ok | {:error, term()}

Remove standalone worker from supervisor.

@spec restart_group(atom(), any(), non_neg_integer()) ::
  {:ok, atom()} | {:error, any()}

Restart all workers in group

@spec restart_group_worker(atom(), any(), any(), non_neg_integer()) ::
  {:ok, atom()} | {:error, any()}

Restart a worker in group

@spec running?(atom()) :: boolean()

Check if supervisor is running.

@spec running_supervisors() :: [{atom(), pid()}]

Lists all supervisors started through this library on the current node.

Entries whose process died are filtered out (and cleaned up lazily).

Examples

iex> Sup.start_with_config(id: :doctest_sup)
iex> Sup.running_supervisors() |> Enum.any?(fn {id, pid} -> id == :doctest_sup and is_pid(pid) end)
true

@spec send_to_chain(atom(), any(), any(), non_neg_integer()) ::
  {:ok, any()} | {:error, any()}

Send data to the entry worker in the chain. If chain doesn't has any worker, it will be dropped.

@spec send_to_group_random(atom(), any(), any(), non_neg_integer()) ::
  :ok | {:error, any()}

Send data to a random worker in the group.

@spec send_to_group_worker(atom(), any(), any(), any(), non_neg_integer()) ::
  :ok | {:error, any()}

Send data to a worker in the group.

@spec send_to_my_group(any(), any()) :: :ok | {:error, any()}

Send data to other worker in the same group.

@spec send_to_my_group_random(any()) :: :ok | {:error, any()}

Send data to a random worker in the same group.

@spec send_to_standalone_worker(atom(), any(), any(), non_neg_integer()) ::
  :ok | {:error, term()}

Send data directly to the worker standalone in the supervisor.

@spec start() :: {:ok, pid()} | {:error, any()}

Start supervisor run as independent process with default options.

@spec start(t()) :: {:ok, pid()} | {:error, any()}

Start supervisor as independent process (no link process).

@spec start_link() :: {:ok, pid()} | {:error, any()}

Work like start_link/1 with default options.

@spec start_link(t()) :: {:ok, pid()} | {:error, any()}

start_link for using supervisor as child in other supervisor or link to current process.

@spec start_with_config(
  id: atom(),
  link: boolean() | pid(),
  num_partitions: integer(),
  report_to: list()
) :: {:ok, pid()} | {:error, any()}

Start supervisor with configurations (Keyword). For run standalone, please set option :link to false. For link to other process (not current process), please set link to pid of that process. result format: {:ok, pid} or {:error, reason}

@spec stop(atom(), shutdown_type :: atom(), timeout :: non_neg_integer()) ::
  {:ok, atom()} | {:error, :not_running}

Stop supervisor.

Shutdown types:

• :kill (default) worker processes are killed with Process.exit(pid, :kill).
• any other type (e.g. :normal) is not implemented yet; it currently falls back to the same brutal kill, so workers cannot run cleanup code.

Returns {:ok, sup_id} when the stop signal was delivered (the supervisor shuts down asynchronously shortly after) or {:error, :not_running}.

@spec supervisor_info(atom(), non_neg_integer()) :: {:ok, map()} | {:error, term()}

Returns an overview of a running supervisor: partition health and counts of groups, chains and workers.

Examples

{:ok,
 %{
   id: :my_sup,
   num_partitions: 4,
   partitions: [%{id: 1, pid: pid, alive?: true, message_queue_len: 0}, ...],
   num_groups: 2,
   num_chains: 1,
   num_standalone_workers: 3,
   total_worker_processes: 9
 }} = Sup.supervisor_info(:my_sup)