Control.Distributed.Process.ManagedProcess.Internal.Types

Types used throughout the ManagedProcess framework

Exported data types

data InitResult s

Return type for and InitHandler expression.

Constructors

InitOk s Delay

InitStop String

InitIgnore

data GenProcess s a

StateT based monad for prioritised process loops.

Instances

Monad (GenProcess s)

Methods

(>>=) :: GenProcess s a -> (a -> GenProcess s b) -> GenProcess s b

(>>) :: GenProcess s a -> GenProcess s b -> GenProcess s b

return :: a -> GenProcess s a

fail :: String -> GenProcess s a

Functor (GenProcess s)

Methods

fmap :: (a -> b) -> GenProcess s a -> GenProcess s b

(<$) :: a -> GenProcess s b -> GenProcess s a

MonadFix (GenProcess s)

Methods

mfix :: (a -> GenProcess s a) -> GenProcess s a

Applicative (GenProcess s)

Methods

pure :: a -> GenProcess s a

(<*>) :: GenProcess s (a -> b) -> GenProcess s a -> GenProcess s b

liftA2 :: (a -> b -> c) -> GenProcess s a -> GenProcess s b -> GenProcess s c

(*>) :: GenProcess s a -> GenProcess s b -> GenProcess s b

(<*) :: GenProcess s a -> GenProcess s b -> GenProcess s a

MonadIO (GenProcess s)

Methods

liftIO :: IO a -> GenProcess s a

MonadThrow (GenProcess s)

Methods

throwM :: Exception e => e -> GenProcess s a

MonadCatch (GenProcess s)

Methods

catch :: Exception e => GenProcess s a -> (e -> GenProcess s a) -> GenProcess s a

MonadMask (GenProcess s)

Methods

mask :: ((forall a. GenProcess s a -> GenProcess s a) -> GenProcess s b) -> GenProcess s b

uninterruptibleMask :: ((forall a. GenProcess s a -> GenProcess s a) -> GenProcess s b) -> GenProcess s b

generalBracket :: GenProcess s a -> (a -> ExitCase b -> GenProcess s c) -> (a -> GenProcess s b) -> GenProcess s (b, c)

MonadState (State s) (GenProcess s)

Methods

get :: GenProcess s (State s)

put :: State s -> GenProcess s ()

state :: (State s -> (a, State s)) -> GenProcess s a

runProcess :: State s -> GenProcess s a -> Process (a, State s)

Run an action in the GenProcess monad.

lift :: Process a -> GenProcess s a

Lift an action in the Process monad to GenProcess.

liftIO :: IO a -> GenProcess s a

Lift an IO action directly into GenProcess, liftIO = lift . Process.LiftIO.

data ProcessState s

Internal state of a prioritised process loop.

Constructors

ProcessState

Fields

• timeoutSpec :: RecvTimeoutPolicy
• procDef :: ProcessDefinition s
• procPrio :: [DispatchPriority s]
• procFilters :: [DispatchFilter s]
• usrTimeout :: Delay
• sysTimeout :: Timer
• usrTimers :: TimerMap
• internalQ :: Queue
• procState :: s

Instances

MonadState (State s) (GenProcess s)

Methods

get :: GenProcess s (State s)

put :: State s -> GenProcess s ()

state :: (State s -> (a, State s)) -> GenProcess s a

type State s = IORef (ProcessState s)

Prioritised process state, held as an IORef.

type Queue = PriorityQ Int Message

Internal priority queue, used by prioritised processes.

type Limit = Maybe Int

Represent a max-backlog from RecvTimeoutPolicy

data Condition s m

Wraps a predicate that is used to determine whether or not a handler is valid based on some combination of the current process state, the type and/or value of the input message or both.

Constructors

Condition (s -> m -> Bool)

predicated on the process state and the message

State (s -> Bool)

predicated on the process state only

Input (m -> Bool)

predicated on the input message only

data ProcessAction s

The action taken by a process after a handler has run and its updated state. See "Control.Distributed.Process.ManagedProcess.Server.continue" "Control.Distributed.Process.ManagedProcess.Server.timeoutAfter" "Control.Distributed.Process.ManagedProcess.Server.hibernate" "Control.Distributed.Process.ManagedProcess.Server.stop" "Control.Distributed.Process.ManagedProcess.Server.stopWith"

Also see "Control.Distributed.Process.Management.Priority.act" and "Control.Distributed.Process.ManagedProcess.Priority.runAfter".

And other actions. This type should not be used directly.

Constructors

ProcessSkip

ProcessActivity (GenProcess s ())

run the given activity

ProcessExpression (GenProcess s (ProcessAction s))

evaluate an expression

ProcessContinue s

continue with (possibly new) state

ProcessTimeout Delay s

timeout if no messages are received

ProcessHibernate TimeInterval s

hibernate for delay

ProcessStop ExitReason

stop the process, giving ExitReason

ProcessStopping s ExitReason

stop the process with ExitReason, with updated state

ProcessBecome (ProcessDefinition s) s

changes the current process definition

data ProcessReply r s

Returned from handlers for the synchronous call protocol, encapsulates the reply data and the action to take after sending the reply. A handler can return NoReply if they wish to ignore the call.

Constructors

ProcessReply r (ProcessAction s)

ProcessReject String (ProcessAction s)

NoReply (ProcessAction s)

type Action s = Process (ProcessAction s)

An action (server state transition) in the Process monad

type Reply b s = Process (ProcessReply b s)

An action (server state transition) causing a reply to a caller, in the Process monad

type ActionHandler s a = s -> a -> Action s

An expression used to handle a message

type CallHandler s a b = s -> a -> Reply b s

An expression used to handle a message and providing a reply

type CastHandler s a = ActionHandler s a

An expression used to handle a cast message

type StatelessHandler s a = a -> s -> Action s

An expression used to ignore server state during handling

type DeferredCallHandler s a b = CallRef b -> CallHandler s a b

An expression used to handle a call message where the reply is deferred via the CallRef

type StatelessCallHandler s a b = CallRef b -> a -> Reply b s

An expression used to handle a call message ignoring server state

type InfoHandler s a = ActionHandler s a

An expression used to handle an info message

type ChannelHandler s a b = SendPort b -> ActionHandler s a

An expression used to handle a channel message

type StatelessChannelHandler s a b = SendPort b -> StatelessHandler s a

An expression used to handle a channel message in a stateless process

type InitHandler a s = a -> Process (InitResult s)

An expression used to initialise a process with its state

type ShutdownHandler s = ExitState s -> ExitReason -> Process ()

An expression used to handle process termination

data ExitState s

Informs a shutdown handler of whether it is running due to a clean shutdown, or in response to an unhandled exception.

Constructors

CleanShutdown s

given when an ordered shutdown is underway

LastKnown s

isCleanShutdown :: ExitState s -> Bool

True if the ExitState is CleanShutdown, otherwise False.

exitState :: ExitState s -> s

Evaluates to the s state datum in the given ExitState.

type TimeoutHandler s = ActionHandler s Delay

An expression used to handle process timeouts

data UnhandledMessagePolicy

Policy for handling unexpected messages, i.e., messages which are not sent using the call or cast APIs, and which are not handled by any of the handleInfo handlers.

Constructors

Terminate

stop immediately, giving ExitOther UnhandledInput as the reason

DeadLetter ProcessId

forward the message to the given recipient

Log

log messages, then behave identically to Drop

Drop

dequeue and then drop/ignore the message

Instances

Eq UnhandledMessagePolicy

Methods

(==) :: UnhandledMessagePolicy -> UnhandledMessagePolicy -> Bool

(/=) :: UnhandledMessagePolicy -> UnhandledMessagePolicy -> Bool

Show UnhandledMessagePolicy

Methods

showsPrec :: Int -> UnhandledMessagePolicy -> ShowS

show :: UnhandledMessagePolicy -> String

showList :: [UnhandledMessagePolicy] -> ShowS

data ProcessDefinition s

Stores the functions that determine runtime behaviour in response to incoming messages and a policy for responding to unhandled messages.

Constructors

ProcessDefinition

Fields

• apiHandlers :: [Dispatcher s]

  functions that handle call/cast messages

• infoHandlers :: [DeferredDispatcher s]

  functions that handle non call/cast messages

• externHandlers :: [ExternDispatcher s]

  functions that handle control channel and STM inputs

• exitHandlers :: [ExitSignalDispatcher s]

  functions that handle exit signals

• timeoutHandler :: TimeoutHandler s

  a function that handles timeouts

• shutdownHandler :: ShutdownHandler s

  a function that is run just before the process exits

• unhandledMessagePolicy :: UnhandledMessagePolicy

  how to deal with unhandled messages

newtype Priority a

Priority of a message, encoded as an Int

Constructors

Priority

Fields

• getPrio :: Int

data DispatchPriority s

Dispatcher for prioritised handlers

Constructors

PrioritiseCall

Fields

• prioritise :: s -> Message -> Process (Maybe (Int, Message))

PrioritiseCast

Fields

• prioritise :: s -> Message -> Process (Maybe (Int, Message))

PrioritiseInfo

Fields

• prioritise :: s -> Message -> Process (Maybe (Int, Message))

data DispatchFilter s

Provides dispatch from a variety of inputs to a typed filter handler.

Constructors

(Serializable a, Serializable b) => FilterApi

Fields

• apiFilter :: s -> Message a b -> Process (Filter s)

Serializable a => FilterAny

Fields

• anyFilter :: s -> a -> Process (Filter s)

FilterRaw

Fields

• rawFilter :: s -> Message -> Process (Maybe (Filter s))

FilterState

Fields

• stateFilter :: s -> Process (Maybe (Filter s))

data Filter s

Given as the result of evaluating a DispatchFilter. This type is intended for internal use. For an API for working with filters, see Control.Distributed.Process.ManagedProcess.Priority.

Constructors

FilterOk s

FilterSafe s

Show m => FilterReject m s

FilterSkip s

FilterStop s ExitReason

data PrioritisedProcessDefinition s

A ProcessDefinition decorated with DispatchPriority for certain input domains.

Constructors

PrioritisedProcessDefinition

Fields

• processDef :: ProcessDefinition s
• priorities :: [DispatchPriority s]
• filters :: [DispatchFilter s]
• recvTimeout :: RecvTimeoutPolicy

data RecvTimeoutPolicy

For a PrioritisedProcessDefinition, this policy determines for how long the receive loop should continue draining the process' mailbox before processing its received mail (in priority order).

If a prioritised managed process is receiving a lot of messages (into its real mailbox), the server might never get around to actually processing its inputs. This (mandatory) policy provides a guarantee that eventually (i.e., after a specified number of received messages or time interval), the server will stop removing messages from its mailbox and process those it has already received.

Constructors

RecvMaxBacklog Int

RecvTimer TimeInterval

newtype ControlChannel m

Provides a means for servers to listen on a separate, typed control channel, thereby segregating the channel from their regular (and potentially busy) mailbox.

Constructors

ControlChannel

Fields

• unControl :: (SendPort (Message m ()), ReceivePort (Message m ()))

newControlChan :: Serializable m => Process (ControlChannel m)

Creates a new ControlChannel.

newtype ControlPort m

The writable end of a ControlChannel.

Constructors

ControlPort

Fields

• unPort :: SendPort (Message m ())

Instances

Eq (ControlPort m)

Methods

(==) :: ControlPort m -> ControlPort m -> Bool

(/=) :: ControlPort m -> ControlPort m -> Bool

Show (ControlPort m)

Methods

showsPrec :: Int -> ControlPort m -> ShowS

show :: ControlPort m -> String

showList :: [ControlPort m] -> ShowS

Serializable m => Binary (ControlPort m)

Methods

put :: ControlPort m -> Put

get :: Get (ControlPort m)

putList :: [ControlPort m] -> Put

channelControlPort :: ControlChannel m -> ControlPort m

Obtain an opaque expression for communicating with a ControlChannel.

data Dispatcher s

Provides dispatch from cast and call messages to a typed handler.

Constructors

(Serializable a, Serializable b) => Dispatch

Fields

• dispatch :: s -> Message a b -> Process (ProcessAction s)

(Serializable a, Serializable b) => DispatchIf

Fields

• dispatch :: s -> Message a b -> Process (ProcessAction s)
• dispatchIf :: s -> Message a b -> Bool

Instances

MessageMatcher Dispatcher

Methods

matchDispatch :: UnhandledMessagePolicy -> s -> Dispatcher s -> Match (ProcessAction s)

data ExternDispatcher s

Provides dispatch for channels and STM actions

Constructors

(Serializable a, Serializable b) => DispatchCC

Fields

• channel :: ReceivePort (Message a b)
• dispatchChan :: s -> Message a b -> Process (ProcessAction s)

Serializable a => DispatchSTM

Fields

• stmAction :: STM a
• dispatchStm :: s -> a -> Process (ProcessAction s)
• matchStm :: Match Message
• matchAnyStm :: forall m. (Message -> m) -> Match m

Instances

ExternMatcher ExternDispatcher

Methods

matchExtern :: UnhandledMessagePolicy -> s -> ExternDispatcher s -> Match Message

matchMapExtern :: UnhandledMessagePolicy -> s -> (Message -> m) -> ExternDispatcher s -> Match m

MessageMatcher ExternDispatcher

Methods

matchDispatch :: UnhandledMessagePolicy -> s -> ExternDispatcher s -> Match (ProcessAction s)

data DeferredDispatcher s

Provides dispatch for any input, returns Nothing for unhandled messages.

Constructors

DeferredDispatcher

Fields

• dispatchInfo :: s -> Message -> Process (Maybe (ProcessAction s))

data ExitSignalDispatcher s

Provides dispatch for any exit signal - returns Nothing for unhandled exceptions

Constructors

ExitSignalDispatcher

Fields

• dispatchExit :: s -> ProcessId -> Message -> Process (Maybe (ProcessAction s))

class MessageMatcher d where

Defines the means of dispatching inbound messages to a handler

Minimal complete definition

matchDispatch

Methods

matchDispatch :: UnhandledMessagePolicy -> s -> d s -> Match (ProcessAction s)

Instances

MessageMatcher ExternDispatcher

Methods

matchDispatch :: UnhandledMessagePolicy -> s -> ExternDispatcher s -> Match (ProcessAction s)

MessageMatcher Dispatcher

Methods

matchDispatch :: UnhandledMessagePolicy -> s -> Dispatcher s -> Match (ProcessAction s)

class ExternMatcher d where

Defines the means of dispatching messages from external channels (e.g. those defined in terms of ControlChannel, and STM actions) to a handler.

Minimal complete definition

matchExtern, matchMapExtern

Methods

matchExtern :: UnhandledMessagePolicy -> s -> d s -> Match Message

matchMapExtern :: forall m s. UnhandledMessagePolicy -> s -> (Message -> m) -> d s -> Match m

Instances

ExternMatcher ExternDispatcher

Methods

matchExtern :: UnhandledMessagePolicy -> s -> ExternDispatcher s -> Match Message

matchMapExtern :: UnhandledMessagePolicy -> s -> (Message -> m) -> ExternDispatcher s -> Match m

data Message a b

Message type used internally by the call, cast, and rpcChan APIs.

Constructors

CastMessage a

CallMessage a (CallRef b)

ChanMessage a (SendPort b)

Instances

(Eq a, Eq b) => Eq (Message a b)

Methods

(==) :: Message a b -> Message a b -> Bool

(/=) :: Message a b -> Message a b -> Bool

(Show a, Show b) => Show (Message a b)

Methods

showsPrec :: Int -> Message a b -> ShowS

show :: Message a b -> String

showList :: [Message a b] -> ShowS

Generic (Message a b)

Associated Types

type Rep (Message a b) :: * -> *

Methods

from :: Message a b -> Rep (Message a b) x

to :: Rep (Message a b) x -> Message a b

(Serializable a, Serializable b) => Binary (Message a b)

Methods

put :: Message a b -> Put

get :: Get (Message a b)

putList :: [Message a b] -> Put

(NFSerializable a, NFSerializable b) => NFData (Message a b)

Methods

rnf :: Message a b -> ()

type Rep (Message a b)

type Rep (Message a b) = D1 * (MetaData "Message" "Control.Distributed.Process.ManagedProcess.Internal.Types" "distributed-process-client-server-0.2.5.1-BTofhwwXL5R2qkWyoacqPv" False) ((:+:) * (C1 * (MetaCons "CastMessage" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) ((:+:) * (C1 * (MetaCons "CallMessage" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (CallRef b))))) (C1 * (MetaCons "ChanMessage" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (SendPort b)))))))

data CallResponse a

Response type for the call API

Constructors

CallResponse a CallId

Instances

Eq a => Eq (CallResponse a)

Methods

(==) :: CallResponse a -> CallResponse a -> Bool

(/=) :: CallResponse a -> CallResponse a -> Bool

Show a => Show (CallResponse a)

Methods

showsPrec :: Int -> CallResponse a -> ShowS

show :: CallResponse a -> String

showList :: [CallResponse a] -> ShowS

Generic (CallResponse a)

Associated Types

type Rep (CallResponse a) :: * -> *

Methods

from :: CallResponse a -> Rep (CallResponse a) x

to :: Rep (CallResponse a) x -> CallResponse a

Serializable a => Binary (CallResponse a)

Methods

put :: CallResponse a -> Put

get :: Get (CallResponse a)

putList :: [CallResponse a] -> Put

NFSerializable a => NFData (CallResponse a)

Methods

rnf :: CallResponse a -> ()

type Rep (CallResponse a)

type Rep (CallResponse a) = D1 * (MetaData "CallResponse" "Control.Distributed.Process.ManagedProcess.Internal.Types" "distributed-process-client-server-0.2.5.1-BTofhwwXL5R2qkWyoacqPv" False) (C1 * (MetaCons "CallResponse" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CallId))))

type CallId = MonitorRef

wrapper for a MonitorRef

newtype CallRef a

Wraps a consumer of the call API

Constructors

CallRef

Fields

• unCaller :: (Recipient, CallId)

Instances

Eq (CallRef a)

Methods

(==) :: CallRef a -> CallRef a -> Bool

(/=) :: CallRef a -> CallRef a -> Bool

Show (CallRef a)

Methods

showsPrec :: Int -> CallRef a -> ShowS

show :: CallRef a -> String

showList :: [CallRef a] -> ShowS

Generic (CallRef a)

Associated Types

type Rep (CallRef a) :: * -> *

Methods

from :: CallRef a -> Rep (CallRef a) x

to :: Rep (CallRef a) x -> CallRef a

Binary (CallRef a)

Methods

put :: CallRef a -> Put

get :: Get (CallRef a)

putList :: [CallRef a] -> Put

NFData (CallRef a)

Methods

rnf :: CallRef a -> ()

Resolvable (CallRef a)

Methods

resolve :: CallRef a -> Process (Maybe ProcessId)

unresolvableMessage :: CallRef a -> String

Routable (CallRef a)

Methods

sendTo :: (Serializable m, Resolvable (CallRef a)) => CallRef a -> m -> Process ()

unsafeSendTo :: (NFSerializable m, Resolvable (CallRef a)) => CallRef a -> m -> Process ()

type Rep (CallRef a)

type Rep (CallRef a) = D1 * (MetaData "CallRef" "Control.Distributed.Process.ManagedProcess.Internal.Types" "distributed-process-client-server-0.2.5.1-BTofhwwXL5R2qkWyoacqPv" True) (C1 * (MetaCons "CallRef" PrefixI True) (S1 * (MetaSel (Just Symbol "unCaller") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Recipient, CallId))))

data CallRejected

Sent to a consumer of the call API when a server filter expression explicitly rejects an incoming call message.

Constructors

CallRejected String CallId

Instances

Eq CallRejected

Methods

(==) :: CallRejected -> CallRejected -> Bool

(/=) :: CallRejected -> CallRejected -> Bool

Show CallRejected

Methods

showsPrec :: Int -> CallRejected -> ShowS

show :: CallRejected -> String

showList :: [CallRejected] -> ShowS

Generic CallRejected

Associated Types

type Rep CallRejected :: * -> *

Methods

from :: CallRejected -> Rep CallRejected x

to :: Rep CallRejected x -> CallRejected

Binary CallRejected

Methods

put :: CallRejected -> Put

get :: Get CallRejected

putList :: [CallRejected] -> Put

NFData CallRejected

Methods

rnf :: CallRejected -> ()

type Rep CallRejected

type Rep CallRejected = D1 * (MetaData "CallRejected" "Control.Distributed.Process.ManagedProcess.Internal.Types" "distributed-process-client-server-0.2.5.1-BTofhwwXL5R2qkWyoacqPv" False) (C1 * (MetaCons "CallRejected" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CallId))))

makeRef :: Recipient -> CallId -> CallRef a

Creates a CallRef for the given Recipient and CallId

caller :: forall a b. Message a b -> Maybe Recipient

Retrieve the Recipient from a Message. If the supplied message is a cast or chan message will evaluate to Nothing, otherwise Just ref.

rejectToCaller :: forall a b. Message a b -> String -> Process ()

Reject a call message with the supplied string. Sends CallRejected to the recipient if the input is a CallMessage, otherwise has no side effects.

recipient :: CallRef a -> Recipient

Retrieve the Recipient for a CallRef.

tag :: CallRef a -> CallId

Retrieve the CallId for a CallRef.

initCall :: forall s a b. (Addressable s, Serializable a, Serializable b) => s -> a -> Process (CallRef b)

The send part of the call client-server interaction. The resulting CallRef can be used to identify the corrolary response message (if one is sent by the server), and is unique to this call-reply pair.

unsafeInitCall :: forall s a b. (Addressable s, NFSerializable a, NFSerializable b) => s -> a -> Process (CallRef b)

Version of initCall that utilises "unsafeSendTo".

waitResponse :: forall b. Serializable b => Maybe TimeInterval -> CallRef b -> Process (Maybe (Either ExitReason b))

Wait on the server's response after an "initCall" has been previously been sent.

This function does not trap asynchronous exceptions.