Safe Haskell	None

Control.Distributed.Process.Internal.Types

Contents

Node and process identifiers
Local nodes and processes
Typed channels
Closures
Messages
Node controller user-visible data types
Node controller internal data types
MessageT monad
Accessors

Description

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.

Synopsis

Node and process identifiers

newtype NodeId Source

Node identifier

Constructors

NodeId
Fields nodeAddress :: EndPointAddress

Instances

Eq NodeId
Ord NodeId
Show NodeId
Binary NodeId

data LocalProcessId Source

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
Ord LocalProcessId
Show LocalProcessId
Typeable LocalProcessId
Binary LocalProcessId

data ProcessId Source

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
Ord ProcessId
Show ProcessId
Typeable ProcessId
Binary ProcessId

data Identifier Source

Union of all kinds of identifiers

Constructors

NodeIdentifier NodeId
ProcessIdentifier ProcessId
SendPortIdentifier SendPortId

Instances

Eq Identifier
Ord Identifier
Show Identifier
Binary Identifier

nodeOf :: Identifier -> NodeId Source

Local nodes and processes

data LocalNode Source

Local nodes

Constructors

LocalNode
Fields localNodeId :: NodeId `NodeId` of the node localEndPoint :: EndPoint The network endpoint associated with this node localState :: MVar LocalNodeState Local node state localCtrlChan :: Chan NCMsg Channel for the node controller remoteTable :: RemoteTable Runtime lookup table for supporting closures TODO: this should be part of the CH state, not the local endpoint state

data LocalNodeState Source

Local node state

Constructors

LocalNodeState
Fields _localProcesses :: Map LocalProcessId LocalProcess _localPidCounter :: Int32 _localPidUnique :: Int32

data LocalProcess Source

Processes running on our local node

Constructors

LocalProcess
Fields processQueue :: CQueue Message processId :: ProcessId processState :: MVar LocalProcessState processThread :: ThreadId

Instances

MonadReader LocalProcess Process

data LocalProcessState Source

Local process state

Constructors

LocalProcessState
Fields _monitorCounter :: Int32 _spawnCounter :: Int32 _channelCounter :: Int32 _typedChannels :: Map LocalSendPortId TypedChannel

newtype Process a Source

The Cloud Haskell Process type

Constructors

Process
Fields unProcess :: ReaderT LocalProcess (MessageT IO) a

Instances

Monad Process
Functor Process
Typeable1 Process
Applicative Process
MonadIO Process
MonadReader LocalProcess Process

procMsg :: MessageT IO a -> Process aSource

Typed channels

type LocalSendPortId = Int32 Source

data SendPortId Source

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
Ord SendPortId
Show SendPortId
Binary SendPortId

data TypedChannel Source

Constructors

forall a . Serializable a => TypedChannel (TChan a)

newtype SendPort a Source

The send send of a typed channel (serializable)

Constructors

SendPort
Fields sendPortId :: SendPortId The (unique) ID of this send port

Instances

Typeable1 SendPort
Eq (SendPort a)
Ord (SendPort a)
Show (SendPort a)
Binary (SendPort a)

data ReceivePort a Source

The receive end of a typed channel (not serializable)

Constructors

ReceivePortSingle (TChan a)	A single receive port
ReceivePortBiased [ReceivePort a]	A left-biased combination of receive ports
ReceivePortRR (TVar [ReceivePort a])	A round-robin combination of receive ports

Closures

newtype Static a Source

A static value is one that is bound at top-level.

Constructors

Static StaticLabel

Instances

Typeable1 Static
Show (Static a)

data Closure a Source

A closure is a static value and an encoded environment

Constructors

Closure (Static (ByteString -> a)) ByteString

Instances

Typeable1 Closure
Show (Closure a)
Binary (Closure a)

data RemoteTable Source

Used to fake static (see paper)

Constructors

RemoteTable
Fields _remoteTableLabels :: Map String Dynamic If the user creates a closure of type `a -> Closure b` from a function `f : a -> b`, then `_remoteTableLabels` should have an entry for f of type `ByteString -> b` (basically, `f . encode`) _remoteTableDicts :: Map TypeRep RuntimeSerializableSupport Runtime counterpart to SerializableDict

data SerializableDict a whereSource

Reification of Serializable (see Control.Distributed.Process.Closure)

Constructors

SerializableDict :: Serializable a => SerializableDict a

Instances

Typeable1 SerializableDict

data RuntimeSerializableSupport Source

Runtime support for implementing polymorphic functions with a Serializable qualifier (sendClosure, returnClosure, ..).

We don't attempt to keep this minimal, but instead just add functions as convenient. This will be replaced anyway once static has been implemented.

Constructors

RuntimeSerializableSupport
Fields rssSend :: Dynamic rssReturn :: Dynamic rssExpect :: Dynamic

Messages

data Message Source

Messages consist of their typeRep fingerprint and their encoding

Constructors

Message
Fields messageFingerprint :: Fingerprint messageEncoding :: ByteString

Instances

Show Message

createMessage :: Serializable a => a -> Message Source

Turn any serialiable term into a message

messageToPayload :: Message -> [ByteString]Source

Serialize a message

payloadToMessage :: [ByteString] -> Message Source

Deserialize a message

Node controller user-visible data types

data MonitorRef Source

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
Ord MonitorRef
Show MonitorRef
Binary MonitorRef

data ProcessMonitorNotification Source

Message sent by process monitors

Constructors

ProcessMonitorNotification MonitorRef ProcessId DiedReason

Instances

Show ProcessMonitorNotification
Typeable ProcessMonitorNotification
Binary ProcessMonitorNotification

data NodeMonitorNotification Source

Message sent by node monitors

Constructors

NodeMonitorNotification MonitorRef NodeId DiedReason

Instances

Show NodeMonitorNotification
Typeable NodeMonitorNotification
Binary NodeMonitorNotification

data PortMonitorNotification Source

Message sent by channel (port) monitors

Constructors

PortMonitorNotification MonitorRef SendPortId DiedReason

Instances

Show PortMonitorNotification
Typeable PortMonitorNotification
Binary PortMonitorNotification

data ProcessLinkException Source

Exceptions thrown when a linked process dies

Constructors

ProcessLinkException ProcessId DiedReason

Instances

Show ProcessLinkException
Typeable ProcessLinkException
Exception ProcessLinkException

data NodeLinkException Source

Exception thrown when a linked node dies

Constructors

NodeLinkException NodeId DiedReason

Instances

Show NodeLinkException
Typeable NodeLinkException
Exception NodeLinkException

data PortLinkException Source

Exception thrown when a linked channel (port) dies

Constructors

PortLinkException SendPortId DiedReason

Instances

Show PortLinkException
Typeable PortLinkException
Exception PortLinkException

data DiedReason Source

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
Show DiedReason
Binary DiedReason

newtype DidUnmonitor Source

(Asynchronous) reply from unmonitor

Constructors

DidUnmonitor MonitorRef

Instances

Typeable DidUnmonitor
Binary DidUnmonitor

newtype DidUnlinkProcess Source

(Asynchronous) reply from unlink

Constructors

DidUnlinkProcess ProcessId

Instances

Typeable DidUnlinkProcess
Binary DidUnlinkProcess

newtype DidUnlinkNode Source

(Asynchronous) reply from unlinkNode

Constructors

DidUnlinkNode NodeId

Instances

Typeable DidUnlinkNode
Binary DidUnlinkNode

newtype DidUnlinkPort Source

(Asynchronous) reply from unlinkPort

Constructors

DidUnlinkPort SendPortId

Instances

Typeable DidUnlinkPort
Binary DidUnlinkPort

newtype SpawnRef Source

SpawnRef are used to return pids of spawned processes

Constructors

SpawnRef Int32

Instances

Eq SpawnRef
Show SpawnRef
Typeable SpawnRef
Binary SpawnRef

data DidSpawn Source

(Asynchronius) reply from spawn

Constructors

DidSpawn SpawnRef ProcessId

Instances

Show DidSpawn
Typeable DidSpawn
Binary DidSpawn

data WhereIsReply Source

(Asynchronous) reply from whereis

Constructors

WhereIsReply String (Maybe ProcessId)

Instances

Show WhereIsReply
Typeable WhereIsReply
Binary WhereIsReply

Node controller internal data types

data NCMsg Source

Messages to the node controller

Constructors

NCMsg
Fields ctrlMsgSender :: Identifier ctrlMsgSignal :: ProcessSignal

Instances

Show NCMsg
Binary NCMsg

data ProcessSignal Source

Signals to the node controller (see NCMsg)

Instances

Show ProcessSignal
Binary ProcessSignal

MessageT monad

newtype MessageT m a Source

Constructors

MessageT
Fields unMessageT :: StateT MessageState m a

Instances

Monad m => MonadState MessageState (MessageT m)
Monad m => Monad (MessageT m)
Functor m => Functor (MessageT m)
(Monad m, Functor m) => Applicative (MessageT m)
MonadIO m => MonadIO (MessageT m)

data MessageState Source

Constructors

MessageState
Fields messageLocalNode :: LocalNode _messageConnections :: Map Identifier Connection

Instances

Monad m => MonadState MessageState (MessageT m)

Accessors

localProcesses :: Accessor LocalNodeState (Map LocalProcessId LocalProcess)Source

localPidCounter :: Accessor LocalNodeState Int32 Source

localPidUnique :: Accessor LocalNodeState Int32 Source

localProcessWithId :: LocalProcessId -> Accessor LocalNodeState (Maybe LocalProcess)Source

monitorCounter :: Accessor LocalProcessState Int32 Source

spawnCounter :: Accessor LocalProcessState Int32 Source

channelCounter :: Accessor LocalProcessState LocalSendPortId Source

typedChannels :: Accessor LocalProcessState (Map LocalSendPortId TypedChannel)Source

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

remoteTableLabels :: Accessor RemoteTable (Map String Dynamic)Source

remoteTableDicts :: Accessor RemoteTable (Map TypeRep RuntimeSerializableSupport)Source

remoteTableLabel :: String -> Accessor RemoteTable (Maybe Dynamic)Source

remoteTableDict :: TypeRep -> Accessor RemoteTable (Maybe RuntimeSerializableSupport)Source

UserStatic String
ClosureReturn
ClosureSend
ClosureExpect
ClosureApply
ClosureConst
ClosureUnit
CpId
CpComp
CpFirst
CpSwap
CpCopy
CpLeft
CpMirror
CpUntag
CpApply

Link Identifier
Unlink Identifier
Monitor MonitorRef
Unmonitor MonitorRef
Died Identifier DiedReason
Spawn (Closure (Process ())) SpawnRef
WhereIs String
Register String (Maybe ProcessId)
NamedSend String Message