Control.Distributed.Process.Internal.Types

Types used throughout the Cloud Haskell framework

We collect all types used internally in a single module because many of these data types are mutually recursive and cannot be split across modules.

Node and process identifiers

newtype NodeId

Node identifier

Constructors

NodeId

Fields

• nodeAddress :: EndPointAddress

Instances

Eq NodeId

Methods

(==) :: NodeId -> NodeId -> Bool

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

Data NodeId

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NodeId -> c NodeId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NodeId

toConstr :: NodeId -> Constr

dataTypeOf :: NodeId -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NodeId)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NodeId)

gmapT :: (forall b. Data b => b -> b) -> NodeId -> NodeId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NodeId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NodeId -> r

gmapQ :: (forall d. Data d => d -> u) -> NodeId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NodeId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeId -> m NodeId

Ord NodeId

Methods

compare :: NodeId -> NodeId -> Ordering

(<) :: NodeId -> NodeId -> Bool

(<=) :: NodeId -> NodeId -> Bool

(>) :: NodeId -> NodeId -> Bool

(>=) :: NodeId -> NodeId -> Bool

max :: NodeId -> NodeId -> NodeId

min :: NodeId -> NodeId -> NodeId

Show NodeId

Methods

showsPrec :: Int -> NodeId -> ShowS

show :: NodeId -> String

showList :: [NodeId] -> ShowS

Generic NodeId

Associated Types

type Rep NodeId :: * -> *

Methods

from :: NodeId -> Rep NodeId x

to :: Rep NodeId x -> NodeId

Binary NodeId

Methods

put :: NodeId -> Put

get :: Get NodeId

putList :: [NodeId] -> Put

NFData NodeId

Methods

rnf :: NodeId -> ()

Hashable NodeId

Methods

hashWithSalt :: Int -> NodeId -> Int

hash :: NodeId -> Int

type Rep NodeId

type Rep NodeId = D1 (MetaData "NodeId" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" True) (C1 (MetaCons "NodeId" PrefixI True) (S1 (MetaSel (Just Symbol "nodeAddress") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EndPointAddress)))

data LocalProcessId

A local process ID consists of a seed which distinguishes processes from different instances of the same local node and a counter

Constructors

LocalProcessId

Fields

• lpidUnique :: !Int32
• lpidCounter :: !Int32

Instances

Eq LocalProcessId

Methods

(==) :: LocalProcessId -> LocalProcessId -> Bool

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

Data LocalProcessId

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LocalProcessId -> c LocalProcessId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LocalProcessId

toConstr :: LocalProcessId -> Constr

dataTypeOf :: LocalProcessId -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LocalProcessId)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalProcessId)

gmapT :: (forall b. Data b => b -> b) -> LocalProcessId -> LocalProcessId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LocalProcessId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LocalProcessId -> r

gmapQ :: (forall d. Data d => d -> u) -> LocalProcessId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LocalProcessId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LocalProcessId -> m LocalProcessId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalProcessId -> m LocalProcessId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalProcessId -> m LocalProcessId

Ord LocalProcessId

Methods

compare :: LocalProcessId -> LocalProcessId -> Ordering

(<) :: LocalProcessId -> LocalProcessId -> Bool

(<=) :: LocalProcessId -> LocalProcessId -> Bool

(>) :: LocalProcessId -> LocalProcessId -> Bool

(>=) :: LocalProcessId -> LocalProcessId -> Bool

max :: LocalProcessId -> LocalProcessId -> LocalProcessId

min :: LocalProcessId -> LocalProcessId -> LocalProcessId

Show LocalProcessId

Methods

showsPrec :: Int -> LocalProcessId -> ShowS

show :: LocalProcessId -> String

showList :: [LocalProcessId] -> ShowS

Generic LocalProcessId

Associated Types

type Rep LocalProcessId :: * -> *

Methods

from :: LocalProcessId -> Rep LocalProcessId x

to :: Rep LocalProcessId x -> LocalProcessId

Binary LocalProcessId

Methods

put :: LocalProcessId -> Put

get :: Get LocalProcessId

putList :: [LocalProcessId] -> Put

Hashable LocalProcessId

Methods

hashWithSalt :: Int -> LocalProcessId -> Int

hash :: LocalProcessId -> Int

type Rep LocalProcessId

type Rep LocalProcessId = D1 (MetaData "LocalProcessId" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" False) (C1 (MetaCons "LocalProcessId" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "lpidUnique") SourceUnpack SourceStrict DecidedStrict) (Rec0 Int32)) (S1 (MetaSel (Just Symbol "lpidCounter") SourceUnpack SourceStrict DecidedStrict) (Rec0 Int32))))

data ProcessId

Process identifier

Constructors

ProcessId

Fields

• processNodeId :: !NodeId

  The ID of the node the process is running on

• processLocalId :: !LocalProcessId

  Node-local identifier for the process

Instances

Eq ProcessId

Methods

(==) :: ProcessId -> ProcessId -> Bool

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

Data ProcessId

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProcessId -> c ProcessId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ProcessId

toConstr :: ProcessId -> Constr

dataTypeOf :: ProcessId -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ProcessId)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProcessId)

gmapT :: (forall b. Data b => b -> b) -> ProcessId -> ProcessId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProcessId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProcessId -> r

gmapQ :: (forall d. Data d => d -> u) -> ProcessId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProcessId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProcessId -> m ProcessId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcessId -> m ProcessId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcessId -> m ProcessId

Ord ProcessId

Methods

compare :: ProcessId -> ProcessId -> Ordering

(<) :: ProcessId -> ProcessId -> Bool

(<=) :: ProcessId -> ProcessId -> Bool

(>) :: ProcessId -> ProcessId -> Bool

(>=) :: ProcessId -> ProcessId -> Bool

max :: ProcessId -> ProcessId -> ProcessId

min :: ProcessId -> ProcessId -> ProcessId

Show ProcessId

Methods

showsPrec :: Int -> ProcessId -> ShowS

show :: ProcessId -> String

showList :: [ProcessId] -> ShowS

Generic ProcessId

Associated Types

type Rep ProcessId :: * -> *

Methods

from :: ProcessId -> Rep ProcessId x

to :: Rep ProcessId x -> ProcessId

Binary ProcessId

Methods

put :: ProcessId -> Put

get :: Get ProcessId

putList :: [ProcessId] -> Put

NFData ProcessId

Methods

rnf :: ProcessId -> ()

Hashable ProcessId

Methods

hashWithSalt :: Int -> ProcessId -> Int

hash :: ProcessId -> Int

type Rep ProcessId

type Rep ProcessId = D1 (MetaData "ProcessId" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" False) (C1 (MetaCons "ProcessId" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "processNodeId") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 NodeId)) (S1 (MetaSel (Just Symbol "processLocalId") SourceUnpack SourceStrict DecidedStrict) (Rec0 LocalProcessId))))

data Identifier

Union of all kinds of identifiers

Constructors

NodeIdentifier !NodeId

ProcessIdentifier !ProcessId

SendPortIdentifier !SendPortId

Instances

Eq Identifier

Methods

(==) :: Identifier -> Identifier -> Bool

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

Ord Identifier

Methods

compare :: Identifier -> Identifier -> Ordering

(<) :: Identifier -> Identifier -> Bool

(<=) :: Identifier -> Identifier -> Bool

(>) :: Identifier -> Identifier -> Bool

(>=) :: Identifier -> Identifier -> Bool

max :: Identifier -> Identifier -> Identifier

min :: Identifier -> Identifier -> Identifier

Show Identifier

Methods

showsPrec :: Int -> Identifier -> ShowS

show :: Identifier -> String

showList :: [Identifier] -> ShowS

Generic Identifier

Associated Types

type Rep Identifier :: * -> *

Methods

from :: Identifier -> Rep Identifier x

to :: Rep Identifier x -> Identifier

Binary Identifier

Methods

put :: Identifier -> Put

get :: Get Identifier

putList :: [Identifier] -> Put

NFData Identifier

Methods

rnf :: Identifier -> ()

Hashable Identifier

Methods

hashWithSalt :: Int -> Identifier -> Int

hash :: Identifier -> Int

type Rep Identifier

type Rep Identifier = D1 (MetaData "Identifier" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" False) ((:+:) (C1 (MetaCons "NodeIdentifier" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 NodeId))) ((:+:) (C1 (MetaCons "ProcessIdentifier" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 ProcessId))) (C1 (MetaCons "SendPortIdentifier" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 SendPortId)))))

nodeOf :: Identifier -> NodeId

firstNonReservedProcessId :: Int32

nullProcessId :: NodeId -> ProcessId

Local nodes and processes

data LocalNode

Local nodes

Constructors

LocalNode

Fields

• localNodeId :: !NodeId

  NodeId of the node

• localEndPoint :: !EndPoint

  The network endpoint associated with this node

• localState :: !(StrictMVar LocalNodeState)

  Local node state

• localCtrlChan :: !(Chan NCMsg)

  Channel for the node controller

• localEventBus :: !MxEventBus

  Internal management event bus

• remoteTable :: !RemoteTable

  Runtime lookup table for supporting closures TODO: this should be part of the CH state, not the local endpoint state

data LocalNodeState

Local node state

Constructors

LocalNodeValid !ValidLocalNodeState

LocalNodeClosed

data ValidLocalNodeState

Constructors

ValidLocalNodeState

Fields

• _localProcesses :: !(Map LocalProcessId LocalProcess)

  Processes running on this node

• _localPidCounter :: !Int32

  Counter to assign PIDs

• _localPidUnique :: !Int32

  The unique value used to create PIDs (so that processes on restarted nodes have new PIDs)

• _localConnections :: !(Map (Identifier, Identifier) (Connection, ImplicitReconnect))

  Outgoing connections

data NodeClosedException

Thrown by some primitives when they notice the node has been closed.

Constructors

NodeClosedException NodeId

Instances

Show NodeClosedException

Methods

showsPrec :: Int -> NodeClosedException -> ShowS

show :: NodeClosedException -> String

showList :: [NodeClosedException] -> ShowS

Exception NodeClosedException

Methods

toException :: NodeClosedException -> SomeException

fromException :: SomeException -> Maybe NodeClosedException

displayException :: NodeClosedException -> String

withValidLocalState :: LocalNode -> (ValidLocalNodeState -> IO r) -> IO r

Wrapper around withMVar that checks that the local node is still in a valid state.

modifyValidLocalState :: LocalNode -> (ValidLocalNodeState -> IO (ValidLocalNodeState, a)) -> IO (Maybe a)

Wrapper around modifyMVar that checks that the local node is still in a valid state.

modifyValidLocalState_ :: LocalNode -> (ValidLocalNodeState -> IO ValidLocalNodeState) -> IO ()

Wrapper around modifyMVar_ that checks that the local node is still in a valid state.

data Tracer

Provides access to the trace controller

Constructors

Tracer

Fields

• tracerPid :: !ProcessId

  Process id for the currently active trace handler

• weakQ :: !(Weak (CQueue Message))

  Weak reference to the tracer controller's mailbox

data MxEventBus

Local system management event bus state

Constructors

MxEventBusInitialising

MxEventBus

Fields

• agent :: !ProcessId

  Process id of the management agent controller process

• tracer :: !Tracer

  Configuration for the local trace controller

• evbuss :: !(Weak (CQueue Message))

  Weak reference to the management agent controller's mailbox

• mxNew :: !(((TChan Message, TChan Message) -> Process ()) -> IO ProcessId)

  API for adding management agents to a running node

data LocalProcess

Processes running on our local node

Constructors

LocalProcess

Fields

• processQueue :: !(CQueue Message)
• processWeakQ :: !(Weak (CQueue Message))
• processId :: !ProcessId
• processState :: !(StrictMVar LocalProcessState)
• processThread :: !ThreadId
• processNode :: !LocalNode

Instances

MonadReader LocalProcess Process

Methods

ask :: Process LocalProcess

local :: (LocalProcess -> LocalProcess) -> Process a -> Process a

reader :: (LocalProcess -> a) -> Process a

data LocalProcessState

Local process state

Constructors

LocalProcessState

Fields

• _monitorCounter :: !Int32
• _spawnCounter :: !Int32
• _channelCounter :: !Int32
• _typedChannels :: !(Map LocalSendPortId TypedChannel)

newtype Process a

The Cloud Haskell Process type

Constructors

Process

Fields

• unProcess :: ReaderT LocalProcess IO a

Instances

Monad Process

Methods

(>>=) :: Process a -> (a -> Process b) -> Process b

(>>) :: Process a -> Process b -> Process b

return :: a -> Process a

fail :: String -> Process a

Functor Process

Methods

fmap :: (a -> b) -> Process a -> Process b

(<$) :: a -> Process b -> Process a

MonadFix Process

Methods

mfix :: (a -> Process a) -> Process a

Applicative Process

Methods

pure :: a -> Process a

(<*>) :: Process (a -> b) -> Process a -> Process b

(*>) :: Process a -> Process b -> Process b

(<*) :: Process a -> Process b -> Process a

MonadIO Process

Methods

liftIO :: IO a -> Process a

MonadThrow Process

Methods

throwM :: Exception e => e -> Process a

MonadCatch Process

Methods

catch :: Exception e => Process a -> (e -> Process a) -> Process a

MonadMask Process

Methods

mask :: ((forall a. Process a -> Process a) -> Process b) -> Process b

uninterruptibleMask :: ((forall a. Process a -> Process a) -> Process b) -> Process b

MonadReader LocalProcess Process

Methods

ask :: Process LocalProcess

local :: (LocalProcess -> LocalProcess) -> Process a -> Process a

reader :: (LocalProcess -> a) -> Process a

Serializable b => MkTDict (Process b)

Methods

mkTDict :: String -> Process b -> RemoteRegister

runLocalProcess :: LocalProcess -> Process a -> IO a

Deconstructor for Process (not exported to the public API)

data ImplicitReconnect

Constructors

WithImplicitReconnect

NoImplicitReconnect

Instances

Eq ImplicitReconnect

Methods

(==) :: ImplicitReconnect -> ImplicitReconnect -> Bool

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

Show ImplicitReconnect

Methods

showsPrec :: Int -> ImplicitReconnect -> ShowS

show :: ImplicitReconnect -> String

showList :: [ImplicitReconnect] -> ShowS

Typed channels

type LocalSendPortId = Int32

data SendPortId

A send port is identified by a SendPortId.

You cannot send directly to a SendPortId; instead, use newChan to create a SendPort.

Constructors

SendPortId

Fields

• sendPortProcessId :: !ProcessId

  The ID of the process that will receive messages sent on this port

• sendPortLocalId :: !LocalSendPortId

  Process-local ID of the channel

Instances

Eq SendPortId

Methods

(==) :: SendPortId -> SendPortId -> Bool

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

Ord SendPortId

Methods

compare :: SendPortId -> SendPortId -> Ordering

(<) :: SendPortId -> SendPortId -> Bool

(<=) :: SendPortId -> SendPortId -> Bool

(>) :: SendPortId -> SendPortId -> Bool

(>=) :: SendPortId -> SendPortId -> Bool

max :: SendPortId -> SendPortId -> SendPortId

min :: SendPortId -> SendPortId -> SendPortId

Show SendPortId

Methods

showsPrec :: Int -> SendPortId -> ShowS

show :: SendPortId -> String

showList :: [SendPortId] -> ShowS

Generic SendPortId

Associated Types

type Rep SendPortId :: * -> *

Methods

from :: SendPortId -> Rep SendPortId x

to :: Rep SendPortId x -> SendPortId

Binary SendPortId

Methods

put :: SendPortId -> Put

get :: Get SendPortId

putList :: [SendPortId] -> Put

NFData SendPortId

Methods

rnf :: SendPortId -> ()

Hashable SendPortId

Methods

hashWithSalt :: Int -> SendPortId -> Int

hash :: SendPortId -> Int

type Rep SendPortId

type Rep SendPortId = D1 (MetaData "SendPortId" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" False) (C1 (MetaCons "SendPortId" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "sendPortProcessId") SourceUnpack SourceStrict DecidedStrict) (Rec0 ProcessId)) (S1 (MetaSel (Just Symbol "sendPortLocalId") SourceUnpack SourceStrict DecidedStrict) (Rec0 LocalSendPortId))))

data TypedChannel

Constructors

Serializable a => TypedChannel (Weak (TQueue a))

newtype SendPort a

The send send of a typed channel (serializable)

Constructors

SendPort

Fields

• sendPortId :: SendPortId

  The (unique) ID of this send port

Instances

Eq (SendPort a)

Methods

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

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

Ord (SendPort a)

Methods

compare :: SendPort a -> SendPort a -> Ordering

(<) :: SendPort a -> SendPort a -> Bool

(<=) :: SendPort a -> SendPort a -> Bool

(>) :: SendPort a -> SendPort a -> Bool

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

max :: SendPort a -> SendPort a -> SendPort a

min :: SendPort a -> SendPort a -> SendPort a

Show (SendPort a)

Methods

showsPrec :: Int -> SendPort a -> ShowS

show :: SendPort a -> String

showList :: [SendPort a] -> ShowS

Generic (SendPort a)

Associated Types

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

Methods

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

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

Serializable a => Binary (SendPort a)

Methods

put :: SendPort a -> Put

get :: Get (SendPort a)

putList :: [SendPort a] -> Put

NFData a => NFData (SendPort a)

Methods

rnf :: SendPort a -> ()

Hashable a => Hashable (SendPort a)

Methods

hashWithSalt :: Int -> SendPort a -> Int

hash :: SendPort a -> Int

type Rep (SendPort a)

type Rep (SendPort a) = D1 (MetaData "SendPort" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" True) (C1 (MetaCons "SendPort" PrefixI True) (S1 (MetaSel (Just Symbol "sendPortId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SendPortId)))

newtype ReceivePort a

The receive end of a typed channel (not serializable)

Note that ReceivePort implements Functor, Applicative, Alternative and Monad. This is especially useful when merging receive ports.

Constructors

ReceivePort

Fields

• receiveSTM :: STM a

Instances

Monad ReceivePort

Methods

(>>=) :: ReceivePort a -> (a -> ReceivePort b) -> ReceivePort b

(>>) :: ReceivePort a -> ReceivePort b -> ReceivePort b

return :: a -> ReceivePort a

fail :: String -> ReceivePort a

Functor ReceivePort

Methods

fmap :: (a -> b) -> ReceivePort a -> ReceivePort b

(<$) :: a -> ReceivePort b -> ReceivePort a

Applicative ReceivePort

Methods

pure :: a -> ReceivePort a

(<*>) :: ReceivePort (a -> b) -> ReceivePort a -> ReceivePort b

(*>) :: ReceivePort a -> ReceivePort b -> ReceivePort b

(<*) :: ReceivePort a -> ReceivePort b -> ReceivePort a

Alternative ReceivePort

Methods

empty :: ReceivePort a

(<|>) :: ReceivePort a -> ReceivePort a -> ReceivePort a

some :: ReceivePort a -> ReceivePort [a]

many :: ReceivePort a -> ReceivePort [a]

Messages

data Message

Messages consist of their typeRep fingerprint and their encoding

Constructors

EncodedMessage

Fields

• messageFingerprint :: !Fingerprint
• messageEncoding :: !ByteString

Serializable a => UnencodedMessage

Fields

• messageFingerprint :: !Fingerprint
• messagePayload :: !a

Instances

Show Message

Methods

showsPrec :: Int -> Message -> ShowS

show :: Message -> String

showList :: [Message] -> ShowS

Binary Message

Methods

put :: Message -> Put

get :: Get Message

putList :: [Message] -> Put

NFData Message

Methods

rnf :: Message -> ()

isEncoded :: Message -> Bool

internal use only.

createMessage :: Serializable a => a -> Message

Turn any serialiable term into a message

createUnencodedMessage :: Serializable a => a -> Message

Turn any serializable term into an unencoded/local message

unsafeCreateUnencodedMessage :: Serializable a => a -> Message

Turn any serializable term into an unencodede/local message, without evalutaing it! This is a dangerous business.

messageToPayload :: Message -> [ByteString]

Serialize a message

payloadToMessage :: [ByteString] -> Message

Deserialize a message

Node controller user-visible data types

data MonitorRef

MonitorRef is opaque for regular Cloud Haskell processes

Constructors

MonitorRef

Fields

• monitorRefIdent :: !Identifier

  ID of the entity to be monitored

• monitorRefCounter :: !Int32

  Unique to distinguish multiple monitor requests by the same process

Instances

Eq MonitorRef

Methods

(==) :: MonitorRef -> MonitorRef -> Bool

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

Ord MonitorRef

Methods

compare :: MonitorRef -> MonitorRef -> Ordering

(<) :: MonitorRef -> MonitorRef -> Bool

(<=) :: MonitorRef -> MonitorRef -> Bool

(>) :: MonitorRef -> MonitorRef -> Bool

(>=) :: MonitorRef -> MonitorRef -> Bool

max :: MonitorRef -> MonitorRef -> MonitorRef

min :: MonitorRef -> MonitorRef -> MonitorRef

Show MonitorRef

Methods

showsPrec :: Int -> MonitorRef -> ShowS

show :: MonitorRef -> String

showList :: [MonitorRef] -> ShowS

Generic MonitorRef

Associated Types

type Rep MonitorRef :: * -> *

Methods

from :: MonitorRef -> Rep MonitorRef x

to :: Rep MonitorRef x -> MonitorRef

Binary MonitorRef

Methods

put :: MonitorRef -> Put

get :: Get MonitorRef

putList :: [MonitorRef] -> Put

NFData MonitorRef

Methods

rnf :: MonitorRef -> ()

Hashable MonitorRef

Methods

hashWithSalt :: Int -> MonitorRef -> Int

hash :: MonitorRef -> Int

type Rep MonitorRef

type Rep MonitorRef = D1 (MetaData "MonitorRef" "Control.Distributed.Process.Internal.Types" "distributed-process-0.6.6-C2Hr50TwUgZDi5s2rjWzWs" False) (C1 (MetaCons "MonitorRef" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "monitorRefIdent") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Identifier)) (S1 (MetaSel (Just Symbol "monitorRefCounter") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int32))))

data ProcessMonitorNotification

Message sent by process monitors

Constructors

ProcessMonitorNotification !MonitorRef !ProcessId !DiedReason

Instances

Show ProcessMonitorNotification

Methods

showsPrec :: Int -> ProcessMonitorNotification -> ShowS

show :: ProcessMonitorNotification -> String

showList :: [ProcessMonitorNotification] -> ShowS

Binary ProcessMonitorNotification

Methods

put :: ProcessMonitorNotification -> Put

get :: Get ProcessMonitorNotification

putList :: [ProcessMonitorNotification] -> Put

data NodeMonitorNotification

Message sent by node monitors

Constructors

NodeMonitorNotification !MonitorRef !NodeId !DiedReason

Instances

Show NodeMonitorNotification

Methods

showsPrec :: Int -> NodeMonitorNotification -> ShowS

show :: NodeMonitorNotification -> String

showList :: [NodeMonitorNotification] -> ShowS

Binary NodeMonitorNotification

Methods

put :: NodeMonitorNotification -> Put

get :: Get NodeMonitorNotification

putList :: [NodeMonitorNotification] -> Put

data PortMonitorNotification

Message sent by channel (port) monitors

Constructors

PortMonitorNotification !MonitorRef !SendPortId !DiedReason

Instances

Show PortMonitorNotification

Methods

showsPrec :: Int -> PortMonitorNotification -> ShowS

show :: PortMonitorNotification -> String

showList :: [PortMonitorNotification] -> ShowS

Binary PortMonitorNotification

Methods

put :: PortMonitorNotification -> Put

get :: Get PortMonitorNotification

putList :: [PortMonitorNotification] -> Put

data ProcessExitException

Internal exception thrown indirectly by exit

Constructors

ProcessExitException !ProcessId !Message

Instances

Show ProcessExitException

Methods

showsPrec :: Int -> ProcessExitException -> ShowS

show :: ProcessExitException -> String

showList :: [ProcessExitException] -> ShowS

Exception ProcessExitException

Methods

toException :: ProcessExitException -> SomeException

fromException :: SomeException -> Maybe ProcessExitException

displayException :: ProcessExitException -> String

data ProcessLinkException

Exceptions thrown when a linked process dies

Constructors

ProcessLinkException !ProcessId !DiedReason

Instances

Show ProcessLinkException

Methods

showsPrec :: Int -> ProcessLinkException -> ShowS

show :: ProcessLinkException -> String

showList :: [ProcessLinkException] -> ShowS

Exception ProcessLinkException

Methods

toException :: ProcessLinkException -> SomeException

fromException :: SomeException -> Maybe ProcessLinkException

displayException :: ProcessLinkException -> String

data NodeLinkException

Exception thrown when a linked node dies

Constructors

NodeLinkException !NodeId !DiedReason

Instances

Show NodeLinkException

Methods

showsPrec :: Int -> NodeLinkException -> ShowS

show :: NodeLinkException -> String

showList :: [NodeLinkException] -> ShowS

Exception NodeLinkException

Methods

toException :: NodeLinkException -> SomeException

fromException :: SomeException -> Maybe NodeLinkException

displayException :: NodeLinkException -> String

data PortLinkException

Exception thrown when a linked channel (port) dies

Constructors

PortLinkException !SendPortId !DiedReason

Instances

Show PortLinkException

Methods

showsPrec :: Int -> PortLinkException -> ShowS

show :: PortLinkException -> String

showList :: [PortLinkException] -> ShowS

Exception PortLinkException

Methods

toException :: PortLinkException -> SomeException

fromException :: SomeException -> Maybe PortLinkException

displayException :: PortLinkException -> String

data ProcessRegistrationException

Exception thrown when a process attempts to register a process under an already-registered name or to unregister a name that hasn't been registered. Returns the name and the identifier of the process that owns it, if any.

Constructors

ProcessRegistrationException !String !(Maybe ProcessId)

Instances

Show ProcessRegistrationException

Methods

showsPrec :: Int -> ProcessRegistrationException -> ShowS

show :: ProcessRegistrationException -> String

showList :: [ProcessRegistrationException] -> ShowS

Exception ProcessRegistrationException

Methods

toException :: ProcessRegistrationException -> SomeException

fromException :: SomeException -> Maybe ProcessRegistrationException

displayException :: ProcessRegistrationException -> String

data DiedReason

Why did a process die?

Constructors

DiedNormal

Normal termination

DiedException !String

The process exited with an exception (provided as String because Exception does not implement Binary)

DiedDisconnect

We got disconnected from the process node

DiedNodeDown

The process node died

DiedUnknownId

Invalid (processnodechannel) identifier

Instances

Eq DiedReason

Methods

(==) :: DiedReason -> DiedReason -> Bool

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

Show DiedReason

Methods

showsPrec :: Int -> DiedReason -> ShowS

show :: DiedReason -> String

showList :: [DiedReason] -> ShowS

Binary DiedReason

Methods

put :: DiedReason -> Put

get :: Get DiedReason

putList :: [DiedReason] -> Put

NFData DiedReason

Methods

rnf :: DiedReason -> ()

newtype DidUnmonitor

(Asynchronous) reply from unmonitor

Constructors

DidUnmonitor MonitorRef

Instances

Binary DidUnmonitor

Methods

put :: DidUnmonitor -> Put

get :: Get DidUnmonitor

putList :: [DidUnmonitor] -> Put

newtype DidUnlinkProcess

(Asynchronous) reply from unlink

Constructors

DidUnlinkProcess ProcessId

Instances

Binary DidUnlinkProcess

Methods

put :: DidUnlinkProcess -> Put

get :: Get DidUnlinkProcess

putList :: [DidUnlinkProcess] -> Put

newtype DidUnlinkNode

(Asynchronous) reply from unlinkNode

Constructors

DidUnlinkNode NodeId

Instances

Binary DidUnlinkNode

Methods

put :: DidUnlinkNode -> Put

get :: Get DidUnlinkNode

putList :: [DidUnlinkNode] -> Put

newtype DidUnlinkPort

(Asynchronous) reply from unlinkPort

Constructors

DidUnlinkPort SendPortId

Instances

Binary DidUnlinkPort

Methods

put :: DidUnlinkPort -> Put

get :: Get DidUnlinkPort

putList :: [DidUnlinkPort] -> Put

newtype SpawnRef

SpawnRef are used to return pids of spawned processes

Constructors

SpawnRef Int32

Instances

Eq SpawnRef

Methods

(==) :: SpawnRef -> SpawnRef -> Bool

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

Show SpawnRef

Methods

showsPrec :: Int -> SpawnRef -> ShowS

show :: SpawnRef -> String

showList :: [SpawnRef] -> ShowS

Binary SpawnRef

Methods

put :: SpawnRef -> Put

get :: Get SpawnRef

putList :: [SpawnRef] -> Put

data DidSpawn

(Asynchronius) reply from spawn

Constructors

DidSpawn SpawnRef ProcessId

Instances

Show DidSpawn

Methods

showsPrec :: Int -> DidSpawn -> ShowS

show :: DidSpawn -> String

showList :: [DidSpawn] -> ShowS

Binary DidSpawn

Methods

put :: DidSpawn -> Put

get :: Get DidSpawn

putList :: [DidSpawn] -> Put

data WhereIsReply

(Asynchronous) reply from whereis

Constructors

WhereIsReply String (Maybe ProcessId)

Instances

Show WhereIsReply

Methods

showsPrec :: Int -> WhereIsReply -> ShowS

show :: WhereIsReply -> String

showList :: [WhereIsReply] -> ShowS

Binary WhereIsReply

Methods

put :: WhereIsReply -> Put

get :: Get WhereIsReply

putList :: [WhereIsReply] -> Put

data RegisterReply

(Asynchronous) reply from register and unregister

Constructors

RegisterReply String Bool (Maybe ProcessId)

Instances

Show RegisterReply

Methods

showsPrec :: Int -> RegisterReply -> ShowS

show :: RegisterReply -> String

showList :: [RegisterReply] -> ShowS

Binary RegisterReply

Methods

put :: RegisterReply -> Put

get :: Get RegisterReply

putList :: [RegisterReply] -> Put

data ProcessInfo

Provide information about a running process

Constructors

ProcessInfo

Fields

• infoNode :: NodeId
• infoRegisteredNames :: [String]
• infoMessageQueueLength :: Int
• infoMonitors :: [(ProcessId, MonitorRef)]
• infoLinks :: [ProcessId]

Instances

Eq ProcessInfo

Methods

(==) :: ProcessInfo -> ProcessInfo -> Bool

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

Show ProcessInfo

Methods

showsPrec :: Int -> ProcessInfo -> ShowS

show :: ProcessInfo -> String

showList :: [ProcessInfo] -> ShowS

Binary ProcessInfo

Methods

put :: ProcessInfo -> Put

get :: Get ProcessInfo

putList :: [ProcessInfo] -> Put

data ProcessInfoNone

Constructors

ProcessInfoNone DiedReason

Instances

Show ProcessInfoNone

Methods

showsPrec :: Int -> ProcessInfoNone -> ShowS

show :: ProcessInfoNone -> String

showList :: [ProcessInfoNone] -> ShowS

Binary ProcessInfoNone

Methods

put :: ProcessInfoNone -> Put

get :: Get ProcessInfoNone

putList :: [ProcessInfoNone] -> Put

data NodeStats

Constructors

NodeStats

Fields

• nodeStatsNode :: NodeId
• nodeStatsRegisteredNames :: Int
• nodeStatsMonitors :: Int
• nodeStatsLinks :: Int
• nodeStatsProcesses :: Int

Instances

Eq NodeStats

Methods

(==) :: NodeStats -> NodeStats -> Bool

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

Show NodeStats

Methods

showsPrec :: Int -> NodeStats -> ShowS

show :: NodeStats -> String

showList :: [NodeStats] -> ShowS

Binary NodeStats

Methods

put :: NodeStats -> Put

get :: Get NodeStats

putList :: [NodeStats] -> Put

Node controller internal data types

data NCMsg

Messages to the node controller

Constructors

NCMsg

Fields

• ctrlMsgSender :: !Identifier
• ctrlMsgSignal :: !ProcessSignal

Instances

Show NCMsg

Methods

showsPrec :: Int -> NCMsg -> ShowS

show :: NCMsg -> String

showList :: [NCMsg] -> ShowS

Binary NCMsg

Methods

put :: NCMsg -> Put

get :: Get NCMsg

putList :: [NCMsg] -> Put

data ProcessSignal

Signals to the node controller (see NCMsg)

Constructors

Link !Identifier

Unlink !Identifier

Monitor !MonitorRef

Unmonitor !MonitorRef

Died Identifier !DiedReason

Spawn !(Closure (Process ())) !SpawnRef

WhereIs !String

Register !String !NodeId !(Maybe ProcessId) !Bool

NamedSend !String !Message

UnreliableSend !LocalProcessId !Message

LocalSend !ProcessId !Message

LocalPortSend !SendPortId !Message

Kill !ProcessId !String

Exit !ProcessId !Message

GetInfo !ProcessId

SigShutdown

GetNodeStats !NodeId

Instances

Show ProcessSignal

Methods

showsPrec :: Int -> ProcessSignal -> ShowS

show :: ProcessSignal -> String

showList :: [ProcessSignal] -> ShowS

Binary ProcessSignal

Methods

put :: ProcessSignal -> Put

get :: Get ProcessSignal

putList :: [ProcessSignal] -> Put

Accessors

localProcesses :: Accessor ValidLocalNodeState (Map LocalProcessId LocalProcess)

localPidCounter :: Accessor ValidLocalNodeState Int32

localPidUnique :: Accessor ValidLocalNodeState Int32

localConnections :: Accessor ValidLocalNodeState (Map (Identifier, Identifier) (Connection, ImplicitReconnect))

localProcessWithId :: LocalProcessId -> Accessor ValidLocalNodeState (Maybe LocalProcess)

localConnectionBetween :: Identifier -> Identifier -> Accessor ValidLocalNodeState (Maybe (Connection, ImplicitReconnect))

monitorCounter :: Accessor LocalProcessState Int32

spawnCounter :: Accessor LocalProcessState Int32

channelCounter :: Accessor LocalProcessState LocalSendPortId

typedChannels :: Accessor LocalProcessState (Map LocalSendPortId TypedChannel)

typedChannelWithId :: LocalSendPortId -> Accessor LocalProcessState (Maybe TypedChannel)

Utilities

forever' :: Monad m => m a -> m b