Transient.Move.Internals

Documentation

data Node

Constructors

Node

Fields

• nodeHost :: HostName
• nodePort :: Int
• connection :: Maybe (MVar Pool)
• nodeServices :: Service

Instances

Eq Node

Methods

(==) :: Node -> Node -> Bool

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

Ord Node

Methods

compare :: Node -> Node -> Ordering

(<) :: Node -> Node -> Bool

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

(>) :: Node -> Node -> Bool

(>=) :: Node -> Node -> Bool

max :: Node -> Node -> Node

min :: Node -> Node -> Node

Read Node

Methods

readsPrec :: Int -> ReadS Node

readList :: ReadS [Node]

readPrec :: ReadPrec Node

readListPrec :: ReadPrec [Node]

Show Node

Methods

showsPrec :: Int -> Node -> ShowS

show :: Node -> String

showList :: [Node] -> ShowS

newtype Cloud a

Constructors

Cloud

Fields

• runCloud' :: TransIO a

Instances

Monad Cloud

Methods

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

(>>) :: Cloud a -> Cloud b -> Cloud b

return :: a -> Cloud a

fail :: String -> Cloud a

Functor Cloud

Methods

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

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

Applicative Cloud

Methods

pure :: a -> Cloud a

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

liftA2 :: (a -> b -> c) -> Cloud a -> Cloud b -> Cloud c

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

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

Alternative Cloud

Methods

empty :: Cloud a

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

some :: Cloud a -> Cloud [a]

many :: Cloud a -> Cloud [a]

MonadState EventF Cloud

Methods

get :: Cloud EventF

put :: EventF -> Cloud ()

state :: (EventF -> (a, EventF)) -> Cloud a

(Fractional a, Eq a) => Fractional (Cloud a)

Methods

(/) :: Cloud a -> Cloud a -> Cloud a

recip :: Cloud a -> Cloud a

fromRational :: Rational -> Cloud a

(Eq a, Num a) => Num (Cloud a)

Methods

(+) :: Cloud a -> Cloud a -> Cloud a

(-) :: Cloud a -> Cloud a -> Cloud a

(*) :: Cloud a -> Cloud a -> Cloud a

negate :: Cloud a -> Cloud a

abs :: Cloud a -> Cloud a

signum :: Cloud a -> Cloud a

fromInteger :: Integer -> Cloud a

Monoid a => Monoid (Cloud a)

Methods

mempty :: Cloud a

mappend :: Cloud a -> Cloud a -> Cloud a

mconcat :: [Cloud a] -> Cloud a

runCloud :: Cloud a -> TransIO a

Execute a distributed computation inside a TransIO computation. All the computations in the TransIO monad that enclose the cloud computation must be logged

tlsHooks :: IORef (SData -> ByteString -> IO (), SData -> IO ByteString, Socket -> ByteString -> TransIO (), String -> Socket -> ByteString -> TransIO ())

sendTLSData :: SData -> ByteString -> IO ()

local :: Loggable a => TransIO a -> Cloud a

Means that this computation will be executed in the current node. the result will be logged so the closure will be recovered if the computation is translated to other node by means of primitives like beamTo, forkTo, runAt, teleport, clustered, mclustered etc

runCloudIO :: Typeable a => Cloud a -> IO (Maybe a)

Run a distributed computation inside the IO monad. Enables asynchronous console input (see keep).

runCloudIO' :: Typeable a => Cloud a -> IO (Maybe a)

Run a distributed computation inside the IO monad with no console input.

onAll :: TransIO a -> Cloud a

alternative to local It means that if the computation is translated to other node this will be executed again if this has not been executed inside a local computation.

onAll foo
local foo'
local $ do
      bar
      runCloud $ do
              onAll baz
              runAt node ....
callTo node' .....

Here foo will be executed in node' but foo' bar and baz don't.

However foo bar and baz will e executed in node.

lazy :: TransIO a -> Cloud a

only executes if the result is demanded. It is useful when the conputation result is only used in the remote node, but it is not serializable.

fixRemote :: TransIO b -> Cloud b

executes a non-serilizable action in the remote node, whose result can be used by subsequent remote invocations

fixClosure :: Cloud ()

experimental: subsequent remote invocatioms will send logs to this closure. Therefore logs will be shorter.

Also, non serializable statements before it will not be re-executed

loggedc :: Loggable a => Cloud a -> Cloud a

loggedc' :: Loggable a => Cloud a -> Cloud a

lliftIO :: Loggable a => IO a -> Cloud a

the Cloud monad has no MonadIO instance. `lliftIO= local . liftIO`

localIO :: Loggable a => IO a -> Cloud a

`localIO = lliftIO`

fullStop :: TransIO stop

stop the current computation and does not execute any alternative computation

beamTo :: Node -> Cloud ()

continue the execution in a new node

forkTo :: Node -> Cloud ()

execute in the remote node a process with the same execution state

callTo :: Loggable a => Node -> Cloud a -> Cloud a

open a wormhole to another node and executes an action on it. currently by default it keep open the connection to receive additional requests and responses (streaming)

callTo' :: (Show a, Read a, Typeable a) => Node -> Cloud a -> Cloud a

A connectionless version of callTo for long running remote calls

atRemote :: Loggable a => Cloud a -> Cloud a

Within a connection to a node opened by wormhole, it run the computation in the remote node and return the result back to the original node.

If atRemote is executed in the remote node, then the computation is executed in the original node

wormhole node2 $ do
    t <- atRemote $ do
          r <- foo              -- executed in node2
          s <- atRemote bar r   -- executed in the original node
          baz s                 -- in node2
    bat t                      -- in the original node

runAt :: Loggable a => Node -> Cloud a -> Cloud a

Execute a computation in the node that initiated the connection.

if the sequence of connections is n1 -> n2 -> n3 then `atCallingNode $ atCallingNode foo` in n3 would execute foo in n1, -- while `atRemote $ atRemote foo` would execute it in n3 atCallingNode :: Loggable a => Cloud a -> Cloud a atCallingNode proc= connectCaller $ atRemote proc

synonymous of callTo

single :: TransIO a -> TransIO a

run a single thread with that action for each connection created. When the same action is re-executed within that connection, all the threads generated by the previous execution are killed

  box <-  foo
  r <- runAt node . local . single $ getMailbox box
  localIO $ print r

if foo return differnt mainbox indentifiers, the above code would print the messages of the last one. Without single, it would print the messages of all of them.

unique :: a -> TransIO ()

run an unique continuation for each connection. The first thread that execute unique is executed for that connection. The rest are ignored.

wormhole :: Loggable a => Node -> Cloud a -> Cloud a

A wormhole opens a connection with another node anywhere in a computation. teleport uses this connection to translate the computation back and forth between the two nodes connected

type JSString = String

connect to the caller node. connectCaller :: Loggable a => Cloud a -> Cloud a connectCaller (Cloud comp)= local $ do conn getState ! CONNECTCALLER case connData conn of Nothing -> empty Just Self -> empty _ -> if not $ calling conn !> ("calling", calling conn) then comp else do ParentConnection conn mmclosure getState <| error "connectCaller: No connection defined: use wormhole" moldconn <- getData :: TransIO (Maybe Connection) mclosure <- getData :: TransIO (Maybe Closure)

pack :: a -> a

data CloudException

Constructors

CloudException Node IdClosure String

Instances

Read CloudException

Methods

readsPrec :: Int -> ReadS CloudException

readList :: ReadS [CloudException]

readPrec :: ReadPrec CloudException

readListPrec :: ReadPrec [CloudException]

Show CloudException

Methods

showsPrec :: Int -> CloudException -> ShowS

show :: CloudException -> String

showList :: [CloudException] -> ShowS

Exception CloudException

Methods

toException :: CloudException -> SomeException

fromException :: SomeException -> Maybe CloudException

displayException :: CloudException -> String

teleport :: Cloud ()

reportBack :: TransIO ()

forward exceptions to the calling node

copyData :: (Typeable * b, Read b, Show b) => b -> Cloud b

copy a session data variable from the local to the remote node. If there is none set in the local node, The parameter is the default value. In this case, the default value is also set in the local node.

putMailbox :: Typeable val => val -> TransIO ()

write to the mailbox Mailboxes are node-wide, for all processes that share the same connection data, that is, are under the same listen or connect while EVars are only visible by the process that initialized it and his children. Internally, the mailbox is in a well known EVar stored by listen in the Connection state.

putMailbox' :: (Typeable key, Ord key, Typeable val) => key -> val -> TransIO ()

write to a mailbox identified by an identifier besides the type

newMailbox :: MailboxId -> TransIO ()

errorMailBox :: a

getMailbox :: Typeable val => TransIO val

get messages from the mailbox that matches with the type expected. The order of reading is defined by readTChan This is reactive. it means that each new message trigger the execution of the continuation each message wake up all the getMailbox computations waiting for it.

getMailbox' :: (Typeable key, Ord key, Typeable val) => key -> TransIO val

read from a mailbox identified by an identifier besides the type

cleanMailbox :: Typeable a => a -> TransIO ()

delete all subscriptions for that mailbox expecting this kind of data

cleanMailbox' :: Typeable a => Int -> a -> TransIO ()

clean a mailbox identified by an Int and the type

clustered :: Loggable a => Cloud a -> Cloud a

execute a Transient action in each of the nodes connected.

The response of each node is received by the invoking node and processed by the rest of the procedure. By default, each response is processed in a new thread. To restrict the number of threads use the thread control primitives.

this snippet receive a message from each of the simulated nodes:

main = keep $ do
   let nodes= map createLocalNode [2000..2005]
   addNodes nodes
   (foldl (<|>) empty $ map listen nodes) <|> return ()

   r <- clustered $ do
              Connection (Just(PortNumber port, _, _, _)) _ <- getSData
              return $ "hi from " ++ show port++ "\n"
   liftIO $ putStrLn r
   where
   createLocalNode n= createNode "localhost" (PortNumber n)

mclustered :: (Monoid a, Loggable a) => Cloud a -> Cloud a

callNodes :: (Show a2, Show a1, Read a2, Read a1, Typeable * a2, Typeable * a1) => (Cloud a2 -> Cloud a1 -> Cloud a1) -> Cloud a1 -> Cloud a2 -> Cloud a1

callNodes' :: (Typeable * a2, Typeable * a1, Read a2, Read a1, Show a2, Show a1) => [Node] -> (Cloud a2 -> Cloud a1 -> Cloud a1) -> Cloud a1 -> Cloud a2 -> Cloud a1

sendRaw :: MonadIO m => Connection -> ByteString -> m ()

type LengthFulLog = Int

data NodeMSG

Constructors

ClosureData IdClosure IdClosure CurrentPointer

RelayMSG Node Node (StreamData NodeMSG)

Instances

Read NodeMSG

Methods

readsPrec :: Int -> ReadS NodeMSG

readList :: ReadS [NodeMSG]

readPrec :: ReadPrec NodeMSG

readListPrec :: ReadPrec [NodeMSG]

Show NodeMSG

Methods

showsPrec :: Int -> NodeMSG -> ShowS

show :: NodeMSG -> String

showList :: [NodeMSG] -> ShowS

msend :: Connection -> StreamData NodeMSG -> TransIO ()

mread :: Loggable a => Connection -> TransIO (StreamData a)

parallelReadHandler :: Loggable a => TransIO (StreamData a)

getWebServerNode :: TransIO Node

mclose :: Connection -> IO ()

mconnect :: Node -> TransIO Connection

data ConnectionError

Constructors

ConnectionError String Node

Instances

Show ConnectionError

Methods

showsPrec :: Int -> ConnectionError -> ShowS

show :: ConnectionError -> String

showList :: [ConnectionError] -> ShowS

Exception ConnectionError

Methods

toException :: ConnectionError -> SomeException

fromException :: SomeException -> Maybe ConnectionError

displayException :: ConnectionError -> String

connectTo' :: Int -> HostName -> PortID -> IO Socket

type Blocked = MVar ()

type BuffSize = Int

data ConnectionData

Constructors

Node2Node

Fields

• port :: PortID
• socket :: Socket
• sockAddr :: SockAddr

TLSNode2Node

Fields

• tlscontext :: SData

Node2Web

Fields

• webSocket :: Connection

Self

Relay Connection Node

data MailboxId

Constructors

(Typeable a, Ord a) => MailboxId a TypeRep

Instances

Eq MailboxId

Methods

(==) :: MailboxId -> MailboxId -> Bool

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

Ord MailboxId

Methods

compare :: MailboxId -> MailboxId -> Ordering

(<) :: MailboxId -> MailboxId -> Bool

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

(>) :: MailboxId -> MailboxId -> Bool

(>=) :: MailboxId -> MailboxId -> Bool

max :: MailboxId -> MailboxId -> MailboxId

min :: MailboxId -> MailboxId -> MailboxId

data Connection

Constructors

Connection

Fields

• idConn :: Int
• myNode :: IORef Node
• remoteNode :: IORef (Maybe Node)
• connData :: Maybe ConnectionData
• bufferSize :: BuffSize
• comEvent :: IORef (Map MailboxId (EVar SData))
• blocked :: Blocked
• calling :: Bool
• localClosures :: MVar (Map IdClosure EventF)
• closChildren :: IORef (Map Int EventF)

defConnection :: (MonadIO m, MonadState EventF m) => m Connection

setBuffSize :: Int -> TransIO ()

getBuffSize :: TransIO BuffSize

listen :: Node -> Cloud ()

Setup the node to start listening for incoming connections.

relay :: StreamData NodeMSG -> TransIO ()

nat :: Node -> Node -> Node -> [Node] -> (Node, Node)

listenNew :: PortNumber -> Connection -> TransIO (StreamData NodeMSG)

rsetHost :: IORef Bool

listenResponses :: Loggable a => TransIO (StreamData a)

type IdClosure = Int

newtype Closure

Constructors

Closure IdClosure

type RemoteClosure = (Node, IdClosure)

newtype JobGroup

Constructors

JobGroup (Map String RemoteClosure)

stopRemoteJob :: String -> Cloud ()

if there is a remote job identified by th string identifier, it stop that job, and set the current remote operation (if any) as the current remote job for this identifier. The purpose is to have a single remote job. to identify the remote job, it should be used after the wormhole and before the remote call:

r <- wormhole node $ do stopRemoteJob "streamlog" atRemote myRemotejob

So:

runAtUnique ident node job= wormhole node $ do stopRemoteJob ident; aRemote job

resetRemote :: Cloud ()

manageClosures :: Cloud ()

delete closures in a remote node when is requested by resetRemote or stopRemoteJob. This is necessary because a remote closure can be reactive or may take a long time.

It should be located as an alternative computation to the program:

 main= initNode $ inputNodes <|> manageClosures <|>  myCloudCode

execLog :: StreamData NodeMSG -> TransIO ()

type Pool = [Connection]

type Package = String

type Program = String

type Service = [(Package, Program)]

readFrom :: Connection -> IO ByteString

toStrict :: ByteString -> ByteString

makeWSStreamFromConn :: Connection -> IO Stream

makeWebsocketConnection :: MonadIO m => Connection -> ByteString -> Headers -> m Connection

servePages :: (a, ByteString, [(CI ByteString, b)]) -> TransIO ()

api :: TransIO ByteString -> Cloud ()

isWebSocketsReq :: [(CI ByteString, b)] -> Bool

data HTTPMethod

Constructors

GET

POST

Instances

Read HTTPMethod

Methods

readsPrec :: Int -> ReadS HTTPMethod

readList :: ReadS [HTTPMethod]

readPrec :: ReadPrec HTTPMethod

readListPrec :: ReadPrec [HTTPMethod]

Show HTTPMethod

Methods

showsPrec :: Int -> HTTPMethod -> ShowS

show :: HTTPMethod -> String

showList :: [HTTPMethod] -> ShowS

getFirstLine :: TransIO (ByteString, ByteString, ByteString)

getRawHeaders :: TransIO ByteString

type PostParams = [(ByteString, String)]

parsePostUrlEncoded :: TransIO PostParams

getHeaders :: TransIO [(CI ByteString, ByteString)]

isBrowserInstance :: Bool

Returns True if we are running in the browser.

emptyPool :: MonadIO m => m (MVar Pool)

createNodeServ :: HostName -> Int -> Service -> IO Node

Create a node from a hostname (or IP address), port number and a list of services.

createNode :: HostName -> Int -> IO Node

createWebNode :: IO Node

nodeList :: TVar [Node]

errorMyNode :: [Char] -> a

getMyNode :: TransIO Node

Return the local node i.e. the node where this computation is running.

getNodes :: MonadIO m => m [Node]

Return the list of nodes in the cluster.

getEqualNodes :: TransIO [Node]

matchNodes :: MonadIO m => ((Package, Program) -> Bool) -> m [[(Package, Program)]]

addNodes :: [Node] -> TransIO ()

Add a list of nodes to the list of existing cluster nodes.

fixNode :: MonadIO m => Node -> m Node

setNodes :: MonadIO m => [Node] -> m ()

set the list of nodes

shuffleNodes :: MonadIO m => m [Node]

Shuffle the list of cluster nodes and return the shuffled list.

connect :: Node -> Node -> Cloud ()

Add a node (first parameter) to the cluster using a node that is already part of the cluster (second parameter). The added node starts listening for incoming connections and the rest of the computation is executed on this newly added node.

connect' :: Node -> Cloud ()

Reconcile the list of nodes in the cluster using a remote node already part of the cluster. Reconciliation end up in each node in the cluster having the same list of nodes.

Orphan instances

Ord PortID

Methods

compare :: PortID -> PortID -> Ordering

(<) :: PortID -> PortID -> Bool

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

(>) :: PortID -> PortID -> Bool

(>=) :: PortID -> PortID -> Bool

max :: PortID -> PortID -> PortID

min :: PortID -> PortID -> PortID