Safe Haskell	None
Language	Haskell2010

Control.Concurrent.Supervisor

Synopsis

type Supervisor = Supervisor TQueue
type Child = Child_ TQueue
newSupervisor :: RestartStrategy -> IO Supervisor
data RestartStrategy = OneForOne
data SupervisionEvent
- = ChildBorn !ThreadId !UTCTime
- | ChildDied !ThreadId !SomeException !UTCTime
- | ChildRestarted !ThreadId !ThreadId !RetryStatus !UTCTime
- | ChildNotFound !ThreadId !UTCTime
- | StaleDeadLetterReceived !ThreadId !LetterEpoch !ChildEpoch !UTCTime
- | ChildRestartLimitReached !ThreadId !RetryStatus !UTCTime
- | ChildFinished !ThreadId !UTCTime
type RestartAction = ThreadId -> IO ThreadId
data Child_ q
data RestartResult
- = Restarted !ThreadId !ThreadId !RetryStatus !UTCTime
- | StaleDeadLetter !ThreadId !LetterEpoch !ChildEpoch !UTCTime
- | RestartFailed SupervisionEvent
data DeadLetter
class QueueLike q where
- newQueueIO :: Natural -> IO (q a)
- readQueue :: q a -> STM a
- writeQueue :: q a -> a -> STM ()
data SupervisionCtx q
fibonacciRetryPolicy :: RetryPolicyM IO
eventStream :: QueueLike q => Supervisor q -> q SupervisionEvent
activeChildren :: QueueLike q => Supervisor q -> IO Int
shutdownSupervisor :: QueueLike q => Supervisor q -> IO ()
forkSupervised :: QueueLike q => Supervisor q -> RetryPolicyM IO -> IO () -> IO ThreadId
monitorWith :: QueueLike q => RetryPolicyM IO -> Supervisor q -> Supervisor q -> IO ThreadId

Documentation

type Supervisor = Supervisor TQueue Source #

type Child = Child_ TQueue Source #

newSupervisor :: RestartStrategy -> IO Supervisor Source #

data RestartStrategy Source #

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

Constructors

OneForOne

Instances

Show RestartStrategy Source #
Instance details Defined in Control.Concurrent.Supervisor.Types Methods showsPrec :: Int -> RestartStrategy -> ShowS # show :: RestartStrategy -> String # showList :: [RestartStrategy] -> ShowS #

data SupervisionEvent Source #

Constructors

ChildBorn !ThreadId !UTCTime
ChildDied !ThreadId !SomeException !UTCTime
ChildRestarted !ThreadId !ThreadId !RetryStatus !UTCTime
ChildNotFound !ThreadId !UTCTime
StaleDeadLetterReceived !ThreadId !LetterEpoch !ChildEpoch !UTCTime
ChildRestartLimitReached !ThreadId !RetryStatus !UTCTime
ChildFinished !ThreadId !UTCTime

Instances

Show SupervisionEvent Source #
Instance details Defined in Control.Concurrent.Supervisor.Types Methods showsPrec :: Int -> SupervisionEvent -> ShowS # show :: SupervisionEvent -> String # showList :: [SupervisionEvent] -> ShowS #

type RestartAction = ThreadId -> IO ThreadId Source #

data Child_ q Source #

data RestartResult Source #

Constructors

Restarted !ThreadId !ThreadId !RetryStatus !UTCTime	The supervised `Child_` was restarted successfully.
StaleDeadLetter !ThreadId !LetterEpoch !ChildEpoch !UTCTime	A stale `DeadLetter` was received.
RestartFailed SupervisionEvent	The restart failed for a reason decribed by a `SupervisionEvent`

Instances

Show RestartResult Source #
Instance details Defined in Control.Concurrent.Supervisor.Types Methods showsPrec :: Int -> RestartResult -> ShowS # show :: RestartResult -> String # showList :: [RestartResult] -> ShowS #

data DeadLetter Source #

class QueueLike q where Source #

Methods

newQueueIO :: Natural -> IO (q a) Source #

readQueue :: q a -> STM a Source #

writeQueue :: q a -> a -> STM () Source #

Instances

QueueLike TQueue Source #
Instance details Defined in Control.Concurrent.Supervisor.Types Methods newQueueIO :: Natural -> IO (TQueue a) Source # readQueue :: TQueue a -> STM a Source # writeQueue :: TQueue a -> a -> STM () Source #
QueueLike TBQueue Source #
Instance details Defined in Control.Concurrent.Supervisor.Types Methods newQueueIO :: Natural -> IO (TBQueue a) Source # readQueue :: TBQueue a -> STM a Source # writeQueue :: TBQueue a -> a -> STM () Source #

data SupervisionCtx q Source #

fibonacciRetryPolicy :: RetryPolicyM IO Source #

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

eventStream :: QueueLike q => Supervisor q -> q SupervisionEvent Source #

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 => Supervisor q -> IO Int Source #

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

shutdownSupervisor :: QueueLike q => Supervisor q -> IO () Source #

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.

forkSupervised Source #

Arguments

:: QueueLike q
=> Supervisor q	The `Supervisor`
-> RetryPolicyM IO	The retry policy to use
-> IO ()	The computation to run
-> IO ThreadId

Fork a thread in a supervised mode.

monitorWith Source #

Arguments

:: QueueLike q
=> RetryPolicyM IO	The retry policy to use
-> Supervisor q	The supervisor
-> Supervisor q	The `supervised` supervisor
-> IO ThreadId

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. Returns the ThreadId of the monitored supervisor.