Specs

count_children(Supervisor.supervisor()) :: %{
  specs: non_neg_integer(),
  active: non_neg_integer(),
  supervisors: non_neg_integer(),
  workers: non_neg_integer()
}

Returns a map containing count values for the supervisor.

The map contains the following keys:

• :specs - always 1 as consumer supervisors have a single specification

• :active - the count of all actively running child processes managed by this supervisor

• :supervisors - the count of all supervisors whether or not the child process is still alive

• :workers - the count of all workers, whether or not the child process is still alive

Receives a template to initialize and a set of options.

This is typically invoked at the end of the init/1 callback of module-based supervisors.

This function returns a the child specification and the supervisor flags.

Examples

Using the child specification changes introduced in Elixir 1.5:

defmodule MyConsumerSupervisor do
  use ConsumerSupervisor

  def start_link(arg) do
    ConsumerSupervisor.start_link(__MODULE__, arg)
  end

  def init(_arg) do
    ConsumerSupervisor.init([MyConsumer], strategy: :one_for_one, subscribe_to: MyProducer)
  end
end

Specs

start_child(Supervisor.supervisor(), [term()]) :: Supervisor.on_start_child()

Starts a child in the consumer supervisor.

The child process will be started by appending the given list of args to the existing function arguments in the child specification.

This child is started separately from any producer and does not count towards the demand of any of them.

If the child process starts, function returns {:ok, child} or {:ok, child, info}, the pid is added to the supervisor, and the function returns the same value.

If the child process start function returns :ignore, an error tuple, or an erroneous value, or if it fails, the child is discarded and :ignore or {:error, error} where error is a term containing information about the error is returned.

Specs

start_link([Supervisor.Spec.spec() | Supervisor.child_spec()], [option()]) ::
  Supervisor.on_start()

start_link(module(), any()) :: Supervisor.on_start()

Starts a supervisor with the given children.

A strategy is required to be given as an option. Furthermore, the :max_restarts, :max_seconds, and :subscribe_to values can be configured as described in the documentation for the init/1 callback.

The options can also be used to register a supervisor name. The supported values are described under the "Name Registration" section in the GenServer module docs.

The child processes specified in children will be started by appending the event to process to the existing function arguments in the child specification.

Note that the consumer supervisor is linked to the parent process and will exit not only on crashes but also if the parent process exits with :normal reason.

Specs

start_link(module(), any(), [option()]) :: Supervisor.on_start()

Starts a consumer supervisor module with the given args.

To start the supervisor, the init/1 callback will be invoked in the given module, with args passed to it. The init/1 callback must return a supervision specification which can be created with the help of the Supervisor module.

If the init/1 callback returns :ignore, this function returns :ignore as well and the supervisor terminates with reason :normal. If it fails or returns an incorrect value, this function returns {:error, term} where term is a term with information about the error, and the supervisor terminates with reason term.

The :name option can also be given in order to register a supervisor name. The supported values are described under the "Name Registration" section in the GenServer module docs.

Specs

terminate_child(Supervisor.supervisor(), pid()) :: :ok | {:error, :not_found}

Terminates the given child pid.

If successful, the function returns :ok. If there is no such pid, the function returns {:error, :not_found}.

Specs

which_children(Supervisor.supervisor()) :: [
  {:undefined, pid() | :restarting, :worker | :supervisor,
   :dynamic | [module()]}
]

Returns a list with information about all children.

Note that calling this function when supervising a large number of children under low memory conditions can cause an out of memory exception.

This function returns a list of tuples containing:

• id - as defined in the child specification but is always set to :undefined for consumer supervisors

• child - the pid of the corresponding child process or the atom :restarting if the process is about to be restarted

• type - :worker or :supervisor as defined in the child specification

• modules - as defined in the child specification