Copyright	(c) Tim Watson 2013, Parallel Scientific (Jeff Epstein) 2012
License	BSD3 (see the file LICENSE)
Safe Haskell	None
Language	Haskell98

Control.Distributed.Process.Extras.Internal.Primitives

Contents

General Purpose Process Addressing
Spawning and Linking
Registered Processes
Selective Receive/Matching
General Utilities
Remote Table

Description

Maintainers : Jeff Epstein, Tim Watson Stability : experimental Portability : non-portable (requires concurrency)

This module provides a set of additional primitives that add functionality to the basic Cloud Haskell APIs.

Synopsis

General Purpose Process Addressing

class (Resolvable a, Routable a) => Addressable a Source

Instances

(Resolvable a, Routable a) => Addressable a Source

class Routable a where Source

Provides a unified API for addressing processes.

Minimal complete definition

sendTo, unsafeSendTo

Methods

sendTo :: Serializable m => a -> m -> Process () Source

Send a message to the target asynchronously

unsafeSendTo :: NFSerializable m => a -> m -> Process () Source

Send some NFData message to the target asynchronously, forcing evaluation (i.e., deepseq) beforehand.

unresolvableMessage :: a -> String Source

Unresolvable Addressable Message

Instances

Routable String Source
Resolvable a => Routable a Source
Routable ProcessId Source
Routable Recipient Source
Routable (Message -> Process ()) Source
Routable (NodeId, String) Source

class Resolvable a where Source

Class of things that can be resolved to a ProcessId.

Methods

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

Resolve the reference to a process id, or Nothing if resolution fails

Instances

Resolvable String Source
Resolvable ProcessId Source
Resolvable Recipient Source
Resolvable LogClient Source
Resolvable (NodeId, String) Source

class Linkable a where Source

Class of things to which a Process can link itself.

Methods

linkTo :: a -> Process () Source

Create a link with the supplied object.

class Killable a where Source

Class of things that can be killed (or instructed to exit).

Methods

killProc :: a -> String -> Process () Source

exitProc :: Serializable m => a -> m -> Process () Source

Instances

Resolvable r => Killable r Source
Killable ProcessId Source

Spawning and Linking

spawnSignalled :: Process a -> (a -> Process ()) -> Process ProcessId Source

Spawn a new (local) process. This variant takes an initialisation action and a secondary expression from the result of the initialisation to Process (). The spawn operation synchronises on the completion of the before action, such that the calling process is guaranteed to only see the newly spawned ProcessId once the initialisation has successfully completed.

spawnLinkLocal :: Process () -> Process ProcessId Source

Node local version of spawnLink. Note that this is just the sequential composition of spawn and link. (The Unified semantics that underlies Cloud Haskell does not even support a synchronous link operation)

spawnMonitorLocal :: Process () -> Process (ProcessId, MonitorRef) Source

Like spawnLinkLocal, but monitors the spawned process.

linkOnFailure :: ProcessId -> Process () Source

CH's link primitive, unlike Erlang's, will trigger when the target process dies for any reason. This function has semantics like Erlang's: it will trigger ProcessLinkException only when the target dies abnormally.

Registered Processes

whereisRemote :: NodeId -> String -> Process (Maybe ProcessId) Source

A synchronous version of whereis, this relies on call to perform the relevant monitoring of the remote node.

whereisOrStart :: String -> Process () -> Process ProcessId Source

Returns the pid of the process that has been registered under the given name. This refers to a local, per-node registration, not global registration. If that name is unregistered, a process is started. This is a handy way to start per-node named servers.

whereisOrStartRemote :: NodeId -> String -> Closure (Process ()) -> Process (Maybe ProcessId) Source

A remote equivalent of whereisOrStart. It deals with the node registry on the given node, and the process, if it needs to be started, will run on that node. If the node is inaccessible, Nothing will be returned.

Selective Receive/Matching

matchCond :: Serializable a => (a -> Maybe (Process b)) -> Match b Source

An alternative to matchIf that allows both predicate and action to be expressed in one parameter.

awaitResponse :: Addressable a => a -> [Match (Either ExitReason b)] -> Process (Either ExitReason b) Source

Safe (i.e., monitored) waiting on an expected response/message.

General Utilities

times :: Int -> Process () -> Process () Source

Apply the supplied expression n times

monitor :: Resolvable a => a -> Process (Maybe MonitorRef) Source

Monitor any Resolvable object.

awaitExit :: Resolvable a => a -> Process () Source

isProcessAlive :: ProcessId -> Process Bool Source

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

Like forever but sans space leak

deliver :: (Addressable a, Serializable m) => m -> a -> Process () Source

Remote Table

__remoteTable :: RemoteTable -> RemoteTable Source