View Source brod_supervisor3 behaviour (brod v4.4.0)

Summary

Types

call/0

XXX: refine

child/0
child_id/0
child_rec/0
child_spec/0
delay/0
dynamics/0
init_sup_name/0
mfargs/0
modules/0
restart/0
shutdown/0
startchild_err/0
startchild_ret/0
startlink_err/0
startlink_ret/0
state/0
stop_rsn/0
strategy/0
sup_name/0
sup_ref/0
tref/0
worker/0

Callbacks

init/1
post_init/1

Functions

check_childspecs(ChildSpecs)
code_change(_, State, _)
count_children(SupRef)
delete_child(SupRef, Id)
find_child(Supervisor, Name)
handle_call(_, From, State)
handle_cast(_, State)
handle_info(Msg, State)
init(_)
restart_child(SupRef, Id)
start_child(SupRef, ChildSpec)
start_link(Module, Args)
start_link(SupName, Module, Args)
terminate(Reason, State)
terminate_child(SupRef, Id)
try_again_restart(SupRef, Child, Reason)
which_children(SupRef)

Types

call/0

-type call() :: which_children | count_children | {_, _}.

XXX: refine

child/0

-type child() :: undefined | pid().

child_id/0

-type child_id() :: term().

child_rec/0

-type child_rec() ::
          #child{pid :: child() | {restarting, pid()} | {delayed_restart, tref()} | [pid()],
                 name :: child_id(),
                 mfargs :: mfargs(),
                 restart_type :: restart(),
                 shutdown :: shutdown(),
                 child_type :: worker(),
                 modules :: modules()}.

child_spec/0

-type child_spec() ::
          {Id :: child_id(),
           StartFunc :: mfargs(),
           Restart :: restart(),
           Shutdown :: shutdown(),
           Type :: worker(),
           Modules :: modules()}.

delay/0

-type delay() :: non_neg_integer().

dynamics/0

-type dynamics() :: dict:dict() | sets:set().

init_sup_name/0

-type init_sup_name() :: sup_name() | self.

mfargs/0

-type mfargs() :: {M :: module(), F :: atom(), A :: [term()] | undefined}.

modules/0

-type modules() :: [module()] | dynamic.

restart/0

-type restart() ::
          permanent | transient | temporary | intrinsic |
          {permanent, delay()} |
          {transient, delay()} |
          {intrinsic, delay()}.

shutdown/0

-type shutdown() :: brutal_kill | timeout().

startchild_err/0

-type startchild_err() :: already_present | {already_started, Child :: child()} | term().

startchild_ret/0

-type startchild_ret() ::
          {ok, Child :: child()} | {ok, Child :: child(), Info :: term()} | {error, startchild_err()}.

state/0

-type state() ::
          #state{name :: atom(),
                 strategy :: strategy(),
                 children :: [child_rec()],
                 dynamics :: dynamics(),
                 intensity :: non_neg_integer(),
                 period :: pos_integer(),
                 restarts :: list(),
                 module :: module(),
                 args :: list()}.

stop_rsn/0

-type stop_rsn() ::
          {shutdown, term()} |
          {bad_return, {module(), init, term()}} |
          {bad_start_spec, term()} |
          {start_spec, term()} |
          {supervisor_data, term()}.

strategy/0

-type strategy() :: one_for_all | one_for_one | rest_for_one | simple_one_for_one.

sup_name/0

-type sup_name() :: {local, Name :: atom()} | {global, Name :: atom()}.

sup_ref/0

-type sup_ref() ::
          (Name :: atom()) | {Name :: atom(), Node :: node()} | {global, Name :: atom()} | pid().

tref/0

-type tref() :: reference().

worker/0

-type worker() :: worker | supervisor.

Callbacks

init/1

-callback init(Args :: term()) ->
                  {ok,
                   {{RestartStrategy :: strategy(), MaxR :: non_neg_integer(), MaxT :: non_neg_integer()},
                    [ChildSpec :: child_spec()]}} |
                  ignore | post_init.

post_init/1

(optional) 
-callback post_init(Args :: term()) ->
                       {ok,
                        {{RestartStrategy :: strategy(),
                          MaxR :: non_neg_integer(),
                          MaxT :: non_neg_integer()},
                         [ChildSpec :: child_spec()]}} |
                       ignore.

Functions

check_childspecs(ChildSpecs)

-spec check_childspecs(ChildSpecs) -> Result
                          when ChildSpecs :: [child_spec()], Result :: ok | {error, Error :: term()}.

code_change(_, State, _)

-spec code_change(term(), state(), term()) -> {ok, state()} | {error, term()}.

count_children(SupRef)

-spec count_children(SupRef) -> PropListOfCounts
                        when
                            SupRef :: sup_ref(),
                            PropListOfCounts :: [Count],
                            Count ::
                                {specs, ChildSpecCount :: non_neg_integer()} |
                                {active, ActiveProcessCount :: non_neg_integer()} |
                                {supervisors, ChildSupervisorCount :: non_neg_integer()} |
                                {workers, ChildWorkerCount :: non_neg_integer()}.

delete_child(SupRef, Id)

-spec delete_child(SupRef, Id) -> Result
                      when
                          SupRef :: sup_ref(),
                          Id :: child_id(),
                          Result :: ok | {error, Error},
                          Error :: running | restarting | not_found | simple_one_for_one.

find_child(Supervisor, Name)

-spec find_child(Supervisor, Name) -> [pid()] when Supervisor :: sup_ref(), Name :: child_id().

handle_call(_, From, State)

-spec handle_call(call(), term(), state()) -> {reply, term(), state()}.

handle_cast(_, State)

-spec handle_cast({try_again_restart, child_id() | pid(), term()}, state()) ->
                     {noreply, state()} | {stop, shutdown, state()}.

handle_info(Msg, State)

-spec handle_info(term(), state()) -> {noreply, state()} | {stop, term(), state()}.

init(_)

-spec init({init_sup_name(), module(), [term()]}) -> {ok, state()} | ignore | {stop, stop_rsn()}.

restart_child(SupRef, Id)

-spec restart_child(SupRef, Id) -> Result
                       when
                           SupRef :: sup_ref(),
                           Id :: child_id(),
                           Result ::
                               {ok, Child :: child()} |
                               {ok, Child :: child(), Info :: term()} |
                               {error, Error},
                           Error :: running | restarting | not_found | simple_one_for_one | term().

start_child(SupRef, ChildSpec)

-spec start_child(SupRef, ChildSpec) -> startchild_ret()
                     when SupRef :: sup_ref(), ChildSpec :: child_spec() | (List :: [term()]).

start_link(Module, Args)

-spec start_link(Module, Args) -> startlink_ret() when Module :: module(), Args :: term().

start_link(SupName, Module, Args)

-spec start_link(SupName, Module, Args) -> startlink_ret()
                    when SupName :: sup_name(), Module :: module(), Args :: term().

terminate(Reason, State)

-spec terminate(term(), state()) -> ok.

terminate_child(SupRef, Id)

-spec terminate_child(SupRef, Id) -> Result
                         when
                             SupRef :: sup_ref(),
                             Id :: pid() | child_id(),
                             Result :: ok | {error, Error},
                             Error :: not_found | simple_one_for_one.

try_again_restart(SupRef, Child, Reason)

-spec try_again_restart(SupRef, Child, Reason) -> ok
                           when SupRef :: sup_ref(), Child :: child_id() | pid(), Reason :: term().

which_children(SupRef)

-spec which_children(SupRef) -> [{Id, Child, Type, Modules}]
                        when
                            SupRef :: sup_ref(),
                            Id :: child_id() | undefined,
                            Child :: child() | restarting,
                            Type :: worker(),
                            Modules :: modules().