Control.Distributed.Backend.P2P

Peer-to-peer node discovery backend for Cloud Haskell based on the TCP transport. Provided with a known node address it discovers and maintains the knowledge of it's peers.

import qualified Control.Distributed.Backend.P2P as P2P
import           Control.Monad.Trans (liftIO)
import           Control.Concurrent (threadDelay)

main = P2P.bootstrap "myhostname" "9001" [P2P.makeNodeId "seedhost:9000"] $ do
    liftIO $ threadDelay 1000000 -- give dispatcher a second to discover other nodes
    P2P.nsendPeers "myService" ("some", "message")

Starting peer controller

bootstrap :: HostName -> ServiceName -> (ServiceName -> (HostName, ServiceName)) -> RemoteTable -> [NodeId] -> Process () -> IO ()

Start a controller service process and aquire connections to a swarm.

bootstrapNonBlocking :: HostName -> ServiceName -> (ServiceName -> (HostName, ServiceName)) -> RemoteTable -> [NodeId] -> Process () -> IO (LocalNode, ProcessId)

Like bootstrap but use forkProcess instead of runProcess. Returns local node and pid of given process

peerController :: [NodeId] -> Process ()

A P2P controller service process.

Nodes manipulation

makeNodeId :: String -> NodeId

Make a NodeId from "host:port" string.

getPeers :: Process [NodeId]

Get a list of currently available peer nodes.

getCapable :: String -> Process [ProcessId]

Poll a network for a list of specific service providers.

nsendPeers :: Serializable a => String -> a -> Process ()

Broadcast a message to a specific service on all peers.

nsendCapable :: Serializable a => String -> a -> Process ()

Broadcast a message to a service of on nodes currently running it.

Auxiliary

createLocalNode :: HostName -> ServiceName -> (ServiceName -> (HostName, ServiceName)) -> RemoteTable -> IO LocalNode

Creates tcp local node which used by bootstrap

waitController :: Process a -> Process a

Waits for controller to start, then runs given process