| Copyright | (c) Phil Hargett 2015 |
|---|---|
| License | MIT (see LICENSE file) |
| Maintainer | phil@haphazardhouse.net |
| Stability | experimental |
| Portability | non-portable (uses STM) |
| Safe Haskell | None |
| Language | Haskell98 |
Network.RPC.Typed
Description
Synopsis
- call :: (Serialize a, Serialize b) => CallSite -> Name -> Method -> a -> IO b
- callWithTimeout :: (Serialize a, Serialize r) => CallSite -> Name -> Method -> Int -> a -> IO (Maybe r)
- gcallWithTimeout :: (Serialize a, Serialize r) => CallSite -> [Name] -> Method -> Int -> a -> IO (Map Name (Maybe r))
- hear :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> IO (a, Reply r)
- hearTimeout :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> Int -> IO (Maybe (a, Reply r))
- handle :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> (a -> IO r) -> IO HandleSite
- typedMethodSelector :: Serialize a => Method -> Message -> Maybe (Name, RequestId, a)
- data HandleSite = HandleSite Name (Async ())
- type Reply b = b -> IO ()
- data CallSite
- data Response = Response {}
- data Request = Request {}
- data RequestId
- type Method = String
- mkRequestId :: IO RequestId
- newCallSite :: Endpoint -> Name -> CallSite
- gcall :: CallSite -> [Name] -> Method -> Message -> IO (Map Name Message)
- anyCall :: CallSite -> [Name] -> Method -> Message -> IO (Message, Name)
- methodSelector :: Method -> Message -> Maybe (Name, RequestId, Message)
- hearAll :: Endpoint -> Name -> IO (Method, Message, Reply Message)
- hearAllTimeout :: Endpoint -> Name -> Int -> IO (Maybe (Method, Message, Reply Message))
- handleAll :: Endpoint -> Name -> (Method -> Message -> IO Message) -> IO HandleSite
- hangup :: HandleSite -> IO ()
Documentation
call :: (Serialize a, Serialize b) => CallSite -> Name -> Method -> a -> IO b #
Call a method with the provided arguments on the recipient with the given name.
The caller will wait until a matching response is received.
callWithTimeout :: (Serialize a, Serialize r) => CallSite -> Name -> Method -> Int -> a -> IO (Maybe r) #
Call a method with the provided arguments on the recipient with the given name.
A request will be made through the CallSite's Endpoint, and then
the caller will wait until a matching response is received. If a response
is received within the provided timeout (measured in microseconds), then
return the value wrapped in Just; otherwise, if the timeout expires
before the call returns, then return 'Nothing.
gcallWithTimeout :: (Serialize a, Serialize r) => CallSite -> [Name] -> Method -> Int -> a -> IO (Map Name (Maybe r)) #
Group call or RPC but with a timeout: call a method with the provided arguments on all the
recipients with the given names. A request will be made through the CallSite's Endpoint,
and then the caller will wait until all matching responses are received or the timeout occurs.
The returned Map has a key for every Name that was a target of the call, and the value
of that key will be Nothing if no response was received before the timeout, or Just value
if a response was received.
hear :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> IO (a, Reply r) #
Wait for a single incoming request to invoke the indicated Method on the specified
Endpoint. Return both the method arguments and a Reply function useful for sending
the reply. A good pattern for using hear will pattern match the result to a tuple of
the form (args,reply), then use the args as needed to compute a result, and then
finally send the result back to the client by simply passing the result to reply: reply result.
The invoker of hear must supply the Name they have bound to the Endpoint, as this
helps the original requestor of the RPC differentiate responses when the RPC was a group
call.
hearTimeout :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> Int -> IO (Maybe (a, Reply r)) #
handle :: (Serialize a, Serialize r) => Endpoint -> Name -> Method -> (a -> IO r) -> IO HandleSite #
Handle all RPCs to invoke the indicated Method on the specified Endpoint,
until hangup is called on the returned HandleSite.
typedMethodSelector :: Serialize a => Method -> Message -> Maybe (Name, RequestId, a) #
A method selector that only matches if the message deserializes into a type that matches arguments to a call.
data HandleSite #
A HandleSite is a just reference to the actual handler of a specific method.
Mostly for invoking hangup on the handler, once it is no longer needed.
Constructors
| HandleSite Name (Async ()) |
A Reply is a one-shot function for sending a response to an incoming request.
A call site is a location for making RPCs: it includes an endpoint and a name by which recipients can return the call
Encapsulates the completion side of a call: every invocation of call produces a Request that is sent
to the destination Endpoint, where the hearing side will generate a Response after completing the request'
Constructors
| Response | |
Fields
| |
Encapsulates the initiating side of a call: every invocation of call produces a Request that is sent
to the destination Endpoint, where the hearing side will generate a Response after completing the request'
Constructors
| Request | |
Fields
| |
A unique identifier for a Request
mkRequestId :: IO RequestId #
Create a new identifier for Requests
newCallSite :: Endpoint -> Name -> CallSite #
gcall :: CallSite -> [Name] -> Method -> Message -> IO (Map Name Message) #
Group call or RPC: call a method with the provided arguments on all the recipients with the given names.
A request will be made through the CallSite's Endpoint, and then
the caller will wait until all matching responses are received.
methodSelector :: Method -> Message -> Maybe (Name, RequestId, Message) #
A simple function that, given a Method, returns a filter suitable for
use with selectMessage. The typical use case will involve partial
application: methodSelector method passed as an argument to selectMessage.
hearAllTimeout :: Endpoint -> Name -> Int -> IO (Maybe (Method, Message, Reply Message)) #
A variant of hearTimeout, except it listens for any incoming RPC request on the specified Endpoint
handleAll :: Endpoint -> Name -> (Method -> Message -> IO Message) -> IO HandleSite #
Handle all RPCs on the specified Endpoint until hangup is called on the returned HandleSite
hangup :: HandleSite -> IO () #
Stop handling incoming RPCs for the indicated HandleSite.