Control.Concurrent.Supervisor.Types

Documentation

type SupervisorSpec0 q = Supervisor_ q Uninitialised

type Supervisor0 q = Supervisor_ q Initialised

data Child_ q

data DeadLetter

type RestartAction = ThreadId -> IO ThreadId

data SupervisionEvent

Constructors

ChildBorn !ThreadId !UTCTime

ChildDied !ThreadId !SomeException !UTCTime

ChildRestarted !ThreadId !ThreadId !RestartStrategy !UTCTime

ChildRestartLimitReached !ThreadId !RestartStrategy !UTCTime

ChildFinished !ThreadId !UTCTime

Instances

Show SupervisionEvent

data RestartStrategy

Erlang inspired strategies. At the moment only the OneForOne is implemented.

Constructors

OneForOne !Int RetryPolicy

Instances

Show RestartStrategy

Creating a new supervisor spec

In order to create a new supervisor, you need a SupervisorSpec, which can be acquired by a call to newSupervisor:

newSupervisorSpec :: QueueLike q => Int -> IO (SupervisorSpec0 q)

Creates a new SupervisorSpec. The reason it doesn't return a Supervisor is to force you to call supervise explicitly, in order to start the supervisor thread.

Creating a new supervisor

newSupervisor :: QueueLike q => SupervisorSpec0 q -> IO (Supervisor0 q)

Restart Strategies

oneForOne :: RestartStrategy

Smart constructor which offers a default throttling based on fibonacci numbers.

Stopping a supervisor

shutdownSupervisor :: QueueLike q => Supervisor0 q -> IO ()

Shutdown the given supervisor. This will cause the supervised children to be killed as well. To do so, we explore the children tree, killing workers as we go, and recursively calling shutdownSupervisor in case we hit a monitored Supervisor.

Accessing Supervisor event log

eventStream :: QueueLike q => Supervisor0 q -> q SupervisionEvent

Gives you access to the event this supervisor is generating, allowing you to react. It's using a bounded queue to explicitly avoid memory leaks in case you do not want to drain the queue to listen to incoming events.

activeChildren :: QueueLike q => Supervisor0 q -> IO Int

Returns the number of active threads at a given moment in time.

Supervise a forked thread

forkSupervised

Arguments

:: QueueLike q

=> Supervisor0 q

The Supervisor

-> RestartStrategy

The RestartStrategy to use

-> IO ()

The computation to run

-> IO ThreadId

Fork a thread in a supervised mode.

Monitor another supervisor

monitor :: QueueLike q => Supervisor0 q -> Supervisor0 q -> IO ()

Monitor another supervisor. To achieve these, we simulate a new DeadLetter, so that the first supervisor will effectively restart the monitored one. Thanks to the fact that for the supervisor the restart means we just copy over its internal state, it should be perfectly fine to do so.